# Copyright 2010 The Emscripten Authors. All rights reserved.

# Emscripten is available under two separate licenses, the MIT license and the

# University of Illinois/NCSA Open Source License. Both these licenses can be

# found in the LICENSE file.

"""A small wrapper script around the core JS compiler. This calls that

compiler with the settings given to it. It can also read data from C/C++

header files (so that the JS compiler can see the constants in those

headers, for the libc implementation in JS).

"""

from __future__ import print_function

import difflib

import os

import json

import subprocess

import re

import time

import logging

import pprint

from collections import OrderedDict

from tools import diagnostics

from tools import shared

from tools import gen_struct_info

from tools import jsrun

from tools.response_file import substitute_response_files

from tools.shared import WINDOWS, asstr, path_from_root, exit_with_error, asmjs_mangle, treat_as_user_function

from tools.toolchain_profiler import ToolchainProfiler

from tools.minified_js_name_generator import MinifiedJsNameGenerator

logger = logging.getLogger('emscripten')

STDERR_FILE = os.environ.get('EMCC_STDERR_FILE')

if STDERR_FILE:

STDERR_FILE = os.path.abspath(STDERR_FILE)

logger.info('logging stderr in js compiler phase into %s' % STDERR_FILE)

STDERR_FILE = open(STDERR_FILE, 'w')

def get_configuration():

if hasattr(get_configuration, 'configuration'):

return get_configuration.configuration

configuration = shared.Configuration(environ=os.environ)

get_configuration.configuration = configuration

return configuration

def quote(prop):

if shared.Settings.USE_CLOSURE_COMPILER == 2:

return ''.join(["'" + p + "'" for p in prop.split('.')])

else:

return prop

def access_quote(prop):

if shared.Settings.USE_CLOSURE_COMPILER == 2:

return ''.join(["['" + p + "']" for p in prop.split('.')])

else:

return '.' + prop

def emscript_fastcomp(infile, outfile, memfile, temp_files, DEBUG):

"""Runs the emscripten LLVM-to-JS compiler.

Args:

infile: The path to the input LLVM assembly file.

outfile: An open file object where the output is written.

"""

assert shared.Settings.ASM_JS, 'fastcomp is asm.js-only (mode 1 or 2)'

success = False

try:

# Overview:

# * Run LLVM backend to emit JS. JS includes function bodies, memory initializer,

# and various metadata

# * Run compiler.js on the metadata to emit the shell js code, pre/post-ambles,

# JS library dependencies, etc.

# metadata is modified by reference in some of the below

# these functions are split up to force variables to go out of scope and allow

# memory to be reclaimed

with ToolchainProfiler.profile_block('get_and_parse_backend'):

backend_output = compile_js(infile, temp_files, DEBUG)

funcs, metadata, mem_init = parse_fastcomp_output(backend_output, DEBUG)

fixup_metadata_tables(metadata)

funcs = fixup_functions(funcs, metadata)

with ToolchainProfiler.profile_block('compiler_glue'):

glue, forwarded_data = compiler_glue(metadata, temp_files, DEBUG)

with ToolchainProfiler.profile_block('function_tables_and_exports'):

(post, function_table_data, bundled_args) = (

function_tables_and_exports(funcs, metadata, mem_init, glue, forwarded_data, outfile, DEBUG))

with ToolchainProfiler.profile_block('write_output_file'):

finalize_output(outfile, post, function_table_data, bundled_args, metadata, DEBUG)

success = True

finally:

outfile.close()

if not success:

shared.try_delete(outfile.name) # remove partial output

def compile_js(infile, temp_files, DEBUG):

"""Compile infile with asm.js backend, return the contents of the compiled js"""

with temp_files.get_file('.4.js') as temp_js:

backend_cmd = create_backend_cmd(infile, temp_js)

if DEBUG:

logger.debug('emscript: llvm backend: ' + ' '.join(backend_cmd))

t = time.time()

shared.print_compiler_stage(backend_cmd)

with ToolchainProfiler.profile_block('emscript_llvm_backend'):

shared.check_call(backend_cmd)

if DEBUG:

logger.debug(' emscript: llvm backend took %s seconds' % (time.time() - t))

# Split up output

backend_output = open(temp_js).read()

return backend_output

def parse_fastcomp_output(backend_output, DEBUG):

start_funcs_marker = '// EMSCRIPTEN_START_FUNCTIONS'

end_funcs_marker = '// EMSCRIPTEN_END_FUNCTIONS'

metadata_split_marker = '// EMSCRIPTEN_METADATA'

start_funcs = backend_output.index(start_funcs_marker)

end_funcs = backend_output.rindex(end_funcs_marker)

metadata_split = backend_output.rindex(metadata_split_marker)

funcs = backend_output[start_funcs + len(start_funcs_marker):end_funcs]

metadata_raw = backend_output[metadata_split + len(metadata_split_marker):]

mem_init = backend_output[end_funcs + len(end_funcs_marker):metadata_split]

# we no longer use the "Runtime" object. TODO: stop emitting it in the backend

mem_init = mem_init.replace('Runtime.', '')

try:

metadata = json.loads(metadata_raw, object_pairs_hook=OrderedDict)

except ValueError:

logger.error('emscript: failure to parse metadata output from compiler backend. raw output is: \n' + metadata_raw)

raise

# This key is being added to fastcomp but doesn't exist in the current

# version.

metadata.setdefault('externFunctions', [])

