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

from .toolchain_profiler import ToolchainProfiler

import json

import logging

import os

import re

import shlex

import shutil

import subprocess

import sys

import tempfile

from subprocess import PIPE

from . import diagnostics

from . import response_file

from . import shared

from . import webassembly

from . import config

from .shared import CLANG_CC, CLANG_CXX, PYTHON

from .shared import LLVM_NM, EMCC, EMAR, EMXX, EMRANLIB, WASM_LD, LLVM_AR

from .shared import LLVM_LINK, LLVM_OBJCOPY

from .shared import try_delete, run_process, check_call, exit_with_error

from .shared import configuration, path_from_root

from .shared import asmjs_mangle, DEBUG

from .shared import TEMP_DIR

from .shared import CANONICAL_TEMP_DIR, LLVM_DWARFDUMP, demangle_c_symbol_name

from .shared import get_emscripten_temp_dir, exe_suffix, is_c_symbol

from .utils import WINDOWS

from .settings import settings

logger = logging.getLogger('building')

# Building

binaryen_checked = False

EXPECTED_BINARYEN_VERSION = 101

# cache results of nm - it can be slow to run

nm_cache = {}

# Stores the object files contained in different archive files passed as input

ar_contents = {}

_is_ar_cache = {}

# the exports the user requested

user_requested_exports = set()

class ObjectFileInfo:

def __init__(self, returncode, output, defs=set(), undefs=set(), commons=set()):

self.returncode = returncode

self.output = output

self.defs = defs

self.undefs = undefs

self.commons = commons

def is_valid_for_nm(self):

return self.returncode == 0

# llvm-ar appears to just use basenames inside archives. as a result, files

# with the same basename will trample each other when we extract them. to help

# warn of such situations, we warn if there are duplicate entries in the

# archive

def warn_if_duplicate_entries(archive_contents, archive_filename):

if len(archive_contents) != len(set(archive_contents)):

msg = '%s: archive file contains duplicate entries. This is not supported by emscripten. Only the last member with a given name will be linked in which can result in undefined symbols. You should either rename your source files, or use `emar` to create you archives which works around this issue.' % archive_filename

warned = set()

for i in range(len(archive_contents)):

curr = archive_contents[i]

if curr not in warned and curr in archive_contents[i + 1:]:

msg += '\n duplicate: %s' % curr

warned.add(curr)

diagnostics.warning('emcc', msg)

# Extracts the given list of archive files and outputs their contents

def extract_archive_contents(archive_files):

archive_results = shared.run_multiple_processes([[LLVM_AR, 't', a] for a in archive_files], pipe_stdout=True)

unpack_temp_dir = tempfile.mkdtemp('_archive_contents', 'emscripten_temp_')

def clean_at_exit():

try_delete(unpack_temp_dir)

shared.atexit.register(clean_at_exit)

archive_contents = []

for i in range(len(archive_results)):

a = archive_results[i]

contents = [l for l in a.splitlines() if len(l)]

if len(contents) == 0:

logger.debug('Archive %s appears to be empty (recommendation: link an .so instead of .a)' % a)

# `ar` files can only contains filenames. Just to be sure, verify that each

# file has only as filename component and is not absolute

for f in contents:

assert not os.path.dirname(f)

assert not os.path.isabs(f)

warn_if_duplicate_entries(contents, a)

archive_contents += [{

'archive_name': archive_files[i],

'o_files': [os.path.join(unpack_temp_dir, c) for c in contents]

}]

shared.run_multiple_processes([[LLVM_AR, 'xo', a] for a in archive_files], cwd=unpack_temp_dir)

# check that all files were created

for a in archive_contents:

missing_contents = [x for x in a['o_files'] if not os.path.exists(x)]

if missing_contents:

exit_with_error(f'llvm-ar failed to extract file(s) {missing_contents} from archive file {f}!')

return archive_contents

def unique_ordered(values):

"""return a list of unique values in an input list, without changing order

(list(set(.)) would change order randomly).

"""

seen = set()

def check(value):

if value in seen:

return False

seen.add(value)

return True

return [v for v in values if check(v)]

# clear caches. this is not normally needed, except if the clang/LLVM

# used changes inside this invocation of Building, which can happen in the benchmarker

# when it compares different builds.

def clear():

nm_cache.clear()

ar_contents.clear()

_is_ar_cache.clear()

# .. but for Popen, we cannot have doublequotes, so provide functionality to

# remove them when needed.

def remove_quotes(arg):

if isinstance(arg, list):

return [remove_quotes(a) for a in arg]

if arg.startswith('"') and arg.endswith('"'):

return arg[1:-1].replace('\\"', '"')

elif arg.startswith("'") and arg.endswith("'"):

return arg[1:-1].replace("\\'", "'")

else:

return arg

def get_building_env():

env = os.environ.copy()

# point CC etc. to the em* tools.

env['CC'] = EMCC

env['CXX'] = EMXX

env['AR'] = EMAR

