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'))