if 'externUses' not in metadata:

exit_with_error('Your fastcomp compiler is out of date, please update! (need >= 1.38.26)')

# JS optimizer turns some heap accesses to others as an optimization, so make HEAP8 imply HEAPU8, HEAP16->HEAPU16, and HEAPF64->HEAPF32.

if 'Int8Array' in metadata['externUses']:

metadata['externUses'] += ['Uint8Array']

if 'Int16Array' in metadata['externUses']:

metadata['externUses'] += ['Uint16Array']

if 'Float64Array' in metadata['externUses']:

metadata['externUses'] += ['Float32Array']

# If we are generating references to Math.fround() from here in emscripten.py, declare it used as well.

if provide_fround() or metadata['simd']:

metadata['externUses'] += ['Math.fround']

# functions marked llvm.used in the code are exports requested by the user

shared.Building.user_requested_exports += metadata['exports']

# In MINIMAL_RUNTIME stackSave() and stackRestore are JS library functions. If LLVM backend generated

# calls to invoke_*() functions that save and restore the stack, we must include the stack functions

# explicitly into the build. (In traditional runtime the stack functions are always present, so this

# tracking is not needed)

if shared.Settings.MINIMAL_RUNTIME and (len(metadata['invokeFuncs']) > 0 or shared.Settings.LINKABLE):

shared.Settings.EXPORTED_FUNCTIONS += ['stackSave', 'stackRestore']

shared.Settings.DEFAULT_LIBRARY_FUNCS_TO_INCLUDE += ['$stackSave', '$stackRestore']

return funcs, metadata, mem_init

def fixup_metadata_tables(metadata):

# if emulating pointer casts, force all tables to the size of the largest

# (for wasm, we use binaryen's fpcast-emu pass, we don't need to do anything

# here)

if shared.Settings.EMULATE_FUNCTION_POINTER_CASTS and not shared.Settings.WASM:

max_size = 0

for k, v in metadata['tables'].items():

max_size = max(max_size, v.count(',') + 1)

for k, v in metadata['tables'].items():

curr = v.count(',') + 1

if curr < max_size:

if v.count('[]') == 1:

metadata['tables'][k] = v.replace(']', (','.join(['0'] * (max_size - curr)) + ']'))

else:

metadata['tables'][k] = v.replace(']', (',0' * (max_size - curr)) + ']')

if shared.Settings.SIDE_MODULE:

for k in metadata['tables'].keys():

metadata['tables'][k] = metadata['tables'][k].replace('var FUNCTION_TABLE_', 'var SIDE_FUNCTION_TABLE_')

def fixup_functions(funcs, metadata):

# function table masks

table_sizes = {}

for k, v in metadata['tables'].items():

# undercounts by one, but that is what we want

table_sizes[k] = str(v.count(','))

# if shared.Settings.ASSERTIONS >= 2 and table_sizes[k] == 0:

# diagnostics.warning('emcc', 'no function pointers with signature ' + k + ', but there is a call, which will abort if it occurs (this can result from undefined behavior, check for compiler warnings on your source files and consider -Werror)'

funcs = re.sub(r"#FM_(\w+)#", lambda m: table_sizes[m.groups(0)[0]], funcs)

# fix +float into float.0, if not running js opts

if not shared.Settings.RUNNING_JS_OPTS:

def fix_dot_zero(m):

num = m.group(3)

# TODO: handle 0x floats?

if num.find('.') < 0:

e = num.find('e')

if e < 0:

num += '.0'

else:

num = num[:e] + '.0' + num[e:]

return m.group(1) + m.group(2) + num

funcs = re.sub(r'([(=,+\-*/%<>:?] *)\+(-?)((0x)?[0-9a-f]*\.?[0-9]+([eE][-+]?[0-9]+)?)', fix_dot_zero, funcs)

return funcs

def compiler_glue(metadata, temp_files, DEBUG):

if DEBUG:

logger.debug('emscript: js compiler glue')

t = time.time()

# FIXME: do these one by one as normal js lib funcs

metadata['declares'] = [i64_func for i64_func in metadata['declares'] if i64_func not in ['getHigh32', 'setHigh32']]

update_settings_glue(metadata, DEBUG)

assert not (metadata['simd'] and shared.Settings.WASM), 'SIMD is used, but not supported in WASM mode yet'

assert not (shared.Settings.SIMD and shared.Settings.WASM), 'SIMD is requested, but not supported in WASM mode yet'

glue, forwarded_data = compile_settings(temp_files)

if DEBUG:

logger.debug(' emscript: glue took %s seconds' % (time.time() - t))

return glue, forwarded_data

def analyze_table(function_table_data):

def table_size(table):

table_contents = table[table.index('[') + 1: table.index(']')]

if len(table_contents) == 0: # empty table

return 0

return table_contents.count(',') + 1

# note that this is a minimal estimate, as when asm2wasm lays out tables it adds padding

table_total_size = sum(table_size(s) for s in function_table_data.values())

shared.Settings.WASM_TABLE_SIZE = table_total_size

# Extracts from JS library code dependencies to runtime primitives.

def get_asm_extern_primitives(pre):

primitives = re.search(r'\/\/ ASM_LIBRARY EXTERN PRIMITIVES: ([^\n]*)', pre)

if primitives:

return [x.strip().replace('Math_', 'Math.') for x in primitives.group(1).split(',')]

else:

return []

