#!/usr/bin/env python3

# Copyright 2011 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.

"""emcc - compiler helper script

=============================

emcc is a drop-in replacement for a compiler like gcc or clang.

See emcc --help for details.

emcc can be influenced by a few environment variables:

EMCC_DEBUG - "1" will log out useful information during compilation, as well as

save each compiler step as an emcc-* file in the temp dir

(by default /tmp/emscripten_temp). "2" will save additional emcc-*

steps, that would normally not be separately produced (so this

slows down compilation).

EMMAKEN_NO_SDK - Will tell emcc *not* to use the emscripten headers. Instead

your system headers will be used.

EMMAKEN_COMPILER - The compiler to be used, if you don't want the default clang.

"""

from __future__ import print_function

import json

import logging

import os

import re

import shlex

import shutil

import stat

import sys

import time

import base64

from subprocess import PIPE

import emscripten

from tools import shared, system_libs, client_mods, js_optimizer, jsrun, colored_logger

from tools.shared import unsuffixed, unsuffixed_basename, WINDOWS, safe_copy, safe_move, run_process, asbytes, read_and_preprocess, exit_with_error, DEBUG

from tools.response_file import substitute_response_files

from tools.minimal_runtime_shell import generate_minimal_runtime_html

import tools.line_endings

from tools.toolchain_profiler import ToolchainProfiler

if __name__ == '__main__':

ToolchainProfiler.record_process_start()

try:

from urllib.parse import quote

except ImportError:

# Python 2 compatibility

from urllib import quote

logger = logging.getLogger('emcc')

# endings = dot + a suffix, safe to test by filename.endswith(endings)

C_ENDINGS = ('.c', '.i')

CXX_ENDINGS = ('.cpp', '.cxx', '.cc', '.c++', '.CPP', '.CXX', '.C', '.CC', '.C++', '.ii')

OBJC_ENDINGS = ('.m', '.mi')

OBJCXX_ENDINGS = ('.mm', '.mii')

SPECIAL_ENDINGLESS_FILENAMES = ('/dev/null' if not WINDOWS else 'NUL',)

SOURCE_ENDINGS = C_ENDINGS + CXX_ENDINGS + OBJC_ENDINGS + OBJCXX_ENDINGS + SPECIAL_ENDINGLESS_FILENAMES

C_ENDINGS = C_ENDINGS + SPECIAL_ENDINGLESS_FILENAMES # consider the special endingless filenames like /dev/null to be C

JS_CONTAINING_ENDINGS = ('.js', '.mjs', '.html')

OBJECT_FILE_ENDINGS = ('.bc', '.o', '.obj', '.lo')

DYNAMICLIB_ENDINGS = ('.dylib', '.so') # Windows .dll suffix is not included in this list, since those are never linked to directly on the command line.

STATICLIB_ENDINGS = ('.a',)

ASSEMBLY_ENDINGS = ('.ll',)

HEADER_ENDINGS = ('.h', '.hxx', '.hpp', '.hh', '.H', '.HXX', '.HPP', '.HH')

WASM_ENDINGS = ('.wasm',)

SUPPORTED_LINKER_FLAGS = (

'--start-group', '--end-group',

'-(', '-)',

'--whole-archive', '--no-whole-archive',

'-whole-archive', '-no-whole-archive'

)

SUPPORTED_LLD_LINKER_FLAG_PREFIXES = (

'-l',

'-L',

'--trace-symbol',

'-debug',

'--export')

SUPPORTED_LLD_LINKER_FLAGS = (

'--fatal-warnings',

'--no-check-features',

'--trace',

'--no-threads',

'-mllvm'

)

LIB_PREFIXES = ('', 'lib')

DEFERRED_RESPONSE_FILES = ('EMTERPRETIFY_BLACKLIST', 'EMTERPRETIFY_WHITELIST', 'EMTERPRETIFY_SYNCLIST')

DEFAULT_ASYNCIFY_IMPORTS = [

'emscripten_sleep', 'emscripten_wget', 'emscripten_wget_data', 'emscripten_idb_load',

'emscripten_idb_store', 'emscripten_idb_delete', 'emscripten_idb_exists',

'emscripten_idb_load_blob', 'emscripten_idb_store_blob', 'SDL_Delay',

'emscripten_scan_registers', 'emscripten_lazy_load_code',

'emscripten_fiber_swap',

'wasi_snapshot_preview1.fd_sync', '__wasi_fd_sync']

# Mapping of emcc opt levels to llvm opt levels. We use llvm opt level 3 in emcc

