diff options
30 files changed, 1018 insertions, 70 deletions
diff --git a/src/abi/js.h b/src/abi/js.h index de74899b6..c8ac94407 100644 --- a/src/abi/js.h +++ b/src/abi/js.h @@ -44,14 +44,21 @@ extern cashew::IString SCRATCH_LOAD_F32; extern cashew::IString SCRATCH_STORE_F32; extern cashew::IString SCRATCH_LOAD_F64; extern cashew::IString SCRATCH_STORE_F64; +extern cashew::IString MEMORY_INIT; +extern cashew::IString MEMORY_FILL; +extern cashew::IString MEMORY_COPY; +extern cashew::IString DATA_DROP; +extern cashew::IString ATOMIC_WAIT_I32; +extern cashew::IString ATOMIC_RMW_I64; +extern cashew::IString GET_STASHED_BITS; -// The wasm2js scratch memory helpers let us read and write to scratch memory -// for purposes of implementing things like reinterpret, etc. +// The wasm2js helpers let us do things that can't be done without special help, +// like read and write to scratch memory for purposes of implementing things +// like reinterpret, etc. // The optional "specific" parameter is a specific function we want. If not // provided, we create them all. -inline void -ensureScratchMemoryHelpers(Module* wasm, - cashew::IString specific = cashew::IString()) { +inline void ensureHelpers(Module* wasm, + cashew::IString specific = cashew::IString()) { auto ensureImport = [&](Name name, Type params, Type results) { if (wasm->getFunctionOrNull(name)) { return; @@ -75,13 +82,28 @@ ensureScratchMemoryHelpers(Module* wasm, ensureImport(SCRATCH_STORE_F32, {Type::f32}, Type::none); ensureImport(SCRATCH_LOAD_F64, {}, Type::f64); ensureImport(SCRATCH_STORE_F64, {Type::f64}, Type::none); + ensureImport( + MEMORY_INIT, {Type::i32, Type::i32, Type::i32, Type::i32}, Type::none); + ensureImport(MEMORY_FILL, {Type::i32, Type::i32, Type::i32}, Type::none); + ensureImport(MEMORY_COPY, {Type::i32, Type::i32, Type::i32}, Type::none); + ensureImport(DATA_DROP, {Type::i32}, Type::none); + ensureImport( + ATOMIC_WAIT_I32, {Type::i32, Type::i32, Type::i32, Type::i32}, Type::i32); + ensureImport( + ATOMIC_RMW_I64, + {Type::i32, Type::i32, Type::i32, Type::i32, Type::i32, Type::i32}, + Type::i32); + ensureImport(GET_STASHED_BITS, {}, Type::i32); } -inline bool isScratchMemoryHelper(cashew::IString name) { +inline bool isHelper(cashew::IString name) { return name == SCRATCH_LOAD_I32 || name == SCRATCH_STORE_I32 || name == SCRATCH_LOAD_I64 || name == SCRATCH_STORE_I64 || name == SCRATCH_LOAD_F32 || name == SCRATCH_STORE_F32 || - name == SCRATCH_LOAD_F64 || name == SCRATCH_STORE_F64; + name == SCRATCH_LOAD_F64 || name == SCRATCH_STORE_F64 || + name == ATOMIC_WAIT_I32 || name == MEMORY_INIT || + name == MEMORY_FILL || name == MEMORY_COPY || name == DATA_DROP || + name == ATOMIC_RMW_I64 || name == GET_STASHED_BITS; } } // namespace wasm2js diff --git a/src/asmjs/shared-constants.cpp b/src/asmjs/shared-constants.cpp index 58742fb1d..8a13cf55c 100644 --- a/src/asmjs/shared-constants.cpp +++ b/src/asmjs/shared-constants.cpp @@ -119,6 +119,13 @@ cashew::IString SCRATCH_LOAD_F32("wasm2js_scratch_load_f32"); cashew::IString SCRATCH_STORE_F32("wasm2js_scratch_store_f32"); cashew::IString SCRATCH_LOAD_F64("wasm2js_scratch_load_f64"); cashew::IString SCRATCH_STORE_F64("wasm2js_scratch_store_f64"); +cashew::IString MEMORY_INIT("wasm2js_memory_init"); +cashew::IString MEMORY_FILL("wasm2js_memory_fill"); +cashew::IString MEMORY_COPY("wasm2js_memory_copy"); +cashew::IString DATA_DROP("wasm2js_data_drop"); +cashew::IString ATOMIC_WAIT_I32("wasm2js_atomic_wait_i32"); +cashew::IString ATOMIC_RMW_I64("wasm2js_atomic_rmw_i64"); +cashew::IString GET_STASHED_BITS("wasm2js_get_stashed_bits"); } // namespace wasm2js } // namespace ABI diff --git a/src/emscripten-optimizer/parser.cpp b/src/emscripten-optimizer/parser.cpp index 72740908e..de749817f 100644 --- a/src/emscripten-optimizer/parser.cpp +++ b/src/emscripten-optimizer/parser.cpp @@ -103,6 +103,10 @@ IString ARRAY("array"); IString OBJECT("object"); IString THROW("throw"); IString SET("="); +IString ATOMICS("Atomics"); +IString COMPARE_EXCHANGE("compareExchange"); +IString LOAD("load"); +IString STORE("store"); IStringSet keywords("var const function if else do while for break continue return " diff --git a/src/emscripten-optimizer/parser.h b/src/emscripten-optimizer/parser.h index 1d4cda79b..3e1623c19 100644 --- a/src/emscripten-optimizer/parser.h +++ b/src/emscripten-optimizer/parser.h @@ -120,6 +120,10 @@ extern IString ARRAY; extern IString OBJECT; extern IString THROW; extern IString SET; +extern IString ATOMICS; +extern IString COMPARE_EXCHANGE; +extern IString LOAD; +extern IString STORE; extern IStringSet keywords; diff --git a/src/passes/I64ToI32Lowering.cpp b/src/passes/I64ToI32Lowering.cpp index 2072f6614..711900e1d 100644 --- a/src/passes/I64ToI32Lowering.cpp +++ b/src/passes/I64ToI32Lowering.cpp @@ -521,7 +521,7 @@ struct I64ToI32Lowering : public WalkerPass<PostWalker<I64ToI32Lowering>> { setOutParam(result, std::move(highBits)); replaceCurrent(result); MemoryUtils::ensureExists(getModule()->memory); - ABI::wasm2js::ensureScratchMemoryHelpers(getModule()); + ABI::wasm2js::ensureHelpers(getModule()); } void lowerReinterpretInt64(Unary* curr) { @@ -539,7 +539,7 @@ struct I64ToI32Lowering : public WalkerPass<PostWalker<I64ToI32Lowering>> { builder->makeCall(ABI::wasm2js::SCRATCH_LOAD_F64, {}, Type::f64)); replaceCurrent(result); MemoryUtils::ensureExists(getModule()->memory); - ABI::wasm2js::ensureScratchMemoryHelpers(getModule()); + ABI::wasm2js::ensureHelpers(getModule()); } void lowerTruncFloatToInt(Unary* curr) { diff --git a/src/passes/RemoveNonJSOps.cpp b/src/passes/RemoveNonJSOps.cpp index 1866877c0..3c1947725 100644 --- a/src/passes/RemoveNonJSOps.cpp +++ b/src/passes/RemoveNonJSOps.cpp @@ -52,7 +52,7 @@ struct RemoveNonJSOpsPass : public WalkerPass<PostWalker<RemoveNonJSOpsPass>> { void doWalkModule(Module* module) { // Intrinsics may use scratch memory, ensure it. - ABI::wasm2js::ensureScratchMemoryHelpers(module); + ABI::wasm2js::ensureHelpers(module); // Discover all of the intrinsics that we need to inject, lowering all // operations to intrinsic calls while we're at it. diff --git a/src/tools/wasm2js.cpp b/src/tools/wasm2js.cpp index b1fc45146..f12d5189d 100644 --- a/src/tools/wasm2js.cpp +++ b/src/tools/wasm2js.cpp @@ -62,7 +62,7 @@ static void optimizeWasm(Module& wasm, PassOptions options) { template<typename T> static void printJS(Ref ast, T& output) { JSPrinter jser(true, true, ast); jser.printAst(); - output << jser.buffer << std::endl; + output << jser.buffer << '\n'; } // Traversals diff --git a/src/wasm2js.h b/src/wasm2js.h index a904bd0f9..fe558c03b 100644 --- a/src/wasm2js.h +++ b/src/wasm2js.h @@ -275,7 +275,7 @@ Ref Wasm2JSBuilder::processWasm(Module* wasm, Name funcName) { // Ensure the scratch memory helpers. // If later on they aren't needed, we'll clean them up. - ABI::wasm2js::ensureScratchMemoryHelpers(wasm); + ABI::wasm2js::ensureHelpers(wasm); // Process the code, and optimize if relevant. // First, do the lowering to a JS-friendly subset. @@ -496,7 +496,7 @@ void Wasm2JSBuilder::addBasics(Ref ast) { void Wasm2JSBuilder::addFunctionImport(Ref ast, Function* import) { // The scratch memory helpers are emitted in the glue, see code and comments // below. - if (ABI::wasm2js::isScratchMemoryHelper(import->base)) { + if (ABI::wasm2js::isHelper(import->base)) { return; } Ref theVar = ValueBuilder::makeVar(); @@ -1404,10 +1404,10 @@ Ref Wasm2JSBuilder::processFunctionBody(Module* m, L_NOT, visit(curr->value, EXPRESSION_RESULT)); } case ReinterpretFloat32: { - ABI::wasm2js::ensureScratchMemoryHelpers( - module, ABI::wasm2js::SCRATCH_STORE_F32); - ABI::wasm2js::ensureScratchMemoryHelpers( - module, ABI::wasm2js::SCRATCH_LOAD_I32); + ABI::wasm2js::ensureHelpers(module, + ABI::wasm2js::SCRATCH_STORE_F32); + ABI::wasm2js::ensureHelpers(module, + ABI::wasm2js::SCRATCH_LOAD_I32); Ref store = ValueBuilder::makeCall(ABI::wasm2js::SCRATCH_STORE_F32, @@ -1482,10 +1482,10 @@ Ref Wasm2JSBuilder::processFunctionBody(Module* m, return makeAsmCoercion(visit(curr->value, EXPRESSION_RESULT), ASM_FLOAT); case ReinterpretInt32: { - ABI::wasm2js::ensureScratchMemoryHelpers( - module, ABI::wasm2js::SCRATCH_STORE_I32); - ABI::wasm2js::ensureScratchMemoryHelpers( - module, ABI::wasm2js::SCRATCH_LOAD_F32); + ABI::wasm2js::ensureHelpers(module, + ABI::wasm2js::SCRATCH_STORE_I32); + ABI::wasm2js::ensureHelpers(module, + ABI::wasm2js::SCRATCH_LOAD_F32); Ref store = ValueBuilder::makeCall(ABI::wasm2js::SCRATCH_STORE_I32, @@ -1839,20 +1839,31 @@ Ref Wasm2JSBuilder::processFunctionBody(Module* m, WASM_UNREACHABLE("unimp"); } Ref visitMemoryInit(MemoryInit* curr) { - unimplemented(curr); - WASM_UNREACHABLE("unimp"); + ABI::wasm2js::ensureHelpers(module, ABI::wasm2js::MEMORY_INIT); + return ValueBuilder::makeCall(ABI::wasm2js::MEMORY_INIT, + ValueBuilder::makeNum(curr->segment), + visit(curr->dest, EXPRESSION_RESULT), + visit(curr->offset, EXPRESSION_RESULT), + visit(curr->size, EXPRESSION_RESULT)); } Ref visitDataDrop(DataDrop* curr) { - unimplemented(curr); - WASM_UNREACHABLE("unimp"); + ABI::wasm2js::ensureHelpers(module, ABI::wasm2js::DATA_DROP); + return ValueBuilder::makeCall(ABI::wasm2js::DATA_DROP, + ValueBuilder::makeNum(curr->segment)); } Ref visitMemoryCopy(MemoryCopy* curr) { - unimplemented(curr); - WASM_UNREACHABLE("unimp"); + ABI::wasm2js::ensureHelpers(module, ABI::wasm2js::MEMORY_COPY); + return ValueBuilder::makeCall(ABI::wasm2js::MEMORY_COPY, + visit(curr->dest, EXPRESSION_RESULT), + visit(curr->source, EXPRESSION_RESULT), + visit(curr->size, EXPRESSION_RESULT)); } Ref visitMemoryFill(MemoryFill* curr) { - unimplemented(curr); - WASM_UNREACHABLE("unimp"); + ABI::wasm2js::ensureHelpers(module, ABI::wasm2js::MEMORY_FILL); + return ValueBuilder::makeCall(ABI::wasm2js::MEMORY_FILL, + visit(curr->dest, EXPRESSION_RESULT), + visit(curr->value, EXPRESSION_RESULT), + visit(curr->size, EXPRESSION_RESULT)); } Ref visitRefNull(RefNull* curr) { unimplemented(curr); @@ -2077,7 +2088,7 @@ private: void emitMemory(std::string buffer, std::string segmentWriter, std::function<std::string(std::string)> accessGlobal); - void emitScratchMemorySupport(); + void emitSpecialSupport(); }; void Wasm2JSGlue::emitPre() { @@ -2087,7 +2098,7 @@ void Wasm2JSGlue::emitPre() { emitPreES6(); } - emitScratchMemorySupport(); + emitSpecialSupport(); } void Wasm2JSGlue::emitPreEmscripten() { @@ -2117,9 +2128,9 @@ void Wasm2JSGlue::emitPreES6() { ModuleUtils::iterImportedGlobals( wasm, [&](Global* import) { noteImport(import->module, import->base); }); ModuleUtils::iterImportedFunctions(wasm, [&](Function* import) { - // The scratch memory helpers are emitted in the glue, see code and comments + // The special helpers are emitted in the glue, see code and comments // below. - if (ABI::wasm2js::isScratchMemoryHelper(import->base)) { + if (ABI::wasm2js::isHelper(import->base)) { return; } noteImport(import->module, import->base); @@ -2202,9 +2213,9 @@ void Wasm2JSGlue::emitPostES6() { out << "abort:function() { throw new Error('abort'); }"; ModuleUtils::iterImportedFunctions(wasm, [&](Function* import) { - // The scratch memory helpers are emitted in the glue, see code and comments + // The special helpers are emitted in the glue, see code and comments // below. - if (ABI::wasm2js::isScratchMemoryHelper(import->base)) { + if (ABI::wasm2js::isHelper(import->base)) { return; } out << "," << asmangle(import->base.str); @@ -2244,11 +2255,23 @@ void Wasm2JSGlue::emitMemory( std::string buffer, std::string segmentWriter, std::function<std::string(std::string)> accessGlobal) { + if (!wasm.memory.exists) { + return; + } + // Create a helper bufferView to access the buffer if we need one. We use it + // for creating memory segments if we have any (we may not if the segments are + // shipped in a side .mem file, for example), and also in bulk memory + // operations. + if (!wasm.memory.segments.empty() || wasm.features.hasBulkMemory()) { + out << "var bufferView = new Uint8Array(" << buffer << ");\n"; + } + // If there are no memory segments, we don't need to emit any support code for + // segment creation. if (wasm.memory.segments.empty()) { return; } - auto expr = + out << R"(for (var base64ReverseLookup = new Uint8Array(123/*'z'+1*/), i = 25; i >= 0; --i) { base64ReverseLookup[48+i] = 52+i; // '0-9' base64ReverseLookup[65+i] = i; // 'A-Z' @@ -2265,9 +2288,16 @@ void Wasm2JSGlue::emitMemory( uint8Array[j++] = base64ReverseLookup[b64.charCodeAt(i)] << 2 | b1 >> 4; if (j < end) uint8Array[j++] = b1 << 4 | b2 >> 2; if (j < end) uint8Array[j++] = b2 << 6 | base64ReverseLookup[b64.charCodeAt(i+3)]; - } - })"; - out << expr << '\n'; + })"; + if (wasm.features.hasBulkMemory()) { + // Passive segments in bulk memory are initialized into new arrays that are + // passed into here, and we need to return them. + out << R"( + return uint8Array;)"; + } + out << R"( + } + )"; auto globalOffset = [&](const Memory::Segment& segment) { if (auto* c = segment.offset->dynCast<Const>()) { @@ -2281,27 +2311,33 @@ void Wasm2JSGlue::emitMemory( Fatal() << "non-constant offsets aren't supported yet\n"; }; - out << "var bufferView = new Uint8Array(" << buffer << ");\n"; - - for (auto& seg : wasm.memory.segments) { - assert(!seg.isPassive && "passive segments not implemented yet"); - out << "base64DecodeToExistingUint8Array(bufferView, " << globalOffset(seg) - << ", \"" << base64Encode(seg.data) << "\");\n"; + for (Index i = 0; i < wasm.memory.segments.size(); i++) { + auto& seg = wasm.memory.segments[i]; + if (!seg.isPassive) { + // Plain active segments are decoded directly into the main memory. + out << "base64DecodeToExistingUint8Array(bufferView, " + << globalOffset(seg) << ", \"" << base64Encode(seg.data) << "\");\n"; + } else { + // Fancy passive segments are decoded into typed arrays on the side, for + // later copying. + out << "memorySegments[" << i + << "] = base64DecodeToExistingUint8Array(new Uint8Array(" + << seg.data.size() << ")" + << ", 0, \"" << base64Encode(seg.data) << "\");\n"; + } } } -void Wasm2JSGlue::emitScratchMemorySupport() { - // The scratch memory helpers are emitted here the glue. We may also want to - // emit them inline at some point. (The reason they are imports is so that - // they appear as "intrinsics" placeholders, and not normal functions that - // the optimizer might want to do something with.) - bool needScratchMemory = false; +void Wasm2JSGlue::emitSpecialSupport() { + // The special support functions are emitted as part of the JS glue, if we + // need them. + bool need = false; ModuleUtils::iterImportedFunctions(wasm, [&](Function* import) { - if (ABI::wasm2js::isScratchMemoryHelper(import->base)) { - needScratchMemory = true; + if (ABI::wasm2js::isHelper(import->base)) { + need = true; } }); - if (!needScratchMemory) { + if (!need) { return; } @@ -2312,6 +2348,15 @@ void Wasm2JSGlue::emitScratchMemorySupport() { var f64ScratchView = new Float64Array(scratchBuffer); )"; + // If we have passive memory segments, or bulk memory operations that operate + // on segment indexes, we need to store those. + bool needMemorySegmentsList = false; + for (auto& seg : wasm.memory.segments) { + if (seg.isPassive) { + needMemorySegmentsList = true; + } + } + ModuleUtils::iterImportedFunctions(wasm, [&](Function* import) { if (import->base == ABI::wasm2js::SCRATCH_STORE_I32) { out << R"( @@ -2363,8 +2408,47 @@ void Wasm2JSGlue::emitScratchMemorySupport() { return f64ScratchView[0]; } )"; + } else if (import->base == ABI::wasm2js::MEMORY_INIT) { + needMemorySegmentsList = true; + out << R"( + function wasm2js_memory_init(segment, dest, offset, size) { + // TODO: traps on invalid things + bufferView.set(memorySegments[segment].subarray(offset, offset + size), dest); + } + )"; + } else if (import->base == ABI::wasm2js::MEMORY_FILL) { + out << R"( + function wasm2js_memory_fill(dest, value, size) { + dest = dest >>> 0; + size = size >>> 0; + if (dest + size > bufferView.length) throw "trap: invalid memory.fill"; + bufferView.fill(value, dest, dest + size); + } + )"; + } else if (import->base == ABI::wasm2js::MEMORY_COPY) { + out << R"( + function wasm2js_memory_copy(dest, source, size) { + // TODO: traps on invalid things + bufferView.copyWithin(dest, source, source + size); + } + )"; + } else if (import->base == ABI::wasm2js::DATA_DROP) { + needMemorySegmentsList = true; + out << R"( + function wasm2js_data_drop(segment) { + // TODO: traps on invalid things + memorySegments[segment] = new Uint8Array(0); + } + )"; } }); + + if (needMemorySegmentsList) { + out << R"( + var memorySegments = {}; + )"; + } + out << '\n'; } diff --git a/test/passes/remove-non-js-ops.txt b/test/passes/remove-non-js-ops.txt index d9af2bae4..f906e8f81 100644 --- a/test/passes/remove-non-js-ops.txt +++ b/test/passes/remove-non-js-ops.txt @@ -4,10 +4,16 @@ (type $i32_i32_=>_i32 (func (param i32 i32) (result i32))) (type $f32_=>_f32 (func (param f32) (result f32))) (type $f64_=>_f64 (func (param f64) (result f64))) + (type $i32_i32_i32_=>_none (func (param i32 i32 i32))) + (type $i32_=>_none (func (param i32))) (type $i32_i32_=>_none (func (param i32 i32))) + (type $i32_i32_i32_i32_=>_none (func (param i32 i32 i32 i32))) (type $i64_=>_none (func (param i64))) (type $f32_=>_none (func (param f32))) (type $f64_=>_none (func (param f64))) + (type $none_=>_i32 (func (result i32))) + (type $i32_i32_i32_i32_=>_i32 (func (param i32 i32 i32 i32) (result i32))) + (type $i32_i32_i32_i32_i32_i32_=>_i32 (func (param i32 i32 i32 i32 i32 i32) (result i32))) (type $none_=>_i64 (func (result i64))) (type $none_=>_f32 (func (result f32))) (type $f32_f32_=>_f32 (func (param f32 f32) (result f32))) @@ -21,6 +27,13 @@ (import "env" "wasm2js_scratch_store_f32" (func $wasm2js_scratch_store_f32 (param f32))) (import "env" "wasm2js_scratch_load_f64" (func $wasm2js_scratch_load_f64 (result f64))) (import "env" "wasm2js_scratch_store_f64" (func $wasm2js_scratch_store_f64 (param f64))) + (import "env" "wasm2js_memory_init" (func $wasm2js_memory_init (param i32 i32 i32 i32))) + (import "env" "wasm2js_memory_fill" (func $wasm2js_memory_fill (param i32 i32 i32))) + (import "env" "wasm2js_memory_copy" (func $wasm2js_memory_copy (param i32 i32 i32))) + (import "env" "wasm2js_data_drop" (func $wasm2js_data_drop (param i32))) + (import "env" "wasm2js_atomic_wait_i32" (func $wasm2js_atomic_wait_i32 (param i32 i32 i32 i32) (result i32))) + (import "env" "wasm2js_atomic_rmw_i64" (func $wasm2js_atomic_rmw_i64 (param i32 i32 i32 i32 i32 i32) (result i32))) + (import "env" "wasm2js_get_stashed_bits" (func $wasm2js_get_stashed_bits (result i32))) (memory $0 1) (func $copysign64 (param $0 f64) (param $1 f64) (result f64) (f64.reinterpret_i64 diff --git a/test/wasm2js/atomic_fence.2asm.js b/test/wasm2js/atomic_fence.2asm.js index bf40601bc..b6694daec 100644 --- a/test/wasm2js/atomic_fence.2asm.js +++ b/test/wasm2js/atomic_fence.2asm.js @@ -57,5 +57,6 @@ function asmFunc(global, env, buffer) { } var memasmFunc = new ArrayBuffer(1507328); +var bufferView = new Uint8Array(memasmFunc); var retasmFunc = asmFunc({Math,Int8Array,Uint8Array,Int16Array,Uint16Array,Int32Array,Uint32Array,Float32Array,Float64Array,NaN,Infinity}, {abort:function() { throw new Error('abort'); }},memasmFunc); export var atomic_fence = retasmFunc.atomic_fence; diff --git a/test/wasm2js/bulk-memory.2asm.js b/test/wasm2js/bulk-memory.2asm.js new file mode 100644 index 000000000..cea852c98 --- /dev/null +++ b/test/wasm2js/bulk-memory.2asm.js @@ -0,0 +1,420 @@ + +function asmFunc(global, env, buffer) { + var HEAP8 = new global.Int8Array(buffer); + var HEAP16 = new global.Int16Array(buffer); + var HEAP32 = new global.Int32Array(buffer); + var HEAPU8 = new global.Uint8Array(buffer); + var HEAPU16 = new global.Uint16Array(buffer); + var HEAPU32 = new global.Uint32Array(buffer); + var HEAPF32 = new global.Float32Array(buffer); + var HEAPF64 = new global.Float64Array(buffer); + var Math_imul = global.Math.imul; + var Math_fround = global.Math.fround; + var Math_abs = global.Math.abs; + var Math_clz32 = global.Math.clz32; + var Math_min = global.Math.min; + var Math_max = global.Math.max; + var Math_floor = global.Math.floor; + var Math_ceil = global.Math.ceil; + var Math_sqrt = global.Math.sqrt; + var abort = env.abort; + var nan = global.NaN; + var infinity = global.Infinity; + var FUNCTION_TABLE = []; + return { + + }; +} + +var memasmFunc = new ArrayBuffer(65536); +var retasmFunc = asmFunc({Math,Int8Array,Uint8Array,Int16Array,Uint16Array,Int32Array,Uint32Array,Float32Array,Float64Array,NaN,Infinity}, {abort:function() { throw new Error('abort'); }},memasmFunc); + + + var scratchBuffer = new ArrayBuffer(8); + var i32ScratchView = new Int32Array(scratchBuffer); + var f32ScratchView = new Float32Array(scratchBuffer); + var f64ScratchView = new Float64Array(scratchBuffer); + + function wasm2js_memory_fill(dest, value, size) { + dest = dest >>> 0; + size = size >>> 0; + if (dest + size > bufferView.length) throw "trap: invalid memory.fill"; + bufferView.fill(value, dest, dest + size); + } + +function asmFunc(global, env, buffer) { + var HEAP8 = new global.Int8Array(buffer); + var HEAP16 = new global.Int16Array(buffer); + var HEAP32 = new global.Int32Array(buffer); + var HEAPU8 = new global.Uint8Array(buffer); + var HEAPU16 = new global.Uint16Array(buffer); + var HEAPU32 = new global.Uint32Array(buffer); + var HEAPF32 = new global.Float32Array(buffer); + var HEAPF64 = new global.Float64Array(buffer); + var Math_imul = global.Math.imul; + var Math_fround = global.Math.fround; + var Math_abs = global.Math.abs; + var Math_clz32 = global.Math.clz32; + var Math_min = global.Math.min; + var Math_max = global.Math.max; + var Math_floor = global.Math.floor; + var Math_ceil = global.Math.ceil; + var Math_sqrt = global.Math.sqrt; + var abort = env.abort; + var nan = global.NaN; + var infinity = global.Infinity; + function $0($0_1, $1_1, $2) { + $0_1 = $0_1 | 0; + $1_1 = $1_1 | 0; + $2 = $2 | 0; + wasm2js_memory_fill($0_1, $1_1, $2); + } + + function $1($0_1) { + $0_1 = $0_1 | 0; + return HEAPU8[$0_1 >> 0] | 0 | 0; + } + + var FUNCTION_TABLE = []; + function __wasm_memory_size() { + return buffer.byteLength / 65536 | 0; + } + + function __wasm_memory_grow(pagesToAdd) { + pagesToAdd = pagesToAdd | 0; + var oldPages = __wasm_memory_size() | 0; + var newPages = oldPages + pagesToAdd | 0; + if ((oldPages < newPages) && (newPages < 65536)) { + var newBuffer = new ArrayBuffer(Math_imul(newPages, 65536)); + var newHEAP8 = new global.Int8Array(newBuffer); + newHEAP8.set(HEAP8); + HEAP8 = newHEAP8; + HEAP8 = new global.Int8Array(newBuffer); + HEAP16 = new global.Int16Array(newBuffer); + HEAP32 = new global.Int32Array(newBuffer); + HEAPU8 = new global.Uint8Array(newBuffer); + HEAPU16 = new global.Uint16Array(newBuffer); + HEAPU32 = new global.Uint32Array(newBuffer); + HEAPF32 = new global.Float32Array(newBuffer); + HEAPF64 = new global.Float64Array(newBuffer); + buffer = newBuffer; + } + return oldPages; + } + + return { + "fill": $0, + "load8_u": $1 + }; +} + +var memasmFunc = new ArrayBuffer(65536); +var bufferView = new Uint8Array(memasmFunc); +var retasmFunc = asmFunc({Math,Int8Array,Uint8Array,Int16Array,Uint16Array,Int32Array,Uint32Array,Float32Array,Float64Array,NaN,Infinity}, {abort:function() { throw new Error('abort'); }},memasmFunc); +export var fill = retasmFunc.fill; +export var load8_u = retasmFunc.load8_u; + + + var scratchBuffer = new ArrayBuffer(8); + var i32ScratchView = new Int32Array(scratchBuffer); + var f32ScratchView = new Float32Array(scratchBuffer); + var f64ScratchView = new Float64Array(scratchBuffer); + + function wasm2js_memory_copy(dest, source, size) { + // TODO: traps on invalid things + bufferView.copyWithin(dest, source, source + size); + } + +function asmFunc(global, env, buffer) { + var HEAP8 = new global.Int8Array(buffer); + var HEAP16 = new global.Int16Array(buffer); + var HEAP32 = new global.Int32Array(buffer); + var HEAPU8 = new global.Uint8Array(buffer); + var HEAPU16 = new global.Uint16Array(buffer); + var HEAPU32 = new global.Uint32Array(buffer); + var HEAPF32 = new global.Float32Array(buffer); + var HEAPF64 = new global.Float64Array(buffer); + var Math_imul = global.Math.imul; + var Math_fround = global.Math.fround; + var Math_abs = global.Math.abs; + var Math_clz32 = global.Math.clz32; + var Math_min = global.Math.min; + var Math_max = global.Math.max; + var Math_floor = global.Math.floor; + var Math_ceil = global.Math.ceil; + var Math_sqrt = global.Math.sqrt; + var abort = env.abort; + var nan = global.NaN; + var infinity = global.Infinity; + function $0($0_1, $1_1, $2) { + $0_1 = $0_1 | 0; + $1_1 = $1_1 | 0; + $2 = $2 | 0; + wasm2js_memory_copy($0_1, $1_1, $2); + } + + function $1($0_1) { + $0_1 = $0_1 | 0; + return HEAPU8[$0_1 >> 0] | 0 | 0; + } + + var FUNCTION_TABLE = []; + function __wasm_memory_size() { + return buffer.byteLength / 65536 | 0; + } + + return { + "copy": $0, + "load8_u": $1 + }; +} + +var memasmFunc = new ArrayBuffer(65536); +var bufferView = new Uint8Array(memasmFunc); +for (var base64ReverseLookup = new Uint8Array(123/*'z'+1*/), i = 25; i >= 0; --i) { + base64ReverseLookup[48+i] = 52+i; // '0-9' + base64ReverseLookup[65+i] = i; // 'A-Z' + base64ReverseLookup[97+i] = 26+i; // 'a-z' + } + base64ReverseLookup[43] = 62; // '+' + base64ReverseLookup[47] = 63; // '/' + /** @noinline Inlining this function would mean expanding the base64 string 4x times in the source code, which Closure seems to be happy to do. */ + function base64DecodeToExistingUint8Array(uint8Array, offset, b64) { + var b1, b2, i = 0, j = offset, bLength = b64.length, end = offset + (bLength*3>>2) - (b64[bLength-2] == '=') - (b64[bLength-1] == '='); + for (; i < bLength; i += 4) { + b1 = base64ReverseLookup[b64.charCodeAt(i+1)]; + b2 = base64ReverseLookup[b64.charCodeAt(i+2)]; + uint8Array[j++] = base64ReverseLookup[b64.charCodeAt(i)] << 2 | b1 >> 4; + if (j < end) uint8Array[j++] = b1 << 4 | b2 >> 2; + if (j < end) uint8Array[j++] = b2 << 6 | base64ReverseLookup[b64.charCodeAt(i+3)]; + } + return uint8Array; + } + base64DecodeToExistingUint8Array(bufferView, 0, "qrvM3Q=="); +var retasmFunc = asmFunc({Math,Int8Array,Uint8Array,Int16Array,Uint16Array,Int32Array,Uint32Array,Float32Array,Float64Array,NaN,Infinity}, {abort:function() { throw new Error('abort'); }},memasmFunc); +export var copy = retasmFunc.copy; +export var load8_u = retasmFunc.load8_u; + + + var scratchBuffer = new ArrayBuffer(8); + var i32ScratchView = new Int32Array(scratchBuffer); + var f32ScratchView = new Float32Array(scratchBuffer); + var f64ScratchView = new Float64Array(scratchBuffer); + + function wasm2js_memory_init(segment, dest, offset, size) { + // TODO: traps on invalid things + bufferView.set(memorySegments[segment].subarray(offset, offset + size), dest); + } + + var memorySegments = {}; + +function asmFunc(global, env, buffer) { + var HEAP8 = new global.Int8Array(buffer); + var HEAP16 = new global.Int16Array(buffer); + var HEAP32 = new global.Int32Array(buffer); + var HEAPU8 = new global.Uint8Array(buffer); + var HEAPU16 = new global.Uint16Array(buffer); + var HEAPU32 = new global.Uint32Array(buffer); + var HEAPF32 = new global.Float32Array(buffer); + var HEAPF64 = new global.Float64Array(buffer); + var Math_imul = global.Math.imul; + var Math_fround = global.Math.fround; + var Math_abs = global.Math.abs; + var Math_clz32 = global.Math.clz32; + var Math_min = global.Math.min; + var Math_max = global.Math.max; + var Math_floor = global.Math.floor; + var Math_ceil = global.Math.ceil; + var Math_sqrt = global.Math.sqrt; + var abort = env.abort; + var nan = global.NaN; + var infinity = global.Infinity; + function $0($0_1, $1_1, $2) { + $0_1 = $0_1 | 0; + $1_1 = $1_1 | 0; + $2 = $2 | 0; + wasm2js_memory_init(0, $0_1, $1_1, $2); + } + + function $1($0_1) { + $0_1 = $0_1 | 0; + return HEAPU8[$0_1 >> 0] | 0 | 0; + } + + var FUNCTION_TABLE = []; + function __wasm_memory_size() { + return buffer.byteLength / 65536 | 0; + } + + function __wasm_memory_grow(pagesToAdd) { + pagesToAdd = pagesToAdd | 0; + var oldPages = __wasm_memory_size() | 0; + var newPages = oldPages + pagesToAdd | 0; + if ((oldPages < newPages) && (newPages < 65536)) { + var newBuffer = new ArrayBuffer(Math_imul(newPages, 65536)); + var newHEAP8 = new global.Int8Array(newBuffer); + newHEAP8.set(HEAP8); + HEAP8 = newHEAP8; + HEAP8 = new global.Int8Array(newBuffer); + HEAP16 = new global.Int16Array(newBuffer); + HEAP32 = new global.Int32Array(newBuffer); + HEAPU8 = new global.Uint8Array(newBuffer); + HEAPU16 = new global.Uint16Array(newBuffer); + HEAPU32 = new global.Uint32Array(newBuffer); + HEAPF32 = new global.Float32Array(newBuffer); + HEAPF64 = new global.Float64Array(newBuffer); + buffer = newBuffer; + } + return oldPages; + } + + return { + "init": $0, + "load8_u": $1 + }; +} + +var memasmFunc = new ArrayBuffer(65536); +var bufferView = new Uint8Array(memasmFunc); +for (var base64ReverseLookup = new Uint8Array(123/*'z'+1*/), i = 25; i >= 0; --i) { + base64ReverseLookup[48+i] = 52+i; // '0-9' + base64ReverseLookup[65+i] = i; // 'A-Z' + base64ReverseLookup[97+i] = 26+i; // 'a-z' + } + base64ReverseLookup[43] = 62; // '+' + base64ReverseLookup[47] = 63; // '/' + /** @noinline Inlining this function would mean expanding the base64 string 4x times in the source code, which Closure seems to be happy to do. */ + function base64DecodeToExistingUint8Array(uint8Array, offset, b64) { + var b1, b2, i = 0, j = offset, bLength = b64.length, end = offset + (bLength*3>>2) - (b64[bLength-2] == '=') - (b64[bLength-1] == '='); + for (; i < bLength; i += 4) { + b1 = base64ReverseLookup[b64.charCodeAt(i+1)]; + b2 = base64ReverseLookup[b64.charCodeAt(i+2)]; + uint8Array[j++] = base64ReverseLookup[b64.charCodeAt(i)] << 2 | b1 >> 4; + if (j < end) uint8Array[j++] = b1 << 4 | b2 >> 2; + if (j < end) uint8Array[j++] = b2 << 6 | base64ReverseLookup[b64.charCodeAt(i+3)]; + } + return uint8Array; + } + memorySegments[0] = base64DecodeToExistingUint8Array(new Uint8Array(4), 0, "qrvM3Q=="); +var retasmFunc = asmFunc({Math,Int8Array,Uint8Array,Int16Array,Uint16Array,Int32Array,Uint32Array,Float32Array,Float64Array,NaN,Infinity}, {abort:function() { throw new Error('abort'); }},memasmFunc); +export var init = retasmFunc.init; +export var load8_u = retasmFunc.load8_u; + + + var scratchBuffer = new ArrayBuffer(8); + var i32ScratchView = new Int32Array(scratchBuffer); + var f32ScratchView = new Float32Array(scratchBuffer); + var f64ScratchView = new Float64Array(scratchBuffer); + + function wasm2js_data_drop(segment) { + // TODO: traps on invalid things + memorySegments[segment] = new Uint8Array(0); + } + + function wasm2js_memory_init(segment, dest, offset, size) { + // TODO: traps on invalid things + bufferView.set(memorySegments[segment].subarray(offset, offset + size), dest); + } + + var memorySegments = {}; + +function asmFunc(global, env, buffer) { + var HEAP8 = new global.Int8Array(buffer); + var HEAP16 = new global.Int16Array(buffer); + var HEAP32 = new global.Int32Array(buffer); + var HEAPU8 = new global.Uint8Array(buffer); + var HEAPU16 = new global.Uint16Array(buffer); + var HEAPU32 = new global.Uint32Array(buffer); + var HEAPF32 = new global.Float32Array(buffer); + var HEAPF64 = new global.Float64Array(buffer); + var Math_imul = global.Math.imul; + var Math_fround = global.Math.fround; + var Math_abs = global.Math.abs; + var Math_clz32 = global.Math.clz32; + var Math_min = global.Math.min; + var Math_max = global.Math.max; + var Math_floor = global.Math.floor; + var Math_ceil = global.Math.ceil; + var Math_sqrt = global.Math.sqrt; + var abort = env.abort; + var nan = global.NaN; + var infinity = global.Infinity; + function $0() { + wasm2js_data_drop(0); + } + + function $1() { + wasm2js_memory_init(0, 0, 0, 0); + } + + function $2() { + wasm2js_data_drop(1); + } + + function $3() { + wasm2js_memory_init(1, 0, 0, 0); + } + + var FUNCTION_TABLE = []; + function __wasm_memory_size() { + return buffer.byteLength / 65536 | 0; + } + + function __wasm_memory_grow(pagesToAdd) { + pagesToAdd = pagesToAdd | 0; + var oldPages = __wasm_memory_size() | 0; + var newPages = oldPages + pagesToAdd | 0; + if ((oldPages < newPages) && (newPages < 65536)) { + var newBuffer = new ArrayBuffer(Math_imul(newPages, 65536)); + var newHEAP8 = new global.Int8Array(newBuffer); + newHEAP8.set(HEAP8); + HEAP8 = newHEAP8; + HEAP8 = new global.Int8Array(newBuffer); + HEAP16 = new global.Int16Array(newBuffer); + HEAP32 = new global.Int32Array(newBuffer); + HEAPU8 = new global.Uint8Array(newBuffer); + HEAPU16 = new global.Uint16Array(newBuffer); + HEAPU32 = new global.Uint32Array(newBuffer); + HEAPF32 = new global.Float32Array(newBuffer); + HEAPF64 = new global.Float64Array(newBuffer); + buffer = newBuffer; + } + return oldPages; + } + + return { + "drop_passive": $0, + "init_passive": $1, + "drop_active": $2, + "init_active": $3 + }; +} + +var memasmFunc = new ArrayBuffer(65536); +var bufferView = new Uint8Array(memasmFunc); +for (var base64ReverseLookup = new Uint8Array(123/*'z'+1*/), i = 25; i >= 0; --i) { + base64ReverseLookup[48+i] = 52+i; // '0-9' + base64ReverseLookup[65+i] = i; // 'A-Z' + base64ReverseLookup[97+i] = 26+i; // 'a-z' + } + base64ReverseLookup[43] = 62; // '+' + base64ReverseLookup[47] = 63; // '/' + /** @noinline Inlining this function would mean expanding the base64 string 4x times in the source code, which Closure seems to be happy to do. */ + function base64DecodeToExistingUint8Array(uint8Array, offset, b64) { + var b1, b2, i = 0, j = offset, bLength = b64.length, end = offset + (bLength*3>>2) - (b64[bLength-2] == '=') - (b64[bLength-1] == '='); + for (; i < bLength; i += 4) { + b1 = base64ReverseLookup[b64.charCodeAt(i+1)]; + b2 = base64ReverseLookup[b64.charCodeAt(i+2)]; + uint8Array[j++] = base64ReverseLookup[b64.charCodeAt(i)] << 2 | b1 >> 4; + if (j < end) uint8Array[j++] = b1 << 4 | b2 >> 2; + if (j < end) uint8Array[j++] = b2 << 6 | base64ReverseLookup[b64.charCodeAt(i+3)]; + } + return uint8Array; + } + memorySegments[0] = base64DecodeToExistingUint8Array(new Uint8Array(0), 0, ""); +base64DecodeToExistingUint8Array(bufferView, 0, ""); +var retasmFunc = asmFunc({Math,Int8Array,Uint8Array,Int16Array,Uint16Array,Int32Array,Uint32Array,Float32Array,Float64Array,NaN,Infinity}, {abort:function() { throw new Error('abort'); }},memasmFunc); +export var drop_passive = retasmFunc.drop_passive; +export var init_passive = retasmFunc.init_passive; +export var drop_active = retasmFunc.drop_active; +export var init_active = retasmFunc.init_active; diff --git a/test/wasm2js/bulk-memory.2asm.js.opt b/test/wasm2js/bulk-memory.2asm.js.opt new file mode 100644 index 000000000..620a7bbc7 --- /dev/null +++ b/test/wasm2js/bulk-memory.2asm.js.opt @@ -0,0 +1,375 @@ + +function asmFunc(global, env, buffer) { + var HEAP8 = new global.Int8Array(buffer); + var HEAP16 = new global.Int16Array(buffer); + var HEAP32 = new global.Int32Array(buffer); + var HEAPU8 = new global.Uint8Array(buffer); + var HEAPU16 = new global.Uint16Array(buffer); + var HEAPU32 = new global.Uint32Array(buffer); + var HEAPF32 = new global.Float32Array(buffer); + var HEAPF64 = new global.Float64Array(buffer); + var Math_imul = global.Math.imul; + var Math_fround = global.Math.fround; + var Math_abs = global.Math.abs; + var Math_clz32 = global.Math.clz32; + var Math_min = global.Math.min; + var Math_max = global.Math.max; + var Math_floor = global.Math.floor; + var Math_ceil = global.Math.ceil; + var Math_sqrt = global.Math.sqrt; + var abort = env.abort; + var nan = global.NaN; + var infinity = global.Infinity; + var FUNCTION_TABLE = []; + return { + + }; +} + +var memasmFunc = new ArrayBuffer(65536); +var retasmFunc = asmFunc({Math,Int8Array,Uint8Array,Int16Array,Uint16Array,Int32Array,Uint32Array,Float32Array,Float64Array,NaN,Infinity}, {abort:function() { throw new Error('abort'); }},memasmFunc); + + + var scratchBuffer = new ArrayBuffer(8); + var i32ScratchView = new Int32Array(scratchBuffer); + var f32ScratchView = new Float32Array(scratchBuffer); + var f64ScratchView = new Float64Array(scratchBuffer); + + function wasm2js_memory_fill(dest, value, size) { + dest = dest >>> 0; + size = size >>> 0; + if (dest + size > bufferView.length) throw "trap: invalid memory.fill"; + bufferView.fill(value, dest, dest + size); + } + +function asmFunc(global, env, buffer) { + var HEAP8 = new global.Int8Array(buffer); + var HEAP16 = new global.Int16Array(buffer); + var HEAP32 = new global.Int32Array(buffer); + var HEAPU8 = new global.Uint8Array(buffer); + var HEAPU16 = new global.Uint16Array(buffer); + var HEAPU32 = new global.Uint32Array(buffer); + var HEAPF32 = new global.Float32Array(buffer); + var HEAPF64 = new global.Float64Array(buffer); + var Math_imul = global.Math.imul; + var Math_fround = global.Math.fround; + var Math_abs = global.Math.abs; + var Math_clz32 = global.Math.clz32; + var Math_min = global.Math.min; + var Math_max = global.Math.max; + var Math_floor = global.Math.floor; + var Math_ceil = global.Math.ceil; + var Math_sqrt = global.Math.sqrt; + var abort = env.abort; + var nan = global.NaN; + var infinity = global.Infinity; + function $0($0_1, $1_1, $2) { + $0_1 = $0_1 | 0; + $1_1 = $1_1 | 0; + $2 = $2 | 0; + wasm2js_memory_fill($0_1, $1_1, $2); + } + + function $1($0_1) { + $0_1 = $0_1 | 0; + return HEAPU8[$0_1 | 0]; + } + + var FUNCTION_TABLE = []; + function __wasm_memory_size() { + return buffer.byteLength / 65536 | 0; + } + + function __wasm_memory_grow(pagesToAdd) { + pagesToAdd = pagesToAdd | 0; + var oldPages = __wasm_memory_size() | 0; + var newPages = oldPages + pagesToAdd | 0; + if ((oldPages < newPages) && (newPages < 65536)) { + var newBuffer = new ArrayBuffer(Math_imul(newPages, 65536)); + var newHEAP8 = new global.Int8Array(newBuffer); + newHEAP8.set(HEAP8); + HEAP8 = newHEAP8; + HEAP8 = new global.Int8Array(newBuffer); + HEAP16 = new global.Int16Array(newBuffer); + HEAP32 = new global.Int32Array(newBuffer); + HEAPU8 = new global.Uint8Array(newBuffer); + HEAPU16 = new global.Uint16Array(newBuffer); + HEAPU32 = new global.Uint32Array(newBuffer); + HEAPF32 = new global.Float32Array(newBuffer); + HEAPF64 = new global.Float64Array(newBuffer); + buffer = newBuffer; + } + return oldPages; + } + + return { + "fill": $0, + "load8_u": $1 + }; +} + +var memasmFunc = new ArrayBuffer(65536); +var bufferView = new Uint8Array(memasmFunc); +var retasmFunc = asmFunc({Math,Int8Array,Uint8Array,Int16Array,Uint16Array,Int32Array,Uint32Array,Float32Array,Float64Array,NaN,Infinity}, {abort:function() { throw new Error('abort'); }},memasmFunc); +export var fill = retasmFunc.fill; +export var load8_u = retasmFunc.load8_u; + + + var scratchBuffer = new ArrayBuffer(8); + var i32ScratchView = new Int32Array(scratchBuffer); + var f32ScratchView = new Float32Array(scratchBuffer); + var f64ScratchView = new Float64Array(scratchBuffer); + + function wasm2js_memory_copy(dest, source, size) { + // TODO: traps on invalid things + bufferView.copyWithin(dest, source, source + size); + } + +function asmFunc(global, env, buffer) { + var HEAP8 = new global.Int8Array(buffer); + var HEAP16 = new global.Int16Array(buffer); + var HEAP32 = new global.Int32Array(buffer); + var HEAPU8 = new global.Uint8Array(buffer); + var HEAPU16 = new global.Uint16Array(buffer); + var HEAPU32 = new global.Uint32Array(buffer); + var HEAPF32 = new global.Float32Array(buffer); + var HEAPF64 = new global.Float64Array(buffer); + var Math_imul = global.Math.imul; + var Math_fround = global.Math.fround; + var Math_abs = global.Math.abs; + var Math_clz32 = global.Math.clz32; + var Math_min = global.Math.min; + var Math_max = global.Math.max; + var Math_floor = global.Math.floor; + var Math_ceil = global.Math.ceil; + var Math_sqrt = global.Math.sqrt; + var abort = env.abort; + var nan = global.NaN; + var infinity = global.Infinity; + function $0($0_1, $1_1, $2) { + $0_1 = $0_1 | 0; + $1_1 = $1_1 | 0; + $2 = $2 | 0; + wasm2js_memory_copy($0_1, $1_1, $2); + } + + function $1($0_1) { + $0_1 = $0_1 | 0; + return HEAPU8[$0_1 | 0]; + } + + var FUNCTION_TABLE = []; + function __wasm_memory_size() { + return buffer.byteLength / 65536 | 0; + } + + return { + "copy": $0, + "load8_u": $1 + }; +} + +var memasmFunc = new ArrayBuffer(65536); +var bufferView = new Uint8Array(memasmFunc); +for (var base64ReverseLookup = new Uint8Array(123/*'z'+1*/), i = 25; i >= 0; --i) { + base64ReverseLookup[48+i] = 52+i; // '0-9' + base64ReverseLookup[65+i] = i; // 'A-Z' + base64ReverseLookup[97+i] = 26+i; // 'a-z' + } + base64ReverseLookup[43] = 62; // '+' + base64ReverseLookup[47] = 63; // '/' + /** @noinline Inlining this function would mean expanding the base64 string 4x times in the source code, which Closure seems to be happy to do. */ + function base64DecodeToExistingUint8Array(uint8Array, offset, b64) { + var b1, b2, i = 0, j = offset, bLength = b64.length, end = offset + (bLength*3>>2) - (b64[bLength-2] == '=') - (b64[bLength-1] == '='); + for (; i < bLength; i += 4) { + b1 = base64ReverseLookup[b64.charCodeAt(i+1)]; + b2 = base64ReverseLookup[b64.charCodeAt(i+2)]; + uint8Array[j++] = base64ReverseLookup[b64.charCodeAt(i)] << 2 | b1 >> 4; + if (j < end) uint8Array[j++] = b1 << 4 | b2 >> 2; + if (j < end) uint8Array[j++] = b2 << 6 | base64ReverseLookup[b64.charCodeAt(i+3)]; + } + return uint8Array; + } + base64DecodeToExistingUint8Array(bufferView, 0, "qrvM3Q=="); +var retasmFunc = asmFunc({Math,Int8Array,Uint8Array,Int16Array,Uint16Array,Int32Array,Uint32Array,Float32Array,Float64Array,NaN,Infinity}, {abort:function() { throw new Error('abort'); }},memasmFunc); +export var copy = retasmFunc.copy; +export var load8_u = retasmFunc.load8_u; + + + var scratchBuffer = new ArrayBuffer(8); + var i32ScratchView = new Int32Array(scratchBuffer); + var f32ScratchView = new Float32Array(scratchBuffer); + var f64ScratchView = new Float64Array(scratchBuffer); + + function wasm2js_memory_init(segment, dest, offset, size) { + // TODO: traps on invalid things + bufferView.set(memorySegments[segment].subarray(offset, offset + size), dest); + } + + var memorySegments = {}; + +function asmFunc(global, env, buffer) { + var HEAP8 = new global.Int8Array(buffer); + var HEAP16 = new global.Int16Array(buffer); + var HEAP32 = new global.Int32Array(buffer); + var HEAPU8 = new global.Uint8Array(buffer); + var HEAPU16 = new global.Uint16Array(buffer); + var HEAPU32 = new global.Uint32Array(buffer); + var HEAPF32 = new global.Float32Array(buffer); + var HEAPF64 = new global.Float64Array(buffer); + var Math_imul = global.Math.imul; + var Math_fround = global.Math.fround; + var Math_abs = global.Math.abs; + var Math_clz32 = global.Math.clz32; + var Math_min = global.Math.min; + var Math_max = global.Math.max; + var Math_floor = global.Math.floor; + var Math_ceil = global.Math.ceil; + var Math_sqrt = global.Math.sqrt; + var abort = env.abort; + var nan = global.NaN; + var infinity = global.Infinity; + function $0($0_1, $1_1, $2) { + $0_1 = $0_1 | 0; + $1_1 = $1_1 | 0; + $2 = $2 | 0; + wasm2js_memory_init(0, $0_1, $1_1, $2); + } + + function $1($0_1) { + $0_1 = $0_1 | 0; + return HEAPU8[$0_1 | 0]; + } + + var FUNCTION_TABLE = []; + function __wasm_memory_size() { + return buffer.byteLength / 65536 | 0; + } + + function __wasm_memory_grow(pagesToAdd) { + pagesToAdd = pagesToAdd | 0; + var oldPages = __wasm_memory_size() | 0; + var newPages = oldPages + pagesToAdd | 0; + if ((oldPages < newPages) && (newPages < 65536)) { + var newBuffer = new ArrayBuffer(Math_imul(newPages, 65536)); + var newHEAP8 = new global.Int8Array(newBuffer); + newHEAP8.set(HEAP8); + HEAP8 = newHEAP8; + HEAP8 = new global.Int8Array(newBuffer); + HEAP16 = new global.Int16Array(newBuffer); + HEAP32 = new global.Int32Array(newBuffer); + HEAPU8 = new global.Uint8Array(newBuffer); + HEAPU16 = new global.Uint16Array(newBuffer); + HEAPU32 = new global.Uint32Array(newBuffer); + HEAPF32 = new global.Float32Array(newBuffer); + HEAPF64 = new global.Float64Array(newBuffer); + buffer = newBuffer; + } + return oldPages; + } + + return { + "init": $0, + "load8_u": $1 + }; +} + +var memasmFunc = new ArrayBuffer(65536); +var bufferView = new Uint8Array(memasmFunc); +for (var base64ReverseLookup = new Uint8Array(123/*'z'+1*/), i = 25; i >= 0; --i) { + base64ReverseLookup[48+i] = 52+i; // '0-9' + base64ReverseLookup[65+i] = i; // 'A-Z' + base64ReverseLookup[97+i] = 26+i; // 'a-z' + } + base64ReverseLookup[43] = 62; // '+' + base64ReverseLookup[47] = 63; // '/' + /** @noinline Inlining this function would mean expanding the base64 string 4x times in the source code, which Closure seems to be happy to do. */ + function base64DecodeToExistingUint8Array(uint8Array, offset, b64) { + var b1, b2, i = 0, j = offset, bLength = b64.length, end = offset + (bLength*3>>2) - (b64[bLength-2] == '=') - (b64[bLength-1] == '='); + for (; i < bLength; i += 4) { + b1 = base64ReverseLookup[b64.charCodeAt(i+1)]; + b2 = base64ReverseLookup[b64.charCodeAt(i+2)]; + uint8Array[j++] = base64ReverseLookup[b64.charCodeAt(i)] << 2 | b1 >> 4; + if (j < end) uint8Array[j++] = b1 << 4 | b2 >> 2; + if (j < end) uint8Array[j++] = b2 << 6 | base64ReverseLookup[b64.charCodeAt(i+3)]; + } + return uint8Array; + } + memorySegments[0] = base64DecodeToExistingUint8Array(new Uint8Array(4), 0, "qrvM3Q=="); +var retasmFunc = asmFunc({Math,Int8Array,Uint8Array,Int16Array,Uint16Array,Int32Array,Uint32Array,Float32Array,Float64Array,NaN,Infinity}, {abort:function() { throw new Error('abort'); }},memasmFunc); +export var init = retasmFunc.init; +export var load8_u = retasmFunc.load8_u; + +function asmFunc(global, env, buffer) { + var HEAP8 = new global.Int8Array(buffer); + var HEAP16 = new global.Int16Array(buffer); + var HEAP32 = new global.Int32Array(buffer); + var HEAPU8 = new global.Uint8Array(buffer); + var HEAPU16 = new global.Uint16Array(buffer); + var HEAPU32 = new global.Uint32Array(buffer); + var HEAPF32 = new global.Float32Array(buffer); + var HEAPF64 = new global.Float64Array(buffer); + var Math_imul = global.Math.imul; + var Math_fround = global.Math.fround; + var Math_abs = global.Math.abs; + var Math_clz32 = global.Math.clz32; + var Math_min = global.Math.min; + var Math_max = global.Math.max; + var Math_floor = global.Math.floor; + var Math_ceil = global.Math.ceil; + var Math_sqrt = global.Math.sqrt; + var abort = env.abort; + var nan = global.NaN; + var infinity = global.Infinity; + function $0() { + + } + + function $1() { + if (0 > __wasm_memory_size() << 16 >>> 0) { + abort() + } + } + + var FUNCTION_TABLE = []; + function __wasm_memory_size() { + return buffer.byteLength / 65536 | 0; + } + + function __wasm_memory_grow(pagesToAdd) { + pagesToAdd = pagesToAdd | 0; + var oldPages = __wasm_memory_size() | 0; + var newPages = oldPages + pagesToAdd | 0; + if ((oldPages < newPages) && (newPages < 65536)) { + var newBuffer = new ArrayBuffer(Math_imul(newPages, 65536)); + var newHEAP8 = new global.Int8Array(newBuffer); + newHEAP8.set(HEAP8); + HEAP8 = newHEAP8; + HEAP8 = new global.Int8Array(newBuffer); + HEAP16 = new global.Int16Array(newBuffer); + HEAP32 = new global.Int32Array(newBuffer); + HEAPU8 = new global.Uint8Array(newBuffer); + HEAPU16 = new global.Uint16Array(newBuffer); + HEAPU32 = new global.Uint32Array(newBuffer); + HEAPF32 = new global.Float32Array(newBuffer); + HEAPF64 = new global.Float64Array(newBuffer); + buffer = newBuffer; + } + return oldPages; + } + + return { + "drop_passive": $0, + "init_passive": $1, + "drop_active": $0, + "init_active": $1 + }; +} + +var memasmFunc = new ArrayBuffer(65536); +var bufferView = new Uint8Array(memasmFunc); +var retasmFunc = asmFunc({Math,Int8Array,Uint8Array,Int16Array,Uint16Array,Int32Array,Uint32Array,Float32Array,Float64Array,NaN,Infinity}, {abort:function() { throw new Error('abort'); }},memasmFunc); +export var drop_passive = retasmFunc.drop_passive; +export var init_passive = retasmFunc.init_passive; +export var drop_active = retasmFunc.drop_active; +export var init_active = retasmFunc.init_active; diff --git a/test/wasm2js/deterministic.2asm.js b/test/wasm2js/deterministic.2asm.js index 8954443cf..675f9003c 100644 --- a/test/wasm2js/deterministic.2asm.js +++ b/test/wasm2js/deterministic.2asm.js @@ -40,5 +40,6 @@ function asmFunc(global, env, buffer) { } var memasmFunc = new ArrayBuffer(65536); +var bufferView = new Uint8Array(memasmFunc); var retasmFunc = asmFunc({Math,Int8Array,Uint8Array,Int16Array,Uint16Array,Int32Array,Uint32Array,Float32Array,Float64Array,NaN,Infinity}, {abort:function() { throw new Error('abort'); }},memasmFunc); export var foo = retasmFunc.foo; diff --git a/test/wasm2js/deterministic.2asm.js.opt b/test/wasm2js/deterministic.2asm.js.opt index 7a49ec1fb..4f103eda8 100644 --- a/test/wasm2js/deterministic.2asm.js.opt +++ b/test/wasm2js/deterministic.2asm.js.opt @@ -39,5 +39,6 @@ function asmFunc(global, env, buffer) { } var memasmFunc = new ArrayBuffer(65536); +var bufferView = new Uint8Array(memasmFunc); var retasmFunc = asmFunc({Math,Int8Array,Uint8Array,Int16Array,Uint16Array,Int32Array,Uint32Array,Float32Array,Float64Array,NaN,Infinity}, {abort:function() { throw new Error('abort'); }},memasmFunc); export var foo = retasmFunc.foo; diff --git a/test/wasm2js/dynamicLibrary.2asm.js b/test/wasm2js/dynamicLibrary.2asm.js index d9ae10cc6..9c58da101 100644 --- a/test/wasm2js/dynamicLibrary.2asm.js +++ b/test/wasm2js/dynamicLibrary.2asm.js @@ -50,6 +50,7 @@ function asmFunc(global, env, buffer) { } var memasmFunc = new ArrayBuffer(16777216); +var bufferView = new Uint8Array(memasmFunc); for (var base64ReverseLookup = new Uint8Array(123/*'z'+1*/), i = 25; i >= 0; --i) { base64ReverseLookup[48+i] = 52+i; // '0-9' base64ReverseLookup[65+i] = i; // 'A-Z' @@ -67,8 +68,8 @@ for (var base64ReverseLookup = new Uint8Array(123/*'z'+1*/), i = 25; i >= 0; --i if (j < end) uint8Array[j++] = b1 << 4 | b2 >> 2; if (j < end) uint8Array[j++] = b2 << 6 | base64ReverseLookup[b64.charCodeAt(i+3)]; } + return uint8Array; } -var bufferView = new Uint8Array(memasmFunc); -base64DecodeToExistingUint8Array(bufferView, memoryBase, "ZHluYW1pYyBkYXRh"); + base64DecodeToExistingUint8Array(bufferView, memoryBase, "ZHluYW1pYyBkYXRh"); var retasmFunc = asmFunc({Math,Int8Array,Uint8Array,Int16Array,Uint16Array,Int32Array,Uint32Array,Float32Array,Float64Array,NaN,Infinity}, {abort:function() { throw new Error('abort'); }},memasmFunc); export var baz = retasmFunc.baz; diff --git a/test/wasm2js/dynamicLibrary.2asm.js.opt b/test/wasm2js/dynamicLibrary.2asm.js.opt index d2e28b645..71fa441ed 100644 --- a/test/wasm2js/dynamicLibrary.2asm.js.opt +++ b/test/wasm2js/dynamicLibrary.2asm.js.opt @@ -42,6 +42,7 @@ function asmFunc(global, env, buffer) { } var memasmFunc = new ArrayBuffer(16777216); +var bufferView = new Uint8Array(memasmFunc); for (var base64ReverseLookup = new Uint8Array(123/*'z'+1*/), i = 25; i >= 0; --i) { base64ReverseLookup[48+i] = 52+i; // '0-9' base64ReverseLookup[65+i] = i; // 'A-Z' @@ -59,8 +60,8 @@ for (var base64ReverseLookup = new Uint8Array(123/*'z'+1*/), i = 25; i >= 0; --i if (j < end) uint8Array[j++] = b1 << 4 | b2 >> 2; if (j < end) uint8Array[j++] = b2 << 6 | base64ReverseLookup[b64.charCodeAt(i+3)]; } + return uint8Array; } -var bufferView = new Uint8Array(memasmFunc); -base64DecodeToExistingUint8Array(bufferView, memoryBase, "ZHluYW1pYyBkYXRh"); + base64DecodeToExistingUint8Array(bufferView, memoryBase, "ZHluYW1pYyBkYXRh"); var retasmFunc = asmFunc({Math,Int8Array,Uint8Array,Int16Array,Uint16Array,Int32Array,Uint32Array,Float32Array,Float64Array,NaN,Infinity}, {abort:function() { throw new Error('abort'); }},memasmFunc); export var baz = retasmFunc.baz; diff --git a/test/wasm2js/emscripten-grow-no.2asm.js b/test/wasm2js/emscripten-grow-no.2asm.js index c3c0be859..dde2dd0ce 100644 --- a/test/wasm2js/emscripten-grow-no.2asm.js +++ b/test/wasm2js/emscripten-grow-no.2asm.js @@ -46,6 +46,7 @@ function asmFunc(global, env, buffer) { }; } +var bufferView = new Uint8Array(wasmMemory.buffer); for (var base64ReverseLookup = new Uint8Array(123/*'z'+1*/), i = 25; i >= 0; --i) { base64ReverseLookup[48+i] = 52+i; // '0-9' base64ReverseLookup[65+i] = i; // 'A-Z' @@ -63,9 +64,9 @@ for (var base64ReverseLookup = new Uint8Array(123/*'z'+1*/), i = 25; i >= 0; --i if (j < end) uint8Array[j++] = b1 << 4 | b2 >> 2; if (j < end) uint8Array[j++] = b2 << 6 | base64ReverseLookup[b64.charCodeAt(i+3)]; } + return uint8Array; } -var bufferView = new Uint8Array(wasmMemory.buffer); -base64DecodeToExistingUint8Array(bufferView, 1600, "YWJj"); + base64DecodeToExistingUint8Array(bufferView, 1600, "YWJj"); return asmFunc({ 'Int8Array': Int8Array, 'Int16Array': Int16Array, diff --git a/test/wasm2js/emscripten-grow-no.2asm.js.opt b/test/wasm2js/emscripten-grow-no.2asm.js.opt index c3c0be859..dde2dd0ce 100644 --- a/test/wasm2js/emscripten-grow-no.2asm.js.opt +++ b/test/wasm2js/emscripten-grow-no.2asm.js.opt @@ -46,6 +46,7 @@ function asmFunc(global, env, buffer) { }; } +var bufferView = new Uint8Array(wasmMemory.buffer); for (var base64ReverseLookup = new Uint8Array(123/*'z'+1*/), i = 25; i >= 0; --i) { base64ReverseLookup[48+i] = 52+i; // '0-9' base64ReverseLookup[65+i] = i; // 'A-Z' @@ -63,9 +64,9 @@ for (var base64ReverseLookup = new Uint8Array(123/*'z'+1*/), i = 25; i >= 0; --i if (j < end) uint8Array[j++] = b1 << 4 | b2 >> 2; if (j < end) uint8Array[j++] = b2 << 6 | base64ReverseLookup[b64.charCodeAt(i+3)]; } + return uint8Array; } -var bufferView = new Uint8Array(wasmMemory.buffer); -base64DecodeToExistingUint8Array(bufferView, 1600, "YWJj"); + base64DecodeToExistingUint8Array(bufferView, 1600, "YWJj"); return asmFunc({ 'Int8Array': Int8Array, 'Int16Array': Int16Array, diff --git a/test/wasm2js/emscripten-grow-yes.2asm.js b/test/wasm2js/emscripten-grow-yes.2asm.js index 5d9b250cf..f42a1b396 100644 --- a/test/wasm2js/emscripten-grow-yes.2asm.js +++ b/test/wasm2js/emscripten-grow-yes.2asm.js @@ -69,6 +69,7 @@ function asmFunc(global, env, buffer) { }; } +var bufferView = new Uint8Array(wasmMemory.buffer); for (var base64ReverseLookup = new Uint8Array(123/*'z'+1*/), i = 25; i >= 0; --i) { base64ReverseLookup[48+i] = 52+i; // '0-9' base64ReverseLookup[65+i] = i; // 'A-Z' @@ -86,9 +87,9 @@ for (var base64ReverseLookup = new Uint8Array(123/*'z'+1*/), i = 25; i >= 0; --i if (j < end) uint8Array[j++] = b1 << 4 | b2 >> 2; if (j < end) uint8Array[j++] = b2 << 6 | base64ReverseLookup[b64.charCodeAt(i+3)]; } + return uint8Array; } -var bufferView = new Uint8Array(wasmMemory.buffer); -base64DecodeToExistingUint8Array(bufferView, 1600, "YWJj"); + base64DecodeToExistingUint8Array(bufferView, 1600, "YWJj"); return asmFunc({ 'Int8Array': Int8Array, 'Int16Array': Int16Array, diff --git a/test/wasm2js/emscripten-grow-yes.2asm.js.opt b/test/wasm2js/emscripten-grow-yes.2asm.js.opt index 5d9b250cf..f42a1b396 100644 --- a/test/wasm2js/emscripten-grow-yes.2asm.js.opt +++ b/test/wasm2js/emscripten-grow-yes.2asm.js.opt @@ -69,6 +69,7 @@ function asmFunc(global, env, buffer) { }; } +var bufferView = new Uint8Array(wasmMemory.buffer); for (var base64ReverseLookup = new Uint8Array(123/*'z'+1*/), i = 25; i >= 0; --i) { base64ReverseLookup[48+i] = 52+i; // '0-9' base64ReverseLookup[65+i] = i; // 'A-Z' @@ -86,9 +87,9 @@ for (var base64ReverseLookup = new Uint8Array(123/*'z'+1*/), i = 25; i >= 0; --i if (j < end) uint8Array[j++] = b1 << 4 | b2 >> 2; if (j < end) uint8Array[j++] = b2 << 6 | base64ReverseLookup[b64.charCodeAt(i+3)]; } + return uint8Array; } -var bufferView = new Uint8Array(wasmMemory.buffer); -base64DecodeToExistingUint8Array(bufferView, 1600, "YWJj"); + base64DecodeToExistingUint8Array(bufferView, 1600, "YWJj"); return asmFunc({ 'Int8Array': Int8Array, 'Int16Array': Int16Array, diff --git a/test/wasm2js/emscripten.2asm.js b/test/wasm2js/emscripten.2asm.js index cf9c0192e..a595eb151 100644 --- a/test/wasm2js/emscripten.2asm.js +++ b/test/wasm2js/emscripten.2asm.js @@ -204,6 +204,7 @@ function asmFunc(global, env, buffer) { }; } +var bufferView = new Uint8Array(wasmMemory.buffer); for (var base64ReverseLookup = new Uint8Array(123/*'z'+1*/), i = 25; i >= 0; --i) { base64ReverseLookup[48+i] = 52+i; // '0-9' base64ReverseLookup[65+i] = i; // 'A-Z' @@ -221,9 +222,9 @@ for (var base64ReverseLookup = new Uint8Array(123/*'z'+1*/), i = 25; i >= 0; --i if (j < end) uint8Array[j++] = b1 << 4 | b2 >> 2; if (j < end) uint8Array[j++] = b2 << 6 | base64ReverseLookup[b64.charCodeAt(i+3)]; } + return uint8Array; } -var bufferView = new Uint8Array(wasmMemory.buffer); -base64DecodeToExistingUint8Array(bufferView, 1024, "aGVsbG8sIHdvcmxkIQoAAJwMAAAtKyAgIDBYMHgAKG51bGwpAAAAAAAAAAAAAAAAEQAKABEREQAAAAAFAAAAAAAACQAAAAALAAAAAAAAAAARAA8KERERAwoHAAETCQsLAAAJBgsAAAsABhEAAAAREREAAAAAAAAAAAAAAAAAAAAACwAAAAAAAAAAEQAKChEREQAKAAACAAkLAAAACQALAAALAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwAAAAAAAAAAAAAAAwAAAAADAAAAAAJDAAAAAAADAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOAAAAAAAAAAAAAAANAAAABA0AAAAACQ4AAAAAAA4AAA4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAADwAAAAAPAAAAAAkQAAAAAAAQAAAQAAASAAAAEhISAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABIAAAASEhIAAAAAAAAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALAAAAAAAAAAAAAAAKAAAAAAoAAAAACQsAAAAAAAsAAAsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAAAAAAAAAAAAAAADAAAAAAMAAAAAAkMAAAAAAAMAAAMAAAwMTIzNDU2Nzg5QUJDREVGLTBYKzBYIDBYLTB4KzB4IDB4AGluZgBJTkYAbmFuAE5BTgAuAA=="); + base64DecodeToExistingUint8Array(bufferView, 1024, "aGVsbG8sIHdvcmxkIQoAAJwMAAAtKyAgIDBYMHgAKG51bGwpAAAAAAAAAAAAAAAAEQAKABEREQAAAAAFAAAAAAAACQAAAAALAAAAAAAAAAARAA8KERERAwoHAAETCQsLAAAJBgsAAAsABhEAAAAREREAAAAAAAAAAAAAAAAAAAAACwAAAAAAAAAAEQAKChEREQAKAAACAAkLAAAACQALAAALAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwAAAAAAAAAAAAAAAwAAAAADAAAAAAJDAAAAAAADAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOAAAAAAAAAAAAAAANAAAABA0AAAAACQ4AAAAAAA4AAA4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAADwAAAAAPAAAAAAkQAAAAAAAQAAAQAAASAAAAEhISAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABIAAAASEhIAAAAAAAAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALAAAAAAAAAAAAAAAKAAAAAAoAAAAACQsAAAAAAAsAAAsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAAAAAAAAAAAAAAADAAAAAAMAAAAAAkMAAAAAAAMAAAMAAAwMTIzNDU2Nzg5QUJDREVGLTBYKzBYIDBYLTB4KzB4IDB4AGluZgBJTkYAbmFuAE5BTgAuAA=="); base64DecodeToExistingUint8Array(bufferView, 1600, "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA="); return asmFunc({ 'Int8Array': Int8Array, diff --git a/test/wasm2js/emscripten.2asm.js.opt b/test/wasm2js/emscripten.2asm.js.opt index d0ed67fdb..d697fa7c7 100644 --- a/test/wasm2js/emscripten.2asm.js.opt +++ b/test/wasm2js/emscripten.2asm.js.opt @@ -185,6 +185,7 @@ function asmFunc(global, env, buffer) { }; } +var bufferView = new Uint8Array(wasmMemory.buffer); for (var base64ReverseLookup = new Uint8Array(123/*'z'+1*/), i = 25; i >= 0; --i) { base64ReverseLookup[48+i] = 52+i; // '0-9' base64ReverseLookup[65+i] = i; // 'A-Z' @@ -202,9 +203,9 @@ for (var base64ReverseLookup = new Uint8Array(123/*'z'+1*/), i = 25; i >= 0; --i if (j < end) uint8Array[j++] = b1 << 4 | b2 >> 2; if (j < end) uint8Array[j++] = b2 << 6 | base64ReverseLookup[b64.charCodeAt(i+3)]; } + return uint8Array; } -var bufferView = new Uint8Array(wasmMemory.buffer); -base64DecodeToExistingUint8Array(bufferView, 1024, "aGVsbG8sIHdvcmxkIQoAAJwMAAAtKyAgIDBYMHgAKG51bGwp"); + base64DecodeToExistingUint8Array(bufferView, 1024, "aGVsbG8sIHdvcmxkIQoAAJwMAAAtKyAgIDBYMHgAKG51bGwp"); base64DecodeToExistingUint8Array(bufferView, 1072, "EQAKABEREQAAAAAFAAAAAAAACQAAAAALAAAAAAAAAAARAA8KERERAwoHAAETCQsLAAAJBgsAAAsABhEAAAARERE="); base64DecodeToExistingUint8Array(bufferView, 1153, "CwAAAAAAAAAAEQAKChEREQAKAAACAAkLAAAACQALAAAL"); base64DecodeToExistingUint8Array(bufferView, 1211, "DA=="); diff --git a/test/wasm2js/endianness.2asm.js b/test/wasm2js/endianness.2asm.js index 866d70005..2146a9840 100644 --- a/test/wasm2js/endianness.2asm.js +++ b/test/wasm2js/endianness.2asm.js @@ -698,6 +698,7 @@ function asmFunc(global, env, buffer) { } var memasmFunc = new ArrayBuffer(65536); +var bufferView = new Uint8Array(memasmFunc); var retasmFunc = asmFunc({Math,Int8Array,Uint8Array,Int16Array,Uint16Array,Int32Array,Uint32Array,Float32Array,Float64Array,NaN,Infinity}, {abort:function() { throw new Error('abort'); },setTempRet0},memasmFunc); export var i32_load16_s = retasmFunc.i32_load16_s; export var i32_load16_u = retasmFunc.i32_load16_u; diff --git a/test/wasm2js/grow-memory-tricky.2asm.js b/test/wasm2js/grow-memory-tricky.2asm.js index 3cf1bb4be..755b2976b 100644 --- a/test/wasm2js/grow-memory-tricky.2asm.js +++ b/test/wasm2js/grow-memory-tricky.2asm.js @@ -81,6 +81,7 @@ function asmFunc(global, env, buffer) { } var memasmFunc = new ArrayBuffer(65536); +var bufferView = new Uint8Array(memasmFunc); var retasmFunc = asmFunc({Math,Int8Array,Uint8Array,Int16Array,Uint16Array,Int32Array,Uint32Array,Float32Array,Float64Array,NaN,Infinity}, {abort:function() { throw new Error('abort'); }},memasmFunc); export var memory = retasmFunc.memory; export var f1 = retasmFunc.f1; diff --git a/test/wasm2js/grow-memory-tricky.2asm.js.opt b/test/wasm2js/grow-memory-tricky.2asm.js.opt index a2377b4c5..40a29264e 100644 --- a/test/wasm2js/grow-memory-tricky.2asm.js.opt +++ b/test/wasm2js/grow-memory-tricky.2asm.js.opt @@ -71,6 +71,7 @@ function asmFunc(global, env, buffer) { } var memasmFunc = new ArrayBuffer(65536); +var bufferView = new Uint8Array(memasmFunc); var retasmFunc = asmFunc({Math,Int8Array,Uint8Array,Int16Array,Uint16Array,Int32Array,Uint32Array,Float32Array,Float64Array,NaN,Infinity}, {abort:function() { throw new Error('abort'); }},memasmFunc); export var memory = retasmFunc.memory; export var f1 = retasmFunc.f1; diff --git a/test/wasm2js/grow_memory.2asm.js b/test/wasm2js/grow_memory.2asm.js index 675ee76e2..3b156ec85 100644 --- a/test/wasm2js/grow_memory.2asm.js +++ b/test/wasm2js/grow_memory.2asm.js @@ -74,6 +74,7 @@ function asmFunc(global, env, buffer) { } var memasmFunc = new ArrayBuffer(65536); +var bufferView = new Uint8Array(memasmFunc); var retasmFunc = asmFunc({Math,Int8Array,Uint8Array,Int16Array,Uint16Array,Int32Array,Uint32Array,Float32Array,Float64Array,NaN,Infinity}, {abort:function() { throw new Error('abort'); }},memasmFunc); export var memory = retasmFunc.memory; export var grow = retasmFunc.grow; diff --git a/test/wasm2js/left-to-right.2asm.js b/test/wasm2js/left-to-right.2asm.js index 2e474002b..4dc0b081c 100644 --- a/test/wasm2js/left-to-right.2asm.js +++ b/test/wasm2js/left-to-right.2asm.js @@ -2216,6 +2216,7 @@ function asmFunc(global, env, buffer) { } var memasmFunc = new ArrayBuffer(65536); +var bufferView = new Uint8Array(memasmFunc); var retasmFunc = asmFunc({Math,Int8Array,Uint8Array,Int16Array,Uint16Array,Int32Array,Uint32Array,Float32Array,Float64Array,NaN,Infinity}, {abort:function() { throw new Error('abort'); },getTempRet0},memasmFunc); export var i32_add = retasmFunc.i32_add; export var i32_sub = retasmFunc.i32_sub; diff --git a/test/wasm2js/traps.2asm.js b/test/wasm2js/traps.2asm.js index 22740f79a..f9070fe34 100644 --- a/test/wasm2js/traps.2asm.js +++ b/test/wasm2js/traps.2asm.js @@ -1828,6 +1828,7 @@ function asmFunc(global, env, buffer) { } var memasmFunc = new ArrayBuffer(65536); +var bufferView = new Uint8Array(memasmFunc); var retasmFunc = asmFunc({Math,Int8Array,Uint8Array,Int16Array,Uint16Array,Int32Array,Uint32Array,Float32Array,Float64Array,NaN,Infinity}, {abort:function() { throw new Error('abort'); }},memasmFunc); export var no_dce_i32_load = retasmFunc.no_dce_i32_load; export var no_dce_i32_load16_s = retasmFunc.no_dce_i32_load16_s; diff --git a/test/wasm2js/unaligned.2asm.js b/test/wasm2js/unaligned.2asm.js index be3163d17..2bf7da493 100644 --- a/test/wasm2js/unaligned.2asm.js +++ b/test/wasm2js/unaligned.2asm.js @@ -175,6 +175,7 @@ function asmFunc(global, env, buffer) { } var memasmFunc = new ArrayBuffer(65536); +var bufferView = new Uint8Array(memasmFunc); var retasmFunc = asmFunc({Math,Int8Array,Uint8Array,Int16Array,Uint16Array,Int32Array,Uint32Array,Float32Array,Float64Array,NaN,Infinity}, {abort:function() { throw new Error('abort'); },setTempRet0},memasmFunc); export var i32_load = retasmFunc.i32_load; export var i64_load = retasmFunc.i64_load; diff --git a/test/wasm2js/unaligned.2asm.js.opt b/test/wasm2js/unaligned.2asm.js.opt index b8df22fe5..8ab514e8f 100644 --- a/test/wasm2js/unaligned.2asm.js.opt +++ b/test/wasm2js/unaligned.2asm.js.opt @@ -128,6 +128,7 @@ function asmFunc(global, env, buffer) { } var memasmFunc = new ArrayBuffer(65536); +var bufferView = new Uint8Array(memasmFunc); var retasmFunc = asmFunc({Math,Int8Array,Uint8Array,Int16Array,Uint16Array,Int32Array,Uint32Array,Float32Array,Float64Array,NaN,Infinity}, {abort:function() { throw new Error('abort'); },setTempRet0},memasmFunc); export var i32_load = retasmFunc.i32_load; export var i64_load = retasmFunc.i64_load; |