env['LD'] = EMCC

env['NM'] = LLVM_NM

env['LDSHARED'] = EMCC

env['RANLIB'] = EMRANLIB

env['EMSCRIPTEN_TOOLS'] = path_from_root('tools')

env['HOST_CC'] = CLANG_CC

env['HOST_CXX'] = CLANG_CXX

env['HOST_CFLAGS'] = '-W' # if set to nothing, CFLAGS is used, which we don't want

env['HOST_CXXFLAGS'] = '-W' # if set to nothing, CXXFLAGS is used, which we don't want

env['PKG_CONFIG_LIBDIR'] = shared.Cache.get_sysroot_dir('local', 'lib', 'pkgconfig') + os.path.pathsep + shared.Cache.get_sysroot_dir('lib', 'pkgconfig')

env['PKG_CONFIG_PATH'] = os.environ.get('EM_PKG_CONFIG_PATH', '')

env['EMSCRIPTEN'] = path_from_root()

env['PATH'] = shared.Cache.get_sysroot_dir('bin') + os.pathsep + env['PATH']

env['CROSS_COMPILE'] = path_from_root('em') # produces /path/to/emscripten/em , which then can have 'cc', 'ar', etc appended to it

return env

# Returns a clone of the given environment with all directories that contain

# sh.exe removed from the PATH. Used to work around CMake limitation with

# MinGW Makefiles, where sh.exe is not allowed to be present.

def remove_sh_exe_from_path(env):

# Should only ever be called on WINDOWS

assert WINDOWS

env = env.copy()

path = env['PATH'].split(';')

path = [p for p in path if not os.path.exists(os.path.join(p, 'sh.exe'))]

env['PATH'] = ';'.join(path)

return env

def make_paths_absolute(f):

if f.startswith('-'): # skip flags

return f

else:

return os.path.abspath(f)

# Runs llvm-nm for the given list of files.

# The results are populated in nm_cache

@ToolchainProfiler.profile_block('llvm_nm_multiple')

def llvm_nm_multiple(files):

if len(files) == 0:

return []

# Run llvm-nm on files that we haven't cached yet

llvm_nm_files = [f for f in files if f not in nm_cache]

# We can issue multiple files in a single llvm-nm calls, but only if those

# files are all .o or .bc files. Because of llvm-nm output format, we cannot

# llvm-nm multiple .a files in one call, but those must be individually checked.

a_files = [f for f in llvm_nm_files if is_ar(f)]

o_files = [f for f in llvm_nm_files if f not in a_files]

# Issue parallel calls for .a files

if len(a_files) > 0:

results = shared.run_multiple_processes([[LLVM_NM, a] for a in a_files], pipe_stdout=True, check=False)

for i in range(len(results)):

nm_cache[a_files[i]] = parse_symbols(results[i])

# Issue a single batch call for multiple .o files

if len(o_files) > 0:

cmd = [LLVM_NM] + o_files

cmd = get_command_with_possible_response_file(cmd)

results = run_process(cmd, stdout=PIPE, stderr=PIPE, check=False)

# If one or more of the input files cannot be processed, llvm-nm will return a non-zero error code, but it will still process and print

# out all the other files in order. So even if process return code is non zero, we should always look at what we got to stdout.

if results.returncode != 0:

logger.debug(f'Subcommand {" ".join(cmd)} failed with return code {results.returncode}! (An input file was corrupt?)')

results = results.stdout

# llvm-nm produces a single listing of form

# file1.o:

# 00000001 T __original_main

# U __stack_pointer

#

# file2.o:

# 0000005d T main

# U printf

#

# ...

# so loop over the report to extract the results

# for each individual file.

filename = o_files[0]

# When we dispatched more than one file, we must manually parse

# the file result delimiters (like shown structured above)

if len(o_files) > 1:

file_start = 0

i = 0

while True:

nl = results.find('\n', i)

if nl < 0:

break

colon = results.rfind(':', i, nl)

if colon >= 0 and results[colon + 1] == '\n': # New file start?

nm_cache[filename] = parse_symbols(results[file_start:i - 1])

filename = results[i:colon].strip()

file_start = colon + 2

i = nl + 1

nm_cache[filename] = parse_symbols(results[file_start:])

else:

# We only dispatched a single file, so can parse all of the result directly

# to that file.

nm_cache[filename] = parse_symbols(results)

return [nm_cache[f] if f in nm_cache else ObjectFileInfo(1, '') for f in files]

def llvm_nm(file):

return llvm_nm_multiple([file])[0]

@ToolchainProfiler.profile_block('read_link_inputs')

def read_link_inputs(files):

# Before performing the link, we need to look at each input file to determine which symbols

# each of them provides. Do this in multiple parallel processes.

archive_names = [] # .a files passed in to the command line to the link

object_names = [] # .o/.bc files passed in to the command line to the link

for f in files:

absolute_path_f = make_paths_absolute(f)