# opt levels 2 and 3 (emcc 3 is unsafe opts, so unsuitable for the only level to

# get llvm opt level 3, and speed-wise emcc level 2 is already the slowest/most

# optimizing level)

LLVM_OPT_LEVEL = {

0: ['-O0'],

1: ['-O1'],

2: ['-O3'],

3: ['-O3'],

}

# Do not compile .ll files into .bc, just compile them with emscripten directly

# Not recommended, this is mainly for the test runner, or if you have some other

# specific need.

# One major limitation with this mode is that libc and libc++ cannot be

# added in. Also, LLVM optimizations will not be done, nor dead code elimination

LEAVE_INPUTS_RAW = int(os.environ.get('EMCC_LEAVE_INPUTS_RAW', '0'))

# If emcc is running with LEAVE_INPUTS_RAW and then launches an emcc to build

# something like the struct info, then we don't want LEAVE_INPUTS_RAW to be

# active in that emcc subprocess.

if LEAVE_INPUTS_RAW:

del os.environ['EMCC_LEAVE_INPUTS_RAW']

# Target options

final = None

UBSAN_SANITIZERS = {

'alignment',

'bool',

'builtin',

'bounds',

'enum',

'float-cast-overflow',

'float-divide-by-zero',

'function',

'implicit-unsigned-integer-truncation',

'implicit-signed-integer-truncation',

'implicit-integer-sign-change',

'integer-divide-by-zero',

'nonnull-attribute',

'null',

'nullability-arg',

'nullability-assign',

'nullability-return',

'object-size',

'pointer-overflow',

'return',

'returns-nonnull-attribute',

'shift',

'signed-integer-overflow',

'unreachable',

'unsigned-integer-overflow',

'vla-bound',

'vptr',

'undefined',

'undefined-trap',

'implicit-integer-truncation',

'implicit-integer-arithmetic-value-change',

'implicit-conversion',

'integer',

'nullability',

}

# this function uses the global 'final' variable, which contains the current

# final output file. if a method alters final, and calls this method, then it

# must modify final globally (i.e. it can't receive final as a param and

# return it)

# TODO: refactor all this, a singleton that abstracts over the final output

# and saving of intermediates

def save_intermediate(name, suffix='js'):

if not DEBUG:

return

if isinstance(final, list):

logger.debug('(not saving intermediate %s because deferring linking)' % name)

return

shared.Building.save_intermediate(final, name + '.' + suffix)

def save_intermediate_with_wasm(name, wasm_binary):

if not DEBUG:

return

save_intermediate(name) # save the js

shared.Building.save_intermediate(wasm_binary, name + '.wasm')

class TimeLogger(object):

last = time.time()

@staticmethod

def update():

TimeLogger.last = time.time()

def log_time(name):

"""Log out times for emcc stages"""

if DEBUG:

now = time.time()

logger.debug('emcc step "%s" took %.2f seconds', name, now - TimeLogger.last)

TimeLogger.update()

def base64_encode(b):

b64 = base64.b64encode(b)

if type(b64) == bytes:

return b64.decode('ascii')

else:

return b64

class EmccOptions(object):

def __init__(self):

self.requested_debug = ''

self.profiling = False

self.profiling_funcs = False

self.tracing = False

self.emit_symbol_map = False

self.js_opts = None

self.force_js_opts = False

self.llvm_opts = None

self.llvm_lto = None

self.use_closure_compiler = None

self.closure_args = []

self.js_transform = None

self.pre_js = '' # before all js

self.post_js = '' # after all js

self.preload_files = []

self.embed_files = []

self.exclude_files = []

self.ignore_dynamic_linking = False

self.shell_path = shared.path_from_root('src', 'shell.html')

self.source_map_base = ''

self.emrun = False

self.cpu_profiler = False

self.thread_profiler = False

self.memory_profiler = False

self.save_bc = False

self.memory_init_file = None

self.use_preload_cache = False

self.no_heap_copy = False

self.use_preload_plugins = False

self.proxy_to_worker = False

self.default_object_extension = '.o'

self.valid_abspaths = []

self.separate_asm = False

self.cfi = False

# Specifies the line ending format to use for all generated text files.

# Defaults to using the native EOL on each platform (\r\n on Windows, \n on

# Linux & MacOS)

self.output_eol = os.linesep

self.binaryen_passes = []

# Whether we will expand the full path of any input files to remove any

# symlinks.

self.expand_symlinks = True

def use_source_map(options):

return shared.Settings.DEBUG_LEVEL >= 4

def will_metadce(options):

