/**

* @license

* Copyright 2010 The Emscripten Authors

* SPDX-License-Identifier: MIT

*/

//"use strict";

// An implementation of basic necessary libraries for the web. This integrates

// with a compiled libc and with the rest of the JS runtime.

//

// We search the Library object when there is an external function. If the

// entry in the Library is a function, we insert it. If it is a string, we

// do another lookup in the library (a simple way to write a function once,

// if it can be called by different names). We also allow dependencies,

// using __deps. Initialization code to be run after allocating all

// global constants can be defined by __postset.

//

// Note that the full function name will be '_' + the name in the Library

// object. For convenience, the short name appears here. Note that if you add a

// new function with an '_', it will not be found.

// Memory allocated during startup, in postsets, should only be static

// (using makeStaticAlloc)

LibraryManager.library = {

// ==========================================================================

// getTempRet0/setTempRet0: scratch space handling i64 return

// ==========================================================================

getTempRet0__sig: 'i',

getTempRet0: function() {

return {{{ makeGetTempRet0() }}};

},

setTempRet0__sig: 'vi',

setTempRet0: function($i) {

{{{ makeSetTempRet0('$i') }}};

},

// ==========================================================================

// JavaScript <-> C string interop

// ==========================================================================

$stringToNewUTF8: function(jsString) {

var length = lengthBytesUTF8(jsString)+1;

var cString = _malloc(length);

stringToUTF8(jsString, cString, length);

return cString;

},

// ==========================================================================

// utime.h

// ==========================================================================

utime__deps: ['$FS', '$setErrNo'],

utime__proxy: 'sync',

utime__sig: 'iii',

utime: function(path, times) {

// int utime(const char *path, const struct utimbuf *times);

// http://pubs.opengroup.org/onlinepubs/009695399/basedefs/utime.h.html

var time;

if (times) {

// NOTE: We don't keep track of access timestamps.

var offset = {{{ C_STRUCTS.utimbuf.modtime }}};

time = {{{ makeGetValue('times', 'offset', 'i32') }}};

time *= 1000;

} else {

time = Date.now();

}

path = UTF8ToString(path);

try {

FS.utime(path, time, time);

return 0;

} catch (e) {

FS.handleFSError(e);

return -1;

}

},

utimes__deps: ['$FS', '$setErrNo'],

utimes__proxy: 'sync',

utimes__sig: 'iii',

utimes: function(path, times) {

var time;

if (times) {

var offset = {{{ C_STRUCTS.timeval.__size__ }}} + {{{ C_STRUCTS.timeval.tv_sec }}};

time = {{{ makeGetValue('times', 'offset', 'i32') }}} * 1000;

offset = {{{ C_STRUCTS.timeval.__size__ }}} + {{{ C_STRUCTS.timeval.tv_usec }}};

time += {{{ makeGetValue('times', 'offset', 'i32') }}} / 1000;

} else {

time = Date.now();

}

path = UTF8ToString(path);

try {

FS.utime(path, time, time);

return 0;

} catch (e) {

FS.handleFSError(e);

return -1;

}

},

// ==========================================================================

// sys/file.h

// ==========================================================================

flock: function(fd, operation) {

// int flock(int fd, int operation);

// Pretend to succeed

return 0;

},

chroot__deps: ['$setErrNo'],

chroot__proxy: 'sync',

chroot__sig: 'ii',

chroot: function(path) {

// int chroot(const char *path);

// http://pubs.opengroup.org/onlinepubs/7908799/xsh/chroot.html

setErrNo({{{ cDefine('EACCES') }}});

return -1;

},

fpathconf__deps: ['$setErrNo'],

fpathconf__proxy: 'sync',

fpathconf__sig: 'iii',

fpathconf: function(fildes, name) {

// long fpathconf(int fildes, int name);

// http://pubs.opengroup.org/onlinepubs/000095399/functions/encrypt.html

// NOTE: The first parameter is ignored, so pathconf == fpathconf.

// The constants here aren't real values. Just mimicking glibc.

switch (name) {

case {{{ cDefine('_PC_LINK_MAX') }}}:

return 32000;

case {{{ cDefine('_PC_MAX_CANON') }}}:

case {{{ cDefine('_PC_MAX_INPUT') }}}:

case {{{ cDefine('_PC_NAME_MAX') }}}:

return 255;

case {{{ cDefine('_PC_PATH_MAX') }}}:

case {{{ cDefine('_PC_PIPE_BUF') }}}:

case {{{ cDefine('_PC_REC_MIN_XFER_SIZE') }}}:

case {{{ cDefine('_PC_REC_XFER_ALIGN') }}}:

case {{{ cDefine('_PC_ALLOC_SIZE_MIN') }}}:

return 4096;

case {{{ cDefine('_PC_CHOWN_RESTRICTED') }}}:

case {{{ cDefine('_PC_NO_TRUNC') }}}:

case {{{ cDefine('_PC_2_SYMLINKS') }}}:

return 1;

case {{{ cDefine('_PC_VDISABLE') }}}:

return 0;

case {{{ cDefine('_PC_SYNC_IO') }}}:

case {{{ cDefine('_PC_ASYNC_IO') }}}:

case {{{ cDefine('_PC_PRIO_IO') }}}:

case {{{ cDefine('_PC_SOCK_MAXBUF') }}}:

case {{{ cDefine('_PC_REC_INCR_XFER_SIZE') }}}:

case {{{ cDefine('_PC_REC_MAX_XFER_SIZE') }}}:

case {{{ cDefine('_PC_SYMLINK_MAX') }}}:

return -1;

case {{{ cDefine('_PC_FILESIZEBITS') }}}:

return 64;

}

setErrNo({{{ cDefine('EINVAL') }}});

return -1;

},

pathconf: 'fpathconf',

confstr__deps: ['$setErrNo', '$ENV'],

confstr__proxy: 'sync',

confstr__sig: 'iiii',

confstr: function(name, buf, len) {

// size_t confstr(int name, char *buf, size_t len);

// http://pubs.opengroup.org/onlinepubs/000095399/functions/confstr.html

var value;

switch (name) {

case {{{ cDefine('_CS_PATH') }}}:

value = ENV['PATH'] || '/';

break;

case {{{ cDefine('_CS_POSIX_V6_WIDTH_RESTRICTED_ENVS') }}}:

// Mimicking glibc.

value = 'POSIX_V6_ILP32_OFF32\nPOSIX_V6_ILP32_OFFBIG';

break;

case {{{ cDefine('_CS_GNU_LIBC_VERSION') }}}:

// This JS implementation was tested against this glibc version.

value = 'glibc 2.14';

break;

case {{{ cDefine('_CS_GNU_LIBPTHREAD_VERSION') }}}:

// We don't support pthreads.

value = '';

break;

case {{{ cDefine('_CS_POSIX_V6_ILP32_OFF32_LIBS') }}}:

case {{{ cDefine('_CS_POSIX_V6_ILP32_OFFBIG_LIBS') }}}:

case {{{ cDefine('_CS_POSIX_V6_LP64_OFF64_CFLAGS') }}}:

case {{{ cDefine('_CS_POSIX_V6_LP64_OFF64_LDFLAGS') }}}:

case {{{ cDefine('_CS_POSIX_V6_LP64_OFF64_LIBS') }}}:

case {{{ cDefine('_CS_POSIX_V6_LPBIG_OFFBIG_CFLAGS') }}}:

case {{{ cDefine('_CS_POSIX_V6_LPBIG_OFFBIG_LDFLAGS') }}}:

case {{{ cDefine('_CS_POSIX_V6_LPBIG_OFFBIG_LIBS') }}}:

value = '';

break;

case {{{ cDefine('_CS_POSIX_V6_ILP32_OFF32_CFLAGS') }}}:

case {{{ cDefine('_CS_POSIX_V6_ILP32_OFF32_LDFLAGS') }}}:

case {{{ cDefine('_CS_POSIX_V6_ILP32_OFFBIG_LDFLAGS') }}}:

value = '-m32';

break;

case {{{ cDefine('_CS_POSIX_V6_ILP32_OFFBIG_CFLAGS') }}}:

value = '-m32 -D_LARGEFILE_SOURCE -D_FILE_OFFSET_BITS=64';

break;

default:

setErrNo({{{ cDefine('EINVAL') }}});

return 0;

}

if (len == 0 || buf == 0) {

return value.length + 1;

} else {

var length = Math.min(len, value.length);

for (var i = 0; i < length; i++) {

{{{ makeSetValue('buf', 'i', 'value.charCodeAt(i)', 'i8') }}};

}

if (len > length) {{{ makeSetValue('buf', 'i++', '0', 'i8') }}};

return i;

}

},

execve__deps: ['$setErrNo'],

execve__sig: 'iiii',

execve: function(path, argv, envp) {

// int execve(const char *pathname, char *const argv[],

// char *const envp[]);

// http://pubs.opengroup.org/onlinepubs/009695399/functions/exec.html

// We don't support executing external code.

setErrNo({{{ cDefine('ENOEXEC') }}});

return -1;

},

exit__sig: 'vi',

exit: function(status) {

#if MINIMAL_RUNTIME

throw 'exit(' + status + ')';

#else

// void _exit(int status);

// http://pubs.opengroup.org/onlinepubs/000095399/functions/exit.html

exit(status);

#endif

},

_exit__sig: 'vi',

_exit: 'exit',

_Exit__sig: 'vi',

_Exit: 'exit',

#if MINIMAL_RUNTIME

$exit: function(status) {

throw 'exit(' + status + ')';

},

#endif

// fork, spawn, etc. all return an error as we don't support multiple

// processes.

fork__deps: ['$setErrNo'],

fork__sig: 'i',

fork: function() {

// pid_t fork(void);

// http://pubs.opengroup.org/onlinepubs/000095399/functions/fork.html

// We don't support multiple processes.

setErrNo({{{ cDefine('EAGAIN') }}});

return -1;

},

vfork: 'fork',

posix_spawn: 'fork',

setgroups__deps: ['$setErrNo', 'sysconf'],

setgroups: function(ngroups, gidset) {

// int setgroups(int ngroups, const gid_t *gidset);

// https://developer.apple.com/library/mac/#documentation/Darwin/Reference/ManPages/man2/setgroups.2.html

if (ngroups < 1 || ngroups > _sysconf({{{ cDefine('_SC_NGROUPS_MAX') }}})) {

setErrNo({{{ cDefine('EINVAL') }}});

return -1;

} else {

// We have just one process/user/group, so it makes no sense to set groups.

setErrNo({{{ cDefine('EPERM') }}});

return -1;

}

},

sysconf__deps: ['$setErrNo'],

sysconf__proxy: 'sync',

sysconf__sig: 'ii',

sysconf: function(name) {

// long sysconf(int name);

// http://pubs.opengroup.org/onlinepubs/009695399/functions/sysconf.html

switch(name) {

case {{{ cDefine('_SC_PAGE_SIZE') }}}: return {{{ POSIX_PAGE_SIZE }}};

case {{{ cDefine('_SC_PHYS_PAGES') }}}:

#if ALLOW_MEMORY_GROWTH

#if MAXIMUM_MEMORY == -1 // no maximum set, assume the best

var maxHeapSize = 4*1024*1024*1024;

#else

var maxHeapSize = {{{ MAXIMUM_MEMORY }}};

#endif

#else // no growth

var maxHeapSize = HEAPU8.length;

#endif

return maxHeapSize / {{{ POSIX_PAGE_SIZE }}};

case {{{ cDefine('_SC_ADVISORY_INFO') }}}:

case {{{ cDefine('_SC_BARRIERS') }}}:

case {{{ cDefine('_SC_ASYNCHRONOUS_IO') }}}:

case {{{ cDefine('_SC_CLOCK_SELECTION') }}}:

case {{{ cDefine('_SC_CPUTIME') }}}:

case {{{ cDefine('_SC_FSYNC') }}}:

case {{{ cDefine('_SC_IPV6') }}}:

case {{{ cDefine('_SC_MAPPED_FILES') }}}:

case {{{ cDefine('_SC_MEMLOCK') }}}:

case {{{ cDefine('_SC_MEMLOCK_RANGE') }}}:

case {{{ cDefine('_SC_MEMORY_PROTECTION') }}}:

case {{{ cDefine('_SC_MESSAGE_PASSING') }}}:

case {{{ cDefine('_SC_MONOTONIC_CLOCK') }}}:

case {{{ cDefine('_SC_PRIORITIZED_IO') }}}:

case {{{ cDefine('_SC_PRIORITY_SCHEDULING') }}}:

case {{{ cDefine('_SC_RAW_SOCKETS') }}}:

case {{{ cDefine('_SC_READER_WRITER_LOCKS') }}}:

case {{{ cDefine('_SC_REALTIME_SIGNALS') }}}:

case {{{ cDefine('_SC_SEMAPHORES') }}}:

case {{{ cDefine('_SC_SHARED_MEMORY_OBJECTS') }}}:

case {{{ cDefine('_SC_SPAWN') }}}:

case {{{ cDefine('_SC_SPIN_LOCKS') }}}:

case {{{ cDefine('_SC_SYNCHRONIZED_IO') }}}:

case {{{ cDefine('_SC_THREAD_ATTR_STACKADDR') }}}:

case {{{ cDefine('_SC_THREAD_ATTR_STACKSIZE') }}}:

case {{{ cDefine('_SC_THREAD_CPUTIME') }}}:

case {{{ cDefine('_SC_THREAD_PRIO_INHERIT') }}}:

case {{{ cDefine('_SC_THREAD_PRIO_PROTECT') }}}:

case {{{ cDefine('_SC_THREAD_PROCESS_SHARED') }}}:

case {{{ cDefine('_SC_THREAD_SAFE_FUNCTIONS') }}}:

case {{{ cDefine('_SC_THREADS') }}}:

case {{{ cDefine('_SC_TIMEOUTS') }}}:

case {{{ cDefine('_SC_TIMERS') }}}:

case {{{ cDefine('_SC_VERSION') }}}:

case {{{ cDefine('_SC_2_C_BIND') }}}:

case {{{ cDefine('_SC_2_C_DEV') }}}:

case {{{ cDefine('_SC_2_CHAR_TERM') }}}:

case {{{ cDefine('_SC_2_LOCALEDEF') }}}:

case {{{ cDefine('_SC_2_SW_DEV') }}}:

case {{{ cDefine('_SC_2_VERSION') }}}:

case {{{ cDefine('_SC_THREAD_PRIORITY_SCHEDULING') }}}:

return 200809;

case {{{ cDefine('_SC_MQ_OPEN_MAX') }}}:

case {{{ cDefine('_SC_XOPEN_STREAMS') }}}:

case {{{ cDefine('_SC_XBS5_LP64_OFF64') }}}:

case {{{ cDefine('_SC_XBS5_LPBIG_OFFBIG') }}}:

case {{{ cDefine('_SC_AIO_LISTIO_MAX') }}}:

case {{{ cDefine('_SC_AIO_MAX') }}}:

case {{{ cDefine('_SC_SPORADIC_SERVER') }}}:

case {{{ cDefine('_SC_THREAD_SPORADIC_SERVER') }}}:

case {{{ cDefine('_SC_TRACE') }}}:

case {{{ cDefine('_SC_TRACE_EVENT_FILTER') }}}:

case {{{ cDefine('_SC_TRACE_EVENT_NAME_MAX') }}}:

case {{{ cDefine('_SC_TRACE_INHERIT') }}}:

case {{{ cDefine('_SC_TRACE_LOG') }}}:

case {{{ cDefine('_SC_TRACE_NAME_MAX') }}}:

case {{{ cDefine('_SC_TRACE_SYS_MAX') }}}:

case {{{ cDefine('_SC_TRACE_USER_EVENT_MAX') }}}:

case {{{ cDefine('_SC_TYPED_MEMORY_OBJECTS') }}}:

case {{{ cDefine('_SC_V6_LP64_OFF64') }}}:

case {{{ cDefine('_SC_V6_LPBIG_OFFBIG') }}}:

case {{{ cDefine('_SC_2_FORT_DEV') }}}:

case {{{ cDefine('_SC_2_FORT_RUN') }}}:

case {{{ cDefine('_SC_2_PBS') }}}:

case {{{ cDefine('_SC_2_PBS_ACCOUNTING') }}}:

case {{{ cDefine('_SC_2_PBS_CHECKPOINT') }}}:

case {{{ cDefine('_SC_2_PBS_LOCATE') }}}:

case {{{ cDefine('_SC_2_PBS_MESSAGE') }}}:

case {{{ cDefine('_SC_2_PBS_TRACK') }}}:

case {{{ cDefine('_SC_2_UPE') }}}:

case {{{ cDefine('_SC_THREAD_THREADS_MAX') }}}:

case {{{ cDefine('_SC_SEM_NSEMS_MAX') }}}:

case {{{ cDefine('_SC_SYMLOOP_MAX') }}}:

case {{{ cDefine('_SC_TIMER_MAX') }}}:

return -1;

case {{{ cDefine('_SC_V6_ILP32_OFF32') }}}:

case {{{ cDefine('_SC_V6_ILP32_OFFBIG') }}}:

case {{{ cDefine('_SC_JOB_CONTROL') }}}:

case {{{ cDefine('_SC_REGEXP') }}}:

case {{{ cDefine('_SC_SAVED_IDS') }}}:

case {{{ cDefine('_SC_SHELL') }}}:

case {{{ cDefine('_SC_XBS5_ILP32_OFF32') }}}:

case {{{ cDefine('_SC_XBS5_ILP32_OFFBIG') }}}:

case {{{ cDefine('_SC_XOPEN_CRYPT') }}}:

case {{{ cDefine('_SC_XOPEN_ENH_I18N') }}}:

case {{{ cDefine('_SC_XOPEN_LEGACY') }}}:

case {{{ cDefine('_SC_XOPEN_REALTIME') }}}:

case {{{ cDefine('_SC_XOPEN_REALTIME_THREADS') }}}:

case {{{ cDefine('_SC_XOPEN_SHM') }}}:

case {{{ cDefine('_SC_XOPEN_UNIX') }}}:

return 1;

case {{{ cDefine('_SC_THREAD_KEYS_MAX') }}}:

case {{{ cDefine('_SC_IOV_MAX') }}}:

case {{{ cDefine('_SC_GETGR_R_SIZE_MAX') }}}:

case {{{ cDefine('_SC_GETPW_R_SIZE_MAX') }}}:

case {{{ cDefine('_SC_OPEN_MAX') }}}:

return 1024;

case {{{ cDefine('_SC_RTSIG_MAX') }}}:

case {{{ cDefine('_SC_EXPR_NEST_MAX') }}}:

case {{{ cDefine('_SC_TTY_NAME_MAX') }}}:

return 32;

case {{{ cDefine('_SC_ATEXIT_MAX') }}}:

case {{{ cDefine('_SC_DELAYTIMER_MAX') }}}:

case {{{ cDefine('_SC_SEM_VALUE_MAX') }}}:

return 2147483647;

case {{{ cDefine('_SC_SIGQUEUE_MAX') }}}:

case {{{ cDefine('_SC_CHILD_MAX') }}}:

return 47839;

case {{{ cDefine('_SC_BC_SCALE_MAX') }}}:

case {{{ cDefine('_SC_BC_BASE_MAX') }}}:

return 99;

case {{{ cDefine('_SC_LINE_MAX') }}}:

case {{{ cDefine('_SC_BC_DIM_MAX') }}}:

return 2048;

case {{{ cDefine('_SC_ARG_MAX') }}}: return 2097152;

case {{{ cDefine('_SC_NGROUPS_MAX') }}}: return 65536;

case {{{ cDefine('_SC_MQ_PRIO_MAX') }}}: return 32768;

case {{{ cDefine('_SC_RE_DUP_MAX') }}}: return 32767;

case {{{ cDefine('_SC_THREAD_STACK_MIN') }}}: return 16384;

case {{{ cDefine('_SC_BC_STRING_MAX') }}}: return 1000;

case {{{ cDefine('_SC_XOPEN_VERSION') }}}: return 700;

case {{{ cDefine('_SC_LOGIN_NAME_MAX') }}}: return 256;

case {{{ cDefine('_SC_COLL_WEIGHTS_MAX') }}}: return 255;

case {{{ cDefine('_SC_CLK_TCK') }}}: return 100;

case {{{ cDefine('_SC_HOST_NAME_MAX') }}}: return 64;

case {{{ cDefine('_SC_AIO_PRIO_DELTA_MAX') }}}: return 20;

case {{{ cDefine('_SC_STREAM_MAX') }}}: return 16;

case {{{ cDefine('_SC_TZNAME_MAX') }}}: return 6;

case {{{ cDefine('_SC_THREAD_DESTRUCTOR_ITERATIONS') }}}: return 4;

case {{{ cDefine('_SC_NPROCESSORS_ONLN') }}}: {

if (typeof navigator === 'object') return navigator['hardwareConcurrency'] || 1;

return 1;

}

}

setErrNo({{{ cDefine('EINVAL') }}});

return -1;

},

emscripten_get_heap_size: function() {

return HEAPU8.length;

},

#if ABORTING_MALLOC

$abortOnCannotGrowMemory: function(requestedSize) {

#if ASSERTIONS

#if ALLOW_MEMORY_GROWTH

abort('Cannot enlarge memory arrays to size ' + requestedSize + ' bytes (OOM). If you want malloc to return NULL (0) instead of this abort, do not link with -s ABORTING_MALLOC=1 (that is, the default when growth is enabled is to not abort, but you have overridden that)');

#else // ALLOW_MEMORY_GROWTH

abort('Cannot enlarge memory arrays to size ' + requestedSize + ' bytes (OOM). Either (1) compile with -s INITIAL_MEMORY=X with X higher than the current value ' + HEAP8.length + ', (2) compile with -s ALLOW_MEMORY_GROWTH=1 which allows increasing the size at runtime, or (3) if you want malloc to return NULL (0) instead of this abort, compile with -s ABORTING_MALLOC=0 ');

#endif // ALLOW_MEMORY_GROWTH

#else // ASSERTIONS

abort('OOM');

#endif // ASSERTIONS

},

#endif // ABORTING_MALLOC

#if TEST_MEMORY_GROWTH_FAILS

$emscripten_realloc_buffer: function(size) {

return false;

},

#else

// Grows the wasm memory to the given byte size, and updates the JS views to

// it. Returns 1 on success, 0 on error.

$emscripten_realloc_buffer: function(size) {

#if MEMORYPROFILER

var oldHeapSize = buffer.byteLength;

#endif

try {

// round size grow request up to wasm page size (fixed 64KB per spec)

wasmMemory.grow((size - buffer.byteLength + 65535) >>> 16); // .grow() takes a delta compared to the previous size

updateGlobalBufferAndViews(wasmMemory.buffer);

#if MEMORYPROFILER

if (typeof emscriptenMemoryProfiler !== 'undefined') {

emscriptenMemoryProfiler.onMemoryResize(oldHeapSize, buffer.byteLength);

}

#endif

return 1 /*success*/;

} catch(e) {

#if ASSERTIONS

console.error('emscripten_realloc_buffer: Attempted to grow heap from ' + buffer.byteLength + ' bytes to ' + size + ' bytes, but got error: ' + e);

#endif

}

// implicit 0 return to save code size (caller will cast "undefined" into 0

// anyhow)

},

#endif // ~TEST_MEMORY_GROWTH_FAILS

emscripten_resize_heap__deps: ['emscripten_get_heap_size'

#if ASSERTIONS == 2

, 'emscripten_get_now'

#endif

#if ABORTING_MALLOC

, '$abortOnCannotGrowMemory'

#endif

#if ALLOW_MEMORY_GROWTH

, '$emscripten_realloc_buffer'

#endif

],

emscripten_resize_heap: function(requestedSize) {

requestedSize = requestedSize >>> 0;

#if ALLOW_MEMORY_GROWTH == 0

#if ABORTING_MALLOC

abortOnCannotGrowMemory(requestedSize);

#else

return false; // malloc will report failure

#endif // ABORTING_MALLOC

#else // ALLOW_MEMORY_GROWTH == 0

var oldSize = _emscripten_get_heap_size();

// With pthreads, races can happen (another thread might increase the size in between), so return a failure, and let the caller retry.

#if USE_PTHREADS

if (requestedSize <= oldSize) {

return false;

}

#endif // USE_PTHREADS

#if ASSERTIONS && !USE_PTHREADS

assert(requestedSize > oldSize);

#endif

#if EMSCRIPTEN_TRACING

// Report old layout one last time

_emscripten_trace_report_memory_layout();

#endif

// Memory resize rules:

// 1. When resizing, always produce a resized heap that is at least 16MB (to avoid tiny heap sizes receiving lots of repeated resizes at startup)

// 2. Always increase heap size to at least the requested size, rounded up to next page multiple.

// 3a. If MEMORY_GROWTH_LINEAR_STEP == -1, excessively resize the heap geometrically: increase the heap size according to

// MEMORY_GROWTH_GEOMETRIC_STEP factor (default +20%),

// At most overreserve by MEMORY_GROWTH_GEOMETRIC_CAP bytes (default 96MB).

// 3b. If MEMORY_GROWTH_LINEAR_STEP != -1, excessively resize the heap linearly: increase the heap size by at least MEMORY_GROWTH_LINEAR_STEP bytes.

// 4. Max size for the heap is capped at 2048MB-WASM_PAGE_SIZE, or by MAXIMUM_MEMORY, or by ASAN limit, depending on which is smallest

// 5. If we were unable to allocate as much memory, it may be due to over-eager decision to excessively reserve due to (3) above.

// Hence if an allocation fails, cut down on the amount of excess growth, in an attempt to succeed to perform a smaller allocation.

#if MAXIMUM_MEMORY != -1

// A limit was set for how much we can grow. We should not exceed that

// (the wasm binary specifies it, so if we tried, we'd fail anyhow).

var maxHeapSize = {{{ MAXIMUM_MEMORY }}};

#else

var maxHeapSize = {{{ CAN_ADDRESS_2GB ? 4294967296 : 2147483648 }}} - {{{ WASM_PAGE_SIZE }}};

#endif

if (requestedSize > maxHeapSize) {

#if ASSERTIONS

err('Cannot enlarge memory, asked to go up to ' + requestedSize + ' bytes, but the limit is ' + maxHeapSize + ' bytes!');

#endif

#if ABORTING_MALLOC

abortOnCannotGrowMemory(requestedSize);

#else

return false;

#endif

}

#if USE_ASAN

// One byte of ASan's shadow memory shadows 8 bytes of real memory. Shadow memory area has a fixed size,

// so do not allow resizing past that limit.

maxHeapSize = Math.min(maxHeapSize, {{{ 8 * ASAN_SHADOW_SIZE }}});

if (requestedSize > maxHeapSize) {

#if ASSERTIONS

err('Failed to grow the heap from ' + oldSize + ', as we reached the limit of our shadow memory. Increase ASAN_SHADOW_SIZE.');

#endif

#if ABORTING_MALLOC

abortOnCannotGrowMemory(requestedSize);

#else

return false;

#endif

}

#endif

var minHeapSize = 16777216;

// Loop through potential heap size increases. If we attempt a too eager reservation that fails, cut down on the

// attempted size and reserve a smaller bump instead. (max 3 times, chosen somewhat arbitrarily)

for(var cutDown = 1; cutDown <= 4; cutDown *= 2) {

#if MEMORY_GROWTH_LINEAR_STEP == -1

var overGrownHeapSize = oldSize * (1 + {{{ MEMORY_GROWTH_GEOMETRIC_STEP }}} / cutDown); // ensure geometric growth

#if MEMORY_GROWTH_GEOMETRIC_CAP

// but limit overreserving (default to capping at +96MB overgrowth at most)

overGrownHeapSize = Math.min(overGrownHeapSize, requestedSize + {{{ MEMORY_GROWTH_GEOMETRIC_CAP }}} );

#endif

#else

var overGrownHeapSize = oldSize + {{{ MEMORY_GROWTH_LINEAR_STEP }}} / cutDown; // ensure linear growth

#endif

var newSize = Math.min(maxHeapSize, alignUp(Math.max(minHeapSize, requestedSize, overGrownHeapSize), {{{ WASM_PAGE_SIZE }}}));

#if ASSERTIONS == 2

var t0 = _emscripten_get_now();

#endif

var replacement = emscripten_realloc_buffer(newSize);

#if ASSERTIONS == 2

var t1 = _emscripten_get_now();

console.log('Heap resize call from ' + oldSize + ' to ' + newSize + ' took ' + (t1 - t0) + ' msecs. Success: ' + !!replacement);

#endif

if (replacement) {

#if ASSERTIONS && WASM2JS

err('Warning: Enlarging memory arrays, this is not fast! ' + [oldSize, newSize]);

#endif

#if EMSCRIPTEN_TRACING

_emscripten_trace_js_log_message("Emscripten", "Enlarging memory arrays from " + oldSize + " to " + newSize);

// And now report the new layout

_emscripten_trace_report_memory_layout();

#endif

return true;

}

}

#if ASSERTIONS

err('Failed to grow the heap from ' + oldSize + ' bytes to ' + newSize + ' bytes, not enough memory!');

#endif

#if ABORTING_MALLOC

abortOnCannotGrowMemory(requestedSize);

#else

return false;

#endif

#endif // ALLOW_MEMORY_GROWTH

},

// Called after wasm grows memory. At that time we need to update the views.

// Without this notification, we'd need to check the buffer in JS every time

// we return from any wasm, which adds overhead. See

// https://github.com/WebAssembly/WASI/issues/82

emscripten_notify_memory_growth: function(memoryIndex) {

#if ASSERTIONS

assert(memoryIndex == 0);

#endif

updateGlobalBufferAndViews(wasmMemory.buffer);

},

system__deps: ['$setErrNo'],

system: function(command) {

#if ENVIRONMENT_MAY_BE_NODE

if (ENVIRONMENT_IS_NODE) {

if (!command) return 1; // shell is available

var cmdstr = UTF8ToString(command);

if (!cmdstr.length) return 0; // this is what glibc seems to do (shell works test?)

var cp = require('child_process');

var ret = cp.spawnSync(cmdstr, [], {shell:true, stdio:'inherit'});

var _W_EXITCODE = function(ret, sig) {

return ((ret) << 8 | (sig));

}

// this really only can happen if process is killed by signal

if (ret.status === null) {

// sadly node doesn't expose such function

var signalToNumber = function(sig) {

// implement only the most common ones, and fallback to SIGINT

switch (sig) {

case 'SIGHUP': return 1;

case 'SIGINT': return 2;

case 'SIGQUIT': return 3;

case 'SIGFPE': return 8;

case 'SIGKILL': return 9;

case 'SIGALRM': return 14;

case 'SIGTERM': return 15;

}

return 2; // SIGINT

}

return _W_EXITCODE(0, signalToNumber(ret.signal));

}

return _W_EXITCODE(ret.status, 0);

}

#endif // ENVIRONMENT_MAY_BE_NODE

// int system(const char *command);

// http://pubs.opengroup.org/onlinepubs/000095399/functions/system.html

// Can't call external programs.

if (!command) return 0; // no shell available

setErrNo({{{ cDefine('EAGAIN') }}});

return -1;

},

// ==========================================================================

// stdlib.h

// ==========================================================================

abs: 'Math_abs',

labs: 'Math_abs',

_ZSt9terminatev__deps: ['exit'],

_ZSt9terminatev: function() {

_exit(-1234);

},

#if MINIMAL_RUNTIME && !EXIT_RUNTIME

atexit__sig: 'v', // atexit unsupported in MINIMAL_RUNTIME

atexit: function(){},

__cxa_atexit: function(){},

#else

atexit__proxy: 'sync',

atexit__sig: 'iii',

atexit: function(func, arg) {

#if EXIT_RUNTIME

__ATEXIT__.unshift({ func: func, arg: arg });

#endif

},

__cxa_atexit: 'atexit',

#endif

// used in rust, clang when doing thread_local statics

#if USE_PTHREADS

__cxa_thread_atexit: 'pthread_cleanup_push',

__cxa_thread_atexit_impl: 'pthread_cleanup_push',

#else

__cxa_thread_atexit: 'atexit',

__cxa_thread_atexit_impl: 'atexit',

#endif

// TODO: There are currently two abort() functions that get imported to asm module scope: the built-in runtime function abort(),

// and this function _abort(). Remove one of these, importing two functions for the same purpose is wasteful.

abort: function() {

#if MINIMAL_RUNTIME

// In MINIMAL_RUNTIME the module object does not exist, so its behavior to abort is to throw directly.

throw 'abort';

#else

abort();

#endif

},

// This object can be modified by the user during startup, which affects

// the initial values of the environment accessible by getenv. (This works

// in both fastcomp and upstream).

$ENV: {},

getloadavg: function(loadavg, nelem) {

// int getloadavg(double loadavg[], int nelem);

// http://linux.die.net/man/3/getloadavg

var limit = Math.min(nelem, 3);

var doubleSize = {{{ Runtime.getNativeTypeSize('double') }}};

for (var i = 0; i < limit; i++) {

{{{ makeSetValue('loadavg', 'i * doubleSize', '0.1', 'double') }}};

}

return limit;

},

// ==========================================================================

// string.h

// ==========================================================================

memcpy__inline: function(dest, src, num, align) {

var ret = '';

ret += makeCopyValues(dest, src, num, 'null', null, align);

return ret;

},

#if MIN_CHROME_VERSION < 45 || MIN_EDGE_VERSION < 14 || MIN_FIREFOX_VERSION < 34 || MIN_IE_VERSION != TARGET_NOT_SUPPORTED || MIN_SAFARI_VERSION < 100101 || STANDALONE_WASM

// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray/copyWithin lists browsers that support TypedArray.prototype.copyWithin, but it

// has outdated information for Safari, saying it would not support it.

// https://github.com/WebKit/webkit/commit/24a800eea4d82d6d595cdfec69d0f68e733b5c52#diff-c484911d8df319ba75fce0d8e7296333R1 suggests support was added on Aug 28, 2015.

// Manual testing suggests:

// Safari/601.1 Version/9.0 on iPhone 4s with iOS 9.3.6 (released September 30, 2015) does not support copyWithin.

// but the following systems do:

// AppleWebKit/602.2.14 Safari/602.1 Version/10.0 Mobile/14B100 iPhone OS 10_1_1 on iPhone 5s with iOS 10.1.1 (released October 31, 2016)

// AppleWebKit/603.3.8 Safari/602.1 Version/10.0 on iPhone 5 with iOS 10.3.4 (released July 22, 2019)

// AppleWebKit/605.1.15 iPhone OS 12_3_1 Version/12.1.1 Safari/604.1 on iPhone SE with iOS 12.3.1

// AppleWebKit/605.1.15 Safari/604.1 Version/13.0.4 iPhone OS 13_3 on iPhone 6s with iOS 13.3

// AppleWebKit/605.1.15 Version/13.0.3 Intel Mac OS X 10_15_1 on Safari 13.0.3 (15608.3.10.1.4) on macOS Catalina 10.15.1

// Hence the support status of .copyWithin() for Safari version range [10.0.0, 10.1.0] is unknown.

emscripten_memcpy_big__import: true,

emscripten_memcpy_big: '= Uint8Array.prototype.copyWithin\n' +

' ? function(dest, src, num) { HEAPU8.copyWithin(dest, src, src + num); }\n' +

' : function(dest, src, num) { HEAPU8.set(HEAPU8.subarray(src, src+num), dest); }\n',

#else

emscripten_memcpy_big: function(dest, src, num) {

HEAPU8.copyWithin(dest, src, src + num);

},

#endif

// ==========================================================================

// GCC/LLVM specifics

// ==========================================================================

__builtin_prefetch: function(){},

__assert_fail: function(condition, filename, line, func) {

abort('Assertion failed: ' + UTF8ToString(condition) + ', at: ' + [filename ? UTF8ToString(filename) : 'unknown filename', line, func ? UTF8ToString(func) : 'unknown function']);

},

__assert_func: function(filename, line, func, condition) {

abort('Assertion failed: ' + (condition ? UTF8ToString(condition) : 'unknown condition') + ', at: ' + [filename ? UTF8ToString(filename) : 'unknown filename', line, func ? UTF8ToString(func) : 'unknown function']);

},

terminate__sig: 'vi',

terminate: '__cxa_call_unexpected',

__gxx_personality_v0: function() {

},

__gcc_personality_v0: function() {

},

// ==========================================================================

// pwd.h

// ==========================================================================

// TODO: Implement.

// http://pubs.opengroup.org/onlinepubs/009695399/basedefs/pwd.h.html

getpwuid: function(uid) {

return 0; // NULL

},

// ==========================================================================

// time.h

// ==========================================================================

clock: function() {

if (_clock.start === undefined) _clock.start = Date.now();

return ((Date.now() - _clock.start) * ({{{ cDefine('CLOCKS_PER_SEC') }}} / 1000))|0;

},

time: function(ptr) {

var ret = (Date.now()/1000)|0;

if (ptr) {

{{{ makeSetValue('ptr', 0, 'ret', 'i32') }}};

}

return ret;

},

difftime: function(time1, time0) {

return time1 - time0;

},

mktime__deps: ['tzset'],

mktime__sig: 'ii',

mktime: function(tmPtr) {

_tzset();

var date = new Date({{{ makeGetValue('tmPtr', C_STRUCTS.tm.tm_year, 'i32') }}} + 1900,

{{{ makeGetValue('tmPtr', C_STRUCTS.tm.tm_mon, 'i32') }}},

{{{ makeGetValue('tmPtr', C_STRUCTS.tm.tm_mday, 'i32') }}},

{{{ makeGetValue('tmPtr', C_STRUCTS.tm.tm_hour, 'i32') }}},

{{{ makeGetValue('tmPtr', C_STRUCTS.tm.tm_min, 'i32') }}},

{{{ makeGetValue('tmPtr', C_STRUCTS.tm.tm_sec, 'i32') }}},

0);

// There's an ambiguous hour when the time goes back; the tm_isdst field is

// used to disambiguate it. Date() basically guesses, so we fix it up if it

// guessed wrong, or fill in tm_isdst with the guess if it's -1.

var dst = {{{ makeGetValue('tmPtr', C_STRUCTS.tm.tm_isdst, 'i32') }}};

var guessedOffset = date.getTimezoneOffset();

var start = new Date(date.getFullYear(), 0, 1);

var summerOffset = new Date(date.getFullYear(), 6, 1).getTimezoneOffset();

var winterOffset = start.getTimezoneOffset();

var dstOffset = Math.min(winterOffset, summerOffset); // DST is in December in South

if (dst < 0) {

// Attention: some regions don't have DST at all.

{{{ makeSetValue('tmPtr', C_STRUCTS.tm.tm_isdst, 'Number(summerOffset != winterOffset && dstOffset == guessedOffset)', 'i32') }}};

} else if ((dst > 0) != (dstOffset == guessedOffset)) {

var nonDstOffset = Math.max(winterOffset, summerOffset);

var trueOffset = dst > 0 ? dstOffset : nonDstOffset;

// Don't try setMinutes(date.getMinutes() + ...) -- it's messed up.

date.setTime(date.getTime() + (trueOffset - guessedOffset)*60000);

}

{{{ makeSetValue('tmPtr', C_STRUCTS.tm.tm_wday, 'date.getDay()', 'i32') }}};

var yday = ((date.getTime() - start.getTime()) / (1000 * 60 * 60 * 24))|0;

{{{ makeSetValue('tmPtr', C_STRUCTS.tm.tm_yday, 'yday', 'i32') }}};

return (date.getTime() / 1000)|0;

},

timelocal: 'mktime',

#if MINIMAL_RUNTIME

gmtime_r__deps: ['allocateUTF8'],

#endif

gmtime_r__sig: 'iii',

gmtime_r: function(time, tmPtr) {

var date = new Date({{{ makeGetValue('time', 0, 'i32') }}}*1000);

{{{ makeSetValue('tmPtr', C_STRUCTS.tm.tm_sec, 'date.getUTCSeconds()', 'i32') }}};

{{{ makeSetValue('tmPtr', C_STRUCTS.tm.tm_min, 'date.getUTCMinutes()', 'i32') }}};

{{{ makeSetValue('tmPtr', C_STRUCTS.tm.tm_hour, 'date.getUTCHours()', 'i32') }}};

{{{ makeSetValue('tmPtr', C_STRUCTS.tm.tm_mday, 'date.getUTCDate()', 'i32') }}};

{{{ makeSetValue('tmPtr', C_STRUCTS.tm.tm_mon, 'date.getUTCMonth()', 'i32') }}};

{{{ makeSetValue('tmPtr', C_STRUCTS.tm.tm_year, 'date.getUTCFullYear()-1900', 'i32') }}};

{{{ makeSetValue('tmPtr', C_STRUCTS.tm.tm_wday, 'date.getUTCDay()', 'i32') }}};

{{{ makeSetValue('tmPtr', C_STRUCTS.tm.tm_gmtoff, '0', 'i32') }}};

{{{ makeSetValue('tmPtr', C_STRUCTS.tm.tm_isdst, '0', 'i32') }}};

var start = Date.UTC(date.getUTCFullYear(), 0, 1, 0, 0, 0, 0);

var yday = ((date.getTime() - start) / (1000 * 60 * 60 * 24))|0;

{{{ makeSetValue('tmPtr', C_STRUCTS.tm.tm_yday, 'yday', 'i32') }}};

// Allocate a string "GMT" for us to point to.

if (!_gmtime_r.GMTString) _gmtime_r.GMTString = allocateUTF8("GMT");

{{{ makeSetValue('tmPtr', C_STRUCTS.tm.tm_zone, '_gmtime_r.GMTString', 'i32') }}};

return tmPtr;

},

__gmtime_r: 'gmtime_r',

timegm__deps: ['tzset'],

timegm: function(tmPtr) {

_tzset();

var time = Date.UTC({{{ makeGetValue('tmPtr', C_STRUCTS.tm.tm_year, 'i32') }}} + 1900,

{{{ makeGetValue('tmPtr', C_STRUCTS.tm.tm_mon, 'i32') }}},

{{{ makeGetValue('tmPtr', C_STRUCTS.tm.tm_mday, 'i32') }}},

{{{ makeGetValue('tmPtr', C_STRUCTS.tm.tm_hour, 'i32') }}},

{{{ makeGetValue('tmPtr', C_STRUCTS.tm.tm_min, 'i32') }}},

{{{ makeGetValue('tmPtr', C_STRUCTS.tm.tm_sec, 'i32') }}},

0);

var date = new Date(time);

{{{ makeSetValue('tmPtr', C_STRUCTS.tm.tm_wday, 'date.getUTCDay()', 'i32') }}};

var start = Date.UTC(date.getUTCFullYear(), 0, 1, 0, 0, 0, 0);

var yday = ((date.getTime() - start) / (1000 * 60 * 60 * 24))|0;

{{{ makeSetValue('tmPtr', C_STRUCTS.tm.tm_yday, 'yday', 'i32') }}};

return (date.getTime() / 1000)|0;

},

localtime_r__deps: ['tzset'],

localtime_r__sig: 'iii',

localtime_r: function(time, tmPtr) {

_tzset();

var date = new Date({{{ makeGetValue('time', 0, 'i32') }}}*1000);

{{{ makeSetValue('tmPtr', C_STRUCTS.tm.tm_sec, 'date.getSeconds()', 'i32') }}};

{{{ makeSetValue('tmPtr', C_STRUCTS.tm.tm_min, 'date.getMinutes()', 'i32') }}};

{{{ makeSetValue('tmPtr', C_STRUCTS.tm.tm_hour, 'date.getHours()', 'i32') }}};

{{{ makeSetValue('tmPtr', C_STRUCTS.tm.tm_mday, 'date.getDate()', 'i32') }}};

{{{ makeSetValue('tmPtr', C_STRUCTS.tm.tm_mon, 'date.getMonth()', 'i32') }}};

{{{ makeSetValue('tmPtr', C_STRUCTS.tm.tm_year, 'date.getFullYear()-1900', 'i32') }}};

{{{ makeSetValue('tmPtr', C_STRUCTS.tm.tm_wday, 'date.getDay()', 'i32') }}};

var start = new Date(date.getFullYear(), 0, 1);

var yday = ((date.getTime() - start.getTime()) / (1000 * 60 * 60 * 24))|0;

{{{ makeSetValue('tmPtr', C_STRUCTS.tm.tm_yday, 'yday', 'i32') }}};

{{{ makeSetValue('tmPtr', C_STRUCTS.tm.tm_gmtoff, '-(date.getTimezoneOffset() * 60)', 'i32') }}};

// Attention: DST is in December in South, and some regions don't have DST at all.

var summerOffset = new Date(date.getFullYear(), 6, 1).getTimezoneOffset();

var winterOffset = start.getTimezoneOffset();

var dst = (summerOffset != winterOffset && date.getTimezoneOffset() == Math.min(winterOffset, summerOffset))|0;

{{{ makeSetValue('tmPtr', C_STRUCTS.tm.tm_isdst, 'dst', 'i32') }}};

var zonePtr = {{{ makeGetValue('__get_tzname()', 'dst ? ' + Runtime.QUANTUM_SIZE + ' : 0', 'i32') }}};

{{{ makeSetValue('tmPtr', C_STRUCTS.tm.tm_zone, 'zonePtr', 'i32') }}};

return tmPtr;

},

__localtime_r: 'localtime_r',

asctime_r__deps: ['mktime'],

asctime_r__sig: 'iii',

asctime_r: function(tmPtr, buf) {

var date = {

tm_sec: {{{ makeGetValue('tmPtr', C_STRUCTS.tm.tm_sec, 'i32') }}},

tm_min: {{{ makeGetValue('tmPtr', C_STRUCTS.tm.tm_min, 'i32') }}},

tm_hour: {{{ makeGetValue('tmPtr', C_STRUCTS.tm.tm_hour, 'i32') }}},

tm_mday: {{{ makeGetValue('tmPtr', C_STRUCTS.tm.tm_mday, 'i32') }}},

tm_mon: {{{ makeGetValue('tmPtr', C_STRUCTS.tm.tm_mon, 'i32') }}},

tm_year: {{{ makeGetValue('tmPtr', C_STRUCTS.tm.tm_year, 'i32') }}},

tm_wday: {{{ makeGetValue('tmPtr', C_STRUCTS.tm.tm_wday, 'i32') }}}

};

var days = [ "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat" ];

var months = [ "Jan", "Feb", "Mar", "Apr", "May", "Jun",

"Jul", "Aug", "Sep", "Oct", "Nov", "Dec" ];

var s = days[date.tm_wday] + ' ' + months[date.tm_mon] +

(date.tm_mday < 10 ? ' ' : ' ') + date.tm_mday +

(date.tm_hour < 10 ? ' 0' : ' ') + date.tm_hour +

(date.tm_min < 10 ? ':0' : ':') + date.tm_min +

(date.tm_sec < 10 ? ':0' : ':') + date.tm_sec +

' ' + (1900 + date.tm_year) + "\n";

// asctime_r is specced to behave in an undefined manner if the algorithm would attempt

// to write out more than 26 bytes (including the null terminator).

// See http://pubs.opengroup.org/onlinepubs/9699919799/functions/asctime.html

// Our undefined behavior is to truncate the write to at most 26 bytes, including null terminator.

stringToUTF8(s, buf, 26);

return buf;

},

__asctime_r: 'asctime_r',

ctime_r__deps: ['localtime_r', 'asctime_r'],

ctime_r__sig: 'iii',

ctime_r: function(time, buf) {

var stack = stackSave();

var rv = _asctime_r(_localtime_r(time, stackAlloc({{{ C_STRUCTS.tm.__size__ }}})), buf);

stackRestore(stack);

return rv;

},

__ctime_r: 'ctime_r',

dysize: function(year) {

var leap = ((year % 4 == 0) && ((year % 100 != 0) || (year % 400 == 0)));

return leap ? 366 : 365;

},

// TODO: Initialize these to defaults on startup from system settings.

// Note: glibc has one fewer underscore for all of these. Also used in other related functions (timegm)

tzset__proxy: 'sync',

tzset__sig: 'v',

#if MINIMAL_RUNTIME

tzset__deps: ['$allocateUTF8'],

#endif

tzset: function() {

// TODO: Use (malleable) environment variables instead of system settings.