if absolute_path_f not in ar_contents and is_ar(absolute_path_f):

archive_names.append(absolute_path_f)

elif absolute_path_f not in nm_cache and is_bitcode(absolute_path_f):

object_names.append(absolute_path_f)

# Archives contain objects, so process all archives first in parallel to obtain the object files in them.

archive_contents = extract_archive_contents(archive_names)

for a in archive_contents:

ar_contents[os.path.abspath(a['archive_name'])] = a['o_files']

for o in a['o_files']:

if o not in nm_cache:

object_names.append(o)

# Next, extract symbols from all object files (either standalone or inside archives we just extracted)

# The results are not used here directly, but populated to llvm-nm cache structure.

llvm_nm_multiple(object_names)

def llvm_backend_args():

# disable slow and relatively unimportant optimization passes

args = ['-combiner-global-alias-analysis=false']

# asm.js-style exception handling

if not settings.DISABLE_EXCEPTION_CATCHING:

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

if settings.EXCEPTION_CATCHING_ALLOWED:

# When 'main' has a non-standard signature, LLVM outlines its content out to

# '__original_main'. So we add it to the allowed list as well.

if 'main' in settings.EXCEPTION_CATCHING_ALLOWED:

settings.EXCEPTION_CATCHING_ALLOWED += ['__original_main']

allowed = ','.join(settings.EXCEPTION_CATCHING_ALLOWED)

args += ['-emscripten-cxx-exceptions-allowed=' + allowed]

if settings.SUPPORT_LONGJMP:

# asm.js-style setjmp/longjmp handling

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

# better (smaller, sometimes faster) codegen, see binaryen#1054

# and https://bugs.llvm.org/show_bug.cgi?id=39488

args += ['-disable-lsr']

return args

@ToolchainProfiler.profile_block('linking to object file')

def link_to_object(args, target):

# link using lld unless LTO is requested (lld can't output LTO/bitcode object files).

if not settings.LTO:

link_lld(args + ['--relocatable'], target)

else:

link_bitcode(args, target)

def link_llvm(linker_inputs, target):

# runs llvm-link to link things.

cmd = [LLVM_LINK] + linker_inputs + ['-o', target]

cmd = get_command_with_possible_response_file(cmd)

check_call(cmd)

def lld_flags_for_executable(external_symbols):

cmd = []

if external_symbols:

undefs = configuration.get_temp_files().get('.undefined').name

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

f.write('\n'.join(external_symbols))

cmd.append('--allow-undefined-file=%s' % undefs)

else:

cmd.append('--allow-undefined')

if settings.IMPORTED_MEMORY:

cmd.append('--import-memory')

if settings.USE_PTHREADS:

cmd.append('--shared-memory')

if settings.MEMORY64:

cmd.append('-mwasm64')

# wasm-ld can strip debug info for us. this strips both the Names

# section and DWARF, so we can only use it when we don't need any of

# those things.

if settings.DEBUG_LEVEL < 2 and (not settings.EMIT_SYMBOL_MAP and

not settings.PROFILING_FUNCS and

not settings.ASYNCIFY):

cmd.append('--strip-debug')

if settings.LINKABLE:

cmd.append('--export-all')

cmd.append('--no-gc-sections')

else:

c_exports = [e for e in settings.EXPORTED_FUNCTIONS if is_c_symbol(e)]

# Strip the leading underscores

c_exports = [demangle_c_symbol_name(e) for e in c_exports]

if external_symbols:

# Filter out symbols external/JS symbols

c_exports = [e for e in c_exports if e not in external_symbols]

for export in c_exports:

cmd += ['--export', export]

for export in settings.EXPORT_IF_DEFINED:

cmd.append('--export-if-defined=' + export)

if settings.RELOCATABLE:

cmd.append('--experimental-pic')

if settings.SIDE_MODULE:

cmd.append('-shared')

else:

cmd.append('-pie')

if not settings.LINKABLE:

cmd.append('--no-export-dynamic')

else:

cmd.append('--export-table')

if settings.ALLOW_TABLE_GROWTH:

cmd.append('--growable-table')

if not settings.SIDE_MODULE:

# Export these two section start symbols so that we can extact the string

# data that they contain.

cmd += [

'-z', 'stack-size=%s' % settings.TOTAL_STACK,

'--initial-memory=%d' % settings.INITIAL_MEMORY,

]

if settings.STANDALONE_WASM:

# when settings.EXPECT_MAIN is set we fall back to wasm-ld default of _start

if not settings.EXPECT_MAIN:

cmd += ['--entry=_initialize']

else:

if settings.EXPECT_MAIN and not settings.IGNORE_MISSING_MAIN:

cmd += ['--entry=main']

else:

cmd += ['--no-entry']

if not settings.ALLOW_MEMORY_GROWTH:

cmd.append('--max-memory=%d' % settings.INITIAL_MEMORY)

elif settings.MAXIMUM_MEMORY != -1:

cmd.append('--max-memory=%d' % settings.MAXIMUM_MEMORY)

if not settings.RELOCATABLE:

cmd.append('--global-base=%s' % settings.GLOBAL_BASE)

return cmd

def link_lld(args, target, external_symbols=None):

if not os.path.exists(WASM_LD):

exit_with_error('linker binary not found in LLVM directory: %s', WASM_LD)

# runs lld to link things.

# lld doesn't currently support --start-group/--end-group since the

# semantics are more like the windows linker where there is no need for

# grouping.

args = [a for a in args if a not in ('--start-group', '--end-group')]

# Emscripten currently expects linkable output (SIDE_MODULE/MAIN_MODULE) to

# include all archive contents.

if settings.LINKABLE:

args.insert(0, '--whole-archive')

args.append('--no-whole-archive')

if settings.STRICT:

args.append('--fatal-warnings')

cmd = [WASM_LD, '-o', target] + args

for a in llvm_backend_args():

cmd += ['-mllvm', a]

# Wasm exception handling. This is a CodeGen option for the LLVM backend, so

# wasm-ld needs to take this for the LTO mode.

# When wasm EH is enabled, we use the legacy pass manager because the new pass

# manager + wasm EH has some known bugs. See

# https://github.com/emscripten-core/emscripten/issues/14180.

# TODO Switch to the new pass manager.

if settings.EXCEPTION_HANDLING:

cmd += ['-mllvm', '-exception-model=wasm', '--lto-legacy-pass-manager']

# For relocatable output (generating an object file) we don't pass any of the

# normal linker flags that are used when building and exectuable

if '--relocatable' not in args and '-r' not in args:

cmd += lld_flags_for_executable(external_symbols)

cmd = get_command_with_possible_response_file(cmd)

check_call(cmd)

def link_bitcode(args, target, force_archive_contents=False):

# "Full-featured" linking: looks into archives (duplicates lld functionality)

input_files = [a for a in args if not a.startswith('-')]

files_to_link = []

# Tracking unresolveds is necessary for .a linking, see below.

# Specify all possible entry points to seed the linking process.

# For a simple application, this would just be "main".

unresolved_symbols = set([func[1:] for func in settings.EXPORTED_FUNCTIONS])

resolved_symbols = set()

# Paths of already included object files from archives.

added_contents = set()

has_ar = any(is_ar(make_paths_absolute(f)) for f in input_files)

# If we have only one archive or the force_archive_contents flag is set,

# then we will add every object file we see, regardless of whether it

# resolves any undefined symbols.

force_add_all = len(input_files) == 1 or force_archive_contents

# Considers an object file for inclusion in the link. The object is included

# if force_add=True or if the object provides a currently undefined symbol.

# If the object is included, the symbol tables are updated and the function

# returns True.

def consider_object(f, force_add=False):

new_symbols = llvm_nm(f)

# Check if the object was valid according to llvm-nm. It also accepts

# native object files.

if not new_symbols.is_valid_for_nm():

diagnostics.warning('emcc', 'object %s is not valid according to llvm-nm, cannot link', f)

return False

# Check the object is valid for us, and not a native object file.

if not is_bitcode(f):

exit_with_error('unknown file type: %s', f)

provided = new_symbols.defs.union(new_symbols.commons)

do_add = force_add or not unresolved_symbols.isdisjoint(provided)

if do_add:

logger.debug('adding object %s to link (forced: %d)' % (f, force_add))

# Update resolved_symbols table with newly resolved symbols

resolved_symbols.update(provided)

# Update unresolved_symbols table by adding newly unresolved symbols and

# removing newly resolved symbols.

unresolved_symbols.update(new_symbols.undefs.difference(resolved_symbols))

unresolved_symbols.difference_update(provided)

files_to_link.append(f)

return do_add

# Traverse a single archive. The object files are repeatedly scanned for

# newly satisfied symbols until no new symbols are found. Returns true if

# any object files were added to the link.

def consider_archive(f, force_add):

added_any_objects = False

loop_again = True

logger.debug('considering archive %s' % (f))

contents = ar_contents[f]

while loop_again: # repeatedly traverse until we have everything we need

loop_again = False

for content in contents:

if content in added_contents:

continue

# Link in the .o if it provides symbols, *or* this is a singleton archive (which is

# apparently an exception in gcc ld)

if consider_object(content, force_add=force_add):

added_contents.add(content)

loop_again = True

added_any_objects = True

logger.debug('done running loop of archive %s' % (f))

return added_any_objects

read_link_inputs(input_files)

# Rescan a group of archives until we don't find any more objects to link.

def scan_archive_group(group):

loop_again = True

logger.debug('starting archive group loop')

while loop_again:

loop_again = False

for archive in group:

if consider_archive(archive, force_add=False):

loop_again = True

logger.debug('done with archive group loop')

current_archive_group = None

in_whole_archive = False

for a in args:

if a.startswith('-'):

if a in ['--start-group', '-(']:

assert current_archive_group is None, 'Nested --start-group, missing --end-group?'

current_archive_group = []

elif a in ['--end-group', '-)']:

assert current_archive_group is not None, '--end-group without --start-group'

scan_archive_group(current_archive_group)

current_archive_group = None

elif a in ['--whole-archive', '-whole-archive']:

in_whole_archive = True

elif a in ['--no-whole-archive', '-no-whole-archive']:

in_whole_archive = False

else:

# Command line flags should already be vetted by the time this method

# is called, so this is an internal error

exit_with_error('unsupported link flag: %s', a)

else:

lib_path = make_paths_absolute(a)

if is_ar(lib_path):

# Extract object files from ar archives, and link according to gnu ld semantics

# (link in an entire .o from the archive if it supplies symbols still unresolved)

consider_archive(lib_path, in_whole_archive or force_add_all)

# If we're inside a --start-group/--end-group section, add to the list

# so we can loop back around later.

if current_archive_group is not None:

current_archive_group.append(lib_path)

elif is_bitcode(lib_path):

if has_ar:

consider_object(a, force_add=True)

else:

# If there are no archives then we can simply link all valid object

# files and skip the symbol table stuff.

files_to_link.append(a)

else:

exit_with_error('unknown file type: %s', a)

# We have to consider the possibility that --start-group was used without a matching

# --end-group; GNU ld permits this behavior and implicitly treats the end of the

# command line as having an --end-group.

if current_archive_group:

logger.debug('--start-group without matching --end-group, rescanning')

scan_archive_group(current_archive_group)

current_archive_group = None

try_delete(target)

# Finish link

# tolerate people trying to link a.so a.so etc.

files_to_link = unique_ordered(files_to_link)

logger.debug('emcc: linking: %s to %s', files_to_link, target)

link_llvm(files_to_link, target)

def get_command_with_possible_response_file(cmd):

# 8k is a bit of an arbitrary limit, but a reasonable one

# for max command line size before we use a response file

if len(' '.join(cmd)) <= 8192:

return cmd

logger.debug('using response file for %s' % cmd[0])

filename = response_file.create_response_file(cmd[1:], TEMP_DIR)

new_cmd = [cmd[0], "@" + filename]

return new_cmd

def parse_symbols(output):

defs = []

undefs = []

commons = []

for line in output.split('\n'):

if not line or line[0] == '#':

continue

# e.g. filename.o: , saying which file it's from

if ':' in line:

continue

parts = [seg for seg in line.split(' ') if len(seg)]

# pnacl-nm will print zero offsets for bitcode, and newer llvm-nm will print present symbols

# as -------- T name

if len(parts) == 3 and parts[0] == "--------" or re.match(r'^[\da-f]{8}$', parts[0]):

parts.pop(0)

if len(parts) == 2:

# ignore lines with absolute offsets, these are not bitcode anyhow

# e.g. |00000630 t d_source_name|

status, symbol = parts

if status == 'U':

undefs.append(symbol)

elif status == 'C':

commons.append(symbol)

elif status == status.upper():

# FIXME: using WTD in the previous line fails due to llvm-nm behavior on macOS,

# so for now we assume all uppercase are normally defined external symbols

defs.append(symbol)

return ObjectFileInfo(0, None, set(defs), set(undefs), set(commons))

def emar(action, output_filename, filenames, stdout=None, stderr=None, env=None):

try_delete(output_filename)

response_filename = response_file.create_response_file(filenames, TEMP_DIR)

cmd = [EMAR, action, output_filename] + ['@' + response_filename]

try:

run_process(cmd, stdout=stdout, stderr=stderr, env=env)

finally:

try_delete(response_filename)

if 'c' in action:

assert os.path.exists(output_filename), 'emar could not create output file: ' + output_filename

def opt_level_to_str(opt_level, shrink_level=0):

# convert opt_level/shrink_level pair to a string argument like -O1

if opt_level == 0:

return '-O0'

if shrink_level == 1:

return '-Os'

elif shrink_level >= 2:

return '-Oz'

else:

return f'-O{min(opt_level, 3)}'

def js_optimizer(filename, passes):

from . import js_optimizer

try:

return js_optimizer.run(filename, passes)

except subprocess.CalledProcessError as e:

exit_with_error("'%s' failed (%d)", ' '.join(e.cmd), e.returncode)

# run JS optimizer on some JS, ignoring asm.js contents if any - just run on it all

def acorn_optimizer(filename, passes, extra_info=None, return_output=False):

optimizer = path_from_root('tools', 'acorn-optimizer.js')

original_filename = filename

if extra_info is not None:

temp_files = configuration.get_temp_files()

temp = temp_files.get('.js').name

shutil.copyfile(filename, temp)

with open(temp, 'a') as f:

f.write('// EXTRA_INFO: ' + extra_info)

filename = temp

cmd = config.NODE_JS + [optimizer, filename] + passes