return shared.Settings.OPT_LEVEL >= 3 or shared.Settings.SHRINK_LEVEL >= 1

class JSOptimizer(object):

def __init__(self, target, options, js_transform_tempfiles, in_temp):

self.queue = []

self.extra_info = {}

self.queue_history = []

self.blacklist = os.environ.get('EMCC_JSOPT_BLACKLIST', '').split(',')

self.minify_whitespace = False

self.cleanup_shell = False

self.target = target

self.emit_symbol_map = options.emit_symbol_map

self.profiling_funcs = options.profiling_funcs

self.use_closure_compiler = options.use_closure_compiler

self.closure_args = options.closure_args

self.js_transform_tempfiles = js_transform_tempfiles

self.in_temp = in_temp

def flush(self, title='js_opts'):

self.queue = [p for p in self.queue if p not in self.blacklist]

assert not shared.Settings.WASM_BACKEND, 'JSOptimizer should not run with pure wasm output'

if self.extra_info is not None and len(self.extra_info) == 0:

self.extra_info = None

if len(self.queue) and not(not shared.Settings.ASM_JS and len(self.queue) == 1 and self.queue[0] == 'last'):

passes = self.queue[:]

if DEBUG != 2 or len(passes) < 2:

# by assumption, our input is JS, and our output is JS. If a pass is going to run in the native optimizer in C++, then we

# must give it JSON and receive from it JSON

chunks = []

curr = []

for p in passes:

if len(curr) == 0:

curr.append(p)

else:

native = js_optimizer.use_native(p, source_map=use_source_map(self))

last_native = js_optimizer.use_native(curr[-1], source_map=use_source_map(self))

if native == last_native:

curr.append(p)

else:

curr.append('emitJSON')

chunks.append(curr)

curr = ['receiveJSON', p]

if len(curr):

chunks.append(curr)

if len(chunks) == 1:

self.run_passes(chunks[0], title, just_split=False, just_concat=False)

else:

for i, chunk in enumerate(chunks):

self.run_passes(chunk, 'js_opts_' + str(i),

just_split='receiveJSON' in chunk,

just_concat='emitJSON' in chunk)

else:

# DEBUG 2, run each pass separately

extra_info = self.extra_info

for p in passes:

self.queue = [p]

self.flush(p)

self.extra_info = extra_info # flush wipes it

log_time('part of js opts')

self.queue_history += self.queue

self.queue = []

self.extra_info = {}

def run_passes(self, passes, title, just_split, just_concat):

global final

passes = ['asm'] + passes

if shared.Settings.PRECISE_F32:

passes = ['asmPreciseF32'] + passes

if (self.emit_symbol_map or shared.Settings.CYBERDWARF) and 'minifyNames' in passes:

passes += ['symbolMap=' + shared.replace_or_append_suffix(self.target, '.symbols')]

if self.profiling_funcs and 'minifyNames' in passes:

passes += ['profilingFuncs']

if self.minify_whitespace and 'last' in passes:

passes += ['minifyWhitespace']

if self.cleanup_shell and 'last' in passes:

passes += ['cleanup']

logger.debug('applying js optimization passes: %s', ' '.join(passes))

final = shared.Building.js_optimizer(final, passes, use_source_map(self),

self.extra_info, just_split=just_split,

just_concat=just_concat,

output_filename=self.in_temp(os.path.basename(final) + '.jsopted.js'),

extra_closure_args=self.closure_args)

self.js_transform_tempfiles.append(final)

save_intermediate(title, suffix='js' if 'emitJSON' not in passes else 'json')

def do_minify(self):

"""minifies the code.

this is also when we do certain optimizations that must be done right before or after minification

"""

if shared.Settings.OPT_LEVEL >= 2:

if shared.Settings.DEBUG_LEVEL < 2 and not self.use_closure_compiler == 2:

self.queue += ['minifyNames']

if shared.Settings.DEBUG_LEVEL == 0:

self.minify_whitespace = True

if self.use_closure_compiler == 1:

self.queue += ['closure']

elif shared.Settings.DEBUG_LEVEL <= 2 and shared.Settings.FINALIZE_ASM_JS and not self.use_closure_compiler:

self.cleanup_shell = True

def embed_memfile(options):

return (shared.Settings.SINGLE_FILE or

(shared.Settings.MEM_INIT_METHOD == 0 and

(not shared.Settings.MAIN_MODULE and

not shared.Settings.SIDE_MODULE and

not use_source_map(options))))

def apply_settings(changes):

