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

import glob

import hashlib

import itertools

import logging

import os

import re

import shutil

import sys

import tarfile

import zipfile

from glob import iglob

from . import shared, building, ports, config, utils

from . import deps_info, tempfiles

from tools.shared import mangle_c_symbol_name, demangle_c_symbol_name

stdout = None

stderr = None

logger = logging.getLogger('system_libs')

LIBC_SOCKETS = ['socket.c', 'socketpair.c', 'shutdown.c', 'bind.c', 'connect.c',

'listen.c', 'accept.c', 'getsockname.c', 'getpeername.c', 'send.c',

'recv.c', 'sendto.c', 'recvfrom.c', 'sendmsg.c', 'recvmsg.c',

'getsockopt.c', 'setsockopt.c', 'freeaddrinfo.c',

'in6addr_any.c', 'in6addr_loopback.c']

def files_in_path(path_components, filenames):

srcdir = shared.path_from_root(*path_components)

return [os.path.join(srcdir, f) for f in filenames]

def glob_in_path(path_components, glob_pattern, excludes=()):

srcdir = shared.path_from_root(*path_components)

files = iglob(os.path.join(srcdir, glob_pattern), recursive=True)

return [f for f in files if os.path.basename(f) not in excludes]

def get_all_files_under(dirname):

for path, subdirs, files in os.walk(dirname):

for name in files:

yield os.path.join(path, name)

def dir_is_newer(dir_a, dir_b):

assert os.path.exists(dir_a)

assert os.path.exists(dir_b)

newest_a = max([os.path.getmtime(x) for x in get_all_files_under(dir_a)])

newest_b = max([os.path.getmtime(x) for x in get_all_files_under(dir_b)])

return newest_a < newest_b

def get_cflags(force_object_files=False):

flags = []

if shared.Settings.LTO and not force_object_files:

flags += ['-flto=' + shared.Settings.LTO]

if shared.Settings.RELOCATABLE:

flags += ['-s', 'RELOCATABLE']

if shared.Settings.MEMORY64:

flags += ['-s', 'MEMORY64=' + str(shared.Settings.MEMORY64)]

return flags

def run_one_command(cmd):

# Helper function used by run_build_commands.

if shared.EM_BUILD_VERBOSE:

print(shared.shlex_join(cmd))

# building system libraries and ports should be hermetic in that it is not

# affected by things like EMMAKEN_CFLAGS which the user may have set

safe_env = os.environ.copy()

for opt in ['EMMAKEN_CFLAGS', 'EMMAKEN_JUST_CONFIGURE']:

if opt in safe_env:

del safe_env[opt]

# TODO(sbc): Remove this one we remove the test_em_config_env_var test

cmd.append('-Wno-deprecated')

shared.run_process(cmd, stdout=stdout, stderr=stderr, env=safe_env)

def run_build_commands(commands):

# Before running a set of build commands make sure the common sysroot

# headers are installed. This prevents each sub-process from attempting

# to setup the sysroot itself.

ensure_sysroot()

cores = min(len(commands), building.get_num_cores())

if cores <= 1 or shared.DEBUG:

for command in commands:

run_one_command(command)

else:

pool = building.get_multiprocessing_pool()

# https://stackoverflow.com/questions/1408356/keyboard-interrupts-with-pythons-multiprocessing-pool

# https://bugs.python.org/issue8296

# 999999 seconds (about 11 days) is reasonably huge to not trigger actual timeout

# and is smaller than the maximum timeout value 4294967.0 for Python 3 on Windows (threading.TIMEOUT_MAX)

pool.map_async(run_one_command, commands, chunksize=1).get(999999)

def create_lib(libname, inputs):

"""Create a library from a set of input objects."""

suffix = shared.suffix(libname)

if suffix in ('.bc', '.o'):

if len(inputs) == 1:

if inputs[0] != libname:

shutil.copyfile(inputs[0], libname)

else:

building.link_to_object(inputs, libname)

elif suffix == '.a':

building.emar('cr', libname, inputs)

else:

raise Exception('unknown suffix ' + libname)

def read_symbols(path):

with open(path) as f:

content = f.read()

# Require that Windows newlines should not be present in a symbols file, if running on Linux or macOS

# This kind of mismatch can occur if one copies a zip file of Emscripten cloned on Windows over to

# a Linux or macOS system. It will result in Emscripten linker getting confused on stray \r characters,

# and be unable to link any library symbols properly. We could harden against this by .strip()ping the

# opened files, but it is possible that the mismatching line endings can cause random problems elsewhere

# in the toolchain, hence abort execution if so.

if os.name != 'nt' and '\r\n' in content:

