2011-07-08 09:53:47 +04:00
|
|
|
#!/usr/bin/python
|
2010-09-10 07:03:24 +04:00
|
|
|
|
2011-07-07 11:38:35 +04:00
|
|
|
import json
|
2011-07-13 23:30:29 +04:00
|
|
|
import optparse
|
2011-07-07 11:38:35 +04:00
|
|
|
import os
|
|
|
|
import subprocess
|
|
|
|
import sys
|
|
|
|
import tempfile
|
2011-07-13 23:30:29 +04:00
|
|
|
from tools import shared
|
2010-09-10 07:03:24 +04:00
|
|
|
|
2011-01-15 09:44:52 +03:00
|
|
|
|
2011-07-09 21:14:00 +04:00
|
|
|
# Temporary files that should be deleted once the program is finished.
|
2011-07-08 08:10:13 +04:00
|
|
|
TEMP_FILES_TO_CLEAN = []
|
2011-07-09 21:14:00 +04:00
|
|
|
# The data layout used by llvm-gcc (as opposed to clang, which doesn't have the
|
|
|
|
# f128:128:128 part).
|
2011-07-08 09:33:45 +04:00
|
|
|
GCC_DATA_LAYOUT = ('target datalayout = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16'
|
|
|
|
'-i32:32:32-i64:32:64-f32:32:32-f64:32:64-v64:64:64'
|
|
|
|
'-v128:128:128-a0:0:64-f80:32:32-f128:128:128-n8:16:32"')
|
2010-09-13 02:11:43 +04:00
|
|
|
|
2010-09-10 07:03:24 +04:00
|
|
|
|
2011-07-07 11:38:35 +04:00
|
|
|
def path_from_root(*target):
|
|
|
|
"""Returns the absolute path to the target from the emscripten root."""
|
|
|
|
abspath = os.path.abspath(os.path.dirname(__file__))
|
|
|
|
return os.path.join(os.path.sep, *(abspath.split(os.sep) + list(target)))
|
|
|
|
|
|
|
|
|
|
|
|
def get_temp_file(suffix):
|
|
|
|
"""Returns a named temp file with the given prefix."""
|
2011-07-08 08:10:13 +04:00
|
|
|
named_file = tempfile.NamedTemporaryFile(
|
2011-07-07 11:38:35 +04:00
|
|
|
dir=shared.TEMP_DIR, suffix=suffix, delete=False)
|
2011-07-08 08:10:13 +04:00
|
|
|
TEMP_FILES_TO_CLEAN.append(named_file.name)
|
|
|
|
return named_file
|
2011-07-07 11:38:35 +04:00
|
|
|
|
|
|
|
|
|
|
|
def assemble(filepath):
|
|
|
|
"""Converts human-readable LLVM assembly to binary LLVM bitcode.
|
|
|
|
|
|
|
|
Args:
|
|
|
|
filepath: The path to the file to assemble. If the name ends with ".bc", the
|
|
|
|
file is assumed to be in bitcode format already.
|
|
|
|
|
|
|
|
Returns:
|
|
|
|
The path to the assembled file.
|
|
|
|
"""
|
|
|
|
if not filepath.endswith('.bc'):
|
2011-07-09 21:14:00 +04:00
|
|
|
command = [shared.LLVM_AS, '-o=-', filepath]
|
|
|
|
with get_temp_file('.bc') as out: ret = subprocess.call(command, stdout=out)
|
2011-07-07 11:38:35 +04:00
|
|
|
if ret != 0: raise RuntimeError('Could not assemble %s.' % filepath)
|
|
|
|
filepath = out.name
|
|
|
|
return filepath
|
|
|
|
|
|
|
|
|
|
|
|
def disassemble(filepath):
|
|
|
|
"""Converts binary LLVM bitcode to human-readable LLVM assembly.
|
|
|
|
|
|
|
|
Args:
|
|
|
|
filepath: The path to the file to disassemble. If the name ends with ".ll",
|
|
|
|
the file is assumed to be in human-readable assembly format already.
|
|
|
|
|
|
|
|
Returns:
|
|
|
|
The path to the disassembled file.
|
|
|
|
"""
|
|
|
|
if not filepath.endswith('.ll'):
|
|
|
|
command = [shared.LLVM_DIS, '-o=-', filepath] + shared.LLVM_DIS_OPTS
|
2011-07-09 21:14:00 +04:00
|
|
|
with get_temp_file('.ll') as out: ret = subprocess.call(command, stdout=out)
|
2011-07-07 11:38:35 +04:00
|
|
|
if ret != 0: raise RuntimeError('Could not disassemble %s.' % filepath)
|
|
|
|
filepath = out.name
|
|
|
|
return filepath
|
|
|
|
|
|
|
|
|
|
|
|
def optimize(filepath):
|
|
|
|
"""Runs LLVM's optimization passes on a given bitcode file.
|
|
|
|
|
|
|
|
Args:
|
|
|
|
filepath: The path to the bitcode file to optimize.
|
|
|
|
|
|
|
|
Returns:
|
|
|
|
The path to the optimized file.
|
|
|
|
"""
|
2011-07-09 21:14:00 +04:00
|
|
|
command = [shared.LLVM_OPT, '-o=-', filepath] + shared.pick_llvm_opts(3, True)
|
|
|
|
with get_temp_file('.bc') as out: ret = subprocess.call(command, stdout=out)
|
2011-07-07 11:38:35 +04:00
|
|
|
if ret != 0: raise RuntimeError('Could not optimize %s.' % filepath)
|
|
|
|
return out.name
|
|
|
|
|
2010-09-10 07:03:24 +04:00
|
|
|
|
2011-07-07 11:38:35 +04:00
|
|
|
def link(*objects):
|
|
|
|
"""Links multiple LLVM bitcode files into a single file.
|
|
|
|
|
|
|
|
Args:
|
|
|
|
objects: The bitcode files to link.
|
|
|
|
|
|
|
|
Returns:
|
|
|
|
The path to the linked file.
|
|
|
|
"""
|
2011-07-09 21:14:00 +04:00
|
|
|
command = [shared.LLVM_LINK] + list(objects)
|
|
|
|
with get_temp_file('.bc') as out: ret = subprocess.call(command, stdout=out)
|
2011-07-07 11:38:35 +04:00
|
|
|
if ret != 0: raise RuntimeError('Could not link %s.' % objects)
|
|
|
|
return out.name
|
|
|
|
|
|
|
|
|
2011-07-08 09:33:45 +04:00
|
|
|
def compile_malloc(compiler):
|
|
|
|
"""Compiles dlmalloc to LLVM bitcode.
|
|
|
|
|
|
|
|
Args:
|
|
|
|
compiler: The compiler command to use, a path to either clang or llvm-gcc.
|
|
|
|
|
|
|
|
Returns:
|
|
|
|
The path to the compiled dlmalloc as an LLVM bitcode (.bc) file.
|
|
|
|
"""
|
2011-07-07 11:38:35 +04:00
|
|
|
src = path_from_root('src', 'dlmalloc.c')
|
2011-07-08 09:33:45 +04:00
|
|
|
includes = '-I' + path_from_root('src', 'include')
|
|
|
|
command = [compiler, '-c', '-g', '-emit-llvm', '-m32', '-o-', includes, src]
|
2011-07-09 21:14:00 +04:00
|
|
|
with get_temp_file('.bc') as out: ret = subprocess.call(command, stdout=out)
|
2011-07-07 11:38:35 +04:00
|
|
|
if ret != 0: raise RuntimeError('Could not compile dlmalloc.')
|
|
|
|
return out.name
|
|
|
|
|
|
|
|
|
2011-07-08 09:33:45 +04:00
|
|
|
def determine_compiler(filepath):
|
|
|
|
"""Determines whether a given file uses llvm-gcc or clang data layout.
|
|
|
|
|
|
|
|
Args:
|
|
|
|
filepath: The .bc or .ll file containing the bitcode/assembly to test.
|
|
|
|
|
|
|
|
Returns:
|
|
|
|
The path to the compiler, either llvm-gcc or clang.
|
|
|
|
"""
|
|
|
|
assembly = open(disassemble(filepath)).read()
|
|
|
|
is_gcc = GCC_DATA_LAYOUT in assembly
|
|
|
|
return shared.to_cc(shared.LLVM_GCC if is_gcc else shared.CLANG)
|
|
|
|
|
|
|
|
|
2011-07-08 08:04:38 +04:00
|
|
|
def has_annotations(filepath):
|
2011-07-08 09:33:45 +04:00
|
|
|
"""Tests whether an assembly file contains annotations.
|
|
|
|
|
|
|
|
Args:
|
|
|
|
filepath: The .ll file containing the assembly to check.
|
|
|
|
|
|
|
|
Returns:
|
|
|
|
Whether the provided file is valid assembly and has annotations.
|
|
|
|
"""
|
2011-07-08 08:04:38 +04:00
|
|
|
return filepath.endswith('.ll') and '[#uses=' in open(filepath).read()
|
|
|
|
|
|
|
|
|
2011-07-07 11:38:35 +04:00
|
|
|
def emscript(infile, settings, outfile):
|
|
|
|
"""Runs the emscripten LLVM-to-JS compiler.
|
|
|
|
|
|
|
|
Args:
|
|
|
|
infile: The path to the input LLVM assembly file.
|
|
|
|
settings: JSON-formatted string of settings that overrides the values
|
|
|
|
defined in src/settings.js.
|
|
|
|
outfile: The file where the output is written.
|
|
|
|
"""
|
2011-07-30 21:26:30 +04:00
|
|
|
settings_file = get_temp_file('.txt').name # Save settings to a file to work around v8 issue 1579
|
|
|
|
s = open(settings_file, 'w')
|
|
|
|
s.write(settings)
|
|
|
|
s.close()
|
2011-07-07 11:38:35 +04:00
|
|
|
compiler = path_from_root('src', 'compiler.js')
|
2011-07-30 21:26:30 +04:00
|
|
|
shared.run_js(shared.COMPILER_ENGINE, compiler, [settings_file, infile], stdout=outfile, stderr=subprocess.STDOUT, cwd=path_from_root('src'))
|
2011-07-07 11:38:35 +04:00
|
|
|
outfile.close()
|
|
|
|
|
|
|
|
|
|
|
|
def main(args):
|
|
|
|
# Construct a final linked and disassembled file.
|
2011-07-08 08:04:38 +04:00
|
|
|
if args.dlmalloc or args.optimize or not has_annotations(args.infile):
|
|
|
|
args.infile = assemble(args.infile)
|
2011-07-08 09:33:45 +04:00
|
|
|
if args.dlmalloc:
|
|
|
|
malloc = compile_malloc(determine_compiler(args.infile))
|
|
|
|
args.infile = link(args.infile, malloc)
|
2011-07-08 08:04:38 +04:00
|
|
|
if args.optimize: args.infile = optimize(args.infile)
|
2011-07-07 11:38:35 +04:00
|
|
|
args.infile = disassemble(args.infile)
|
|
|
|
|
|
|
|
# Prepare settings for serialization to JSON.
|
|
|
|
settings = {}
|
|
|
|
for setting in args.settings:
|
2011-07-13 23:30:29 +04:00
|
|
|
name, value = setting.strip().split('=', 1)
|
2011-07-07 11:38:35 +04:00
|
|
|
settings[name] = json.loads(value)
|
|
|
|
|
|
|
|
# Adjust sign correction for dlmalloc.
|
|
|
|
if args.dlmalloc:
|
2011-07-08 09:33:45 +04:00
|
|
|
CORRECT_SIGNS = settings.get('CORRECT_SIGNS', 0)
|
2011-07-07 11:38:35 +04:00
|
|
|
if CORRECT_SIGNS in (0, 2):
|
|
|
|
path = path_from_root('src', 'dlmalloc.c')
|
2011-07-08 09:33:45 +04:00
|
|
|
old_lines = settings.get('CORRECT_SIGNS_LINES', [])
|
2011-07-07 11:38:35 +04:00
|
|
|
line_nums = [4816, 4191, 4246, 4199, 4205, 4235, 4227]
|
|
|
|
lines = old_lines + [path + ':' + str(i) for i in line_nums]
|
|
|
|
settings['CORRECT_SIGNS'] = 2
|
|
|
|
settings['CORRECT_SIGNS_LINES'] = lines
|
|
|
|
|
|
|
|
# Compile the assembly to Javascript.
|
|
|
|
emscript(args.infile, json.dumps(settings), args.outfile)
|
|
|
|
|
|
|
|
|
|
|
|
if __name__ == '__main__':
|
2011-07-13 23:30:29 +04:00
|
|
|
parser = optparse.OptionParser(
|
|
|
|
usage='usage: %prog [-h] [-O] [-m] [-o OUTFILE] [-s FOO=BAR]* infile',
|
|
|
|
description=('Compile an LLVM assembly file to Javascript. Accepts both '
|
|
|
|
'human-readable (*.ll) and bitcode (*.bc) formats.'),
|
2011-07-07 11:38:35 +04:00
|
|
|
epilog='You should have an ~/.emscripten file set up; see settings.py.')
|
2011-07-13 23:30:29 +04:00
|
|
|
parser.add_option('-O', '--optimize',
|
|
|
|
default=False,
|
|
|
|
action='store_true',
|
|
|
|
help='Run LLVM optimizations on the input.')
|
|
|
|
parser.add_option('-m', '--dlmalloc',
|
|
|
|
default=False,
|
|
|
|
action='store_true',
|
|
|
|
help='Use dlmalloc. Without, uses a dummy allocator.')
|
|
|
|
parser.add_option('-o', '--outfile',
|
|
|
|
default=sys.stdout,
|
|
|
|
help='Where to write the output; defaults to stdout.')
|
|
|
|
parser.add_option('-s', '--setting',
|
|
|
|
dest='settings',
|
|
|
|
default=[],
|
|
|
|
action='append',
|
|
|
|
metavar='FOO=BAR',
|
|
|
|
help=('Overrides for settings defined in settings.js. '
|
|
|
|
'May occur multiple times.'))
|
|
|
|
|
|
|
|
# Convert to the same format that argparse would have produced.
|
|
|
|
keywords, positional = parser.parse_args()
|
|
|
|
if len(positional) != 1:
|
|
|
|
raise RuntimeError('Must provide exactly one positional argument.')
|
2011-07-30 21:43:43 +04:00
|
|
|
keywords.infile = os.path.abspath(positional[0])
|
2011-07-13 23:30:29 +04:00
|
|
|
if isinstance(keywords.outfile, basestring):
|
|
|
|
keywords.outfile = open(keywords.outfile, 'w')
|
2011-07-08 08:38:42 +04:00
|
|
|
|
|
|
|
try:
|
2011-07-13 23:30:29 +04:00
|
|
|
main(keywords)
|
2011-07-08 08:38:42 +04:00
|
|
|
finally:
|
|
|
|
for filename in TEMP_FILES_TO_CLEAN:
|
|
|
|
os.unlink(filename)
|