"""Take a list of settings in form `NAME=VALUE` and apply them to the global

Settings object.

"""

def standardize_setting_change(key, value):

# boolean NO_X settings are aliases for X

# (note that *non*-boolean setting values have special meanings,

# and we can't just flip them, so leave them as-is to be

# handled in a special way later)

if key.startswith('NO_') and value in ('0', '1'):

key = key[3:]

value = str(1 - int(value))

return key, value

for change in changes:

key, value = change.split('=', 1)

key, value = standardize_setting_change(key, value)

if key in shared.Settings.internal_settings:

exit_with_error('%s is an internal setting and cannot be set from command line', key)

# map legacy settings which have aliases to the new names

# but keep the original key so errors are correctly reported via the `setattr` below

user_key = key

if key in shared.Settings.legacy_settings and key in shared.Settings.alt_names:

key = shared.Settings.alt_names[key]

# In those settings fields that represent amount of memory, translate suffixes to multiples of 1024.

if key in ('TOTAL_STACK', 'INITIAL_MEMORY', 'MEMORY_GROWTH_LINEAR_STEP', 'MEMORY_GROWTH_GEOMETRIC_STEP',

'GL_MAX_TEMP_BUFFER_SIZE', 'MAXIMUM_MEMORY', 'DEFAULT_PTHREAD_STACK_SIZE'):

value = str(shared.expand_byte_size_suffixes(value))

if value[0] == '@':

if key not in DEFERRED_RESPONSE_FILES:

value = open(value[1:]).read()

else:

value = value.replace('\\', '\\\\')

try:

value = parse_value(value)

except Exception as e:

exit_with_error('a problem occured in evaluating the content after a "-s", specifically "%s": %s', change, str(e))

setattr(shared.Settings, user_key, value)

if shared.Settings.WASM_BACKEND and key == 'BINARYEN_TRAP_MODE':

exit_with_error('BINARYEN_TRAP_MODE is not supported by the LLVM wasm backend')

if key == 'EXPORTED_FUNCTIONS':

# used for warnings in emscripten.py

shared.Settings.USER_EXPORTED_FUNCTIONS = shared.Settings.EXPORTED_FUNCTIONS[:]

# TODO(sbc): Remove this legacy way.

if key == 'WASM_OBJECT_FILES':

shared.Settings.LTO = 0 if value else 'full'

def find_output_arg(args):

"""Find and remove any -o arguments. The final one takes precedence.

Return the final -o target along with the remaining (non-o) arguments.

"""

outargs = []

specified_target = None

use_next = False

for arg in args:

if use_next:

specified_target = arg

use_next = False

continue

if arg == '-o':

use_next = True

elif arg.startswith('-o'):

specified_target = arg[2:]

else:

outargs.append(arg)

return specified_target, outargs

def do_emscripten(infile, memfile):

# Run Emscripten

outfile = infile + '.o.js'

with ToolchainProfiler.profile_block('emscripten.py'):

emscripten.run(infile, outfile, memfile)

# Detect compilation crashes and errors

assert os.path.exists(outfile), 'Emscripten failed to generate .js'

return outfile

def is_ar_file_with_missing_index(archive_file):

# We parse the archive header outselves because llvm-nm --print-armap is slower and less

# reliable.

# See: https://github.com/emscripten-core/emscripten/issues/10195

archive_header = b'!<arch>\n'

file_header_size = 60

with open(archive_file, 'rb') as f:

header = f.read(len(archive_header))

if header != archive_header:

# This is not even an ar file

return False

file_header = f.read(file_header_size)

if len(file_header) != file_header_size:

# We don't have any file entires at all so we don't consider the index missing

return False

name = file_header[:16].strip()

# If '/' is the name of the first file we have an index

return name != b'/'

def ensure_archive_index(archive_file):

# Fastcomp linking works without archive indexes.

if not shared.Settings.WASM_BACKEND or not shared.Settings.AUTO_ARCHIVE_INDEXES:

return

if is_ar_file_with_missing_index(archive_file):

shared.warning('%s: archive is missing an index; Use emar when creating libraries to ensure an index is created', archive_file)

shared.warning('%s: adding index', archive_file)

run_process([shared.LLVM_RANLIB, archive_file])

def get_all_js_library_funcs(temp_files):

# Runs the js compiler to generate a list of all functions available in the JS

# libraries. This must be done separately for each linker invokation since the

# list of library functions depends on what settings are used.

# TODO(sbc): Find a way to optimize this. Potentially we could add a super-set

# mode of the js compiler that would generate a list of all possible symbols