raise Exception('Windows newlines \\r\\n detected in symbols file "' + path + '"! This could happen for example when copying Emscripten checkout from Windows to Linux or macOS. Please use Unix line endings on checkouts of Emscripten on Linux and macOS!')

return building.parse_symbols(content).defs

def get_wasm_libc_rt_files():

# Static linking is tricky with LLVM, since e.g. memset might not be used

# from libc, but be used as an intrinsic, and codegen will generate a libc

# call from that intrinsic *after* static linking would have thought it is

# all in there. In asm.js this is not an issue as we do JS linking anyhow,

# and have asm.js-optimized versions of all the LLVM intrinsics. But for

# wasm, we need a better solution. For now, make another archive that gets

# included at the same time as compiler-rt.

# Note that this also includes things that may be depended on by those

# functions - fmin uses signbit, for example, so signbit must be here (so if

# fmin is added by codegen, it will have all it needs).

math_files = files_in_path(

path_components=['system', 'lib', 'libc', 'musl', 'src', 'math'],

filenames=[

'fmin.c', 'fminf.c', 'fminl.c',

'fmax.c', 'fmaxf.c', 'fmaxl.c',

'fmod.c', 'fmodf.c', 'fmodl.c',

'log2.c', 'log2f.c', 'log10.c', 'log10f.c',

'exp2.c', 'exp2f.c', 'exp10.c', 'exp10f.c',

'scalbn.c', '__fpclassifyl.c',

'__signbitl.c', '__signbitf.c', '__signbit.c'

])

other_files = files_in_path(

path_components=['system', 'lib', 'libc'],

filenames=['emscripten_memcpy.c', 'emscripten_memset.c',

'emscripten_scan_stack.c',

'emscripten_memmove.c'])

# Calls to iprintf can be generated during codegen. Ideally we wouldn't

# compile these with -O2 like we do the rest of compiler-rt since its

# probably not performance sensitive. However we don't currently have

# a way to set per-file compiler flags. And hopefully we should be able

# move all this stuff back into libc once we it LTO compatible.

iprintf_files = files_in_path(

path_components=['system', 'lib', 'libc', 'musl', 'src', 'stdio'],

filenames=['__towrite.c', '__overflow.c', 'fwrite.c', 'fputs.c',

'printf.c', 'puts.c', '__lockfile.c'])

iprintf_files += files_in_path(

path_components=['system', 'lib', 'libc', 'musl', 'src', 'string'],

filenames=['strlen.c'])

return math_files + other_files + iprintf_files

class Library(object):

"""

`Library` is the base class of all system libraries.

There are two types of libraries: abstract and concrete.

* An abstract library, e.g. MTLibrary, is a subclass of `Library` that

implements certain behaviour common to multiple libraries. The features

of multiple abstract libraries can be used through multiple inheritance.

* A concrete library, e.g. libc, is a subclass of `Library` that describes

how to build a particular library, and its properties, such as name and

dependencies.

This library system is meant to handle having many versions of the same library,

which we call *variations*. For example, some libraries (those that inherit

from MTLibrary), have both single-threaded and multi-threaded versions.

An instance of a `Library` subclass represents a specific variation of the

library. Instance methods perform operations relating to this variation.

For example, `get_cflags()` would return the emcc flags needed to build this

variation, and `build()` would generate the library file for this variation.

The constructor takes keyword arguments that defines the variation.

Class methods perform tasks relating to all variations. For example,

`variations()` returns a list of all variations that exists for this library,

and `get_default_variation()` returns the variation suitable for the current

environment.

Other class methods act upon a group of libraries. For example,

`Library.get_all_variations()` returns a mapping of all variations of

existing libraries.

To add a new type of variation, you must add an parameter to `__init__` that

selects the variant. Then, override one of `vary_on` or `variations`, as well

as `get_default_variation`.

If the parameter is boolean, overriding `vary_on` to add the parameter name

to the returned list is sufficient:

@classmethod

def vary_on(cls):

return super().vary_on() + ['my_parameter']

Otherwise, you must override `variations`:

@classmethod

def variations(cls):

return [{'my_parameter': value, **other} for value, other in

itertools.product([1, 2, 3], super().variations())]

Overriding either `vary_on` or `variations` allows `embuilder.py` to know all

possible variations so it can build all of them.

You then need to modify `get_default_variation` to detect the correct value

for your new parameter based on the settings:

@classmethod

def get_default_variation(cls, **kwargs):

return super().get_default_variation(my_parameter=shared.Settings.MY_PARAMETER, **kwargs)

This allows the correct variation of the library to be selected when building

code with Emscripten.

"""

# The simple name of the library. When linking, this is the name to use to

# automatically get the correct version of the library.

