final_libs = [files[x].get() for x in llvm_libs] + \ [x for (x,y) in found_libs if not y] def toLflag(path): if os.path.exists(path): return "-L%s" % path else: return None searchflags = [x for x in map(toLflag,search) if x is not None] if '-lpthread' in native_libs: native_libs.append('-Xlinker=-pthread') # Link everything together sys.stderr.write("linking...") sys.stderr.write(config.LLVM['ld']) driver.run(config.LLVM['ld'], ['-native'] + ['-o=%s' % binary] + [files[m].get() for m in modules] + final_libs + searchflags + shared + ['-Xlinker=-static'] + native_libs) sys.stderr.write("done\n") if not (POOL is None): POOL.shutdown() return 0 target.register('previrt', PrevirtTool('previrt'))
class RanlibTool (par.ParallelTool): def opts(self, args): return ({}, args) def occam(self, cfg, args): def modify(p): if p.startswith('-'): return p else: return self.fixinputname(p) args = map(modify,args) return driver.run(cfg.getStdTool('ranlib'), args) class ChmodTool (par.ParallelTool): def opts(self, args): return ({}, args) def occam(self, cfg, args): def modify(p): if p.startswith('-'): return p else: return self.fixinputname(p) args = map(modify,args) return driver.run(cfg.getStdTool('chmod'), args) target.register('strip', StripTool('strip')) target.register('ranlib', RanlibTool('ranlib')) target.register('chmod', ChmodTool('chmod'))
import sys class ShowTool (target.Target): def usage(self): return "%s <files...>" % self.name def desc(self): return '\n'.join( [" Display human-readable versions of the given files to", " standard output. The understood file formats are:", " - interface files", " - rewrite files"]) def run(self, cfg, flags, args): for p in args: print p if p == '-': data = sys.stdin.read() for f in formats.FORMATS: if f.parse_string(data): break else: print "Unknown format: stdin" else: for f in formats.FORMATS: if f.parse_file(p): break else: print "Unknown format: '%s'" % p target.register('show', ShowTool('show'))
if self.name == 'install' and args[i] in ['-B', '-f', '-g', '-m', '-o']: flags.extend(args[i:i+2]) i += 1 elif args[i].startswith('-'): flags.append(args[i]) else: nargs.append(args[i]) i += 1 cmdline = flags def fixarg(arg): return self.fixinputname(arg,keep=False,create=self.name not in ['unlink','rm']) inputs = filter(None,map(fixarg,nargs[0:len(nargs)-1])) if not inputs: return 0 last = nargs[len(nargs)-1] if len(nargs) > 1 and os.path.isdir(last) and self.name not in ['unlink', 'rm']: output = last else: output = self.fixname(last) cmdline = flags + inputs + [output] if self.name == 'ln' and os.path.exists(output): return 0 return driver.run(cfg.getStdTool(self.name), cmdline) target.register('cp', CpTool('cp')) target.register('mv', CpTool('mv')) target.register('ln', CpTool('cp')) target.register('install', CpTool('install')) target.register('unlink', CpTool('unlink')) target.register('rm', CpTool('rm'))
import getopt class PartialEvalTool (target.Target): def opts(self, args): return getopt.getopt(args, 'o:', ['--log=']) def usage(self): return "%s -o <output.bc> [--log <log-file>] <input.bc>" % self.name def desc(self): return '\n'.join( [" partial evaluation of input.bc writing the resulting code", " to output.bc."]) def args(self): return [('-o', "the output file")] def run(self, cfg, flags, args): if len(args) < 1: raise ArgError() input_file = args[0] output_file = target.flag(flags, '-o') log_file = target.flag(flags, '--log') if log_file is not None: log_file = open(log_file, 'w+') return passes.peval(input_file, output_file, log=log_file) target.register('peval', PartialEvalTool('peval'))
if len(input_files) == 0: return 0 elif '-Wl,--help' in flags: # this is just help return 0 elif '-Wl,-shared' in flags: # LLVM doesn't do shared... return 0 elif '-Wl,-r' in flags or '-Wl,-i' in flags or '-Wl,--relocatable' in flags: # this is essentially linking as a library if output_file is None: output_file = ld_default_o(input_files[0]) retcode = toolchain.bundle(self.fixname(output_file), map(self.fixinputname,input_files), [x for x in flags if x.startswith('-l')], [x[2:] for x in flags if x.startswith('-L')]) return retcode else: if output_file is None: output_file = ld_default_o(input_files[0]) retcode = toolchain.link(map(self.fixinputname,input_files), self.fixname(output_file), flags + ['-lc'], save='%s_main.bc' % output_file, link=True) return retcode for x in ['ld']: target.register(x, LdTool(x))
from occam import toolchain, driver, passes import getopt class ArgsTool (target.Target): def opts(self, args): return getopt.getopt(args, 'o:', ['name=']) def usage(self): return "%s -o <output.bc> [--name <program-name>] <input.bc>" % self.name def desc(self): return '\n'.join( [" partial evaluation of input.bc writing the resulting code", " to output.bc."]) def args(self): return [('-o', "the output file"), ('--name', "the name of the program")] def run(self, cfg, flags, args): if len(args) < 1: raise ArgError() input_file = args[0] args = args[1:] output_file = target.flag(flags, '-o') name = target.flag(flags, '--name') return passes.specialize_program_args(input_file, output_file, args, name=name) target.register('args', ArgsTool('args'))
if not '--ignore' in map(lambda x: x[0], flags): inputs = get_default(manifest, 'modules', []) + inputs libs = get_default(manifest, 'libs', []) native_libs = get_default(manifest, 'native-libs', []) if '-lpthread' in native_libs: native_libs.append('-Xlinker=-pthread') search = get_default(manifest, 'search', []) def toLflag(path): if os.path.exists(path): return "-L%s" % path else: return None searchflags = [x for x in map(toLflag,search) if x is not None] shared = get_default(manifest, 'shared', []) try: found_libs = [get_library(x,search) for x in libs] except NotFound,e: logging.getLogger().error("ERROR: The library '%s' could not be found. Search path:" % e.__str__()) logging.getLogger().error('\n'.join(search)) return 1 args = ['-native', '-o=%s' % output] + inputs + found_libs + searchflags + shared + ['-Xlinker=-static'] + native_libs for (a,b) in flags: if a == '-O': args += ['-O%s' % b] return driver.run(config.LLVM['ld'], args) target.register('build', BuildTool('build'))
from occam import target import getopt # TODO class PackTool (target.Target): def opts(self, args): return getopt.getopt(args, 'o:', []) def usage(self): return "%s -o <output.bc> <input.bc.a> <main.bc>+" % self.name def desc(self): return '\n'.join( [" bundle up an archive given the modules it will link with"]) def run(self, cfg, flags, args): if len(args) == 0: raise target.ArgError() input_file = args[0] if len(args) == 1: ifaces = None else: ifaces = args[1:] output_file = target.flag(flags, '-o') return toolchain.archive_to_module(input_file, output_file, minimal=ifaces) target.register('pack', PackTool('pack'))
class WatchTool(target.Target): def opts(self, args): return getopt.getopt(args, 'o:', []) def usage(self): return "%s -o <output.bc> <input.bc> <watch.watch>+" % self.name def desc(self): return """ Watch the given module with the given watch specifications.""" def args(self): return [] def run(self, cfg, flags, args): if len(args) < 2: raise ArgError() input_file = args[0] interfaces = args[1:] output_file = target.flag(flags, '-o') if output_file is None: raise ArgError() return driver.previrt(input_file, output_file, ['-Pwatch2'] + driver.all_args('-Pwatch2-input', interfaces)) target.register('watch', WatchTool('watch'))
class ShowTool(target.Target): def usage(self): return "%s <files...>" % self.name def desc(self): return '\n'.join([ " Display human-readable versions of the given files to", " standard output. The understood file formats are:", " - interface files", " - rewrite files" ]) def run(self, cfg, flags, args): for p in args: print p if p == '-': data = sys.stdin.read() for f in formats.FORMATS: if f.parse_string(data): break else: print "Unknown format: stdin" else: for f in formats.FORMATS: if f.parse_file(p): break else: print "Unknown format: '%s'" % p target.register('show', ShowTool('show'))
# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, # OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. # ------------------------------------------------------------------------------ from occam import target import sys class HelpTool(target.Target): def opts(self, args): return ({}, args) def usage(self): return "%s target+" % self.name def desc(self): return """ Get help on a target.""" def run(self, cfg, flags, args): if len(args) == 0: target.usage() else: for x in args: target.TOOLS[x].help() return 0 target.register('help', HelpTool('help'))
try: retcode = toolchain.link(map(self.fixname,o_files) + map(self.fixinputname,toLink), self.fixname(output_file), flags + stdlibs, link=True, save='%s_mani' % output_file) except driver.ReturnCode,ex: logging.getLogger().warn("WARNING: manifest link failed for %s" % output_file) logging.getLogger().warn("%s" % ex) retcode = 0 map(os.unlink,o_files) else: if output_file is None: output_file = 'a.out' try: retcode = toolchain.link(map(self.fixinputname,input_files), self.fixname(output_file), flags + stdlibs, save='%s_main.bc' % output_file, link=True) except driver.ReturnCode,ex: logging.getLogger().warn("WARNING: manifest link failed for %s" % output_file) logging.getLogger().warn("%s" % ex) retcode = 0 return retcode for x in ['clang', 'clang++', 'clang-cpp']: target.register(x, ClangTool(x))
def args(self): return [('--in', "place checks inside the function"), ('--out', "place checks at function calls"), ('-o', "the output file")] def run(self, cfg, flags, args): input_file = args[0] interfaces = args[1:] output_file = target.flag(flags, 'o') if output_file is None: raise ArgError() inF = ('--in', '') in flags outF = ('--out', '') in flags if inF and outF: raise ArgError() elif inF: tool = '-Penforce-inside' elif outF: tool = '-Penforce-outside' else: raise ArgError() return driver.previrt(input_file, output_file, [tool] + driver.all_args('%s-input' % tool, interfaces)) target.register('enforce', EnforceTool('enforce'))
# and/or other materials provided with the distribution. # # * Neither the name of SRI International nor the names of its contributors may # be used to endorse or promote products derived from this software without # specific prior written permission. # # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" # AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE # IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE # DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE # FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL # DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR # SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER # CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, # OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. # ------------------------------------------------------------------------------ from occam import toolchain from occam import target from occam.targets import par import os, shutil class AsTool (par.ParallelTool): def occam(self, cfg, args): return toolchain.archive(args[0], map(self.fixname, args[2:]), self.fixname(args[1])) target.register('as', AsTool('as'))
if args[0] == 'hook' or args[0] == 'watch': result = None for x in args[1:]: if result is None: result = watchparse.parse(readFile(x)) else: watchparse.parseInto(result, readFile(x)) if not (result is None): sys.stdout.write(result.SerializeToString()) return 0 elif args[0] == 'hook2' or args[0] == 'watch2': result = None for x in args[1:]: if result is None: result = watchparse2.parse(readFile(x)) else: watchparse.parseInto(result, readFile(x)) if not (result is None): sys.stdout.write(result.SerializeToString()) return 0 elif args[0] == 'iface': assert False elif args[0] == 'rw': assert False else: self.help() return -1 target.register('parse', ReadTool('parse'))
#removed these in the apache build. are they ever needed? xlinker_start = [''] xlinker_end = [''] #xlinker_start = ['-Wl,-static'] #xlinker_end = ['-Wl,-call_shared'] #iam: these two flags are not for Darwin. if platform.system() == 'Darwin': xlinker_start = [''] xlinker_end = [''] if '-lpthread' in native_libs: shared.append('-pthread') # Link everything together sys.stderr.write("linking...\n") if binary.endswith('.bc'): binary = binary[:-3] toolchain.llvmLDWrapper(binary, [files[m].get() for m in modules], final_libs, searchflags, shared, xlinker_start, native_libs, xlinker_end, []) sys.stderr.write("done\n") if not (POOL is None): POOL.shutdown() return 0 target.register('previrt', PrevirtTool('previrt'))
# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER # CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, # OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. # ------------------------------------------------------------------------------ from occam import formats from occam import target import sys class ArLinkTool (target.Target): def usage(self): return "%s -o <output.bc> <file.bc.a>" % self.name def desc(self): return '\n'.join( [" Gather only the files necessary for linking and build a single", " module for them. This is useful/necessary to remove dead assembly", " from libc"]) def opts(self, args): return getopt.getopt(args, 'o:', []) def run(self, cfg, flags, args): output = target.flag(flags, '-o', None) if (output is None) or len(args) != 2: raise target.ArgError('o') archive_to_module(args[0], output, minimal=None) return 0 target.register('arlink', ArLinkTool('arlink'))
# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE # FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL # DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR # SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER # CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, # OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. # ------------------------------------------------------------------------------ from occam import target import sys class HelpTool (target.Target): def opts(self, args): return ({}, args) def usage(self): return "%s target+" % self.name def desc(self): return """ Get help on a target.""" def run(self, cfg, flags, args): if len(args) == 0: target.usage() else: for x in args: target.TOOLS[x].help() return 0 target.register('help', HelpTool('help'))
from occam import formats from occam import target import sys class ArLinkTool(target.Target): def usage(self): return "%s -o <output.bc> <file.bc.a>" % self.name def desc(self): return '\n'.join([ " Gather only the files necessary for linking and build a single", " module for them. This is useful/necessary to remove dead assembly", " from libc" ]) def opts(self, args): return getopt.getopt(args, 'o:', []) def run(self, cfg, flags, args): output = target.flag(flags, '-o', None) if (output is None) or len(args) != 2: raise target.ArgError('o') archive_to_module(args[0], output, minimal=None) return 0 target.register('arlink', ArLinkTool('arlink'))
# * Neither the name of SRI International nor the names of its contributors may # be used to endorse or promote products derived from this software without # specific prior written permission. # # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" # AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE # IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE # DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE # FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL # DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR # SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER # CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, # OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. # ------------------------------------------------------------------------------ from occam import toolchain from occam import target from occam.targets import par class ArTool (par.ParallelTool): def opts(self, args): return ([], args) def occam(self, cfg, args): return toolchain.archive(args[0], map(self.fixname, args[2:]), self.fixname(args[1])) target.register('ar', ArTool('ar'))
# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, # OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. # ------------------------------------------------------------------------------ from occam import target import sys def readFile(fn): if fn == '-': return sys.stdin.read() else: return open(fn, 'r').read() class RunTool (target.Target): def usage(self): return "%s args+" % self.name def desc(self): return """ Run the command in the occam environment.""" def run(self, cfg, flags, args): if len(args) < 1: raise target.ArgError() # TODO : need to handle this... assert False # not implemented target.register('run', RunTool('run'))
import getopt class WatchTool (target.Target): def opts(self, args): return getopt.getopt(args, 'o:', []) def usage(self): return "%s -o <output.bc> <input.bc> <watch.watch>+" % self.name def desc(self): return """ Watch the given module with the given watch specifications.""" def args(self): return [] def run(self, cfg, flags, args): if len(args) < 2: raise ArgError() input_file = args[0] interfaces = args[1:] output_file = target.flag(flags, '-o') if output_file is None: raise ArgError() return driver.previrt(input_file, output_file, ['-Pwatch2'] + driver.all_args('-Pwatch2-input', interfaces)) target.register('watch', WatchTool('watch'))
def desc(self): return "\n".join( [ " simplify input.bc with respect to the given interfaces.", " generates a simplified module (output.bc) and a rewrite", " specification for taking programs with the old specification", " and rewriting them for the new specification.", ] ) def args(self): return [ ("--in", "place checks inside the function"), ("--out", "place checks at function calls"), ("-o", "the output file"), ] def run(self, cfg, flags, args): if len(args) < 2: raise ArgError() input_file = args[0] interfaces = args[1:] output_file = target.flag(flags, "-o") rw_file = target.flag(flags, "--rw") return passes.specialize(input_file, output_file, rw_file, interfaces) target.register("specialize", SpecializeTool("specialize"))
def run(self, cfg, flags, args): output = target.flag(flags, "-o", "-") if ("--join", "") in flags: if len(args) < 1: raise target.ArgError() ifs = [parse(x) for x in args] result = ifs[0] for x in ifs[1:]: interface.joinInterfaces(result, x) else: # This is computing the interface if len(args) < 1: raise target.ArgError() if args[0] == "@*": iface = None else: iface = parse(args[0]) libs = args[1:] if "--deep" in flags: result = deep(libs, iface) else: result = shallow(libs, iface) interface.writeInterface(result, output) return 0 target.register("interface", InterfaceTool("interface"))
from occam.target import ArgError from occam import target from occam import toolchain, driver, passes import getopt class RewriteTool (target.Target): def opts(self, args): return getopt.getopt(args, 'o:', []) def usage(self): return "%s -o <output.bc> <input.bc> <rewrite.rw>+" % self.name def desc(self): return '\n'.join( [" rewrite input.bc based on the given set of rewrites."]) def args(self): return [('-o', "the output file")] def run(self, cfg, flags, args): if len(args) < 2: raise ArgError() input_file = args[0] rewrites = args[1:] output_file = target.flag(flags, '-o') passes.rewrite(input_file, output_file, rewrites) return 0 target.register('rewrite', RewriteTool('rewrite'))
import getopt # TODO class SliceTool (target.Target): def opts(self, args): return getopt.getopt(args, 'o:', []) def usage(self): return "%s -o <output.bc> <input.bc> <interface.iface>+" % self.name def desc(self): return '\n'.join( [" remove all functionality not necessary to implement the given", " interfaces."]) def run(self, cfg, flags, args): if len(args) < 2: raise target.ArgError() input_file = args[0] ifaces = args[1:] output_file = target.flag(flags, '-o') return driver.previrt(input_file, output_file, ['-Poccam'] + driver.all_args('-Poccam-input', ifaces)) target.register('slice', SliceTool('slice'))
return (flags,nargs) def remove_dups(args): return [x for (x,i) in zip(args, range(0, len(args))) if args.index(x) == i] class InstallTool (par.ParallelTool): def occam(self, cfg, args): def modify(p): if p.startswith('-'): return p if os.path.isdir(p): return p if os.path.exists(self.fixinputname(p)): return self.fixinputname(p) return None (flags,nargs) = parse_args(args, ['-m', '-o', '-g'], modify) nargs = remove_dups(nargs) if len(nargs) == 0: return 0 elif len(nargs) == 1: if os.path.isdir(args[-1]): return 0 else: nargs += [self.fixinputname(args[-1])] return driver.run(cfg.getStdTool('install'), flags + nargs) target.register('install', InstallTool('install'))
return """ Enforce all of the given interfaces on input.bc.""" def args(self): return [('--in', "place checks inside the function"), ('--out', "place checks at function calls"), ('-o', "the output file")] def run(self, cfg, flags, args): input_file = args[0] interfaces = args[1:] output_file = target.flag(flags, 'o') if output_file is None: raise ArgError() inF = ('--in', '') in flags outF = ('--out', '') in flags if inF and outF: raise ArgError() elif inF: tool = '-Penforce-inside' elif outF: tool = '-Penforce-outside' else: raise ArgError() return driver.previrt(input_file, output_file, [tool] + driver.all_args('%s-input' % tool, interfaces)) target.register('enforce', EnforceTool('enforce'))