# that could be checked in.

old_full = shared.Settings.INCLUDE_FULL_LIBRARY

old_linkable = shared.Settings.LINKABLE

try:

# Temporarily define INCLUDE_FULL_LIBRARY since we want a full list

# of all available JS library functions.

shared.Settings.INCLUDE_FULL_LIBRARY = True

# Temporarily set LINKABLE so that the jscompiler doesn't report

# undefined symbolls itself.

shared.Settings.LINKABLE = True

emscripten.generate_struct_info()

glue, forwarded_data = emscripten.compile_settings(temp_files)

forwarded_json = json.loads(forwarded_data)

library_fns = forwarded_json['Functions']['libraryFunctions']

library_fns_list = []

for name in library_fns:

if shared.is_c_symbol(name):

name = shared.demangle_c_symbol_name(name)

library_fns_list.append(name)

# TODO(sbc): wasm-ld shouldn't be reporting errors for symbols

# such as __wasi_fd_write which are defined with import_name attibutes

# but it currently does. Remove this once we fix wasm-ld.

library_fns_list.append('__wasi_' + name)

finally:

shared.Settings.INCLUDE_FULL_LIBRARY = old_full

shared.Settings.LINKABLE = old_linkable

return library_fns_list

#

# Main run() function

#

def run(args):

global final

target = None

# Additional compiler flags that we treat as if they were passed to us on the

# commandline

EMCC_CFLAGS = os.environ.get('EMCC_CFLAGS')

if DEBUG:

cmd = ' '.join(args)

if EMCC_CFLAGS:

cmd += ' + ' + EMCC_CFLAGS

logger.warning('invocation: ' + cmd + ' (in ' + os.getcwd() + ')')

if EMCC_CFLAGS:

args.extend(shlex.split(EMCC_CFLAGS))

# Strip args[0] (program name)

args = args[1:]

if DEBUG and LEAVE_INPUTS_RAW:

logger.warning('leaving inputs raw')

if '--emscripten-cxx' in args:

run_via_emxx = True

args = [x for x in args if x != '--emscripten-cxx']

else:

run_via_emxx = False

misc_temp_files = shared.configuration.get_temp_files()

# Handle some global flags

# read response files very early on

try:

args = substitute_response_files(args)

except IOError as e:

exit_with_error(e)

if '--help' in args:

# Documentation for emcc and its options must be updated in:

# site/source/docs/tools_reference/emcc.rst

# A prebuilt local version of the documentation is available at:

# site/build/text/docs/tools_reference/emcc.txt

# (it is read from there and printed out when --help is invoked)

# You can also build docs locally as HTML or other formats in site/

# An online HTML version (which may be of a different version of Emscripten)

# is up at http://kripken.github.io/emscripten-site/docs/tools_reference/emcc.html

with open(shared.path_from_root('site', 'build', 'text', 'docs', 'tools_reference', 'emcc.txt'), 'r') as f:

print(f.read())

print('''

------------------------------------------------------------------

emcc: supported targets: llvm bitcode, javascript, NOT elf

(autoconf likes to see elf above to enable shared object support)

''')

return 0

if '--version' in args:

# if the emscripten folder is not a git repo, don't run git show - that can

# look up and find the revision in a parent directory that is a git repo

revision = ''

if os.path.exists(shared.path_from_root('.git')):

revision = ' (' + run_process(['git', 'show'], stdout=PIPE, stderr=PIPE, cwd=shared.path_from_root()).stdout.splitlines()[0] + ')'

print('''emcc (Emscripten gcc/clang-like replacement) %s%s

Copyright (C) 2014 the Emscripten authors (see AUTHORS.txt)

This is free and open source software under the MIT license.

There is NO warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

''' % (shared.EMSCRIPTEN_VERSION, revision))

return 0

if len(args) == 1 and args[0] == '-v': # -v with no inputs

# autoconf likes to see 'GNU' in the output to enable shared object support

print('emcc (Emscripten gcc/clang-like replacement + linker emulating GNU ld) %s' % shared.EMSCRIPTEN_VERSION, file=sys.stderr)

code = run_process([shared.CLANG_CC, '-v'], check=False).returncode

shared.check_sanity(force=True)

return code

shared.check_sanity(force=DEBUG)

# This check comes after check_sanity because test_sanity expects this.

if not args:

logger.warning('no input files')

return 1

if '-dumpmachine' in args:

print(shared.get_llvm_target())

return 0

if '-dumpversion' in args: # gcc's doc states "Print the compiler version [...] and don't do anything else."