def compute_minimal_runtime_initializer_and_exports(post, initializers, exports, receiving):

# Generate invocations for all global initializers directly off the asm export object, e.g. asm['__GLOBAL__INIT']();

post = post.replace('/*** RUN_GLOBAL_INITIALIZERS(); ***/', '\n'.join(["asm['" + x + "']();" for x in global_initializer_funcs(initializers)]))

if shared.Settings.WASM:

# Declare all exports out to global JS scope so that JS library functions can access them in a

# way that minifies well with Closure

# e.g. var a,b,c,d,e,f;

exports_that_are_not_initializers = [x for x in exports if x not in initializers]

if shared.Settings.WASM_BACKEND:

# In Wasm backend the exports are still unmangled at this point, so mangle the names here

exports_that_are_not_initializers = [asmjs_mangle(x) for x in exports_that_are_not_initializers]

post = post.replace('/*** ASM_MODULE_EXPORTS_DECLARES ***/', 'var ' + ','.join(exports_that_are_not_initializers) + ';')

# Generate assignments from all asm.js/wasm exports out to the JS variables above: e.g. a = asm['a']; b = asm['b'];

post = post.replace('/*** ASM_MODULE_EXPORTS ***/', receiving)

receiving = ''

return post, receiving

def function_tables_and_exports(funcs, metadata, mem_init, glue, forwarded_data, outfile, DEBUG):

if DEBUG:

logger.debug('emscript: python processing: function tables and exports')

t = time.time()

forwarded_json = json.loads(forwarded_data)

# merge in information from llvm backend

function_table_data = metadata['tables']

if shared.Settings.WASM:

analyze_table(function_table_data)

# merge forwarded data

shared.Settings.EXPORTED_FUNCTIONS = forwarded_json['EXPORTED_FUNCTIONS']

pre, post = glue.split('// EMSCRIPTEN_END_FUNCS')

pre = apply_script_source(pre)

asm_extern_primitives = get_asm_extern_primitives(pre)

metadata['externUses'] += asm_extern_primitives

pre = memory_and_global_initializers(pre, metadata, mem_init)

pre, funcs_js = get_js_funcs(pre, funcs)

all_exported_functions = get_all_exported_functions(function_table_data)

all_implemented = get_all_implemented(forwarded_json, metadata)

report_missing_symbols(all_implemented, pre)

implemented_functions = get_implemented_functions(metadata)

pre = include_asm_consts(pre, forwarded_json, metadata)

pre = apply_table(pre)

outfile.write(pre)

pre = None

# Move preAsms to their right place

def move_preasm(m):

contents = m.groups(0)[0]

outfile.write(contents + '\n')

return ''

if not shared.Settings.BOOTSTRAPPING_STRUCT_INFO and len(funcs_js) > 1:

funcs_js[1] = re.sub(r'/\* PRE_ASM \*/(.*)\n', move_preasm, funcs_js[1])

if 'pre' in function_table_data:

pre_tables = function_table_data['pre']

del function_table_data['pre']

else:

pre_tables = ''

function_table_sigs = list(function_table_data.keys())

in_table, debug_tables, function_tables_defs = make_function_tables_defs(

implemented_functions, all_implemented, function_table_data, metadata)

exported_implemented_functions = get_exported_implemented_functions(

all_exported_functions, all_implemented, metadata)

# List of function signatures of used 'invoke_xxx()' functions in the application

# For backwards compatibility if one might be using a mismatching Emscripten compiler version, if 'invokeFuncs' is not present in metadata,

# use the full list of signatures in function table and generate invoke_() functions for all signatures in the program (producing excessive code size)

# we must also emit the full list if we are emitting code that can be linked later

if 'invokeFuncs' in metadata and not shared.Settings.LINKABLE:

invoke_function_names = metadata['invokeFuncs']

else:

invoke_function_names = ['invoke_' + x for x in function_table_sigs]

asm_setup = create_asm_setup(debug_tables, function_table_data, invoke_function_names, metadata)

basic_funcs = create_basic_funcs(function_table_sigs, invoke_function_names)

basic_vars = create_basic_vars(exported_implemented_functions, forwarded_json, metadata)

funcs_js += create_mftCall_funcs(function_table_data)

exports = create_exports(exported_implemented_functions, in_table, function_table_data, metadata)

# calculate globals

try:

del forwarded_json['Variables']['globals']['_llvm_global_ctors'] # not a true variable

except KeyError:

pass

if not shared.Settings.RELOCATABLE:

global_vars = metadata['externs']

else:

global_vars = [] # linkable code accesses globals through function calls

global_funcs = set(key for key, value in forwarded_json['Functions']['libraryFunctions'].items() if value != 2)

global_funcs = sorted(global_funcs.difference(set(global_vars)).difference(implemented_functions))

if shared.Settings.RELOCATABLE:

global_funcs += ['g$' + extern for extern in metadata['externs']]

global_funcs += ['fp$' + extern for extern in metadata['externFunctions']]

# Tracks the set of used (minified) function names in

# JS symbols imported to asm.js module.

minified_js_names = MinifiedJsNameGenerator()

# Converts list of imports ['foo', 'bar', ...] to a dictionary of

# name mappings in form { 'minified': 'unminified', ... }

def define_asmjs_import_names(imports):

if shared.Settings.MINIFY_ASMJS_IMPORT_NAMES:

return [(minified_js_names.generate(), i) for i in imports]