# This should only be overridden in a concrete library class, e.g. libc,

# and left as None in an abstract library class, e.g. MTLibrary.

name = None

# A set of symbols that this library exports. This will be set with a set

# returned by `read_symbols`.

symbols = set()

# Set to true to prevent EMCC_FORCE_STDLIBS from linking this library.

never_force = False

# A list of flags to pass to emcc.

# The flags for the parent class is automatically inherited.

cflags = ['-Werror']

# A list of directories to put in the include path when building.

# This is a list of tuples of path components.

# For example, to put system/lib/a and system/lib/b under the emscripten

# directory into the include path, you would write:

# includes = [('system', 'lib', 'a'), ('system', 'lib', 'b')]

# The include path of the parent class is automatically inherited.

includes = []

# By default, `get_files` look for source files for this library under `src_dir`.

# It will either use the files listed in `src_files`, or use the glob pattern in

# `src_glob`. You may not specify both `src_files` and `src_glob`.

# When using `src_glob`, you can specify a list of files in `src_glob_exclude`

# to be excluded from the library.

# Alternatively, you can override `get_files` to use your own logic.

src_dir = None

src_files = None

src_glob = None

src_glob_exclude = None

# Whether to always generate WASM object files, even when LTO is set

force_object_files = False

def __init__(self):

"""

Creates a variation of this library.

A variation is a specific combination of settings a library can have.

For example, libc++-mt-noexcept is a variation of libc++.

There might be only one variation of a library.

The constructor keyword arguments will define what variation to use.

Use the `variations` classmethod to get the list of all possible constructor

arguments for this library.

Use the `get_default_variation` classmethod to construct the variation

suitable for the current invocation of emscripten.

"""

if not self.name:

raise NotImplementedError('Cannot instantiate an abstract library')

def can_use(self):

"""

Whether this library can be used in the current environment.

For example, libmalloc would override this and return False

if the user requested no malloc.

"""

return True

def can_build(self):

"""

Whether this library can be built in the current environment.

Override this if, for example, the library can only be built on WASM backend.

"""

return True

def erase(self):

shared.Cache.erase_file(shared.Cache.get_lib_name(self.get_filename()))

def get_path(self):

"""

Gets the cached path of this library.

This will trigger a build if this library is not in the cache.

"""

return shared.Cache.get_lib(self.get_filename(), self.build)

def get_files(self):

"""

Gets a list of source files for this library.

Typically, you will use `src_dir`, `src_files`, `src_glob` and `src_glob_exclude`.

If those are insufficient to describe the files needed, you can override this method.

"""

if self.src_dir:

if self.src_files and self.src_glob:

raise Exception('Cannot use src_files and src_glob together')

if self.src_files:

return files_in_path(self.src_dir, self.src_files)

elif self.src_glob:

return glob_in_path(self.src_dir, self.src_glob, self.src_glob_exclude or ())

raise NotImplementedError()

def build_objects(self, build_dir):

"""

Returns a list of compiled object files for this library.

By default, this builds all the source files returned by `self.get_files()`,

with the `cflags` returned by `self.get_cflags()`.

"""

commands = []

objects = []

cflags = self.get_cflags()

for src in self.get_files():

o = os.path.join(build_dir, shared.unsuffixed_basename(src) + '.o')

ext = shared.suffix(src)

if ext in ('.s', '.c'):

cmd = [shared.EMCC]

else:

cmd = [shared.EMXX]

if ext != '.s':

cmd += cflags

elif shared.Settings.MEMORY64:

cmd += ['-s', 'MEMORY64=' + str(shared.Settings.MEMORY64)]

commands.append(cmd + ['-c', src, '-o', o])

objects.append(o)

run_build_commands(commands)

return objects

def build(self, out_filename):

"""Builds the library and returns the path to the file."""

build_dir = shared.Cache.get_path(os.path.join('build', self.get_base_name()))

utils.safe_ensure_dirs(build_dir)

create_lib(out_filename, self.build_objects(build_dir))

if not shared.DEBUG:

tempfiles.try_delete(build_dir)

@classmethod

def _inherit_list(cls, attr):

# Some properties, like cflags and includes, makes more sense to inherit

# via concatenation than replacement.

result = []

for item in cls.__mro__[::-1]:

# Using __dict__ to avoid inheritance

result += item.__dict__.get(attr, [])

return result

def get_cflags(self):

"""

Returns the list of flags to pass to emcc when building this variation

of the library.

Override and add any flags as needed to handle new variations.

"""

cflags = self._inherit_list('cflags')

cflags += get_cflags(force_object_files=self.force_object_files)

if self.includes:

cflags += ['-I' + shared.path_from_root(*path) for path in self._inherit_list('includes')]