print(shared.EMSCRIPTEN_VERSION)

return 0

if '--cflags' in args:

# fake running the command, to see the full args we pass to clang

debug_env = os.environ.copy()

args = [x for x in args if x != '--cflags']

with misc_temp_files.get_file(suffix='.o') as temp_target:

input_file = 'hello_world.c'

cmd = [shared.PYTHON, sys.argv[0], shared.path_from_root('tests', input_file), '-v', '-c', '-o', temp_target] + args

proc = run_process(cmd, stderr=PIPE, env=debug_env, check=False)

if proc.returncode != 0:

print(proc.stderr)

exit_with_error('error getting cflags')

lines = [x for x in proc.stderr.splitlines() if shared.CLANG_CC in x and input_file in x]

parts = shlex.split(lines[0].replace('\\', '\\\\'))

parts = [x for x in parts if x not in ['-c', '-o', '-v', '-emit-llvm'] and input_file not in x and temp_target not in x]

print(' '.join(shared.Building.doublequote_spaces(parts[1:])))

return 0

# Default to using C++ even when run as `emcc`.

# This means that emcc will act as a C++ linker when no source files are

# specified. However, when a C source is specified we do default to C.

# This differs to clang and gcc where the default is always C unless run as

# clang++/g++.

use_cxx = True

def get_language_mode(args):

return_next = False

for item in args:

if return_next:

return item

if item == '-x':

return_next = True

continue

if item.startswith('-x'):

return item[2:]

return None

def has_c_source(args):

for a in args:

if a[0] != '-' and a.endswith(C_ENDINGS + OBJC_ENDINGS):

return True

return False

language_mode = get_language_mode(args)

has_fixed_language_mode = language_mode is not None

if language_mode == 'c':

use_cxx = False

if not has_fixed_language_mode:

if not run_via_emxx and has_c_source(args):

use_cxx = False

def is_minus_s_for_emcc(args, i):

# -s OPT=VALUE or -s OPT are interpreted as emscripten flags.

# -s by itself is a linker option (alias for --strip-all)

assert args[i] == '-s'

if len(args) > i + 1:

arg = args[i + 1]

if arg.split('=')[0].isupper():

return True

logger.debug('treating -s as linker option and not as -s OPT=VALUE for js compilation')

return False

# If this is a configure-type thing, do not compile to JavaScript, instead use clang

# to compile to a native binary (using our headers, so things make sense later)

CONFIGURE_CONFIG = (os.environ.get('EMMAKEN_JUST_CONFIGURE') or 'conftest.c' in args) and not os.environ.get('EMMAKEN_JUST_CONFIGURE_RECURSE')

CMAKE_CONFIG = 'CMakeFiles/cmTryCompileExec.dir' in ' '.join(args)# or 'CMakeCCompilerId' in ' '.join(args)

if CONFIGURE_CONFIG or CMAKE_CONFIG:

# XXX use this to debug configure stuff. ./configure's generally hide our

# normal output including stderr so we write to a file

debug_configure = 0

if debug_configure:

tempout = '/tmp/emscripten_temp/out'

if not os.path.exists(tempout):

open(tempout, 'w').write('//\n')

src = None

for arg in args:

if arg.endswith(SOURCE_ENDINGS):

try:

src = open(arg).read()

if debug_configure:

open(tempout, 'a').write('============= ' + arg + '\n' + src + '\n=============\n\n')

except IOError:

pass

# if CONFIGURE_CC is defined, use that. let's you use local gcc etc. if you need that

compiler = os.environ.get('CONFIGURE_CC') or shared.EMXX

if 'CXXCompiler' not in ' '.join(args) and not use_cxx:

compiler = shared.to_cc(compiler)

def filter_emscripten_options(argv):

skip_next = False

for idx, arg in enumerate(argv):

if skip_next:

skip_next = False

continue

if arg != '--tracing':

yield arg

if compiler in (shared.EMCC, shared.EMXX):

compiler = [shared.PYTHON, compiler]

else:

compiler = [compiler]

cmd = compiler + list(filter_emscripten_options(args))

# configure tests want a more shell-like style, where we emit return codes on exit()

cmd += ['-s', 'NO_EXIT_RUNTIME=0']

# use node.js raw filesystem access, to behave just like a native executable

cmd += ['-s', 'NODERAWFS=1']

logger.debug('just configuring: ' + ' '.join(cmd))

if debug_configure:

open(tempout, 'a').write('emcc, just configuring: ' + ' '.join(cmd) + '\n\n')

only_object = '-c' in cmd