# Keep JS code comments intact through the acorn optimization pass so that JSDoc comments

# will be carried over to a later Closure run.

if settings.USE_CLOSURE_COMPILER:

cmd += ['--closureFriendly']

if settings.VERBOSE:

cmd += ['verbose']

if not return_output:

next = original_filename + '.jso.js'

configuration.get_temp_files().note(next)

check_call(cmd, stdout=open(next, 'w'))

save_intermediate(next, '%s.js' % passes[0])

return next

output = check_call(cmd, stdout=PIPE).stdout

return output

# evals ctors. if binaryen_bin is provided, it is the dir of the binaryen tool

# for this, and we are in wasm mode

def eval_ctors(js_file, binary_file, debug_info=False): # noqa

logger.debug('Ctor evalling in the wasm backend is disabled due to https://github.com/emscripten-core/emscripten/issues/9527')

return

# TODO re-enable

# cmd = [PYTHON, path_from_root('tools', 'ctor_evaller.py'), js_file, binary_file, str(settings.INITIAL_MEMORY), str(settings.TOTAL_STACK), str(settings.GLOBAL_BASE), binaryen_bin, str(int(debug_info))]

# if binaryen_bin:

# cmd += get_binaryen_feature_flags()

# check_call(cmd)

def get_closure_compiler():

# First check if the user configured a specific CLOSURE_COMPILER in thier settings

if config.CLOSURE_COMPILER:

return shared.CLOSURE_COMPILER

# Otherwise use the one installed vai npm

cmd = shared.get_npm_cmd('google-closure-compiler')

if not WINDOWS:

# Work around an issue that Closure compiler can take up a lot of memory and crash in an error

# "FATAL ERROR: Ineffective mark-compacts near heap limit Allocation failed - JavaScript heap

# out of memory"

cmd.insert(-1, '--max_old_space_size=8192')

return cmd

def check_closure_compiler(cmd, args, env, allowed_to_fail):

try:

output = run_process(cmd + args + ['--version'], stdout=PIPE, env=env).stdout

except Exception as e:

if allowed_to_fail:

return False

logger.warn(str(e))

exit_with_error('closure compiler ("%s --version") did not execute properly!' % str(cmd))

if 'Version:' not in output:

if allowed_to_fail:

return False

exit_with_error('unrecognized closure compiler --version output (%s):\n%s' % (str(cmd), output))

return True

@ToolchainProfiler.profile_block('closure_compiler')

def closure_compiler(filename, pretty, advanced=True, extra_closure_args=None):

env = shared.env_with_node_in_path()

user_args = []

env_args = os.environ.get('EMCC_CLOSURE_ARGS')

if env_args:

user_args += shlex.split(env_args)

if extra_closure_args:

user_args += extra_closure_args

# Closure compiler expects JAVA_HOME to be set *and* java.exe to be in the PATH in order

# to enable use the java backend. Without this it will only try the native and JavaScript

# versions of the compiler.

java_bin = os.path.dirname(config.JAVA)

if java_bin:

def add_to_path(dirname):

env['PATH'] = env['PATH'] + os.pathsep + dirname

add_to_path(java_bin)

java_home = os.path.dirname(java_bin)

env.setdefault('JAVA_HOME', java_home)

closure_cmd = get_closure_compiler()

native_closure_compiler_works = check_closure_compiler(closure_cmd, user_args, env, allowed_to_fail=True)

if not native_closure_compiler_works and not any(a.startswith('--platform') for a in user_args):

# Run with Java Closure compiler as a fallback if the native version does not work

user_args.append('--platform=java')

check_closure_compiler(closure_cmd, user_args, env, allowed_to_fail=False)

# Closure externs file contains known symbols to be extern to the minification, Closure

# should not minify these symbol names.

CLOSURE_EXTERNS = [path_from_root('src', 'closure-externs', 'closure-externs.js')]

# Closure compiler needs to know about all exports that come from the wasm module, because to optimize for small code size,

# the exported symbols are added to global scope via a foreach loop in a way that evades Closure's static analysis. With an explicit

# externs file for the exports, Closure is able to reason about the exports.

if settings.WASM_FUNCTION_EXPORTS and not settings.DECLARE_ASM_MODULE_EXPORTS:

# Generate an exports file that records all the exported symbols from the wasm module.

module_exports_suppressions = '\n'.join(['/**\n * @suppress {duplicate, undefinedVars}\n */\nvar %s;\n' % asmjs_mangle(i) for i in settings.WASM_FUNCTION_EXPORTS])

exports_file = configuration.get_temp_files().get('_module_exports.js')

exports_file.write(module_exports_suppressions.encode())

exports_file.close()

CLOSURE_EXTERNS += [exports_file.name]

# Node.js specific externs

if shared.target_environment_may_be('node'):

NODE_EXTERNS_BASE = path_from_root('third_party', 'closure-compiler', 'node-externs')

NODE_EXTERNS = os.listdir(NODE_EXTERNS_BASE)