return cflags

def get_base_name_prefix(self):

"""

Returns the base name of the library without any suffixes.

"""

return self.name

def get_base_name(self):

"""

Returns the base name of the library file.

This will include suffixes such as -mt, but will not include a file extension.

"""

return self.get_base_name_prefix()

def get_ext(self):

"""

Return the appropriate file extension for this library.

"""

return '.a'

def get_filename(self):

"""

Return the full name of the library file, including the file extension.

"""

return self.get_base_name() + self.get_ext()

@classmethod

def vary_on(cls):

"""

Returns a list of strings that are the names of boolean constructor

arguments that defines the variations of this library.

This is used by the default implementation of `cls.variations()` to generate

every possible combination of boolean values to pass to these arguments.

"""

return []

@classmethod

def variations(cls):

"""

Returns a list of keyword arguments to pass to the constructor to create

every possible variation of this library.

By default, this is every possible combination of boolean values to pass

to the list of arguments returned by `vary_on`, but you can override

the behaviour.

"""

vary_on = cls.vary_on()

return [dict(zip(vary_on, toggles)) for toggles in

itertools.product([False, True], repeat=len(vary_on))]

@classmethod

def get_default_variation(cls, **kwargs):

"""

Construct the variation suitable for the current invocation of emscripten.

Subclasses should pass the keyword arguments they introduce to the

superclass version, and propagate **kwargs. The base class collects

all the keyword arguments and creates the instance.

"""

return cls(**kwargs)

@classmethod

def get_inheritance_tree(cls):

"""Returns all the classes in the inheritance tree of the current class."""

yield cls

for subclass in cls.__subclasses__():

for subclass in subclass.get_inheritance_tree():

yield subclass

@classmethod

def get_all_variations(cls):

"""

Gets all the variations of libraries in the inheritance tree of the current

library.

Calling Library.get_all_variations() returns the variations of ALL libraries

that can be built as a dictionary of variation names to Library objects.

"""

result = {}

for library in cls.get_inheritance_tree():

if library.name:

for flags in library.variations():

variation = library(**flags)

if variation.can_build():

result[variation.get_base_name()] = variation

return result

@classmethod

def get_usable_variations(cls):

"""

Gets all libraries suitable for the current invocation of emscripten.

This returns a dictionary of simple names to Library objects.

"""

result = {}

for subclass in cls.get_inheritance_tree():

if subclass.name:

library = subclass.get_default_variation()

if library.can_build() and library.can_use():

result[subclass.name] = library

return result

class MTLibrary(Library):

def __init__(self, **kwargs):

self.is_mt = kwargs.pop('is_mt')

super(MTLibrary, self).__init__(**kwargs)

def get_cflags(self):

cflags = super(MTLibrary, self).get_cflags()

if self.is_mt:

cflags += ['-s', 'USE_PTHREADS']

return cflags

def get_base_name(self):

name = super(MTLibrary, self).get_base_name()

if self.is_mt:

name += '-mt'

return name

@classmethod

def vary_on(cls):

return super(MTLibrary, cls).vary_on() + ['is_mt']

@classmethod

def get_default_variation(cls, **kwargs):

return super(MTLibrary, cls).get_default_variation(is_mt=shared.Settings.USE_PTHREADS, **kwargs)

class exceptions(object):

"""

This represents exception handling mode of Emscripten. Currently there are

three modes of exception handling:

- None: Does not handle exceptions. This includes -fno-exceptions, which

prevents both throwing and catching, and -fignore-exceptions, which only

allows throwing, but library-wise they use the same version.

- Emscripten: Emscripten provides exception handling capability using JS

emulation. This causes code size increase and performance degradation.

- Wasm: Wasm native exception handling support uses Wasm EH instructions and

is meant to be fast. You need to use a VM that has the EH support to use

this. This is not fully working yet and still experimental.

"""

none = 0

emscripten = 1

wasm = 2

class NoExceptLibrary(Library):

def __init__(self, **kwargs):

self.eh_mode = kwargs.pop('eh_mode')

super(NoExceptLibrary, self).__init__(**kwargs)

def get_cflags(self):

cflags = super(NoExceptLibrary, self).get_cflags()

if self.eh_mode == exceptions.none:

cflags += ['-fno-exceptions']

elif self.eh_mode == exceptions.emscripten:

cflags += ['-s', 'DISABLE_EXCEPTION_CATCHING=0']

elif self.eh_mode == exceptions.wasm:

cflags += ['-fwasm-exceptions']

return cflags

def get_base_name(self):

name = super(NoExceptLibrary, self).get_base_name()

# TODO Currently emscripten-based exception is the default mode, thus no