for i in reversed(range(len(cmd) - 1)): # Last -o directive should take precedence, if multiple are specified

if cmd[i] == '-o':

if not only_object:

cmd[i + 1] += '.js'

target = cmd[i + 1]

break

if not target:

target = 'a.out.js'

os.environ['EMMAKEN_JUST_CONFIGURE_RECURSE'] = '1'

ret = run_process(cmd, check=False).returncode

os.environ['EMMAKEN_JUST_CONFIGURE_RECURSE'] = ''

if not os.path.exists(target):

# note that emcc -c will cause target to have the wrong value here;

# but then, we don't care about bitcode outputs anyhow, below, so

# skipping returning early is fine

return ret

if target.endswith('.js'):

shutil.copyfile(target, unsuffixed(target))

target = unsuffixed(target)

if not target.endswith(OBJECT_FILE_ENDINGS):

src = open(target).read()

full_node = ' '.join(shared.NODE_JS)

if os.path.sep not in full_node:

full_node = '/usr/bin/' + full_node # TODO: use whereis etc. And how about non-*NIX?

open(target, 'w').write('#!' + full_node + '\n' + src) # add shebang

try:

os.chmod(target, stat.S_IMODE(os.stat(target).st_mode) | stat.S_IXUSR) # make executable

except OSError:

pass # can fail if e.g. writing the executable to /dev/null

return ret

CXX = os.environ.get('EMMAKEN_COMPILER', shared.CLANG_CPP)

CC = shared.to_cc(CXX)

EMMAKEN_CFLAGS = os.environ.get('EMMAKEN_CFLAGS')

if EMMAKEN_CFLAGS:

args += shlex.split(EMMAKEN_CFLAGS)

# ---------------- Utilities ---------------

def suffix(name):

"""Return the file extension"""

return os.path.splitext(name)[1]

seen_names = {}

def uniquename(name):

if name not in seen_names:

seen_names[name] = str(len(seen_names))

return unsuffixed(name) + '_' + seen_names[name] + suffix(name)

# ---------------- End configs -------------

# Check if a target is specified on the command line

specified_target, args = find_output_arg(args)

# specified_target is the user-specified one, target is what we will generate

if specified_target:

target = specified_target

# check for the existence of the output directory now, to avoid having

# to do so repeatedly when each of the various output files (.mem, .wasm,

# etc) are written. This gives a more useful error message than the

# IOError and python backtrace that users would otherwise see.

dirname = os.path.dirname(target)

if dirname and not os.path.isdir(dirname):

exit_with_error("specified output file (%s) is in a directory that does not exist" % target)

else:

target = 'a.out.js'

shared.Settings.TARGET_BASENAME = target_basename = unsuffixed_basename(target)

final_suffix = suffix(target)

temp_dir = shared.get_emscripten_temp_dir()

def in_temp(name):

return os.path.join(temp_dir, os.path.basename(name))

def get_file_suffix(filename):

"""Parses the essential suffix of a filename, discarding Unix-style version

numbers in the name. For example for 'libz.so.1.2.8' returns '.so'"""

if filename in SPECIAL_ENDINGLESS_FILENAMES:

return filename

while filename:

filename, suffix = os.path.splitext(filename)

if not suffix[1:].isdigit():

return suffix

return ''

def optimizing(opts):

return '-O0' not in opts

def need_llvm_debug_info(options):

return shared.Settings.DEBUG_LEVEL >= 3 or shared.Settings.CYBERDWARF

with ToolchainProfiler.profile_block('parse arguments and setup'):

## Parse args

newargs = list(args)

# Scan and strip emscripten specific cmdline warning flags.

# This needs to run before other cmdline flags have been parsed, so that

# warnings are properly printed during arg parse.

newargs = shared.WarningManager.capture_warnings(newargs)

for i in range(len(newargs)):

if newargs[i] in ('-l', '-L', '-I'):

# Scan for individual -l/-L/-I arguments and concatenate the next arg on

# if there is no suffix

newargs[i] += newargs[i + 1]

newargs[i + 1] = ''

options, settings_changes, newargs = parse_args(newargs)

if use_cxx:

clang_compiler = CXX

else:

clang_compiler = CC

if '-print-search-dirs' in newargs:

return run_process([clang_compiler, '-print-search-dirs'], check=False).returncode

if options.emrun:

options.pre_js += open(shared.path_from_root('src', 'emrun_prejs.js')).read() + '\n'

options.post_js += open(shared.path_from_root('src', 'emrun_postjs.js')).read() + '\n'