else:

return [(i, i) for i in imports]

basic_funcs = define_asmjs_import_names(basic_funcs)

global_funcs = define_asmjs_import_names(global_funcs)

basic_vars = define_asmjs_import_names(basic_vars)

global_vars = define_asmjs_import_names(global_vars)

bg_funcs = basic_funcs + global_funcs

bg_vars = basic_vars + global_vars

asm_global_funcs = create_asm_global_funcs(bg_funcs, metadata)

asm_global_vars = create_asm_global_vars(bg_vars)

the_global = create_the_global(metadata)

sending_vars = bg_funcs + bg_vars

sending = OrderedDict([(math_fix(minified), unminified) for (minified, unminified) in sending_vars])

if shared.Settings.WASM:

add_standard_wasm_imports(sending)

sorted_sending_keys = sorted(sending.keys())

sending = '{ ' + ', '.join('"' + k + '": ' + sending[k] for k in sorted_sending_keys) + ' }'

receiving = create_receiving(function_table_data, function_tables_defs,

exported_implemented_functions, metadata['initializers'])

post = apply_table(post)

post = apply_static_code_hooks(post)

if shared.Settings.MINIMAL_RUNTIME:

post, receiving = compute_minimal_runtime_initializer_and_exports(post, metadata['initializers'], [mangled for mangled, unmangled in shared.Settings.MODULE_EXPORTS], receiving)

function_tables_impls = make_function_tables_impls(function_table_data)

final_function_tables = '\n'.join(function_tables_impls) + '\n' + function_tables_defs

if shared.Settings.EMULATED_FUNCTION_POINTERS:

final_function_tables = (

final_function_tables

.replace("asm['", '')

.replace("']", '')

.replace('var SIDE_FUNCTION_TABLE_', 'var FUNCTION_TABLE_')

.replace('var dynCall_', '//')

)

if DEBUG:

logger.debug('asm text sizes' + str([

[len(s) for s in funcs_js], len(asm_setup), len(asm_global_vars), len(asm_global_funcs), len(pre_tables),

len('\n'.join(function_tables_impls)), len(function_tables_defs) + (function_tables_defs.count('\n') * len(' ')),

len(exports), len(the_global), len(sending), len(receiving)]))

logger.debug(' emscript: python processing: function tables and exports took %s seconds' % (time.time() - t))

bundled_args = (funcs_js, asm_setup, the_global, sending, receiving, asm_global_vars,

asm_global_funcs, pre_tables, final_function_tables, exports)

return (post, function_table_data, bundled_args)

def finalize_output(outfile, post, function_table_data, bundled_args, metadata, DEBUG):

function_table_sigs = function_table_data.keys()

module = create_module_asmjs(function_table_sigs, metadata, *bundled_args)

if DEBUG:

logger.debug('emscript: python processing: finalize')

t = time.time()

write_output_file(outfile, post, module)

module = None

if DEBUG:

logger.debug(' emscript: python processing: finalize took %s seconds' % (time.time() - t))

write_cyberdwarf_data(outfile, metadata)

# Given JS code that consists only exactly of a series of "var a = ...;\n var b = ...;" statements,

# this function collapses the redundant 'var ' statements at the beginning of each line to a

# single var a =..., b=..., c=...; statement.

def collapse_redundant_vars(code):

if shared.Settings.WASM:

return code # Skip if targeting Wasm, this does not matter there

old_code = ''

while code != old_code: # Repeated vars overlap, so can't run in one regex pass. Runs in O(log(N)) time

old_code = code

code = re.sub(r'(var [^;]*);\s*var ', r'\1,\n ', code)

return code

def global_initializer_funcs(initializers):

# If we have at most one global ctor, no need to group global initializers.

# Also in EVAL_CTORS mode, we want to try to evaluate the individual ctor functions, so in that mode,

# do not group ctors into one.

return ['globalCtors'] if (len(initializers) > 1 and not shared.Settings.EVAL_CTORS) else initializers

# Each .cpp file with global constructors generates a __GLOBAL__init() function that needs to be

# called to construct the global objects in that compilation unit. This function groups all these

# global initializer functions together into a single globalCtors() function that lives inside the

# asm.js/wasm module, and gets exported out to JS scope to be called at the startup of the application.

def create_global_initializer(initializers):

# If we have no global ctors, don't even generate a dummy empty function to save code space

# Also in EVAL_CTORS mode, we want to try to evaluate the individual ctor functions, so in that mode,

# we do not group ctors into one.

if 'globalCtors' not in global_initializer_funcs(initializers):

return ''

global_initializer = ''' function globalCtors() {

%s

}''' % '\n '.join(i + '();' for i in initializers)

return global_initializer

def create_module_asmjs(function_table_sigs, metadata,

funcs_js, asm_setup, the_global, sending, receiving, asm_global_vars,

asm_global_funcs, pre_tables, final_function_tables, exports):

receiving += create_named_globals(metadata)

runtime_funcs = create_runtime_funcs_asmjs(exports, metadata)

asm_start_pre = create_asm_start_pre(asm_setup, the_global, sending, metadata)

memory_views = create_memory_views(metadata)

asm_temp_vars = create_asm_temp_vars(metadata)

asm_runtime_thread_local_vars = create_asm_runtime_thread_local_vars()

stack = ''

if not shared.Settings.RELOCATABLE and not (shared.Settings.WASM and shared.Settings.SIDE_MODULE):

