From b3c4053a10f79a61928571b5f3faa34e598890bd Mon Sep 17 00:00:00 2001 From: Volodymyr Shymanskyy Date: Thu, 14 Nov 2019 14:46:51 +0200 Subject: [PATCH] Update CoreMark --- test/benchmark/coremark/README.md | 3 +- test/benchmark/coremark/coremark-side.wasm | Bin 0 -> 13678 bytes test/benchmark/coremark/coremark.html | 1301 ++++++++++- test/benchmark/coremark/coremark.js | 2300 +++++++++++++++++++- test/benchmark/coremark/coremark.wasm | Bin 26922 -> 55873 bytes 5 files changed, 3583 insertions(+), 21 deletions(-) create mode 100644 test/benchmark/coremark/coremark-side.wasm diff --git a/test/benchmark/coremark/README.md b/test/benchmark/coremark/README.md index 3eef4a4..7bb9cf1 100644 --- a/test/benchmark/coremark/README.md +++ b/test/benchmark/coremark/README.md @@ -3,7 +3,8 @@ The `coremark` files in this directory were produced by: ```sh -$ make compile PORT_DIR=linux CC=emcc EXE=.html XCFLAGS="-O3 --llvm-lto 3 --closure 1" +$ make compile PORT_DIR=linux CC=emcc EXE=-side.wasm XCFLAGS="-O3 -s SIDE_MODULE=1 --llvm-lto 3" +$ make compile PORT_DIR=linux CC=emcc EXE=.html XCFLAGS="-O3 -g2 --llvm-lto 3 --closure 1" $ make compile PORT_DIR=linux CC=wasicc EXE=-wasi.wasm XCFLAGS="-Ofast -flto" ``` diff --git a/test/benchmark/coremark/coremark-side.wasm b/test/benchmark/coremark/coremark-side.wasm new file mode 100644 index 0000000000000000000000000000000000000000..0e90f88fb07aa2e177038f99ceb7d9a99ae6dc2b GIT binary patch literal 13678 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 literal 0 HcmV?d00001 diff --git a/test/benchmark/coremark/coremark.html b/test/benchmark/coremark/coremark.html index 1193b90..8f061ea 100644 --- a/test/benchmark/coremark/coremark.html +++ b/test/benchmark/coremark/coremark.html @@ -1 +1,1300 @@ -Emscripten-Generated Codeimage/svg+xml
Downloading...
Resize canvasLock/hide mouse pointer    
\ No newline at end of file + + + + + + Emscripten-Generated Code + + + + + image/svg+xml + + + +
Downloading...
+ + + Resize canvas + Lock/hide mouse pointer     + + + + +
+ +
+ + +
+ +
+ + + + + + + + diff --git a/test/benchmark/coremark/coremark.js b/test/benchmark/coremark/coremark.js index e53e04f..6a69975 100644 --- a/test/benchmark/coremark/coremark.js +++ b/test/benchmark/coremark/coremark.js @@ -1,19 +1,2281 @@ -var b;b||(b=typeof Module !== 'undefined' ? Module : {});var l={},n;for(n in b)b.hasOwnProperty(n)&&(l[n]=b[n]);var p=[],r="./this.program";function t(a,c){throw c;}var u=!1,v=!1,w=!1,ca=!1,da=!1;u="object"===typeof window;v="function"===typeof importScripts;w=(ca="object"===typeof process&&"object"===typeof process.versions&&"string"===typeof process.versions.node)&&!u&&!v;da=!u&&!w&&!v;var x="",B,C; -if(w){x=__dirname+"/";var D,E;B=function(a,c){D||(D=require("fs"));E||(E=require("path"));a=E.normalize(a);a=D.readFileSync(a);return c?a:a.toString()};C=function(a){a=B(a,!0);a.buffer||(a=new Uint8Array(a));a.buffer||F("Assertion failed: undefined");return a};1=e&&(e=65536+((e&1023)<<10)|a.charCodeAt(++d)&1023);127>=e?++c:c=2047>=e?c+2:65535>=e?c+3:c+4}var g=c+1;c=ja(g);d=c;e=ka;if(0=f){var k=a.charCodeAt(++h);f=65536+((f&1023)<<10)|k&1023}if(127>=f){if(d>=g)break;e[d++]=f}else{if(2047>=f){if(d+1>=g)break;e[d++]=192|f>>6}else{if(65535>=f){if(d+2>=g)break;e[d++]=224|f>>12}else{if(d+3>=g)break; -e[d++]=240|f>>18;e[d++]=128|f>>12&63}e[d++]=128|f>>6&63}e[d++]=128|f&63}}e[d]=0}return c}var buffer,ka,M,N,O=b.TOTAL_MEMORY||16777216;b.wasmMemory?K=b.wasmMemory:K=new WebAssembly.Memory({initial:O/65536,maximum:O/65536});K&&(buffer=K.buffer);O=buffer.byteLength;var P=buffer;buffer=P;b.HEAP8=ka=new Int8Array(P);b.HEAP16=new Int16Array(P);b.HEAP32=N=new Int32Array(P);b.HEAPU8=M=new Uint8Array(P);b.HEAPU16=new Uint16Array(P);b.HEAPU32=new Uint32Array(P);b.HEAPF32=new Float32Array(P);b.HEAPF64=new Float64Array(P); -N[1292]=5248240;function Q(a){for(;0>2]=28),-1;N[c>>2]=a/1E3|0;N[c+4>>2]=a%1E3*1E6|0;return 0},b:function(a,c,d){M.set(M.subarray(c,c+d),a)},c:function(){F("OOM")},d:function(a,c,d,e){try{for(var g=0,h=0;h>2],k=N[c+(8*h+4)>>2],X=0;X=z);)++A;if(16m)z+=String.fromCharCode(m);else{var sa=m-65536;z+=String.fromCharCode(55296|sa>>10,56320|sa&1023)}}}else z+=String.fromCharCode(m)}qa=z}Da(qa);Z.length= -0}else Z.push(Y)}g+=k}N[e>>2]=g;return 0}catch(ba){return"undefined"!==typeof FS&&ba instanceof FS.l||F(ba),ba.m}},memory:K,table:fa},Aa=function(){function a(a){b.asm=a.exports;R--;b.monitorRunDependencies&&b.monitorRunDependencies(R);0==R&&(null!==S&&(clearInterval(S),S=null),T&&(a=T,T=null,a()))}function c(c){a(c.instance)}function d(a){return wa().then(function(a){return WebAssembly.instantiate(a,e)}).then(a,function(a){H("failed to asynchronously prepare wasm: "+a);F(a)})}var e={env:za,wasi_unstable:za}; -R++;b.monitorRunDependencies&&b.monitorRunDependencies(R);if(b.instantiateWasm)try{return b.instantiateWasm(e,a)}catch(g){return H("Module.instantiateWasm callback failed with error: "+g),!1}(function(){if(I||"function"!==typeof WebAssembly.instantiateStreaming||ta()||"function"!==typeof fetch)return d(c);fetch(U,{credentials:"same-origin"}).then(function(a){return WebAssembly.instantiateStreaming(a,e).then(c,function(a){H("wasm streaming compile failed: "+a);H("falling back to ArrayBuffer instantiation"); -d(c)})})})();return{}}();b.asm=Aa;var xa=b.___wasm_call_ctors=function(){return b.asm.e.apply(null,arguments)};b._main=function(){return b.asm.f.apply(null,arguments)};b.___errno_location=function(){return b.asm.g.apply(null,arguments)};var ja=b.stackAlloc=function(){return b.asm.h.apply(null,arguments)};b.asm=Aa;var W;function G(a){this.name="ExitStatus";this.message="Program terminated with exit("+a+")";this.status=a}T=function Ba(){W||Ca();W||(T=Ba)}; -function Ca(a){function c(){if(!W&&(W=!0,!L)){Q(ma);Q(na);if(b.onRuntimeInitialized)b.onRuntimeInitialized();if(Ea){var c=a;c=c||[];var e=c.length+1,g=ja(4*(e+1));N[g>>2]=ia(r);for(var h=1;h>2)+h]=ia(c[h-1]);N[(g>>2)+e]=0;try{var f=b._main(e,g);if(!J||0!==f){if(!J&&(L=!0,b.onExit))b.onExit(f);t(f,new G(f))}}catch(k){k instanceof G||("SimulateInfiniteLoop"==k?J=!0:((c=k)&&"object"===typeof k&&k.stack&&(c=[k,k.stack]),H("exception thrown: "+c),t(1,k)))}finally{}}if(b.postRun)for("function"== -typeof b.postRun&&(b.postRun=[b.postRun]);b.postRun.length;)c=b.postRun.shift(),oa.unshift(c);Q(oa)}}a=a||p;if(!(0 1) { + thisProgram = process['argv'][1].replace(/\\/g, '/'); + } + + arguments_ = process['argv'].slice(2); + + if (typeof module !== 'undefined') { + module['exports'] = Module; + } + + process['on']('uncaughtException', function(ex) { + // suppress ExitStatus exceptions from showing an error + if (!(ex instanceof ExitStatus)) { + throw ex; + } + }); + + process['on']('unhandledRejection', abort); + + quit_ = function(status) { + process['exit'](status); + }; + + Module['inspect'] = function () { return '[Emscripten Module object]'; }; +} else +if (ENVIRONMENT_IS_SHELL) { + + + if (typeof read != 'undefined') { + read_ = function shell_read(f) { + return read(f); + }; + } + + readBinary = function readBinary(f) { + var data; + if (typeof readbuffer === 'function') { + return new Uint8Array(readbuffer(f)); + } + data = read(f, 'binary'); + assert(typeof data === 'object'); + return data; + }; + + if (typeof scriptArgs != 'undefined') { + arguments_ = scriptArgs; + } else if (typeof arguments != 'undefined') { + arguments_ = arguments; + } + + if (typeof quit === 'function') { + quit_ = function(status) { + quit(status); + }; + } + + if (typeof print !== 'undefined') { + // Prefer to use print/printErr where they exist, as they usually work better. + if (typeof console === 'undefined') console = {}; + console.log = print; + console.warn = console.error = typeof printErr !== 'undefined' ? printErr : print; + } +} else +if (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER) { + if (ENVIRONMENT_IS_WORKER) { // Check worker, not web, since window could be polyfilled + scriptDirectory = self.location.href; + } else if (document.currentScript) { // web + scriptDirectory = document.currentScript.src; + } + // blob urls look like blob:http://site.com/etc/etc and we cannot infer anything from them. + // otherwise, slice off the final part of the url to find the script directory. + // if scriptDirectory does not contain a slash, lastIndexOf will return -1, + // and scriptDirectory will correctly be replaced with an empty string. + if (scriptDirectory.indexOf('blob:') !== 0) { + scriptDirectory = scriptDirectory.substr(0, scriptDirectory.lastIndexOf('/')+1); + } else { + scriptDirectory = ''; + } + + + read_ = function shell_read(url) { + var xhr = new XMLHttpRequest(); + xhr.open('GET', url, false); + xhr.send(null); + return xhr.responseText; + }; + + if (ENVIRONMENT_IS_WORKER) { + readBinary = function readBinary(url) { + var xhr = new XMLHttpRequest(); + xhr.open('GET', url, false); + xhr.responseType = 'arraybuffer'; + xhr.send(null); + return new Uint8Array(xhr.response); + }; + } + + readAsync = function readAsync(url, onload, onerror) { + var xhr = new XMLHttpRequest(); + xhr.open('GET', url, true); + xhr.responseType = 'arraybuffer'; + xhr.onload = function xhr_onload() { + if (xhr.status == 200 || (xhr.status == 0 && xhr.response)) { // file URLs can return 0 + onload(xhr.response); + return; + } + onerror(); + }; + xhr.onerror = onerror; + xhr.send(null); + }; + + setWindowTitle = function(title) { document.title = title }; +} else +{ +} + +// Set up the out() and err() hooks, which are how we can print to stdout or +// stderr, respectively. +var out = Module['print'] || console.log.bind(console); +var err = Module['printErr'] || console.warn.bind(console); + +// Merge back in the overrides +for (key in moduleOverrides) { + if (moduleOverrides.hasOwnProperty(key)) { + Module[key] = moduleOverrides[key]; + } +} +// Free the object hierarchy contained in the overrides, this lets the GC +// reclaim data used e.g. in memoryInitializerRequest, which is a large typed array. +moduleOverrides = null; + +// Emit code to handle expected values on the Module object. This applies Module.x +// to the proper local x. This has two benefits: first, we only emit it if it is +// expected to arrive, and second, by using a local everywhere else that can be +// minified. +if (Module['arguments']) arguments_ = Module['arguments']; +if (Module['thisProgram']) thisProgram = Module['thisProgram']; +if (Module['quit']) quit_ = Module['quit']; + +// perform assertions in shell.js after we set up out() and err(), as otherwise if an assertion fails it cannot print the message + +// TODO remove when SDL2 is fixed (also see above) + + + +// Copyright 2017 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. + +// {{PREAMBLE_ADDITIONS}} + +var STACK_ALIGN = 16; + + +function dynamicAlloc(size) { + var ret = HEAP32[DYNAMICTOP_PTR>>2]; + var end = (ret + size + 15) & -16; + if (end > _emscripten_get_heap_size()) { + abort(); + } + HEAP32[DYNAMICTOP_PTR>>2] = end; + return ret; +} + +function alignMemory(size, factor) { + if (!factor) factor = STACK_ALIGN; // stack alignment (16-byte) by default + return Math.ceil(size / factor) * factor; +} + +function getNativeTypeSize(type) { + switch (type) { + case 'i1': case 'i8': return 1; + case 'i16': return 2; + case 'i32': return 4; + case 'i64': return 8; + case 'float': return 4; + case 'double': return 8; + default: { + if (type[type.length-1] === '*') { + return 4; // A pointer + } else if (type[0] === 'i') { + var bits = parseInt(type.substr(1)); + assert(bits % 8 === 0, 'getNativeTypeSize invalid bits ' + bits + ', type ' + type); + return bits / 8; + } else { + return 0; + } + } + } +} + +function warnOnce(text) { + if (!warnOnce.shown) warnOnce.shown = {}; + if (!warnOnce.shown[text]) { + warnOnce.shown[text] = 1; + err(text); + } +} + +var asm2wasmImports = { // special asm2wasm imports + "f64-rem": function(x, y) { + return x % y; + }, + "debugger": function() { + } +}; + + + + +// Wraps a JS function as a wasm function with a given signature. +// In the future, we may get a WebAssembly.Function constructor. Until then, +// we create a wasm module that takes the JS function as an import with a given +// signature, and re-exports that as a wasm function. +function convertJsFunctionToWasm(func, sig) { + + // The module is static, with the exception of the type section, which is + // generated based on the signature passed in. + var typeSection = [ + 0x01, // id: section, + 0x00, // length: 0 (placeholder) + 0x01, // count: 1 + 0x60, // form: func + ]; + var sigRet = sig.slice(0, 1); + var sigParam = sig.slice(1); + var typeCodes = { + 'i': 0x7f, // i32 + 'j': 0x7e, // i64 + 'f': 0x7d, // f32 + 'd': 0x7c, // f64 + }; + + // Parameters, length + signatures + typeSection.push(sigParam.length); + for (var i = 0; i < sigParam.length; ++i) { + typeSection.push(typeCodes[sigParam[i]]); + } + + // Return values, length + signatures + // With no multi-return in MVP, either 0 (void) or 1 (anything else) + if (sigRet == 'v') { + typeSection.push(0x00); + } else { + typeSection = typeSection.concat([0x01, typeCodes[sigRet]]); + } + + // Write the overall length of the type section back into the section header + // (excepting the 2 bytes for the section id and length) + typeSection[1] = typeSection.length - 2; + + // Rest of the module is static + var bytes = new Uint8Array([ + 0x00, 0x61, 0x73, 0x6d, // magic ("\0asm") + 0x01, 0x00, 0x00, 0x00, // version: 1 + ].concat(typeSection, [ + 0x02, 0x07, // import section + // (import "e" "f" (func 0 (type 0))) + 0x01, 0x01, 0x65, 0x01, 0x66, 0x00, 0x00, + 0x07, 0x05, // export section + // (export "f" (func 0 (type 0))) + 0x01, 0x01, 0x66, 0x00, 0x00, + ])); + + // We can compile this wasm module synchronously because it is very small. + // This accepts an import (at "e.f"), that it reroutes to an export (at "f") + var module = new WebAssembly.Module(bytes); + var instance = new WebAssembly.Instance(module, { + e: { + f: func + } + }); + var wrappedFunc = instance.exports.f; + return wrappedFunc; +} + +// Add a wasm function to the table. +function addFunctionWasm(func, sig) { + var table = wasmTable; + var ret = table.length; + + // Grow the table + try { + table.grow(1); + } catch (err) { + if (!err instanceof RangeError) { + throw err; + } + throw 'Unable to grow wasm table. Use a higher value for RESERVED_FUNCTION_POINTERS or set ALLOW_TABLE_GROWTH.'; + } + + // Insert new element + try { + // Attempting to call this with JS function will cause of table.set() to fail + table.set(ret, func); + } catch (err) { + if (!err instanceof TypeError) { + throw err; + } + assert(typeof sig !== 'undefined', 'Missing signature argument to addFunction'); + var wrapped = convertJsFunctionToWasm(func, sig); + table.set(ret, wrapped); + } + + return ret; +} + +function removeFunctionWasm(index) { + // TODO(sbc): Look into implementing this to allow re-using of table slots +} + +// 'sig' parameter is required for the llvm backend but only when func is not +// already a WebAssembly function. +function addFunction(func, sig) { + + return addFunctionWasm(func, sig); +} + +function removeFunction(index) { + removeFunctionWasm(index); +} + +var funcWrappers = {}; + +function getFuncWrapper(func, sig) { + if (!func) return; // on null pointer, return undefined + assert(sig); + if (!funcWrappers[sig]) { + funcWrappers[sig] = {}; + } + var sigCache = funcWrappers[sig]; + if (!sigCache[func]) { + // optimize away arguments usage in common cases + if (sig.length === 1) { + sigCache[func] = function dynCall_wrapper() { + return dynCall(sig, func); + }; + } else if (sig.length === 2) { + sigCache[func] = function dynCall_wrapper(arg) { + return dynCall(sig, func, [arg]); + }; + } else { + // general case + sigCache[func] = function dynCall_wrapper() { + return dynCall(sig, func, Array.prototype.slice.call(arguments)); + }; + } + } + return sigCache[func]; +} + + +function makeBigInt(low, high, unsigned) { + return unsigned ? ((+((low>>>0)))+((+((high>>>0)))*4294967296.0)) : ((+((low>>>0)))+((+((high|0)))*4294967296.0)); +} + +function dynCall(sig, ptr, args) { + if (args && args.length) { + return Module['dynCall_' + sig].apply(null, [ptr].concat(args)); + } else { + return Module['dynCall_' + sig].call(null, ptr); + } +} + +var tempRet0 = 0; + +var setTempRet0 = function(value) { + tempRet0 = value; +}; + +var getTempRet0 = function() { + return tempRet0; +}; + + +var Runtime = { +}; + +// The address globals begin at. Very low in memory, for code size and optimization opportunities. +// Above 0 is static memory, starting with globals. +// Then the stack. +// Then 'dynamic' memory for sbrk. +var GLOBAL_BASE = 1024; + + + + +// === Preamble library stuff === + +// Documentation for the public APIs defined in this file must be updated in: +// site/source/docs/api_reference/preamble.js.rst +// A prebuilt local version of the documentation is available at: +// site/build/text/docs/api_reference/preamble.js.txt +// You can also build docs locally as HTML or other formats in site/ +// An online HTML version (which may be of a different version of Emscripten) +// is up at http://kripken.github.io/emscripten-site/docs/api_reference/preamble.js.html + + +var wasmBinary;if (Module['wasmBinary']) wasmBinary = Module['wasmBinary']; +var noExitRuntime;if (Module['noExitRuntime']) noExitRuntime = Module['noExitRuntime']; + + +if (typeof WebAssembly !== 'object') { + err('no native wasm support detected'); +} + + +// In MINIMAL_RUNTIME, setValue() and getValue() are only available when building with safe heap enabled, for heap safety checking. +// In traditional runtime, setValue() and getValue() are always available (although their use is highly discouraged due to perf penalties) + +/** @type {function(number, number, string, boolean=)} */ +function setValue(ptr, value, type, noSafe) { + type = type || 'i8'; + if (type.charAt(type.length-1) === '*') type = 'i32'; // pointers are 32-bit + switch(type) { + case 'i1': HEAP8[((ptr)>>0)]=value; break; + case 'i8': HEAP8[((ptr)>>0)]=value; break; + case 'i16': HEAP16[((ptr)>>1)]=value; break; + case 'i32': HEAP32[((ptr)>>2)]=value; break; + case 'i64': (tempI64 = [value>>>0,(tempDouble=value,(+(Math_abs(tempDouble))) >= 1.0 ? (tempDouble > 0.0 ? ((Math_min((+(Math_floor((tempDouble)/4294967296.0))), 4294967295.0))|0)>>>0 : (~~((+(Math_ceil((tempDouble - +(((~~(tempDouble)))>>>0))/4294967296.0)))))>>>0) : 0)],HEAP32[((ptr)>>2)]=tempI64[0],HEAP32[(((ptr)+(4))>>2)]=tempI64[1]); break; + case 'float': HEAPF32[((ptr)>>2)]=value; break; + case 'double': HEAPF64[((ptr)>>3)]=value; break; + default: abort('invalid type for setValue: ' + type); + } +} + +/** @type {function(number, string, boolean=)} */ +function getValue(ptr, type, noSafe) { + type = type || 'i8'; + if (type.charAt(type.length-1) === '*') type = 'i32'; // pointers are 32-bit + switch(type) { + case 'i1': return HEAP8[((ptr)>>0)]; + case 'i8': return HEAP8[((ptr)>>0)]; + case 'i16': return HEAP16[((ptr)>>1)]; + case 'i32': return HEAP32[((ptr)>>2)]; + case 'i64': return HEAP32[((ptr)>>2)]; + case 'float': return HEAPF32[((ptr)>>2)]; + case 'double': return HEAPF64[((ptr)>>3)]; + default: abort('invalid type for getValue: ' + type); + } + return null; +} + + + + + +// Wasm globals + +var wasmMemory; + +// In fastcomp asm.js, we don't need a wasm Table at all. +// In the wasm backend, we polyfill the WebAssembly object, +// so this creates a (non-native-wasm) table for us. +var wasmTable = new WebAssembly.Table({ + 'initial': 5, + 'maximum': 5 + 0, + 'element': 'anyfunc' +}); + + +//======================================== +// Runtime essentials +//======================================== + +// whether we are quitting the application. no code should run after this. +// set in exit() and abort() +var ABORT = false; + +// set by exit() and abort(). Passed to 'onExit' handler. +// NOTE: This is also used as the process return code code in shell environments +// but only when noExitRuntime is false. +var EXITSTATUS = 0; + +/** @type {function(*, string=)} */ +function assert(condition, text) { + if (!condition) { + abort('Assertion failed: ' + text); + } +} + +// Returns the C function with a specified identifier (for C++, you need to do manual name mangling) +function getCFunc(ident) { + var func = Module['_' + ident]; // closure exported function + assert(func, 'Cannot call unknown function ' + ident + ', make sure it is exported'); + return func; +} + +// C calling interface. +function ccall(ident, returnType, argTypes, args, opts) { + // For fast lookup of conversion functions + var toC = { + 'string': function(str) { + var ret = 0; + if (str !== null && str !== undefined && str !== 0) { // null string + // at most 4 bytes per UTF-8 code point, +1 for the trailing '\0' + var len = (str.length << 2) + 1; + ret = stackAlloc(len); + stringToUTF8(str, ret, len); + } + return ret; + }, + 'array': function(arr) { + var ret = stackAlloc(arr.length); + writeArrayToMemory(arr, ret); + return ret; + } + }; + + function convertReturnValue(ret) { + if (returnType === 'string') return UTF8ToString(ret); + if (returnType === 'boolean') return Boolean(ret); + return ret; + } + + var func = getCFunc(ident); + var cArgs = []; + var stack = 0; + if (args) { + for (var i = 0; i < args.length; i++) { + var converter = toC[argTypes[i]]; + if (converter) { + if (stack === 0) stack = stackSave(); + cArgs[i] = converter(args[i]); + } else { + cArgs[i] = args[i]; + } + } + } + var ret = func.apply(null, cArgs); + + ret = convertReturnValue(ret); + if (stack !== 0) stackRestore(stack); + return ret; +} + +function cwrap(ident, returnType, argTypes, opts) { + argTypes = argTypes || []; + // When the function takes numbers and returns a number, we can just return + // the original function + var numericArgs = argTypes.every(function(type){ return type === 'number'}); + var numericRet = returnType !== 'string'; + if (numericRet && numericArgs && !opts) { + return getCFunc(ident); + } + return function() { + return ccall(ident, returnType, argTypes, arguments, opts); + } +} + +var ALLOC_NORMAL = 0; // Tries to use _malloc() +var ALLOC_STACK = 1; // Lives for the duration of the current function call +var ALLOC_DYNAMIC = 2; // Cannot be freed except through sbrk +var ALLOC_NONE = 3; // Do not allocate + +// allocate(): This is for internal use. You can use it yourself as well, but the interface +// is a little tricky (see docs right below). The reason is that it is optimized +// for multiple syntaxes to save space in generated code. So you should +// normally not use allocate(), and instead allocate memory using _malloc(), +// initialize it with setValue(), and so forth. +// @slab: An array of data, or a number. If a number, then the size of the block to allocate, +// in *bytes* (note that this is sometimes confusing: the next parameter does not +// affect this!) +// @types: Either an array of types, one for each byte (or 0 if no type at that position), +// or a single type which is used for the entire block. This only matters if there +// is initial data - if @slab is a number, then this does not matter at all and is +// ignored. +// @allocator: How to allocate memory, see ALLOC_* +/** @type {function((TypedArray|Array|number), string, number, number=)} */ +function allocate(slab, types, allocator, ptr) { + var zeroinit, size; + if (typeof slab === 'number') { + zeroinit = true; + size = slab; + } else { + zeroinit = false; + size = slab.length; + } + + var singleType = typeof types === 'string' ? types : null; + + var ret; + if (allocator == ALLOC_NONE) { + ret = ptr; + } else { + ret = [_malloc, + stackAlloc, + dynamicAlloc][allocator](Math.max(size, singleType ? 1 : types.length)); + } + + if (zeroinit) { + var stop; + ptr = ret; + assert((ret & 3) == 0); + stop = ret + (size & ~3); + for (; ptr < stop; ptr += 4) { + HEAP32[((ptr)>>2)]=0; + } + stop = ret + size; + while (ptr < stop) { + HEAP8[((ptr++)>>0)]=0; + } + return ret; + } + + if (singleType === 'i8') { + if (slab.subarray || slab.slice) { + HEAPU8.set(/** @type {!Uint8Array} */ (slab), ret); + } else { + HEAPU8.set(new Uint8Array(slab), ret); + } + return ret; + } + + var i = 0, type, typeSize, previousType; + while (i < size) { + var curr = slab[i]; + + type = singleType || types[i]; + if (type === 0) { + i++; + continue; + } + + if (type == 'i64') type = 'i32'; // special case: we have one i32 here, and one i32 later + + setValue(ret+i, curr, type); + + // no need to look up size unless type changes, so cache it + if (previousType !== type) { + typeSize = getNativeTypeSize(type); + previousType = type; + } + i += typeSize; + } + + return ret; +} + +// Allocate memory during any stage of startup - static memory early on, dynamic memory later, malloc when ready +function getMemory(size) { + if (!runtimeInitialized) return dynamicAlloc(size); + return _malloc(size); +} + + + + +/** @type {function(number, number=)} */ +function Pointer_stringify(ptr, length) { + abort("this function has been removed - you should use UTF8ToString(ptr, maxBytesToRead) instead!"); +} + +// Given a pointer 'ptr' to a null-terminated ASCII-encoded string in the emscripten HEAP, returns +// a copy of that string as a Javascript String object. + +function AsciiToString(ptr) { + var str = ''; + while (1) { + var ch = HEAPU8[((ptr++)>>0)]; + if (!ch) return str; + str += String.fromCharCode(ch); + } +} + +// Copies the given Javascript String object 'str' to the emscripten HEAP at address 'outPtr', +// null-terminated and encoded in ASCII form. The copy will require at most str.length+1 bytes of space in the HEAP. + +function stringToAscii(str, outPtr) { + return writeAsciiToMemory(str, outPtr, false); +} + + +// Given a pointer 'ptr' to a null-terminated UTF8-encoded string in the given array that contains uint8 values, returns +// a copy of that string as a Javascript String object. + +var UTF8Decoder = typeof TextDecoder !== 'undefined' ? new TextDecoder('utf8') : undefined; + +/** + * @param {number} idx + * @param {number=} maxBytesToRead + * @return {string} + */ +function UTF8ArrayToString(u8Array, idx, maxBytesToRead) { + var endIdx = idx + maxBytesToRead; + var endPtr = idx; + // TextDecoder needs to know the byte length in advance, it doesn't stop on null terminator by itself. + // Also, use the length info to avoid running tiny strings through TextDecoder, since .subarray() allocates garbage. + // (As a tiny code save trick, compare endPtr against endIdx using a negation, so that undefined means Infinity) + while (u8Array[endPtr] && !(endPtr >= endIdx)) ++endPtr; + + if (endPtr - idx > 16 && u8Array.subarray && UTF8Decoder) { + return UTF8Decoder.decode(u8Array.subarray(idx, endPtr)); + } else { + var str = ''; + // If building with TextDecoder, we have already computed the string length above, so test loop end condition against that + while (idx < endPtr) { + // For UTF8 byte structure, see: + // http://en.wikipedia.org/wiki/UTF-8#Description + // https://www.ietf.org/rfc/rfc2279.txt + // https://tools.ietf.org/html/rfc3629 + var u0 = u8Array[idx++]; + if (!(u0 & 0x80)) { str += String.fromCharCode(u0); continue; } + var u1 = u8Array[idx++] & 63; + if ((u0 & 0xE0) == 0xC0) { str += String.fromCharCode(((u0 & 31) << 6) | u1); continue; } + var u2 = u8Array[idx++] & 63; + if ((u0 & 0xF0) == 0xE0) { + u0 = ((u0 & 15) << 12) | (u1 << 6) | u2; + } else { + u0 = ((u0 & 7) << 18) | (u1 << 12) | (u2 << 6) | (u8Array[idx++] & 63); + } + + if (u0 < 0x10000) { + str += String.fromCharCode(u0); + } else { + var ch = u0 - 0x10000; + str += String.fromCharCode(0xD800 | (ch >> 10), 0xDC00 | (ch & 0x3FF)); + } + } + } + return str; +} + +// Given a pointer 'ptr' to a null-terminated UTF8-encoded string in the emscripten HEAP, returns a +// copy of that string as a Javascript String object. +// maxBytesToRead: an optional length that specifies the maximum number of bytes to read. You can omit +// this parameter to scan the string until the first \0 byte. If maxBytesToRead is +// passed, and the string at [ptr, ptr+maxBytesToReadr[ contains a null byte in the +// middle, then the string will cut short at that byte index (i.e. maxBytesToRead will +// not produce a string of exact length [ptr, ptr+maxBytesToRead[) +// N.B. mixing frequent uses of UTF8ToString() with and without maxBytesToRead may +// throw JS JIT optimizations off, so it is worth to consider consistently using one +// style or the other. +/** + * @param {number} ptr + * @param {number=} maxBytesToRead + * @return {string} + */ +function UTF8ToString(ptr, maxBytesToRead) { + return ptr ? UTF8ArrayToString(HEAPU8, ptr, maxBytesToRead) : ''; +} + +// Copies the given Javascript String object 'str' to the given byte array at address 'outIdx', +// encoded in UTF8 form and null-terminated. The copy will require at most str.length*4+1 bytes of space in the HEAP. +// Use the function lengthBytesUTF8 to compute the exact number of bytes (excluding null terminator) that this function will write. +// Parameters: +// str: the Javascript string to copy. +// outU8Array: the array to copy to. Each index in this array is assumed to be one 8-byte element. +// outIdx: The starting offset in the array to begin the copying. +// maxBytesToWrite: The maximum number of bytes this function can write to the array. +// This count should include the null terminator, +// i.e. if maxBytesToWrite=1, only the null terminator will be written and nothing else. +// maxBytesToWrite=0 does not write any bytes to the output, not even the null terminator. +// Returns the number of bytes written, EXCLUDING the null terminator. + +function stringToUTF8Array(str, outU8Array, outIdx, maxBytesToWrite) { + if (!(maxBytesToWrite > 0)) // Parameter maxBytesToWrite is not optional. Negative values, 0, null, undefined and false each don't write out any bytes. + return 0; + + var startIdx = outIdx; + var endIdx = outIdx + maxBytesToWrite - 1; // -1 for string null terminator. + for (var i = 0; i < str.length; ++i) { + // Gotcha: charCodeAt returns a 16-bit word that is a UTF-16 encoded code unit, not a Unicode code point of the character! So decode UTF16->UTF32->UTF8. + // See http://unicode.org/faq/utf_bom.html#utf16-3 + // For UTF8 byte structure, see http://en.wikipedia.org/wiki/UTF-8#Description and https://www.ietf.org/rfc/rfc2279.txt and https://tools.ietf.org/html/rfc3629 + var u = str.charCodeAt(i); // possibly a lead surrogate + if (u >= 0xD800 && u <= 0xDFFF) { + var u1 = str.charCodeAt(++i); + u = 0x10000 + ((u & 0x3FF) << 10) | (u1 & 0x3FF); + } + if (u <= 0x7F) { + if (outIdx >= endIdx) break; + outU8Array[outIdx++] = u; + } else if (u <= 0x7FF) { + if (outIdx + 1 >= endIdx) break; + outU8Array[outIdx++] = 0xC0 | (u >> 6); + outU8Array[outIdx++] = 0x80 | (u & 63); + } else if (u <= 0xFFFF) { + if (outIdx + 2 >= endIdx) break; + outU8Array[outIdx++] = 0xE0 | (u >> 12); + outU8Array[outIdx++] = 0x80 | ((u >> 6) & 63); + outU8Array[outIdx++] = 0x80 | (u & 63); + } else { + if (outIdx + 3 >= endIdx) break; + outU8Array[outIdx++] = 0xF0 | (u >> 18); + outU8Array[outIdx++] = 0x80 | ((u >> 12) & 63); + outU8Array[outIdx++] = 0x80 | ((u >> 6) & 63); + outU8Array[outIdx++] = 0x80 | (u & 63); + } + } + // Null-terminate the pointer to the buffer. + outU8Array[outIdx] = 0; + return outIdx - startIdx; +} + +// Copies the given Javascript String object 'str' to the emscripten HEAP at address 'outPtr', +// null-terminated and encoded in UTF8 form. The copy will require at most str.length*4+1 bytes of space in the HEAP. +// Use the function lengthBytesUTF8 to compute the exact number of bytes (excluding null terminator) that this function will write. +// Returns the number of bytes written, EXCLUDING the null terminator. + +function stringToUTF8(str, outPtr, maxBytesToWrite) { + return stringToUTF8Array(str, HEAPU8,outPtr, maxBytesToWrite); +} + +// Returns the number of bytes the given Javascript string takes if encoded as a UTF8 byte array, EXCLUDING the null terminator byte. +function lengthBytesUTF8(str) { + var len = 0; + for (var i = 0; i < str.length; ++i) { + // Gotcha: charCodeAt returns a 16-bit word that is a UTF-16 encoded code unit, not a Unicode code point of the character! So decode UTF16->UTF32->UTF8. + // See http://unicode.org/faq/utf_bom.html#utf16-3 + var u = str.charCodeAt(i); // possibly a lead surrogate + if (u >= 0xD800 && u <= 0xDFFF) u = 0x10000 + ((u & 0x3FF) << 10) | (str.charCodeAt(++i) & 0x3FF); + if (u <= 0x7F) ++len; + else if (u <= 0x7FF) len += 2; + else if (u <= 0xFFFF) len += 3; + else len += 4; + } + return len; +} + + +// Given a pointer 'ptr' to a null-terminated UTF16LE-encoded string in the emscripten HEAP, returns +// a copy of that string as a Javascript String object. + +var UTF16Decoder = typeof TextDecoder !== 'undefined' ? new TextDecoder('utf-16le') : undefined; +function UTF16ToString(ptr) { + var endPtr = ptr; + // TextDecoder needs to know the byte length in advance, it doesn't stop on null terminator by itself. + // Also, use the length info to avoid running tiny strings through TextDecoder, since .subarray() allocates garbage. + var idx = endPtr >> 1; + while (HEAP16[idx]) ++idx; + endPtr = idx << 1; + + if (endPtr - ptr > 32 && UTF16Decoder) { + return UTF16Decoder.decode(HEAPU8.subarray(ptr, endPtr)); + } else { + var i = 0; + + var str = ''; + while (1) { + var codeUnit = HEAP16[(((ptr)+(i*2))>>1)]; + if (codeUnit == 0) return str; + ++i; + // fromCharCode constructs a character from a UTF-16 code unit, so we can pass the UTF16 string right through. + str += String.fromCharCode(codeUnit); + } + } +} + +// Copies the given Javascript String object 'str' to the emscripten HEAP at address 'outPtr', +// null-terminated and encoded in UTF16 form. The copy will require at most str.length*4+2 bytes of space in the HEAP. +// Use the function lengthBytesUTF16() to compute the exact number of bytes (excluding null terminator) that this function will write. +// Parameters: +// str: the Javascript string to copy. +// outPtr: Byte address in Emscripten HEAP where to write the string to. +// maxBytesToWrite: The maximum number of bytes this function can write to the array. This count should include the null +// terminator, i.e. if maxBytesToWrite=2, only the null terminator will be written and nothing else. +// maxBytesToWrite<2 does not write any bytes to the output, not even the null terminator. +// Returns the number of bytes written, EXCLUDING the null terminator. + +function stringToUTF16(str, outPtr, maxBytesToWrite) { + // Backwards compatibility: if max bytes is not specified, assume unsafe unbounded write is allowed. + if (maxBytesToWrite === undefined) { + maxBytesToWrite = 0x7FFFFFFF; + } + if (maxBytesToWrite < 2) return 0; + maxBytesToWrite -= 2; // Null terminator. + var startPtr = outPtr; + var numCharsToWrite = (maxBytesToWrite < str.length*2) ? (maxBytesToWrite / 2) : str.length; + for (var i = 0; i < numCharsToWrite; ++i) { + // charCodeAt returns a UTF-16 encoded code unit, so it can be directly written to the HEAP. + var codeUnit = str.charCodeAt(i); // possibly a lead surrogate + HEAP16[((outPtr)>>1)]=codeUnit; + outPtr += 2; + } + // Null-terminate the pointer to the HEAP. + HEAP16[((outPtr)>>1)]=0; + return outPtr - startPtr; +} + +// Returns the number of bytes the given Javascript string takes if encoded as a UTF16 byte array, EXCLUDING the null terminator byte. + +function lengthBytesUTF16(str) { + return str.length*2; +} + +function UTF32ToString(ptr) { + var i = 0; + + var str = ''; + while (1) { + var utf32 = HEAP32[(((ptr)+(i*4))>>2)]; + if (utf32 == 0) + return str; + ++i; + // Gotcha: fromCharCode constructs a character from a UTF-16 encoded code (pair), not from a Unicode code point! So encode the code point to UTF-16 for constructing. + // See http://unicode.org/faq/utf_bom.html#utf16-3 + if (utf32 >= 0x10000) { + var ch = utf32 - 0x10000; + str += String.fromCharCode(0xD800 | (ch >> 10), 0xDC00 | (ch & 0x3FF)); + } else { + str += String.fromCharCode(utf32); + } + } +} + +// Copies the given Javascript String object 'str' to the emscripten HEAP at address 'outPtr', +// null-terminated and encoded in UTF32 form. The copy will require at most str.length*4+4 bytes of space in the HEAP. +// Use the function lengthBytesUTF32() to compute the exact number of bytes (excluding null terminator) that this function will write. +// Parameters: +// str: the Javascript string to copy. +// outPtr: Byte address in Emscripten HEAP where to write the string to. +// maxBytesToWrite: The maximum number of bytes this function can write to the array. This count should include the null +// terminator, i.e. if maxBytesToWrite=4, only the null terminator will be written and nothing else. +// maxBytesToWrite<4 does not write any bytes to the output, not even the null terminator. +// Returns the number of bytes written, EXCLUDING the null terminator. + +function stringToUTF32(str, outPtr, maxBytesToWrite) { + // Backwards compatibility: if max bytes is not specified, assume unsafe unbounded write is allowed. + if (maxBytesToWrite === undefined) { + maxBytesToWrite = 0x7FFFFFFF; + } + if (maxBytesToWrite < 4) return 0; + var startPtr = outPtr; + var endPtr = startPtr + maxBytesToWrite - 4; + for (var i = 0; i < str.length; ++i) { + // Gotcha: charCodeAt returns a 16-bit word that is a UTF-16 encoded code unit, not a Unicode code point of the character! We must decode the string to UTF-32 to the heap. + // See http://unicode.org/faq/utf_bom.html#utf16-3 + var codeUnit = str.charCodeAt(i); // possibly a lead surrogate + if (codeUnit >= 0xD800 && codeUnit <= 0xDFFF) { + var trailSurrogate = str.charCodeAt(++i); + codeUnit = 0x10000 + ((codeUnit & 0x3FF) << 10) | (trailSurrogate & 0x3FF); + } + HEAP32[((outPtr)>>2)]=codeUnit; + outPtr += 4; + if (outPtr + 4 > endPtr) break; + } + // Null-terminate the pointer to the HEAP. + HEAP32[((outPtr)>>2)]=0; + return outPtr - startPtr; +} + +// Returns the number of bytes the given Javascript string takes if encoded as a UTF16 byte array, EXCLUDING the null terminator byte. + +function lengthBytesUTF32(str) { + var len = 0; + for (var i = 0; i < str.length; ++i) { + // Gotcha: charCodeAt returns a 16-bit word that is a UTF-16 encoded code unit, not a Unicode code point of the character! We must decode the string to UTF-32 to the heap. + // See http://unicode.org/faq/utf_bom.html#utf16-3 + var codeUnit = str.charCodeAt(i); + if (codeUnit >= 0xD800 && codeUnit <= 0xDFFF) ++i; // possibly a lead surrogate, so skip over the tail surrogate. + len += 4; + } + + return len; +} + +// Allocate heap space for a JS string, and write it there. +// It is the responsibility of the caller to free() that memory. +function allocateUTF8(str) { + var size = lengthBytesUTF8(str) + 1; + var ret = _malloc(size); + if (ret) stringToUTF8Array(str, HEAP8, ret, size); + return ret; +} + +// Allocate stack space for a JS string, and write it there. +function allocateUTF8OnStack(str) { + var size = lengthBytesUTF8(str) + 1; + var ret = stackAlloc(size); + stringToUTF8Array(str, HEAP8, ret, size); + return ret; +} + +// Deprecated: This function should not be called because it is unsafe and does not provide +// a maximum length limit of how many bytes it is allowed to write. Prefer calling the +// function stringToUTF8Array() instead, which takes in a maximum length that can be used +// to be secure from out of bounds writes. +/** @deprecated */ +function writeStringToMemory(string, buffer, dontAddNull) { + warnOnce('writeStringToMemory is deprecated and should not be called! Use stringToUTF8() instead!'); + + var /** @type {number} */ lastChar, /** @type {number} */ end; + if (dontAddNull) { + // stringToUTF8Array always appends null. If we don't want to do that, remember the + // character that existed at the location where the null will be placed, and restore + // that after the write (below). + end = buffer + lengthBytesUTF8(string); + lastChar = HEAP8[end]; + } + stringToUTF8(string, buffer, Infinity); + if (dontAddNull) HEAP8[end] = lastChar; // Restore the value under the null character. +} + +function writeArrayToMemory(array, buffer) { + HEAP8.set(array, buffer); +} + +function writeAsciiToMemory(str, buffer, dontAddNull) { + for (var i = 0; i < str.length; ++i) { + HEAP8[((buffer++)>>0)]=str.charCodeAt(i); + } + // Null-terminate the pointer to the HEAP. + if (!dontAddNull) HEAP8[((buffer)>>0)]=0; +} + + + + +// Memory management + +var PAGE_SIZE = 16384; +var WASM_PAGE_SIZE = 65536; +var ASMJS_PAGE_SIZE = 16777216; + +function alignUp(x, multiple) { + if (x % multiple > 0) { + x += multiple - (x % multiple); + } + return x; +} + +var HEAP, +/** @type {ArrayBuffer} */ + buffer, +/** @type {Int8Array} */ + HEAP8, +/** @type {Uint8Array} */ + HEAPU8, +/** @type {Int16Array} */ + HEAP16, +/** @type {Uint16Array} */ + HEAPU16, +/** @type {Int32Array} */ + HEAP32, +/** @type {Uint32Array} */ + HEAPU32, +/** @type {Float32Array} */ + HEAPF32, +/** @type {Float64Array} */ + HEAPF64; + +function updateGlobalBufferAndViews(buf) { + buffer = buf; + Module['HEAP8'] = HEAP8 = new Int8Array(buf); + Module['HEAP16'] = HEAP16 = new Int16Array(buf); + Module['HEAP32'] = HEAP32 = new Int32Array(buf); + Module['HEAPU8'] = HEAPU8 = new Uint8Array(buf); + Module['HEAPU16'] = HEAPU16 = new Uint16Array(buf); + Module['HEAPU32'] = HEAPU32 = new Uint32Array(buf); + Module['HEAPF32'] = HEAPF32 = new Float32Array(buf); + Module['HEAPF64'] = HEAPF64 = new Float64Array(buf); +} + + +var STATIC_BASE = 1024, + STACK_BASE = 5248240, + STACKTOP = STACK_BASE, + STACK_MAX = 5360, + DYNAMIC_BASE = 5248240, + DYNAMICTOP_PTR = 5168; + + + + +var TOTAL_STACK = 5242880; + +var INITIAL_TOTAL_MEMORY = Module['TOTAL_MEMORY'] || 16777216; + + + + + + + +// In standalone mode, the wasm creates the memory, and the user can't provide it. +// In non-standalone/normal mode, we create the memory here. + +// Create the main memory. (Note: this isn't used in STANDALONE_WASM mode since the wasm +// memory is created in the wasm, not in JS.) + + if (Module['wasmMemory']) { + wasmMemory = Module['wasmMemory']; + } else + { + wasmMemory = new WebAssembly.Memory({ + 'initial': INITIAL_TOTAL_MEMORY / WASM_PAGE_SIZE + , + 'maximum': INITIAL_TOTAL_MEMORY / WASM_PAGE_SIZE + }); + } + + +if (wasmMemory) { + buffer = wasmMemory.buffer; +} + +// If the user provides an incorrect length, just use that length instead rather than providing the user to +// specifically provide the memory length with Module['TOTAL_MEMORY']. +INITIAL_TOTAL_MEMORY = buffer.byteLength; +updateGlobalBufferAndViews(buffer); + +HEAP32[DYNAMICTOP_PTR>>2] = DYNAMIC_BASE; + + + + + + + + + + +function callRuntimeCallbacks(callbacks) { + while(callbacks.length > 0) { + var callback = callbacks.shift(); + if (typeof callback == 'function') { + callback(); + continue; + } + var func = callback.func; + if (typeof func === 'number') { + if (callback.arg === undefined) { + Module['dynCall_v'](func); + } else { + Module['dynCall_vi'](func, callback.arg); + } + } else { + func(callback.arg === undefined ? null : callback.arg); + } + } +} + +var __ATPRERUN__ = []; // functions called before the runtime is initialized +var __ATINIT__ = []; // functions called during startup +var __ATMAIN__ = []; // functions called when main() is to be run +var __ATEXIT__ = []; // functions called during shutdown +var __ATPOSTRUN__ = []; // functions called after the main() is called + +var runtimeInitialized = false; +var runtimeExited = false; + + +function preRun() { + + if (Module['preRun']) { + if (typeof Module['preRun'] == 'function') Module['preRun'] = [Module['preRun']]; + while (Module['preRun'].length) { + addOnPreRun(Module['preRun'].shift()); + } + } + + callRuntimeCallbacks(__ATPRERUN__); +} + +function initRuntime() { + runtimeInitialized = true; + + callRuntimeCallbacks(__ATINIT__); +} + +function preMain() { + + callRuntimeCallbacks(__ATMAIN__); +} + +function exitRuntime() { + runtimeExited = true; +} + +function postRun() { + + if (Module['postRun']) { + if (typeof Module['postRun'] == 'function') Module['postRun'] = [Module['postRun']]; + while (Module['postRun'].length) { + addOnPostRun(Module['postRun'].shift()); + } + } + + callRuntimeCallbacks(__ATPOSTRUN__); +} + +function addOnPreRun(cb) { + __ATPRERUN__.unshift(cb); +} + +function addOnInit(cb) { + __ATINIT__.unshift(cb); +} + +function addOnPreMain(cb) { + __ATMAIN__.unshift(cb); +} + +function addOnExit(cb) { +} + +function addOnPostRun(cb) { + __ATPOSTRUN__.unshift(cb); +} + +function unSign(value, bits, ignore) { + if (value >= 0) { + return value; + } + return bits <= 32 ? 2*Math.abs(1 << (bits-1)) + value // Need some trickery, since if bits == 32, we are right at the limit of the bits JS uses in bitshifts + : Math.pow(2, bits) + value; +} +function reSign(value, bits, ignore) { + if (value <= 0) { + return value; + } + var half = bits <= 32 ? Math.abs(1 << (bits-1)) // abs is needed if bits == 32 + : Math.pow(2, bits-1); + if (value >= half && (bits <= 32 || value > half)) { // for huge values, we can hit the precision limit and always get true here. so don't do that + // but, in general there is no perfect solution here. With 64-bit ints, we get rounding and errors + // TODO: In i64 mode 1, resign the two parts separately and safely + value = -2*half + value; // Cannot bitshift half, as it may be at the limit of the bits JS uses in bitshifts + } + return value; +} + + + +var Math_abs = Math.abs; +var Math_cos = Math.cos; +var Math_sin = Math.sin; +var Math_tan = Math.tan; +var Math_acos = Math.acos; +var Math_asin = Math.asin; +var Math_atan = Math.atan; +var Math_atan2 = Math.atan2; +var Math_exp = Math.exp; +var Math_log = Math.log; +var Math_sqrt = Math.sqrt; +var Math_ceil = Math.ceil; +var Math_floor = Math.floor; +var Math_pow = Math.pow; +var Math_imul = Math.imul; +var Math_fround = Math.fround; +var Math_round = Math.round; +var Math_min = Math.min; +var Math_max = Math.max; +var Math_clz32 = Math.clz32; +var Math_trunc = Math.trunc; + + + +// A counter of dependencies for calling run(). If we need to +// do asynchronous work before running, increment this and +// decrement it. Incrementing must happen in a place like +// Module.preRun (used by emcc to add file preloading). +// Note that you can add dependencies in preRun, even though +// it happens right before run - run will be postponed until +// the dependencies are met. +var runDependencies = 0; +var runDependencyWatcher = null; +var dependenciesFulfilled = null; // overridden to take different actions when all run dependencies are fulfilled + +function getUniqueRunDependency(id) { + return id; +} + +function addRunDependency(id) { + runDependencies++; + + if (Module['monitorRunDependencies']) { + Module['monitorRunDependencies'](runDependencies); + } + +} + +function removeRunDependency(id) { + runDependencies--; + + if (Module['monitorRunDependencies']) { + Module['monitorRunDependencies'](runDependencies); + } + + if (runDependencies == 0) { + if (runDependencyWatcher !== null) { + clearInterval(runDependencyWatcher); + runDependencyWatcher = null; + } + if (dependenciesFulfilled) { + var callback = dependenciesFulfilled; + dependenciesFulfilled = null; + callback(); // can add another dependenciesFulfilled + } + } +} + +Module["preloadedImages"] = {}; // maps url to image data +Module["preloadedAudios"] = {}; // maps url to audio data + + +function abort(what) { + if (Module['onAbort']) { + Module['onAbort'](what); + } + + what += ''; + out(what); + err(what); + + ABORT = true; + EXITSTATUS = 1; + + throw 'abort(' + what + '). Build with -s ASSERTIONS=1 for more info.'; +} + + +var memoryInitializer = null; + + + + + + + +// Copyright 2017 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. + +// Prefix of data URIs emitted by SINGLE_FILE and related options. +var dataURIPrefix = 'data:application/octet-stream;base64,'; + +// Indicates whether filename is a base64 data URI. +function isDataURI(filename) { + return String.prototype.startsWith ? + filename.startsWith(dataURIPrefix) : + filename.indexOf(dataURIPrefix) === 0; +} + + + + +var wasmBinaryFile = 'coremark.wasm'; +if (!isDataURI(wasmBinaryFile)) { + wasmBinaryFile = locateFile(wasmBinaryFile); +} + +function getBinary() { + try { + if (wasmBinary) { + return new Uint8Array(wasmBinary); + } + + if (readBinary) { + return readBinary(wasmBinaryFile); + } else { + throw "both async and sync fetching of the wasm failed"; + } + } + catch (err) { + abort(err); + } +} + +function getBinaryPromise() { + // if we don't have the binary yet, and have the Fetch api, use that + // in some environments, like Electron's render process, Fetch api may be present, but have a different context than expected, let's only use it on the Web + if (!wasmBinary && (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER) && typeof fetch === 'function') { + return fetch(wasmBinaryFile, { credentials: 'same-origin' }).then(function(response) { + if (!response['ok']) { + throw "failed to load wasm binary file at '" + wasmBinaryFile + "'"; + } + return response['arrayBuffer'](); + }).catch(function () { + return getBinary(); + }); + } + // Otherwise, getBinary should be able to get it synchronously + return new Promise(function(resolve, reject) { + resolve(getBinary()); + }); +} + + + +// Create the wasm instance. +// Receives the wasm imports, returns the exports. +function createWasm() { + // prepare imports + var info = { + 'env': asmLibraryArg, + 'wasi_unstable': asmLibraryArg + }; + // Load the wasm module and create an instance of using native support in the JS engine. + // handle a generated wasm instance, receiving its exports and + // performing other necessary setup + function receiveInstance(instance, module) { + var exports = instance.exports; + Module['asm'] = exports; + removeRunDependency('wasm-instantiate'); + } + // we can't run yet (except in a pthread, where we have a custom sync instantiator) + addRunDependency('wasm-instantiate'); + + + function receiveInstantiatedSource(output) { + // 'output' is a WebAssemblyInstantiatedSource object which has both the module and instance. + // receiveInstance() will swap in the exports (to Module.asm) so they can be called + // TODO: Due to Closure regression https://github.com/google/closure-compiler/issues/3193, the above line no longer optimizes out down to the following line. + // When the regression is fixed, can restore the above USE_PTHREADS-enabled path. + receiveInstance(output['instance']); + } + + + function instantiateArrayBuffer(receiver) { + return getBinaryPromise().then(function(binary) { + return WebAssembly.instantiate(binary, info); + }).then(receiver, function(reason) { + err('failed to asynchronously prepare wasm: ' + reason); + abort(reason); + }); + } + + // Prefer streaming instantiation if available. + function instantiateAsync() { + if (!wasmBinary && + typeof WebAssembly.instantiateStreaming === 'function' && + !isDataURI(wasmBinaryFile) && + typeof fetch === 'function') { + fetch(wasmBinaryFile, { credentials: 'same-origin' }).then(function (response) { + var result = WebAssembly.instantiateStreaming(response, info); + return result.then(receiveInstantiatedSource, function(reason) { + // We expect the most common failure cause to be a bad MIME type for the binary, + // in which case falling back to ArrayBuffer instantiation should work. + err('wasm streaming compile failed: ' + reason); + err('falling back to ArrayBuffer instantiation'); + instantiateArrayBuffer(receiveInstantiatedSource); + }); + }); + } else { + return instantiateArrayBuffer(receiveInstantiatedSource); + } + } + // User shell pages can write their own Module.instantiateWasm = function(imports, successCallback) callback + // to manually instantiate the Wasm module themselves. This allows pages to run the instantiation parallel + // to any other async startup actions they are performing. + if (Module['instantiateWasm']) { + try { + var exports = Module['instantiateWasm'](info, receiveInstance); + return exports; + } catch(e) { + err('Module.instantiateWasm callback failed with error: ' + e); + return false; + } + } + + instantiateAsync(); + return {}; // no exports yet; we'll fill them in later +} + + +// Globals used by JS i64 conversions +var tempDouble; +var tempI64; + +// === Body === + +var ASM_CONSTS = []; + + + + +// STATICTOP = STATIC_BASE + 4336; +/* global initializers */ __ATINIT__.push({ func: function() { ___wasm_call_ctors() } }); + + + +/* no memory initializer */ +// {{PRE_LIBRARY}} + + + function demangle(func) { + return func; + } + + function demangleAll(text) { + var regex = + /\b_Z[\w\d_]+/g; + return text.replace(regex, + function(x) { + var y = demangle(x); + return x === y ? x : (y + ' [' + x + ']'); + }); + } + + function jsStackTrace() { + var err = new Error(); + if (!err.stack) { + // IE10+ special cases: It does have callstack info, but it is only populated if an Error object is thrown, + // so try that as a special-case. + try { + throw new Error(0); + } catch(e) { + err = e; + } + if (!err.stack) { + return '(no stack trace available)'; + } + } + return err.stack.toString(); + } + + function stackTrace() { + var js = jsStackTrace(); + if (Module['extraStackTrace']) js += '\n' + Module['extraStackTrace'](); + return demangleAll(js); + } + + function _abort() { + abort(); + } + + + function _emscripten_get_now() { abort() } + + function _emscripten_get_now_is_monotonic() { + // return whether emscripten_get_now is guaranteed monotonic; the Date.now + // implementation is not :( + return (0 + || ENVIRONMENT_IS_NODE + || (typeof dateNow !== 'undefined') + || (typeof performance === 'object' && performance && typeof performance['now'] === 'function') + ); + } + + function ___setErrNo(value) { + if (Module['___errno_location']) HEAP32[((Module['___errno_location']())>>2)]=value; + return value; + }function _clock_gettime(clk_id, tp) { + // int clock_gettime(clockid_t clk_id, struct timespec *tp); + var now; + if (clk_id === 0) { + now = Date.now(); + } else if (clk_id === 1 && _emscripten_get_now_is_monotonic()) { + now = _emscripten_get_now(); + } else { + ___setErrNo(28); + return -1; + } + HEAP32[((tp)>>2)]=(now/1000)|0; // seconds + HEAP32[(((tp)+(4))>>2)]=((now % 1000)*1000*1000)|0; // nanoseconds + return 0; + } + + function _emscripten_get_heap_size() { + return HEAP8.length; + } + + function _emscripten_get_sbrk_ptr() { + return 5168; + } + + function _emscripten_memcpy_big(dest, src, num) { + HEAPU8.set(HEAPU8.subarray(src, src+num), dest); + } + + + function abortOnCannotGrowMemory(requestedSize) { + abort('OOM'); + }function _emscripten_resize_heap(requestedSize) { + abortOnCannotGrowMemory(requestedSize); + } + + + function flush_NO_FILESYSTEM() { + // flush anything remaining in the buffers during shutdown + var fflush = Module["_fflush"]; + if (fflush) fflush(0); + var buffers = SYSCALLS.buffers; + if (buffers[1].length) SYSCALLS.printChar(1, 10); + if (buffers[2].length) SYSCALLS.printChar(2, 10); + } + + + var PATH={splitPath:function(filename) { + var splitPathRe = /^(\/?|)([\s\S]*?)((?:\.{1,2}|[^\/]+?|)(\.[^.\/]*|))(?:[\/]*)$/; + return splitPathRe.exec(filename).slice(1); + },normalizeArray:function(parts, allowAboveRoot) { + // if the path tries to go above the root, `up` ends up > 0 + var up = 0; + for (var i = parts.length - 1; i >= 0; i--) { + var last = parts[i]; + if (last === '.') { + parts.splice(i, 1); + } else if (last === '..') { + parts.splice(i, 1); + up++; + } else if (up) { + parts.splice(i, 1); + up--; + } + } + // if the path is allowed to go above the root, restore leading ..s + if (allowAboveRoot) { + for (; up; up--) { + parts.unshift('..'); + } + } + return parts; + },normalize:function(path) { + var isAbsolute = path.charAt(0) === '/', + trailingSlash = path.substr(-1) === '/'; + // Normalize the path + path = PATH.normalizeArray(path.split('/').filter(function(p) { + return !!p; + }), !isAbsolute).join('/'); + if (!path && !isAbsolute) { + path = '.'; + } + if (path && trailingSlash) { + path += '/'; + } + return (isAbsolute ? '/' : '') + path; + },dirname:function(path) { + var result = PATH.splitPath(path), + root = result[0], + dir = result[1]; + if (!root && !dir) { + // No dirname whatsoever + return '.'; + } + if (dir) { + // It has a dirname, strip trailing slash + dir = dir.substr(0, dir.length - 1); + } + return root + dir; + },basename:function(path) { + // EMSCRIPTEN return '/'' for '/', not an empty string + if (path === '/') return '/'; + var lastSlash = path.lastIndexOf('/'); + if (lastSlash === -1) return path; + return path.substr(lastSlash+1); + },extname:function(path) { + return PATH.splitPath(path)[3]; + },join:function() { + var paths = Array.prototype.slice.call(arguments, 0); + return PATH.normalize(paths.join('/')); + },join2:function(l, r) { + return PATH.normalize(l + '/' + r); + }};var SYSCALLS={buffers:[null,[],[]],printChar:function(stream, curr) { + var buffer = SYSCALLS.buffers[stream]; + if (curr === 0 || curr === 10) { + (stream === 1 ? out : err)(UTF8ArrayToString(buffer, 0)); + buffer.length = 0; + } else { + buffer.push(curr); + } + },varargs:0,get:function(varargs) { + SYSCALLS.varargs += 4; + var ret = HEAP32[(((SYSCALLS.varargs)-(4))>>2)]; + return ret; + },getStr:function() { + var ret = UTF8ToString(SYSCALLS.get()); + return ret; + },get64:function() { + var low = SYSCALLS.get(), high = SYSCALLS.get(); + return low; + },getZero:function() { + SYSCALLS.get(); + }};function _fd_write(fd, iov, iovcnt, pnum) {try { + + // hack to support printf in SYSCALLS_REQUIRE_FILESYSTEM=0 + var num = 0; + for (var i = 0; i < iovcnt; i++) { + var ptr = HEAP32[(((iov)+(i*8))>>2)]; + var len = HEAP32[(((iov)+(i*8 + 4))>>2)]; + for (var j = 0; j < len; j++) { + SYSCALLS.printChar(fd, HEAPU8[ptr+j]); + } + num += len; + } + HEAP32[((pnum)>>2)]=num + return 0; + } catch (e) { + if (typeof FS === 'undefined' || !(e instanceof FS.ErrnoError)) abort(e); + return e.errno; + } + } + + + function _memcpy(dest, src, num) { + dest = dest|0; src = src|0; num = num|0; + var ret = 0; + var aligned_dest_end = 0; + var block_aligned_dest_end = 0; + var dest_end = 0; + // Test against a benchmarked cutoff limit for when HEAPU8.set() becomes faster to use. + if ((num|0) >= 8192) { + _emscripten_memcpy_big(dest|0, src|0, num|0)|0; + return dest|0; + } + + ret = dest|0; + dest_end = (dest + num)|0; + if ((dest&3) == (src&3)) { + // The initial unaligned < 4-byte front. + while (dest & 3) { + if ((num|0) == 0) return ret|0; + HEAP8[((dest)>>0)]=((HEAP8[((src)>>0)])|0); + dest = (dest+1)|0; + src = (src+1)|0; + num = (num-1)|0; + } + aligned_dest_end = (dest_end & -4)|0; + block_aligned_dest_end = (aligned_dest_end - 64)|0; + while ((dest|0) <= (block_aligned_dest_end|0) ) { + HEAP32[((dest)>>2)]=((HEAP32[((src)>>2)])|0); + HEAP32[(((dest)+(4))>>2)]=((HEAP32[(((src)+(4))>>2)])|0); + HEAP32[(((dest)+(8))>>2)]=((HEAP32[(((src)+(8))>>2)])|0); + HEAP32[(((dest)+(12))>>2)]=((HEAP32[(((src)+(12))>>2)])|0); + HEAP32[(((dest)+(16))>>2)]=((HEAP32[(((src)+(16))>>2)])|0); + HEAP32[(((dest)+(20))>>2)]=((HEAP32[(((src)+(20))>>2)])|0); + HEAP32[(((dest)+(24))>>2)]=((HEAP32[(((src)+(24))>>2)])|0); + HEAP32[(((dest)+(28))>>2)]=((HEAP32[(((src)+(28))>>2)])|0); + HEAP32[(((dest)+(32))>>2)]=((HEAP32[(((src)+(32))>>2)])|0); + HEAP32[(((dest)+(36))>>2)]=((HEAP32[(((src)+(36))>>2)])|0); + HEAP32[(((dest)+(40))>>2)]=((HEAP32[(((src)+(40))>>2)])|0); + HEAP32[(((dest)+(44))>>2)]=((HEAP32[(((src)+(44))>>2)])|0); + HEAP32[(((dest)+(48))>>2)]=((HEAP32[(((src)+(48))>>2)])|0); + HEAP32[(((dest)+(52))>>2)]=((HEAP32[(((src)+(52))>>2)])|0); + HEAP32[(((dest)+(56))>>2)]=((HEAP32[(((src)+(56))>>2)])|0); + HEAP32[(((dest)+(60))>>2)]=((HEAP32[(((src)+(60))>>2)])|0); + dest = (dest+64)|0; + src = (src+64)|0; + } + while ((dest|0) < (aligned_dest_end|0) ) { + HEAP32[((dest)>>2)]=((HEAP32[((src)>>2)])|0); + dest = (dest+4)|0; + src = (src+4)|0; + } + } else { + // In the unaligned copy case, unroll a bit as well. + aligned_dest_end = (dest_end - 4)|0; + while ((dest|0) < (aligned_dest_end|0) ) { + HEAP8[((dest)>>0)]=((HEAP8[((src)>>0)])|0); + HEAP8[(((dest)+(1))>>0)]=((HEAP8[(((src)+(1))>>0)])|0); + HEAP8[(((dest)+(2))>>0)]=((HEAP8[(((src)+(2))>>0)])|0); + HEAP8[(((dest)+(3))>>0)]=((HEAP8[(((src)+(3))>>0)])|0); + dest = (dest+4)|0; + src = (src+4)|0; + } + } + // The remaining unaligned < 4 byte tail. + while ((dest|0) < (dest_end|0)) { + HEAP8[((dest)>>0)]=((HEAP8[((src)>>0)])|0); + dest = (dest+1)|0; + src = (src+1)|0; + } + return ret|0; + } + + function _memset(ptr, value, num) { + ptr = ptr|0; value = value|0; num = num|0; + var end = 0, aligned_end = 0, block_aligned_end = 0, value4 = 0; + end = (ptr + num)|0; + + value = value & 0xff; + if ((num|0) >= 67 /* 64 bytes for an unrolled loop + 3 bytes for unaligned head*/) { + while ((ptr&3) != 0) { + HEAP8[((ptr)>>0)]=value; + ptr = (ptr+1)|0; + } + + aligned_end = (end & -4)|0; + value4 = value | (value << 8) | (value << 16) | (value << 24); + + block_aligned_end = (aligned_end - 64)|0; + + while((ptr|0) <= (block_aligned_end|0)) { + HEAP32[((ptr)>>2)]=value4; + HEAP32[(((ptr)+(4))>>2)]=value4; + HEAP32[(((ptr)+(8))>>2)]=value4; + HEAP32[(((ptr)+(12))>>2)]=value4; + HEAP32[(((ptr)+(16))>>2)]=value4; + HEAP32[(((ptr)+(20))>>2)]=value4; + HEAP32[(((ptr)+(24))>>2)]=value4; + HEAP32[(((ptr)+(28))>>2)]=value4; + HEAP32[(((ptr)+(32))>>2)]=value4; + HEAP32[(((ptr)+(36))>>2)]=value4; + HEAP32[(((ptr)+(40))>>2)]=value4; + HEAP32[(((ptr)+(44))>>2)]=value4; + HEAP32[(((ptr)+(48))>>2)]=value4; + HEAP32[(((ptr)+(52))>>2)]=value4; + HEAP32[(((ptr)+(56))>>2)]=value4; + HEAP32[(((ptr)+(60))>>2)]=value4; + ptr = (ptr + 64)|0; + } + + while ((ptr|0) < (aligned_end|0) ) { + HEAP32[((ptr)>>2)]=value4; + ptr = (ptr+4)|0; + } + } + // The remaining bytes. + while ((ptr|0) < (end|0)) { + HEAP8[((ptr)>>0)]=value; + ptr = (ptr+1)|0; + } + return (end-num)|0; + } + + function _setTempRet0($i) { + setTempRet0(($i) | 0); + } +if (ENVIRONMENT_IS_NODE) { + _emscripten_get_now = function _emscripten_get_now_actual() { + var t = process['hrtime'](); + return t[0] * 1e3 + t[1] / 1e6; + }; + } else if (typeof dateNow !== 'undefined') { + _emscripten_get_now = dateNow; + } else if (typeof performance === 'object' && performance && typeof performance['now'] === 'function') { + _emscripten_get_now = function() { return performance['now'](); }; + } else { + _emscripten_get_now = Date.now; + }; +var ASSERTIONS = false; + +// Copyright 2017 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. + +/** @type {function(string, boolean=, number=)} */ +function intArrayFromString(stringy, dontAddNull, length) { + var len = length > 0 ? length : lengthBytesUTF8(stringy)+1; + var u8array = new Array(len); + var numBytesWritten = stringToUTF8Array(stringy, u8array, 0, u8array.length); + if (dontAddNull) u8array.length = numBytesWritten; + return u8array; +} + +function intArrayToString(array) { + var ret = []; + for (var i = 0; i < array.length; i++) { + var chr = array[i]; + if (chr > 0xFF) { + if (ASSERTIONS) { + assert(false, 'Character code ' + chr + ' (' + String.fromCharCode(chr) + ') at offset ' + i + ' not in 0x00-0xFF.'); + } + chr &= 0xFF; + } + ret.push(String.fromCharCode(chr)); + } + return ret.join(''); +} + + +// ASM_LIBRARY EXTERN PRIMITIVES: Int8Array,Int32Array + +var asmGlobalArg = {}; +var asmLibraryArg = { "abort": _abort, "clock_gettime": _clock_gettime, "emscripten_get_sbrk_ptr": _emscripten_get_sbrk_ptr, "emscripten_memcpy_big": _emscripten_memcpy_big, "emscripten_resize_heap": _emscripten_resize_heap, "fd_write": _fd_write, "memory": wasmMemory, "setTempRet0": _setTempRet0, "table": wasmTable }; +var asm = createWasm(); +Module["asm"] = asm; +var ___wasm_call_ctors = Module["___wasm_call_ctors"] = function() { + return Module["asm"]["__wasm_call_ctors"].apply(null, arguments) +}; + +var _main = Module["_main"] = function() { + return Module["asm"]["main"].apply(null, arguments) +}; + +var _malloc = Module["_malloc"] = function() { + return Module["asm"]["malloc"].apply(null, arguments) +}; + +var _free = Module["_free"] = function() { + return Module["asm"]["free"].apply(null, arguments) +}; + +var ___errno_location = Module["___errno_location"] = function() { + return Module["asm"]["__errno_location"].apply(null, arguments) +}; + +var _setThrew = Module["_setThrew"] = function() { + return Module["asm"]["setThrew"].apply(null, arguments) +}; + +var stackSave = Module["stackSave"] = function() { + return Module["asm"]["stackSave"].apply(null, arguments) +}; + +var stackAlloc = Module["stackAlloc"] = function() { + return Module["asm"]["stackAlloc"].apply(null, arguments) +}; + +var stackRestore = Module["stackRestore"] = function() { + return Module["asm"]["stackRestore"].apply(null, arguments) +}; + +var __growWasmMemory = Module["__growWasmMemory"] = function() { + return Module["asm"]["__growWasmMemory"].apply(null, arguments) +}; + +var dynCall_ii = Module["dynCall_ii"] = function() { + return Module["asm"]["dynCall_ii"].apply(null, arguments) +}; + +var dynCall_iiii = Module["dynCall_iiii"] = function() { + return Module["asm"]["dynCall_iiii"].apply(null, arguments) +}; + +var dynCall_jiji = Module["dynCall_jiji"] = function() { + return Module["asm"]["dynCall_jiji"].apply(null, arguments) +}; + +var dynCall_iidiiii = Module["dynCall_iidiiii"] = function() { + return Module["asm"]["dynCall_iidiiii"].apply(null, arguments) +}; + + + + +// === Auto-generated postamble setup entry stuff === + +Module['asm'] = asm; + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +var calledRun; + + +/** + * @constructor + * @this {ExitStatus} + */ +function ExitStatus(status) { + this.name = "ExitStatus"; + this.message = "Program terminated with exit(" + status + ")"; + this.status = status; +} + +var calledMain = false; + +dependenciesFulfilled = function runCaller() { + // If run has never been called, and we should call run (INVOKE_RUN is true, and Module.noInitialRun is not false) + if (!calledRun) run(); + if (!calledRun) dependenciesFulfilled = runCaller; // try this again later, after new deps are fulfilled +}; + +function callMain(args) { + + + args = args || []; + + var argc = args.length+1; + var argv = stackAlloc((argc + 1) * 4); + HEAP32[argv >> 2] = allocateUTF8OnStack(thisProgram); + for (var i = 1; i < argc; i++) { + HEAP32[(argv >> 2) + i] = allocateUTF8OnStack(args[i - 1]); + } + HEAP32[(argv >> 2) + argc] = 0; + + + try { + + + var ret = Module['_main'](argc, argv); + + + // if we're not running an evented main loop, it's time to exit + exit(ret, /* implicit = */ true); + } + catch(e) { + if (e instanceof ExitStatus) { + // exit() throws this once it's done to make sure execution + // has been stopped completely + return; + } else if (e == 'SimulateInfiniteLoop') { + // running an evented main loop, don't immediately exit + noExitRuntime = true; + return; + } else { + var toLog = e; + if (e && typeof e === 'object' && e.stack) { + toLog = [e, e.stack]; + } + err('exception thrown: ' + toLog); + quit_(1, e); + } + } finally { + calledMain = true; + } +} + + + + +/** @type {function(Array=)} */ +function run(args) { + args = args || arguments_; + + if (runDependencies > 0) { + return; + } + + + preRun(); + + if (runDependencies > 0) return; // a preRun added a dependency, run will be called later + + function doRun() { + // run may have just been called through dependencies being fulfilled just in this very frame, + // or while the async setStatus time below was happening + if (calledRun) return; + calledRun = true; + + if (ABORT) return; + + initRuntime(); + + preMain(); + + if (Module['onRuntimeInitialized']) Module['onRuntimeInitialized'](); + + if (shouldRunNow) callMain(args); + + postRun(); + } + + if (Module['setStatus']) { + Module['setStatus']('Running...'); + setTimeout(function() { + setTimeout(function() { + Module['setStatus'](''); + }, 1); + doRun(); + }, 1); + } else + { + doRun(); + } +} +Module['run'] = run; + + +function exit(status, implicit) { + + // if this is just main exit-ing implicitly, and the status is 0, then we + // don't need to do anything here and can just leave. if the status is + // non-zero, though, then we need to report it. + // (we may have warned about this earlier, if a situation justifies doing so) + if (implicit && noExitRuntime && status === 0) { + return; + } + + if (noExitRuntime) { + } else { + + ABORT = true; + EXITSTATUS = status; + + exitRuntime(); + + if (Module['onExit']) Module['onExit'](status); + } + + quit_(status, new ExitStatus(status)); +} + +if (Module['preInit']) { + if (typeof Module['preInit'] == 'function') Module['preInit'] = [Module['preInit']]; + while (Module['preInit'].length > 0) { + Module['preInit'].pop()(); + } +} + +// shouldRunNow refers to calling main(), not run(). +var shouldRunNow = true; + +if (Module['noInitialRun']) shouldRunNow = false; + + + noExitRuntime = true; + +run(); + + + + + +// {{MODULE_ADDITIONS}} + + + diff --git a/test/benchmark/coremark/coremark.wasm b/test/benchmark/coremark/coremark.wasm index 32aa94686227e3d8cee3fe90826b6d589f4190fd..a60c268256f9a10418aab51e1030197faba6026d 100644 GIT binary patch literal 55873 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

L9To;uY0N(KLN?~ofG62e0X;qlk# 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 delta 6530 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 HI^+Bc=HeuT