# emrun mode waits on program exit

shared.Settings.EXIT_RUNTIME = 1

if options.cpu_profiler:

options.post_js += open(shared.path_from_root('src', 'cpuprofiler.js')).read() + '\n'

if options.memory_profiler:

shared.Settings.MEMORYPROFILER = 1

if options.thread_profiler:

options.post_js += open(shared.path_from_root('src', 'threadprofiler.js')).read() + '\n'

if options.js_opts is None:

options.js_opts = shared.Settings.OPT_LEVEL >= 2

if options.llvm_opts is None:

options.llvm_opts = LLVM_OPT_LEVEL[shared.Settings.OPT_LEVEL]

elif type(options.llvm_opts) == int:

options.llvm_opts = ['-O%d' % options.llvm_opts]

if options.memory_init_file is None:

options.memory_init_file = shared.Settings.OPT_LEVEL >= 2

# TODO: support source maps with js_transform

if options.js_transform and use_source_map(options):

logger.warning('disabling source maps because a js transform is being done')

shared.Settings.DEBUG_LEVEL = 3

if DEBUG:

start_time = time.time() # done after parsing arguments, which might affect debug state

for i in range(len(newargs)):

if newargs[i] == '-s':

if is_minus_s_for_emcc(newargs, i):

key = newargs[i + 1]

# If not = is specified default to 1

if '=' not in key:

key += '=1'

# Special handling of browser version targets. A version -1 means that the specific version

# is not supported at all. Replace those with INT32_MAX to make it possible to compare e.g.

# #if MIN_FIREFOX_VERSION < 68

try:

if re.match(r'MIN_.*_VERSION(=.*)?', key) and int(key.split('=')[1]) < 0:

key = key.split('=')[0] + '=0x7FFFFFFF'

except Exception:

pass

settings_changes.append(key)

newargs[i] = newargs[i + 1] = ''

newargs = [arg for arg in newargs if arg]

settings_key_changes = set()

for s in settings_changes:

key, value = s.split('=', 1)

settings_key_changes.add(key)

if key == 'WASM_BACKEND':

exit_with_error('do not set -s WASM_BACKEND, this is detected based on the llvm version in use')

# Find input files

# These three arrays are used to store arguments of different types for

# type-specific processing. In order to shuffle the arguments back together

# after processing, all of these arrays hold tuples (original_index, value).

# Note that the index part of the tuple can have a fractional part for input

# arguments that expand into multiple processed arguments, as in -Wl,-f1,-f2.

input_files = []

libs = []

link_flags = []

# All of the above arg lists entries contain indexes into the full argument

# list. In order to add extra implicit args (embind.cc, etc) below, we keep a

# counter for the next index that should be used.

next_arg_index = len(newargs)

has_source_inputs = False

has_header_inputs = False

lib_dirs = []

has_dash_c = '-c' in newargs

has_dash_S = '-S' in newargs

has_dash_E = '-E' in newargs

link_to_object = False

executable_endings = JS_CONTAINING_ENDINGS + ('.wasm',)

compile_only = has_dash_c or has_dash_S or has_dash_E

def add_link_flag(i, f):

# Filter out libraries that musl includes in libc itself, or which we

# otherwise provide implicitly.

if f in ('-lm', '-lrt', '-ldl', '-lpthread'):

return

if f.startswith('-l'):

libs.append((i, f[2:]))

if f.startswith('-L'):

lib_dirs.append(f[2:])

link_flags.append((i, f))

# find input files with a simple heuristic. we should really analyze

# based on a full understanding of gcc params, right now we just assume that

# what is left contains no more |-x OPT| things

for i in range(len(newargs)):

arg = newargs[i]

if i > 0:

prev = newargs[i - 1]

if prev in ('-MT', '-MF', '-MQ', '-D', '-U', '-o', '-x',

'-Xpreprocessor', '-include', '-imacros', '-idirafter',

'-iprefix', '-iwithprefix', '-iwithprefixbefore',

'-isysroot', '-imultilib', '-A', '-isystem', '-iquote',

'-install_name', '-compatibility_version',

'-current_version', '-I', '-L', '-include-pch'):

continue # ignore this gcc-style argument

if options.expand_symlinks and os.path.islink(arg) and get_file_suffix(os.path.realpath(arg)) in SOURCE_ENDINGS + OBJECT_FILE_ENDINGS + DYNAMICLIB_ENDINGS + ASSEMBLY_ENDINGS + HEADER_ENDINGS:

arg = os.path.realpath(arg)

if not arg.startswith('-'):