if 'STACKTOP' in shared.Settings.ASM_PRIMITIVE_VARS:

stack += apply_memory(' var STACKTOP = {{{ STACK_BASE }}};\n')

if 'STACK_MAX' in shared.Settings.ASM_PRIMITIVE_VARS:

stack += apply_memory(' var STACK_MAX = {{{ STACK_MAX }}};\n')

if 'tempFloat' in shared.Settings.ASM_PRIMITIVE_VARS:

temp_float = ' var tempFloat = %s;\n' % ('Math_fround(0)' if provide_fround() else '0.0')

else:

temp_float = ''

async_state = ' var asyncState = 0;\n' if shared.Settings.EMTERPRETIFY_ASYNC else ''

f0_fround = ' const f0 = Math_fround(0);\n' if provide_fround() else ''

replace_memory = create_replace_memory(metadata)

start_funcs_marker = '\n// EMSCRIPTEN_START_FUNCS\n'

asm_end = create_asm_end(exports)

asm_variables = collapse_redundant_vars(memory_views + asm_global_vars + asm_temp_vars + asm_runtime_thread_local_vars + '\n' + asm_global_funcs + stack + temp_float + async_state + f0_fround)

asm_global_initializer = create_global_initializer(metadata['initializers'])

module = [

asm_start_pre,

asm_variables,

replace_memory,

start_funcs_marker,

asm_global_initializer

] + runtime_funcs + funcs_js + [

'\n ',

pre_tables, final_function_tables, asm_end,

'\n', receiving, ';\n'

]

if shared.Settings.SIDE_MODULE:

module.append('''

parentModule['registerFunctions'](%s, Module);

''' % str([str(f) for f in function_table_sigs]))

return module

def write_output_file(outfile, post, module):

for i in range(len(module)): # do this loop carefully to save memory

module[i] = normalize_line_endings(module[i])

outfile.write(module[i])

post = normalize_line_endings(post)

outfile.write(post)

def write_cyberdwarf_data(outfile, metadata):

if not shared.Settings.CYBERDWARF:

return

assert('cyberdwarf_data' in metadata)

cd_file_name = outfile.name + ".cd"

with open(cd_file_name, 'w') as f:

json.dump({'cyberdwarf': metadata['cyberdwarf_data']}, f)

def create_backend_cmd(infile, temp_js):

"""Create asm.js backend command from settings dict"""

args = [

shared.LLVM_COMPILER, infile, '-march=js', '-filetype=asm', '-o', temp_js,

'-emscripten-stack-size=%d' % shared.Settings.TOTAL_STACK,

'-O%s' % shared.Settings.OPT_LEVEL,

]

if shared.Settings.PRECISE_F32:

args += ['-emscripten-precise-f32']

if shared.Settings.USE_PTHREADS:

args += ['-emscripten-enable-pthreads']

if shared.Settings.WARN_UNALIGNED:

args += ['-emscripten-warn-unaligned']

if shared.Settings.RESERVED_FUNCTION_POINTERS > 0:

args += ['-emscripten-reserved-function-pointers=%d' % shared.Settings.RESERVED_FUNCTION_POINTERS]

if shared.Settings.ASSERTIONS > 0:

args += ['-emscripten-assertions=%d' % shared.Settings.ASSERTIONS]

if shared.Settings.ALIASING_FUNCTION_POINTERS == 0:

args += ['-emscripten-no-aliasing-function-pointers']

if shared.Settings.EMULATED_FUNCTION_POINTERS:

args += ['-emscripten-emulated-function-pointers']

if shared.Settings.EMULATE_FUNCTION_POINTER_CASTS:

args += ['-emscripten-emulate-function-pointer-casts']

if shared.Settings.RELOCATABLE:

args += ['-emscripten-relocatable']

args += ['-emscripten-global-base=0']

elif shared.Settings.GLOBAL_BASE >= 0:

args += ['-emscripten-global-base=%d' % shared.Settings.GLOBAL_BASE]

if shared.Settings.SIDE_MODULE:

args += ['-emscripten-side-module']

if shared.Settings.LEGALIZE_JS_FFI != 1:

args += ['-emscripten-legalize-javascript-ffi=0']

if shared.Settings.DISABLE_EXCEPTION_CATCHING != 1:

args += ['-enable-emscripten-cpp-exceptions']

if shared.Settings.DISABLE_EXCEPTION_CATCHING == 2:

args += ['-emscripten-cpp-exceptions-whitelist=' + ','.join(shared.Settings.EXCEPTION_CATCHING_WHITELIST or ['fake'])]

if not shared.Settings.EXIT_RUNTIME:

args += ['-emscripten-no-exit-runtime']

if shared.Settings.WORKAROUND_IOS_9_RIGHT_SHIFT_BUG:

args += ['-emscripten-asmjs-work-around-ios-9-right-shift-bug']

if shared.Settings.WASM:

args += ['-emscripten-wasm']

if shared.Building.is_wasm_only():

args += ['-emscripten-only-wasm']

if shared.Settings.CYBERDWARF:

args += ['-enable-cyberdwarf']

return args

def optimize_syscalls(declares, DEBUG):

"""Disables filesystem if only a limited subset of syscalls is used.

Our syscalls are static, and so if we see a very limited set of them - in particular,

no open() syscall and just simple writing - then we don't need full filesystem support.

If FORCE_FILESYSTEM is set, we can't do this. We also don't do it if INCLUDE_FULL_LIBRARY, since

not including the filesystem would mean not including the full JS libraries, and the same for

MAIN_MODULE since a side module might need the filesystem.

"""