NODE_EXTERNS = [os.path.join(NODE_EXTERNS_BASE, name) for name in NODE_EXTERNS

if name.endswith('.js')]

CLOSURE_EXTERNS += [path_from_root('src', 'closure-externs', 'node-externs.js')] + NODE_EXTERNS

# V8/SpiderMonkey shell specific externs

if shared.target_environment_may_be('shell'):

V8_EXTERNS = [path_from_root('src', 'closure-externs', 'v8-externs.js')]

SPIDERMONKEY_EXTERNS = [path_from_root('src', 'closure-externs', 'spidermonkey-externs.js')]

CLOSURE_EXTERNS += V8_EXTERNS + SPIDERMONKEY_EXTERNS

# Web environment specific externs

if shared.target_environment_may_be('web') or shared.target_environment_may_be('worker'):

BROWSER_EXTERNS_BASE = path_from_root('src', 'closure-externs', 'browser-externs')

if os.path.isdir(BROWSER_EXTERNS_BASE):

BROWSER_EXTERNS = os.listdir(BROWSER_EXTERNS_BASE)

BROWSER_EXTERNS = [os.path.join(BROWSER_EXTERNS_BASE, name) for name in BROWSER_EXTERNS

if name.endswith('.js')]

CLOSURE_EXTERNS += BROWSER_EXTERNS

if settings.MINIMAL_RUNTIME and settings.USE_PTHREADS and not settings.MODULARIZE:

CLOSURE_EXTERNS += [path_from_root('src', 'minimal_runtime_worker_externs.js')]

args = ['--compilation_level', 'ADVANCED_OPTIMIZATIONS' if advanced else 'SIMPLE_OPTIMIZATIONS']

# Keep in sync with ecmaVersion in tools/acorn-optimizer.js

args += ['--language_in', 'ECMASCRIPT_2020']

# Tell closure not to do any transpiling or inject any polyfills.

# At some point we may want to look into using this as way to convert to ES5 but

# babel is perhaps a better tool for that.

args += ['--language_out', 'NO_TRANSPILE']

# Tell closure never to inject the 'use strict' directive.

args += ['--emit_use_strict=false']

# Closure compiler is unable to deal with path names that are not 7-bit ASCII:

# https://github.com/google/closure-compiler/issues/3784

tempfiles = configuration.get_temp_files()

outfile = tempfiles.get('.cc.js').name # Safe 7-bit filename

def move_to_safe_7bit_ascii_filename(filename):

safe_filename = tempfiles.get('.js').name # Safe 7-bit filename

shutil.copyfile(filename, safe_filename)

return os.path.relpath(safe_filename, tempfiles.tmpdir)

for e in CLOSURE_EXTERNS:

args += ['--externs', move_to_safe_7bit_ascii_filename(e)]

for i in range(len(user_args)):

if user_args[i] == '--externs':

user_args[i + 1] = move_to_safe_7bit_ascii_filename(user_args[i + 1])

# Specify output file relative to the temp directory to avoid specifying non-7-bit-ASCII path names.

args += ['--js_output_file', os.path.relpath(outfile, tempfiles.tmpdir)]

if settings.IGNORE_CLOSURE_COMPILER_ERRORS:

args.append('--jscomp_off=*')

if pretty:

args += ['--formatting', 'PRETTY_PRINT']

# Specify input file relative to the temp directory to avoid specifying non-7-bit-ASCII path names.

args += ['--js', move_to_safe_7bit_ascii_filename(filename)]

cmd = closure_cmd + args + user_args

logger.debug('closure compiler: ' + ' '.join(cmd))

# Closure compiler does not work if any of the input files contain characters outside the

# 7-bit ASCII range. Therefore make sure the command line we pass does not contain any such

# input files by passing all input filenames relative to the cwd. (user temp directory might

# be in user's home directory, and user's profile name might contain unicode characters)

proc = run_process(cmd, stderr=PIPE, check=False, env=env, cwd=tempfiles.tmpdir)

# XXX Closure bug: if Closure is invoked with --create_source_map, Closure should create a

# outfile.map source map file (https://github.com/google/closure-compiler/wiki/Source-Maps)

# But it looks like it creates such files on Linux(?) even without setting that command line

# flag (and currently we don't), so delete the produced source map file to not leak files in

# temp directory.

try_delete(outfile + '.map')

# Print Closure diagnostics result up front.

if proc.returncode != 0:

logger.error('Closure compiler run failed:\n')

elif len(proc.stderr.strip()) > 0:

if settings.CLOSURE_WARNINGS == 'error':

logger.error('Closure compiler completed with warnings and -s CLOSURE_WARNINGS=error enabled, aborting!\n')

elif settings.CLOSURE_WARNINGS == 'warn':

logger.warn('Closure compiler completed with warnings:\n')

# Print input file (long wall of text!)

if DEBUG == 2 and (proc.returncode != 0 or (len(proc.stderr.strip()) > 0 and settings.CLOSURE_WARNINGS != 'quiet')):