# suffixes. Change the default to wasm exception later.

if self.eh_mode == exceptions.none:

name += '-noexcept'

elif self.eh_mode == exceptions.wasm:

name += '-except'

return name

@classmethod

def variations(cls, **kwargs):

combos = super(NoExceptLibrary, cls).variations()

return ([dict(eh_mode=exceptions.none, **combo) for combo in combos] +

[dict(eh_mode=exceptions.emscripten, **combo) for combo in combos] +

[dict(eh_mode=exceptions.wasm, **combo) for combo in combos])

@classmethod

def get_default_variation(cls, **kwargs):

if shared.Settings.EXCEPTION_HANDLING:

eh_mode = exceptions.wasm

elif shared.Settings.DISABLE_EXCEPTION_CATCHING == 1:

eh_mode = exceptions.none

else:

eh_mode = exceptions.emscripten

return super(NoExceptLibrary, cls).get_default_variation(eh_mode=eh_mode, **kwargs)

class MuslInternalLibrary(Library):

includes = [

['system', 'lib', 'libc', 'musl', 'src', 'internal'],

]

cflags = [

'-D_XOPEN_SOURCE=700',

'-Wno-unused-result', # system call results are often ignored in musl, and in wasi that warns

]

class AsanInstrumentedLibrary(Library):

def __init__(self, **kwargs):

self.is_asan = kwargs.pop('is_asan', False)

super(AsanInstrumentedLibrary, self).__init__(**kwargs)

def get_cflags(self):

cflags = super(AsanInstrumentedLibrary, self).get_cflags()

if self.is_asan:

cflags += ['-fsanitize=address']

return cflags

def get_base_name(self):

name = super(AsanInstrumentedLibrary, self).get_base_name()

if self.is_asan:

name += '-asan'

return name

@classmethod

def vary_on(cls):

return super(AsanInstrumentedLibrary, cls).vary_on() + ['is_asan']

@classmethod

def get_default_variation(cls, **kwargs):

return super(AsanInstrumentedLibrary, cls).get_default_variation(is_asan=shared.Settings.USE_ASAN, **kwargs)

class libcompiler_rt(MTLibrary):

name = 'libcompiler_rt'

# compiler_rt files can't currently be part of LTO although we are hoping to remove this

# restriction soon: https://reviews.llvm.org/D71738

force_object_files = True

cflags = ['-O2', '-fno-builtin']

src_dir = ['system', 'lib', 'compiler-rt', 'lib', 'builtins']

src_files = glob_in_path(src_dir, '*.c')

src_files.append(shared.path_from_root('system', 'lib', 'compiler-rt', 'stack_ops.S'))

src_files.append(shared.path_from_root('system', 'lib', 'compiler-rt', 'stack_limits.S'))

src_files.append(shared.path_from_root('system', 'lib', 'compiler-rt', 'emscripten_setjmp.c'))

src_files.append(shared.path_from_root('system', 'lib', 'compiler-rt', 'emscripten_exception_builtins.c'))

class libc(AsanInstrumentedLibrary, MuslInternalLibrary, MTLibrary):

name = 'libc'

# Without -fno-builtin, LLVM can optimize away or convert calls to library

# functions to something else based on assumptions that they behave exactly

# like the standard library. This can cause unexpected bugs when we use our

# custom standard library. The same for other libc/libm builds.

cflags = ['-Os', '-fno-builtin']

# Disable certain warnings for code patterns that are contained in upstream musl

cflags += ['-Wno-ignored-attributes',

'-Wno-dangling-else',

'-Wno-unknown-pragmas',

'-Wno-shift-op-parentheses',

'-Wno-string-plus-int',

'-Wno-pointer-sign']

def get_files(self):

libc_files = []

musl_srcdir = shared.path_from_root('system', 'lib', 'libc', 'musl', 'src')

# musl modules

ignore = [

'ipc', 'passwd', 'thread', 'signal', 'sched', 'ipc', 'time', 'linux',

'aio', 'exit', 'legacy', 'mq', 'search', 'setjmp', 'env',

'ldso', 'conf'

]

# individual files

ignore += [

'memcpy.c', 'memset.c', 'memmove.c', 'getaddrinfo.c', 'getnameinfo.c',

'inet_addr.c', 'res_query.c', 'res_querydomain.c', 'gai_strerror.c',

'proto.c', 'gethostbyaddr.c', 'gethostbyaddr_r.c', 'gethostbyname.c',

'gethostbyname2_r.c', 'gethostbyname_r.c', 'gethostbyname2.c',

'alarm.c', 'syscall.c', '_exit.c', 'popen.c',

'getgrouplist.c', 'initgroups.c', 'wordexp.c', 'timer_create.c',

'faccessat.c',

# 'process' exclusion

'fork.c', 'vfork.c', 'posix_spawn.c', 'execve.c', 'waitid.c', 'system.c'

]