relevant_settings = ['FORCE_FILESYSTEM', 'INCLUDE_FULL_LIBRARY', 'MAIN_MODULE']

if any(shared.Settings[s] for s in relevant_settings):

return

if shared.Settings.FILESYSTEM == 0:

# without filesystem support, it doesn't matter what syscalls need

shared.Settings.SYSCALLS_REQUIRE_FILESYSTEM = 0

else:

syscall_prefixes = ('__sys', 'fd_', '__wasi_fd_')

syscalls = [d for d in declares if d.startswith(syscall_prefixes)]

# check if the only filesystem syscalls are in: close, ioctl, llseek, write

# (without open, etc.. nothing substantial can be done, so we can disable

# extra filesystem support in that case)

if set(syscalls).issubset(set([

'__sys_ioctl',

# legacy/fastcomp name for __sys_ioctl

'__syscall6',

'fd_seek', '__wasi_fd_seek',

'fd_write', '__wasi_fd_write',

'fd_close', '__wasi_fd_close',

])):

if DEBUG:

logger.debug('very limited syscalls (%s) so disabling full filesystem support', ', '.join(str(s) for s in syscalls))

shared.Settings.SYSCALLS_REQUIRE_FILESYSTEM = 0

def is_int(x):

try:

int(x)

return True

except ValueError:

return False

def align_memory(addr):

return (addr + 15) & -16

def align_static_bump(metadata):

metadata['staticBump'] = align_memory(metadata['staticBump'])

return metadata['staticBump']

def update_settings_glue(metadata, DEBUG):

optimize_syscalls(metadata['declares'], DEBUG)

if shared.Settings.CYBERDWARF:

shared.Settings.DEFAULT_LIBRARY_FUNCS_TO_INCLUDE.append("cyberdwarf_Debugger")

shared.Settings.EXPORTED_FUNCTIONS.append("cyberdwarf_Debugger")

# Integrate info from backend

if shared.Settings.SIDE_MODULE:

# we don't need any JS library contents in side modules

shared.Settings.DEFAULT_LIBRARY_FUNCS_TO_INCLUDE = []

if metadata.get('cantValidate') and shared.Settings.ASM_JS != 2:

diagnostics.warning('almost-asm', 'disabling asm.js validation due to use of non-supported features: ' + metadata['cantValidate'])

shared.Settings.ASM_JS = 2

all_funcs = shared.Settings.DEFAULT_LIBRARY_FUNCS_TO_INCLUDE + [shared.JS.to_nice_ident(d) for d in metadata['declares']]

implemented_funcs = [x[1:] for x in metadata['implementedFunctions']]

shared.Settings.DEFAULT_LIBRARY_FUNCS_TO_INCLUDE = sorted(set(all_funcs).difference(implemented_funcs))

shared.Settings.DEFAULT_LIBRARY_FUNCS_TO_INCLUDE += [x[1:] for x in metadata['externs']]

if metadata['simd']:

shared.Settings.SIMD = 1

if shared.Settings.ASM_JS != 2:

diagnostics.warning('almost-asm', 'disabling asm.js validation due to use of SIMD')

shared.Settings.ASM_JS = 2

shared.Settings.MAX_GLOBAL_ALIGN = metadata['maxGlobalAlign']

shared.Settings.IMPLEMENTED_FUNCTIONS = metadata['implementedFunctions']

shared.Settings.WEAK_DECLARES = metadata.get('weakDeclares', [])

if metadata['asmConsts']:

# emit the EM_ASM signature-reading helper function only if we have any EM_ASM

# functions in the module.

shared.Settings.DEFAULT_LIBRARY_FUNCS_TO_INCLUDE += ['$readAsmConstArgs']

# Extract the list of function signatures that MAIN_THREAD_EM_ASM blocks in

# the compiled code have, each signature will need a proxy function invoker

# generated for it.

def read_proxied_function_signatures(asmConsts):

proxied_function_signatures = set()

for _, sigs, proxying_types in asmConsts.values():

for sig, proxying_type in zip(sigs, proxying_types):

if proxying_type == 'sync_on_main_thread_':

proxied_function_signatures.add(sig + '_sync')

elif proxying_type == 'async_on_main_thread_':

proxied_function_signatures.add(sig + '_async')

return list(proxied_function_signatures)

shared.Settings.PROXIED_FUNCTION_SIGNATURES = read_proxied_function_signatures(metadata['asmConsts'])

shared.Settings.STATIC_BUMP = align_static_bump(metadata)

if shared.Settings.WASM_BACKEND:

shared.Settings.BINARYEN_FEATURES = metadata['features']

shared.Settings.WASM_TABLE_SIZE = metadata['tableSize']

if shared.Settings.RELOCATABLE:

# When building relocatable output (e.g. MAIN_MODULE) the reported table

# size does not include the reserved slot at zero for the null pointer.

# Instead we use __table_base to offset the elements by 1.

shared.Settings.WASM_TABLE_SIZE += 1

shared.Settings.MAIN_READS_PARAMS = metadata['mainReadsParams']

# static code hooks

class StaticCodeHooks:

atinits = []

atmains = []

atexits = []

def apply_static_code_hooks(code):