input_file = open(filename, 'r').read().splitlines()

for i in range(len(input_file)):

sys.stderr.write(f'{i + 1}: {input_file[i]}\n')

if proc.returncode != 0:

logger.error(proc.stderr) # print list of errors (possibly long wall of text if input was minified)

# Exit and print final hint to get clearer output

msg = 'closure compiler failed (rc: %d): %s' % (proc.returncode, shared.shlex_join(cmd))

if not pretty:

msg += ' the error message may be clearer with -g1 and EMCC_DEBUG=2 set'

exit_with_error(msg)

if len(proc.stderr.strip()) > 0 and settings.CLOSURE_WARNINGS != 'quiet':

# print list of warnings (possibly long wall of text if input was minified)

if settings.CLOSURE_WARNINGS == 'error':

logger.error(proc.stderr)

else:

logger.warn(proc.stderr)

# Exit and/or print final hint to get clearer output

if not pretty:

logger.warn('(rerun with -g1 linker flag for an unminified output)')

elif DEBUG != 2:

logger.warn('(rerun with EMCC_DEBUG=2 enabled to dump Closure input file)')

if settings.CLOSURE_WARNINGS == 'error':

exit_with_error('closure compiler produced warnings and -s CLOSURE_WARNINGS=error enabled')

return outfile

# minify the final wasm+JS combination. this is done after all the JS

# and wasm optimizations; here we do the very final optimizations on them

def minify_wasm_js(js_file, wasm_file, expensive_optimizations, minify_whitespace, debug_info):

# start with JSDCE, to clean up obvious JS garbage. When optimizing for size,

# use AJSDCE (aggressive JS DCE, performs multiple iterations). Clean up

# whitespace if necessary too.

passes = []

if not settings.LINKABLE:

passes.append('JSDCE' if not expensive_optimizations else 'AJSDCE')

if minify_whitespace:

passes.append('minifyWhitespace')

if passes:

logger.debug('running cleanup on shell code: ' + ' '.join(passes))

js_file = acorn_optimizer(js_file, passes)

# if we can optimize this js+wasm combination under the assumption no one else

# will see the internals, do so

if not settings.LINKABLE:

# if we are optimizing for size, shrink the combined wasm+JS

# TODO: support this when a symbol map is used

if expensive_optimizations:

js_file = metadce(js_file, wasm_file, minify_whitespace=minify_whitespace, debug_info=debug_info)

# now that we removed unneeded communication between js and wasm, we can clean up

# the js some more.

passes = ['AJSDCE']

if minify_whitespace:

passes.append('minifyWhitespace')

logger.debug('running post-meta-DCE cleanup on shell code: ' + ' '.join(passes))

js_file = acorn_optimizer(js_file, passes)

if settings.MINIFY_WASM_IMPORTS_AND_EXPORTS:

js_file = minify_wasm_imports_and_exports(js_file, wasm_file, minify_whitespace=minify_whitespace, minify_exports=settings.MINIFY_ASMJS_EXPORT_NAMES, debug_info=debug_info)

return js_file

# run binaryen's wasm-metadce to dce both js and wasm

def metadce(js_file, wasm_file, minify_whitespace, debug_info):

logger.debug('running meta-DCE')

temp_files = configuration.get_temp_files()

# first, get the JS part of the graph

if settings.MAIN_MODULE:

# For the main module we include all exports as possible roots, not just function exports.

# This means that any usages of data symbols within the JS or in the side modules can/will keep

# these exports alive on the wasm module.

# This is important today for weak data symbols that are defined by the main and the side module

# (i.e. RTTI info). We want to make sure the main module's symbols get added to asmLibraryArg

# when the main module is loaded. If this doesn't happen then the symbols in the side module

# will take precedence.

exports = settings.WASM_EXPORTS

else:

exports = settings.WASM_FUNCTION_EXPORTS

extra_info = '{ "exports": [' + ','.join(f'["{asmjs_mangle(x)}", "{x}"]' for x in exports) + ']}'

txt = acorn_optimizer(js_file, ['emitDCEGraph', 'noPrint'], return_output=True, extra_info=extra_info)

graph = json.loads(txt)

# ensure that functions expected to be exported to the outside are roots

required_symbols = user_requested_exports.union(set(settings.SIDE_MODULE_IMPORTS))

for item in graph:

if 'export' in item:

export = asmjs_mangle(item['export'])

if settings.EXPORT_ALL or export in required_symbols:

item['root'] = True

# in standalone wasm, always export the memory

if not settings.IMPORTED_MEMORY:

graph.append({

'export': 'memory',

'name': 'emcc$export$memory',

'reaches': [],

'root': True

})

if not settings.RELOCATABLE:

graph.append({

'export': '__indirect_function_table',

'name': 'emcc$export$__indirect_function_table',

'reaches': [],

'root': True

})

# fix wasi imports TODO: support wasm stable with an option?