diff options
Diffstat (limited to 'tools')
| -rw-r--r-- | tools/asm_module.py | 271 | ||||
| -rw-r--r-- | tools/file_packager.py | 18 | ||||
| -rw-r--r-- | tools/js-optimizer.js | 32 | ||||
| -rwxr-xr-x | tools/merge_asm.py | 26 | ||||
| -rw-r--r-- | tools/shared.py | 12 | ||||
| -rwxr-xr-x | tools/split_asm.py | 30 |
6 files changed, 374 insertions, 15 deletions
diff --git a/tools/asm_module.py b/tools/asm_module.py new file mode 100644 index 00000000..e54cfc21 --- /dev/null +++ b/tools/asm_module.py @@ -0,0 +1,271 @@ + +import sys, re + +import shared, js_optimizer + + +class AsmModule(): + def __init__(self, filename): + self.filename = filename + self.js = open(filename).read() + + self.start_asm = self.js.find(js_optimizer.start_asm_marker) + self.start_funcs = self.js.find(js_optimizer.start_funcs_marker) + self.end_funcs = self.js.rfind(js_optimizer.end_funcs_marker) + self.end_asm = self.js.rfind(js_optimizer.end_asm_marker) + + # pre and asm + self.pre_js = self.js[:self.start_asm] + self.asm_js = self.js[self.start_asm:self.end_asm] + + # heap initializer + self.staticbump = int(re.search(shared.JS.memory_staticbump_pattern, self.pre_js).group(1)) + if self.staticbump: + self.mem_init_js = re.search(shared.JS.memory_initializer_pattern, self.pre_js).group(0) + + # global initializers + global_inits = re.search(shared.JS.global_initializers_pattern, self.pre_js) + if global_inits: + self.global_inits_js = global_inits.group(0) + self.global_inits = map(lambda init: init.split('{')[2][1:].split('(')[0], global_inits.groups(0)[0].split(',')) + else: + self.global_inits_js = '' + self.global_inits = [] + + # imports (and global variables) + first_var = self.js.find('var ', self.js.find('var ', self.start_asm)+4) + self.pre_imports_js = self.js[self.start_asm:first_var] + self.imports_js = self.js[first_var:self.start_funcs] + self.imports = {} + for imp in js_optimizer.import_sig.finditer(self.imports_js): + key, value = imp.group(0).split('var ')[1][:-1].split('=', 1) + self.imports[key.strip()] = value.strip() + #print >> sys.stderr, 'imports', self.imports + + # funcs + self.funcs_js = self.js[self.start_funcs:self.end_funcs] + self.funcs = set([m.group(2) for m in js_optimizer.func_sig.finditer(self.funcs_js)]) + #print 'funcs', self.funcs + + # tables and exports + post_js = self.js[self.end_funcs:self.end_asm] + ret = post_js.find('return') + self.tables_js = post_js[:ret] + self.exports_js = post_js[ret:] + self.tables = self.parse_tables(self.tables_js) + self.exports = set([export.strip() for export in self.exports_js[self.exports_js.find('{')+1:self.exports_js.find('}')].split(',')]) + + # post + self.post_js = self.js[self.end_asm:] + self.sendings = {} + for sending in [sending.strip() for sending in self.post_js[self.post_js.find('}, { ')+5:self.post_js.find(' }, buffer);')].split(',')]: + colon = sending.find(':') + self.sendings[sending[:colon].replace('"', '')] = sending[colon+1:].strip() + self.module_defs = set(re.findall('var [\w\d_$]+ = Module\["[\w\d_$]+"\] = asm\["[\w\d_$]+"\];\n', self.post_js)) + + def relocate_into(self, main): + # heap initializer + if self.staticbump > 0: + new_mem_init = self.mem_init_js[:self.mem_init_js.rfind(', ')] + ', Runtime.GLOBAL_BASE+%d)' % main.staticbump + main.pre_js = re.sub(shared.JS.memory_staticbump_pattern, 'STATICTOP = STATIC_BASE + %d;\n' % (main.staticbump + self.staticbump) + new_mem_init, main.pre_js, count=1) + + # Find function name replacements TODO: do not rename duplicate names with duplicate contents, just merge them + replacements = {} + for func in self.funcs: + rep = func + while rep in main.funcs: + rep += '_' + replacements[func] = rep + #print >> sys.stderr, 'replacements:', replacements + + # sendings: add invokes for new tables + all_sendings = main.sendings + added_sending = False + for table in self.tables: + if table not in main.tables: + sig = table[table.rfind('_')+1:] + all_sendings['invoke_%s' % sig] = shared.JS.make_invoke(sig, named=False) + added_sending = True + + # imports + all_imports = main.imports + for key, value in self.imports.iteritems(): + if key in self.funcs or key in main.funcs: continue # external function in one module, implemented in the other + value_concrete = '.' not in value # env.key means it is an import, an external value, and not a concrete one + main_value = main.imports.get(key) + main_value_concrete = main_value and '.' not in main_value + if value_concrete and main_value_concrete: continue # standard global var + if not main_value or value_concrete: + if '+' in value: + # relocate + value = value.replace('(', '').replace(')', '').replace('| 0', '').replace('|0', '').replace(' ', '') + left, right = value.split('+') + assert left == 'H_BASE' + value = str(main.staticbump + int(right)) + all_imports[key] = value + if (value_concrete or main_value_concrete) and key in all_sendings: + del all_sendings[key] # import of external value no longer needed + main.imports_js = '\n'.join(['var %s = %s;' % (key, value) for key, value in all_imports.iteritems()]) + '\n' + + # check for undefined references to global variables + def check_import(key, value): + if value.startswith('+') or value.endswith('|0'): # ignore functions + if key not in all_sendings: + print >> sys.stderr, 'warning: external variable %s is still not defined after linking' % key + all_sendings[key] = '0' + for key, value in all_imports.iteritems(): check_import(key, value) + + if added_sending: + sendings_js = ', '.join(['%s: %s' % (key, value) for key, value in all_sendings.iteritems()]) + sendings_start = main.post_js.find('}, { ')+5 + sendings_end = main.post_js.find(' }, buffer);') + main.post_js = main.post_js[:sendings_start] + sendings_js + main.post_js[sendings_end:] + + # tables + f_bases = {} + f_sizes = {} + for table, data in self.tables.iteritems(): + main.tables[table] = self.merge_tables(table, main.tables.get(table), data, replacements, f_bases, f_sizes) + main.combine_tables() + #print >> sys.stderr, 'f bases', f_bases + + # relocate + temp = shared.Building.js_optimizer(self.filename, ['asm', 'relocate', 'last'], extra_info={ + 'replacements': replacements, + 'fBases': f_bases, + 'hBase': main.staticbump + }) + #print >> sys.stderr, 'relocated side into', temp + relocated_funcs = AsmModule(temp) + shared.try_delete(temp) + main.extra_funcs_js = relocated_funcs.funcs_js.replace(js_optimizer.start_funcs_marker, '\n') + + # update function table uses + ft_marker = 'FUNCTION_TABLE_' + + def update_fts(what): + updates = [] + i = 1 # avoid seeing marker in recursion + while 1: + i = what.find(ft_marker, i) + if i < 0: break; + start = i + end = what.find('[', start) + table = what[i:end] + if table not in f_sizes: + # table was not modified + i += len(ft_marker) + continue + nesting = 1 + while nesting > 0: + next = what.find(']', end+1) + nesting -= 1 + nesting += what.count('[', end+1, next) + end = next + assert end > 0 + mask = what.rfind('&', start, end) + assert mask > 0 and end - mask <= 13 + fixed = update_fts(what[start:mask+1] + str(f_sizes[table]-1) + ']') + updates.append((start, end, fixed)) + i = end # additional function table uses were done by recursion + # apply updates + if len(updates) == 0: return what + parts = [] + so_far = 0 + for i in range(len(updates)): + start, end, fixed = updates[i] + parts.append(what[so_far:start]) + parts.append(fixed) + so_far = end+1 + parts.append(what[so_far:]) + return ''.join(parts) + + main.funcs_js = update_fts(main.funcs_js) + main.extra_funcs_js = update_fts(main.extra_funcs_js) + + # global initializers + if self.global_inits: + my_global_inits = map(lambda init: replacements[init] if init in replacements else init, self.global_inits) + all_global_inits = map(lambda init: '{ func: function() { %s() } }' % init, main.global_inits + my_global_inits) + all_global_inits_js = '/* global initializers */ __ATINIT__.push(' + ','.join(all_global_inits) + ');' + if main.global_inits: + target = main.global_inits_js + else: + target = '// === Body ===\n' + all_global_inits_js = target + all_global_inits_js + main.pre_js = main.pre_js.replace(target, all_global_inits_js) + + # exports + def rep_exp(export): + key, value = export.split(':') + if key in replacements: + repped = replacements[key] + return repped + ': ' + repped + return export + my_exports = map(rep_exp, self.exports) + exports = main.exports.union(my_exports) + main.exports_js = 'return {' + ','.join(list(exports)) + '};\n})\n' + + # post + def rep_def(deff): + key = deff.split(' ')[1] + if key in replacements: + rep = replacements[key] + return 'var %s = Module["%s"] = asm["%s"];\n' % (rep, rep, rep) + return deff + my_module_defs = map(rep_def, self.module_defs) + new_module_defs = set(my_module_defs).difference(main.module_defs) + if len(new_module_defs) > 0: + position = main.post_js.find('Runtime.') # Runtime is the start of the hardcoded ones + main.post_js = main.post_js[:position] + ''.join(list(new_module_defs)) + '\n' + main.post_js[position:] + + def write(self, out): + f = open(out, 'w') + f.write(self.pre_js) + f.write(self.pre_imports_js) + f.write(self.imports_js) + f.write(self.funcs_js) + f.write(self.extra_funcs_js) + f.write(self.tables_js) + f.write(self.exports_js) + f.write(self.post_js) + f.close() + + # Utilities + + def parse_tables(self, js): + tables = {} + parts = js.split(';') + for part in parts: + if '=' not in part: continue + part = part.split('var ')[1] + name, data = part.split('=') + tables[name.strip()] = data.strip() + return tables + + def merge_tables(self, table, main, side, replacements, f_bases, f_sizes): + sig = table.split('_')[-1] + side = side[1:-1].split(',') + side = map(lambda f: replacements[f] if f in replacements else f, side) + if not main: + f_bases[sig] = 0 + f_sizes[table] = len(side) + return '[' + ','.join(side) + ']' + main = main[1:-1].split(',') + # TODO: handle non-aliasing case too + assert len(main) % 2 == 0 + f_bases[sig] = len(main) + ret = main + side + size = 2 + while size < len(ret): size *= 2 + aborter = ret[1] # we can assume odd indexes have an aborting function with the right signature + ret = ret + [aborter]*(size - len(ret)) + assert len(ret) == size + f_sizes[table] = size + return '[' + ','.join(ret) + ']' + + def combine_tables(self): + self.tables_js = '// EMSCRIPTEN_END_FUNCS\n' + for table, data in self.tables.iteritems(): + self.tables_js += 'var %s = %s;\n' % (table, data) + diff --git a/tools/file_packager.py b/tools/file_packager.py index 575e5957..1a9d925b 100644 --- a/tools/file_packager.py +++ b/tools/file_packager.py @@ -122,8 +122,6 @@ for arg in sys.argv[1:]: srcpath, dstpath = arg.split('@') # User is specifying destination filename explicitly. else: srcpath = dstpath = arg # Use source path as destination path. - if os.path.isabs(dstpath): - print >> sys.stderr, 'Warning: Embedding an absolute file/directory name "' + dstpath + '" to the virtual filesystem. The file will be made available in the path "' + dstpath + '", and not in the root of the generated file system. Use the explicit syntax --preload-file srcpath@dstpath to specify the target location the absolute source path should be directed to.' if os.path.isfile(srcpath) or os.path.isdir(srcpath): data_files.append({ 'srcpath': srcpath, 'dstpath': dstpath, 'mode': mode }) else: @@ -198,6 +196,22 @@ for file_ in data_files: os.path.walk(file_['srcpath'], add, [file_['mode'], file_['srcpath'], file_['dstpath']]) data_files = filter(lambda file_: not os.path.isdir(file_['srcpath']), data_files) +# Absolutize paths, and check that they make sense +curr_abspath = os.path.abspath(os.getcwd()) +for file_ in data_files: + if file_['srcpath'] == file_['dstpath']: + # This file was not defined with src@dst, so we inferred the destination from the source. In that case, + # we require that the destination not be under the current location + path = file_['dstpath'] + abspath = os.path.abspath(path) + if DEBUG: print >> sys.stderr, path, abspath, curr_abspath + if not abspath.startswith(curr_abspath): + print >> sys.stderr, 'Error: Embedding "%s" which is below the current directory "%s". This is invalid since the current directory becomes the root that the generated code will see' % (path, curr_abspath) + sys.exit(1) + file_['dstpath'] = abspath[len(curr_abspath)+1:] + if os.path.isabs(path): + print >> sys.stderr, 'Warning: Embedding an absolute file/directory name "' + path + '" to the virtual filesystem. The file will be made available in the relative path "' + file_['dstpath'] + '". You can use the explicit syntax --preload-file srcpath@dstpath to explicitly specify the target location the absolute source path should be directed to.' + for file_ in data_files: file_['dstpath'] = file_['dstpath'].replace(os.path.sep, '/') # name in the filesystem, native and emulated if file_['dstpath'].endswith('/'): # If user has submitted a directory name as the destination but omitted the destination filename, use the filename from source file diff --git a/tools/js-optimizer.js b/tools/js-optimizer.js index 29b36cad..4192ddd1 100644 --- a/tools/js-optimizer.js +++ b/tools/js-optimizer.js @@ -2817,7 +2817,7 @@ function relocate(ast) { var other = node[3]; if (base === 0) return other; if (other[0] == 'num') { - other[1] += base; + other[1] = (other[1] + base)|0; return other; } else { node[2] = ['num', base]; @@ -3106,7 +3106,7 @@ function outline(ast) { // Reserve an extra two spots per possible outlining: one for control flow var, the other for control flow data // The control variables are zeroed out when calling an outlined function, and after using // the value after they return. - asmData.maxOutlinings = Math.round(3*measureSize(func)/sizeToOutline); + asmData.maxOutlinings = Math.round(3*measureSize(func)/extraInfo.sizeToOutline); asmData.totalStackSize = stackSize + (stack.length + 2*asmData.maxOutlinings)*8; asmData.controlStackPos = function(i) { return stackSize + (stack.length + i)*8 }; asmData.controlDataStackPos = function(i) { return stackSize + (stack.length + i)*8 + 4 }; @@ -3210,22 +3210,30 @@ function outline(ast) { var CONTROL_BREAK = 1, CONTROL_BREAK_LABEL = 2, CONTROL_CONTINUE = 3, CONTROL_CONTINUE_LABEL = 4, CONTROL_RETURN_VOID = 5, CONTROL_RETURN_INT = 6, CONTROL_RETURN_DOUBLE = 7; - var sizeToOutline = extraInfo.sizeToOutline; - var level = 0; + var sizeToOutline = null; // customized per function and as we make progress + function calculateThreshold(func) { + sizeToOutline = extraInfo.sizeToOutline; + var size = measureSize(func); + //var desiredChunks = Math.ceil(size/extraInfo.sizeToOutline); + ////sizeToOutline = Math.round((extraInfo.sizeToOutline + (2*size/desiredChunks))/3); + //sizeToOutline = Math.round(size/desiredChunks); + printErr('trying to reduce the size of ' + func[1] + ' which is ' + size + ' (>= ' + extraInfo.sizeToOutline + '), aim for ' + sizeToOutline); + } + var level = 0; var outliningParents = {}; // function name => parent it was outlined from function doOutline(func, asmData, stats, start, end) { if (asmData.splitCounter === asmData.maxOutlinings) return []; if (!extraInfo.allowCostlyOutlines) var originalStats = copy(stats); var code = stats.slice(start, end+1); + var originalCodeSize = measureSize(code); var funcSize = measureSize(func); var outlineIndex = asmData.splitCounter++; var newIdent = func[1] + '$' + outlineIndex; // analyze variables, and find 'owned' variables - that only appear in the outlined code, and do not need any spill support var codeInfo = analyzeCode(func, asmData, code); var allCodeInfo = analyzeCode(func, asmData, func); - //printErr(' do outline ' + [func[1], level, 'range:', start, end, 'of', stats.length, newIdent, measureSize(code), JSON.stringify(codeInfo.labels), JSON.stringify(codeInfo.breaks), JSON.stringify(codeInfo.continues)]); var owned = { sp: 1 }; // sp is always owned, each has its own keys(setUnion(codeInfo.reads, codeInfo.writes)).forEach(function(v) { if (allCodeInfo.reads[v] === codeInfo.reads[v] && allCodeInfo.writes[v] === codeInfo.writes[v] && !(v in asmData.params)) { @@ -3409,9 +3417,11 @@ function outline(ast) { stats.splice.apply(stats, [start, end-start+1].concat(reps)); // final evaluation and processing if (!extraInfo.allowCostlyOutlines && (measureSize(func) >= funcSize || measureSize(newFunc) >= funcSize)) { + //printErr('aborted outline attempt ' + [measureSize(func), measureSize(newFunc), ' one of which >= ', funcSize]); // abort, this was pointless stats.length = originalStats.length; for (var i = 0; i < stats.length; i++) stats[i] = originalStats[i]; + asmData.splitCounter--; return []; } for (var v in owned) { @@ -3426,6 +3436,8 @@ function outline(ast) { } } outliningParents[newIdent] = func[1]; + printErr('performed outline ' + [func[1], newIdent, 'code sizes (pre/post):', originalCodeSize, measureSize(code), 'overhead (w/r):', setSize(setSub(codeInfo.writes, owned)), setSize(setSub(codeInfo.reads, owned))]); + calculateThreshold(func); return [newFunc]; } @@ -3452,7 +3464,7 @@ function outline(ast) { } while (1) { i--; - calcMinIndex(); + calcMinIndex(); // TODO: optimize if (i < minIndex) { // we might be done. but, if we have just outlined, do a further attempt from the beginning. // (but only if the total costs are not extravagant) @@ -3509,7 +3521,7 @@ function outline(ast) { // If this is big enough to outline, but not too big (if very close to the size of the full function, // outlining is pointless; remove stats from the end to try to achieve the good case), then outline. // Also, try to reduce the size if it is much larger than the hoped-for size - while ((sizeSeen > maxSize || sizeSeen > 2*sizeToOutline) && end > i+1 && stats[end][0] !== 'begin-outline-call' && stats[end][0] !== 'end-outline-call') { + while ((sizeSeen > maxSize || sizeSeen > 2*sizeToOutline) && end > i && stats[end][0] !== 'begin-outline-call' && stats[end][0] !== 'end-outline-call') { sizeSeen -= measureSize(stats[end]); if (sizeSeen >= sizeToOutline) { end--; @@ -3531,12 +3543,12 @@ function outline(ast) { }); assert(sum == 0); // final decision and action + //printErr(' will try done working on sizeSeen due to ' + [(sizeSeen > maxSize || sizeSeen > 2*sizeToOutline), end > i , stats[end][0] !== 'begin-outline-call' , stats[end][0] !== 'end-outline-call'] + ' ... ' + [sizeSeen, sizeToOutline, maxSize, sizeSeen >= sizeToOutline, sizeSeen <= maxSize]); if (sizeSeen >= sizeToOutline && sizeSeen <= maxSize) { assert(i >= minIndex); var newFuncs = doOutline(func, asmData, stats, i, end); // outline [i, .. ,end] inclusive if (newFuncs.length) { ret.push.apply(ret, newFuncs); - printErr('performed outline on ' + func[1] + ' of ' + sizeSeen + ', func is now size ' + measureSize(func) + ' ==> ' + newFuncs[0][1]); } sizeSeen = 0; end = i-1; @@ -3566,10 +3578,10 @@ function outline(ast) { funcs.forEach(function(func) { var asmData = normalizeAsm(func); var size = measureSize(func); - if (size >= sizeToOutline) { - printErr('trying to reduce the size of ' + func[1] + ' which is ' + size + ' (>= ' + sizeToOutline + ')'); + if (size >= extraInfo.sizeToOutline) { aggressiveVariableElimination(func, asmData); flatten(func, asmData); + calculateThreshold(func); analyzeFunction(func, asmData); var stats = getStatements(func); var ret = outlineStatements(func, asmData, stats, 0.9*size); diff --git a/tools/merge_asm.py b/tools/merge_asm.py new file mode 100755 index 00000000..fe143a89 --- /dev/null +++ b/tools/merge_asm.py @@ -0,0 +1,26 @@ +#!/usr/bin/env python2 + +''' +Splits a compiler outputted program into the asm module and the surrounding shell. This +can be useful if you want to process the shell in some manner (e.g. minifiy it) in ways +that would be harmful to asm.js code. +''' + +import sys +import shared + +try: + me, in_shell, in_asm, outfile = sys.argv[:4] +except: + print >> sys.stderr, 'usage: emlink.py [input file] [shell output file] [asm output file]' + sys.exit(1) + +print 'Shell input:', in_shell +print 'Asm input:', in_asm +print 'Input file:', outfile + +shared.try_delete(outfile) + +pre, post = open(in_shell).read().split('// ASM_CODE\n') +open(outfile, 'w').write(pre + '\n' + open(in_asm).read() + '\n' + post) + diff --git a/tools/shared.py b/tools/shared.py index 007c2ee8..c0df227d 100644 --- a/tools/shared.py +++ b/tools/shared.py @@ -286,7 +286,7 @@ def check_node_version(): EMSCRIPTEN_VERSION = '1.5.3' def generate_sanity(): - return EMSCRIPTEN_VERSION + '|' + get_llvm_target() + return EMSCRIPTEN_VERSION + '|' + get_llvm_target() + '|' + LLVM_ROOT def check_sanity(force=False): try: @@ -509,6 +509,7 @@ COMPILER_OPTS = COMPILER_OPTS + ['-m32', '-U__i386__', '-U__i386', '-Ui386', '-target', LLVM_TARGET] if LLVM_TARGET == 'le32-unknown-nacl': + COMPILER_OPTS = filter(lambda opt: opt != '-m32', COMPILER_OPTS) # le32 target is 32-bit anyhow, no need for -m32 COMPILER_OPTS += ['-U__native_client__', '-U__pnacl__', '-U__ELF__'] # The nacl target is originally used for Google Native Client. Emscripten is not NaCl, so remove the platform #define, when using their triple. USE_EMSDK = not os.environ.get('EMMAKEN_NO_SDK') @@ -516,7 +517,7 @@ USE_EMSDK = not os.environ.get('EMMAKEN_NO_SDK') if USE_EMSDK: # Disable system C and C++ include directories, and add our own (using -idirafter so they are last, like system dirs, which # allows projects to override them) - EMSDK_OPTS = ['-nostdinc', '-nostdinc++', '-Xclang', '-nobuiltininc', '-Xclang', '-nostdsysteminc', + EMSDK_OPTS = ['-nostdinc', '-Xclang', '-nobuiltininc', '-Xclang', '-nostdsysteminc', '-Xclang', '-isystem' + path_from_root('system', 'local', 'include'), '-Xclang', '-isystem' + path_from_root('system', 'include', 'libcxx'), '-Xclang', '-isystem' + path_from_root('system', 'include'), @@ -529,9 +530,14 @@ if USE_EMSDK: ] + [ '-U__APPLE__', '-U__linux__' ] + if LLVM_TARGET != 'le32-unknown-nacl': + EMSDK_CXX_OPTS = ['-nostdinc++'] # le32 target does not need -nostdinc++ + else: + EMSDK_CXX_OPTS = [] COMPILER_OPTS += EMSDK_OPTS else: EMSDK_OPTS = [] + EMSDK_CXX_OPTS = [] #print >> sys.stderr, 'SDK opts', ' '.join(EMSDK_OPTS) #print >> sys.stderr, 'Compiler opts', ' '.join(COMPILER_OPTS) @@ -593,7 +599,7 @@ def line_splitter(data): return out -def limit_size(string, MAX=80*20): +def limit_size(string, MAX=120*20): if len(string) < MAX: return string return string[0:MAX/2] + '\n[..]\n' + string[-MAX/2:] diff --git a/tools/split_asm.py b/tools/split_asm.py new file mode 100755 index 00000000..39eaca00 --- /dev/null +++ b/tools/split_asm.py @@ -0,0 +1,30 @@ +#!/usr/bin/env python2 + +''' +Splits a compiler outputted program into the asm module and the surrounding shell. This +can be useful if you want to process the shell in some manner (e.g. minifiy it) in ways +that would be harmful to asm.js code. +''' + +import sys +import shared +from asm_module import AsmModule + +try: + me, infile, out_shell, out_asm = sys.argv[:4] +except: + print >> sys.stderr, 'usage: emlink.py [input file] [shell output file] [asm output file]' + sys.exit(1) + +print 'Input file:', infile +print 'Shell output:', out_shell +print 'Asm output:', out_asm + +shared.try_delete(out_shell) +shared.try_delete(out_asm) + +module = AsmModule(infile) + +open(out_shell, 'w').write(module.pre_js + '\n// ASM_CODE\n' + module.post_js) +open(out_asm, 'w').write(module.asm_js) + |