code = code.replace('{{{ ATINITS }}}', StaticCodeHooks.atinits)

code = code.replace('{{{ ATMAINS }}}', StaticCodeHooks.atmains)

code = code.replace('{{{ ATEXITS }}}', StaticCodeHooks.atexits)

return code

def apply_forwarded_data(forwarded_data):

forwarded_json = json.loads(forwarded_data)

# Be aware of JS static allocations

shared.Settings.STATIC_BUMP = forwarded_json['STATIC_BUMP']

shared.Settings.DYNAMICTOP_PTR = forwarded_json['DYNAMICTOP_PTR']

# Be aware of JS static code hooks

StaticCodeHooks.atinits = str(forwarded_json['ATINITS'])

StaticCodeHooks.atmains = str(forwarded_json['ATMAINS'])

StaticCodeHooks.atexits = str(forwarded_json['ATEXITS'])

def compile_settings(temp_files):

# Save settings to a file to work around v8 issue 1579

with temp_files.get_file('.txt') as settings_file:

with open(settings_file, 'w') as s:

json.dump(shared.Settings.to_dict(), s, sort_keys=True)

# Call js compiler

env = os.environ.copy()

env['EMCC_BUILD_DIR'] = os.getcwd()

out = jsrun.run_js_tool(path_from_root('src', 'compiler.js'), shared.NODE_JS,

[settings_file], stdout=subprocess.PIPE, stderr=STDERR_FILE,

cwd=path_from_root('src'), env=env)

assert '//FORWARDED_DATA:' in out, 'Did not receive forwarded data in pre output - process failed?'

glue, forwarded_data = out.split('//FORWARDED_DATA:')

apply_forwarded_data(forwarded_data)

return glue, forwarded_data

class Memory():

def __init__(self):

# Note: if RELOCATABLE, then only relative sizes can be computed, and we don't

# actually write out any absolute memory locations ({{{ STACK_BASE }}}

# does not exist, etc.)

# Memory layout:

# * first the static globals

self.global_base = shared.Settings.GLOBAL_BASE

self.static_bump = shared.Settings.STATIC_BUMP

# * then the stack (up on fastcomp, down on upstream)

self.stack_low = align_memory(self.global_base + self.static_bump)

self.stack_high = align_memory(self.stack_low + shared.Settings.TOTAL_STACK)

if shared.Settings.WASM_BACKEND:

self.stack_base = self.stack_high

self.stack_max = self.stack_low

else:

self.stack_base = self.stack_low

self.stack_max = self.stack_high

# * then dynamic memory begins

self.dynamic_base = align_memory(self.stack_high)

if self.dynamic_base >= shared.Settings.INITIAL_MEMORY:

exit_with_error('Memory is not large enough for static data (%d) plus the stack (%d), please increase INITIAL_MEMORY (%d) to at least %d' % (self.static_bump, shared.Settings.TOTAL_STACK, shared.Settings.INITIAL_MEMORY, self.dynamic_base))

def apply_memory(js):

# Apply the statically-at-compile-time computed memory locations.

memory = Memory()

# Write it all out

js = js.replace('{{{ STATIC_BUMP }}}', str(memory.static_bump))

js = js.replace('{{{ STACK_BASE }}}', str(memory.stack_base))

js = js.replace('{{{ STACK_MAX }}}', str(memory.stack_max))

js = js.replace('{{{ DYNAMIC_BASE }}}', str(memory.dynamic_base))

logger.debug('global_base: %d stack_base: %d, stack_max: %d, dynamic_base: %d, static bump: %d', memory.global_base, memory.stack_base, memory.stack_max, memory.dynamic_base, memory.static_bump)

shared.Settings.DYNAMIC_BASE = memory.dynamic_base

return js

def apply_table(js):

js = js.replace('{{{ WASM_TABLE_SIZE }}}', str(shared.Settings.WASM_TABLE_SIZE))

return js

def apply_script_source(js):

js = js.replace('{{{ TARGET_BASENAME }}}', shared.Settings.TARGET_BASENAME)

return js

def memory_and_global_initializers(pre, metadata, mem_init):

if shared.Settings.SIMD == 1:

pre = open(path_from_root(os.path.join('src', 'ecmascript_simd.js'))).read() + '\n\n' + pre

staticbump = shared.Settings.STATIC_BUMP

pthread = ''

if shared.Settings.USE_PTHREADS:

pthread = 'if (!ENVIRONMENT_IS_PTHREAD)'

global_initializers = ''

if not shared.Settings.MINIMAL_RUNTIME:

# In traditional runtime, global initializers are pushed to the __ATINIT__ array to be processed when runtime is loaded

# In MINIMAL_RUNTIME global initializers are invoked directly off of the asm[''] export object, so this does not apply.

global_initializers = global_initializer_funcs(metadata['initializers'])

if len(global_initializers) > 0:

global_initializers = ', '.join('{ func: function() { %s() } }' % i for i in global_initializers)

global_initializers = '/* global initializers */ {pthread} __ATINIT__.push({global_initializers});'.format(pthread=pthread, global_initializers=global_initializers)

else:

global_initializers = '/* global initializers */ /*__ATINIT__.push();*/'

pre = pre.replace('STATICTOP = STATIC_BASE + 0;', '''\

STATICTOP = STATIC_BASE + {staticbump};

{global_initializers}

{mem_init}'''.format(staticbump=staticbump,

global_initializers=global_initializers,

mem_init=mem_init))