ignore += LIBC_SOCKETS

if self.is_asan:

# With ASan, we need to use specialized implementations of certain libc

# functions that do not rely on undefined behavior, for example, reading

# multiple bytes at once as an int and overflowing a buffer.

# Otherwise, ASan will catch these errors and terminate the program.

ignore += ['strcpy.c', 'memchr.c', 'strchrnul.c', 'strlen.c',

'aligned_alloc.c', 'fcntl.c']

libc_files += [

shared.path_from_root('system', 'lib', 'libc', 'emscripten_asan_strcpy.c'),

shared.path_from_root('system', 'lib', 'libc', 'emscripten_asan_memchr.c'),

shared.path_from_root('system', 'lib', 'libc', 'emscripten_asan_strchrnul.c'),

shared.path_from_root('system', 'lib', 'libc', 'emscripten_asan_strlen.c'),

shared.path_from_root('system', 'lib', 'libc', 'emscripten_asan_fcntl.c'),

]

# These are included in wasm_libc_rt instead

ignore += [os.path.basename(f) for f in get_wasm_libc_rt_files()]

ignore = set(ignore)

# TODO: consider using more math code from musl, doing so makes box2d faster

for dirpath, dirnames, filenames in os.walk(musl_srcdir):

for f in filenames:

if f.endswith('.c'):

if f in ignore:

continue

dir_parts = os.path.split(dirpath)

cancel = False

for part in dir_parts:

if part in ignore:

cancel = True

break

if not cancel:

libc_files.append(os.path.join(musl_srcdir, dirpath, f))

# Allowed files from ignored modules

libc_files += files_in_path(

path_components=['system', 'lib', 'libc', 'musl', 'src', 'time'],

filenames=['clock_settime.c', 'asctime.c', 'ctime.c', 'gmtime.c', 'localtime.c', 'nanosleep.c'])

libc_files += files_in_path(

path_components=['system', 'lib', 'libc', 'musl', 'src', 'legacy'],

filenames=['getpagesize.c', 'err.c'])

libc_files += files_in_path(

path_components=['system', 'lib', 'libc', 'musl', 'src', 'env'],

filenames=['__environ.c', 'getenv.c', 'putenv.c', 'setenv.c', 'unsetenv.c'])

libc_files += files_in_path(

path_components=['system', 'lib', 'libc', 'musl', 'src', 'sched'],

filenames=['sched_yield.c'])

libc_files += files_in_path(

path_components=['system', 'lib', 'libc'],

filenames=['extras.c', 'wasi-helpers.c', 'emscripten_pthread.c'])

libc_files += files_in_path(

path_components=['system', 'lib', 'pthread'],

filenames=['emscripten_atomic.c'])

libc_files += files_in_path(

path_components=['system', 'lib', 'libc', 'musl', 'src', 'thread'],

filenames=[

'pthread_self.c',

# C11 thread library functions

'thrd_create.c',

'thrd_exit.c',

'thrd_join.c',

'thrd_sleep.c',

'thrd_yield.c',

'call_once.c',

])

libc_files += glob_in_path(['system', 'lib', 'libc', 'compat'], '*.c')

if self.is_mt:

libc_files += files_in_path(

path_components=['system', 'lib', 'libc', 'musl', 'src', 'thread'],

filenames=[

'pthread_attr_destroy.c', 'pthread_condattr_setpshared.c',

'pthread_mutex_lock.c', 'pthread_spin_destroy.c', 'pthread_attr_get.c',

'pthread_cond_broadcast.c', 'pthread_mutex_setprioceiling.c',

'pthread_spin_init.c', 'pthread_attr_init.c', 'pthread_cond_destroy.c',

'pthread_mutex_timedlock.c', 'pthread_spin_lock.c',

'pthread_attr_setdetachstate.c', 'pthread_cond_init.c',

'pthread_mutex_trylock.c', 'pthread_spin_trylock.c',

'pthread_attr_setguardsize.c', 'pthread_cond_signal.c',

'pthread_mutex_unlock.c', 'pthread_spin_unlock.c',

'pthread_attr_setinheritsched.c', 'pthread_cond_timedwait.c',

'pthread_once.c', 'sem_destroy.c', 'pthread_attr_setschedparam.c',

'pthread_cond_wait.c', 'pthread_rwlockattr_destroy.c', 'sem_getvalue.c',

'pthread_attr_setschedpolicy.c', 'pthread_equal.c', 'pthread_rwlockattr_init.c',

'sem_init.c', 'pthread_attr_setscope.c', 'pthread_getspecific.c',

'pthread_rwlockattr_setpshared.c', 'sem_open.c', 'pthread_attr_setstack.c',

'pthread_key_create.c', 'pthread_rwlock_destroy.c', 'sem_post.c',

'pthread_attr_setstacksize.c', 'pthread_mutexattr_destroy.c',

'pthread_rwlock_init.c', 'sem_timedwait.c', 'pthread_barrierattr_destroy.c',

'pthread_mutexattr_init.c', 'pthread_rwlock_rdlock.c', 'sem_trywait.c',

'pthread_barrierattr_init.c', 'pthread_mutexattr_setprotocol.c',

'pthread_rwlock_timedrdlock.c', 'sem_unlink.c',

'pthread_barrierattr_setpshared.c', 'pthread_mutexattr_setpshared.c',

'pthread_rwlock_timedwrlock.c', 'sem_wait.c', 'pthread_barrier_destroy.c',

'pthread_mutexattr_setrobust.c', 'pthread_rwlock_tryrdlock.c',

'__timedwait.c', 'pthread_barrier_init.c', 'pthread_mutexattr_settype.c',

'pthread_rwlock_trywrlock.c', 'vmlock.c', 'pthread_barrier_wait.c',

'pthread_mutex_consistent.c', 'pthread_rwlock_unlock.c', '__wait.c',

'pthread_condattr_destroy.c', 'pthread_mutex_destroy.c',

'pthread_rwlock_wrlock.c', 'pthread_condattr_init.c',

'pthread_mutex_getprioceiling.c', 'pthread_setcanceltype.c',

'pthread_condattr_setclock.c', 'pthread_mutex_init.c',

'pthread_setspecific.c', 'pthread_setcancelstate.c',

'pthread_getconcurrency.c', 'pthread_setconcurrency.c',

'pthread_getschedparam.c', 'pthread_setschedparam.c',

'pthread_setschedprio.c', 'pthread_atfork.c',

'pthread_getcpuclockid.c',

])

libc_files += files_in_path(

path_components=['system', 'lib', 'pthread'],

filenames=[

'library_pthread.c',

'emscripten_tls_init.c',

'emscripten_thread_state.s',

])

else:

libc_files += [shared.path_from_root('system', 'lib', 'pthread', 'library_pthread_stub.c')]

return libc_files

class libprintf_long_double(libc):

name = 'libprintf_long_double'

cflags = ['-DEMSCRIPTEN_PRINTF_LONG_DOUBLE']

def get_files(self):

return files_in_path(

path_components=['system', 'lib', 'libc', 'musl', 'src', 'stdio'],

filenames=['vfprintf.c'])

class libsockets(MuslInternalLibrary, MTLibrary):

name = 'libsockets'

cflags = ['-Os', '-fno-builtin']

def get_files(self):

network_dir = shared.path_from_root('system', 'lib', 'libc', 'musl', 'src', 'network')

return [os.path.join(network_dir, x) for x in LIBC_SOCKETS]

class libsockets_proxy(MuslInternalLibrary, MTLibrary):

name = 'libsockets_proxy'

cflags = ['-Os']

def get_files(self):

return [shared.path_from_root('system', 'lib', 'websocket', 'websocket_to_posix_socket.cpp'),

shared.path_from_root('system', 'lib', 'libc', 'musl', 'src', 'network', 'inet_addr.c')]

class crt1(MuslInternalLibrary):

name = 'crt1'

cflags = ['-O2']

src_dir = ['system', 'lib', 'libc']

src_files = ['crt1.c']

force_object_files = True

def get_ext(self):

return '.o'

def can_use(self):

return super(crt1, self).can_use() and shared.Settings.STANDALONE_WASM

class crt1_reactor(MuslInternalLibrary):

name = 'crt1_reactor'

cflags = ['-O2']

src_dir = ['system', 'lib', 'libc']

src_files = ['crt1_reactor.c']

force_object_files = True

def get_ext(self):

return '.o'

def can_use(self):

return super(crt1_reactor, self).can_use() and shared.Settings.STANDALONE_WASM

class libcxxabi(NoExceptLibrary, MTLibrary):

name = 'libc++abi'

cflags = [

'-Oz',

'-D_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS',

# Remove this once we update to include this llvm

# revision: https://reviews.llvm.org/D64961

'-D_LIBCXXABI_GUARD_ABI_ARM',

]

def get_cflags(self):

cflags = super(libcxxabi, self).get_cflags()

cflags.append('-DNDEBUG')

if not self.is_mt:

cflags.append('-D_LIBCXXABI_HAS_NO_THREADS')

if self.eh_mode == exceptions.none:

cflags.append('-D_LIBCXXABI_NO_EXCEPTIONS')

elif self.eh_mode == exceptions.emscripten:

cflags.append('-D__USING_EMSCRIPTEN_EXCEPTIONS__')

elif self.eh_mode == exceptions.wasm:

cflags.append('-D__USING_WASM_EXCEPTIONS__')

return cflags

def get_files(self):

filenames = [

'abort_message.cpp',

'cxa_aux_runtime.cpp',

'cxa_default_handlers.cpp',

'cxa_demangle.cpp',

'cxa_exception_storage.cpp',

'cxa_guard.cpp',

'cxa_handlers.cpp',

'cxa_virtual.cpp',

'fallback_malloc.cpp',

'stdlib_new_delete.cpp',

'stdlib_exception.cpp',

'stdlib_stdexcept.cpp',

'stdlib_typeinfo.cpp',

'private_typeinfo.cpp'

]

if self.eh_mode == exceptions.none:

filenames += ['cxa_noexception.cpp']

elif self.eh_mode == exceptions.wasm:

filenames += [

'cxa_exception.cpp',

'cxa_personality.cpp'

]

return files_in_path(

path_components=['system', 'lib', 'libcxxabi', 'src'],

filenames=filenames)

class libcxx(NoExceptLibrary, MTLibrary):

name = 'libc++'

cflags = ['-DLIBCXX_BUILDING_LIBCXXABI=1', '-D_LIBCPP_BUILDING_LIBRARY', '-Oz',

'-D_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS']

src_dir = ['system', 'lib', 'libcxx', 'src']

src_glob = '**/*.cpp'

src_glob_exclude = ['locale_win32.cpp', 'thread_win32.cpp', 'support.cpp', 'int128_builtins.cpp']

class libunwind(NoExceptLibrary, MTLibrary):

name = 'libunwind'

cflags = ['-Oz', '-D_LIBUNWIND_DISABLE_VISIBILITY_ANNOTATIONS']

src_dir = ['system', 'lib', 'libunwind', 'src']

# Without this we can't build libunwind since it will pickup the unwind.h

# that is part of llvm (which is not compatible for some reason).

includes = [['system', 'lib', 'libunwind', 'include']]

src_files = ['Unwind-wasm.cpp']

def __init__(self, **kwargs):

super(libunwind, self).__init__(**kwargs)

def can_use(self):

return super(libunwind, self).can_use() and self.eh_mode == exceptions.wasm

def get_cflags(self):

cflags = super(libunwind, self).get_cflags()

cflags.append('-DNDEBUG')

if not self.is_mt:

cflags.append('-D_LIBUNWIND_HAS_NO_THREADS')

if self.eh_mode == exceptions.none:

cflags.append('-D_LIBUNWIND_HAS_NO_EXCEPTIONS')

elif self.eh_mode == exceptions.emscripten:

cflags.append('-D__USING_EMSCRIPTEN_EXCEPTIONS__')

elif self.eh_mode == exceptions.wasm:

cflags.append('-D__USING_WASM_EXCEPTIONS__')

return cflags

class libmalloc(MTLibrary):

name = 'libmalloc'

cflags = ['-O2', '-fno-builtin']

def __init__(self, **kwargs):

self.malloc = kwargs.pop('malloc')

if self.malloc not in ('dlmalloc', 'emmalloc', 'emmalloc-debug', 'emmalloc-memvalidate', 'emmalloc-verbose', 'emmalloc-memvalidate-verbose', 'none'):

raise Exception('malloc must be one of "emmalloc[-debug|-memvalidate][-verbose]", "dlmalloc" or "none", see settings.js')

self.use_errno = kwargs.pop('use_errno')

self.is_tracing = kwargs.pop('is_tracing')

self.memvalidate = kwargs.pop('memvalidate')

self.verbose = kwargs.pop('verbose')

self.is_debug = kwargs.pop('is_debug') or self.memvalidate or self.verbose

super(libmalloc, self).__init__(**kwargs)

def get_files(self):

malloc_base = self.malloc.replace('-memvalidate', '').replace('-verbose', '').replace('-debug', '')

malloc = shared.path_from_root('system', 'lib', {

'dlmalloc': 'dlmalloc.c', 'emmalloc': 'emmalloc.cpp',

}[malloc_base])

sbrk = shared.path_from_root('system', 'lib', 'sbrk.c')

return [malloc, sbrk]

def get_cflags(self):

cflags = super(libmalloc, self).get_cflags()

if self.memvalidate:

cflags += ['-DEMMALLOC_MEMVALIDATE']

if self.verbose:

cflags += ['-DEMMALLOC_VERBOSE']