if shared.Settings.SIDE_MODULE:

pre = pre.replace('GLOBAL_BASE', 'gb')

pre = apply_memory(pre)

pre = apply_static_code_hooks(pre)

return pre

def get_js_funcs(pre, funcs):

funcs_js = [funcs]

parts = pre.split('// ASM_LIBRARY FUNCTIONS\n')

if len(parts) > 1:

pre = parts[0]

funcs_js.append(parts[1])

return pre, funcs_js

def get_all_exported_functions(function_table_data):

# both asm.js and otherwise

all_exported_functions = set(shared.Settings.EXPORTED_FUNCTIONS)

# additional functions to export from asm, if they are implemented

for additional_export in shared.Settings.DEFAULT_LIBRARY_FUNCS_TO_INCLUDE:

all_exported_functions.add('_' + additional_export)

if shared.Settings.EXPORT_FUNCTION_TABLES:

for table in function_table_data.values():

for func in table.split('[')[1].split(']')[0].split(','):

if func[0] == '_':

all_exported_functions.add(func)

return all_exported_functions

def get_all_implemented(forwarded_json, metadata):

return set(metadata['implementedFunctions']).union(forwarded_json['Functions']['implementedFunctions'])

def report_missing_symbols(all_implemented, pre):

# we are not checking anyway, so just skip this

if not shared.Settings.ERROR_ON_UNDEFINED_SYMBOLS and not shared.Settings.WARN_ON_UNDEFINED_SYMBOLS:

return

# the initial list of missing functions are that the user explicitly exported

# but were not implemented in compiled code

missing = list(set(shared.Settings.USER_EXPORTED_FUNCTIONS) - all_implemented)

for requested in missing:

if ('function ' + asstr(requested)) in pre:

continue

# special-case malloc, EXPORTED by default for internal use, but we bake in a

# trivial allocator and warn at runtime if used in ASSERTIONS

if missing == '_malloc':

continue

diagnostics.warning('undefined', 'undefined exported function: "%s"', requested)

# Handle main specially, unless IGNORE_MISSING_MAIN is set

if not shared.Settings.IGNORE_MISSING_MAIN:

if '_main' in shared.Settings.EXPORTED_FUNCTIONS and '_main' not in all_implemented:

# For compatibility with the output of wasm-ld we use the same wording here in our

# error message as if wasm-ld had failed (i.e. in LLD_REPORT_UNDEFINED mode).

exit_with_error('entry symbol not defined (pass --no-entry to suppress): main')

def get_exported_implemented_functions(all_exported_functions, all_implemented, metadata):

funcs = set(metadata['exports'])

export_bindings = shared.Settings.EXPORT_BINDINGS

export_all = shared.Settings.EXPORT_ALL

for key in all_implemented:

if key in all_exported_functions or export_all or (export_bindings and key.startswith('_emscripten_bind')):

funcs.add(key)

if not export_all:

for name, alias in metadata['aliases'].items():

# here we export the aliases,

# if not the side module (which imports the alias)

# will not be able to get to the actual implementation

if alias in all_implemented and name in all_exported_functions:

funcs.add(alias)

funcs = list(funcs) + global_initializer_funcs(metadata['initializers'])

if shared.Settings.ALLOW_MEMORY_GROWTH:

funcs.append('_emscripten_replace_memory')

if not shared.Settings.SIDE_MODULE and not shared.Settings.MINIMAL_RUNTIME:

funcs += ['stackAlloc', 'stackSave', 'stackRestore']

if shared.Settings.USE_PTHREADS:

funcs += ['asmJsEstablishStackFrame']

if shared.Settings.EMTERPRETIFY:

funcs += ['emterpret']

if shared.Settings.EMTERPRETIFY_ASYNC:

funcs += ['setAsyncState', 'emtStackSave', 'emtStackRestore', 'getEmtStackMax', 'setEmtStackMax']

return sorted(set(funcs))

def get_implemented_functions(metadata):

return set(metadata['implementedFunctions'])

def proxy_debug_print(sync):

if shared.Settings.PTHREADS_DEBUG:

if sync:

return 'warnOnce("sync proxying function " + code);'

else:

return 'warnOnce("async proxying function " + code);'

return ''

def include_asm_consts(pre, forwarded_json, metadata):

if shared.Settings.WASM and shared.Settings.SIDE_MODULE:

if metadata['asmConsts']:

exit_with_error('EM_ASM is not yet supported in shared wasm module (it cannot be stored in the wasm itself, need some solution)')

asm_consts, all_sigs = all_asm_consts(metadata)

asm_const_funcs = []

for sig, call_type in all_sigs:

if 'j' in sig:

exit_with_error('emscript: EM_ASM should not receive i64s as inputs, they are not valid in JS')

if '_emscripten_asm_const_' + call_type + sig in forwarded_json['Functions']['libraryFunctions']:

continue # Only one invoker needs to be emitted for each ASM_CONST (signature x call_type) item

forwarded_json['Functions']['libraryFunctions']['_emscripten_asm_const_' + call_type + sig] = 1

args = ['a%d' % i for i in range(len(sig) - 1)]

all_args = ['code'] + args

pre_asm_const = ''

if shared.Settings.USE_PTHREADS:

sync_proxy = call_type == 'sync_on_main_thread_'

async_proxy = call_type == 'async_on_main_thread_'

proxied = sync_proxy or async_proxy

if proxied: