diff --git a/.gitignore b/.gitignore index 45a0fcad856..93c9356846b 100644 --- a/.gitignore +++ b/.gitignore @@ -50,3 +50,10 @@ test/lit/lit.site.cfg.py # files related to clangd cache .cache/* + +# files related to tsc compilation +/src/ts/binaryen_post.js +/src/ts/binaryen_post.d.ts +/src/ts/binaryen.d.ts +/src/ts/binaryen.js +/*.map diff --git a/CMakeLists.txt b/CMakeLists.txt index 1836d955659..5ab7b497174 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -24,7 +24,7 @@ set(CMAKE_CXX_EXTENSIONS OFF) if(NOT CMAKE_BUILD_TYPE) message(STATUS "No build type selected, default to Release") - set(CMAKE_BUILD_TYPE "Release") + set(CMAKE_BUILD_TYPE "Debug") endif() # We default to assertions enabled, even in release builds so that we get @@ -352,7 +352,7 @@ if(EMSCRIPTEN) add_link_flag("-sMODULARIZE") add_link_flag("-sEXPORT_ES6") add_link_flag("-sFILESYSTEM") - add_link_flag("-sFORCE_FILESYSTEM") + add_link_flag("-sFORCE_FILESYSTEM") else() # On Node.js, make the tools immediately usable. add_link_flag("-sNODERAWFS") @@ -455,18 +455,39 @@ if(EMSCRIPTEN) ) # binaryen.js WebAssembly variant + # compile the TypeScript file injected in the generated js + add_custom_target(binaryen_post_js + COMMAND tsc --target ES2020 --module ES2022 --outDir ${CMAKE_BINARY_DIR}/bin ${CMAKE_CURRENT_SOURCE_DIR}/src/ts/binaryen_post.ts) + # compile the TypeScript file that wraps the generated js + if(WIN32) # not tested! + add_custom_target(binaryen_wasm_wrapper + COMMAND (Get-content ${CMAKE_CURRENT_SOURCE_DIR}/src/ts/binaryen.ts) | Foreach-Object {$_ -replace "TARGET", "wasm"} | Set-Content ${CMAKE_CURRENT_SOURCE_DIR}/src/ts/binaryen_wasm.ts && + tsc --target ES2020 --module ES2022 --declaration --declarationMap --outDir ${CMAKE_BINARY_DIR}/bin ${CMAKE_CURRENT_SOURCE_DIR}/src/ts/binaryen_wasm.ts && + rm ${CMAKE_CURRENT_SOURCE_DIR}/src/ts/binaryen_wasm.ts) + else() + add_custom_target(binaryen_wasm_wrapper + COMMAND sed -e 's/TARGET/wasm/g' ${CMAKE_CURRENT_SOURCE_DIR}/src/ts/binaryen.ts >> ${CMAKE_CURRENT_SOURCE_DIR}/src/ts/binaryen_wasm.ts && + tsc --target ES2020 --module ES2022 --declaration --declarationMap --outDir ${CMAKE_BINARY_DIR}/bin ${CMAKE_CURRENT_SOURCE_DIR}/src/ts/binaryen_wasm.ts && + rm ${CMAKE_CURRENT_SOURCE_DIR}/src/ts/binaryen_wasm.ts) + endif() add_executable(binaryen_wasm ${binaryen_emscripten_SOURCES}) + add_dependencies(binaryen_wasm binaryen_post_js binaryen_wasm_wrapper) + set_target_properties(binaryen_wasm PROPERTIES OUTPUT_NAME "binaryen_raw_wasm") target_link_libraries(binaryen_wasm wasm asmjs emscripten-optimizer passes ir cfg support analysis parser wasm) target_link_libraries(binaryen_wasm "-sFILESYSTEM") target_link_libraries(binaryen_wasm "-sEXPORT_NAME=Binaryen") target_link_libraries(binaryen_wasm "-sNODERAWFS=0") target_link_libraries(binaryen_wasm "-sEXPORT_ES6") - target_link_libraries(binaryen_wasm "-sEXPORTED_RUNTIME_METHODS=allocateUTF8OnStack,stringToAscii") + target_link_libraries(binaryen_wasm "-sEXPORTED_RUNTIME_METHODS=allocateUTF8OnStack,stringToAscii,stackSave,stackAlloc,stackRestore,UTF8ToString") target_link_libraries(binaryen_wasm "-sEXPORTED_FUNCTIONS=_malloc,_free") - target_link_libraries(binaryen_wasm "--post-js=${CMAKE_CURRENT_SOURCE_DIR}/src/js/binaryen.js-post.js") + # useful when working on --post-js file + target_link_libraries(binaryen_wasm "--minify=0") + target_link_libraries(binaryen_wasm "--post-js=${CMAKE_BINARY_DIR}/bin/binaryen_post.js") target_link_libraries(binaryen_wasm "-msign-ext") target_link_libraries(binaryen_wasm "-mbulk-memory") + target_link_libraries(binaryen_wasm optimized "--closure=0") + target_link_libraries(binaryen_wasm optimized "--closure-args=\"--language_in=ECMASCRIPT6 --language_out=ECMASCRIPT6\"") target_link_libraries(binaryen_wasm optimized "--closure=1") # TODO: Fix closure warnings! (#5062) target_link_libraries(binaryen_wasm optimized "-Wno-error=closure") @@ -475,8 +496,22 @@ if(EMSCRIPTEN) install(TARGETS binaryen_wasm DESTINATION ${CMAKE_INSTALL_BINDIR}) # binaryen.js JavaScript variant + # compile the TypeScript file that wraps the generated js + if(WIN32) # not tested! + add_custom_target(binaryen_js_wrapper + COMMAND (Get-content ${CMAKE_CURRENT_SOURCE_DIR}/src/ts/binaryen.ts) | Foreach-Object {$_ -replace "TARGET", "js"} | Set-Content ${CMAKE_CURRENT_SOURCE_DIR}/src/ts/binaryen_js.ts && + tsc --target ES2020 --module ES2022 --declaration --declarationMap --outDir ${CMAKE_BINARY_DIR}/bin ${CMAKE_CURRENT_SOURCE_DIR}/src/ts/binaryen_js.ts && + rm ${CMAKE_CURRENT_SOURCE_DIR}/src/ts/binaryen_js.ts) + else() + add_custom_target(binaryen_js_wrapper + COMMAND sed -e 's/TARGET/js/g' ${CMAKE_CURRENT_SOURCE_DIR}/src/ts/binaryen.ts >> ${CMAKE_CURRENT_SOURCE_DIR}/src/ts/binaryen_js.ts && + tsc --target ES2020 --module ES2022 --declaration --declarationMap --outDir ${CMAKE_BINARY_DIR}/bin ${CMAKE_CURRENT_SOURCE_DIR}/src/ts/binaryen_js.ts && + rm ${CMAKE_CURRENT_SOURCE_DIR}/src/ts/binaryen_js.ts) + endif() add_executable(binaryen_js ${binaryen_emscripten_SOURCES}) + add_dependencies(binaryen_js binaryen_post_js binaryen_js_wrapper) + set_target_properties(binaryen_js PROPERTIES OUTPUT_NAME "binaryen_raw_js") target_link_libraries(binaryen_js wasm asmjs emscripten-optimizer passes ir cfg support analysis parser wasm) target_link_libraries(binaryen_js "-sWASM=0") target_link_libraries(binaryen_js "-sWASM_ASYNC_COMPILATION=0") @@ -500,9 +535,11 @@ if(EMSCRIPTEN) else() target_link_libraries(binaryen_js "-sEXPORT_ES6=1") endif() - target_link_libraries(binaryen_js "-sEXPORTED_RUNTIME_METHODS=allocateUTF8OnStack,stringToAscii") + target_link_libraries(binaryen_js "-sEXPORTED_RUNTIME_METHODS=allocateUTF8OnStack,stringToAscii,stackSave,stackAlloc,stackRestore,UTF8ToString") target_link_libraries(binaryen_js "-sEXPORTED_FUNCTIONS=_malloc,_free") - target_link_libraries(binaryen_js "--post-js=${CMAKE_CURRENT_SOURCE_DIR}/src/js/binaryen.js-post.js") + # useful when working on --post-js file + # target_link_libraries(binaryen_js "--minify=0") + target_link_libraries(binaryen_js "--post-js=${CMAKE_BINARY_DIR}/bin/binaryen_post.js") # js_of_ocaml needs a specified variable with special comment to provide the library to consumers if(JS_OF_OCAML) target_link_libraries(binaryen_js "--extern-pre-js=${CMAKE_CURRENT_SOURCE_DIR}/src/js/binaryen.jsoo-extern-pre.js") @@ -518,6 +555,7 @@ if(EMSCRIPTEN) target_link_libraries(binaryen_js debug "--profiling") target_link_libraries(binaryen_js debug "-sASSERTIONS") install(TARGETS binaryen_js DESTINATION ${CMAKE_INSTALL_BINDIR}) + endif() configure_file(scripts/binaryen-lit.in ${CMAKE_BINARY_DIR}/bin/binaryen-lit @ONLY) diff --git a/src/js/binaryen.js-post.js b/src/js/binaryen.js-post.js deleted file mode 100644 index 111c020b3a0..00000000000 --- a/src/js/binaryen.js-post.js +++ /dev/null @@ -1,4938 +0,0 @@ -// export friendly API methods -function preserveStack(func) { - try { - var stack = stackSave(); - return func(); - } finally { - stackRestore(stack); - } -} - -function strToStack(str) { - return str ? allocateUTF8OnStack(str) : 0; -} - -function i32sToStack(i32s) { - const ret = stackAlloc(i32s.length << 2); - HEAP32.set(i32s, ret >>> 2); - return ret; -} - -function i8sToStack(i8s) { - const ret = stackAlloc(i8s.length); - HEAP8.set(i8s, ret); - return ret; -} - -function initializeConstants() { - - // Types - [ ['none', 'None'], - ['i32', 'Int32'], - ['i64', 'Int64'], - ['f32', 'Float32'], - ['f64', 'Float64'], - ['v128', 'Vec128'], - ['funcref', 'Funcref'], - ['externref', 'Externref'], - ['anyref', 'Anyref'], - ['eqref', 'Eqref'], - ['i31ref', 'I31ref'], - ['structref', 'Structref'], - ['stringref', 'Stringref'], - ['stringview_wtf8', 'StringviewWTF8'], - ['stringview_wtf16', 'StringviewWTF16'], - ['stringview_iter', 'StringviewIter'], - ['unreachable', 'Unreachable'], - ['auto', 'Auto'] - ].forEach(entry => { - Module[entry[0]] = Module['_BinaryenType' + entry[1]](); - }); - - // Expression ids - Module['ExpressionIds'] = {}; - [ 'Invalid', - 'Block', - 'If', - 'Loop', - 'Break', - 'Switch', - 'Call', - 'CallIndirect', - 'LocalGet', - 'LocalSet', - 'GlobalGet', - 'GlobalSet', - 'Load', - 'Store', - 'Const', - 'Unary', - 'Binary', - 'Select', - 'Drop', - 'Return', - 'MemorySize', - 'MemoryGrow', - 'Nop', - 'Unreachable', - 'AtomicCmpxchg', - 'AtomicRMW', - 'AtomicWait', - 'AtomicNotify', - 'AtomicFence', - 'SIMDExtract', - 'SIMDReplace', - 'SIMDShuffle', - 'SIMDTernary', - 'SIMDShift', - 'SIMDLoad', - 'SIMDLoadStoreLane', - 'MemoryInit', - 'DataDrop', - 'MemoryCopy', - 'MemoryFill', - 'RefNull', - 'RefIsNull', - 'RefFunc', - 'RefEq', - 'TableGet', - 'TableSet', - 'TableSize', - 'TableGrow', - 'Try', - 'Throw', - 'Rethrow', - 'TupleMake', - 'TupleExtract', - 'Pop', - 'RefI31', - 'I31Get', - 'CallRef', - 'RefTest', - 'RefCast', - 'BrOn', - 'StructNew', - 'StructGet', - 'StructSet', - 'ArrayNew', - 'ArrayNewFixed', - 'ArrayGet', - 'ArraySet', - 'ArrayLen', - 'ArrayCopy', - 'RefAs', - 'StringNew', - 'StringConst', - 'StringMeasure', - 'StringEncode', - 'StringConcat', - 'StringEq', - 'StringAs', - 'StringWTF8Advance', - 'StringWTF16Get', - 'StringIterNext', - 'StringIterMove', - 'StringSliceWTF', - 'StringSliceIter' - ].forEach(name => { - Module['ExpressionIds'][name] = Module[name + 'Id'] = Module['_Binaryen' + name + 'Id'](); - }); - - // External kinds - Module['ExternalKinds'] = {}; - [ 'Function', - 'Table', - 'Memory', - 'Global', - 'Tag' - ].forEach(name => { - Module['ExternalKinds'][name] = Module['External' + name] = Module['_BinaryenExternal' + name](); - }); - - // Features - Module['Features'] = {}; - [ 'MVP', - 'Atomics', - 'BulkMemory', - 'MutableGlobals', - 'NontrappingFPToInt', - 'SignExt', - 'SIMD128', - 'ExceptionHandling', - 'TailCall', - 'ReferenceTypes', - 'Multivalue', - 'GC', - 'Memory64', - 'RelaxedSIMD', - 'ExtendedConst', - 'Strings', - 'MultiMemory', - 'All' - ].forEach(name => { - Module['Features'][name] = Module['_BinaryenFeature' + name](); - }); - - // Operations - Module['Operations'] = {}; - [ 'ClzInt32', - 'CtzInt32', - 'PopcntInt32', - 'NegFloat32', - 'AbsFloat32', - 'CeilFloat32', - 'FloorFloat32', - 'TruncFloat32', - 'NearestFloat32', - 'SqrtFloat32', - 'EqZInt32', - 'ClzInt64', - 'CtzInt64', - 'PopcntInt64', - 'NegFloat64', - 'AbsFloat64', - 'CeilFloat64', - 'FloorFloat64', - 'TruncFloat64', - 'NearestFloat64', - 'SqrtFloat64', - 'EqZInt64', - 'ExtendSInt32', - 'ExtendUInt32', - 'WrapInt64', - 'TruncSFloat32ToInt32', - 'TruncSFloat32ToInt64', - 'TruncUFloat32ToInt32', - 'TruncUFloat32ToInt64', - 'TruncSFloat64ToInt32', - 'TruncSFloat64ToInt64', - 'TruncUFloat64ToInt32', - 'TruncUFloat64ToInt64', - 'TruncSatSFloat32ToInt32', - 'TruncSatSFloat32ToInt64', - 'TruncSatUFloat32ToInt32', - 'TruncSatUFloat32ToInt64', - 'TruncSatSFloat64ToInt32', - 'TruncSatSFloat64ToInt64', - 'TruncSatUFloat64ToInt32', - 'TruncSatUFloat64ToInt64', - 'ReinterpretFloat32', - 'ReinterpretFloat64', - 'ConvertSInt32ToFloat32', - 'ConvertSInt32ToFloat64', - 'ConvertUInt32ToFloat32', - 'ConvertUInt32ToFloat64', - 'ConvertSInt64ToFloat32', - 'ConvertSInt64ToFloat64', - 'ConvertUInt64ToFloat32', - 'ConvertUInt64ToFloat64', - 'PromoteFloat32', - 'DemoteFloat64', - 'ReinterpretInt32', - 'ReinterpretInt64', - 'ExtendS8Int32', - 'ExtendS16Int32', - 'ExtendS8Int64', - 'ExtendS16Int64', - 'ExtendS32Int64', - 'AddInt32', - 'SubInt32', - 'MulInt32', - 'DivSInt32', - 'DivUInt32', - 'RemSInt32', - 'RemUInt32', - 'AndInt32', - 'OrInt32', - 'XorInt32', - 'ShlInt32', - 'ShrUInt32', - 'ShrSInt32', - 'RotLInt32', - 'RotRInt32', - 'EqInt32', - 'NeInt32', - 'LtSInt32', - 'LtUInt32', - 'LeSInt32', - 'LeUInt32', - 'GtSInt32', - 'GtUInt32', - 'GeSInt32', - 'GeUInt32', - 'AddInt64', - 'SubInt64', - 'MulInt64', - 'DivSInt64', - 'DivUInt64', - 'RemSInt64', - 'RemUInt64', - 'AndInt64', - 'OrInt64', - 'XorInt64', - 'ShlInt64', - 'ShrUInt64', - 'ShrSInt64', - 'RotLInt64', - 'RotRInt64', - 'EqInt64', - 'NeInt64', - 'LtSInt64', - 'LtUInt64', - 'LeSInt64', - 'LeUInt64', - 'GtSInt64', - 'GtUInt64', - 'GeSInt64', - 'GeUInt64', - 'AddFloat32', - 'SubFloat32', - 'MulFloat32', - 'DivFloat32', - 'CopySignFloat32', - 'MinFloat32', - 'MaxFloat32', - 'EqFloat32', - 'NeFloat32', - 'LtFloat32', - 'LeFloat32', - 'GtFloat32', - 'GeFloat32', - 'AddFloat64', - 'SubFloat64', - 'MulFloat64', - 'DivFloat64', - 'CopySignFloat64', - 'MinFloat64', - 'MaxFloat64', - 'EqFloat64', - 'NeFloat64', - 'LtFloat64', - 'LeFloat64', - 'GtFloat64', - 'GeFloat64', - 'AtomicRMWAdd', - 'AtomicRMWSub', - 'AtomicRMWAnd', - 'AtomicRMWOr', - 'AtomicRMWXor', - 'AtomicRMWXchg', - 'SplatVecI8x16', - 'ExtractLaneSVecI8x16', - 'ExtractLaneUVecI8x16', - 'ReplaceLaneVecI8x16', - 'SplatVecI16x8', - 'ExtractLaneSVecI16x8', - 'ExtractLaneUVecI16x8', - 'ReplaceLaneVecI16x8', - 'SplatVecI32x4', - 'ExtractLaneVecI32x4', - 'ReplaceLaneVecI32x4', - 'SplatVecI64x2', - 'ExtractLaneVecI64x2', - 'ReplaceLaneVecI64x2', - 'SplatVecF32x4', - 'ExtractLaneVecF32x4', - 'ReplaceLaneVecF32x4', - 'SplatVecF64x2', - 'ExtractLaneVecF64x2', - 'ReplaceLaneVecF64x2', - 'EqVecI8x16', - 'NeVecI8x16', - 'LtSVecI8x16', - 'LtUVecI8x16', - 'GtSVecI8x16', - 'GtUVecI8x16', - 'LeSVecI8x16', - 'LeUVecI8x16', - 'GeSVecI8x16', - 'GeUVecI8x16', - 'EqVecI16x8', - 'NeVecI16x8', - 'LtSVecI16x8', - 'LtUVecI16x8', - 'GtSVecI16x8', - 'GtUVecI16x8', - 'LeSVecI16x8', - 'LeUVecI16x8', - 'GeSVecI16x8', - 'GeUVecI16x8', - 'EqVecI32x4', - 'NeVecI32x4', - 'LtSVecI32x4', - 'LtUVecI32x4', - 'GtSVecI32x4', - 'GtUVecI32x4', - 'LeSVecI32x4', - 'LeUVecI32x4', - 'GeSVecI32x4', - 'GeUVecI32x4', - 'EqVecI64x2', - 'NeVecI64x2', - 'LtSVecI64x2', - 'GtSVecI64x2', - 'LeSVecI64x2', - 'GeSVecI64x2', - 'EqVecF32x4', - 'NeVecF32x4', - 'LtVecF32x4', - 'GtVecF32x4', - 'LeVecF32x4', - 'GeVecF32x4', - 'EqVecF64x2', - 'NeVecF64x2', - 'LtVecF64x2', - 'GtVecF64x2', - 'LeVecF64x2', - 'GeVecF64x2', - 'NotVec128', - 'AndVec128', - 'OrVec128', - 'XorVec128', - 'AndNotVec128', - 'BitselectVec128', - 'RelaxedFmaVecF32x4', - 'RelaxedFmsVecF32x4', - 'RelaxedFmaVecF64x2', - 'RelaxedFmsVecF64x2', - 'LaneselectI8x16', - 'LaneselectI16x8', - 'LaneselectI32x4', - 'LaneselectI64x2', - 'DotI8x16I7x16AddSToVecI32x4', - 'AnyTrueVec128', - 'PopcntVecI8x16', - 'AbsVecI8x16', - 'NegVecI8x16', - 'AllTrueVecI8x16', - 'BitmaskVecI8x16', - 'ShlVecI8x16', - 'ShrSVecI8x16', - 'ShrUVecI8x16', - 'AddVecI8x16', - 'AddSatSVecI8x16', - 'AddSatUVecI8x16', - 'SubVecI8x16', - 'SubSatSVecI8x16', - 'SubSatUVecI8x16', - 'MinSVecI8x16', - 'MinUVecI8x16', - 'MaxSVecI8x16', - 'MaxUVecI8x16', - 'AvgrUVecI8x16', - 'AbsVecI16x8', - 'NegVecI16x8', - 'AllTrueVecI16x8', - 'BitmaskVecI16x8', - 'ShlVecI16x8', - 'ShrSVecI16x8', - 'ShrUVecI16x8', - 'AddVecI16x8', - 'AddSatSVecI16x8', - 'AddSatUVecI16x8', - 'SubVecI16x8', - 'SubSatSVecI16x8', - 'SubSatUVecI16x8', - 'MulVecI16x8', - 'MinSVecI16x8', - 'MinUVecI16x8', - 'MaxSVecI16x8', - 'MaxUVecI16x8', - 'AvgrUVecI16x8', - 'Q15MulrSatSVecI16x8', - 'ExtMulLowSVecI16x8', - 'ExtMulHighSVecI16x8', - 'ExtMulLowUVecI16x8', - 'ExtMulHighUVecI16x8', - 'DotSVecI16x8ToVecI32x4', - 'ExtMulLowSVecI32x4', - 'ExtMulHighSVecI32x4', - 'ExtMulLowUVecI32x4', - 'ExtMulHighUVecI32x4', - 'AbsVecI32x4', - 'NegVecI32x4', - 'AllTrueVecI32x4', - 'BitmaskVecI32x4', - 'ShlVecI32x4', - 'ShrSVecI32x4', - 'ShrUVecI32x4', - 'AddVecI32x4', - 'SubVecI32x4', - 'MulVecI32x4', - 'MinSVecI32x4', - 'MinUVecI32x4', - 'MaxSVecI32x4', - 'MaxUVecI32x4', - 'AbsVecI64x2', - 'NegVecI64x2', - 'AllTrueVecI64x2', - 'BitmaskVecI64x2', - 'ShlVecI64x2', - 'ShrSVecI64x2', - 'ShrUVecI64x2', - 'AddVecI64x2', - 'SubVecI64x2', - 'MulVecI64x2', - 'ExtMulLowSVecI64x2', - 'ExtMulHighSVecI64x2', - 'ExtMulLowUVecI64x2', - 'ExtMulHighUVecI64x2', - 'AbsVecF32x4', - 'NegVecF32x4', - 'SqrtVecF32x4', - 'AddVecF32x4', - 'SubVecF32x4', - 'MulVecF32x4', - 'DivVecF32x4', - 'MinVecF32x4', - 'MaxVecF32x4', - 'PMinVecF32x4', - 'PMaxVecF32x4', - 'CeilVecF32x4', - 'FloorVecF32x4', - 'TruncVecF32x4', - 'NearestVecF32x4', - 'AbsVecF64x2', - 'NegVecF64x2', - 'SqrtVecF64x2', - 'AddVecF64x2', - 'SubVecF64x2', - 'MulVecF64x2', - 'DivVecF64x2', - 'MinVecF64x2', - 'MaxVecF64x2', - 'PMinVecF64x2', - 'PMaxVecF64x2', - 'CeilVecF64x2', - 'FloorVecF64x2', - 'TruncVecF64x2', - 'NearestVecF64x2', - 'ExtAddPairwiseSVecI8x16ToI16x8', - 'ExtAddPairwiseUVecI8x16ToI16x8', - 'ExtAddPairwiseSVecI16x8ToI32x4', - 'ExtAddPairwiseUVecI16x8ToI32x4', - 'TruncSatSVecF32x4ToVecI32x4', - 'TruncSatUVecF32x4ToVecI32x4', - 'ConvertSVecI32x4ToVecF32x4', - 'ConvertUVecI32x4ToVecF32x4', - 'Load8SplatVec128', - 'Load16SplatVec128', - 'Load32SplatVec128', - 'Load64SplatVec128', - 'Load8x8SVec128', - 'Load8x8UVec128', - 'Load16x4SVec128', - 'Load16x4UVec128', - 'Load32x2SVec128', - 'Load32x2UVec128', - 'Load32ZeroVec128', - 'Load64ZeroVec128', - 'Load8LaneVec128', - 'Load16LaneVec128', - 'Load32LaneVec128', - 'Load64LaneVec128', - 'Store8LaneVec128', - 'Store16LaneVec128', - 'Store32LaneVec128', - 'Store64LaneVec128', - 'NarrowSVecI16x8ToVecI8x16', - 'NarrowUVecI16x8ToVecI8x16', - 'NarrowSVecI32x4ToVecI16x8', - 'NarrowUVecI32x4ToVecI16x8', - 'ExtendLowSVecI8x16ToVecI16x8', - 'ExtendHighSVecI8x16ToVecI16x8', - 'ExtendLowUVecI8x16ToVecI16x8', - 'ExtendHighUVecI8x16ToVecI16x8', - 'ExtendLowSVecI16x8ToVecI32x4', - 'ExtendHighSVecI16x8ToVecI32x4', - 'ExtendLowUVecI16x8ToVecI32x4', - 'ExtendHighUVecI16x8ToVecI32x4', - 'ExtendLowSVecI32x4ToVecI64x2', - 'ExtendHighSVecI32x4ToVecI64x2', - 'ExtendLowUVecI32x4ToVecI64x2', - 'ExtendHighUVecI32x4ToVecI64x2', - 'ConvertLowSVecI32x4ToVecF64x2', - 'ConvertLowUVecI32x4ToVecF64x2', - 'TruncSatZeroSVecF64x2ToVecI32x4', - 'TruncSatZeroUVecF64x2ToVecI32x4', - 'DemoteZeroVecF64x2ToVecF32x4', - 'PromoteLowVecF32x4ToVecF64x2', - 'RelaxedTruncSVecF32x4ToVecI32x4', - 'RelaxedTruncUVecF32x4ToVecI32x4', - 'RelaxedTruncZeroSVecF64x2ToVecI32x4', - 'RelaxedTruncZeroUVecF64x2ToVecI32x4', - 'SwizzleVecI8x16', - 'RelaxedSwizzleVecI8x16', - 'RelaxedMinVecF32x4', - 'RelaxedMaxVecF32x4', - 'RelaxedMinVecF64x2', - 'RelaxedMaxVecF64x2', - 'RelaxedQ15MulrSVecI16x8', - 'DotI8x16I7x16SToVecI16x8', - 'RefAsNonNull', - 'RefAsExternInternalize', - 'RefAsExternExternalize', - 'BrOnNull', - 'BrOnNonNull', - 'BrOnCast', - 'BrOnCastFail', - 'StringNewUTF8', - 'StringNewWTF8', - 'StringNewLossyUTF8', - 'StringNewWTF16', - 'StringNewUTF8Array', - 'StringNewWTF8Array', - 'StringNewLossyUTF8Array', - 'StringNewWTF16Array', - 'StringNewFromCodePoint', - 'StringMeasureUTF8', - 'StringMeasureWTF8', - 'StringMeasureWTF16', - 'StringMeasureIsUSV', - 'StringMeasureWTF16View', - 'StringEncodeUTF8', - 'StringEncodeLossyUTF8', - 'StringEncodeWTF8', - 'StringEncodeWTF16', - 'StringEncodeUTF8Array', - 'StringEncodeLossyUTF8Array', - 'StringEncodeWTF8Array', - 'StringEncodeWTF16Array', - 'StringAsWTF8', - 'StringAsWTF16', - 'StringAsIter', - 'StringIterMoveAdvance', - 'StringIterMoveRewind', - 'StringSliceWTF8', - 'StringSliceWTF16', - 'StringEqEqual', - 'StringEqCompare' - ].forEach(name => { - Module['Operations'][name] = Module[name] = Module['_Binaryen' + name](); - }); - - // Expression side effects - Module['SideEffects'] = {}; - [ 'None', - 'Branches', - 'Calls', - 'ReadsLocal', - 'WritesLocal', - 'ReadsGlobal', - 'WritesGlobal', - 'ReadsMemory', - 'WritesMemory', - 'ReadsTable', - 'WritesTable', - 'ImplicitTrap', - 'IsAtomic', - 'Throws', - 'DanglingPop', - 'TrapsNeverHappen', - 'Any' - ].forEach(name => { - Module['SideEffects'][name] = Module['_BinaryenSideEffect' + name](); - }); - - // ExpressionRunner flags - Module['ExpressionRunner']['Flags'] = { - 'Default': Module['_ExpressionRunnerFlagsDefault'](), - 'PreserveSideeffects': Module['_ExpressionRunnerFlagsPreserveSideeffects'](), - 'TraverseCalls': Module['_ExpressionRunnerFlagsTraverseCalls']() - }; -} - -// 'Module' interface -Module['Module'] = function(module) { - assert(!module); // guard against incorrect old API usage - wrapModule(Module['_BinaryenModuleCreate'](), this); -}; - -// Receives a C pointer to a C Module and a JS object, and creates -// the JS wrappings on the object to access the C data. -// This is meant for internal use only, and is necessary as we -// want to access Module from JS that were perhaps not created -// from JS. -function wrapModule(module, self = {}) { - assert(module); // guard against incorrect old API usage - - self['ptr'] = module; - - // The size of a single literal in memory as used in Const creation, - // which is a little different: we don't want users to need to make - // their own Literals, as the C API handles them by value, which means - // we would leak them. Instead, Const creation is fused together with - // an intermediate stack allocation of this size to pass the value. - const sizeOfLiteral = _BinaryenSizeofLiteral(); - - // 'Expression' creation - self['block'] = function(name, children, type) { - return preserveStack(() => - Module['_BinaryenBlock'](module, name ? strToStack(name) : 0, - i32sToStack(children), children.length, - typeof type !== 'undefined' ? type : Module['none']) - ); - }; - self['if'] = function(condition, ifTrue, ifFalse) { - return Module['_BinaryenIf'](module, condition, ifTrue, ifFalse); - }; - self['loop'] = function(label, body) { - return preserveStack(() => Module['_BinaryenLoop'](module, strToStack(label), body)); - }; - self['break'] = self['br'] = function(label, condition, value) { - return preserveStack(() => Module['_BinaryenBreak'](module, strToStack(label), condition, value)); - }; - self['br_if'] = function(label, condition, value) { - return self['br'](label, condition, value); - }; - self['switch'] = function(names, defaultName, condition, value) { - return preserveStack(() => - Module['_BinaryenSwitch'](module, i32sToStack(names.map(strToStack)), names.length, strToStack(defaultName), condition, value) - ); - }; - self['call'] = function(name, operands, type) { - return preserveStack(() => Module['_BinaryenCall'](module, strToStack(name), i32sToStack(operands), operands.length, type)); - }; - // 'callIndirect', 'returnCall', 'returnCallIndirect' are deprecated and may - // be removed in a future release. Please use the the snake_case names - // instead. - self['callIndirect'] = self['call_indirect'] = function(table, target, operands, params, results) { - return preserveStack(() => - Module['_BinaryenCallIndirect'](module, strToStack(table), target, i32sToStack(operands), operands.length, params, results) - ); - }; - self['returnCall'] = self['return_call'] = function(name, operands, type) { - return preserveStack(() => - Module['_BinaryenReturnCall'](module, strToStack(name), i32sToStack(operands), operands.length, type) - ); - }; - self['returnCallIndirect'] = self['return_call_indirect'] = function(table, target, operands, params, results) { - return preserveStack(() => - Module['_BinaryenReturnCallIndirect'](module, strToStack(table), target, i32sToStack(operands), operands.length, params, results) - ); - }; - - self['local'] = { - 'get'(index, type) { - return Module['_BinaryenLocalGet'](module, index, type); - }, - 'set'(index, value) { - return Module['_BinaryenLocalSet'](module, index, value); - }, - 'tee'(index, value, type) { - if (typeof type === 'undefined') { - throw new Error("local.tee's type should be defined"); - } - return Module['_BinaryenLocalTee'](module, index, value, type); - } - } - - self['global'] = { - 'get'(name, type) { - return Module['_BinaryenGlobalGet'](module, strToStack(name), type); - }, - 'set'(name, value) { - return Module['_BinaryenGlobalSet'](module, strToStack(name), value); - } - } - - self['table'] = { - 'get'(name, index, type) { - return Module['_BinaryenTableGet'](module, strToStack(name), index, type); - }, - 'set'(name, index, value) { - return Module['_BinaryenTableSet'](module, strToStack(name), index, value); - }, - 'size'(name) { - return Module['_BinaryenTableSize'](module, strToStack(name)); - }, - 'grow'(name, value, delta) { - return Module['_BinaryenTableGrow'](module, strToStack(name), value, delta); - } - } - - self['memory'] = { - // memory64 defaults to undefined/false. - 'size'(name, memory64) { - return Module['_BinaryenMemorySize'](module, strToStack(name), memory64); - }, - 'grow'(value, name, memory64) { - return Module['_BinaryenMemoryGrow'](module, value, strToStack(name), memory64); - }, - 'init'(segment, dest, offset, size, name) { - return preserveStack(() => Module['_BinaryenMemoryInit'](module, strToStack(segment), dest, offset, size, strToStack(name))); - }, - 'copy'(dest, source, size, destMemory, sourceMemory) { - return Module['_BinaryenMemoryCopy'](module, dest, source, size, strToStack(destMemory), strToStack(sourceMemory)); - }, - 'fill'(dest, value, size, name) { - return Module['_BinaryenMemoryFill'](module, dest, value, size, strToStack(name)); - }, - 'atomic': { - 'notify'(ptr, notifyCount, name) { - return Module['_BinaryenAtomicNotify'](module, ptr, notifyCount, strToStack(name)); - }, - 'wait32'(ptr, expected, timeout, name) { - return Module['_BinaryenAtomicWait'](module, ptr, expected, timeout, Module['i32'], strToStack(name)); - }, - 'wait64'(ptr, expected, timeout, name) { - return Module['_BinaryenAtomicWait'](module, ptr, expected, timeout, Module['i64'], strToStack(name)); - } - } - } - - self['data'] = { - 'drop'(segment) { - return preserveStack(() => Module['_BinaryenDataDrop'](module, strToStack(segment))); - } - } - - self['i32'] = { - 'load'(offset, align, ptr, name) { - return Module['_BinaryenLoad'](module, 4, true, offset, align, Module['i32'], ptr, strToStack(name)); - }, - 'load8_s'(offset, align, ptr, name) { - return Module['_BinaryenLoad'](module, 1, true, offset, align, Module['i32'], ptr, strToStack(name)); - }, - 'load8_u'(offset, align, ptr, name) { - return Module['_BinaryenLoad'](module, 1, false, offset, align, Module['i32'], ptr, strToStack(name)); - }, - 'load16_s'(offset, align, ptr, name) { - return Module['_BinaryenLoad'](module, 2, true, offset, align, Module['i32'], ptr, strToStack(name)); - }, - 'load16_u'(offset, align, ptr, name) { - return Module['_BinaryenLoad'](module, 2, false, offset, align, Module['i32'], ptr, strToStack(name)); - }, - 'store'(offset, align, ptr, value, name) { - return Module['_BinaryenStore'](module, 4, offset, align, ptr, value, Module['i32'], strToStack(name)); - }, - 'store8'(offset, align, ptr, value, name) { - return Module['_BinaryenStore'](module, 1, offset, align, ptr, value, Module['i32'], strToStack(name)); - }, - 'store16'(offset, align, ptr, value, name) { - return Module['_BinaryenStore'](module, 2, offset, align, ptr, value, Module['i32'], strToStack(name)); - }, - 'const'(x) { - return preserveStack(() => { - const tempLiteral = stackAlloc(sizeOfLiteral); - Module['_BinaryenLiteralInt32'](tempLiteral, x); - return Module['_BinaryenConst'](module, tempLiteral); - }); - }, - 'clz'(value) { - return Module['_BinaryenUnary'](module, Module['ClzInt32'], value); - }, - 'ctz'(value) { - return Module['_BinaryenUnary'](module, Module['CtzInt32'], value); - }, - 'popcnt'(value) { - return Module['_BinaryenUnary'](module, Module['PopcntInt32'], value); - }, - 'eqz'(value) { - return Module['_BinaryenUnary'](module, Module['EqZInt32'], value); - }, - 'trunc_s': { - 'f32'(value) { - return Module['_BinaryenUnary'](module, Module['TruncSFloat32ToInt32'], value); - }, - 'f64'(value) { - return Module['_BinaryenUnary'](module, Module['TruncSFloat64ToInt32'], value); - }, - }, - 'trunc_u': { - 'f32'(value) { - return Module['_BinaryenUnary'](module, Module['TruncUFloat32ToInt32'], value); - }, - 'f64'(value) { - return Module['_BinaryenUnary'](module, Module['TruncUFloat64ToInt32'], value); - }, - }, - 'trunc_s_sat': { - 'f32'(value) { - return Module['_BinaryenUnary'](module, Module['TruncSatSFloat32ToInt32'], value); - }, - 'f64'(value) { - return Module['_BinaryenUnary'](module, Module['TruncSatSFloat64ToInt32'], value); - }, - }, - 'trunc_u_sat': { - 'f32'(value) { - return Module['_BinaryenUnary'](module, Module['TruncSatUFloat32ToInt32'], value); - }, - 'f64'(value) { - return Module['_BinaryenUnary'](module, Module['TruncSatUFloat64ToInt32'], value); - }, - }, - 'reinterpret'(value) { - return Module['_BinaryenUnary'](module, Module['ReinterpretFloat32'], value); - }, - 'extend8_s'(value) { - return Module['_BinaryenUnary'](module, Module['ExtendS8Int32'], value); - }, - 'extend16_s'(value) { - return Module['_BinaryenUnary'](module, Module['ExtendS16Int32'], value); - }, - 'wrap'(value) { - return Module['_BinaryenUnary'](module, Module['WrapInt64'], value); - }, - 'add'(left, right) { - return Module['_BinaryenBinary'](module, Module['AddInt32'], left, right); - }, - 'sub'(left, right) { - return Module['_BinaryenBinary'](module, Module['SubInt32'], left, right); - }, - 'mul'(left, right) { - return Module['_BinaryenBinary'](module, Module['MulInt32'], left, right); - }, - 'div_s'(left, right) { - return Module['_BinaryenBinary'](module, Module['DivSInt32'], left, right); - }, - 'div_u'(left, right) { - return Module['_BinaryenBinary'](module, Module['DivUInt32'], left, right); - }, - 'rem_s'(left, right) { - return Module['_BinaryenBinary'](module, Module['RemSInt32'], left, right); - }, - 'rem_u'(left, right) { - return Module['_BinaryenBinary'](module, Module['RemUInt32'], left, right); - }, - 'and'(left, right) { - return Module['_BinaryenBinary'](module, Module['AndInt32'], left, right); - }, - 'or'(left, right) { - return Module['_BinaryenBinary'](module, Module['OrInt32'], left, right); - }, - 'xor'(left, right) { - return Module['_BinaryenBinary'](module, Module['XorInt32'], left, right); - }, - 'shl'(left, right) { - return Module['_BinaryenBinary'](module, Module['ShlInt32'], left, right); - }, - 'shr_u'(left, right) { - return Module['_BinaryenBinary'](module, Module['ShrUInt32'], left, right); - }, - 'shr_s'(left, right) { - return Module['_BinaryenBinary'](module, Module['ShrSInt32'], left, right); - }, - 'rotl'(left, right) { - return Module['_BinaryenBinary'](module, Module['RotLInt32'], left, right); - }, - 'rotr'(left, right) { - return Module['_BinaryenBinary'](module, Module['RotRInt32'], left, right); - }, - 'eq'(left, right) { - return Module['_BinaryenBinary'](module, Module['EqInt32'], left, right); - }, - 'ne'(left, right) { - return Module['_BinaryenBinary'](module, Module['NeInt32'], left, right); - }, - 'lt_s'(left, right) { - return Module['_BinaryenBinary'](module, Module['LtSInt32'], left, right); - }, - 'lt_u'(left, right) { - return Module['_BinaryenBinary'](module, Module['LtUInt32'], left, right); - }, - 'le_s'(left, right) { - return Module['_BinaryenBinary'](module, Module['LeSInt32'], left, right); - }, - 'le_u'(left, right) { - return Module['_BinaryenBinary'](module, Module['LeUInt32'], left, right); - }, - 'gt_s'(left, right) { - return Module['_BinaryenBinary'](module, Module['GtSInt32'], left, right); - }, - 'gt_u'(left, right) { - return Module['_BinaryenBinary'](module, Module['GtUInt32'], left, right); - }, - 'ge_s'(left, right) { - return Module['_BinaryenBinary'](module, Module['GeSInt32'], left, right); - }, - 'ge_u'(left, right) { - return Module['_BinaryenBinary'](module, Module['GeUInt32'], left, right); - }, - 'atomic': { - 'load'(offset, ptr, name) { - return Module['_BinaryenAtomicLoad'](module, 4, offset, Module['i32'], ptr, strToStack(name)); - }, - 'load8_u'(offset, ptr, name) { - return Module['_BinaryenAtomicLoad'](module, 1, offset, Module['i32'], ptr, strToStack(name)); - }, - 'load16_u'(offset, ptr, name) { - return Module['_BinaryenAtomicLoad'](module, 2, offset, Module['i32'], ptr, strToStack(name)); - }, - 'store'(offset, ptr, value, name) { - return Module['_BinaryenAtomicStore'](module, 4, offset, ptr, value, Module['i32'], strToStack(name)); - }, - 'store8'(offset, ptr, value, name) { - return Module['_BinaryenAtomicStore'](module, 1, offset, ptr, value, Module['i32'], strToStack(name)); - }, - 'store16'(offset, ptr, value, name) { - return Module['_BinaryenAtomicStore'](module, 2, offset, ptr, value, Module['i32'], strToStack(name)); - }, - 'rmw': { - 'add'(offset, ptr, value, name) { - return Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWAdd'], 4, offset, ptr, value, Module['i32'], strToStack(name)); - }, - 'sub'(offset, ptr, value, name) { - return Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWSub'], 4, offset, ptr, value, Module['i32'], strToStack(name)); - }, - 'and'(offset, ptr, value, name) { - return Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWAnd'], 4, offset, ptr, value, Module['i32'], strToStack(name)); - }, - 'or'(offset, ptr, value, name) { - return Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWOr'], 4, offset, ptr, value, Module['i32'], strToStack(name)); - }, - 'xor'(offset, ptr, value, name) { - return Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWXor'], 4, offset, ptr, value, Module['i32'], strToStack(name)); - }, - 'xchg'(offset, ptr, value, name) { - return Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWXchg'], 4, offset, ptr, value, Module['i32'], strToStack(name)); - }, - 'cmpxchg'(offset, ptr, expected, replacement, name) { - return Module['_BinaryenAtomicCmpxchg'](module, 4, offset, ptr, expected, replacement, Module['i32'], strToStack(name)) - }, - }, - 'rmw8_u': { - 'add'(offset, ptr, value, name) { - return Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWAdd'], 1, offset, ptr, value, Module['i32'], strToStack(name)); - }, - 'sub'(offset, ptr, value, name) { - return Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWSub'], 1, offset, ptr, value, Module['i32'], strToStack(name)); - }, - 'and'(offset, ptr, value, name) { - return Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWAnd'], 1, offset, ptr, value, Module['i32'], strToStack(name)); - }, - 'or'(offset, ptr, value, name) { - return Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWOr'], 1, offset, ptr, value, Module['i32'], strToStack(name)); - }, - 'xor'(offset, ptr, value, name) { - return Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWXor'], 1, offset, ptr, value, Module['i32'], strToStack(name)); - }, - 'xchg'(offset, ptr, value, name) { - return Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWXchg'], 1, offset, ptr, value, Module['i32'], strToStack(name)); - }, - 'cmpxchg'(offset, ptr, expected, replacement, name) { - return Module['_BinaryenAtomicCmpxchg'](module, 1, offset, ptr, expected, replacement, Module['i32'], strToStack(name)) - }, - }, - 'rmw16_u': { - 'add'(offset, ptr, value, name) { - return Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWAdd'], 2, offset, ptr, value, Module['i32'], strToStack(name)); - }, - 'sub'(offset, ptr, value, name) { - return Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWSub'], 2, offset, ptr, value, Module['i32'], strToStack(name)); - }, - 'and'(offset, ptr, value, name) { - return Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWAnd'], 2, offset, ptr, value, Module['i32'], strToStack(name)); - }, - 'or'(offset, ptr, value, name) { - return Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWOr'], 2, offset, ptr, value, Module['i32'], strToStack(name)); - }, - 'xor'(offset, ptr, value, name) { - return Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWXor'], 2, offset, ptr, value, Module['i32'], strToStack(name)); - }, - 'xchg'(offset, ptr, value, name) { - return Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWXchg'], 2, offset, ptr, value, Module['i32'], strToStack(name)); - }, - 'cmpxchg'(offset, ptr, expected, replacement, name) { - return Module['_BinaryenAtomicCmpxchg'](module, 2, offset, ptr, expected, replacement, Module['i32'], strToStack(name)) - }, - }, - }, - 'pop'() { - return Module['_BinaryenPop'](module, Module['i32']); - } - }; - - self['i64'] = { - 'load'(offset, align, ptr, name) { - return Module['_BinaryenLoad'](module, 8, true, offset, align, Module['i64'], ptr, strToStack(name)); - }, - 'load8_s'(offset, align, ptr, name) { - return Module['_BinaryenLoad'](module, 1, true, offset, align, Module['i64'], ptr, strToStack(name)); - }, - 'load8_u'(offset, align, ptr, name) { - return Module['_BinaryenLoad'](module, 1, false, offset, align, Module['i64'], ptr, strToStack(name)); - }, - 'load16_s'(offset, align, ptr, name) { - return Module['_BinaryenLoad'](module, 2, true, offset, align, Module['i64'], ptr, strToStack(name)); - }, - 'load16_u'(offset, align, ptr, name) { - return Module['_BinaryenLoad'](module, 2, false, offset, align, Module['i64'], ptr, strToStack(name)); - }, - 'load32_s'(offset, align, ptr, name) { - return Module['_BinaryenLoad'](module, 4, true, offset, align, Module['i64'], ptr, strToStack(name)); - }, - 'load32_u'(offset, align, ptr, name) { - return Module['_BinaryenLoad'](module, 4, false, offset, align, Module['i64'], ptr, strToStack(name)); - }, - 'store'(offset, align, ptr, value, name) { - return Module['_BinaryenStore'](module, 8, offset, align, ptr, value, Module['i64'], strToStack(name)); - }, - 'store8'(offset, align, ptr, value, name) { - return Module['_BinaryenStore'](module, 1, offset, align, ptr, value, Module['i64'], strToStack(name)); - }, - 'store16'(offset, align, ptr, value, name) { - return Module['_BinaryenStore'](module, 2, offset, align, ptr, value, Module['i64'], strToStack(name)); - }, - 'store32'(offset, align, ptr, value, name) { - return Module['_BinaryenStore'](module, 4, offset, align, ptr, value, Module['i64'], strToStack(name)); - }, - 'const'(x, y) { - return preserveStack(() => { - const tempLiteral = stackAlloc(sizeOfLiteral); - Module['_BinaryenLiteralInt64'](tempLiteral, x, y); - return Module['_BinaryenConst'](module, tempLiteral); - }); - }, - 'clz'(value) { - return Module['_BinaryenUnary'](module, Module['ClzInt64'], value); - }, - 'ctz'(value) { - return Module['_BinaryenUnary'](module, Module['CtzInt64'], value); - }, - 'popcnt'(value) { - return Module['_BinaryenUnary'](module, Module['PopcntInt64'], value); - }, - 'eqz'(value) { - return Module['_BinaryenUnary'](module, Module['EqZInt64'], value); - }, - 'trunc_s': { - 'f32'(value) { - return Module['_BinaryenUnary'](module, Module['TruncSFloat32ToInt64'], value); - }, - 'f64'(value) { - return Module['_BinaryenUnary'](module, Module['TruncSFloat64ToInt64'], value); - }, - }, - 'trunc_u': { - 'f32'(value) { - return Module['_BinaryenUnary'](module, Module['TruncUFloat32ToInt64'], value); - }, - 'f64'(value) { - return Module['_BinaryenUnary'](module, Module['TruncUFloat64ToInt64'], value); - }, - }, - 'trunc_s_sat': { - 'f32'(value) { - return Module['_BinaryenUnary'](module, Module['TruncSatSFloat32ToInt64'], value); - }, - 'f64'(value) { - return Module['_BinaryenUnary'](module, Module['TruncSatSFloat64ToInt64'], value); - }, - }, - 'trunc_u_sat': { - 'f32'(value) { - return Module['_BinaryenUnary'](module, Module['TruncSatUFloat32ToInt64'], value); - }, - 'f64'(value) { - return Module['_BinaryenUnary'](module, Module['TruncSatUFloat64ToInt64'], value); - }, - }, - 'reinterpret'(value) { - return Module['_BinaryenUnary'](module, Module['ReinterpretFloat64'], value); - }, - 'extend8_s'(value) { - return Module['_BinaryenUnary'](module, Module['ExtendS8Int64'], value); - }, - 'extend16_s'(value) { - return Module['_BinaryenUnary'](module, Module['ExtendS16Int64'], value); - }, - 'extend32_s'(value) { - return Module['_BinaryenUnary'](module, Module['ExtendS32Int64'], value); - }, - 'extend_s'(value) { - return Module['_BinaryenUnary'](module, Module['ExtendSInt32'], value); - }, - 'extend_u'(value) { - return Module['_BinaryenUnary'](module, Module['ExtendUInt32'], value); - }, - 'add'(left, right) { - return Module['_BinaryenBinary'](module, Module['AddInt64'], left, right); - }, - 'sub'(left, right) { - return Module['_BinaryenBinary'](module, Module['SubInt64'], left, right); - }, - 'mul'(left, right) { - return Module['_BinaryenBinary'](module, Module['MulInt64'], left, right); - }, - 'div_s'(left, right) { - return Module['_BinaryenBinary'](module, Module['DivSInt64'], left, right); - }, - 'div_u'(left, right) { - return Module['_BinaryenBinary'](module, Module['DivUInt64'], left, right); - }, - 'rem_s'(left, right) { - return Module['_BinaryenBinary'](module, Module['RemSInt64'], left, right); - }, - 'rem_u'(left, right) { - return Module['_BinaryenBinary'](module, Module['RemUInt64'], left, right); - }, - 'and'(left, right) { - return Module['_BinaryenBinary'](module, Module['AndInt64'], left, right); - }, - 'or'(left, right) { - return Module['_BinaryenBinary'](module, Module['OrInt64'], left, right); - }, - 'xor'(left, right) { - return Module['_BinaryenBinary'](module, Module['XorInt64'], left, right); - }, - 'shl'(left, right) { - return Module['_BinaryenBinary'](module, Module['ShlInt64'], left, right); - }, - 'shr_u'(left, right) { - return Module['_BinaryenBinary'](module, Module['ShrUInt64'], left, right); - }, - 'shr_s'(left, right) { - return Module['_BinaryenBinary'](module, Module['ShrSInt64'], left, right); - }, - 'rotl'(left, right) { - return Module['_BinaryenBinary'](module, Module['RotLInt64'], left, right); - }, - 'rotr'(left, right) { - return Module['_BinaryenBinary'](module, Module['RotRInt64'], left, right); - }, - 'eq'(left, right) { - return Module['_BinaryenBinary'](module, Module['EqInt64'], left, right); - }, - 'ne'(left, right) { - return Module['_BinaryenBinary'](module, Module['NeInt64'], left, right); - }, - 'lt_s'(left, right) { - return Module['_BinaryenBinary'](module, Module['LtSInt64'], left, right); - }, - 'lt_u'(left, right) { - return Module['_BinaryenBinary'](module, Module['LtUInt64'], left, right); - }, - 'le_s'(left, right) { - return Module['_BinaryenBinary'](module, Module['LeSInt64'], left, right); - }, - 'le_u'(left, right) { - return Module['_BinaryenBinary'](module, Module['LeUInt64'], left, right); - }, - 'gt_s'(left, right) { - return Module['_BinaryenBinary'](module, Module['GtSInt64'], left, right); - }, - 'gt_u'(left, right) { - return Module['_BinaryenBinary'](module, Module['GtUInt64'], left, right); - }, - 'ge_s'(left, right) { - return Module['_BinaryenBinary'](module, Module['GeSInt64'], left, right); - }, - 'ge_u'(left, right) { - return Module['_BinaryenBinary'](module, Module['GeUInt64'], left, right); - }, - 'atomic': { - 'load'(offset, ptr, name) { - return Module['_BinaryenAtomicLoad'](module, 8, offset, Module['i64'], ptr, strToStack(name)); - }, - 'load8_u'(offset, ptr, name) { - return Module['_BinaryenAtomicLoad'](module, 1, offset, Module['i64'], ptr, strToStack(name)); - }, - 'load16_u'(offset, ptr, name) { - return Module['_BinaryenAtomicLoad'](module, 2, offset, Module['i64'], ptr, strToStack(name)); - }, - 'load32_u'(offset, ptr, name) { - return Module['_BinaryenAtomicLoad'](module, 4, offset, Module['i64'], ptr, strToStack(name)); - }, - 'store'(offset, ptr, value, name) { - return Module['_BinaryenAtomicStore'](module, 8, offset, ptr, value, Module['i64'], strToStack(name)); - }, - 'store8'(offset, ptr, value, name) { - return Module['_BinaryenAtomicStore'](module, 1, offset, ptr, value, Module['i64'], strToStack(name)); - }, - 'store16'(offset, ptr, value, name) { - return Module['_BinaryenAtomicStore'](module, 2, offset, ptr, value, Module['i64'], strToStack(name)); - }, - 'store32'(offset, ptr, value, name) { - return Module['_BinaryenAtomicStore'](module, 4, offset, ptr, value, Module['i64'], strToStack(name)); - }, - 'rmw': { - 'add'(offset, ptr, value, name) { - return Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWAdd'], 8, offset, ptr, value, Module['i64'], strToStack(name)); - }, - 'sub'(offset, ptr, value, name) { - return Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWSub'], 8, offset, ptr, value, Module['i64'], strToStack(name)); - }, - 'and'(offset, ptr, value, name) { - return Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWAnd'], 8, offset, ptr, value, Module['i64'], strToStack(name)); - }, - 'or'(offset, ptr, value, name) { - return Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWOr'], 8, offset, ptr, value, Module['i64'], strToStack(name)); - }, - 'xor'(offset, ptr, value, name) { - return Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWXor'], 8, offset, ptr, value, Module['i64'], strToStack(name)); - }, - 'xchg'(offset, ptr, value, name) { - return Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWXchg'], 8, offset, ptr, value, Module['i64'], strToStack(name)); - }, - 'cmpxchg'(offset, ptr, expected, replacement, name) { - return Module['_BinaryenAtomicCmpxchg'](module, 8, offset, ptr, expected, replacement, Module['i64'], strToStack(name)) - }, - }, - 'rmw8_u': { - 'add'(offset, ptr, value, name) { - return Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWAdd'], 1, offset, ptr, value, Module['i64'], strToStack(name)); - }, - 'sub'(offset, ptr, value, name) { - return Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWSub'], 1, offset, ptr, value, Module['i64'], strToStack(name)); - }, - 'and'(offset, ptr, value, name) { - return Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWAnd'], 1, offset, ptr, value, Module['i64'], strToStack(name)); - }, - 'or'(offset, ptr, value, name) { - return Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWOr'], 1, offset, ptr, value, Module['i64'], strToStack(name)); - }, - 'xor'(offset, ptr, value, name) { - return Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWXor'], 1, offset, ptr, value, Module['i64'], strToStack(name)); - }, - 'xchg'(offset, ptr, value, name) { - return Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWXchg'], 1, offset, ptr, value, Module['i64'], strToStack(name)); - }, - 'cmpxchg'(offset, ptr, expected, replacement, name) { - return Module['_BinaryenAtomicCmpxchg'](module, 1, offset, ptr, expected, replacement, Module['i64'], strToStack(name)) - }, - }, - 'rmw16_u': { - 'add'(offset, ptr, value, name) { - return Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWAdd'], 2, offset, ptr, value, Module['i64'], strToStack(name)); - }, - 'sub'(offset, ptr, value, name) { - return Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWSub'], 2, offset, ptr, value, Module['i64'], strToStack(name)); - }, - 'and'(offset, ptr, value, name) { - return Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWAnd'], 2, offset, ptr, value, Module['i64'], strToStack(name)); - }, - 'or'(offset, ptr, value, name) { - return Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWOr'], 2, offset, ptr, value, Module['i64'], strToStack(name)); - }, - 'xor'(offset, ptr, value, name) { - return Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWXor'], 2, offset, ptr, value, Module['i64'], strToStack(name)); - }, - 'xchg'(offset, ptr, value, name) { - return Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWXchg'], 2, offset, ptr, value, Module['i64'], strToStack(name)); - }, - 'cmpxchg'(offset, ptr, expected, replacement, name) { - return Module['_BinaryenAtomicCmpxchg'](module, 2, offset, ptr, expected, replacement, Module['i64'], strToStack(name)) - }, - }, - 'rmw32_u': { - 'add'(offset, ptr, value, name) { - return Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWAdd'], 4, offset, ptr, value, Module['i64'], strToStack(name)); - }, - 'sub'(offset, ptr, value, name) { - return Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWSub'], 4, offset, ptr, value, Module['i64'], strToStack(name)); - }, - 'and'(offset, ptr, value, name) { - return Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWAnd'], 4, offset, ptr, value, Module['i64'], strToStack(name)); - }, - 'or'(offset, ptr, value, name) { - return Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWOr'], 4, offset, ptr, value, Module['i64'], strToStack(name)); - }, - 'xor'(offset, ptr, value, name) { - return Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWXor'], 4, offset, ptr, value, Module['i64'], strToStack(name)); - }, - 'xchg'(offset, ptr, value, name) { - return Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWXchg'], 4, offset, ptr, value, Module['i64'], strToStack(name)); - }, - 'cmpxchg'(offset, ptr, expected, replacement, name) { - return Module['_BinaryenAtomicCmpxchg'](module, 4, offset, ptr, expected, replacement, Module['i64'], strToStack(name)) - }, - }, - }, - 'pop'() { - return Module['_BinaryenPop'](module, Module['i64']); - } - }; - - self['f32'] = { - 'load'(offset, align, ptr, name) { - return Module['_BinaryenLoad'](module, 4, true, offset, align, Module['f32'], ptr, strToStack(name)); - }, - 'store'(offset, align, ptr, value, name) { - return Module['_BinaryenStore'](module, 4, offset, align, ptr, value, Module['f32'], strToStack(name)); - }, - 'const'(x) { - return preserveStack(() => { - const tempLiteral = stackAlloc(sizeOfLiteral); - Module['_BinaryenLiteralFloat32'](tempLiteral, x); - return Module['_BinaryenConst'](module, tempLiteral); - }); - }, - 'const_bits'(x) { - return preserveStack(() => { - const tempLiteral = stackAlloc(sizeOfLiteral); - Module['_BinaryenLiteralFloat32Bits'](tempLiteral, x); - return Module['_BinaryenConst'](module, tempLiteral); - }); - }, - 'neg'(value) { - return Module['_BinaryenUnary'](module, Module['NegFloat32'], value); - }, - 'abs'(value) { - return Module['_BinaryenUnary'](module, Module['AbsFloat32'], value); - }, - 'ceil'(value) { - return Module['_BinaryenUnary'](module, Module['CeilFloat32'], value); - }, - 'floor'(value) { - return Module['_BinaryenUnary'](module, Module['FloorFloat32'], value); - }, - 'trunc'(value) { - return Module['_BinaryenUnary'](module, Module['TruncFloat32'], value); - }, - 'nearest'(value) { - return Module['_BinaryenUnary'](module, Module['NearestFloat32'], value); - }, - 'sqrt'(value) { - return Module['_BinaryenUnary'](module, Module['SqrtFloat32'], value); - }, - 'reinterpret'(value) { - return Module['_BinaryenUnary'](module, Module['ReinterpretInt32'], value); - }, - 'convert_s': { - 'i32'(value) { - return Module['_BinaryenUnary'](module, Module['ConvertSInt32ToFloat32'], value); - }, - 'i64'(value) { - return Module['_BinaryenUnary'](module, Module['ConvertSInt64ToFloat32'], value); - }, - }, - 'convert_u': { - 'i32'(value) { - return Module['_BinaryenUnary'](module, Module['ConvertUInt32ToFloat32'], value); - }, - 'i64'(value) { - return Module['_BinaryenUnary'](module, Module['ConvertUInt64ToFloat32'], value); - }, - }, - 'demote'(value) { - return Module['_BinaryenUnary'](module, Module['DemoteFloat64'], value); - }, - 'add'(left, right) { - return Module['_BinaryenBinary'](module, Module['AddFloat32'], left, right); - }, - 'sub'(left, right) { - return Module['_BinaryenBinary'](module, Module['SubFloat32'], left, right); - }, - 'mul'(left, right) { - return Module['_BinaryenBinary'](module, Module['MulFloat32'], left, right); - }, - 'div'(left, right) { - return Module['_BinaryenBinary'](module, Module['DivFloat32'], left, right); - }, - 'copysign'(left, right) { - return Module['_BinaryenBinary'](module, Module['CopySignFloat32'], left, right); - }, - 'min'(left, right) { - return Module['_BinaryenBinary'](module, Module['MinFloat32'], left, right); - }, - 'max'(left, right) { - return Module['_BinaryenBinary'](module, Module['MaxFloat32'], left, right); - }, - 'eq'(left, right) { - return Module['_BinaryenBinary'](module, Module['EqFloat32'], left, right); - }, - 'ne'(left, right) { - return Module['_BinaryenBinary'](module, Module['NeFloat32'], left, right); - }, - 'lt'(left, right) { - return Module['_BinaryenBinary'](module, Module['LtFloat32'], left, right); - }, - 'le'(left, right) { - return Module['_BinaryenBinary'](module, Module['LeFloat32'], left, right); - }, - 'gt'(left, right) { - return Module['_BinaryenBinary'](module, Module['GtFloat32'], left, right); - }, - 'ge'(left, right) { - return Module['_BinaryenBinary'](module, Module['GeFloat32'], left, right); - }, - 'pop'() { - return Module['_BinaryenPop'](module, Module['f32']); - } - }; - - self['f64'] = { - 'load'(offset, align, ptr, name) { - return Module['_BinaryenLoad'](module, 8, true, offset, align, Module['f64'], ptr, strToStack(name)); - }, - 'store'(offset, align, ptr, value, name) { - return Module['_BinaryenStore'](module, 8, offset, align, ptr, value, Module['f64'], strToStack(name)); - }, - 'const'(x) { - return preserveStack(() => { - const tempLiteral = stackAlloc(sizeOfLiteral); - Module['_BinaryenLiteralFloat64'](tempLiteral, x); - return Module['_BinaryenConst'](module, tempLiteral); - }); - }, - 'const_bits'(x, y) { - return preserveStack(() => { - const tempLiteral = stackAlloc(sizeOfLiteral); - Module['_BinaryenLiteralFloat64Bits'](tempLiteral, x, y); - return Module['_BinaryenConst'](module, tempLiteral); - }); - }, - 'neg'(value) { - return Module['_BinaryenUnary'](module, Module['NegFloat64'], value); - }, - 'abs'(value) { - return Module['_BinaryenUnary'](module, Module['AbsFloat64'], value); - }, - 'ceil'(value) { - return Module['_BinaryenUnary'](module, Module['CeilFloat64'], value); - }, - 'floor'(value) { - return Module['_BinaryenUnary'](module, Module['FloorFloat64'], value); - }, - 'trunc'(value) { - return Module['_BinaryenUnary'](module, Module['TruncFloat64'], value); - }, - 'nearest'(value) { - return Module['_BinaryenUnary'](module, Module['NearestFloat64'], value); - }, - 'sqrt'(value) { - return Module['_BinaryenUnary'](module, Module['SqrtFloat64'], value); - }, - 'reinterpret'(value) { - return Module['_BinaryenUnary'](module, Module['ReinterpretInt64'], value); - }, - 'convert_s': { - 'i32'(value) { - return Module['_BinaryenUnary'](module, Module['ConvertSInt32ToFloat64'], value); - }, - 'i64'(value) { - return Module['_BinaryenUnary'](module, Module['ConvertSInt64ToFloat64'], value); - }, - }, - 'convert_u': { - 'i32'(value) { - return Module['_BinaryenUnary'](module, Module['ConvertUInt32ToFloat64'], value); - }, - 'i64'(value) { - return Module['_BinaryenUnary'](module, Module['ConvertUInt64ToFloat64'], value); - }, - }, - 'promote'(value) { - return Module['_BinaryenUnary'](module, Module['PromoteFloat32'], value); - }, - 'add'(left, right) { - return Module['_BinaryenBinary'](module, Module['AddFloat64'], left, right); - }, - 'sub'(left, right) { - return Module['_BinaryenBinary'](module, Module['SubFloat64'], left, right); - }, - 'mul'(left, right) { - return Module['_BinaryenBinary'](module, Module['MulFloat64'], left, right); - }, - 'div'(left, right) { - return Module['_BinaryenBinary'](module, Module['DivFloat64'], left, right); - }, - 'copysign'(left, right) { - return Module['_BinaryenBinary'](module, Module['CopySignFloat64'], left, right); - }, - 'min'(left, right) { - return Module['_BinaryenBinary'](module, Module['MinFloat64'], left, right); - }, - 'max'(left, right) { - return Module['_BinaryenBinary'](module, Module['MaxFloat64'], left, right); - }, - 'eq'(left, right) { - return Module['_BinaryenBinary'](module, Module['EqFloat64'], left, right); - }, - 'ne'(left, right) { - return Module['_BinaryenBinary'](module, Module['NeFloat64'], left, right); - }, - 'lt'(left, right) { - return Module['_BinaryenBinary'](module, Module['LtFloat64'], left, right); - }, - 'le'(left, right) { - return Module['_BinaryenBinary'](module, Module['LeFloat64'], left, right); - }, - 'gt'(left, right) { - return Module['_BinaryenBinary'](module, Module['GtFloat64'], left, right); - }, - 'ge'(left, right) { - return Module['_BinaryenBinary'](module, Module['GeFloat64'], left, right); - }, - 'pop'() { - return Module['_BinaryenPop'](module, Module['f64']); - } - }; - - self['v128'] = { - 'load'(offset, align, ptr, name) { - return Module['_BinaryenLoad'](module, 16, false, offset, align, Module['v128'], ptr, strToStack(name)); - }, - 'load8_splat'(offset, align, ptr, name) { - return Module['_BinaryenSIMDLoad'](module, Module['Load8SplatVec128'], offset, align, ptr, strToStack(name)); - }, - 'load16_splat'(offset, align, ptr, name) { - return Module['_BinaryenSIMDLoad'](module, Module['Load16SplatVec128'], offset, align, ptr, strToStack(name)); - }, - 'load32_splat'(offset, align, ptr, name) { - return Module['_BinaryenSIMDLoad'](module, Module['Load32SplatVec128'], offset, align, ptr, strToStack(name)); - }, - 'load64_splat'(offset, align, ptr, name) { - return Module['_BinaryenSIMDLoad'](module, Module['Load64SplatVec128'], offset, align, ptr, strToStack(name)); - }, - 'load8x8_s'(offset, align, ptr, name) { - return Module['_BinaryenSIMDLoad'](module, Module['Load8x8SVec128'], offset, align, ptr, strToStack(name)); - }, - 'load8x8_u'(offset, align, ptr, name) { - return Module['_BinaryenSIMDLoad'](module, Module['Load8x8UVec128'], offset, align, ptr, strToStack(name)); - }, - 'load16x4_s'(offset, align, ptr, name) { - return Module['_BinaryenSIMDLoad'](module, Module['Load16x4SVec128'], offset, align, ptr, strToStack(name)); - }, - 'load16x4_u'(offset, align, ptr, name) { - return Module['_BinaryenSIMDLoad'](module, Module['Load16x4UVec128'], offset, align, ptr, strToStack(name)); - }, - 'load32x2_s'(offset, align, ptr, name) { - return Module['_BinaryenSIMDLoad'](module, Module['Load32x2SVec128'], offset, align, ptr, strToStack(name)); - }, - 'load32x2_u'(offset, align, ptr, name) { - return Module['_BinaryenSIMDLoad'](module, Module['Load32x2UVec128'], offset, align, ptr, strToStack(name)); - }, - 'load32_zero'(offset, align, ptr, name) { - return Module['_BinaryenSIMDLoad'](module, Module['Load32ZeroVec128'], offset, align, ptr, strToStack(name)); - }, - 'load64_zero'(offset, align, ptr, name) { - return Module['_BinaryenSIMDLoad'](module, Module['Load64ZeroVec128'], offset, align, ptr, strToStack(name)); - }, - 'load8_lane'(offset, align, index, ptr, vec, name) { - return Module['_BinaryenSIMDLoadStoreLane'](module, Module['Load8LaneVec128'], offset, align, index, ptr, vec, strToStack(name)); - }, - 'load16_lane'(offset, align, index, ptr, vec, name) { - return Module['_BinaryenSIMDLoadStoreLane'](module, Module['Load16LaneVec128'], offset, align, index, ptr, vec, strToStack(name)); - }, - 'load32_lane'(offset, align, index, ptr, vec, name) { - return Module['_BinaryenSIMDLoadStoreLane'](module, Module['Load32LaneVec128'], offset, align, index, ptr, vec, strToStack(name)); - }, - 'load64_lane'(offset, align, index, ptr, vec, name) { - return Module['_BinaryenSIMDLoadStoreLane'](module, Module['Load64LaneVec128'], offset, align, index, ptr, vec, strToStack(name)); - }, - 'store8_lane'(offset, align, index, ptr, vec, name) { - return Module['_BinaryenSIMDLoadStoreLane'](module, Module['Store8LaneVec128'], offset, align, index, ptr, vec, strToStack(name)); - }, - 'store16_lane'(offset, align, index, ptr, vec, name) { - return Module['_BinaryenSIMDLoadStoreLane'](module, Module['Store16LaneVec128'], offset, align, index, ptr, vec, strToStack(name)); - }, - 'store32_lane'(offset, align, index, ptr, vec, name) { - return Module['_BinaryenSIMDLoadStoreLane'](module, Module['Store32LaneVec128'], offset, align, index, ptr, vec, strToStack(name)); - }, - 'store64_lane'(offset, align, index, ptr, vec, name) { - return Module['_BinaryenSIMDLoadStoreLane'](module, Module['Store64LaneVec128'], offset, align, index, ptr, vec, strToStack(name)); - }, - 'store'(offset, align, ptr, value, name) { - return Module['_BinaryenStore'](module, 16, offset, align, ptr, value, Module['v128'], strToStack(name)); - }, - 'const'(i8s) { - return preserveStack(() => { - const tempLiteral = stackAlloc(sizeOfLiteral); - Module['_BinaryenLiteralVec128'](tempLiteral, i8sToStack(i8s)); - return Module['_BinaryenConst'](module, tempLiteral); - }); - }, - 'not'(value) { - return Module['_BinaryenUnary'](module, Module['NotVec128'], value); - }, - 'any_true'(value) { - return Module['_BinaryenUnary'](module, Module['AnyTrueVec128'], value); - }, - 'and'(left, right) { - return Module['_BinaryenBinary'](module, Module['AndVec128'], left, right); - }, - 'or'(left, right) { - return Module['_BinaryenBinary'](module, Module['OrVec128'], left, right); - }, - 'xor'(left, right) { - return Module['_BinaryenBinary'](module, Module['XorVec128'], left, right); - }, - 'andnot'(left, right) { - return Module['_BinaryenBinary'](module, Module['AndNotVec128'], left, right); - }, - 'bitselect'(left, right, cond) { - return Module['_BinaryenSIMDTernary'](module, Module['BitselectVec128'], left, right, cond); - }, - 'pop'() { - return Module['_BinaryenPop'](module, Module['v128']); - } - }; - - self['i8x16'] = { - 'shuffle'(left, right, mask) { - return preserveStack(() => Module['_BinaryenSIMDShuffle'](module, left, right, i8sToStack(mask))); - }, - 'swizzle'(left, right) { - return Module['_BinaryenBinary'](module, Module['SwizzleVecI8x16'], left, right); - }, - 'splat'(value) { - return Module['_BinaryenUnary'](module, Module['SplatVecI8x16'], value); - }, - 'extract_lane_s'(vec, index) { - return Module['_BinaryenSIMDExtract'](module, Module['ExtractLaneSVecI8x16'], vec, index); - }, - 'extract_lane_u'(vec, index) { - return Module['_BinaryenSIMDExtract'](module, Module['ExtractLaneUVecI8x16'], vec, index); - }, - 'replace_lane'(vec, index, value) { - return Module['_BinaryenSIMDReplace'](module, Module['ReplaceLaneVecI8x16'], vec, index, value); - }, - 'eq'(left, right) { - return Module['_BinaryenBinary'](module, Module['EqVecI8x16'], left, right); - }, - 'ne'(left, right) { - return Module['_BinaryenBinary'](module, Module['NeVecI8x16'], left, right); - }, - 'lt_s'(left, right) { - return Module['_BinaryenBinary'](module, Module['LtSVecI8x16'], left, right); - }, - 'lt_u'(left, right) { - return Module['_BinaryenBinary'](module, Module['LtUVecI8x16'], left, right); - }, - 'gt_s'(left, right) { - return Module['_BinaryenBinary'](module, Module['GtSVecI8x16'], left, right); - }, - 'gt_u'(left, right) { - return Module['_BinaryenBinary'](module, Module['GtUVecI8x16'], left, right); - }, - 'le_s'(left, right) { - return Module['_BinaryenBinary'](module, Module['LeSVecI8x16'], left, right); - }, - 'le_u'(left, right) { - return Module['_BinaryenBinary'](module, Module['LeUVecI8x16'], left, right); - }, - 'ge_s'(left, right) { - return Module['_BinaryenBinary'](module, Module['GeSVecI8x16'], left, right); - }, - 'ge_u'(left, right) { - return Module['_BinaryenBinary'](module, Module['GeUVecI8x16'], left, right); - }, - 'abs'(value) { - return Module['_BinaryenUnary'](module, Module['AbsVecI8x16'], value); - }, - 'neg'(value) { - return Module['_BinaryenUnary'](module, Module['NegVecI8x16'], value); - }, - 'all_true'(value) { - return Module['_BinaryenUnary'](module, Module['AllTrueVecI8x16'], value); - }, - 'bitmask'(value) { - return Module['_BinaryenUnary'](module, Module['BitmaskVecI8x16'], value); - }, - 'popcnt'(value) { - return Module['_BinaryenUnary'](module, Module['PopcntVecI8x16'], value); - }, - 'shl'(vec, shift) { - return Module['_BinaryenSIMDShift'](module, Module['ShlVecI8x16'], vec, shift); - }, - 'shr_s'(vec, shift) { - return Module['_BinaryenSIMDShift'](module, Module['ShrSVecI8x16'], vec, shift); - }, - 'shr_u'(vec, shift) { - return Module['_BinaryenSIMDShift'](module, Module['ShrUVecI8x16'], vec, shift); - }, - 'add'(left, right) { - return Module['_BinaryenBinary'](module, Module['AddVecI8x16'], left, right); - }, - 'add_saturate_s'(left, right) { - return Module['_BinaryenBinary'](module, Module['AddSatSVecI8x16'], left, right); - }, - 'add_saturate_u'(left, right) { - return Module['_BinaryenBinary'](module, Module['AddSatUVecI8x16'], left, right); - }, - 'sub'(left, right) { - return Module['_BinaryenBinary'](module, Module['SubVecI8x16'], left, right); - }, - 'sub_saturate_s'(left, right) { - return Module['_BinaryenBinary'](module, Module['SubSatSVecI8x16'], left, right); - }, - 'sub_saturate_u'(left, right) { - return Module['_BinaryenBinary'](module, Module['SubSatUVecI8x16'], left, right); - }, - 'min_s'(left, right) { - return Module['_BinaryenBinary'](module, Module['MinSVecI8x16'], left, right); - }, - 'min_u'(left, right) { - return Module['_BinaryenBinary'](module, Module['MinUVecI8x16'], left, right); - }, - 'max_s'(left, right) { - return Module['_BinaryenBinary'](module, Module['MaxSVecI8x16'], left, right); - }, - 'max_u'(left, right) { - return Module['_BinaryenBinary'](module, Module['MaxUVecI8x16'], left, right); - }, - 'avgr_u'(left, right) { - return Module['_BinaryenBinary'](module, Module['AvgrUVecI8x16'], left, right); - }, - 'narrow_i16x8_s'(left, right) { - return Module['_BinaryenBinary'](module, Module['NarrowSVecI16x8ToVecI8x16'], left, right); - }, - 'narrow_i16x8_u'(left, right) { - return Module['_BinaryenBinary'](module, Module['NarrowUVecI16x8ToVecI8x16'], left, right); - }, - }; - - self['i16x8'] = { - 'splat'(value) { - return Module['_BinaryenUnary'](module, Module['SplatVecI16x8'], value); - }, - 'extract_lane_s'(vec, index) { - return Module['_BinaryenSIMDExtract'](module, Module['ExtractLaneSVecI16x8'], vec, index); - }, - 'extract_lane_u'(vec, index) { - return Module['_BinaryenSIMDExtract'](module, Module['ExtractLaneUVecI16x8'], vec, index); - }, - 'replace_lane'(vec, index, value) { - return Module['_BinaryenSIMDReplace'](module, Module['ReplaceLaneVecI16x8'], vec, index, value); - }, - 'eq'(left, right) { - return Module['_BinaryenBinary'](module, Module['EqVecI16x8'], left, right); - }, - 'ne'(left, right) { - return Module['_BinaryenBinary'](module, Module['NeVecI16x8'], left, right); - }, - 'lt_s'(left, right) { - return Module['_BinaryenBinary'](module, Module['LtSVecI16x8'], left, right); - }, - 'lt_u'(left, right) { - return Module['_BinaryenBinary'](module, Module['LtUVecI16x8'], left, right); - }, - 'gt_s'(left, right) { - return Module['_BinaryenBinary'](module, Module['GtSVecI16x8'], left, right); - }, - 'gt_u'(left, right) { - return Module['_BinaryenBinary'](module, Module['GtUVecI16x8'], left, right); - }, - 'le_s'(left, right) { - return Module['_BinaryenBinary'](module, Module['LeSVecI16x8'], left, right); - }, - 'le_u'(left, right) { - return Module['_BinaryenBinary'](module, Module['LeUVecI16x8'], left, right); - }, - 'ge_s'(left, right) { - return Module['_BinaryenBinary'](module, Module['GeSVecI16x8'], left, right); - }, - 'ge_u'(left, right) { - return Module['_BinaryenBinary'](module, Module['GeUVecI16x8'], left, right); - }, - 'abs'(value) { - return Module['_BinaryenUnary'](module, Module['AbsVecI16x8'], value); - }, - 'neg'(value) { - return Module['_BinaryenUnary'](module, Module['NegVecI16x8'], value); - }, - 'all_true'(value) { - return Module['_BinaryenUnary'](module, Module['AllTrueVecI16x8'], value); - }, - 'bitmask'(value) { - return Module['_BinaryenUnary'](module, Module['BitmaskVecI16x8'], value); - }, - 'shl'(vec, shift) { - return Module['_BinaryenSIMDShift'](module, Module['ShlVecI16x8'], vec, shift); - }, - 'shr_s'(vec, shift) { - return Module['_BinaryenSIMDShift'](module, Module['ShrSVecI16x8'], vec, shift); - }, - 'shr_u'(vec, shift) { - return Module['_BinaryenSIMDShift'](module, Module['ShrUVecI16x8'], vec, shift); - }, - 'add'(left, right) { - return Module['_BinaryenBinary'](module, Module['AddVecI16x8'], left, right); - }, - 'add_saturate_s'(left, right) { - return Module['_BinaryenBinary'](module, Module['AddSatSVecI16x8'], left, right); - }, - 'add_saturate_u'(left, right) { - return Module['_BinaryenBinary'](module, Module['AddSatUVecI16x8'], left, right); - }, - 'sub'(left, right) { - return Module['_BinaryenBinary'](module, Module['SubVecI16x8'], left, right); - }, - 'sub_saturate_s'(left, right) { - return Module['_BinaryenBinary'](module, Module['SubSatSVecI16x8'], left, right); - }, - 'sub_saturate_u'(left, right) { - return Module['_BinaryenBinary'](module, Module['SubSatUVecI16x8'], left, right); - }, - 'mul'(left, right) { - return Module['_BinaryenBinary'](module, Module['MulVecI16x8'], left, right); - }, - 'min_s'(left, right) { - return Module['_BinaryenBinary'](module, Module['MinSVecI16x8'], left, right); - }, - 'min_u'(left, right) { - return Module['_BinaryenBinary'](module, Module['MinUVecI16x8'], left, right); - }, - 'max_s'(left, right) { - return Module['_BinaryenBinary'](module, Module['MaxSVecI16x8'], left, right); - }, - 'max_u'(left, right) { - return Module['_BinaryenBinary'](module, Module['MaxUVecI16x8'], left, right); - }, - 'avgr_u'(left, right) { - return Module['_BinaryenBinary'](module, Module['AvgrUVecI16x8'], left, right); - }, - 'q15mulr_sat_s'(left, right) { - return Module['_BinaryenBinary'](module, Module['Q15MulrSatSVecI16x8'], left, right); - }, - 'extmul_low_i8x16_s'(left, right) { - return Module['_BinaryenBinary'](module, Module['ExtMulLowSVecI16x8'], left, right); - }, - 'extmul_high_i8x16_s'(left, right) { - return Module['_BinaryenBinary'](module, Module['ExtMulHighSVecI16x8'], left, right); - }, - 'extmul_low_i8x16_u'(left, right) { - return Module['_BinaryenBinary'](module, Module['ExtMulLowUVecI16x8'], left, right); - }, - 'extmul_high_i8x16_u'(left, right) { - return Module['_BinaryenBinary'](module, Module['ExtMulHighUVecI16x8'], left, right); - }, - 'extadd_pairwise_i8x16_s'(value) { - return Module['_BinaryenUnary'](module, Module['ExtAddPairwiseSVecI8x16ToI16x8'], value); - }, - 'extadd_pairwise_i8x16_u'(value) { - return Module['_BinaryenUnary'](module, Module['ExtAddPairwiseUVecI8x16ToI16x8'], value); - }, - 'narrow_i32x4_s'(left, right) { - return Module['_BinaryenBinary'](module, Module['NarrowSVecI32x4ToVecI16x8'], left, right); - }, - 'narrow_i32x4_u'(left, right) { - return Module['_BinaryenBinary'](module, Module['NarrowUVecI32x4ToVecI16x8'], left, right); - }, - 'extend_low_i8x16_s'(value) { - return Module['_BinaryenUnary'](module, Module['ExtendLowSVecI8x16ToVecI16x8'], value); - }, - 'extend_high_i8x16_s'(value) { - return Module['_BinaryenUnary'](module, Module['ExtendHighSVecI8x16ToVecI16x8'], value); - }, - 'extend_low_i8x16_u'(value) { - return Module['_BinaryenUnary'](module, Module['ExtendLowUVecI8x16ToVecI16x8'], value); - }, - 'extend_high_i8x16_u'(value) { - return Module['_BinaryenUnary'](module, Module['ExtendHighUVecI8x16ToVecI16x8'], value); - }, - }; - - self['i32x4'] = { - 'splat'(value) { - return Module['_BinaryenUnary'](module, Module['SplatVecI32x4'], value); - }, - 'extract_lane'(vec, index) { - return Module['_BinaryenSIMDExtract'](module, Module['ExtractLaneVecI32x4'], vec, index); - }, - 'replace_lane'(vec, index, value) { - return Module['_BinaryenSIMDReplace'](module, Module['ReplaceLaneVecI32x4'], vec, index, value); - }, - 'eq'(left, right) { - return Module['_BinaryenBinary'](module, Module['EqVecI32x4'], left, right); - }, - 'ne'(left, right) { - return Module['_BinaryenBinary'](module, Module['NeVecI32x4'], left, right); - }, - 'lt_s'(left, right) { - return Module['_BinaryenBinary'](module, Module['LtSVecI32x4'], left, right); - }, - 'lt_u'(left, right) { - return Module['_BinaryenBinary'](module, Module['LtUVecI32x4'], left, right); - }, - 'gt_s'(left, right) { - return Module['_BinaryenBinary'](module, Module['GtSVecI32x4'], left, right); - }, - 'gt_u'(left, right) { - return Module['_BinaryenBinary'](module, Module['GtUVecI32x4'], left, right); - }, - 'le_s'(left, right) { - return Module['_BinaryenBinary'](module, Module['LeSVecI32x4'], left, right); - }, - 'le_u'(left, right) { - return Module['_BinaryenBinary'](module, Module['LeUVecI32x4'], left, right); - }, - 'ge_s'(left, right) { - return Module['_BinaryenBinary'](module, Module['GeSVecI32x4'], left, right); - }, - 'ge_u'(left, right) { - return Module['_BinaryenBinary'](module, Module['GeUVecI32x4'], left, right); - }, - 'abs'(value) { - return Module['_BinaryenUnary'](module, Module['AbsVecI32x4'], value); - }, - 'neg'(value) { - return Module['_BinaryenUnary'](module, Module['NegVecI32x4'], value); - }, - 'all_true'(value) { - return Module['_BinaryenUnary'](module, Module['AllTrueVecI32x4'], value); - }, - 'bitmask'(value) { - return Module['_BinaryenUnary'](module, Module['BitmaskVecI32x4'], value); - }, - 'shl'(vec, shift) { - return Module['_BinaryenSIMDShift'](module, Module['ShlVecI32x4'], vec, shift); - }, - 'shr_s'(vec, shift) { - return Module['_BinaryenSIMDShift'](module, Module['ShrSVecI32x4'], vec, shift); - }, - 'shr_u'(vec, shift) { - return Module['_BinaryenSIMDShift'](module, Module['ShrUVecI32x4'], vec, shift); - }, - 'add'(left, right) { - return Module['_BinaryenBinary'](module, Module['AddVecI32x4'], left, right); - }, - 'sub'(left, right) { - return Module['_BinaryenBinary'](module, Module['SubVecI32x4'], left, right); - }, - 'mul'(left, right) { - return Module['_BinaryenBinary'](module, Module['MulVecI32x4'], left, right); - }, - 'min_s'(left, right) { - return Module['_BinaryenBinary'](module, Module['MinSVecI32x4'], left, right); - }, - 'min_u'(left, right) { - return Module['_BinaryenBinary'](module, Module['MinUVecI32x4'], left, right); - }, - 'max_s'(left, right) { - return Module['_BinaryenBinary'](module, Module['MaxSVecI32x4'], left, right); - }, - 'max_u'(left, right) { - return Module['_BinaryenBinary'](module, Module['MaxUVecI32x4'], left, right); - }, - 'dot_i16x8_s'(left, right) { - return Module['_BinaryenBinary'](module, Module['DotSVecI16x8ToVecI32x4'], left, right); - }, - 'extmul_low_i16x8_s'(left, right) { - return Module['_BinaryenBinary'](module, Module['ExtMulLowSVecI32x4'], left, right); - }, - 'extmul_high_i16x8_s'(left, right) { - return Module['_BinaryenBinary'](module, Module['ExtMulHighSVecI32x4'], left, right); - }, - 'extmul_low_i16x8_u'(left, right) { - return Module['_BinaryenBinary'](module, Module['ExtMulLowUVecI32x4'], left, right); - }, - 'extmul_high_i16x8_u'(left, right) { - return Module['_BinaryenBinary'](module, Module['ExtMulHighUVecI32x4'], left, right); - }, - 'extadd_pairwise_i16x8_s'(value) { - return Module['_BinaryenUnary'](module, Module['ExtAddPairwiseSVecI16x8ToI32x4'], value); - }, - 'extadd_pairwise_i16x8_u'(value) { - return Module['_BinaryenUnary'](module, Module['ExtAddPairwiseUVecI16x8ToI32x4'], value); - }, - 'trunc_sat_f32x4_s'(value) { - return Module['_BinaryenUnary'](module, Module['TruncSatSVecF32x4ToVecI32x4'], value); - }, - 'trunc_sat_f32x4_u'(value) { - return Module['_BinaryenUnary'](module, Module['TruncSatUVecF32x4ToVecI32x4'], value); - }, - 'extend_low_i16x8_s'(value) { - return Module['_BinaryenUnary'](module, Module['ExtendLowSVecI16x8ToVecI32x4'], value); - }, - 'extend_high_i16x8_s'(value) { - return Module['_BinaryenUnary'](module, Module['ExtendHighSVecI16x8ToVecI32x4'], value); - }, - 'extend_low_i16x8_u'(value) { - return Module['_BinaryenUnary'](module, Module['ExtendLowUVecI16x8ToVecI32x4'], value); - }, - 'extend_high_i16x8_u'(value) { - return Module['_BinaryenUnary'](module, Module['ExtendHighUVecI16x8ToVecI32x4'], value); - }, - 'trunc_sat_f64x2_s_zero'(value) { - return Module['_BinaryenUnary'](module, Module['TruncSatZeroSVecF64x2ToVecI32x4'], value); - }, - 'trunc_sat_f64x2_u_zero'(value) { - return Module['_BinaryenUnary'](module, Module['TruncSatZeroUVecF64x2ToVecI32x4'], value); - }, - }; - - self['i64x2'] = { - 'splat'(value) { - return Module['_BinaryenUnary'](module, Module['SplatVecI64x2'], value); - }, - 'extract_lane'(vec, index) { - return Module['_BinaryenSIMDExtract'](module, Module['ExtractLaneVecI64x2'], vec, index); - }, - 'replace_lane'(vec, index, value) { - return Module['_BinaryenSIMDReplace'](module, Module['ReplaceLaneVecI64x2'], vec, index, value); - }, - 'eq'(left, right) { - return Module['_BinaryenBinary'](module, Module['EqVecI64x2'], left, right); - }, - 'ne'(left, right) { - return Module['_BinaryenBinary'](module, Module['NeVecI64x2'], left, right); - }, - 'lt_s'(left, right) { - return Module['_BinaryenBinary'](module, Module['LtSVecI64x2'], left, right); - }, - 'gt_s'(left, right) { - return Module['_BinaryenBinary'](module, Module['GtSVecI64x2'], left, right); - }, - 'le_s'(left, right) { - return Module['_BinaryenBinary'](module, Module['LeSVecI64x2'], left, right); - }, - 'ge_s'(left, right) { - return Module['_BinaryenBinary'](module, Module['GeSVecI64x2'], left, right); - }, - 'abs'(value) { - return Module['_BinaryenUnary'](module, Module['AbsVecI64x2'], value); - }, - 'neg'(value) { - return Module['_BinaryenUnary'](module, Module['NegVecI64x2'], value); - }, - 'all_true'(value) { - return Module['_BinaryenUnary'](module, Module['AllTrueVecI64x2'], value); - }, - 'bitmask'(value) { - return Module['_BinaryenUnary'](module, Module['BitmaskVecI64x2'], value); - }, - 'shl'(vec, shift) { - return Module['_BinaryenSIMDShift'](module, Module['ShlVecI64x2'], vec, shift); - }, - 'shr_s'(vec, shift) { - return Module['_BinaryenSIMDShift'](module, Module['ShrSVecI64x2'], vec, shift); - }, - 'shr_u'(vec, shift) { - return Module['_BinaryenSIMDShift'](module, Module['ShrUVecI64x2'], vec, shift); - }, - 'add'(left, right) { - return Module['_BinaryenBinary'](module, Module['AddVecI64x2'], left, right); - }, - 'sub'(left, right) { - return Module['_BinaryenBinary'](module, Module['SubVecI64x2'], left, right); - }, - 'mul'(left, right) { - return Module['_BinaryenBinary'](module, Module['MulVecI64x2'], left, right); - }, - 'extmul_low_i32x4_s'(left, right) { - return Module['_BinaryenBinary'](module, Module['ExtMulLowSVecI64x2'], left, right); - }, - 'extmul_high_i32x4_s'(left, right) { - return Module['_BinaryenBinary'](module, Module['ExtMulHighSVecI64x2'], left, right); - }, - 'extmul_low_i32x4_u'(left, right) { - return Module['_BinaryenBinary'](module, Module['ExtMulLowUVecI64x2'], left, right); - }, - 'extmul_high_i32x4_u'(left, right) { - return Module['_BinaryenBinary'](module, Module['ExtMulHighUVecI64x2'], left, right); - }, - 'extend_low_i32x4_s'(value) { - return Module['_BinaryenUnary'](module, Module['ExtendLowSVecI32x4ToVecI64x2'], value); - }, - 'extend_high_i32x4_s'(value) { - return Module['_BinaryenUnary'](module, Module['ExtendHighSVecI32x4ToVecI64x2'], value); - }, - 'extend_low_i32x4_u'(value) { - return Module['_BinaryenUnary'](module, Module['ExtendLowUVecI32x4ToVecI64x2'], value); - }, - 'extend_high_i32x4_u'(value) { - return Module['_BinaryenUnary'](module, Module['ExtendHighUVecI32x4ToVecI64x2'], value); - }, - }; - - self['f32x4'] = { - 'splat'(value) { - return Module['_BinaryenUnary'](module, Module['SplatVecF32x4'], value); - }, - 'extract_lane'(vec, index) { - return Module['_BinaryenSIMDExtract'](module, Module['ExtractLaneVecF32x4'], vec, index); - }, - 'replace_lane'(vec, index, value) { - return Module['_BinaryenSIMDReplace'](module, Module['ReplaceLaneVecF32x4'], vec, index, value); - }, - 'eq'(left, right) { - return Module['_BinaryenBinary'](module, Module['EqVecF32x4'], left, right); - }, - 'ne'(left, right) { - return Module['_BinaryenBinary'](module, Module['NeVecF32x4'], left, right); - }, - 'lt'(left, right) { - return Module['_BinaryenBinary'](module, Module['LtVecF32x4'], left, right); - }, - 'gt'(left, right) { - return Module['_BinaryenBinary'](module, Module['GtVecF32x4'], left, right); - }, - 'le'(left, right) { - return Module['_BinaryenBinary'](module, Module['LeVecF32x4'], left, right); - }, - 'ge'(left, right) { - return Module['_BinaryenBinary'](module, Module['GeVecF32x4'], left, right); - }, - 'abs'(value) { - return Module['_BinaryenUnary'](module, Module['AbsVecF32x4'], value); - }, - 'neg'(value) { - return Module['_BinaryenUnary'](module, Module['NegVecF32x4'], value); - }, - 'sqrt'(value) { - return Module['_BinaryenUnary'](module, Module['SqrtVecF32x4'], value); - }, - 'add'(left, right) { - return Module['_BinaryenBinary'](module, Module['AddVecF32x4'], left, right); - }, - 'sub'(left, right) { - return Module['_BinaryenBinary'](module, Module['SubVecF32x4'], left, right); - }, - 'mul'(left, right) { - return Module['_BinaryenBinary'](module, Module['MulVecF32x4'], left, right); - }, - 'div'(left, right) { - return Module['_BinaryenBinary'](module, Module['DivVecF32x4'], left, right); - }, - 'min'(left, right) { - return Module['_BinaryenBinary'](module, Module['MinVecF32x4'], left, right); - }, - 'max'(left, right) { - return Module['_BinaryenBinary'](module, Module['MaxVecF32x4'], left, right); - }, - 'pmin'(left, right) { - return Module['_BinaryenBinary'](module, Module['PMinVecF32x4'], left, right); - }, - 'pmax'(left, right) { - return Module['_BinaryenBinary'](module, Module['PMaxVecF32x4'], left, right); - }, - 'ceil'(value) { - return Module['_BinaryenUnary'](module, Module['CeilVecF32x4'], value); - }, - 'floor'(value) { - return Module['_BinaryenUnary'](module, Module['FloorVecF32x4'], value); - }, - 'trunc'(value) { - return Module['_BinaryenUnary'](module, Module['TruncVecF32x4'], value); - }, - 'nearest'(value) { - return Module['_BinaryenUnary'](module, Module['NearestVecF32x4'], value); - }, - 'convert_i32x4_s'(value) { - return Module['_BinaryenUnary'](module, Module['ConvertSVecI32x4ToVecF32x4'], value); - }, - 'convert_i32x4_u'(value) { - return Module['_BinaryenUnary'](module, Module['ConvertUVecI32x4ToVecF32x4'], value); - }, - 'demote_f64x2_zero'(value) { - return Module['_BinaryenUnary'](module, Module['DemoteZeroVecF64x2ToVecF32x4'], value); - }, - }; - - self['f64x2'] = { - 'splat'(value) { - return Module['_BinaryenUnary'](module, Module['SplatVecF64x2'], value); - }, - 'extract_lane'(vec, index) { - return Module['_BinaryenSIMDExtract'](module, Module['ExtractLaneVecF64x2'], vec, index); - }, - 'replace_lane'(vec, index, value) { - return Module['_BinaryenSIMDReplace'](module, Module['ReplaceLaneVecF64x2'], vec, index, value); - }, - 'eq'(left, right) { - return Module['_BinaryenBinary'](module, Module['EqVecF64x2'], left, right); - }, - 'ne'(left, right) { - return Module['_BinaryenBinary'](module, Module['NeVecF64x2'], left, right); - }, - 'lt'(left, right) { - return Module['_BinaryenBinary'](module, Module['LtVecF64x2'], left, right); - }, - 'gt'(left, right) { - return Module['_BinaryenBinary'](module, Module['GtVecF64x2'], left, right); - }, - 'le'(left, right) { - return Module['_BinaryenBinary'](module, Module['LeVecF64x2'], left, right); - }, - 'ge'(left, right) { - return Module['_BinaryenBinary'](module, Module['GeVecF64x2'], left, right); - }, - 'abs'(value) { - return Module['_BinaryenUnary'](module, Module['AbsVecF64x2'], value); - }, - 'neg'(value) { - return Module['_BinaryenUnary'](module, Module['NegVecF64x2'], value); - }, - 'sqrt'(value) { - return Module['_BinaryenUnary'](module, Module['SqrtVecF64x2'], value); - }, - 'add'(left, right) { - return Module['_BinaryenBinary'](module, Module['AddVecF64x2'], left, right); - }, - 'sub'(left, right) { - return Module['_BinaryenBinary'](module, Module['SubVecF64x2'], left, right); - }, - 'mul'(left, right) { - return Module['_BinaryenBinary'](module, Module['MulVecF64x2'], left, right); - }, - 'div'(left, right) { - return Module['_BinaryenBinary'](module, Module['DivVecF64x2'], left, right); - }, - 'min'(left, right) { - return Module['_BinaryenBinary'](module, Module['MinVecF64x2'], left, right); - }, - 'max'(left, right) { - return Module['_BinaryenBinary'](module, Module['MaxVecF64x2'], left, right); - }, - 'pmin'(left, right) { - return Module['_BinaryenBinary'](module, Module['PMinVecF64x2'], left, right); - }, - 'pmax'(left, right) { - return Module['_BinaryenBinary'](module, Module['PMaxVecF64x2'], left, right); - }, - 'ceil'(value) { - return Module['_BinaryenUnary'](module, Module['CeilVecF64x2'], value); - }, - 'floor'(value) { - return Module['_BinaryenUnary'](module, Module['FloorVecF64x2'], value); - }, - 'trunc'(value) { - return Module['_BinaryenUnary'](module, Module['TruncVecF64x2'], value); - }, - 'nearest'(value) { - return Module['_BinaryenUnary'](module, Module['NearestVecF64x2'], value); - }, - 'convert_low_i32x4_s'(value) { - return Module['_BinaryenUnary'](module, Module['ConvertLowSVecI32x4ToVecF64x2'], value); - }, - 'convert_low_i32x4_u'(value) { - return Module['_BinaryenUnary'](module, Module['ConvertLowUVecI32x4ToVecF64x2'], value); - }, - 'promote_low_f32x4'(value) { - return Module['_BinaryenUnary'](module, Module['PromoteLowVecF32x4ToVecF64x2'], value); - }, - }; - - self['funcref'] = { - 'pop'() { - return Module['_BinaryenPop'](module, Module['funcref']); - } - }; - - self['externref'] = { - 'pop'() { - return Module['_BinaryenPop'](module, Module['externref']); - } - }; - - self['anyref'] = { - 'pop'() { - return Module['_BinaryenPop'](module, Module['anyref']); - } - }; - - self['eqref'] = { - 'pop'() { - return Module['_BinaryenPop'](module, Module['eqref']); - } - }; - - self['i31ref'] = { - 'pop'() { - return Module['_BinaryenPop'](module, Module['i31ref']); - } - }; - - self['structref'] = { - 'pop'() { - return Module['_BinaryenPop'](module, Module['structref']); - } - }; - - self['stringref'] = { - 'pop'() { - return Module['_BinaryenPop'](module, Module['stringref']); - } - }; - - self['stringview_wtf8'] = { - 'pop'() { - return Module['_BinaryenPop'](module, Module['stringview_wtf8']); - } - }; - - self['stringview_wtf16'] = { - 'pop'() { - return Module['_BinaryenPop'](module, Module['stringview_wtf16']); - } - }; - - self['stringview_iter'] = { - 'pop'() { - return Module['_BinaryenPop'](module, Module['stringview_iter']); - } - }; - - self['ref'] = { - 'null'(type) { - return Module['_BinaryenRefNull'](module, type); - }, - 'is_null'(value) { - return Module['_BinaryenRefIsNull'](module, value); - }, - 'as_non_null'(value) { - return Module['_BinaryenRefAs'](module, Module['RefAsNonNull'], value); - }, - 'func'(func, type) { - return preserveStack(() => Module['_BinaryenRefFunc'](module, strToStack(func), type)); - }, - 'i31'(value) { - return Module['_BinaryenRefI31'](module, value); - }, - 'eq'(left, right) { - return Module['_BinaryenRefEq'](module, left, right); - } - }; - - self['select'] = function(condition, ifTrue, ifFalse, type) { - return Module['_BinaryenSelect'](module, condition, ifTrue, ifFalse, typeof type !== 'undefined' ? type : Module['auto']); - }; - self['drop'] = function(value) { - return Module['_BinaryenDrop'](module, value); - }; - self['return'] = function(value) { - return Module['_BinaryenReturn'](module, value); - }; - self['nop'] = function() { - return Module['_BinaryenNop'](module); - }; - self['unreachable'] = function() { - return Module['_BinaryenUnreachable'](module); - }; - - self['atomic'] = { - 'fence'() { - return Module['_BinaryenAtomicFence'](module); - } - }; - - self['try'] = function(name, body, catchTags, catchBodies, delegateTarget) { - return preserveStack(() => - Module['_BinaryenTry'](module, name ? strToStack(name) : 0, body, i32sToStack(catchTags.map(strToStack)), catchTags.length, i32sToStack(catchBodies), catchBodies.length, delegateTarget ? strToStack(delegateTarget) : 0)); - }; - self['throw'] = function(tag, operands) { - return preserveStack(() => Module['_BinaryenThrow'](module, strToStack(tag), i32sToStack(operands), operands.length)); - }; - self['rethrow'] = function(target) { - return Module['_BinaryenRethrow'](module, strToStack(target)); - }; - - self['tuple'] = { - 'make'(elements) { - return preserveStack(() => Module['_BinaryenTupleMake'](module, i32sToStack(elements), elements.length)); - }, - 'extract'(tuple, index) { - return Module['_BinaryenTupleExtract'](module, tuple, index); - } - }; - - self['i31'] = { - 'get_s'(i31) { - return Module['_BinaryenI31Get'](module, i31, 1); - }, - 'get_u'(i31) { - return Module['_BinaryenI31Get'](module, i31, 0); - } - }; - - // TODO: extern.internalize - // TODO: extern.externalize - // TODO: ref.test - // TODO: ref.cast - // TODO: br_on_* - // TODO: struct.* - // TODO: array.* - // TODO: string.* - // TODO: stringview_wtf8.* - // TODO: stringview_wtf16.* - // TODO: stringview_iter.* - - // 'Module' operations - self['addFunction'] = function(name, params, results, varTypes, body) { - return preserveStack(() => - Module['_BinaryenAddFunction'](module, strToStack(name), params, results, i32sToStack(varTypes), varTypes.length, body) - ); - }; - self['getFunction'] = function(name) { - return preserveStack(() => Module['_BinaryenGetFunction'](module, strToStack(name))); - }; - self['removeFunction'] = function(name) { - return preserveStack(() => Module['_BinaryenRemoveFunction'](module, strToStack(name))); - }; - self['addGlobal'] = function(name, type, mutable, init) { - return preserveStack(() => Module['_BinaryenAddGlobal'](module, strToStack(name), type, mutable, init)); - } - self['getGlobal'] = function(name) { - return preserveStack(() => Module['_BinaryenGetGlobal'](module, strToStack(name))); - }; - self['addTable'] = function(table, initial, maximum, type = Module['_BinaryenTypeFuncref']()) { - return preserveStack(() => Module['_BinaryenAddTable'](module, strToStack(table), initial, maximum, type)); - } - self['getTable'] = function(name) { - return preserveStack(() => Module['_BinaryenGetTable'](module, strToStack(name))); - }; - self['addActiveElementSegment'] = function(table, name, funcNames, offset = self['i32']['const'](0)) { - return preserveStack(() => Module['_BinaryenAddActiveElementSegment']( - module, - strToStack(table), - strToStack(name), - i32sToStack(funcNames.map(strToStack)), - funcNames.length, - offset - )); - }; - self['addPassiveElementSegment'] = function(name, funcNames) { - return preserveStack(() => Module['_BinaryenAddPassiveElementSegment']( - module, - strToStack(name), - i32sToStack(funcNames.map(strToStack)), - funcNames.length - )); - }; - self['getElementSegment'] = function(name) { - return preserveStack(() => Module['_BinaryenGetElementSegment'](module, strToStack(name))); - }; - self['getTableSegments'] = function(table) { - var numElementSegments = Module['_BinaryenGetNumElementSegments'](module); - var tableName = UTF8ToString(Module['_BinaryenTableGetName'](table)); - var ret = []; - for (var i = 0; i < numElementSegments; i++) { - var segment = Module['_BinaryenGetElementSegmentByIndex'](module, i); - var elemTableName = UTF8ToString(Module['_BinaryenElementSegmentGetTable'](segment)); - if (tableName === elemTableName) { - ret.push(segment); - } - } - return ret; - } - self['removeGlobal'] = function(name) { - return preserveStack(() => Module['_BinaryenRemoveGlobal'](module, strToStack(name))); - } - self['removeTable'] = function(name) { - return preserveStack(() => Module['_BinaryenRemoveTable'](module, strToStack(name))); - }; - self['removeElementSegment'] = function(name) { - return preserveStack(() => Module['_BinaryenRemoveElementSegment'](module, strToStack(name))); - }; - self['addTag'] = function(name, params, results) { - return preserveStack(() => Module['_BinaryenAddTag'](module, strToStack(name), params, results)); - }; - self['getTag'] = function(name) { - return preserveStack(() => Module['_BinaryenGetTag'](module, strToStack(name))); - }; - self['removeTag'] = function(name) { - return preserveStack(() => Module['_BinaryenRemoveTag'](module, strToStack(name))); - }; - self['addFunctionImport'] = function(internalName, externalModuleName, externalBaseName, params, results) { - return preserveStack(() => - Module['_BinaryenAddFunctionImport'](module, strToStack(internalName), strToStack(externalModuleName), strToStack(externalBaseName), params, results) - ); - }; - self['addTableImport'] = function(internalName, externalModuleName, externalBaseName) { - return preserveStack(() => - Module['_BinaryenAddTableImport'](module, strToStack(internalName), strToStack(externalModuleName), strToStack(externalBaseName)) - ); - }; - self['addMemoryImport'] = function(internalName, externalModuleName, externalBaseName, shared) { - return preserveStack(() => - Module['_BinaryenAddMemoryImport'](module, strToStack(internalName), strToStack(externalModuleName), strToStack(externalBaseName), shared) - ); - }; - self['addGlobalImport'] = function(internalName, externalModuleName, externalBaseName, globalType, mutable) { - return preserveStack(() => - Module['_BinaryenAddGlobalImport'](module, strToStack(internalName), strToStack(externalModuleName), strToStack(externalBaseName), globalType, mutable) - ); - }; - self['addTagImport'] = function(internalName, externalModuleName, externalBaseName, params, results) { - return preserveStack(() => - Module['_BinaryenAddTagImport'](module, strToStack(internalName), strToStack(externalModuleName), strToStack(externalBaseName), params, results) - ); - }; - self['addExport'] = // deprecated - self['addFunctionExport'] = function(internalName, externalName) { - return preserveStack(() => Module['_BinaryenAddFunctionExport'](module, strToStack(internalName), strToStack(externalName))); - }; - self['addTableExport'] = function(internalName, externalName) { - return preserveStack(() => Module['_BinaryenAddTableExport'](module, strToStack(internalName), strToStack(externalName))); - }; - self['addMemoryExport'] = function(internalName, externalName) { - return preserveStack(() => Module['_BinaryenAddMemoryExport'](module, strToStack(internalName), strToStack(externalName))); - }; - self['addGlobalExport'] = function(internalName, externalName) { - return preserveStack(() => Module['_BinaryenAddGlobalExport'](module, strToStack(internalName), strToStack(externalName))); - }; - self['addTagExport'] = function(internalName, externalName) { - return preserveStack(() => Module['_BinaryenAddTagExport'](module, strToStack(internalName), strToStack(externalName))); - }; - self['removeExport'] = function(externalName) { - return preserveStack(() => Module['_BinaryenRemoveExport'](module, strToStack(externalName))); - }; - self['setMemory'] = function(initial, maximum, exportName, segments = [], shared = false, memory64 = false, internalName = null) { - // segments are assumed to be { passive: bool, offset: expression ref, data: array of 8-bit data } - return preserveStack(() => { - const segmentsLen = segments.length; - const names = new Array(segmentsLen); - const datas = new Array(segmentsLen); - const lengths = new Array(segmentsLen); - const passives = new Array(segmentsLen); - const offsets = new Array(segmentsLen); - for (let i = 0; i < segmentsLen; i++) { - const { name, data, offset, passive } = segments[i]; - names[i] = name ? strToStack(name) : null; - datas[i] = _malloc(data.length); - HEAP8.set(data, datas[i]); - lengths[i] = data.length; - passives[i] = passive; - offsets[i] = offset; - } - const ret = Module['_BinaryenSetMemory']( - module, initial, maximum, strToStack(exportName), - i32sToStack(names), - i32sToStack(datas), - i8sToStack(passives), - i32sToStack(offsets), - i32sToStack(lengths), - segmentsLen, - shared, - memory64, - strToStack(internalName) - ); - for (let i = 0; i < segmentsLen; i++) { - _free(datas[i]); - } - return ret; - }); - }; - self['hasMemory'] = function() { - return Boolean(Module['_BinaryenHasMemory'](module)); - }; - self['getMemoryInfo'] = function(name) { - var memoryInfo = { - 'module': UTF8ToString(Module['_BinaryenMemoryImportGetModule'](module, strToStack(name))), - 'base': UTF8ToString(Module['_BinaryenMemoryImportGetBase'](module, strToStack(name))), - 'initial': Module['_BinaryenMemoryGetInitial'](module, strToStack(name)), - 'shared': Boolean(Module['_BinaryenMemoryIsShared'](module, strToStack(name))), - 'is64': Boolean(Module['_BinaryenMemoryIs64'](module, strToStack(name))), - }; - if (Module['_BinaryenMemoryHasMax'](module, strToStack(name))) { - memoryInfo['max'] = Module['_BinaryenMemoryGetMax'](module, strToStack(name)); - } - return memoryInfo; - }; - self['getNumMemorySegments'] = function() { - return Module['_BinaryenGetNumMemorySegments'](module); - }; - self['getMemorySegmentInfo'] = function(name) { - const passive = Boolean(Module['_BinaryenGetMemorySegmentPassive'](module, strToStack(name))); - let offset = null; - if (!passive) { - offset = Module['_BinaryenGetMemorySegmentByteOffset'](module, strToStack(name)); - } - return { - 'offset': offset, - 'data': (function(){ - const size = Module['_BinaryenGetMemorySegmentByteLength'](module, strToStack(name)); - const ptr = _malloc(size); - Module['_BinaryenCopyMemorySegmentData'](module, strToStack(name), ptr); - const res = new Uint8Array(size); - res.set(HEAP8.subarray(ptr, ptr + size)); - _free(ptr); - return res.buffer; - })(), - 'passive': passive - }; - }; - self['setStart'] = function(start) { - return Module['_BinaryenSetStart'](module, start); - }; - self['getFeatures'] = function() { - return Module['_BinaryenModuleGetFeatures'](module); - }; - self['setFeatures'] = function(features) { - Module['_BinaryenModuleSetFeatures'](module, features); - }; - self['addCustomSection'] = function(name, contents) { - return preserveStack(() => - Module['_BinaryenAddCustomSection'](module, strToStack(name), i8sToStack(contents), contents.length) - ); - }; - self['getExport'] = function(externalName) { - return preserveStack(() => Module['_BinaryenGetExport'](module, strToStack(externalName))); - }; - self['getNumExports'] = function() { - return Module['_BinaryenGetNumExports'](module); - }; - self['getExportByIndex'] = function(index) { - return Module['_BinaryenGetExportByIndex'](module, index); - }; - self['getNumFunctions'] = function() { - return Module['_BinaryenGetNumFunctions'](module); - }; - self['getFunctionByIndex'] = function(index) { - return Module['_BinaryenGetFunctionByIndex'](module, index); - }; - self['getNumGlobals'] = function() { - return Module['_BinaryenGetNumGlobals'](module); - }; - self['getNumTables'] = function() { - return Module['_BinaryenGetNumTables'](module); - }; - self['getNumElementSegments'] = function() { - return Module['_BinaryenGetNumElementSegments'](module); - }; - self['getGlobalByIndex'] = function(index) { - return Module['_BinaryenGetGlobalByIndex'](module, index); - }; - self['getTableByIndex'] = function(index) { - return Module['_BinaryenGetTableByIndex'](module, index); - }; - self['getElementSegmentByIndex'] = function(index) { - return Module['_BinaryenGetElementSegmentByIndex'](module, index); - }; - self['emitText'] = function() { - let textPtr = Module['_BinaryenModuleAllocateAndWriteText'](module); - let text = UTF8ToString(textPtr); - if (textPtr) _free(textPtr); - return text; - }; - self['emitStackIR'] = function(optimize) { - let textPtr = Module['_BinaryenModuleAllocateAndWriteStackIR'](module, optimize); - let text = UTF8ToString(textPtr); - if (textPtr) _free(textPtr); - return text; - }; - self['emitAsmjs'] = function() { - const old = out; - let ret = ''; - out = x => { ret += x + '\n' }; - Module['_BinaryenModulePrintAsmjs'](module); - out = old; - return ret; - }; - self['validate'] = function() { - return Module['_BinaryenModuleValidate'](module); - }; - self['optimize'] = function() { - return Module['_BinaryenModuleOptimize'](module); - }; - self['optimizeFunction'] = function(func) { - if (typeof func === 'string') func = self['getFunction'](func); - return Module['_BinaryenFunctionOptimize'](func, module); - }; - self['runPasses'] = function(passes) { - return preserveStack(() => - Module['_BinaryenModuleRunPasses'](module, i32sToStack(passes.map(strToStack)), passes.length) - ); - }; - self['runPassesOnFunction'] = function(func, passes) { - if (typeof func === 'string') func = self['getFunction'](func); - return preserveStack(() => - Module['_BinaryenFunctionRunPasses'](func, module, i32sToStack(passes.map(strToStack)), passes.length) - ); - }; - self['autoDrop'] = function() { - return Module['_BinaryenModuleAutoDrop'](module); - }; - self['dispose'] = function() { - Module['_BinaryenModuleDispose'](module); - }; - self['emitBinary'] = function(sourceMapUrl) { - return preserveStack(() => { - const tempBuffer = stackAlloc(_BinaryenSizeofAllocateAndWriteResult()); - Module['_BinaryenModuleAllocateAndWrite'](tempBuffer, module, strToStack(sourceMapUrl)); - const binaryPtr = HEAPU32[ tempBuffer >>> 2 ]; - const binaryBytes = HEAPU32[(tempBuffer >>> 2) + 1]; - const sourceMapPtr = HEAPU32[(tempBuffer >>> 2) + 2]; - try { - const buffer = new Uint8Array(binaryBytes); - buffer.set(HEAPU8.subarray(binaryPtr, binaryPtr + binaryBytes)); - return typeof sourceMapUrl === 'undefined' - ? buffer - : { 'binary': buffer, 'sourceMap': UTF8ToString(sourceMapPtr) }; - } finally { - _free(binaryPtr); - if (sourceMapPtr) _free(sourceMapPtr); - } - }); - }; - self['interpret'] = function() { - return Module['_BinaryenModuleInterpret'](module); - }; - self['addDebugInfoFileName'] = function(filename) { - return preserveStack(() => Module['_BinaryenModuleAddDebugInfoFileName'](module, strToStack(filename))); - }; - self['getDebugInfoFileName'] = function(index) { - return UTF8ToString(Module['_BinaryenModuleGetDebugInfoFileName'](module, index)); - }; - self['setDebugLocation'] = function(func, expr, fileIndex, lineNumber, columnNumber) { - return Module['_BinaryenFunctionSetDebugLocation'](func, expr, fileIndex, lineNumber, columnNumber); - }; - self['copyExpression'] = function(expr) { - return Module['_BinaryenExpressionCopy'](expr, module); - }; - - return self; -} -Module['wrapModule'] = wrapModule; - -// 'Relooper' interface -/** @constructor */ -Module['Relooper'] = function(module) { - assert(module && typeof module === 'object' && module['ptr'] && module['block'] && module['if']); // guard against incorrect old API usage - const relooper = Module['_RelooperCreate'](module['ptr']); - this['ptr'] = relooper; - - this['addBlock'] = function(code) { - return Module['_RelooperAddBlock'](relooper, code); - }; - this['addBranch'] = function(from, to, condition, code) { - return Module['_RelooperAddBranch'](from, to, condition, code); - }; - this['addBlockWithSwitch'] = function(code, condition) { - return Module['_RelooperAddBlockWithSwitch'](relooper, code, condition); - }; - this['addBranchForSwitch'] = function(from, to, indexes, code) { - return preserveStack(() => Module['_RelooperAddBranchForSwitch'](from, to, i32sToStack(indexes), indexes.length, code)); - }; - this['renderAndDispose'] = function(entry, labelHelper) { - return Module['_RelooperRenderAndDispose'](relooper, entry, labelHelper); - }; -}; - -// 'ExpressionRunner' interface -/** @constructor */ -Module['ExpressionRunner'] = function(module, flags, maxDepth, maxLoopIterations) { - const runner = Module['_ExpressionRunnerCreate'](module['ptr'], flags, maxDepth, maxLoopIterations); - this['ptr'] = runner; - - this['setLocalValue'] = function(index, valueExpr) { - return Boolean(Module['_ExpressionRunnerSetLocalValue'](runner, index, valueExpr)); - }; - this['setGlobalValue'] = function(name, valueExpr) { - return preserveStack(() => Boolean(Module['_ExpressionRunnerSetGlobalValue'](runner, strToStack(name), valueExpr))); - }; - this['runAndDispose'] = function(expr) { - return Module['_ExpressionRunnerRunAndDispose'](runner, expr); - }; -}; - -function getAllNested(ref, numFn, getFn) { - const num = numFn(ref); - const ret = new Array(num); - for (let i = 0; i < num; ++i) ret[i] = getFn(ref, i); - return ret; -} - -function setAllNested(ref, values, numFn, setFn, appendFn, removeFn) { - const num = values.length; - let prevNum = numFn(ref); - let index = 0; - while (index < num) { - if (index < prevNum) { - setFn(ref, index, values[index]); - } else { - appendFn(ref, values[index]); - } - ++index; - } - while (prevNum > index) { - removeFn(ref, --prevNum); - } -} - -// Gets the specific id of an 'Expression' -Module['getExpressionId'] = function(expr) { - return Module['_BinaryenExpressionGetId'](expr); -}; - -// Gets the result type of an 'Expression' -Module['getExpressionType'] = function(expr) { - return Module['_BinaryenExpressionGetType'](expr); -}; - -// Obtains information about an 'Expression' -Module['getExpressionInfo'] = function(expr) { - const id = Module['_BinaryenExpressionGetId'](expr); - const type = Module['_BinaryenExpressionGetType'](expr); - switch (id) { - case Module['BlockId']: - return { - 'id': id, - 'type': type, - 'name': UTF8ToString(Module['_BinaryenBlockGetName'](expr)), - 'children': getAllNested(expr, Module['_BinaryenBlockGetNumChildren'], Module['_BinaryenBlockGetChildAt']) - }; - case Module['IfId']: - return { - 'id': id, - 'type': type, - 'condition': Module['_BinaryenIfGetCondition'](expr), - 'ifTrue': Module['_BinaryenIfGetIfTrue'](expr), - 'ifFalse': Module['_BinaryenIfGetIfFalse'](expr) - }; - case Module['LoopId']: - return { - 'id': id, - 'type': type, - 'name': UTF8ToString(Module['_BinaryenLoopGetName'](expr)), - 'body': Module['_BinaryenLoopGetBody'](expr) - }; - case Module['BreakId']: - return { - 'id': id, - 'type': type, - 'name': UTF8ToString(Module['_BinaryenBreakGetName'](expr)), - 'condition': Module['_BinaryenBreakGetCondition'](expr), - 'value': Module['_BinaryenBreakGetValue'](expr) - }; - case Module['SwitchId']: - return { - 'id': id, - 'type': type, - // Do not pass the index as the second parameter to UTF8ToString as that will cut off the string. - 'names': getAllNested(expr, Module['_BinaryenSwitchGetNumNames'], Module['_BinaryenSwitchGetNameAt']).map(p => UTF8ToString(p)), - 'defaultName': UTF8ToString(Module['_BinaryenSwitchGetDefaultName'](expr)), - 'condition': Module['_BinaryenSwitchGetCondition'](expr), - 'value': Module['_BinaryenSwitchGetValue'](expr) - }; - case Module['CallId']: - return { - 'id': id, - 'type': type, - 'isReturn': Boolean(Module['_BinaryenCallIsReturn'](expr)), - 'target': UTF8ToString(Module['_BinaryenCallGetTarget'](expr)), - 'operands': getAllNested(expr, Module[ '_BinaryenCallGetNumOperands'], Module['_BinaryenCallGetOperandAt']) - }; - case Module['CallIndirectId']: - return { - 'id': id, - 'type': type, - 'isReturn': Boolean(Module['_BinaryenCallIndirectIsReturn'](expr)), - 'target': Module['_BinaryenCallIndirectGetTarget'](expr), - 'table': Module['_BinaryenCallIndirectGetTable'](expr), - 'operands': getAllNested(expr, Module['_BinaryenCallIndirectGetNumOperands'], Module['_BinaryenCallIndirectGetOperandAt']) - }; - case Module['LocalGetId']: - return { - 'id': id, - 'type': type, - 'index': Module['_BinaryenLocalGetGetIndex'](expr) - }; - case Module['LocalSetId']: - return { - 'id': id, - 'type': type, - 'isTee': Boolean(Module['_BinaryenLocalSetIsTee'](expr)), - 'index': Module['_BinaryenLocalSetGetIndex'](expr), - 'value': Module['_BinaryenLocalSetGetValue'](expr) - }; - case Module['GlobalGetId']: - return { - 'id': id, - 'type': type, - 'name': UTF8ToString(Module['_BinaryenGlobalGetGetName'](expr)) - }; - case Module['GlobalSetId']: - return { - 'id': id, - 'type': type, - 'name': UTF8ToString(Module['_BinaryenGlobalSetGetName'](expr)), - 'value': Module['_BinaryenGlobalSetGetValue'](expr) - }; - case Module['TableGetId']: - return { - 'id': id, - 'type': type, - 'table': UTF8ToString(Module['_BinaryenTableGetGetTable'](expr)), - 'index': Module['_BinaryenTableGetGetIndex'](expr) - }; - case Module['TableSetId']: - return { - 'id': id, - 'type': type, - 'table': UTF8ToString(Module['_BinaryenTableSetGetTable'](expr)), - 'index': Module['_BinaryenTableSetGetIndex'](expr), - 'value': Module['_BinaryenTableSetGetValue'](expr) - }; - case Module['TableSizeId']: - return { - 'id': id, - 'type': type, - 'table': UTF8ToString(Module['_BinaryenTableSizeGetTable'](expr)), - }; - case Module['TableGrowId']: - return { - 'id': id, - 'type': type, - 'table': UTF8ToString(Module['_BinaryenTableGrowGetTable'](expr)), - 'value': Module['_BinaryenTableGrowGetValue'](expr), - 'delta': Module['_BinaryenTableGrowGetDelta'](expr), - }; - case Module['LoadId']: - return { - 'id': id, - 'type': type, - 'isAtomic': Boolean(Module['_BinaryenLoadIsAtomic'](expr)), - 'isSigned': Boolean(Module['_BinaryenLoadIsSigned'](expr)), - 'offset': Module['_BinaryenLoadGetOffset'](expr), - 'bytes': Module['_BinaryenLoadGetBytes'](expr), - 'align': Module['_BinaryenLoadGetAlign'](expr), - 'ptr': Module['_BinaryenLoadGetPtr'](expr) - }; - case Module['StoreId']: - return { - 'id': id, - 'type': type, - 'isAtomic': Boolean(Module['_BinaryenStoreIsAtomic'](expr)), - 'offset': Module['_BinaryenStoreGetOffset'](expr), - 'bytes': Module['_BinaryenStoreGetBytes'](expr), - 'align': Module['_BinaryenStoreGetAlign'](expr), - 'ptr': Module['_BinaryenStoreGetPtr'](expr), - 'value': Module['_BinaryenStoreGetValue'](expr) - }; - case Module['ConstId']: { - let value; - switch (type) { - case Module['i32']: value = Module['_BinaryenConstGetValueI32'](expr); break; - case Module['i64']: value = { - 'low': Module['_BinaryenConstGetValueI64Low'](expr), - 'high': Module['_BinaryenConstGetValueI64High'](expr) - }; break; - case Module['f32']: value = Module['_BinaryenConstGetValueF32'](expr); break; - case Module['f64']: value = Module['_BinaryenConstGetValueF64'](expr); break; - case Module['v128']: { - preserveStack(() => { - const tempBuffer = stackAlloc(16); - Module['_BinaryenConstGetValueV128'](expr, tempBuffer); - value = new Array(16); - for (let i = 0; i < 16; i++) { - value[i] = HEAPU8[tempBuffer + i]; - } - }); - break; - } - default: throw Error('unexpected type: ' + type); - } - return { - 'id': id, - 'type': type, - 'value': value - }; - } - case Module['UnaryId']: - return { - 'id': id, - 'type': type, - 'op': Module['_BinaryenUnaryGetOp'](expr), - 'value': Module['_BinaryenUnaryGetValue'](expr) - }; - case Module['BinaryId']: - return { - 'id': id, - 'type': type, - 'op': Module['_BinaryenBinaryGetOp'](expr), - 'left': Module['_BinaryenBinaryGetLeft'](expr), - 'right': Module['_BinaryenBinaryGetRight'](expr) - }; - case Module['SelectId']: - return { - 'id': id, - 'type': type, - 'ifTrue': Module['_BinaryenSelectGetIfTrue'](expr), - 'ifFalse': Module['_BinaryenSelectGetIfFalse'](expr), - 'condition': Module['_BinaryenSelectGetCondition'](expr) - }; - case Module['DropId']: - return { - 'id': id, - 'type': type, - 'value': Module['_BinaryenDropGetValue'](expr) - }; - case Module['ReturnId']: - return { - 'id': id, - 'type': type, - 'value': Module['_BinaryenReturnGetValue'](expr) - }; - case Module['NopId']: - case Module['UnreachableId']: - case Module['PopId']: - return { - 'id': id, - 'type': type - }; - case Module['MemorySizeId']: - return { - 'id': id, - 'type': type - }; - case Module['MemoryGrowId']: - return { - 'id': id, - 'type': type, - 'delta': Module['_BinaryenMemoryGrowGetDelta'](expr) - } - case Module['AtomicRMWId']: - return { - 'id': id, - 'type': type, - 'op': Module['_BinaryenAtomicRMWGetOp'](expr), - 'bytes': Module['_BinaryenAtomicRMWGetBytes'](expr), - 'offset': Module['_BinaryenAtomicRMWGetOffset'](expr), - 'ptr': Module['_BinaryenAtomicRMWGetPtr'](expr), - 'value': Module['_BinaryenAtomicRMWGetValue'](expr) - }; - case Module['AtomicCmpxchgId']: - return { - 'id': id, - 'type': type, - 'bytes': Module['_BinaryenAtomicCmpxchgGetBytes'](expr), - 'offset': Module['_BinaryenAtomicCmpxchgGetOffset'](expr), - 'ptr': Module['_BinaryenAtomicCmpxchgGetPtr'](expr), - 'expected': Module['_BinaryenAtomicCmpxchgGetExpected'](expr), - 'replacement': Module['_BinaryenAtomicCmpxchgGetReplacement'](expr) - }; - case Module['AtomicWaitId']: - return { - 'id': id, - 'type': type, - 'ptr': Module['_BinaryenAtomicWaitGetPtr'](expr), - 'expected': Module['_BinaryenAtomicWaitGetExpected'](expr), - 'timeout': Module['_BinaryenAtomicWaitGetTimeout'](expr), - 'expectedType': Module['_BinaryenAtomicWaitGetExpectedType'](expr) - }; - case Module['AtomicNotifyId']: - return { - 'id': id, - 'type': type, - 'ptr': Module['_BinaryenAtomicNotifyGetPtr'](expr), - 'notifyCount': Module['_BinaryenAtomicNotifyGetNotifyCount'](expr) - }; - case Module['AtomicFenceId']: - return { - 'id': id, - 'type': type, - 'order': Module['_BinaryenAtomicFenceGetOrder'](expr) - }; - case Module['SIMDExtractId']: - return { - 'id': id, - 'type': type, - 'op': Module['_BinaryenSIMDExtractGetOp'](expr), - 'vec': Module['_BinaryenSIMDExtractGetVec'](expr), - 'index': Module['_BinaryenSIMDExtractGetIndex'](expr) - }; - case Module['SIMDReplaceId']: - return { - 'id': id, - 'type': type, - 'op': Module['_BinaryenSIMDReplaceGetOp'](expr), - 'vec': Module['_BinaryenSIMDReplaceGetVec'](expr), - 'index': Module['_BinaryenSIMDReplaceGetIndex'](expr), - 'value': Module['_BinaryenSIMDReplaceGetValue'](expr) - }; - case Module['SIMDShuffleId']: - return preserveStack(() => { - const tempBuffer = stackAlloc(16); - Module['_BinaryenSIMDShuffleGetMask'](expr, tempBuffer); - const mask = new Array(16); - for (let i = 0; i < 16; i++) { - mask[i] = HEAPU8[tempBuffer + i]; - } - return { - 'id': id, - 'type': type, - 'left': Module['_BinaryenSIMDShuffleGetLeft'](expr), - 'right': Module['_BinaryenSIMDShuffleGetRight'](expr), - 'mask': mask - }; - }); - case Module['SIMDTernaryId']: - return { - 'id': id, - 'type': type, - 'op': Module['_BinaryenSIMDTernaryGetOp'](expr), - 'a': Module['_BinaryenSIMDTernaryGetA'](expr), - 'b': Module['_BinaryenSIMDTernaryGetB'](expr), - 'c': Module['_BinaryenSIMDTernaryGetC'](expr) - }; - case Module['SIMDShiftId']: - return { - 'id': id, - 'type': type, - 'op': Module['_BinaryenSIMDShiftGetOp'](expr), - 'vec': Module['_BinaryenSIMDShiftGetVec'](expr), - 'shift': Module['_BinaryenSIMDShiftGetShift'](expr) - }; - case Module['SIMDLoadId']: - return { - 'id': id, - 'type': type, - 'op': Module['_BinaryenSIMDLoadGetOp'](expr), - 'offset': Module['_BinaryenSIMDLoadGetOffset'](expr), - 'align': Module['_BinaryenSIMDLoadGetAlign'](expr), - 'ptr': Module['_BinaryenSIMDLoadGetPtr'](expr) - }; - case Module['SIMDLoadStoreLaneId']: - return { - 'id': id, - 'type': type, - 'op': Module['_BinaryenSIMDLoadStoreLaneGetOp'](expr), - 'offset': Module['_BinaryenSIMDLoadStoreLaneGetOffset'](expr), - 'align': Module['_BinaryenSIMDLoadStoreLaneGetAlign'](expr), - 'index': Module['_BinaryenSIMDLoadStoreLaneGetIndex'](expr), - 'ptr': Module['_BinaryenSIMDLoadStoreLaneGetPtr'](expr), - 'vec': Module['_BinaryenSIMDLoadStoreLaneGetVec'](expr) - }; - case Module['MemoryInitId']: - return { - 'id': id, - 'segment': UTF8ToString(Module['_BinaryenMemoryInitGetSegment'](expr)), - 'dest': Module['_BinaryenMemoryInitGetDest'](expr), - 'offset': Module['_BinaryenMemoryInitGetOffset'](expr), - 'size': Module['_BinaryenMemoryInitGetSize'](expr) - }; - case Module['DataDropId']: - return { - 'id': id, - 'segment': UTF8ToString(Module['_BinaryenDataDropGetSegment'](expr)), - }; - case Module['MemoryCopyId']: - return { - 'id': id, - 'dest': Module['_BinaryenMemoryCopyGetDest'](expr), - 'source': Module['_BinaryenMemoryCopyGetSource'](expr), - 'size': Module['_BinaryenMemoryCopyGetSize'](expr) - }; - case Module['MemoryFillId']: - return { - 'id': id, - 'dest': Module['_BinaryenMemoryFillGetDest'](expr), - 'value': Module['_BinaryenMemoryFillGetValue'](expr), - 'size': Module['_BinaryenMemoryFillGetSize'](expr) - }; - case Module['RefNullId']: - return { - 'id': id, - 'type': type - }; - case Module['RefIsNullId']: - return { - 'id': id, - 'type': type, - 'value': Module['_BinaryenRefIsNullGetValue'](expr) - }; - case Module['RefAsId']: - return { - 'id': id, - 'type': type, - 'op': Module['_BinaryenRefAsGetOp'](expr), - 'value': Module['_BinaryenRefAsGetValue'](expr) - }; - case Module['RefFuncId']: - return { - 'id': id, - 'type': type, - 'func': UTF8ToString(Module['_BinaryenRefFuncGetFunc'](expr)), - }; - case Module['RefEqId']: - return { - 'id': id, - 'type': type, - 'left': Module['_BinaryenRefEqGetLeft'](expr), - 'right': Module['_BinaryenRefEqGetRight'](expr) - }; - case Module['TryId']: - return { - 'id': id, - 'type': type, - 'name': UTF8ToString(Module['_BinaryenTryGetName'](expr)), - 'body': Module['_BinaryenTryGetBody'](expr), - 'catchTags': getAllNested(expr, Module['_BinaryenTryGetNumCatchTags'], Module['_BinaryenTryGetCatchTagAt']), - 'catchBodies': getAllNested(expr, Module['_BinaryenTryGetNumCatchBodies'], Module['_BinaryenTryGetCatchBodyAt']), - 'hasCatchAll': Module['_BinaryenTryHasCatchAll'](expr), - 'delegateTarget': UTF8ToString(Module['_BinaryenTryGetDelegateTarget'](expr)), - 'isDelegate': Module['_BinaryenTryIsDelegate'](expr) - }; - case Module['ThrowId']: - return { - 'id': id, - 'type': type, - 'tag': UTF8ToString(Module['_BinaryenThrowGetTag'](expr)), - 'operands': getAllNested(expr, Module['_BinaryenThrowGetNumOperands'], Module['_BinaryenThrowGetOperandAt']) - }; - case Module['RethrowId']: - return { - 'id': id, - 'type': type, - 'target': UTF8ToString(Module['_BinaryenRethrowGetTarget'](expr)) - }; - case Module['TupleMakeId']: - return { - 'id': id, - 'type': type, - 'operands': getAllNested(expr, Module['_BinaryenTupleMakeGetNumOperands'], Module['_BinaryenTupleMakeGetOperandAt']) - }; - case Module['TupleExtractId']: - return { - 'id': id, - 'type': type, - 'tuple': Module['_BinaryenTupleExtractGetTuple'](expr), - 'index': Module['_BinaryenTupleExtractGetIndex'](expr) - }; - case Module['RefI31Id']: - return { - 'id': id, - 'type': type, - 'value': Module['_BinaryenRefI31GetValue'](expr) - }; - case Module['I31GetId']: - return { - 'id': id, - 'type': type, - 'i31': Module['_BinaryenI31GetGetI31'](expr), - 'isSigned': Boolean(Module['_BinaryenI31GetIsSigned'](expr)) - }; - - default: - throw Error('unexpected id: ' + id); - } -}; - -// Gets the side effects of the specified expression -Module['getSideEffects'] = function(expr, module) { - assert(module); // guard against incorrect old API usage: a module must be - // provided here. - return Module['_BinaryenExpressionGetSideEffects'](expr, module['ptr']); -}; - -Module['createType'] = function(types) { - return preserveStack(() => Module['_BinaryenTypeCreate'](i32sToStack(types), types.length)); -}; - -Module['expandType'] = function(ty) { - return preserveStack(() => { - const numTypes = Module['_BinaryenTypeArity'](ty); - const array = stackAlloc(numTypes << 2); - Module['_BinaryenTypeExpand'](ty, array); - const types = new Array(numTypes); - for (let i = 0; i < numTypes; i++) { - types[i] = HEAPU32[(array >>> 2) + i]; - } - return types; - }); -}; - -// Obtains information about a 'Function' -Module['getFunctionInfo'] = function(func) { - return { - 'name': UTF8ToString(Module['_BinaryenFunctionGetName'](func)), - 'module': UTF8ToString(Module['_BinaryenFunctionImportGetModule'](func)), - 'base': UTF8ToString(Module['_BinaryenFunctionImportGetBase'](func)), - 'params': Module['_BinaryenFunctionGetParams'](func), - 'results': Module['_BinaryenFunctionGetResults'](func), - 'vars': getAllNested(func, Module['_BinaryenFunctionGetNumVars'], Module['_BinaryenFunctionGetVar']), - 'body': Module['_BinaryenFunctionGetBody'](func) - }; -}; - -// Obtains information about a 'Global' -Module['getGlobalInfo'] = function(global) { - return { - 'name': UTF8ToString(Module['_BinaryenGlobalGetName'](global)), - 'module': UTF8ToString(Module['_BinaryenGlobalImportGetModule'](global)), - 'base': UTF8ToString(Module['_BinaryenGlobalImportGetBase'](global)), - 'type': Module['_BinaryenGlobalGetType'](global), - 'mutable': Boolean(Module['_BinaryenGlobalIsMutable'](global)), - 'init': Module['_BinaryenGlobalGetInitExpr'](global) - }; -}; - -// Obtains information about a 'Table' -Module['getTableInfo'] = function(table) { - var hasMax = Boolean(Module['_BinaryenTableHasMax'](table)); - var tableInfo = { - 'name': UTF8ToString(Module['_BinaryenTableGetName'](table)), - 'module': UTF8ToString(Module['_BinaryenTableImportGetModule'](table)), - 'base': UTF8ToString(Module['_BinaryenTableImportGetBase'](table)), - 'initial': Module['_BinaryenTableGetInitial'](table), - } - - if (hasMax) { - tableInfo.max = Module['_BinaryenTableGetMax'](table); - } - - return tableInfo; -}; - -Module['getElementSegmentInfo'] = function(segment) { - var segmentLength = Module['_BinaryenElementSegmentGetLength'](segment); - var names = new Array(segmentLength); - for (let j = 0; j !== segmentLength; ++j) { - var ptr = Module['_BinaryenElementSegmentGetData'](segment, j); - names[j] = UTF8ToString(ptr); - } - - return { - 'name': UTF8ToString(Module['_BinaryenElementSegmentGetName'](segment)), - 'table': UTF8ToString(Module['_BinaryenElementSegmentGetTable'](segment)), - 'offset': Module['_BinaryenElementSegmentGetOffset'](segment), - 'data': names - } -} - -// Obtains information about a 'Tag' -Module['getTagInfo'] = function(tag) { - return { - 'name': UTF8ToString(Module['_BinaryenTagGetName'](tag)), - 'module': UTF8ToString(Module['_BinaryenTagImportGetModule'](tag)), - 'base': UTF8ToString(Module['_BinaryenTagImportGetBase'](tag)), - 'params': Module['_BinaryenTagGetParams'](tag), - 'results': Module['_BinaryenTagGetResults'](tag) - }; -}; - -// Obtains information about an 'Export' -Module['getExportInfo'] = function(export_) { - return { - 'kind': Module['_BinaryenExportGetKind'](export_), - 'name': UTF8ToString(Module['_BinaryenExportGetName'](export_)), - 'value': UTF8ToString(Module['_BinaryenExportGetValue'](export_)) - }; -}; - -// Emits text format of an expression or a module -Module['emitText'] = function(expr) { - if (typeof expr === 'object') { - return expr.emitText(); - } - const old = out; - let ret = ''; - out = x => { ret += x + '\n' }; - Module['_BinaryenExpressionPrint'](expr); - out = old; - return ret; -}; - -// Parses a binary to a module - -// If building with Emscripten ASSERTIONS, there is a property added to -// Module to guard against users mistakening using the removed readBinary() -// API. We must defuse that carefully. -Object.defineProperty(Module, 'readBinary', { writable: true }); - -Module['readBinary'] = function(data) { - const buffer = _malloc(data.length); - HEAP8.set(data, buffer); - const ptr = Module['_BinaryenModuleRead'](buffer, data.length); - _free(buffer); - return wrapModule(ptr); -}; - -// Parses text format to a module -Module['parseText'] = function(text) { - const buffer = _malloc(text.length + 1); - stringToAscii(text, buffer); - const ptr = Module['_BinaryenModuleParse'](buffer); - _free(buffer); - return wrapModule(ptr); -}; - -// Gets the currently set optimize level. 0, 1, 2 correspond to -O0, -O1, -O2, etc. -Module['getOptimizeLevel'] = function() { - return Module['_BinaryenGetOptimizeLevel'](); -}; - -// Sets the optimization level to use. 0, 1, 2 correspond to -O0, -O1, -O2, etc. -Module['setOptimizeLevel'] = function(level) { - Module['_BinaryenSetOptimizeLevel'](level); -}; - -// Gets the currently set shrink level. 0, 1, 2 correspond to -O0, -Os, -Oz. -Module['getShrinkLevel'] = function() { - return Module['_BinaryenGetShrinkLevel'](); -}; - -// Sets the shrink level to use. 0, 1, 2 correspond to -O0, -Os, -Oz. -Module['setShrinkLevel'] = function(level) { - Module['_BinaryenSetShrinkLevel'](level); -}; - -// Gets whether generating debug information is currently enabled or not. -Module['getDebugInfo'] = function() { - return Boolean(Module['_BinaryenGetDebugInfo']()); -}; - -// Enables or disables debug information in emitted binaries. -Module['setDebugInfo'] = function(on) { - Module['_BinaryenSetDebugInfo'](on); -}; - -// Gets whether the low 1K of memory can be considered unused when optimizing. -Module['getLowMemoryUnused'] = function() { - return Boolean(Module['_BinaryenGetLowMemoryUnused']()); -}; - -// Enables or disables whether the low 1K of memory can be considered unused -// when optimizing. -Module['setLowMemoryUnused'] = function(on) { - Module['_BinaryenSetLowMemoryUnused'](on); -}; - -// Gets whether that an imported memory will be zero-initialized speculation. -Module['getZeroFilledMemory'] = function() { - return Boolean(Module['_BinaryenGetZeroFilledMemory']()); -}; - -// Enables or disables whether that an imported memory will be -// zero-initialized speculation. -Module['setZeroFilledMemory'] = function(on) { - Module['_BinaryenSetZeroFilledMemory'](on); -}; -// Gets whether fast math optimizations are enabled, ignoring for example -// corner cases of floating-point math like NaN changes. -Module['getFastMath'] = function() { - return Boolean(Module['_BinaryenGetFastMath']()); -}; - -// Enables or disables fast math optimizations, ignoring for example -// corner cases of floating-point math like NaN changes. -Module['setFastMath'] = function(value) { - Module['_BinaryenSetFastMath'](value); -}; - -// Gets the value of the specified arbitrary pass argument. -Module['getPassArgument'] = function(key) { - return preserveStack(() => { - const ret = Module['_BinaryenGetPassArgument'](strToStack(key)); - return ret !== 0 ? UTF8ToString(ret) : null; - }); -}; - -// Sets the value of the specified arbitrary pass argument. Removes the -// respective argument if `value` is NULL. -Module['setPassArgument'] = function (key, value) { - preserveStack(() => { Module['_BinaryenSetPassArgument'](strToStack(key), strToStack(value)) }); -}; - -// Clears all arbitrary pass arguments. -Module['clearPassArguments'] = function() { - Module['_BinaryenClearPassArguments'](); -}; - -// Gets the function size at which we always inline. -Module['getAlwaysInlineMaxSize'] = function() { - return Module['_BinaryenGetAlwaysInlineMaxSize'](); -}; - -// Sets the function size at which we always inline. -Module['setAlwaysInlineMaxSize'] = function(size) { - Module['_BinaryenSetAlwaysInlineMaxSize'](size); -}; - -// Gets the function size which we inline when functions are lightweight. -Module['getFlexibleInlineMaxSize'] = function() { - return Module['_BinaryenGetFlexibleInlineMaxSize'](); -}; - -// Sets the function size which we inline when functions are lightweight. -Module['setFlexibleInlineMaxSize'] = function(size) { - Module['_BinaryenSetFlexibleInlineMaxSize'](size); -}; - -// Gets the function size which we inline when there is only one caller. -Module['getOneCallerInlineMaxSize'] = function() { - return Module['_BinaryenGetOneCallerInlineMaxSize'](); -}; - -// Sets the function size which we inline when there is only one caller. -Module['setOneCallerInlineMaxSize'] = function(size) { - Module['_BinaryenSetOneCallerInlineMaxSize'](size); -}; - -// Gets the value which allow inline functions that are not "lightweight". -Module['getAllowInliningFunctionsWithLoops'] = function() { - return Boolean(Module['_BinaryenGetAllowInliningFunctionsWithLoops']()); -}; - -// Sets the value which allow inline functions that are not "lightweight". -Module['setAllowInliningFunctionsWithLoops'] = function(value) { - Module['_BinaryenSetAllowInliningFunctionsWithLoops'](value); -}; - -// Expression wrappers - -// Private symbol used to store the underlying C-API pointer of a wrapped object. -const thisPtr = Symbol(); - -// Makes a specific expression wrapper class with the specified static members -// while automatically deriving instance methods and accessors. -function makeExpressionWrapper(ownStaticMembers) { - /** - * @constructor - * @extends Expression - */ - function SpecificExpression(expr) { - // can call the constructor without `new` - if (!(this instanceof SpecificExpression)) { - if (!expr) return null; - return new SpecificExpression(expr); - } - Expression.call(this, expr); - } - // inherit static members of Expression - Object.assign(SpecificExpression, Expression); - // add own static members - Object.assign(SpecificExpression, ownStaticMembers); - // inherit from Expression - (SpecificExpression.prototype = Object.create(Expression.prototype)).constructor = SpecificExpression; - // derive own instance members - deriveWrapperInstanceMembers(SpecificExpression.prototype, ownStaticMembers); - return SpecificExpression; -} - -// Derives the instance members of a wrapper class from the given static -// members. -function deriveWrapperInstanceMembers(prototype, staticMembers) { - // Given a static member `getName(ptr)` for example, an instance method - // `getName()` and a `name` accessor with the `this` argument bound will be - // derived and added to the wrapper's prototype. If a corresponding static - // `setName(ptr)` is present, a setter for the `name` accessor will be added - // as well. - Object.keys(staticMembers).forEach(memberName => { - const member = staticMembers[memberName]; - if (typeof member === "function") { - // Instance method calls the respective static method with `this` bound. - /** @this {Expression} */ - prototype[memberName] = function(...args) { - return this.constructor[memberName](this[thisPtr], ...args); - }; - // Instance accessors call the respective static methods. Accessors are - // derived only if the respective underlying static method takes exactly - // one argument, the `this` argument, e.g. `getChild(ptr, idx)` does not - // trigger an accessor. - let match; - if (member.length === 1 && (match = memberName.match(/^(get|is)/))) { - const index = match[1].length; - const propertyName = memberName.charAt(index).toLowerCase() + memberName.substring(index + 1); - const setterIfAny = staticMembers["set" + memberName.substring(index)]; - Object.defineProperty(prototype, propertyName, { - /** @this {Expression} */ - get() { - return member(this[thisPtr]); - }, - /** @this {Expression} */ - set(value) { - if (setterIfAny) setterIfAny(this[thisPtr], value); - else throw Error("property '" + propertyName + "' has no setter"); - } - }); - } - } - }); -} - -// Base class of all expression wrappers -/** @constructor */ -function Expression(expr) { - if (!expr) throw Error("expression reference must not be null"); - this[thisPtr] = expr; -} -Expression['getId'] = function(expr) { - return Module['_BinaryenExpressionGetId'](expr); -}; -Expression['getType'] = function(expr) { - return Module['_BinaryenExpressionGetType'](expr); -}; -Expression['setType'] = function(expr, type) { - Module['_BinaryenExpressionSetType'](expr, type); -}; -Expression['finalize'] = function(expr) { - return Module['_BinaryenExpressionFinalize'](expr); -}; -Expression['toText'] = function(expr) { - return Module['emitText'](expr); -}; -deriveWrapperInstanceMembers(Expression.prototype, Expression); -Expression.prototype['valueOf'] = function() { - return this[thisPtr]; -}; - -Module['Expression'] = Expression; - -Module['Block'] = makeExpressionWrapper({ - 'getName'(expr) { - const name = Module['_BinaryenBlockGetName'](expr); - return name ? UTF8ToString(name) : null; - }, - 'setName'(expr, name) { - preserveStack(() => { Module['_BinaryenBlockSetName'](expr, strToStack(name)) }); - }, - 'getNumChildren'(expr) { - return Module['_BinaryenBlockGetNumChildren'](expr); - }, - 'getChildren'(expr) { - return getAllNested(expr, Module['_BinaryenBlockGetNumChildren'], Module['_BinaryenBlockGetChildAt']); - }, - 'setChildren'(expr, children) { - setAllNested(expr, children, Module['_BinaryenBlockGetNumChildren'], Module['_BinaryenBlockSetChildAt'], Module['_BinaryenBlockAppendChild'], Module['_BinaryenBlockRemoveChildAt']); - }, - 'getChildAt'(expr, index) { - return Module['_BinaryenBlockGetChildAt'](expr, index); - }, - 'setChildAt'(expr, index, childExpr) { - Module['_BinaryenBlockSetChildAt'](expr, index, childExpr); - }, - 'appendChild'(expr, childExpr) { - return Module['_BinaryenBlockAppendChild'](expr, childExpr); - }, - 'insertChildAt'(expr, index, childExpr) { - Module['_BinaryenBlockInsertChildAt'](expr, index, childExpr); - }, - 'removeChildAt'(expr, index) { - return Module['_BinaryenBlockRemoveChildAt'](expr, index); - } -}); - -Module['If'] = makeExpressionWrapper({ - 'getCondition'(expr) { - return Module['_BinaryenIfGetCondition'](expr); - }, - 'setCondition'(expr, condExpr) { - Module['_BinaryenIfSetCondition'](expr, condExpr); - }, - 'getIfTrue'(expr) { - return Module['_BinaryenIfGetIfTrue'](expr); - }, - 'setIfTrue'(expr, ifTrueExpr) { - Module['_BinaryenIfSetIfTrue'](expr, ifTrueExpr); - }, - 'getIfFalse'(expr) { - return Module['_BinaryenIfGetIfFalse'](expr); - }, - 'setIfFalse'(expr, ifFalseExpr) { - Module['_BinaryenIfSetIfFalse'](expr, ifFalseExpr); - } -}); - -Module['Loop'] = makeExpressionWrapper({ - 'getName'(expr) { - const name = Module['_BinaryenLoopGetName'](expr); - return name ? UTF8ToString(name) : null; - }, - 'setName'(expr, name) { - preserveStack(() => { Module['_BinaryenLoopSetName'](expr, strToStack(name)) }); - }, - 'getBody'(expr) { - return Module['_BinaryenLoopGetBody'](expr); - }, - 'setBody'(expr, bodyExpr) { - Module['_BinaryenLoopSetBody'](expr, bodyExpr); - } -}); - -Module['Break'] = makeExpressionWrapper({ - 'getName'(expr) { - const name = Module['_BinaryenBreakGetName'](expr); - return name ? UTF8ToString(name) : null; - }, - 'setName'(expr, name) { - preserveStack(() => { Module['_BinaryenBreakSetName'](expr, strToStack(name)) }); - }, - 'getCondition'(expr) { - return Module['_BinaryenBreakGetCondition'](expr); - }, - 'setCondition'(expr, condExpr) { - Module['_BinaryenBreakSetCondition'](expr, condExpr); - }, - 'getValue'(expr) { - return Module['_BinaryenBreakGetValue'](expr); - }, - 'setValue'(expr, valueExpr) { - Module['_BinaryenBreakSetValue'](expr, valueExpr); - } -}); - -Module['Switch'] = makeExpressionWrapper({ - 'getNumNames'(expr) { - return Module['_BinaryenSwitchGetNumNames'](expr); - }, - 'getNames'(expr) { - return getAllNested(expr, Module['_BinaryenSwitchGetNumNames'], Module['_BinaryenSwitchGetNameAt']).map(p => UTF8ToString(p)); - }, - 'setNames'(expr, names) { - preserveStack(() => { - setAllNested(expr, names.map(strToStack), Module['_BinaryenSwitchGetNumNames'], Module['_BinaryenSwitchSetNameAt'], Module['_BinaryenSwitchAppendName'], Module['_BinaryenSwitchRemoveNameAt']); - }); - }, - 'getDefaultName'(expr) { - const name = Module['_BinaryenSwitchGetDefaultName'](expr); - return name ? UTF8ToString(name) : null; - }, - 'setDefaultName'(expr, defaultName) { - preserveStack(() => { Module['_BinaryenSwitchSetDefaultName'](expr, strToStack(defaultName)) }); - }, - 'getCondition'(expr) { - return Module['_BinaryenSwitchGetCondition'](expr); - }, - 'setCondition'(expr, condExpr) { - Module['_BinaryenSwitchSetCondition'](expr, condExpr); - }, - 'getValue'(expr) { - return Module['_BinaryenSwitchGetValue'](expr); - }, - 'setValue'(expr, valueExpr) { - Module['_BinaryenSwitchSetValue'](expr, valueExpr); - }, - 'getNameAt'(expr, index) { - return UTF8ToString(Module['_BinaryenSwitchGetNameAt'](expr, index)); - }, - 'setNameAt'(expr, index, name) { - preserveStack(() => { Module['_BinaryenSwitchSetNameAt'](expr, index, strToStack(name)) }); - }, - 'appendName'(expr, name) { - preserveStack(() => Module['_BinaryenSwitchAppendName'](expr, strToStack(name))); - }, - 'insertNameAt'(expr, index, name) { - preserveStack(() => { Module['_BinaryenSwitchInsertNameAt'](expr, index, strToStack(name)) }); - }, - 'removeNameAt'(expr, index) { - return UTF8ToString(Module['_BinaryenSwitchRemoveNameAt'](expr, index)); - }, -}); - -Module['Call'] = makeExpressionWrapper({ - 'getTarget'(expr) { - return UTF8ToString(Module['_BinaryenCallGetTarget'](expr)); - }, - 'setTarget'(expr, targetName) { - preserveStack(() => { Module['_BinaryenCallSetTarget'](expr, strToStack(targetName)) }); - }, - 'getNumOperands'(expr) { - return Module['_BinaryenCallGetNumOperands'](expr); - }, - 'getOperands'(expr) { - return getAllNested(expr, Module['_BinaryenCallGetNumOperands'], Module['_BinaryenCallGetOperandAt']); - }, - 'setOperands'(expr, operands) { - setAllNested(expr, operands, Module['_BinaryenCallGetNumOperands'], Module['_BinaryenCallSetOperandAt'], Module['_BinaryenCallAppendOperand'], Module['_BinaryenCallRemoveOperandAt']); - }, - 'getOperandAt'(expr, index) { - return Module['_BinaryenCallGetOperandAt'](expr, index); - }, - 'setOperandAt'(expr, index, operandExpr) { - Module['_BinaryenCallSetOperandAt'](expr, index, operandExpr); - }, - 'appendOperand'(expr, operandExpr) { - return Module['_BinaryenCallAppendOperand'](expr, operandExpr); - }, - 'insertOperandAt'(expr, index, operandExpr) { - Module['_BinaryenCallInsertOperandAt'](expr, index, operandExpr); - }, - 'removeOperandAt'(expr, index) { - return Module['_BinaryenCallRemoveOperandAt'](expr, index); - }, - 'isReturn'(expr) { - return Boolean(Module['_BinaryenCallIsReturn'](expr)); - }, - 'setReturn'(expr, isReturn) { - Module['_BinaryenCallSetReturn'](expr, isReturn); - } -}); - -Module['CallIndirect'] = makeExpressionWrapper({ - 'getTarget'(expr) { - return Module['_BinaryenCallIndirectGetTarget'](expr); - }, - 'setTarget'(expr, targetExpr) { - Module['_BinaryenCallIndirectSetTarget'](expr, targetExpr); - }, - 'getTable'(expr) { - return UTF8ToString(Module['_BinaryenCallIndirectGetTable'](expr)); - }, - 'setTable'(expr, table) { - preserveStack(() => { Module['_BinaryenCallIndirectSetTable'](expr, strToStack(table)) }); - }, - 'getNumOperands'(expr) { - return Module['_BinaryenCallIndirectGetNumOperands'](expr); - }, - 'getOperands'(expr) { - return getAllNested(expr, Module['_BinaryenCallIndirectGetNumOperands'], Module['_BinaryenCallIndirectGetOperandAt']); - }, - 'setOperands'(expr, operands) { - setAllNested(expr, operands, Module['_BinaryenCallIndirectGetNumOperands'], Module['_BinaryenCallIndirectSetOperandAt'], Module['_BinaryenCallIndirectAppendOperand'], Module['_BinaryenCallIndirectRemoveOperandAt']); - }, - 'getOperandAt'(expr, index) { - return Module['_BinaryenCallIndirectGetOperandAt'](expr, index); - }, - 'setOperandAt'(expr, index, operandExpr) { - Module['_BinaryenCallIndirectSetOperandAt'](expr, index, operandExpr); - }, - 'appendOperand'(expr, operandExpr) { - return Module['_BinaryenCallIndirectAppendOperand'](expr, operandExpr); - }, - 'insertOperandAt'(expr, index, operandExpr) { - Module['_BinaryenCallIndirectInsertOperandAt'](expr, index, operandExpr); - }, - 'removeOperandAt'(expr, index) { - return Module['_BinaryenCallIndirectRemoveOperandAt'](expr, index); - }, - 'isReturn'(expr) { - return Boolean(Module['_BinaryenCallIndirectIsReturn'](expr)); - }, - 'setReturn'(expr, isReturn) { - Module['_BinaryenCallIndirectSetReturn'](expr, isReturn); - }, - 'getParams'(expr) { - return Module['_BinaryenCallIndirectGetParams'](expr); - }, - 'setParams'(expr, params) { - Module['_BinaryenCallIndirectSetParams'](expr, params); - }, - 'getResults'(expr) { - return Module['_BinaryenCallIndirectGetResults'](expr); - }, - 'setResults'(expr, results) { - Module['_BinaryenCallIndirectSetResults'](expr, results); - } -}); - -Module['LocalGet'] = makeExpressionWrapper({ - 'getIndex'(expr) { - return Module['_BinaryenLocalGetGetIndex'](expr); - }, - 'setIndex'(expr, index) { - Module['_BinaryenLocalGetSetIndex'](expr, index); - } -}); - -Module['LocalSet'] = makeExpressionWrapper({ - 'getIndex'(expr) { - return Module['_BinaryenLocalSetGetIndex'](expr); - }, - 'setIndex'(expr, index) { - Module['_BinaryenLocalSetSetIndex'](expr, index); - }, - 'isTee'(expr) { - return Boolean(Module['_BinaryenLocalSetIsTee'](expr)); - }, - 'getValue'(expr) { - return Module['_BinaryenLocalSetGetValue'](expr); - }, - 'setValue'(expr, valueExpr) { - Module['_BinaryenLocalSetSetValue'](expr, valueExpr); - } -}); - -Module['GlobalGet'] = makeExpressionWrapper({ - 'getName'(expr) { - return UTF8ToString(Module['_BinaryenGlobalGetGetName'](expr)); - }, - 'setName'(expr, name) { - preserveStack(() => { Module['_BinaryenGlobalGetSetName'](expr, strToStack(name)) }); - } -}); - -Module['GlobalSet'] = makeExpressionWrapper({ - 'getName'(expr) { - return UTF8ToString(Module['_BinaryenGlobalSetGetName'](expr)); - }, - 'setName'(expr, name) { - preserveStack(() => { Module['_BinaryenGlobalSetSetName'](expr, strToStack(name)) }); - }, - 'getValue'(expr) { - return Module['_BinaryenGlobalSetGetValue'](expr); - }, - 'setValue'(expr, valueExpr) { - Module['_BinaryenGlobalSetSetValue'](expr, valueExpr); - } -}); - -Module['TableGet'] = makeExpressionWrapper({ - 'getTable'(expr) { - return UTF8ToString(Module['_BinaryenTableGetGetTable'](expr)); - }, - 'setTable'(expr, name) { - preserveStack(() => { Module['_BinaryenTableGetSetTable'](expr, strToStack(name)) }); - }, - 'getIndex'(expr) { - return Module['_BinaryenTableGetGetIndex'](expr); - }, - 'setIndex'(expr, indexExpr) { - Module['_BinaryenTableGetSetIndex'](expr, indexExpr); - } -}); - -Module['TableSet'] = makeExpressionWrapper({ - 'getTable'(expr) { - return UTF8ToString(Module['_BinaryenTableSetGetTable'](expr)); - }, - 'setTable'(expr, name) { - preserveStack(() => { Module['_BinaryenTableSetSetTable'](expr, strToStack(name)) }); - }, - 'getIndex'(expr) { - return Module['_BinaryenTableSetGetIndex'](expr); - }, - 'setIndex'(expr, indexExpr) { - Module['_BinaryenTableSetSetIndex'](expr, indexExpr); - }, - 'getValue'(expr) { - return Module['_BinaryenTableSetGetValue'](expr); - }, - 'setValue'(expr, valueExpr) { - Module['_BinaryenTableSetSetValue'](expr, valueExpr); - } -}); - -Module['TableSize'] = makeExpressionWrapper({ - 'getTable'(expr) { - return UTF8ToString(Module['_BinaryenTableSizeGetTable'](expr)); - }, - 'setTable'(expr, name) { - preserveStack(() => { Module['_BinaryenTableSizeSetTable'](expr, strToStack(name)) }); - }, -}); - -Module['TableGrow'] = makeExpressionWrapper({ - 'getTable'(expr) { - return UTF8ToString(Module['_BinaryenTableGrowGetTable'](expr)); - }, - 'setTable'(expr, name) { - preserveStack(() => { Module['_BinaryenTableGrowSetTable'](expr, strToStack(name)) }); - }, - 'getValue'(expr) { - return Module['_BinaryenTableGrowGetValue'](expr); - }, - 'setValue'(expr, valueExpr) { - Module['_BinaryenTableGrowSetValue'](expr, valueExpr); - }, - 'getDelta'(expr) { - return Module['_BinaryenTableGrowGetDelta'](expr); - }, - 'setDelta'(expr, deltaExpr) { - Module['_BinaryenTableGrowSetDelta'](expr, deltaExpr); - } -}); - -Module['MemorySize'] = makeExpressionWrapper({}); - -Module['MemoryGrow'] = makeExpressionWrapper({ - 'getDelta'(expr) { - return Module['_BinaryenMemoryGrowGetDelta'](expr); - }, - 'setDelta'(expr, deltaExpr) { - Module['_BinaryenMemoryGrowSetDelta'](expr, deltaExpr); - } -}); - -Module['Load'] = makeExpressionWrapper({ - 'isAtomic'(expr) { - return Boolean(Module['_BinaryenLoadIsAtomic'](expr)); - }, - 'setAtomic'(expr, isAtomic) { - Module['_BinaryenLoadSetAtomic'](expr, isAtomic); - }, - 'isSigned'(expr) { - return Boolean(Module['_BinaryenLoadIsSigned'](expr)); - }, - 'setSigned'(expr, isSigned) { - Module['_BinaryenLoadSetSigned'](expr, isSigned); - }, - 'getOffset'(expr) { - return Module['_BinaryenLoadGetOffset'](expr); - }, - 'setOffset'(expr, offset) { - Module['_BinaryenLoadSetOffset'](expr, offset); - }, - 'getBytes'(expr) { - return Module['_BinaryenLoadGetBytes'](expr); - }, - 'setBytes'(expr, bytes) { - Module['_BinaryenLoadSetBytes'](expr, bytes); - }, - 'getAlign'(expr) { - return Module['_BinaryenLoadGetAlign'](expr); - }, - 'setAlign'(expr, align) { - Module['_BinaryenLoadSetAlign'](expr, align); - }, - 'getPtr'(expr) { - return Module['_BinaryenLoadGetPtr'](expr); - }, - 'setPtr'(expr, ptrExpr) { - Module['_BinaryenLoadSetPtr'](expr, ptrExpr); - } -}); - -Module['Store'] = makeExpressionWrapper({ - 'isAtomic'(expr) { - return Boolean(Module['_BinaryenStoreIsAtomic'](expr)); - }, - 'setAtomic'(expr, isAtomic) { - Module['_BinaryenStoreSetAtomic'](expr, isAtomic); - }, - 'getBytes'(expr) { - return Module['_BinaryenStoreGetBytes'](expr); - }, - 'setBytes'(expr, bytes) { - Module['_BinaryenStoreSetBytes'](expr, bytes); - }, - 'getOffset'(expr) { - return Module['_BinaryenStoreGetOffset'](expr); - }, - 'setOffset'(expr, offset) { - Module['_BinaryenStoreSetOffset'](expr, offset); - }, - 'getAlign'(expr) { - return Module['_BinaryenStoreGetAlign'](expr); - }, - 'setAlign'(expr, align) { - Module['_BinaryenStoreSetAlign'](expr, align); - }, - 'getPtr'(expr) { - return Module['_BinaryenStoreGetPtr'](expr); - }, - 'setPtr'(expr, ptrExpr) { - Module['_BinaryenStoreSetPtr'](expr, ptrExpr); - }, - 'getValue'(expr) { - return Module['_BinaryenStoreGetValue'](expr); - }, - 'setValue'(expr, valueExpr) { - Module['_BinaryenStoreSetValue'](expr, valueExpr); - }, - 'getValueType'(expr) { - return Module['_BinaryenStoreGetValueType'](expr); - }, - 'setValueType'(expr, valueType) { - Module['_BinaryenStoreSetValueType'](expr, valueType); - } -}); - -Module['Const'] = makeExpressionWrapper({ - 'getValueI32'(expr) { - return Module['_BinaryenConstGetValueI32'](expr); - }, - 'setValueI32'(expr, value) { - Module['_BinaryenConstSetValueI32'](expr, value); - }, - 'getValueI64Low'(expr) { - return Module['_BinaryenConstGetValueI64Low'](expr); - }, - 'setValueI64Low'(expr, value) { - Module['_BinaryenConstSetValueI64Low'](expr, value); - }, - 'getValueI64High'(expr) { - return Module['_BinaryenConstGetValueI64High'](expr); - }, - 'setValueI64High'(expr, value) { - Module['_BinaryenConstSetValueI64High'](expr, value); - }, - 'getValueF32'(expr) { - return Module['_BinaryenConstGetValueF32'](expr); - }, - 'setValueF32'(expr, value) { - Module['_BinaryenConstSetValueF32'](expr, value); - }, - 'getValueF64'(expr) { - return Module['_BinaryenConstGetValueF64'](expr); - }, - 'setValueF64'(expr, value) { - Module['_BinaryenConstSetValueF64'](expr, value); - }, - 'getValueV128'(expr) { - let value; - preserveStack(() => { - const tempBuffer = stackAlloc(16); - Module['_BinaryenConstGetValueV128'](expr, tempBuffer); - value = new Array(16); - for (let i = 0 ; i < 16; ++i) { - value[i] = HEAPU8[tempBuffer + i]; - } - }); - return value; - }, - 'setValueV128'(expr, value) { - preserveStack(() => { - const tempBuffer = stackAlloc(16); - for (let i = 0 ; i < 16; ++i) { - HEAPU8[tempBuffer + i] = value[i]; - } - Module['_BinaryenConstSetValueV128'](expr, tempBuffer); - }); - } -}); - -Module['Unary'] = makeExpressionWrapper({ - 'getOp'(expr) { - return Module['_BinaryenUnaryGetOp'](expr); - }, - 'setOp'(expr, op) { - Module['_BinaryenUnarySetOp'](expr, op); - }, - 'getValue'(expr) { - return Module['_BinaryenUnaryGetValue'](expr); - }, - 'setValue'(expr, valueExpr) { - Module['_BinaryenUnarySetValue'](expr, valueExpr); - } -}); - -Module['Binary'] = makeExpressionWrapper({ - 'getOp'(expr) { - return Module['_BinaryenBinaryGetOp'](expr); - }, - 'setOp'(expr, op) { - Module['_BinaryenBinarySetOp'](expr, op); - }, - 'getLeft'(expr) { - return Module['_BinaryenBinaryGetLeft'](expr); - }, - 'setLeft'(expr, leftExpr) { - Module['_BinaryenBinarySetLeft'](expr, leftExpr); - }, - 'getRight'(expr) { - return Module['_BinaryenBinaryGetRight'](expr); - }, - 'setRight'(expr, rightExpr) { - Module['_BinaryenBinarySetRight'](expr, rightExpr); - } -}); - -Module['Select'] = makeExpressionWrapper({ - 'getIfTrue'(expr) { - return Module['_BinaryenSelectGetIfTrue'](expr); - }, - 'setIfTrue'(expr, ifTrueExpr) { - Module['_BinaryenSelectSetIfTrue'](expr, ifTrueExpr); - }, - 'getIfFalse'(expr) { - return Module['_BinaryenSelectGetIfFalse'](expr); - }, - 'setIfFalse'(expr, ifFalseExpr) { - Module['_BinaryenSelectSetIfFalse'](expr, ifFalseExpr); - }, - 'getCondition'(expr) { - return Module['_BinaryenSelectGetCondition'](expr); - }, - 'setCondition'(expr, condExpr) { - Module['_BinaryenSelectSetCondition'](expr, condExpr); - } -}); - -Module['Drop'] = makeExpressionWrapper({ - 'getValue'(expr) { - return Module['_BinaryenDropGetValue'](expr); - }, - 'setValue'(expr, valueExpr) { - Module['_BinaryenDropSetValue'](expr, valueExpr); - } -}); - -Module['Return'] = makeExpressionWrapper({ - 'getValue'(expr) { - return Module['_BinaryenReturnGetValue'](expr); - }, - 'setValue'(expr, valueExpr) { - Module['_BinaryenReturnSetValue'](expr, valueExpr); - } -}); - -Module['AtomicRMW'] = makeExpressionWrapper({ - 'getOp'(expr) { - return Module['_BinaryenAtomicRMWGetOp'](expr); - }, - 'setOp'(expr, op) { - Module['_BinaryenAtomicRMWSetOp'](expr, op); - }, - 'getBytes'(expr) { - return Module['_BinaryenAtomicRMWGetBytes'](expr); - }, - 'setBytes'(expr, bytes) { - Module['_BinaryenAtomicRMWSetBytes'](expr, bytes); - }, - 'getOffset'(expr) { - return Module['_BinaryenAtomicRMWGetOffset'](expr); - }, - 'setOffset'(expr, offset) { - Module['_BinaryenAtomicRMWSetOffset'](expr, offset); - }, - 'getPtr'(expr) { - return Module['_BinaryenAtomicRMWGetPtr'](expr); - }, - 'setPtr'(expr, ptrExpr) { - Module['_BinaryenAtomicRMWSetPtr'](expr, ptrExpr); - }, - 'getValue'(expr) { - return Module['_BinaryenAtomicRMWGetValue'](expr); - }, - 'setValue'(expr, valueExpr) { - Module['_BinaryenAtomicRMWSetValue'](expr, valueExpr); - } -}); - -Module['AtomicCmpxchg'] = makeExpressionWrapper({ - 'getBytes'(expr) { - return Module['_BinaryenAtomicCmpxchgGetBytes'](expr); - }, - 'setBytes'(expr, bytes) { - Module['_BinaryenAtomicCmpxchgSetBytes'](expr, bytes); - }, - 'getOffset'(expr) { - return Module['_BinaryenAtomicCmpxchgGetOffset'](expr); - }, - 'setOffset'(expr, offset) { - Module['_BinaryenAtomicCmpxchgSetOffset'](expr, offset); - }, - 'getPtr'(expr) { - return Module['_BinaryenAtomicCmpxchgGetPtr'](expr); - }, - 'setPtr'(expr, ptrExpr) { - Module['_BinaryenAtomicCmpxchgSetPtr'](expr, ptrExpr); - }, - 'getExpected'(expr) { - return Module['_BinaryenAtomicCmpxchgGetExpected'](expr); - }, - 'setExpected'(expr, expectedExpr) { - Module['_BinaryenAtomicCmpxchgSetExpected'](expr, expectedExpr); - }, - 'getReplacement'(expr) { - return Module['_BinaryenAtomicCmpxchgGetReplacement'](expr); - }, - 'setReplacement'(expr, replacementExpr) { - Module['_BinaryenAtomicCmpxchgSetReplacement'](expr, replacementExpr); - } -}); - -Module['AtomicWait'] = makeExpressionWrapper({ - 'getPtr'(expr) { - return Module['_BinaryenAtomicWaitGetPtr'](expr); - }, - 'setPtr'(expr, ptrExpr) { - Module['_BinaryenAtomicWaitSetPtr'](expr, ptrExpr); - }, - 'getExpected'(expr) { - return Module['_BinaryenAtomicWaitGetExpected'](expr); - }, - 'setExpected'(expr, expectedExpr) { - Module['_BinaryenAtomicWaitSetExpected'](expr, expectedExpr); - }, - 'getTimeout'(expr) { - return Module['_BinaryenAtomicWaitGetTimeout'](expr); - }, - 'setTimeout'(expr, timeoutExpr) { - Module['_BinaryenAtomicWaitSetTimeout'](expr, timeoutExpr); - }, - 'getExpectedType'(expr) { - return Module['_BinaryenAtomicWaitGetExpectedType'](expr); - }, - 'setExpectedType'(expr, expectedType) { - Module['_BinaryenAtomicWaitSetExpectedType'](expr, expectedType); - } -}); - -Module['AtomicNotify'] = makeExpressionWrapper({ - 'getPtr'(expr) { - return Module['_BinaryenAtomicNotifyGetPtr'](expr); - }, - 'setPtr'(expr, ptrExpr) { - Module['_BinaryenAtomicNotifySetPtr'](expr, ptrExpr); - }, - 'getNotifyCount'(expr) { - return Module['_BinaryenAtomicNotifyGetNotifyCount'](expr); - }, - 'setNotifyCount'(expr, notifyCountExpr) { - Module['_BinaryenAtomicNotifySetNotifyCount'](expr, notifyCountExpr); - } -}); - -Module['AtomicFence'] = makeExpressionWrapper({ - 'getOrder'(expr) { - return Module['_BinaryenAtomicFenceGetOrder'](expr); - }, - 'setOrder'(expr, order) { - Module['_BinaryenAtomicFenceSetOrder'](expr, order); - } -}); - -Module['SIMDExtract'] = makeExpressionWrapper({ - 'getOp'(expr) { - return Module['_BinaryenSIMDExtractGetOp'](expr); - }, - 'setOp'(expr, op) { - Module['_BinaryenSIMDExtractSetOp'](expr, op); - }, - 'getVec'(expr) { - return Module['_BinaryenSIMDExtractGetVec'](expr); - }, - 'setVec'(expr, vecExpr) { - Module['_BinaryenSIMDExtractSetVec'](expr, vecExpr); - }, - 'getIndex'(expr) { - return Module['_BinaryenSIMDExtractGetIndex'](expr); - }, - 'setIndex'(expr, index) { - Module['_BinaryenSIMDExtractSetIndex'](expr, index) - } -}); - -Module['SIMDReplace'] = makeExpressionWrapper({ - 'getOp'(expr) { - return Module['_BinaryenSIMDReplaceGetOp'](expr); - }, - 'setOp'(expr, op) { - Module['_BinaryenSIMDReplaceSetOp'](expr, op); - }, - 'getVec'(expr) { - return Module['_BinaryenSIMDReplaceGetVec'](expr); - }, - 'setVec'(expr, vecExpr) { - Module['_BinaryenSIMDReplaceSetVec'](expr, vecExpr); - }, - 'getIndex'(expr) { - return Module['_BinaryenSIMDReplaceGetIndex'](expr); - }, - 'setIndex'(expr, index) { - Module['_BinaryenSIMDReplaceSetIndex'](expr, index); - }, - 'getValue'(expr) { - return Module['_BinaryenSIMDReplaceGetValue'](expr); - }, - 'setValue'(expr, valueExpr) { - Module['_BinaryenSIMDReplaceSetValue'](expr, valueExpr); - } -}); - -Module['SIMDShuffle'] = makeExpressionWrapper({ - 'getLeft'(expr) { - return Module['_BinaryenSIMDShuffleGetLeft'](expr); - }, - 'setLeft'(expr, leftExpr) { - Module['_BinaryenSIMDShuffleSetLeft'](expr, leftExpr) - }, - 'getRight'(expr) { - return Module['_BinaryenSIMDShuffleGetRight'](expr); - }, - 'setRight'(expr, rightExpr) { - Module['_BinaryenSIMDShuffleSetRight'](expr, rightExpr); - }, - 'getMask'(expr) { - let mask; - preserveStack(() => { - const tempBuffer = stackAlloc(16); - Module['_BinaryenSIMDShuffleGetMask'](expr, tempBuffer); - mask = new Array(16); - for (let i = 0 ; i < 16; ++i) { - mask[i] = HEAPU8[tempBuffer + i]; - } - }); - return mask; - }, - 'setMask'(expr, mask) { - preserveStack(() => { - const tempBuffer = stackAlloc(16); - for (let i = 0 ; i < 16; ++i) { - HEAPU8[tempBuffer + i] = mask[i]; - } - Module['_BinaryenSIMDShuffleSetMask'](expr, tempBuffer); - }); - } -}); - -Module['SIMDTernary'] = makeExpressionWrapper({ - 'getOp'(expr) { - return Module['_BinaryenSIMDTernaryGetOp'](expr); - }, - 'setOp'(expr, op) { - Module['_BinaryenSIMDTernarySetOp'](expr, op); - }, - 'getA'(expr) { - return Module['_BinaryenSIMDTernaryGetA'](expr); - }, - 'setA'(expr, aExpr) { - Module['_BinaryenSIMDTernarySetA'](expr, aExpr); - }, - 'getB'(expr) { - return Module['_BinaryenSIMDTernaryGetB'](expr); - }, - 'setB'(expr, bExpr) { - Module['_BinaryenSIMDTernarySetB'](expr, bExpr); - }, - 'getC'(expr) { - return Module['_BinaryenSIMDTernaryGetC'](expr); - }, - 'setC'(expr, cExpr) { - Module['_BinaryenSIMDTernarySetC'](expr, cExpr); - } -}); - -Module['SIMDShift'] = makeExpressionWrapper({ - 'getOp'(expr) { - return Module['_BinaryenSIMDShiftGetOp'](expr); - }, - 'setOp'(expr, op) { - Module['_BinaryenSIMDShiftSetOp'](expr, op); - }, - 'getVec'(expr) { - return Module['_BinaryenSIMDShiftGetVec'](expr); - }, - 'setVec'(expr, vecExpr) { - Module['_BinaryenSIMDShiftSetVec'](expr, vecExpr); - }, - 'getShift'(expr) { - return Module['_BinaryenSIMDShiftGetShift'](expr); - }, - 'setShift'(expr, shiftExpr) { - Module['_BinaryenSIMDShiftSetShift'](expr, shiftExpr); - } -}); - -Module['SIMDLoad'] = makeExpressionWrapper({ - 'getOp'(expr) { - return Module['_BinaryenSIMDLoadGetOp'](expr); - }, - 'setOp'(expr, op) { - Module['_BinaryenSIMDLoadSetOp'](expr, op); - }, - 'getOffset'(expr) { - return Module['_BinaryenSIMDLoadGetOffset'](expr); - }, - 'setOffset'(expr, offset) { - Module['_BinaryenSIMDLoadSetOffset'](expr, offset); - }, - 'getAlign'(expr) { - return Module['_BinaryenSIMDLoadGetAlign'](expr); - }, - 'setAlign'(expr, align) { - Module['_BinaryenSIMDLoadSetAlign'](expr, align); - }, - 'getPtr'(expr) { - return Module['_BinaryenSIMDLoadGetPtr'](expr); - }, - 'setPtr'(expr, ptrExpr) { - Module['_BinaryenSIMDLoadSetPtr'](expr, ptrExpr); - } -}); - -Module['SIMDLoadStoreLane'] = makeExpressionWrapper({ - 'getOp'(expr) { - return Module['_BinaryenSIMDLoadStoreLaneGetOp'](expr); - }, - 'setOp'(expr, op) { - Module['_BinaryenSIMDLoadStoreLaneSetOp'](expr, op); - }, - 'getOffset'(expr) { - return Module['_BinaryenSIMDLoadStoreLaneGetOffset'](expr); - }, - 'setOffset'(expr, offset) { - Module['_BinaryenSIMDLoadStoreLaneSetOffset'](expr, offset); - }, - 'getAlign'(expr) { - return Module['_BinaryenSIMDLoadStoreLaneGetAlign'](expr); - }, - 'setAlign'(expr, align) { - Module['_BinaryenSIMDLoadStoreLaneSetAlign'](expr, align); - }, - 'getIndex'(expr) { - return Module['_BinaryenSIMDLoadStoreLaneGetIndex'](expr); - }, - 'setIndex'(expr, align) { - Module['_BinaryenSIMDLoadStoreLaneSetIndex'](expr, align); - }, - 'getPtr'(expr) { - return Module['_BinaryenSIMDLoadStoreLaneGetPtr'](expr); - }, - 'setPtr'(expr, ptrExpr) { - Module['_BinaryenSIMDLoadStoreLaneSetPtr'](expr, ptrExpr); - }, - 'getVec'(expr) { - return Module['_BinaryenSIMDLoadStoreLaneGetVec'](expr); - }, - 'setVec'(expr, ptrExpr) { - Module['_BinaryenSIMDLoadStoreLaneSetVec'](expr, ptrExpr); - }, - 'isStore'(expr) { - return Boolean(Module['_BinaryenSIMDLoadStoreLaneIsStore'](expr)); - } -}); - -Module['MemoryInit'] = makeExpressionWrapper({ - 'getSegment'(expr) { - return UTF8ToString(Module['_BinaryenMemoryInitGetSegment'](expr)); - }, - 'setSegment'(expr, segment) { - preserveStack(() => Module['_BinaryenMemoryInitSetSegment'](expr, strToStack(segment))); - }, - 'getDest'(expr) { - return Module['_BinaryenMemoryInitGetDest'](expr); - }, - 'setDest'(expr, destExpr) { - Module['_BinaryenMemoryInitSetDest'](expr, destExpr); - }, - 'getOffset'(expr) { - return Module['_BinaryenMemoryInitGetOffset'](expr); - }, - 'setOffset'(expr, offset) { - Module['_BinaryenMemoryInitSetOffset'](expr, offset); - }, - 'getSize'(expr) { - return Module['_BinaryenMemoryInitGetSize'](expr); - }, - 'setSize'(expr, sizeExpr) { - Module['_BinaryenMemoryInitSetSize'](expr, sizeExpr); - } -}); - -Module['DataDrop'] = makeExpressionWrapper({ - 'getSegment'(expr) { - return UTF8ToString(Module['_BinaryenDataDropGetSegment'](expr)); - }, - 'setSegment'(expr, segment) { - preserveStack(() => Module['_BinaryenDataDropSetSegment'](expr, strToStack(segment))); - } -}); - -Module['MemoryCopy'] = makeExpressionWrapper({ - 'getDest'(expr) { - return Module['_BinaryenMemoryCopyGetDest'](expr); - }, - 'setDest'(expr, destExpr) { - Module['_BinaryenMemoryCopySetDest'](expr, destExpr); - }, - 'getSource'(expr) { - return Module['_BinaryenMemoryCopyGetSource'](expr); - }, - 'setSource'(expr, sourceExpr) { - Module['_BinaryenMemoryCopySetSource'](expr, sourceExpr); - }, - 'getSize'(expr) { - return Module['_BinaryenMemoryCopyGetSize'](expr); - }, - 'setSize'(expr, sizeExpr) { - Module['_BinaryenMemoryCopySetSize'](expr, sizeExpr); - } -}); - -Module['MemoryFill'] = makeExpressionWrapper({ - 'getDest'(expr) { - return Module['_BinaryenMemoryFillGetDest'](expr); - }, - 'setDest'(expr, destExpr) { - Module['_BinaryenMemoryFillSetDest'](expr, destExpr); - }, - 'getValue'(expr) { - return Module['_BinaryenMemoryFillGetValue'](expr); - }, - 'setValue'(expr, valueExpr) { - Module['_BinaryenMemoryFillSetValue'](expr, valueExpr); - }, - 'getSize'(expr) { - return Module['_BinaryenMemoryFillGetSize'](expr); - }, - 'setSize'(expr, sizeExpr) { - Module['_BinaryenMemoryFillSetSize'](expr, sizeExpr); - } -}); - -Module['RefIsNull'] = makeExpressionWrapper({ - 'getValue'(expr) { - return Module['_BinaryenRefIsNullGetValue'](expr); - }, - 'setValue'(expr, valueExpr) { - Module['_BinaryenRefIsNullSetValue'](expr, valueExpr); - } -}); - -Module['RefAs'] = makeExpressionWrapper({ - 'getOp'(expr) { - return Module['_BinaryenRefAsGetOp'](expr); - }, - 'setOp'(expr, op) { - Module['_BinaryenRefAsSetOp'](expr, op); - }, - 'getValue'(expr) { - return Module['_BinaryenRefAsGetValue'](expr); - }, - 'setValue'(expr, valueExpr) { - Module['_BinaryenRefAsSetValue'](expr, valueExpr); - } -}); - -Module['RefFunc'] = makeExpressionWrapper({ - 'getFunc'(expr) { - return UTF8ToString(Module['_BinaryenRefFuncGetFunc'](expr)); - }, - 'setFunc'(expr, funcName) { - preserveStack(() => { Module['_BinaryenRefFuncSetFunc'](expr, strToStack(funcName)) }); - } -}); - -Module['RefEq'] = makeExpressionWrapper({ - 'getLeft'(expr) { - return Module['_BinaryenRefEqGetLeft'](expr); - }, - 'setLeft'(expr, leftExpr) { - return Module['_BinaryenRefEqSetLeft'](expr, leftExpr); - }, - 'getRight'(expr) { - return Module['_BinaryenRefEqGetRight'](expr); - }, - 'setRight'(expr, rightExpr) { - return Module['_BinaryenRefEqSetRight'](expr, rightExpr); - } -}); - -Module['Try'] = makeExpressionWrapper({ - 'getName'(expr) { - const name = Module['_BinaryenTryGetName'](expr); - return name ? UTF8ToString(name) : null; - }, - 'setName'(expr, name) { - preserveStack(() => { Module['_BinaryenTrySetName'](expr, strToStack(name)) }); - }, - 'getBody'(expr) { - return Module['_BinaryenTryGetBody'](expr); - }, - 'setBody'(expr, bodyExpr) { - Module['_BinaryenTrySetBody'](expr, bodyExpr); - }, - 'getNumCatchTags'(expr) { - return Module['_BinaryenTryGetNumCatchTags'](expr); - }, - 'getCatchTags'(expr) { - return getAllNested(expr, Module['_BinaryenTryGetNumCatchTags'], Module['_BinaryenTryGetCatchTagAt']).map(p => UTF8ToString(p)); - }, - 'setCatchTags'(expr, catchTags) { - preserveStack(() => { - setAllNested(expr, catchTags.map(strToStack), Module['_BinaryenTryGetNumCatchTags'], Module['_BinaryenTrySetCatchTagAt'], Module['_BinaryenTryAppendCatchTag'], Module['_BinaryenTryRemoveCatchTagAt']); - }); - }, - 'getCatchTagAt'(expr, index) { - return UTF8ToString(Module['_BinaryenTryGetCatchTagAt'](expr, index)); - }, - 'setCatchTagAt'(expr, index, catchTag) { - preserveStack(() => { Module['_BinaryenTrySetCatchTagAt'](expr, index, strToStack(catchTag)) }); - }, - 'appendCatchTag'(expr, catchTag) { - preserveStack(() => Module['_BinaryenTryAppendCatchTag'](expr, strToStack(catchTag))); - }, - 'insertCatchTagAt'(expr, index, catchTag) { - preserveStack(() => { Module['_BinaryenTryInsertCatchTagAt'](expr, index, strToStack(catchTag)) }); - }, - 'removeCatchTagAt'(expr, index) { - return UTF8ToString(Module['_BinaryenTryRemoveCatchTagAt'](expr, index)); - }, - 'getNumCatchBodies'(expr) { - return Module['_BinaryenTryGetNumCatchBodies'](expr); - }, - 'getCatchBodies'(expr) { - return getAllNested(expr, Module['_BinaryenTryGetNumCatchBodies'], Module['_BinaryenTryGetCatchBodyAt']); - }, - 'setCatchBodies'(expr, catchBodies) { - setAllNested(expr, catchBodies, Module['_BinaryenTryGetNumCatchBodies'], Module['_BinaryenTrySetCatchBodyAt'], Module['_BinaryenTryAppendCatchBody'], Module['_BinaryenTryRemoveCatchBodyAt']); - }, - 'getCatchBodyAt'(expr, index) { - return Module['_BinaryenTryGetCatchBodyAt'](expr, index); - }, - 'setCatchBodyAt'(expr, index, catchExpr) { - Module['_BinaryenTrySetCatchBodyAt'](expr, index, catchExpr); - }, - 'appendCatchBody'(expr, catchExpr) { - return Module['_BinaryenTryAppendCatchBody'](expr, catchExpr); - }, - 'insertCatchBodyAt'(expr, index, catchExpr) { - Module['_BinaryenTryInsertCatchBodyAt'](expr, index, catchExpr); - }, - 'removeCatchBodyAt'(expr, index) { - return Module['_BinaryenTryRemoveCatchBodyAt'](expr, index); - }, - 'hasCatchAll'(expr) { - return Boolean(Module['_BinaryenTryHasCatchAll'](expr)); - }, - 'getDelegateTarget'(expr) { - const name = Module['_BinaryenTryGetDelegateTarget'](expr); - return name ? UTF8ToString(name) : null; - }, - 'setDelegateTarget'(expr, name) { - preserveStack(() => { Module['_BinaryenTrySetDelegateTarget'](expr, strToStack(name)) }); - }, - 'isDelegate'(expr) { - return Boolean(Module['_BinaryenTryIsDelegate'](expr)); - } -}); - -Module['Throw'] = makeExpressionWrapper({ - 'getTag'(expr) { - return UTF8ToString(Module['_BinaryenThrowGetTag'](expr)); - }, - 'setTag'(expr, tagName) { - preserveStack(() => { Module['_BinaryenThrowSetTag'](expr, strToStack(tagName)) }); - }, - 'getNumOperands'(expr) { - return Module['_BinaryenThrowGetNumOperands'](expr); - }, - 'getOperands'(expr) { - return getAllNested(expr, Module['_BinaryenThrowGetNumOperands'], Module['_BinaryenThrowGetOperandAt']); - }, - 'setOperands'(expr, operands) { - setAllNested(expr, operands, Module['_BinaryenThrowGetNumOperands'], Module['_BinaryenThrowSetOperandAt'], Module['_BinaryenThrowAppendOperand'], Module['_BinaryenThrowRemoveOperandAt']); - }, - 'getOperandAt'(expr, index) { - return Module['_BinaryenThrowGetOperandAt'](expr, index); - }, - 'setOperandAt'(expr, index, operandExpr) { - Module['_BinaryenThrowSetOperandAt'](expr, index, operandExpr); - }, - 'appendOperand'(expr, operandExpr) { - return Module['_BinaryenThrowAppendOperand'](expr, operandExpr); - }, - 'insertOperandAt'(expr, index, operandExpr) { - Module['_BinaryenThrowInsertOperandAt'](expr, index, operandExpr); - }, - 'removeOperandAt'(expr, index) { - return Module['_BinaryenThrowRemoveOperandAt'](expr, index); - }, -}); - -Module['Rethrow'] = makeExpressionWrapper({ - 'getTarget'(expr) { - const target = Module['_BinaryenRethrowGetTarget'](expr); - return target ? UTF8ToString(target) : null; - }, - 'setTarget'(expr, target) { - preserveStack(() => { Module['_BinaryenRethrowSetTarget'](expr, strToStack(target)) }); - } -}); - -Module['TupleMake'] = makeExpressionWrapper({ - 'getNumOperands'(expr) { - return Module['_BinaryenTupleMakeGetNumOperands'](expr); - }, - 'getOperands'(expr) { - return getAllNested(expr, Module['_BinaryenTupleMakeGetNumOperands'], Module['_BinaryenTupleMakeGetOperandAt']); - }, - 'setOperands'(expr, operands) { - setAllNested(expr, operands, Module['_BinaryenTupleMakeGetNumOperands'], Module['_BinaryenTupleMakeSetOperandAt'], Module['_BinaryenTupleMakeAppendOperand'], Module['_BinaryenTupleMakeRemoveOperandAt']); - }, - 'getOperandAt'(expr, index) { - return Module['_BinaryenTupleMakeGetOperandAt'](expr, index); - }, - 'setOperandAt'(expr, index, operandExpr) { - Module['_BinaryenTupleMakeSetOperandAt'](expr, index, operandExpr); - }, - 'appendOperand'(expr, operandExpr) { - return Module['_BinaryenTupleMakeAppendOperand'](expr, operandExpr); - }, - 'insertOperandAt'(expr, index, operandExpr) { - Module['_BinaryenTupleMakeInsertOperandAt'](expr, index, operandExpr); - }, - 'removeOperandAt'(expr, index) { - return Module['_BinaryenTupleMakeRemoveOperandAt'](expr, index); - } -}); - -Module['TupleExtract'] = makeExpressionWrapper({ - 'getTuple'(expr) { - return Module['_BinaryenTupleExtractGetTuple'](expr); - }, - 'setTuple'(expr, tupleExpr) { - Module['_BinaryenTupleExtractSetTuple'](expr, tupleExpr); - }, - 'getIndex'(expr) { - return Module['_BinaryenTupleExtractGetIndex'](expr); - }, - 'setIndex'(expr, index) { - Module['_BinaryenTupleExtractSetIndex'](expr, index); - } -}); - -Module['RefI31'] = makeExpressionWrapper({ - 'getValue'(expr) { - return Module['_BinaryenRefI31GetValue'](expr); - }, - 'setValue'(expr, valueExpr) { - Module['_BinaryenRefI31SetValue'](expr, valueExpr); - } -}); - -Module['I31Get'] = makeExpressionWrapper({ - 'getI31'(expr) { - return Module['_BinaryenI31GetGetI31'](expr); - }, - 'setI31'(expr, i31Expr) { - Module['_BinaryenI31GetSetI31'](expr, i31Expr); - }, - 'isSigned'(expr) { - return Boolean(Module['_BinaryenI31GetIsSigned'](expr)); - }, - 'setSigned'(expr, isSigned) { - Module['_BinaryenI31GetSetSigned'](expr, isSigned); - } -}); - -// Function wrapper - -Module['Function'] = (() => { - // Closure compiler doesn't allow multiple `Function`s at top-level, so: - /** @constructor */ - function Function(func) { - if (!(this instanceof Function)) { - if (!func) return null; - return new Function(func); - } - if (!func) throw Error("function reference must not be null"); - this[thisPtr] = func; - } - Function['getName'] = function(func) { - return UTF8ToString(Module['_BinaryenFunctionGetName'](func)); - }; - Function['getParams'] = function(func) { - return Module['_BinaryenFunctionGetParams'](func); - }; - Function['getResults'] = function(func) { - return Module['_BinaryenFunctionGetResults'](func); - }; - Function['getNumVars'] = function(func) { - return Module['_BinaryenFunctionGetNumVars'](func); - }; - Function['getVar'] = function(func, index) { - return Module['_BinaryenFunctionGetVar'](func, index); - }; - Function['getNumLocals'] = function(func) { - return Module['_BinaryenFunctionGetNumLocals'](func); - }; - Function['hasLocalName'] = function(func, index) { - return Boolean(Module['_BinaryenFunctionHasLocalName'](func, index)); - }; - Function['getLocalName'] = function(func, index) { - return UTF8ToString(Module['_BinaryenFunctionGetLocalName'](func, index)); - }; - Function['setLocalName'] = function(func, index, name) { - preserveStack(() => { - Module['_BinaryenFunctionSetLocalName'](func, index, strToStack(name)); - }); - }; - Function['getBody'] = function(func) { - return Module['_BinaryenFunctionGetBody'](func); - }; - Function['setBody'] = function(func, bodyExpr) { - Module['_BinaryenFunctionSetBody'](func, bodyExpr); - }; - deriveWrapperInstanceMembers(Function.prototype, Function); - Function.prototype['valueOf'] = function() { - return this[thisPtr]; - }; - return Function; -})(); - -// Additional customizations - -Module['exit'] = function(status) { - // Instead of exiting silently on errors, always show an error with - // a stack trace, for debuggability. - if (status != 0) throw new Error('exiting due to error: ' + status); -}; - -// Intercept the onRuntimeInitialized hook if necessary -if (runtimeInitialized) { - initializeConstants(); -} else { - Module['onRuntimeInitialized'] = (super_ => () => { - initializeConstants(); - if (super_) super_(); - })(Module['onRuntimeInitialized']); -} diff --git a/src/ts/README.md b/src/ts/README.md new file mode 100644 index 00000000000..b4c29a78d55 --- /dev/null +++ b/src/ts/README.md @@ -0,0 +1,19 @@ +"binaryen.ts" file is the single source of truth for exposing binaryen's JS API. +The committed file imports the js file generated by emscripten as follows: +```Typescript +const JSModule = await import("./binaryen_raw_TARGET.js"); +``` +That file exists in the source code, but it's only here to help compile binaryen.ts during development. +(this is done using `tsc --target ES2020 --module ES2022 --declaration --declarationMap binaryen.ts`) +During build, the file name is replaces by the real one using sed, as follows: +``` +sed -e 's/TARGET//g' binaryen_ts.ts +``` +where `` is either "js" or "wasm", depending on the target. + +"binaryen_post.ts" contains the minimal constructs to inject in the generated js file, required by binaryen.ts. +During build, the file is compiled to js (using tsc) and then injected using emscripten's --post-js option. + + + + diff --git a/src/ts/binaryen.ts b/src/ts/binaryen.ts new file mode 100644 index 00000000000..03adcc3dc04 --- /dev/null +++ b/src/ts/binaryen.ts @@ -0,0 +1,3245 @@ +// @ts-ignore +import Binaryen from "./binaryen_raw_TARGET.js"; +const JSModule = await Binaryen(); +const _malloc: (size: number) => number = JSModule._malloc; +const _free: (size: number) => void = JSModule._free; +const HEAP8: Int8Array = JSModule.HEAP8; +const HEAPU8: Uint8Array = JSModule.HEAPU8; +const HEAP32: Int32Array = JSModule.HEAP32; +const HEAPU32: Uint32Array = JSModule.HEAPU32; +const stringToAscii: (s: string, ptr: number) => void = JSModule.stringToAscii; +const stackSave: () => number = JSModule.stackSave; +const stackAlloc: (size: number) => number = JSModule.stackAlloc; +const stackRestore: (ref: number) => void = JSModule.stackRestore; +const allocateUTF8OnStack: (s: string) => number = JSModule.allocateUTF8OnStack; +const UTF8ToString: (ptr: number) => string | null = JSModule.UTF8ToString; +const __i32_store: (offset: number, value: number) => void = JSModule['__i32_store']; +const __i32_load: (offset: number) => number = JSModule['__i32_load']; +const utils = JSModule['utils']; +type Writer = (...data: any[]) => void; +const swapOut: (func: Writer) => Writer = utils.swapOut; +const swapErr: (func: Writer) => Writer = utils.swapErr; +const _BinaryenSizeofLiteral: () => number = utils._BinaryenSizeofLiteral; +const _BinaryenSizeofAllocateAndWriteResult: () => number = utils._BinaryenSizeofAllocateAndWriteResult; + + +function preserveStack(func: () => R): R { + try { + var stack = stackSave(); + return func(); + } finally { + stackRestore(stack); + } +} + +function strToStack(str: string) { + return str ? allocateUTF8OnStack(str) : 0; +} + +function i32sToStack(i32s: ArrayLike): number { + const ret = stackAlloc(i32s.length << 2); + HEAP32.set(i32s, ret >>> 2); + return ret; +} + +function i8sToStack(i8s: ArrayLike): number { + const ret = stackAlloc(i8s.length); + HEAP8.set(i8s, ret); + return ret; +} + +function getAllNested(ref: ExpressionRef, numFn: (ref: ExpressionRef) => number, getFn: (ref: ExpressionRef, i: number) => T): T[] { + const num = numFn(ref); + const ret = new Array(num); + for (let i = 0; i < num; ++i) ret[i] = getFn(ref, i); + return ret; +} + +export const sizeOfLiteral: number = _BinaryenSizeofLiteral(); + +export type Type = number; +export type ElementSegmentRef = number; +export type ExpressionRef = number; +export type FunctionRef = number; +export type GlobalRef = number; +export type ExportRef = number; +export type TableRef = number; +export type TagRef = number; +export type RelooperBlockRef = number; +export type ExpressionRunnerRef = number; +export type TypeBuilderRef = number; +export type HeapType = number; + +export const none: Type = JSModule['_BinaryenTypeNone'](); +export const i32: Type = JSModule['_BinaryenTypeInt32'](); +export const i64: Type = JSModule['_BinaryenTypeInt64'](); +export const f32: Type = JSModule['_BinaryenTypeFloat32'](); +export const f64: Type = JSModule['_BinaryenTypeFloat64'](); +export const v128: Type = JSModule['_BinaryenTypeVec128'](); +export const funcref: Type = JSModule['_BinaryenTypeFuncref'](); +export const externref: Type = JSModule['_BinaryenTypeExternref'](); +export const anyref: Type = JSModule['_BinaryenTypeAnyref'](); +export const eqref: Type = JSModule['_BinaryenTypeEqref'](); +export const i31ref: Type = JSModule['_BinaryenTypeI31ref'](); +export const structref: Type = JSModule['_BinaryenTypeStructref'](); +/* explicitly skipping string stuff until it's reprioritized +export const stringref: Type = JSModule['_BinaryenTypeStringref'](); +export const stringview_wtf8: Type = JSModule['_BinaryenTypeStringviewWTF8'](); +export const stringview_wtf16: Type = JSModule['_BinaryenTypeStringviewWTF16'](); +export const stringview_iter: Type = JSModule['_BinaryenTypeStringviewIter'](); +*/ +export const unreachable: Type = JSModule['_BinaryenTypeUnreachable'](); +export const auto: Type = JSModule['_BinaryenTypeAuto'](); + +export function createType(types: Type[]): Type { + return preserveStack(() => JSModule['_BinaryenTypeCreate'](i32sToStack(types), types.length)); +} +export function expandType(type: Type): Type[] { + return preserveStack(() => { + const numTypes = JSModule['_BinaryenTypeArity'](type); + const array = stackAlloc(numTypes << 2); + JSModule['_BinaryenTypeExpand'](type, array); + const types = new Array(numTypes); + for (let i = 0; i < numTypes; i++) { + types[i] = HEAPU32[(array >>> 2) + i]; + } + return types; + }); +} + +export enum ExternalKinds { + Function = JSModule['_BinaryenExternalFunction'](), + Table = JSModule['_BinaryenExternalTable'](), + Memory = JSModule['_BinaryenExternalMemory'](), + Global = JSModule['_BinaryenExternalGlobal'](), + Tag = JSModule['_BinaryenExternalTag']() +} + +export enum Feature { + MVP = JSModule['_BinaryenFeatureMVP'](), + Atomics = JSModule['_BinaryenFeatureAtomics'](), + BulkMemory = JSModule['_BinaryenFeatureBulkMemory'](), + MutableGlobals = JSModule['_BinaryenFeatureMutableGlobals'](), + NontrappingFPToInt = JSModule['_BinaryenFeatureNontrappingFPToInt'](), + SignExt = JSModule['_BinaryenFeatureSignExt'](), + SIMD128 = JSModule['_BinaryenFeatureSIMD128'](), + ExceptionHandling = JSModule['_BinaryenFeatureExceptionHandling'](), + TailCall = JSModule['_BinaryenFeatureTailCall'](), + ReferenceTypes = JSModule['_BinaryenFeatureReferenceTypes'](), + Multivalue = JSModule['_BinaryenFeatureMultivalue'](), + GC = JSModule['_BinaryenFeatureGC'](), + Memory64 = JSModule['_BinaryenFeatureMemory64'](), + RelaxedSIMD = JSModule['_BinaryenFeatureRelaxedSIMD'](), + ExtendedConst = JSModule['_BinaryenFeatureExtendedConst'](), + /* explicitly skipping string stuff until it's reprioritized + Strings = JSModule['_BinaryenFeatureStrings'](), + */ + All = JSModule['_BinaryenFeatureAll']() +} +export enum Operations { + ClzInt32 = JSModule['_BinaryenClzInt32'](), + CtzInt32 = JSModule['_BinaryenCtzInt32'](), + PopcntInt32 = JSModule['_BinaryenPopcntInt32'](), + NegFloat32 = JSModule['_BinaryenNegFloat32'](), + AbsFloat32 = JSModule['_BinaryenAbsFloat32'](), + CeilFloat32 = JSModule['_BinaryenCeilFloat32'](), + FloorFloat32 = JSModule['_BinaryenFloorFloat32'](), + TruncFloat32 = JSModule['_BinaryenTruncFloat32'](), + NearestFloat32 = JSModule['_BinaryenNearestFloat32'](), + SqrtFloat32 = JSModule['_BinaryenSqrtFloat32'](), + EqZInt32 = JSModule['_BinaryenEqZInt32'](), + ClzInt64 = JSModule['_BinaryenClzInt64'](), + CtzInt64 = JSModule['_BinaryenCtzInt64'](), + PopcntInt64 = JSModule['_BinaryenPopcntInt64'](), + NegFloat64 = JSModule['_BinaryenNegFloat64'](), + AbsFloat64 = JSModule['_BinaryenAbsFloat64'](), + CeilFloat64 = JSModule['_BinaryenCeilFloat64'](), + FloorFloat64 = JSModule['_BinaryenFloorFloat64'](), + TruncFloat64 = JSModule['_BinaryenTruncFloat64'](), + NearestFloat64 = JSModule['_BinaryenNearestFloat64'](), + SqrtFloat64 = JSModule['_BinaryenSqrtFloat64'](), + EqZInt64 = JSModule['_BinaryenEqZInt64'](), + ExtendSInt32 = JSModule['_BinaryenExtendSInt32'](), + ExtendUInt32 = JSModule['_BinaryenExtendUInt32'](), + WrapInt64 = JSModule['_BinaryenWrapInt64'](), + TruncSFloat32ToInt32 = JSModule['_BinaryenTruncSFloat32ToInt32'](), + TruncSFloat32ToInt64 = JSModule['_BinaryenTruncSFloat32ToInt64'](), + TruncUFloat32ToInt32 = JSModule['_BinaryenTruncUFloat32ToInt32'](), + TruncUFloat32ToInt64 = JSModule['_BinaryenTruncUFloat32ToInt64'](), + TruncSFloat64ToInt32 = JSModule['_BinaryenTruncSFloat64ToInt32'](), + TruncSFloat64ToInt64 = JSModule['_BinaryenTruncSFloat64ToInt64'](), + TruncUFloat64ToInt32 = JSModule['_BinaryenTruncUFloat64ToInt32'](), + TruncUFloat64ToInt64 = JSModule['_BinaryenTruncUFloat64ToInt64'](), + TruncSatSFloat32ToInt32 = JSModule['_BinaryenTruncSatSFloat32ToInt32'](), + TruncSatSFloat32ToInt64 = JSModule['_BinaryenTruncSatSFloat32ToInt64'](), + TruncSatUFloat32ToInt32 = JSModule['_BinaryenTruncSatUFloat32ToInt32'](), + TruncSatUFloat32ToInt64 = JSModule['_BinaryenTruncSatUFloat32ToInt64'](), + TruncSatSFloat64ToInt32 = JSModule['_BinaryenTruncSatSFloat64ToInt32'](), + TruncSatSFloat64ToInt64 = JSModule['_BinaryenTruncSatSFloat64ToInt64'](), + TruncSatUFloat64ToInt32 = JSModule['_BinaryenTruncSatUFloat64ToInt32'](), + TruncSatUFloat64ToInt64 = JSModule['_BinaryenTruncSatUFloat64ToInt64'](), + ReinterpretFloat32 = JSModule['_BinaryenReinterpretFloat32'](), + ReinterpretFloat64 = JSModule['_BinaryenReinterpretFloat64'](), + ConvertSInt32ToFloat32 = JSModule['_BinaryenConvertSInt32ToFloat32'](), + ConvertSInt32ToFloat64 = JSModule['_BinaryenConvertSInt32ToFloat64'](), + ConvertUInt32ToFloat32 = JSModule['_BinaryenConvertUInt32ToFloat32'](), + ConvertUInt32ToFloat64 = JSModule['_BinaryenConvertUInt32ToFloat64'](), + ConvertSInt64ToFloat32 = JSModule['_BinaryenConvertSInt64ToFloat32'](), + ConvertSInt64ToFloat64 = JSModule['_BinaryenConvertSInt64ToFloat64'](), + ConvertUInt64ToFloat32 = JSModule['_BinaryenConvertUInt64ToFloat32'](), + ConvertUInt64ToFloat64 = JSModule['_BinaryenConvertUInt64ToFloat64'](), + PromoteFloat32 = JSModule['_BinaryenPromoteFloat32'](), + DemoteFloat64 = JSModule['_BinaryenDemoteFloat64'](), + ReinterpretInt32 = JSModule['_BinaryenReinterpretInt32'](), + ReinterpretInt64 = JSModule['_BinaryenReinterpretInt64'](), + ExtendS8Int32 = JSModule['_BinaryenExtendS8Int32'](), + ExtendS16Int32 = JSModule['_BinaryenExtendS16Int32'](), + ExtendS8Int64 = JSModule['_BinaryenExtendS8Int64'](), + ExtendS16Int64 = JSModule['_BinaryenExtendS16Int64'](), + ExtendS32Int64 = JSModule['_BinaryenExtendS32Int64'](), + AddInt32 = JSModule['_BinaryenAddInt32'](), + SubInt32 = JSModule['_BinaryenSubInt32'](), + MulInt32 = JSModule['_BinaryenMulInt32'](), + DivSInt32 = JSModule['_BinaryenDivSInt32'](), + DivUInt32 = JSModule['_BinaryenDivUInt32'](), + RemSInt32 = JSModule['_BinaryenRemSInt32'](), + RemUInt32 = JSModule['_BinaryenRemUInt32'](), + AndInt32 = JSModule['_BinaryenAndInt32'](), + OrInt32 = JSModule['_BinaryenOrInt32'](), + XorInt32 = JSModule['_BinaryenXorInt32'](), + ShlInt32 = JSModule['_BinaryenShlInt32'](), + ShrUInt32 = JSModule['_BinaryenShrUInt32'](), + ShrSInt32 = JSModule['_BinaryenShrSInt32'](), + RotLInt32 = JSModule['_BinaryenRotLInt32'](), + RotRInt32 = JSModule['_BinaryenRotRInt32'](), + EqInt32 = JSModule['_BinaryenEqInt32'](), + NeInt32 = JSModule['_BinaryenNeInt32'](), + LtSInt32 = JSModule['_BinaryenLtSInt32'](), + LtUInt32 = JSModule['_BinaryenLtUInt32'](), + LeSInt32 = JSModule['_BinaryenLeSInt32'](), + LeUInt32 = JSModule['_BinaryenLeUInt32'](), + GtSInt32 = JSModule['_BinaryenGtSInt32'](), + GtUInt32 = JSModule['_BinaryenGtUInt32'](), + GeSInt32 = JSModule['_BinaryenGeSInt32'](), + GeUInt32 = JSModule['_BinaryenGeUInt32'](), + AddInt64 = JSModule['_BinaryenAddInt64'](), + SubInt64 = JSModule['_BinaryenSubInt64'](), + MulInt64 = JSModule['_BinaryenMulInt64'](), + DivSInt64 = JSModule['_BinaryenDivSInt64'](), + DivUInt64 = JSModule['_BinaryenDivUInt64'](), + RemSInt64 = JSModule['_BinaryenRemSInt64'](), + RemUInt64 = JSModule['_BinaryenRemUInt64'](), + AndInt64 = JSModule['_BinaryenAndInt64'](), + OrInt64 = JSModule['_BinaryenOrInt64'](), + XorInt64 = JSModule['_BinaryenXorInt64'](), + ShlInt64 = JSModule['_BinaryenShlInt64'](), + ShrUInt64 = JSModule['_BinaryenShrUInt64'](), + ShrSInt64 = JSModule['_BinaryenShrSInt64'](), + RotLInt64 = JSModule['_BinaryenRotLInt64'](), + RotRInt64 = JSModule['_BinaryenRotRInt64'](), + EqInt64 = JSModule['_BinaryenEqInt64'](), + NeInt64 = JSModule['_BinaryenNeInt64'](), + LtSInt64 = JSModule['_BinaryenLtSInt64'](), + LtUInt64 = JSModule['_BinaryenLtUInt64'](), + LeSInt64 = JSModule['_BinaryenLeSInt64'](), + LeUInt64 = JSModule['_BinaryenLeUInt64'](), + GtSInt64 = JSModule['_BinaryenGtSInt64'](), + GtUInt64 = JSModule['_BinaryenGtUInt64'](), + GeSInt64 = JSModule['_BinaryenGeSInt64'](), + GeUInt64 = JSModule['_BinaryenGeUInt64'](), + AddFloat32 = JSModule['_BinaryenAddFloat32'](), + SubFloat32 = JSModule['_BinaryenSubFloat32'](), + MulFloat32 = JSModule['_BinaryenMulFloat32'](), + DivFloat32 = JSModule['_BinaryenDivFloat32'](), + CopySignFloat32 = JSModule['_BinaryenCopySignFloat32'](), + MinFloat32 = JSModule['_BinaryenMinFloat32'](), + MaxFloat32 = JSModule['_BinaryenMaxFloat32'](), + EqFloat32 = JSModule['_BinaryenEqFloat32'](), + NeFloat32 = JSModule['_BinaryenNeFloat32'](), + LtFloat32 = JSModule['_BinaryenLtFloat32'](), + LeFloat32 = JSModule['_BinaryenLeFloat32'](), + GtFloat32 = JSModule['_BinaryenGtFloat32'](), + GeFloat32 = JSModule['_BinaryenGeFloat32'](), + AddFloat64 = JSModule['_BinaryenAddFloat64'](), + SubFloat64 = JSModule['_BinaryenSubFloat64'](), + MulFloat64 = JSModule['_BinaryenMulFloat64'](), + DivFloat64 = JSModule['_BinaryenDivFloat64'](), + CopySignFloat64 = JSModule['_BinaryenCopySignFloat64'](), + MinFloat64 = JSModule['_BinaryenMinFloat64'](), + MaxFloat64 = JSModule['_BinaryenMaxFloat64'](), + EqFloat64 = JSModule['_BinaryenEqFloat64'](), + NeFloat64 = JSModule['_BinaryenNeFloat64'](), + LtFloat64 = JSModule['_BinaryenLtFloat64'](), + LeFloat64 = JSModule['_BinaryenLeFloat64'](), + GtFloat64 = JSModule['_BinaryenGtFloat64'](), + GeFloat64 = JSModule['_BinaryenGeFloat64'](), + AtomicRMWAdd = JSModule['_BinaryenAtomicRMWAdd'](), + AtomicRMWSub = JSModule['_BinaryenAtomicRMWSub'](), + AtomicRMWAnd = JSModule['_BinaryenAtomicRMWAnd'](), + AtomicRMWOr = JSModule['_BinaryenAtomicRMWOr'](), + AtomicRMWXor = JSModule['_BinaryenAtomicRMWXor'](), + AtomicRMWXchg = JSModule['_BinaryenAtomicRMWXchg'](), + SplatVecI8x16 = JSModule['_BinaryenSplatVecI8x16'](), + ExtractLaneSVecI8x16 = JSModule['_BinaryenExtractLaneSVecI8x16'](), + ExtractLaneUVecI8x16 = JSModule['_BinaryenExtractLaneUVecI8x16'](), + ReplaceLaneVecI8x16 = JSModule['_BinaryenReplaceLaneVecI8x16'](), + SplatVecI16x8 = JSModule['_BinaryenSplatVecI16x8'](), + ExtractLaneSVecI16x8 = JSModule['_BinaryenExtractLaneSVecI16x8'](), + ExtractLaneUVecI16x8 = JSModule['_BinaryenExtractLaneUVecI16x8'](), + ReplaceLaneVecI16x8 = JSModule['_BinaryenReplaceLaneVecI16x8'](), + SplatVecI32x4 = JSModule['_BinaryenSplatVecI32x4'](), + ExtractLaneVecI32x4 = JSModule['_BinaryenExtractLaneVecI32x4'](), + ReplaceLaneVecI32x4 = JSModule['_BinaryenReplaceLaneVecI32x4'](), + SplatVecI64x2 = JSModule['_BinaryenSplatVecI64x2'](), + ExtractLaneVecI64x2 = JSModule['_BinaryenExtractLaneVecI64x2'](), + ReplaceLaneVecI64x2 = JSModule['_BinaryenReplaceLaneVecI64x2'](), + SplatVecF32x4 = JSModule['_BinaryenSplatVecF32x4'](), + ExtractLaneVecF32x4 = JSModule['_BinaryenExtractLaneVecF32x4'](), + ReplaceLaneVecF32x4 = JSModule['_BinaryenReplaceLaneVecF32x4'](), + SplatVecF64x2 = JSModule['_BinaryenSplatVecF64x2'](), + ExtractLaneVecF64x2 = JSModule['_BinaryenExtractLaneVecF64x2'](), + ReplaceLaneVecF64x2 = JSModule['_BinaryenReplaceLaneVecF64x2'](), + EqVecI8x16 = JSModule['_BinaryenEqVecI8x16'](), + NeVecI8x16 = JSModule['_BinaryenNeVecI8x16'](), + LtSVecI8x16 = JSModule['_BinaryenLtSVecI8x16'](), + LtUVecI8x16 = JSModule['_BinaryenLtUVecI8x16'](), + GtSVecI8x16 = JSModule['_BinaryenGtSVecI8x16'](), + GtUVecI8x16 = JSModule['_BinaryenGtUVecI8x16'](), + LeSVecI8x16 = JSModule['_BinaryenLeSVecI8x16'](), + LeUVecI8x16 = JSModule['_BinaryenLeUVecI8x16'](), + GeSVecI8x16 = JSModule['_BinaryenGeSVecI8x16'](), + GeUVecI8x16 = JSModule['_BinaryenGeUVecI8x16'](), + EqVecI16x8 = JSModule['_BinaryenEqVecI16x8'](), + NeVecI16x8 = JSModule['_BinaryenNeVecI16x8'](), + LtSVecI16x8 = JSModule['_BinaryenLtSVecI16x8'](), + LtUVecI16x8 = JSModule['_BinaryenLtUVecI16x8'](), + GtSVecI16x8 = JSModule['_BinaryenGtSVecI16x8'](), + GtUVecI16x8 = JSModule['_BinaryenGtUVecI16x8'](), + LeSVecI16x8 = JSModule['_BinaryenLeSVecI16x8'](), + LeUVecI16x8 = JSModule['_BinaryenLeUVecI16x8'](), + GeSVecI16x8 = JSModule['_BinaryenGeSVecI16x8'](), + GeUVecI16x8 = JSModule['_BinaryenGeUVecI16x8'](), + EqVecI32x4 = JSModule['_BinaryenEqVecI32x4'](), + NeVecI32x4 = JSModule['_BinaryenNeVecI32x4'](), + LtSVecI32x4 = JSModule['_BinaryenLtSVecI32x4'](), + LtUVecI32x4 = JSModule['_BinaryenLtUVecI32x4'](), + GtSVecI32x4 = JSModule['_BinaryenGtSVecI32x4'](), + GtUVecI32x4 = JSModule['_BinaryenGtUVecI32x4'](), + LeSVecI32x4 = JSModule['_BinaryenLeSVecI32x4'](), + LeUVecI32x4 = JSModule['_BinaryenLeUVecI32x4'](), + GeSVecI32x4 = JSModule['_BinaryenGeSVecI32x4'](), + GeUVecI32x4 = JSModule['_BinaryenGeUVecI32x4'](), + EqVecI64x2 = JSModule['_BinaryenEqVecI64x2'](), + NeVecI64x2 = JSModule['_BinaryenNeVecI64x2'](), + LtSVecI64x2 = JSModule['_BinaryenLtSVecI64x2'](), + GtSVecI64x2 = JSModule['_BinaryenGtSVecI64x2'](), + LeSVecI64x2 = JSModule['_BinaryenLeSVecI64x2'](), + GeSVecI64x2 = JSModule['_BinaryenGeSVecI64x2'](), + EqVecF32x4 = JSModule['_BinaryenEqVecF32x4'](), + NeVecF32x4 = JSModule['_BinaryenNeVecF32x4'](), + LtVecF32x4 = JSModule['_BinaryenLtVecF32x4'](), + GtVecF32x4 = JSModule['_BinaryenGtVecF32x4'](), + LeVecF32x4 = JSModule['_BinaryenLeVecF32x4'](), + GeVecF32x4 = JSModule['_BinaryenGeVecF32x4'](), + EqVecF64x2 = JSModule['_BinaryenEqVecF64x2'](), + NeVecF64x2 = JSModule['_BinaryenNeVecF64x2'](), + LtVecF64x2 = JSModule['_BinaryenLtVecF64x2'](), + GtVecF64x2 = JSModule['_BinaryenGtVecF64x2'](), + LeVecF64x2 = JSModule['_BinaryenLeVecF64x2'](), + GeVecF64x2 = JSModule['_BinaryenGeVecF64x2'](), + NotVec128 = JSModule['_BinaryenNotVec128'](), + AndVec128 = JSModule['_BinaryenAndVec128'](), + OrVec128 = JSModule['_BinaryenOrVec128'](), + XorVec128 = JSModule['_BinaryenXorVec128'](), + AndNotVec128 = JSModule['_BinaryenAndNotVec128'](), + BitselectVec128 = JSModule['_BinaryenBitselectVec128'](), + RelaxedFmaVecF32x4 = JSModule['_BinaryenRelaxedFmaVecF32x4'](), + RelaxedFmsVecF32x4 = JSModule['_BinaryenRelaxedFmsVecF32x4'](), + RelaxedFmaVecF64x2 = JSModule['_BinaryenRelaxedFmaVecF64x2'](), + RelaxedFmsVecF64x2 = JSModule['_BinaryenRelaxedFmsVecF64x2'](), + LaneselectI8x16 = JSModule['_BinaryenLaneselectI8x16'](), + LaneselectI16x8 = JSModule['_BinaryenLaneselectI16x8'](), + LaneselectI32x4 = JSModule['_BinaryenLaneselectI32x4'](), + LaneselectI64x2 = JSModule['_BinaryenLaneselectI64x2'](), + DotI8x16I7x16AddSToVecI32x4 = JSModule['_BinaryenDotI8x16I7x16AddSToVecI32x4'](), + AnyTrueVec128 = JSModule['_BinaryenAnyTrueVec128'](), + PopcntVecI8x16 = JSModule['_BinaryenPopcntVecI8x16'](), + AbsVecI8x16 = JSModule['_BinaryenAbsVecI8x16'](), + NegVecI8x16 = JSModule['_BinaryenNegVecI8x16'](), + AllTrueVecI8x16 = JSModule['_BinaryenAllTrueVecI8x16'](), + BitmaskVecI8x16 = JSModule['_BinaryenBitmaskVecI8x16'](), + ShlVecI8x16 = JSModule['_BinaryenShlVecI8x16'](), + ShrSVecI8x16 = JSModule['_BinaryenShrSVecI8x16'](), + ShrUVecI8x16 = JSModule['_BinaryenShrUVecI8x16'](), + AddVecI8x16 = JSModule['_BinaryenAddVecI8x16'](), + AddSatSVecI8x16 = JSModule['_BinaryenAddSatSVecI8x16'](), + AddSatUVecI8x16 = JSModule['_BinaryenAddSatUVecI8x16'](), + SubVecI8x16 = JSModule['_BinaryenSubVecI8x16'](), + SubSatSVecI8x16 = JSModule['_BinaryenSubSatSVecI8x16'](), + SubSatUVecI8x16 = JSModule['_BinaryenSubSatUVecI8x16'](), + MinSVecI8x16 = JSModule['_BinaryenMinSVecI8x16'](), + MinUVecI8x16 = JSModule['_BinaryenMinUVecI8x16'](), + MaxSVecI8x16 = JSModule['_BinaryenMaxSVecI8x16'](), + MaxUVecI8x16 = JSModule['_BinaryenMaxUVecI8x16'](), + AvgrUVecI8x16 = JSModule['_BinaryenAvgrUVecI8x16'](), + AbsVecI16x8 = JSModule['_BinaryenAbsVecI16x8'](), + NegVecI16x8 = JSModule['_BinaryenNegVecI16x8'](), + AllTrueVecI16x8 = JSModule['_BinaryenAllTrueVecI16x8'](), + BitmaskVecI16x8 = JSModule['_BinaryenBitmaskVecI16x8'](), + ShlVecI16x8 = JSModule['_BinaryenShlVecI16x8'](), + ShrSVecI16x8 = JSModule['_BinaryenShrSVecI16x8'](), + ShrUVecI16x8 = JSModule['_BinaryenShrUVecI16x8'](), + AddVecI16x8 = JSModule['_BinaryenAddVecI16x8'](), + AddSatSVecI16x8 = JSModule['_BinaryenAddSatSVecI16x8'](), + AddSatUVecI16x8 = JSModule['_BinaryenAddSatUVecI16x8'](), + SubVecI16x8 = JSModule['_BinaryenSubVecI16x8'](), + SubSatSVecI16x8 = JSModule['_BinaryenSubSatSVecI16x8'](), + SubSatUVecI16x8 = JSModule['_BinaryenSubSatUVecI16x8'](), + MulVecI16x8 = JSModule['_BinaryenMulVecI16x8'](), + MinSVecI16x8 = JSModule['_BinaryenMinSVecI16x8'](), + MinUVecI16x8 = JSModule['_BinaryenMinUVecI16x8'](), + MaxSVecI16x8 = JSModule['_BinaryenMaxSVecI16x8'](), + MaxUVecI16x8 = JSModule['_BinaryenMaxUVecI16x8'](), + AvgrUVecI16x8 = JSModule['_BinaryenAvgrUVecI16x8'](), + Q15MulrSatSVecI16x8 = JSModule['_BinaryenQ15MulrSatSVecI16x8'](), + ExtMulLowSVecI16x8 = JSModule['_BinaryenExtMulLowSVecI16x8'](), + ExtMulHighSVecI16x8 = JSModule['_BinaryenExtMulHighSVecI16x8'](), + ExtMulLowUVecI16x8 = JSModule['_BinaryenExtMulLowUVecI16x8'](), + ExtMulHighUVecI16x8 = JSModule['_BinaryenExtMulHighUVecI16x8'](), + DotSVecI16x8ToVecI32x4 = JSModule['_BinaryenDotSVecI16x8ToVecI32x4'](), + ExtMulLowSVecI32x4 = JSModule['_BinaryenExtMulLowSVecI32x4'](), + ExtMulHighSVecI32x4 = JSModule['_BinaryenExtMulHighSVecI32x4'](), + ExtMulLowUVecI32x4 = JSModule['_BinaryenExtMulLowUVecI32x4'](), + ExtMulHighUVecI32x4 = JSModule['_BinaryenExtMulHighUVecI32x4'](), + AbsVecI32x4 = JSModule['_BinaryenAbsVecI32x4'](), + NegVecI32x4 = JSModule['_BinaryenNegVecI32x4'](), + AllTrueVecI32x4 = JSModule['_BinaryenAllTrueVecI32x4'](), + BitmaskVecI32x4 = JSModule['_BinaryenBitmaskVecI32x4'](), + ShlVecI32x4 = JSModule['_BinaryenShlVecI32x4'](), + ShrSVecI32x4 = JSModule['_BinaryenShrSVecI32x4'](), + ShrUVecI32x4 = JSModule['_BinaryenShrUVecI32x4'](), + AddVecI32x4 = JSModule['_BinaryenAddVecI32x4'](), + SubVecI32x4 = JSModule['_BinaryenSubVecI32x4'](), + MulVecI32x4 = JSModule['_BinaryenMulVecI32x4'](), + MinSVecI32x4 = JSModule['_BinaryenMinSVecI32x4'](), + MinUVecI32x4 = JSModule['_BinaryenMinUVecI32x4'](), + MaxSVecI32x4 = JSModule['_BinaryenMaxSVecI32x4'](), + MaxUVecI32x4 = JSModule['_BinaryenMaxUVecI32x4'](), + AbsVecI64x2 = JSModule['_BinaryenAbsVecI64x2'](), + NegVecI64x2 = JSModule['_BinaryenNegVecI64x2'](), + AllTrueVecI64x2 = JSModule['_BinaryenAllTrueVecI64x2'](), + BitmaskVecI64x2 = JSModule['_BinaryenBitmaskVecI64x2'](), + ShlVecI64x2 = JSModule['_BinaryenShlVecI64x2'](), + ShrSVecI64x2 = JSModule['_BinaryenShrSVecI64x2'](), + ShrUVecI64x2 = JSModule['_BinaryenShrUVecI64x2'](), + AddVecI64x2 = JSModule['_BinaryenAddVecI64x2'](), + SubVecI64x2 = JSModule['_BinaryenSubVecI64x2'](), + MulVecI64x2 = JSModule['_BinaryenMulVecI64x2'](), + ExtMulLowSVecI64x2 = JSModule['_BinaryenExtMulLowSVecI64x2'](), + ExtMulHighSVecI64x2 = JSModule['_BinaryenExtMulHighSVecI64x2'](), + ExtMulLowUVecI64x2 = JSModule['_BinaryenExtMulLowUVecI64x2'](), + ExtMulHighUVecI64x2 = JSModule['_BinaryenExtMulHighUVecI64x2'](), + AbsVecF32x4 = JSModule['_BinaryenAbsVecF32x4'](), + NegVecF32x4 = JSModule['_BinaryenNegVecF32x4'](), + SqrtVecF32x4 = JSModule['_BinaryenSqrtVecF32x4'](), + AddVecF32x4 = JSModule['_BinaryenAddVecF32x4'](), + SubVecF32x4 = JSModule['_BinaryenSubVecF32x4'](), + MulVecF32x4 = JSModule['_BinaryenMulVecF32x4'](), + DivVecF32x4 = JSModule['_BinaryenDivVecF32x4'](), + MinVecF32x4 = JSModule['_BinaryenMinVecF32x4'](), + MaxVecF32x4 = JSModule['_BinaryenMaxVecF32x4'](), + PMinVecF32x4 = JSModule['_BinaryenPMinVecF32x4'](), + PMaxVecF32x4 = JSModule['_BinaryenPMaxVecF32x4'](), + CeilVecF32x4 = JSModule['_BinaryenCeilVecF32x4'](), + FloorVecF32x4 = JSModule['_BinaryenFloorVecF32x4'](), + TruncVecF32x4 = JSModule['_BinaryenTruncVecF32x4'](), + NearestVecF32x4 = JSModule['_BinaryenNearestVecF32x4'](), + AbsVecF64x2 = JSModule['_BinaryenAbsVecF64x2'](), + NegVecF64x2 = JSModule['_BinaryenNegVecF64x2'](), + SqrtVecF64x2 = JSModule['_BinaryenSqrtVecF64x2'](), + AddVecF64x2 = JSModule['_BinaryenAddVecF64x2'](), + SubVecF64x2 = JSModule['_BinaryenSubVecF64x2'](), + MulVecF64x2 = JSModule['_BinaryenMulVecF64x2'](), + DivVecF64x2 = JSModule['_BinaryenDivVecF64x2'](), + MinVecF64x2 = JSModule['_BinaryenMinVecF64x2'](), + MaxVecF64x2 = JSModule['_BinaryenMaxVecF64x2'](), + PMinVecF64x2 = JSModule['_BinaryenPMinVecF64x2'](), + PMaxVecF64x2 = JSModule['_BinaryenPMaxVecF64x2'](), + CeilVecF64x2 = JSModule['_BinaryenCeilVecF64x2'](), + FloorVecF64x2 = JSModule['_BinaryenFloorVecF64x2'](), + TruncVecF64x2 = JSModule['_BinaryenTruncVecF64x2'](), + NearestVecF64x2 = JSModule['_BinaryenNearestVecF64x2'](), + ExtAddPairwiseSVecI8x16ToI16x8 = JSModule['_BinaryenExtAddPairwiseSVecI8x16ToI16x8'](), + ExtAddPairwiseUVecI8x16ToI16x8 = JSModule['_BinaryenExtAddPairwiseUVecI8x16ToI16x8'](), + ExtAddPairwiseSVecI16x8ToI32x4 = JSModule['_BinaryenExtAddPairwiseSVecI16x8ToI32x4'](), + ExtAddPairwiseUVecI16x8ToI32x4 = JSModule['_BinaryenExtAddPairwiseUVecI16x8ToI32x4'](), + TruncSatSVecF32x4ToVecI32x4 = JSModule['_BinaryenTruncSatSVecF32x4ToVecI32x4'](), + TruncSatUVecF32x4ToVecI32x4 = JSModule['_BinaryenTruncSatUVecF32x4ToVecI32x4'](), + ConvertSVecI32x4ToVecF32x4 = JSModule['_BinaryenConvertSVecI32x4ToVecF32x4'](), + ConvertUVecI32x4ToVecF32x4 = JSModule['_BinaryenConvertUVecI32x4ToVecF32x4'](), + Load8SplatVec128 = JSModule['_BinaryenLoad8SplatVec128'](), + Load16SplatVec128 = JSModule['_BinaryenLoad16SplatVec128'](), + Load32SplatVec128 = JSModule['_BinaryenLoad32SplatVec128'](), + Load64SplatVec128 = JSModule['_BinaryenLoad64SplatVec128'](), + Load8x8SVec128 = JSModule['_BinaryenLoad8x8SVec128'](), + Load8x8UVec128 = JSModule['_BinaryenLoad8x8UVec128'](), + Load16x4SVec128 = JSModule['_BinaryenLoad16x4SVec128'](), + Load16x4UVec128 = JSModule['_BinaryenLoad16x4UVec128'](), + Load32x2SVec128 = JSModule['_BinaryenLoad32x2SVec128'](), + Load32x2UVec128 = JSModule['_BinaryenLoad32x2UVec128'](), + Load32ZeroVec128 = JSModule['_BinaryenLoad32ZeroVec128'](), + Load64ZeroVec128 = JSModule['_BinaryenLoad64ZeroVec128'](), + Load8LaneVec128 = JSModule['_BinaryenLoad8LaneVec128'](), + Load16LaneVec128 = JSModule['_BinaryenLoad16LaneVec128'](), + Load32LaneVec128 = JSModule['_BinaryenLoad32LaneVec128'](), + Load64LaneVec128 = JSModule['_BinaryenLoad64LaneVec128'](), + Store8LaneVec128 = JSModule['_BinaryenStore8LaneVec128'](), + Store16LaneVec128 = JSModule['_BinaryenStore16LaneVec128'](), + Store32LaneVec128 = JSModule['_BinaryenStore32LaneVec128'](), + Store64LaneVec128 = JSModule['_BinaryenStore64LaneVec128'](), + NarrowSVecI16x8ToVecI8x16 = JSModule['_BinaryenNarrowSVecI16x8ToVecI8x16'](), + NarrowUVecI16x8ToVecI8x16 = JSModule['_BinaryenNarrowUVecI16x8ToVecI8x16'](), + NarrowSVecI32x4ToVecI16x8 = JSModule['_BinaryenNarrowSVecI32x4ToVecI16x8'](), + NarrowUVecI32x4ToVecI16x8 = JSModule['_BinaryenNarrowUVecI32x4ToVecI16x8'](), + ExtendLowSVecI8x16ToVecI16x8 = JSModule['_BinaryenExtendLowSVecI8x16ToVecI16x8'](), + ExtendHighSVecI8x16ToVecI16x8 = JSModule['_BinaryenExtendHighSVecI8x16ToVecI16x8'](), + ExtendLowUVecI8x16ToVecI16x8 = JSModule['_BinaryenExtendLowUVecI8x16ToVecI16x8'](), + ExtendHighUVecI8x16ToVecI16x8 = JSModule['_BinaryenExtendHighUVecI8x16ToVecI16x8'](), + ExtendLowSVecI16x8ToVecI32x4 = JSModule['_BinaryenExtendLowSVecI16x8ToVecI32x4'](), + ExtendHighSVecI16x8ToVecI32x4 = JSModule['_BinaryenExtendHighSVecI16x8ToVecI32x4'](), + ExtendLowUVecI16x8ToVecI32x4 = JSModule['_BinaryenExtendLowUVecI16x8ToVecI32x4'](), + ExtendHighUVecI16x8ToVecI32x4 = JSModule['_BinaryenExtendHighUVecI16x8ToVecI32x4'](), + ExtendLowSVecI32x4ToVecI64x2 = JSModule['_BinaryenExtendLowSVecI32x4ToVecI64x2'](), + ExtendHighSVecI32x4ToVecI64x2 = JSModule['_BinaryenExtendHighSVecI32x4ToVecI64x2'](), + ExtendLowUVecI32x4ToVecI64x2 = JSModule['_BinaryenExtendLowUVecI32x4ToVecI64x2'](), + ExtendHighUVecI32x4ToVecI64x2 = JSModule['_BinaryenExtendHighUVecI32x4ToVecI64x2'](), + ConvertLowSVecI32x4ToVecF64x2 = JSModule['_BinaryenConvertLowSVecI32x4ToVecF64x2'](), + ConvertLowUVecI32x4ToVecF64x2 = JSModule['_BinaryenConvertLowUVecI32x4ToVecF64x2'](), + TruncSatZeroSVecF64x2ToVecI32x4 = JSModule['_BinaryenTruncSatZeroSVecF64x2ToVecI32x4'](), + TruncSatZeroUVecF64x2ToVecI32x4 = JSModule['_BinaryenTruncSatZeroUVecF64x2ToVecI32x4'](), + DemoteZeroVecF64x2ToVecF32x4 = JSModule['_BinaryenDemoteZeroVecF64x2ToVecF32x4'](), + PromoteLowVecF32x4ToVecF64x2 = JSModule['_BinaryenPromoteLowVecF32x4ToVecF64x2'](), + RelaxedTruncSVecF32x4ToVecI32x4 = JSModule['_BinaryenRelaxedTruncSVecF32x4ToVecI32x4'](), + RelaxedTruncUVecF32x4ToVecI32x4 = JSModule['_BinaryenRelaxedTruncUVecF32x4ToVecI32x4'](), + RelaxedTruncZeroSVecF64x2ToVecI32x4 = JSModule['_BinaryenRelaxedTruncZeroSVecF64x2ToVecI32x4'](), + RelaxedTruncZeroUVecF64x2ToVecI32x4 = JSModule['_BinaryenRelaxedTruncZeroUVecF64x2ToVecI32x4'](), + SwizzleVecI8x16 = JSModule['_BinaryenSwizzleVecI8x16'](), + RelaxedSwizzleVecI8x16 = JSModule['_BinaryenRelaxedSwizzleVecI8x16'](), + RelaxedMinVecF32x4 = JSModule['_BinaryenRelaxedMinVecF32x4'](), + RelaxedMaxVecF32x4 = JSModule['_BinaryenRelaxedMaxVecF32x4'](), + RelaxedMinVecF64x2 = JSModule['_BinaryenRelaxedMinVecF64x2'](), + RelaxedMaxVecF64x2 = JSModule['_BinaryenRelaxedMaxVecF64x2'](), + RelaxedQ15MulrSVecI16x8 = JSModule['_BinaryenRelaxedQ15MulrSVecI16x8'](), + DotI8x16I7x16SToVecI16x8 = JSModule['_BinaryenDotI8x16I7x16SToVecI16x8'](), + RefAsNonNull = JSModule['_BinaryenRefAsNonNull'](), + RefAsExternInternalize = JSModule['_BinaryenRefAsExternInternalize'](), + RefAsExternExternalize = JSModule['_BinaryenRefAsExternExternalize'](), + BrOnNull = JSModule['_BinaryenBrOnNull'](), + BrOnNonNull = JSModule['_BinaryenBrOnNonNull'](), + BrOnCast = JSModule['_BinaryenBrOnCast'](), + BrOnCastFail = JSModule['_BinaryenBrOnCastFail'](), + /* explicitly skipping string stuff until it's reprioritized + StringNewUTF8 = JSModule['_BinaryenStringNewUTF8'](), + StringNewWTF8 = JSModule['_BinaryenStringNewWTF8'](), + StringNewLossyUTF8 = JSModule['_BinaryenStringNewLossyUTF8'](), + StringNewWTF16 = JSModule['_BinaryenStringNewWTF16'](), + StringNewUTF8Array = JSModule['_BinaryenStringNewUTF8Array'](), + StringNewWTF8Array = JSModule['_BinaryenStringNewWTF8Array'](), + StringNewLossyUTF8Array = JSModule['_BinaryenStringNewLossyUTF8Array'](), + StringNewWTF16Array = JSModule['_BinaryenStringNewWTF16Array'](), + StringNewFromCodePoint = JSModule['_BinaryenStringNewFromCodePoint'](), + StringMeasureUTF8 = JSModule['_BinaryenStringMeasureUTF8'](), + StringMeasureWTF8 = JSModule['_BinaryenStringMeasureWTF8'](), + StringMeasureWTF16 = JSModule['_BinaryenStringMeasureWTF16'](), + StringMeasureIsUSV = JSModule['_BinaryenStringMeasureIsUSV'](), + StringMeasureWTF16View = JSModule['_BinaryenStringMeasureWTF16View'](), + StringEncodeUTF8 = JSModule['_BinaryenStringEncodeUTF8'](), + StringEncodeLossyUTF8 = JSModule['_BinaryenStringEncodeLossyUTF8'](), + StringEncodeWTF8 = JSModule['_BinaryenStringEncodeWTF8'](), + StringEncodeWTF16 = JSModule['_BinaryenStringEncodeWTF16'](), + StringEncodeUTF8Array = JSModule['_BinaryenStringEncodeUTF8Array'](), + StringEncodeLossyUTF8Array = JSModule['_BinaryenStringEncodeLossyUTF8Array'](), + StringEncodeWTF8Array = JSModule['_BinaryenStringEncodeWTF8Array'](), + StringEncodeWTF16Array = JSModule['_BinaryenStringEncodeWTF16Array'](), + StringAsWTF8 = JSModule['_BinaryenStringAsWTF8'](), + StringAsWTF16 = JSModule['_BinaryenStringAsWTF16'](), + StringAsIter = JSModule['_BinaryenStringAsIter'](), + StringIterMoveAdvance = JSModule['_BinaryenStringIterMoveAdvance'](), + StringIterMoveRewind = JSModule['_BinaryenStringIterMoveRewind'](), + StringSliceWTF8 = JSModule['_BinaryenStringSliceWTF8'](), + StringSliceWTF16 = JSModule['_BinaryenStringSliceWTF16'](), + StringEqEqual = JSModule['_BinaryenStringEqEqual'](), + StringEqCompare = JSModule['_BinaryenStringEqCompare']() + */ +} + +export enum SideEffects { + None = JSModule['_BinaryenSideEffectNone'](), + Branches = JSModule['_BinaryenSideEffectBranches'](), + Calls = JSModule['_BinaryenSideEffectCalls'](), + ReadsLocal = JSModule['_BinaryenSideEffectReadsLocal'](), + WritesLocal = JSModule['_BinaryenSideEffectWritesLocal'](), + ReadsGlobal = JSModule['_BinaryenSideEffectReadsGlobal'](), + WritesGlobal = JSModule['_BinaryenSideEffectWritesGlobal'](), + ReadsMemory = JSModule['_BinaryenSideEffectReadsMemory'](), + WritesMemory = JSModule['_BinaryenSideEffectWritesMemory'](), + ReadsTable = JSModule['_BinaryenSideEffectReadsTable'](), + WritesTable = JSModule['_BinaryenSideEffectWritesTable'](), + ImplicitTrap = JSModule['_BinaryenSideEffectImplicitTrap'](), + IsAtomic = JSModule['_BinaryenSideEffectIsAtomic'](), + Throws = JSModule['_BinaryenSideEffectThrows'](), + DanglingPop = JSModule['_BinaryenSideEffectDanglingPop'](), + TrapsNeverHappen = JSModule['_BinaryenSideEffectTrapsNeverHappen'](), + Any = JSModule['_BinaryenSideEffectAny']() +} + +export enum PackedType { + NotPacked = JSModule['_BinaryenPackedTypeNotPacked'](), + Int8 = JSModule['_BinaryenPackedTypeInt8'](), + Int16 = JSModule['_BinaryenPackedTypeInt16']() +} + +export class Function { + + readonly func: FunctionRef; + + constructor(func: FunctionRef) { + this.func = func; + } + + getName(): string { + return UTF8ToString(JSModule['_BinaryenFunctionGetName'](this.func)); + } + getParams(): Type { + return JSModule['_BinaryenFunctionGetParams'](this.func); + } + getResults(): Type { + return JSModule['_BinaryenFunctionGetResults'](this.func); + } + getNumVars(): number { + return JSModule['_BinaryenFunctionGetNumVars'](this.func); + } + getVar(index: number): Type { + return JSModule['_BinaryenFunctionGetVar'](this.func, index); + } + getNumLocals(): number { + return JSModule['_BinaryenFunctionGetNumLocals'](this.func); + } + hasLocalName(index: number): boolean { + return Boolean(JSModule['_BinaryenFunctionHasLocalName'](this.func, index)); + } + getLocalName(index: number): string { + return UTF8ToString(JSModule['_BinaryenFunctionGetLocalName'](this.func, index)); + } + setLocalName(index: number, name: string): void { + preserveStack(() => { + JSModule['_BinaryenFunctionSetLocalName'](this.func, index, strToStack(name)); + }); + } + getBody(): ExpressionRef { + return JSModule['_BinaryenFunctionGetBody'](this.func); + } + setBody(bodyExpr: ExpressionRef): void { + JSModule['_BinaryenFunctionSetBody'](this.func, bodyExpr); + } + setDebugLocation(expr: ExpressionRef, fileIndex: number, lineNumber: number, columnNumber: number): void { + JSModule['_BinaryenFunctionSetDebugLocation'](this.func, expr, fileIndex, lineNumber, columnNumber); + } + getInfo(): FunctionInfo { + return { + 'name': this.getName(), + 'module': UTF8ToString(JSModule['_BinaryenFunctionImportGetModule'](this.func)), + 'base': UTF8ToString(JSModule['_BinaryenFunctionImportGetBase'](this.func)), + 'params': this.getParams(), + 'results': this.getResults(), + 'vars': getAllNested(this.func, this.getNumVars, this.getVar), + 'body':this.getBody() + }; + } +} + +export interface FunctionInfo { + name: string; + module: string | null; + base: string | null; + params: Type; + results: Type; + vars: Type[]; + body: ExpressionRef; +} + +export interface TableInfo { + name: string; + module: string | null; + base: string | null; + initial: number; + max?: number; +} + +export interface ElementSegmentInfo { + name: string, + table: string, + offset: number, + data: string[] +} + +export interface GlobalInfo { + name: string; + module: string | null; + base: string | null; + type: Type; + mutable: boolean; + init: ExpressionRef; +} + +export interface TagInfo { + name: string; + module: string | null; + base: string | null; + params: Type; + results: Type; +} + +export interface ExportInfo { + kind: ExternalKinds; + name: string; + value: string; +} + +function getOptimizeLevel(): number { + return JSModule['_BinaryenGetOptimizeLevel'](); +} +function setOptimizeLevel(level: number): void { + JSModule['_BinaryenSetOptimizeLevel'](level); +} +function getShrinkLevel(): number { + return JSModule['_BinaryenGetShrinkLevel'](); +} +function setShrinkLevel(level: number): void { + JSModule['_BinaryenSetShrinkLevel'](level); +} +function getDebugInfo(): boolean { + return Boolean(JSModule['_BinaryenGetDebugInfo']()); +} +function setDebugInfo(on: boolean): void { + JSModule['_BinaryenSetDebugInfo'](on); +} +function getLowMemoryUnused(): boolean { + return Boolean(JSModule['_BinaryenGetLowMemoryUnused']()); +} +function setLowMemoryUnused(on: boolean): void { + JSModule['_BinaryenSetLowMemoryUnused'](on); +} +function getZeroFilledMemory(): boolean { + return Boolean(JSModule['_BinaryenGetZeroFilledMemory']()); +} +function setZeroFilledMemory(on: boolean): void { + JSModule['_BinaryenSetZeroFilledMemory'](on); +} +function getFastMath(): boolean { + return Boolean(JSModule['_BinaryenGetFastMath']()); +} +function setFastMath(on: boolean): void { + JSModule['_BinaryenSetFastMath'](on); +} +function getPassArgument(key: string): string | null { + return preserveStack(() => { + const ret = JSModule['_BinaryenGetPassArgument'](strToStack(key)); + return ret !== 0 ? UTF8ToString(ret) : null; + }); +} +function setPassArgument(key: string, value: string | null): void { + preserveStack(() => { JSModule['_BinaryenSetPassArgument'](strToStack(key), strToStack(value)) }); +} +function clearPassArguments(): void { + JSModule['_BinaryenClearPassArguments'](); +} +function getAlwaysInlineMaxSize(): number { + return JSModule['_BinaryenGetAlwaysInlineMaxSize'](); +} +function setAlwaysInlineMaxSize(size: number): void { + JSModule['_BinaryenSetAlwaysInlineMaxSize'](size); +} +function getFlexibleInlineMaxSize(): number { + return JSModule['_BinaryenGetFlexibleInlineMaxSize'](); +} +function setFlexibleInlineMaxSize(size: number): void { + JSModule['_BinaryenSetFlexibleInlineMaxSize'](size); +} +function getOneCallerInlineMaxSize(): number { + return JSModule['_BinaryenGetOneCallerInlineMaxSize'](); +} +function setOneCallerInlineMaxSize(size: number): void { + JSModule['_BinaryenSetOneCallerInlineMaxSize'](size); +} +function getAllowInliningFunctionsWithLoops(): boolean { + return Boolean(JSModule['_BinaryenGetAllowInliningFunctionsWithLoops']()); +} +function setAllowInliningFunctionsWithLoops(on: boolean): void { + JSModule['_BinaryenSetAllowInliningFunctionsWithLoops'](on); +} +function exit(status: number): void { + if (status != 0) + throw new Error('Exiting due to error: ' + status); +} + +export class Module { + + static readBinary(data: Uint8Array): Module { + const buffer = _malloc(data.length); + HEAP8.set(data, buffer); + const ptr = JSModule['_BinaryenModuleRead'](buffer, data.length); + _free(buffer); + return new Module(ptr); + } + + static parseText(text: string): Module { + const buffer = _malloc(text.length + 1); + stringToAscii(text, buffer); + const ptr = JSModule['_BinaryenModuleParse'](buffer); + _free(buffer); + return new Module(ptr); + } + + readonly ptr: number; + + constructor(ptr?: number) { + this.ptr = ptr || JSModule['_BinaryenModuleCreate'](); + } + dispose(): void { + JSModule['_BinaryenModuleDispose'](this.ptr); + } + setStart(start: FunctionRef): void { + JSModule['_BinaryenSetStart'](this.ptr, start); + } + setFeatures(... features: Feature[]): void { + const flags = features.reduce((previous, current) => previous |= current, 0); + JSModule['_BinaryenModuleSetFeatures'](this.ptr, flags); + } + getFeatures(): Set { + const flags = JSModule['_BinaryenModuleGetFeatures'](this.ptr); + const features = new Set(); + Object.keys(Feature).forEach(key => { + const entry = Feature[key as keyof typeof Feature]; + if(typeof(entry) == "string" && entry != "All") { + const value = Feature[entry as keyof typeof Feature]; + if ((flags & value) != 0) + features.add(value); + } + }); + return features; + } + addFeature(feature: Feature): void { + let flags = JSModule['_BinaryenModuleGetFeatures'](this.ptr); + flags |= feature; + JSModule['_BinaryenModuleSetFeatures'](this.ptr, flags); + } + + hasFeature(feature: Feature): boolean { + const flags = JSModule['_BinaryenModuleGetFeatures'](this.ptr); + return (flags & feature) != 0; + } + + autoDrop(): void { + JSModule['_BinaryenModuleAutoDrop'](this.ptr); + } + addCustomSection(name: string, contents: Uint8Array): void { + preserveStack(() => + JSModule['_BinaryenAddCustomSection'](this.ptr, strToStack(name), i8sToStack(contents), contents.length) + ); + } + addDebugInfoFileName(filename: string): number { + return preserveStack(() => JSModule['_BinaryenModuleAddDebugInfoFileName'](this.ptr, strToStack(filename))); + } + getDebugInfoFileName(index: number): string | null { + return UTF8ToString(JSModule['_BinaryenModuleGetDebugInfoFileName'](this.ptr, index)); + } + validate(out?: (...data: any[]) => void): boolean { + if(out) { + const oldErr = swapErr(out); + try { + return JSModule['_BinaryenModuleValidate'](this.ptr); + } finally { + swapErr(oldErr); + } + } else { + return JSModule['_BinaryenModuleValidate'](this.ptr); + } + } + optimize(): void { + return JSModule['_BinaryenModuleOptimize'](this.ptr); + } + optimizeFunction(func: string | FunctionRef): void { + if (typeof func === 'string') + func = this.functions.getRefByName(func); + return JSModule['_BinaryenFunctionOptimize'](func, this.ptr); + } + runPasses(passes: string[]): void { + preserveStack(() => + JSModule['_BinaryenModuleRunPasses'](this.ptr, i32sToStack(passes.map(strToStack)), passes.length) + ); + } + runPassesOnFunction(func: string | FunctionRef, passes: string[]): void { + if (typeof func === 'string') + func = this.functions.getRefByName(func); + preserveStack(() => + JSModule['_BinaryenFunctionRunPasses'](func, this.ptr, i32sToStack(passes.map(strToStack)), passes.length) + ); + } + emitText(): string { + const textPtr = JSModule['_BinaryenModuleAllocateAndWriteText'](this.ptr); + const text = textPtr ? UTF8ToString(textPtr) : null; + if (textPtr) + _free(textPtr); + return text; + } + emitStackIR(optimize?: boolean): string { + const textPtr = JSModule['_BinaryenModuleAllocateAndWriteStackIR'](this.ptr, optimize); + const text = textPtr ? UTF8ToString(textPtr) : null; + if (textPtr) + _free(textPtr); + return text; + } + emitAsmjs(): string { + let text = ''; + const old = swapOut(s => { text += s + '\n' }); + JSModule['_BinaryenModulePrintAsmjs'](this.ptr); + swapOut(old); + return text; + } + emitBinary(): Uint8Array; + emitBinary(sourceMapUrl: string): { binary: Uint8Array; sourceMap: string; }; + emitBinary(sourceMapUrl?: string): Uint8Array | { binary: Uint8Array; sourceMap: string; } { + return preserveStack(() => { + const tempBuffer = stackAlloc(_BinaryenSizeofAllocateAndWriteResult()); + JSModule['_BinaryenModuleAllocateAndWrite'](tempBuffer, this.ptr, strToStack(sourceMapUrl)); + const binaryPtr = HEAPU32[ tempBuffer >>> 2 ]; + const binaryBytes = HEAPU32[(tempBuffer >>> 2) + 1]; + const sourceMapPtr = HEAPU32[(tempBuffer >>> 2) + 2]; + try { + const buffer = new Uint8Array(binaryBytes); + buffer.set(HEAPU8.subarray(binaryPtr, binaryPtr + binaryBytes)); + return typeof sourceMapUrl === 'undefined' ? buffer : { 'binary': buffer, 'sourceMap': UTF8ToString(sourceMapPtr) }; + } finally { + _free(binaryPtr); + if (sourceMapPtr) + _free(sourceMapPtr); + } + }); + } + interpret(): void { + JSModule['_BinaryenModuleInterpret'](this.ptr); + } + block(label: string | null, children: ExpressionRef[], resultType?: Type): ExpressionRef { + return preserveStack(() => JSModule['_BinaryenBlock']( + this.ptr, label ? strToStack(label) : 0, + i32sToStack(children), + children.length, + typeof resultType !== 'undefined' ? resultType : none)); + } + if(condition: ExpressionRef, ifTrue: ExpressionRef, ifFalse?: ExpressionRef): ExpressionRef { + return JSModule['_BinaryenIf'](this.ptr, condition, ifTrue, ifFalse); + } + loop(label: string | null, body: ExpressionRef): ExpressionRef { + return preserveStack(() => JSModule['_BinaryenLoop'](this.ptr, strToStack(label), body)); + } + br(label: string, condition?: ExpressionRef, value?: ExpressionRef): ExpressionRef { + return preserveStack(() => JSModule['_BinaryenBreak'](this.ptr, strToStack(label), condition, value)); + } + br_if(label: string, condition?: ExpressionRef, value?: ExpressionRef): ExpressionRef { + return this.br(label, condition, value); + } + switch(labels: string[], defaultLabel: string, condition: ExpressionRef, value?: ExpressionRef): ExpressionRef { + return preserveStack(() => + JSModule['_BinaryenSwitch'](this.ptr, i32sToStack(labels.map(strToStack)), labels.length, strToStack(defaultLabel), condition, value) + ); + } + call(name: string, operands: ExpressionRef[], returnType: Type): ExpressionRef { + return preserveStack(() => JSModule['_BinaryenCall'](this.ptr, strToStack(name), i32sToStack(operands), operands.length, returnType)); + } + call_indirect(table: string, target: ExpressionRef, operands: ExpressionRef[], params: Type, results: Type): ExpressionRef { + return preserveStack(() => + JSModule['_BinaryenCallIndirect'](this.ptr, strToStack(table), target, i32sToStack(operands), operands.length, params, results) + ); + } + return_call(name: string, operands: ExpressionRef[], returnType: Type): ExpressionRef { + return preserveStack(() => + JSModule['_BinaryenReturnCall'](this.ptr, strToStack(name), i32sToStack(operands), operands.length, returnType) + ); + } + return_call_indirect(table: string, target: ExpressionRef, operands: ExpressionRef[], params: Type, results: Type): ExpressionRef { + return preserveStack(() => + JSModule['_BinaryenReturnCallIndirect'](this.ptr, strToStack(table), target, i32sToStack(operands), operands.length, params, results) + ); + } + select(condition: ExpressionRef, ifTrue: ExpressionRef, ifFalse: ExpressionRef, type?: Type): ExpressionRef { + return JSModule['_BinaryenSelect'](this.ptr, condition, ifTrue, ifFalse, typeof type !== 'undefined' ? type : JSModule['auto']); + } + drop(value: ExpressionRef): ExpressionRef { + return JSModule['_BinaryenDrop'](this.ptr, value); + } + return(value?: ExpressionRef): ExpressionRef { + return JSModule['_BinaryenReturn'](this.ptr, value); + } + nop(): ExpressionRef { + return JSModule['_BinaryenNop'](this.ptr); + } + unreachable(): ExpressionRef { + return JSModule['_BinaryenUnreachable'](this.ptr); + } + try(name: string, body: ExpressionRef, catchTags: string[], catchBodies: ExpressionRef[], delegateTarget?: string): ExpressionRef { + return preserveStack(() => + JSModule['_BinaryenTry'](this.ptr, name ? strToStack(name) : 0, body, i32sToStack(catchTags.map(strToStack)), catchTags.length, i32sToStack(catchBodies), catchBodies.length, delegateTarget ? strToStack(delegateTarget) : 0)); + } + throw(tag: string, operands: ExpressionRef[]): ExpressionRef { + return preserveStack(() => JSModule['_BinaryenThrow'](this.ptr, strToStack(tag), i32sToStack(operands), operands.length)); + } + rethrow(target: string): ExpressionRef { + return JSModule['_BinaryenRethrow'](this.ptr, strToStack(target)); + } + get i32 () { + const unary = (op: Operations, value: ExpressionRef) => + JSModule['_BinaryenUnary'](this.ptr, op, value); + const binary = (op: Operations, left: ExpressionRef, right: ExpressionRef) => + JSModule['_BinaryenBinary'](this.ptr, op, left, right); + const load = (size: number, signed: boolean, offset: number, align: number, ptr: ExpressionRef, name: string) => + JSModule['_BinaryenLoad'](this.ptr, size, signed, offset, align, i32, ptr, strToStack(name)); + const store = (size: number, offset: number, align: number, ptr: ExpressionRef, value: ExpressionRef, name: string) => + JSModule['_BinaryenStore'](this.ptr, size, offset, align, ptr, value, i32, strToStack(name)); + const atomic_load = (size: number, offset: number, ptr: ExpressionRef, name: string) => + JSModule['_BinaryenAtomicLoad'](this.ptr, size, offset, i32, ptr, strToStack(name)); + const atomic_store = (size: number, offset: number, ptr: ExpressionRef, value: ExpressionRef, name: string) => + JSModule['_BinaryenAtomicStore'](this.ptr, size, offset, ptr, value, i32, strToStack(name)); + const atomic_rmw = (op: Operations, size: number, offset: number, ptr: ExpressionRef, value: ExpressionRef, name: string) => + JSModule['_BinaryenAtomicRMW'](this.ptr, op, size, offset, ptr, value, i32, strToStack(name)); + return { + load: (offset: number, align: number, ptr: ExpressionRef, name?: string): ExpressionRef => load(4, true, offset, align, ptr, name), + load8_s: (offset: number, align: number, ptr: ExpressionRef, name?: string): ExpressionRef => load(1, true, offset, align, ptr, name), + load8_u: (offset: number, align: number, ptr: ExpressionRef, name?: string): ExpressionRef => load(1, false, offset, align, ptr, name), + load16_s: (offset: number, align: number, ptr: ExpressionRef, name?: string): ExpressionRef => load(2, true, offset, align, ptr, name), + load16_u: (offset: number, align: number, ptr: ExpressionRef, name?: string): ExpressionRef => load(2, false, offset, align, ptr, name), + store: (offset: number, align: number, ptr: ExpressionRef, value: ExpressionRef, name?: string): ExpressionRef => store(4, offset, align, ptr, value, name), + store8: (offset: number, align: number, ptr: ExpressionRef, value: ExpressionRef, name?: string): ExpressionRef => store(1, offset, align, ptr, value, name), + store16: (offset: number, align: number, ptr: ExpressionRef, value: ExpressionRef, name?: string): ExpressionRef => store(2, offset, align, ptr, value, name), + const: (value: number): ExpressionRef => preserveStack(() => { + const tempLiteral = stackAlloc(sizeOfLiteral); + JSModule['_BinaryenLiteralInt32'](tempLiteral, value); + return JSModule['_BinaryenConst'](this.ptr, tempLiteral); + }), + clz: (value: ExpressionRef): ExpressionRef => unary(Operations.ClzInt32, value), + ctz: (value: ExpressionRef): ExpressionRef => unary(Operations.CtzInt32, value), + popcnt: (value: ExpressionRef): ExpressionRef => unary(Operations.PopcntInt32, value), + eqz: (value: ExpressionRef): ExpressionRef => unary(Operations.EqZInt32, value), + trunc_s: { + f32: (value: ExpressionRef): ExpressionRef => unary(Operations.TruncSFloat32ToInt32, value), + f64: (value: ExpressionRef): ExpressionRef => unary(Operations.TruncSFloat64ToInt32, value) + }, + trunc_u: { + f32: (value: ExpressionRef): ExpressionRef => unary(Operations.TruncUFloat32ToInt32, value), + f64: (value: ExpressionRef): ExpressionRef => unary(Operations.TruncUFloat64ToInt32, value) + }, + trunc_s_sat: { + f32: (value: ExpressionRef): ExpressionRef => unary(Operations.TruncSatSFloat32ToInt32, value), + f64: (value: ExpressionRef): ExpressionRef => unary(Operations.TruncSatSFloat64ToInt32, value) + }, + trunc_u_sat: { + f32: (value: ExpressionRef): ExpressionRef => unary(Operations.TruncSatUFloat32ToInt32, value), + f64: (value: ExpressionRef): ExpressionRef => unary(Operations.TruncSatUFloat64ToInt32, value) + }, + reinterpret_f32: (value: ExpressionRef): ExpressionRef => unary(Operations.ReinterpretFloat32, value), + extend8_s: (value: ExpressionRef): ExpressionRef => unary(Operations.ExtendS8Int32, value), + extend16_s: (value: ExpressionRef): ExpressionRef => unary(Operations.ExtendS16Int32, value), + wrap_i64: (value: ExpressionRef): ExpressionRef => unary(Operations.WrapInt64, value), + add: (left: ExpressionRef, right: ExpressionRef): ExpressionRef => binary(Operations.AddInt32, left, right), + sub: (left: ExpressionRef, right: ExpressionRef): ExpressionRef => binary(Operations.SubInt32, left, right), + mul: (left: ExpressionRef, right: ExpressionRef): ExpressionRef => binary(Operations.MulInt32, left, right), + div_s: (left: ExpressionRef, right: ExpressionRef): ExpressionRef => binary(Operations.DivSInt32, left, right), + div_u: (left: ExpressionRef, right: ExpressionRef): ExpressionRef => binary(Operations.DivUInt32, left, right), + rem_s: (left: ExpressionRef, right: ExpressionRef): ExpressionRef => binary(Operations.RemSInt32, left, right), + rem_u: (left: ExpressionRef, right: ExpressionRef): ExpressionRef => binary(Operations.RemUInt32, left, right), + and: (left: ExpressionRef, right: ExpressionRef): ExpressionRef => binary(Operations.AndInt32, left, right), + or: (left: ExpressionRef, right: ExpressionRef): ExpressionRef => binary(Operations.OrInt32, left, right), + xor: (left: ExpressionRef, right: ExpressionRef): ExpressionRef => binary(Operations.XorInt32, left, right), + shl: (left: ExpressionRef, right: ExpressionRef): ExpressionRef => binary(Operations.ShlInt32, left, right), + shr_u: (left: ExpressionRef, right: ExpressionRef): ExpressionRef => binary(Operations.ShrUInt32, left, right), + shr_s: (left: ExpressionRef, right: ExpressionRef): ExpressionRef => binary(Operations.ShrSInt32, left, right), + rotl: (left: ExpressionRef, right: ExpressionRef): ExpressionRef => binary(Operations.RotLInt32, left, right), + rotr: (left: ExpressionRef, right: ExpressionRef): ExpressionRef => binary(Operations.RotRInt32, left, right), + eq: (left: ExpressionRef, right: ExpressionRef): ExpressionRef => binary(Operations.EqInt32, left, right), + ne: (left: ExpressionRef, right: ExpressionRef): ExpressionRef => binary(Operations.NeInt32, left, right), + lt_s: (left: ExpressionRef, right: ExpressionRef): ExpressionRef => binary(Operations.LtSInt32, left, right), + lt_u: (left: ExpressionRef, right: ExpressionRef): ExpressionRef => binary(Operations.LtUInt32, left, right), + le_s: (left: ExpressionRef, right: ExpressionRef): ExpressionRef => binary(Operations.LeSInt32, left, right), + le_u: (left: ExpressionRef, right: ExpressionRef): ExpressionRef => binary(Operations.LeUInt32, left, right), + gt_s: (left: ExpressionRef, right: ExpressionRef): ExpressionRef => binary(Operations.GtSInt32, left, right), + gt_u: (left: ExpressionRef, right: ExpressionRef): ExpressionRef => binary(Operations.GtUInt32, left, right), + ge_s: (left: ExpressionRef, right: ExpressionRef): ExpressionRef => binary(Operations.GeSInt32, left, right), + ge_u: (left: ExpressionRef, right: ExpressionRef): ExpressionRef => binary(Operations.GeUInt32, left, right), + pop: (): ExpressionRef => JSModule['_BinaryenPop'](this.ptr, i32), + atomic: { + load: (offset: number, ptr: ExpressionRef, name?: string): ExpressionRef => atomic_load(4, offset, ptr, name), + load8_u: (offset: number, ptr: ExpressionRef, name?: string): ExpressionRef => atomic_load(1, offset, ptr, name), + load16_u: (offset: number, ptr: ExpressionRef, name?: string): ExpressionRef => atomic_load(2, offset, ptr, name), + store: (offset: number, ptr: ExpressionRef, value: ExpressionRef, name?: string): ExpressionRef => atomic_store(4, offset, ptr, value, name), + store8: (offset: number, ptr: ExpressionRef, value: ExpressionRef, name?: string): ExpressionRef => atomic_store(1, offset, ptr, value, name), + store16: (offset: number, ptr: ExpressionRef, value: ExpressionRef, name?: string): ExpressionRef => atomic_store(2, offset, ptr, value, name), + rmw: { + add: (offset: number, ptr: ExpressionRef, value: ExpressionRef, name?: string): ExpressionRef => + atomic_rmw(Operations.AtomicRMWAdd, 4, offset, ptr, value, name), + sub: (offset: number, ptr: ExpressionRef, value: ExpressionRef, name?: string): ExpressionRef => + atomic_rmw(Operations.AtomicRMWSub, 4, offset, ptr, value, name), + and: (offset: number, ptr: ExpressionRef, value: ExpressionRef, name?: string): ExpressionRef => + atomic_rmw(Operations.AtomicRMWAnd, 4, offset, ptr, value, name), + or: (offset: number, ptr: ExpressionRef, value: ExpressionRef, name?: string): ExpressionRef => + atomic_rmw(Operations.AtomicRMWOr, 4, offset, ptr, value, name), + xor: (offset: number, ptr: ExpressionRef, value: ExpressionRef, name?: string): ExpressionRef => + atomic_rmw(Operations.AtomicRMWXor, 4, offset, ptr, value, name), + xchg: (offset: number, ptr: ExpressionRef, value: ExpressionRef, name?: string): ExpressionRef => + atomic_rmw(Operations.AtomicRMWXchg, 4, offset, ptr, value, name), + cmpxchg: (offset: number, ptr: ExpressionRef, expected: ExpressionRef, replacement: ExpressionRef, name?: string): ExpressionRef => + JSModule['_BinaryenAtomicCmpxchg'](this.ptr, 4, offset, ptr, expected, replacement, i32, strToStack(name)) + }, + rmw8_u: { + add: (offset: number, ptr: ExpressionRef, value: ExpressionRef, name?: string): ExpressionRef => + atomic_rmw(Operations.AtomicRMWAdd, 1, offset, ptr, value, name), + sub: (offset: number, ptr: ExpressionRef, value: ExpressionRef, name?: string): ExpressionRef => + atomic_rmw(Operations.AtomicRMWSub, 1, offset, ptr, value, name), + and: (offset: number, ptr: ExpressionRef, value: ExpressionRef, name?: string): ExpressionRef => + atomic_rmw(Operations.AtomicRMWAnd, 1, offset, ptr, value, name), + or: (offset: number, ptr: ExpressionRef, value: ExpressionRef, name?: string): ExpressionRef => + atomic_rmw(Operations.AtomicRMWOr, 1, offset, ptr, value, name), + xor: (offset: number, ptr: ExpressionRef, value: ExpressionRef, name?: string): ExpressionRef => + atomic_rmw(Operations.AtomicRMWXor, 1, offset, ptr, value, name), + xchg: (offset: number, ptr: ExpressionRef, value: ExpressionRef, name?: string): ExpressionRef => + atomic_rmw(Operations.AtomicRMWXchg, 1, offset, ptr, value, name), + cmpxchg: (offset: number, ptr: ExpressionRef, expected: ExpressionRef, replacement: ExpressionRef, name?: string): ExpressionRef => + JSModule['_BinaryenAtomicCmpxchg'](this.ptr, 1, offset, ptr, expected, replacement, i32, strToStack(name)) + }, + rmw16_u: { + add: (offset: number, ptr: ExpressionRef, value: ExpressionRef, name?: string): ExpressionRef => + atomic_rmw(Operations.AtomicRMWAdd, 2, offset, ptr, value, name), + sub: (offset: number, ptr: ExpressionRef, value: ExpressionRef, name?: string): ExpressionRef => + atomic_rmw(Operations.AtomicRMWSub, 2, offset, ptr, value, name), + and: (offset: number, ptr: ExpressionRef, value: ExpressionRef, name?: string): ExpressionRef => + atomic_rmw(Operations.AtomicRMWAnd, 2, offset, ptr, value, name), + or: (offset: number, ptr: ExpressionRef, value: ExpressionRef, name?: string): ExpressionRef => + atomic_rmw(Operations.AtomicRMWOr, 2, offset, ptr, value, name), + xor: (offset: number, ptr: ExpressionRef, value: ExpressionRef, name?: string): ExpressionRef => + atomic_rmw(Operations.AtomicRMWXor, 2, offset, ptr, value, name), + xchg: (offset: number, ptr: ExpressionRef, value: ExpressionRef, name?: string): ExpressionRef => + atomic_rmw(Operations.AtomicRMWXchg, 2, offset, ptr, value, name), + cmpxchg: (offset: number, ptr: ExpressionRef, expected: ExpressionRef, replacement: ExpressionRef, name?: string): ExpressionRef => + JSModule['_BinaryenAtomicCmpxchg'](this.ptr, 2, offset, ptr, expected, replacement, i32, strToStack(name)) + } + } + }; + } + get i64 () { + const unary = (op: Operations, value: ExpressionRef) => + JSModule['_BinaryenUnary'](this.ptr, op, value); + const binary = (op: Operations, left: ExpressionRef, right: ExpressionRef) => + JSModule['_BinaryenBinary'](this.ptr, op, left, right); + const load = (size: number, signed: boolean, offset: number, align: number, ptr: ExpressionRef, name: string): ExpressionRef => + JSModule['_BinaryenLoad'](this.ptr, size, signed, offset, align, i64, ptr, strToStack(name)); + const store = (size: number, offset: number, align: number, ptr: ExpressionRef, value: ExpressionRef, name: string) => + JSModule['_BinaryenStore'](this.ptr, size, offset, align, ptr, value, i64, strToStack(name)); + const atomic_load = (size: number, offset: number, ptr: ExpressionRef, name: string) => + JSModule['_BinaryenAtomicLoad'](this.ptr, size, offset, i64, ptr, strToStack(name)); + const atomic_store = (size: number, offset: number, ptr: ExpressionRef, value: ExpressionRef, name: string) => + JSModule['_BinaryenAtomicStore'](this.ptr, size, offset, ptr, value, i64, strToStack(name)); + const atomic_rmw = (op: Operations, size: number, offset: number, ptr: ExpressionRef, value: ExpressionRef, name: string) => + JSModule['_BinaryenAtomicRMW'](this.ptr, op, size, offset, ptr, value, i64, strToStack(name)); + return { + load: (offset: number, align: number, ptr: ExpressionRef, name?: string): ExpressionRef => load(8, true, offset, align, ptr, name), + load8_s: (offset: number, align: number, ptr: ExpressionRef, name?: string): ExpressionRef => load(1, true, offset, align, ptr, name), + load8_u: (offset: number, align: number, ptr: ExpressionRef, name?: string): ExpressionRef => load(1, false, offset, align, ptr, name), + load16_s: (offset: number, align: number, ptr: ExpressionRef, name?: string): ExpressionRef => load(2, true, offset, align, ptr, name), + load16_u: (offset: number, align: number, ptr: ExpressionRef, name?: string): ExpressionRef => load(2, false, offset, align, ptr, name), + load32_s: (offset: number, align: number, ptr: ExpressionRef, name?: string): ExpressionRef => load(4, true, offset, align, ptr, name), + load32_u: (offset: number, align: number, ptr: ExpressionRef, name?: string): ExpressionRef => load(4, false, offset, align, ptr, name), + store: (offset: number, align: number, ptr: ExpressionRef, value: ExpressionRef, name?: string): ExpressionRef => store(4, offset, align, ptr, value, name), + store8: (offset: number, align: number, ptr: ExpressionRef, value: ExpressionRef, name?: string): ExpressionRef => store(1, offset, align, ptr, value, name), + store16: (offset: number, align: number, ptr: ExpressionRef, value: ExpressionRef, name?: string): ExpressionRef => store(2, offset, align, ptr, value, name), + store32: (offset: number, align: number, ptr: ExpressionRef, value: ExpressionRef, name?: string): ExpressionRef => store(4, offset, align, ptr, value, name), + const: (low: number, high: number): ExpressionRef => preserveStack(() => { + const tempLiteral = stackAlloc(sizeOfLiteral); + JSModule['_BinaryenLiteralInt64'](tempLiteral, low, high); + return JSModule['_BinaryenConst'](this.ptr, tempLiteral); + }), + clz: (value: ExpressionRef): ExpressionRef => unary(Operations.ClzInt64, value), + ctz: (value: ExpressionRef): ExpressionRef => unary(Operations.CtzInt64, value), + popcnt: (value: ExpressionRef): ExpressionRef => unary(Operations.PopcntInt64, value), + eqz: (value: ExpressionRef): ExpressionRef => unary(Operations.EqZInt64, value), + trunc_s: { + f32: (value: ExpressionRef): ExpressionRef => unary(Operations.TruncSFloat32ToInt64, value), + f64: (value: ExpressionRef): ExpressionRef => unary(Operations.TruncSFloat64ToInt64, value) + }, + trunc_u: { + f32: (value: ExpressionRef): ExpressionRef => unary(Operations.TruncUFloat32ToInt64, value), + f64: (value: ExpressionRef): ExpressionRef => unary(Operations.TruncUFloat64ToInt64, value) + }, + trunc_s_sat: { + f32: (value: ExpressionRef): ExpressionRef => unary(Operations.TruncSatSFloat32ToInt64, value), + f64: (value: ExpressionRef): ExpressionRef => unary(Operations.TruncSatSFloat64ToInt64, value) + }, + trunc_u_sat: { + f32: (value: ExpressionRef): ExpressionRef => unary(Operations.TruncSatUFloat32ToInt64, value), + f64: (value: ExpressionRef): ExpressionRef => unary(Operations.TruncSatUFloat64ToInt64, value) + }, + reinterpret_f64: (value: ExpressionRef): ExpressionRef => unary(Operations.ReinterpretFloat64, value), + extend8_s: (value: ExpressionRef): ExpressionRef => unary(Operations.ExtendS8Int64, value), + extend16_s: (value: ExpressionRef): ExpressionRef => unary(Operations.ExtendS16Int64, value), + extend32_s: (value: ExpressionRef): ExpressionRef => unary(Operations.ExtendS32Int64, value), + extend_s: (value: ExpressionRef): ExpressionRef => unary(Operations.ExtendSInt32, value), + extend_u: (value: ExpressionRef): ExpressionRef => unary(Operations.ExtendUInt32, value), + add: (left: ExpressionRef, right: ExpressionRef): ExpressionRef => binary(Operations.AddInt64, left, right), + sub: (left: ExpressionRef, right: ExpressionRef): ExpressionRef => binary(Operations.SubInt64, left, right), + mul: (left: ExpressionRef, right: ExpressionRef): ExpressionRef => binary(Operations.MulInt32, left, right), + div_s: (left: ExpressionRef, right: ExpressionRef): ExpressionRef => binary(Operations.DivSInt64, left, right), + div_u: (left: ExpressionRef, right: ExpressionRef): ExpressionRef => binary(Operations.DivUInt64, left, right), + rem_s: (left: ExpressionRef, right: ExpressionRef): ExpressionRef => binary(Operations.RemSInt64, left, right), + rem_u: (left: ExpressionRef, right: ExpressionRef): ExpressionRef => binary(Operations.RemUInt64, left, right), + and: (left: ExpressionRef, right: ExpressionRef): ExpressionRef => binary(Operations.AndInt64, left, right), + or: (left: ExpressionRef, right: ExpressionRef): ExpressionRef => binary(Operations.OrInt64, left, right), + xor: (left: ExpressionRef, right: ExpressionRef): ExpressionRef => binary(Operations.XorInt64, left, right), + shl: (left: ExpressionRef, right: ExpressionRef): ExpressionRef => binary(Operations.ShlInt64, left, right), + shr_u: (left: ExpressionRef, right: ExpressionRef): ExpressionRef => binary(Operations.ShrUInt64, left, right), + shr_s: (left: ExpressionRef, right: ExpressionRef): ExpressionRef => binary(Operations.ShrSInt64, left, right), + rotl: (left: ExpressionRef, right: ExpressionRef): ExpressionRef => binary(Operations.RotLInt64, left, right), + rotr: (left: ExpressionRef, right: ExpressionRef): ExpressionRef => binary(Operations.RotRInt64, left, right), + eq: (left: ExpressionRef, right: ExpressionRef): ExpressionRef => binary(Operations.EqInt64, left, right), + ne: (left: ExpressionRef, right: ExpressionRef): ExpressionRef => binary(Operations.NeInt64, left, right), + lt_s: (left: ExpressionRef, right: ExpressionRef): ExpressionRef => binary(Operations.LtSInt64, left, right), + lt_u: (left: ExpressionRef, right: ExpressionRef): ExpressionRef => binary(Operations.LtUInt64, left, right), + le_s: (left: ExpressionRef, right: ExpressionRef): ExpressionRef => binary(Operations.LeSInt64, left, right), + le_u: (left: ExpressionRef, right: ExpressionRef): ExpressionRef => binary(Operations.LeUInt64, left, right), + gt_s: (left: ExpressionRef, right: ExpressionRef): ExpressionRef => binary(Operations.GtSInt64, left, right), + gt_u: (left: ExpressionRef, right: ExpressionRef): ExpressionRef => binary(Operations.GtUInt64, left, right), + ge_s: (left: ExpressionRef, right: ExpressionRef): ExpressionRef => binary(Operations.GeSInt64, left, right), + ge_u: (left: ExpressionRef, right: ExpressionRef): ExpressionRef => binary(Operations.GeUInt64, left, right), + pop: (): ExpressionRef => JSModule['_BinaryenPop'](this.ptr, i64), + atomic: { + load: (offset: number, ptr: ExpressionRef, name?: string): ExpressionRef => atomic_load(8, offset, ptr, name), + load8_u: (offset: number, ptr: ExpressionRef, name?: string): ExpressionRef => atomic_load(1, offset, ptr, name), + load16_u: (offset: number, ptr: ExpressionRef, name?: string): ExpressionRef => atomic_load(2, offset, ptr, name), + load32_u: (offset: number, ptr: ExpressionRef, name?: string): ExpressionRef => atomic_load(4, offset, ptr, name), + store: (offset: number, ptr: ExpressionRef, value: ExpressionRef, name?: string): ExpressionRef => atomic_store(4, offset, ptr, value, name), + store8: (offset: number, ptr: ExpressionRef, value: ExpressionRef, name?: string): ExpressionRef => atomic_store(1, offset, ptr, value, name), + store16: (offset: number, ptr: ExpressionRef, value: ExpressionRef, name?: string): ExpressionRef => atomic_store(2, offset, ptr, value, name), + store32: (offset: number, ptr: ExpressionRef, value: ExpressionRef, name?: string): ExpressionRef => atomic_store(4, offset, ptr, value, name), + rmw: { + add: (offset: number, ptr: ExpressionRef, value: ExpressionRef, name?: string): ExpressionRef => + atomic_rmw(Operations.AtomicRMWAdd, 8, offset, ptr, value, name), + sub: (offset: number, ptr: ExpressionRef, value: ExpressionRef, name?: string): ExpressionRef => + atomic_rmw(Operations.AtomicRMWSub, 8, offset, ptr, value, name), + and: (offset: number, ptr: ExpressionRef, value: ExpressionRef, name?: string): ExpressionRef => + atomic_rmw(Operations.AtomicRMWAnd, 8, offset, ptr, value, name), + or: (offset: number, ptr: ExpressionRef, value: ExpressionRef, name?: string): ExpressionRef => + atomic_rmw(Operations.AtomicRMWOr, 8, offset, ptr, value, name), + xor: (offset: number, ptr: ExpressionRef, value: ExpressionRef, name?: string): ExpressionRef => + atomic_rmw(Operations.AtomicRMWXor, 8, offset, ptr, value, name), + xchg: (offset: number, ptr: ExpressionRef, value: ExpressionRef, name?: string): ExpressionRef => + atomic_rmw(Operations.AtomicRMWXchg, 8, offset, ptr, value, name), + cmpxchg: (offset: number, ptr: ExpressionRef, expected: ExpressionRef, replacement: ExpressionRef, name?: string): ExpressionRef => + JSModule['_BinaryenAtomicCmpxchg'](this.ptr, 8, offset, ptr, expected, replacement, i64, strToStack(name)) + }, + rmw8_u: { + add: (offset: number, ptr: ExpressionRef, value: ExpressionRef, name?: string): ExpressionRef => + atomic_rmw(Operations.AtomicRMWAdd, 1, offset, ptr, value, name), + sub: (offset: number, ptr: ExpressionRef, value: ExpressionRef, name?: string): ExpressionRef => + atomic_rmw(Operations.AtomicRMWSub, 1, offset, ptr, value, name), + and: (offset: number, ptr: ExpressionRef, value: ExpressionRef, name?: string): ExpressionRef => + atomic_rmw(Operations.AtomicRMWAnd, 1, offset, ptr, value, name), + or: (offset: number, ptr: ExpressionRef, value: ExpressionRef, name?: string): ExpressionRef => + atomic_rmw(Operations.AtomicRMWOr, 1, offset, ptr, value, name), + xor: (offset: number, ptr: ExpressionRef, value: ExpressionRef, name?: string): ExpressionRef => + atomic_rmw(Operations.AtomicRMWXor, 1, offset, ptr, value, name), + xchg: (offset: number, ptr: ExpressionRef, value: ExpressionRef, name?: string): ExpressionRef => + atomic_rmw(Operations.AtomicRMWXchg, 1, offset, ptr, value, name), + cmpxchg: (offset: number, ptr: ExpressionRef, expected: ExpressionRef, replacement: ExpressionRef, name?: string): ExpressionRef => + JSModule['_BinaryenAtomicCmpxchg'](this.ptr, 1, offset, ptr, expected, replacement, i64, strToStack(name)) + }, + rmw16_u: { + add: (offset: number, ptr: ExpressionRef, value: ExpressionRef, name?: string): ExpressionRef => + atomic_rmw(Operations.AtomicRMWAdd, 2, offset, ptr, value, name), + sub: (offset: number, ptr: ExpressionRef, value: ExpressionRef, name?: string): ExpressionRef => + atomic_rmw(Operations.AtomicRMWSub, 2, offset, ptr, value, name), + and: (offset: number, ptr: ExpressionRef, value: ExpressionRef, name?: string): ExpressionRef => + atomic_rmw(Operations.AtomicRMWAnd, 2, offset, ptr, value, name), + or: (offset: number, ptr: ExpressionRef, value: ExpressionRef, name?: string): ExpressionRef => + atomic_rmw(Operations.AtomicRMWOr, 2, offset, ptr, value, name), + xor: (offset: number, ptr: ExpressionRef, value: ExpressionRef, name?: string): ExpressionRef => + atomic_rmw(Operations.AtomicRMWXor, 2, offset, ptr, value, name), + xchg: (offset: number, ptr: ExpressionRef, value: ExpressionRef, name?: string): ExpressionRef => + atomic_rmw(Operations.AtomicRMWXchg, 2, offset, ptr, value, name), + cmpxchg: (offset: number, ptr: ExpressionRef, expected: ExpressionRef, replacement: ExpressionRef, name?: string): ExpressionRef => + JSModule['_BinaryenAtomicCmpxchg'](this.ptr, 2, offset, ptr, expected, replacement, i32, strToStack(name)) + }, + rmw32_u: { + add: (offset: number, ptr: ExpressionRef, value: ExpressionRef, name?: string): ExpressionRef => + atomic_rmw(Operations.AtomicRMWAdd, 4, offset, ptr, value, name), + sub: (offset: number, ptr: ExpressionRef, value: ExpressionRef, name?: string): ExpressionRef => + atomic_rmw(Operations.AtomicRMWSub, 4, offset, ptr, value, name), + and: (offset: number, ptr: ExpressionRef, value: ExpressionRef, name?: string): ExpressionRef => + atomic_rmw(Operations.AtomicRMWAnd, 4, offset, ptr, value, name), + or: (offset: number, ptr: ExpressionRef, value: ExpressionRef, name?: string): ExpressionRef => + atomic_rmw(Operations.AtomicRMWOr, 4, offset, ptr, value, name), + xor: (offset: number, ptr: ExpressionRef, value: ExpressionRef, name?: string): ExpressionRef => + atomic_rmw(Operations.AtomicRMWXor, 4, offset, ptr, value, name), + xchg: (offset: number, ptr: ExpressionRef, value: ExpressionRef, name?: string): ExpressionRef => + atomic_rmw(Operations.AtomicRMWXchg, 4, offset, ptr, value, name), + cmpxchg: (offset: number, ptr: ExpressionRef, expected: ExpressionRef, replacement: ExpressionRef, name?: string): ExpressionRef => + JSModule['_BinaryenAtomicCmpxchg'](this.ptr, 4, offset, ptr, expected, replacement, i32, strToStack(name)) + } + } + }; + } + get f32 () { + const unary = (op: Operations, value: ExpressionRef) => + JSModule['_BinaryenUnary'](this.ptr, op, value); + const binary = (op: Operations, left: ExpressionRef, right: ExpressionRef) => + JSModule['_BinaryenBinary'](this.ptr, op, left, right); + return { + load: (offset: number, align: number, ptr: ExpressionRef, name?: string): ExpressionRef => + JSModule['_BinaryenLoad'](this.ptr, 4, true, offset, align, f32, ptr, strToStack(name)), + store: (offset: number, align: number, ptr: ExpressionRef, value: ExpressionRef, name?: string): ExpressionRef => + JSModule['_BinaryenStore'](this.ptr, 4, offset, align, ptr, value, f32, strToStack(name)), + const: (value: number): ExpressionRef => + preserveStack(() => { + const tempLiteral = stackAlloc(sizeOfLiteral); + JSModule['_BinaryenLiteralFloat32'](tempLiteral, value); + return JSModule['_BinaryenConst'](this.ptr, tempLiteral); + }), + const_bits: (value: number): ExpressionRef => + preserveStack(() => { + const tempLiteral = stackAlloc(sizeOfLiteral); + JSModule['_BinaryenLiteralFloat32Bits'](tempLiteral, value); + return JSModule['_BinaryenConst'](this.ptr, tempLiteral); + }), + neg: (value: ExpressionRef): ExpressionRef => unary(Operations.NegFloat32, value), + abs: (value: ExpressionRef): ExpressionRef => unary(Operations.AbsFloat32, value), + ceil: (value: ExpressionRef): ExpressionRef => unary(Operations.CeilFloat32, value), + floor: (value: ExpressionRef): ExpressionRef => unary(Operations.FloorFloat32, value), + trunc: (value: ExpressionRef): ExpressionRef => unary(Operations.TruncFloat32, value), + nearest: (value: ExpressionRef): ExpressionRef => unary(Operations.NearestFloat32, value), + sqrt: (value: ExpressionRef): ExpressionRef => unary(Operations.SqrtFloat32, value), + reinterpret_i32: (value: ExpressionRef): ExpressionRef => unary(Operations.ReinterpretInt32, value), + convert_s: { + i32: (value: ExpressionRef): ExpressionRef => unary(Operations.ConvertSInt32ToFloat32, value), + i64: (value: ExpressionRef): ExpressionRef => unary(Operations.ConvertSInt64ToFloat32, value) + }, + convert_u: { + i32: (value: ExpressionRef): ExpressionRef => unary(Operations.ConvertUInt32ToFloat32, value), + i64: (value: ExpressionRef): ExpressionRef => unary(Operations.ConvertUInt64ToFloat32, value) + }, + demote_f64: (value: ExpressionRef): ExpressionRef => unary(Operations.DemoteFloat64, value), + add: (left: ExpressionRef, right: ExpressionRef): ExpressionRef => binary(Operations.AddFloat32, left, right), + sub: (left: ExpressionRef, right: ExpressionRef): ExpressionRef => binary(Operations.SubFloat32, left, right), + mul: (left: ExpressionRef, right: ExpressionRef): ExpressionRef => binary(Operations.MulFloat32, left, right), + div: (left: ExpressionRef, right: ExpressionRef): ExpressionRef => binary(Operations.DivFloat32, left, right), + copysign: (left: ExpressionRef, right: ExpressionRef): ExpressionRef => binary(Operations.CopySignFloat32, left, right), + min: (left: ExpressionRef, right: ExpressionRef): ExpressionRef => binary(Operations.MinFloat32, left, right), + max: (left: ExpressionRef, right: ExpressionRef): ExpressionRef => binary(Operations.MaxFloat32, left, right), + eq: (left: ExpressionRef, right: ExpressionRef): ExpressionRef => binary(Operations.EqFloat32, left, right), + ne: (left: ExpressionRef, right: ExpressionRef): ExpressionRef => binary(Operations.NeFloat32, left, right), + lt: (left: ExpressionRef, right: ExpressionRef): ExpressionRef => binary(Operations.LtFloat32, left, right), + le: (left: ExpressionRef, right: ExpressionRef): ExpressionRef => binary(Operations.LeFloat32, left, right), + gt: (left: ExpressionRef, right: ExpressionRef): ExpressionRef => binary(Operations.GtFloat32, left, right), + ge: (left: ExpressionRef, right: ExpressionRef): ExpressionRef => binary(Operations.GeFloat32, left, right), + pop: (): ExpressionRef => JSModule['_BinaryenPop'](this.ptr, f32) + }; + } + get f64 () { + const unary = (op: Operations, value: ExpressionRef) => + JSModule['_BinaryenUnary'](this.ptr, op, value); + const binary = (op: Operations, left: ExpressionRef, right: ExpressionRef) => + JSModule['_BinaryenBinary'](this.ptr, op, left, right); + return { + load: (offset: number, align: number, ptr: ExpressionRef, name?: string): ExpressionRef => + JSModule['_BinaryenLoad'](this.ptr, 8, true, offset, align, f64, ptr, strToStack(name)), + store: (offset: number, align: number, ptr: ExpressionRef, value: ExpressionRef, name?: string): ExpressionRef => + JSModule['_BinaryenStore'](this.ptr, 8, offset, align, ptr, value, f64, strToStack(name)), + const: (value: number): ExpressionRef => + preserveStack(() => { + const tempLiteral = stackAlloc(sizeOfLiteral); + JSModule['_BinaryenLiteralFloat64'](tempLiteral, value); + return JSModule['_BinaryenConst'](this.ptr, tempLiteral); + }), + const_bits: (value: number): ExpressionRef => + preserveStack(() => { + const tempLiteral = stackAlloc(sizeOfLiteral); + JSModule['_BinaryenLiteralFloat64Bits'](tempLiteral, value); + return JSModule['_BinaryenConst'](this.ptr, tempLiteral); + }), + neg: (value: ExpressionRef): ExpressionRef => unary(Operations.NegFloat64, value), + abs: (value: ExpressionRef): ExpressionRef => unary(Operations.AbsFloat64, value), + ceil: (value: ExpressionRef): ExpressionRef => unary(Operations.CeilFloat64, value), + floor: (value: ExpressionRef): ExpressionRef => unary(Operations.FloorFloat64, value), + trunc: (value: ExpressionRef): ExpressionRef => unary(Operations.TruncFloat64, value), + nearest: (value: ExpressionRef): ExpressionRef => unary(Operations.NearestFloat64, value), + sqrt: (value: ExpressionRef): ExpressionRef => unary(Operations.SqrtFloat64, value), + reinterpret_i64: (value: ExpressionRef): ExpressionRef => unary(Operations.ReinterpretInt64, value), + convert_s: { + i32: (value: ExpressionRef): ExpressionRef => unary(Operations.ConvertSInt32ToFloat64, value), + i64: (value: ExpressionRef): ExpressionRef => unary(Operations.ConvertSInt64ToFloat64, value) + }, + convert_u: { + i32: (value: ExpressionRef): ExpressionRef => unary(Operations.ConvertUInt32ToFloat64, value), + i64: (value: ExpressionRef): ExpressionRef => unary(Operations.ConvertUInt64ToFloat64, value) + }, + promote_f32: (value: ExpressionRef): ExpressionRef => unary(Operations.PromoteFloat32, value), + add: (left: ExpressionRef, right: ExpressionRef): ExpressionRef => binary(Operations.AddFloat64, left, right), + sub: (left: ExpressionRef, right: ExpressionRef): ExpressionRef => binary(Operations.SubFloat64, left, right), + mul: (left: ExpressionRef, right: ExpressionRef): ExpressionRef => binary(Operations.MulFloat64, left, right), + div: (left: ExpressionRef, right: ExpressionRef): ExpressionRef => binary(Operations.DivFloat64, left, right), + copysign: (left: ExpressionRef, right: ExpressionRef): ExpressionRef => binary(Operations.CopySignFloat64, left, right), + min: (left: ExpressionRef, right: ExpressionRef): ExpressionRef => binary(Operations.MinFloat64, left, right), + max: (left: ExpressionRef, right: ExpressionRef): ExpressionRef => binary(Operations.MaxFloat64, left, right), + eq: (left: ExpressionRef, right: ExpressionRef): ExpressionRef => binary(Operations.EqFloat64, left, right), + ne: (left: ExpressionRef, right: ExpressionRef): ExpressionRef => binary(Operations.NeFloat64, left, right), + lt: (left: ExpressionRef, right: ExpressionRef): ExpressionRef => binary(Operations.LtFloat64, left, right), + le: (left: ExpressionRef, right: ExpressionRef): ExpressionRef => binary(Operations.LeFloat64, left, right), + gt: (left: ExpressionRef, right: ExpressionRef): ExpressionRef => binary(Operations.GtFloat64, left, right), + ge: (left: ExpressionRef, right: ExpressionRef): ExpressionRef => binary(Operations.GeFloat64, left, right), + pop: (): ExpressionRef => JSModule['_BinaryenPop'](this.ptr, f64) + }; + } + get v128 () { + const simd_load = (op: Operations, offset: number, align: number, ptr: ExpressionRef, name: string): ExpressionRef => + JSModule['_BinaryenSIMDLoad'](this.ptr, op, offset, align, ptr, strToStack(name)); + const simd_lane = (op: Operations, offset: number, align: number, index: number, ptr: ExpressionRef, vec: number, name: string): ExpressionRef => + JSModule['_BinaryenSIMDLoadStoreLane'](this.ptr, op, offset, align, index, ptr, vec, strToStack(name)); + return { + load: (offset: number, align: number, ptr: ExpressionRef, name?: string): ExpressionRef => + JSModule['_BinaryenLoad'](this.ptr, 16, false, offset, align, v128, ptr, strToStack(name)), + load8_splat: (offset: number, align: number, ptr: ExpressionRef, name?: string): ExpressionRef => + simd_load(Operations.Load8SplatVec128, offset, align, ptr, name), + load16_splat: (offset: number, align: number, ptr: ExpressionRef, name?: string): ExpressionRef => + simd_load(Operations.Load16SplatVec128, offset, align, ptr, name), + load32_splat: (offset: number, align: number, ptr: ExpressionRef, name?: string): ExpressionRef => + simd_load(Operations.Load32SplatVec128, offset, align, ptr, name), + load64_splat: (offset: number, align: number, ptr: ExpressionRef, name?: string): ExpressionRef => + simd_load(Operations.Load64SplatVec128, offset, align, ptr, name), + load8x8_s: (offset: number, align: number, ptr: ExpressionRef, name?: string): ExpressionRef => + simd_load(Operations.Load8x8SVec128, offset, align, ptr, name), + load8x8_u: (offset: number, align: number, ptr: ExpressionRef, name?: string): ExpressionRef => + simd_load(Operations.Load8x8UVec128, offset, align, ptr, name), + load16x4_s: (offset: number, align: number, ptr: ExpressionRef, name?: string): ExpressionRef => + simd_load(Operations.Load16x4SVec128, offset, align, ptr, name), + load16x4_u: (offset: number, align: number, ptr: ExpressionRef, name?: string): ExpressionRef => + simd_load(Operations.Load16x4UVec128, offset, align, ptr, name), + load32x2_s: (offset: number, align: number, ptr: ExpressionRef, name?: string): ExpressionRef => + simd_load(Operations.Load32x2SVec128, offset, align, ptr, name), + load32x2_u: (offset: number, align: number, ptr: ExpressionRef, name?: string): ExpressionRef => + simd_load(Operations.Load32x2UVec128, offset, align, ptr, name), + load32_zero: (offset: number, align: number, ptr: ExpressionRef, name?: string): ExpressionRef => + simd_load(Operations.Load32ZeroVec128, offset, align, ptr, name), + load64_zero: (offset: number, align: number, ptr: ExpressionRef, name?: string): ExpressionRef => + simd_load(Operations.Load64ZeroVec128, offset, align, ptr, name), + load8_lane: (offset: number, align: number, index: number, ptr: ExpressionRef, vec: ExpressionRef, name?: string): ExpressionRef => + simd_lane(Operations.Load8LaneVec128, offset, align, index, ptr, vec, name), + load16_lane: (offset: number, align: number, index: number, ptr: ExpressionRef, vec: ExpressionRef, name?: string): ExpressionRef => + simd_lane(Operations.Load16LaneVec128, offset, align, index, ptr, vec, name), + load32_lane: (offset: number, align: number, index: number, ptr: ExpressionRef, vec: ExpressionRef, name?: string): ExpressionRef => + simd_lane(Operations.Load32LaneVec128, offset, align, index, ptr, vec, name), + load64_lane: (offset: number, align: number, index: number, ptr: ExpressionRef, vec: ExpressionRef, name?: string): ExpressionRef => + simd_lane(Operations.Load64LaneVec128, offset, align, index, ptr, vec, name), + store8_lane: (offset: number, align: number, index: number, ptr: ExpressionRef, vec: ExpressionRef, name?: string): ExpressionRef => + simd_lane(Operations.Store8LaneVec128, offset, align, index, ptr, vec, name), + store16_lane: (offset: number, align: number, index: number, ptr: ExpressionRef, vec: ExpressionRef, name?: string): ExpressionRef => + simd_lane(Operations.Store16LaneVec128, offset, align, index, ptr, vec, name), + store32_lane: (offset: number, align: number, index: number, ptr: ExpressionRef, vec: ExpressionRef, name?: string): ExpressionRef => + simd_lane(Operations.Store32LaneVec128, offset, align, index, ptr, vec, name), + store64_lane: (offset: number, align: number, index: number, ptr: ExpressionRef, vec: ExpressionRef, name?: string): ExpressionRef => + simd_lane(Operations.Store64LaneVec128, offset, align, index, ptr, vec, name), + store: (offset: number, align: number, ptr: ExpressionRef, value: ExpressionRef, name?: string): ExpressionRef => + JSModule['_BinaryenStore'](this.ptr, 16, offset, align, ptr, value, v128, strToStack(name)), + const: (i8s: ArrayLike): ExpressionRef => { + const tempLiteral = stackAlloc(sizeOfLiteral); + JSModule['_BinaryenLiteralVec128'](tempLiteral, i8sToStack(i8s)); + return JSModule['_BinaryenConst'](this.ptr, tempLiteral); + }, + not: (value: ExpressionRef): ExpressionRef => JSModule['_BinaryenUnary'](this.ptr, Operations.NotVec128, value), + any_true: (value: ExpressionRef): ExpressionRef => JSModule['_BinaryenUnary'](this.ptr, Operations.AnyTrueVec128, value), + and: (left: ExpressionRef, right: ExpressionRef): ExpressionRef => JSModule['_BinaryenBinary'](this.ptr, Operations.AndVec128, left, right), + or: (left: ExpressionRef, right: ExpressionRef): ExpressionRef => JSModule['_BinaryenBinary'](this.ptr, Operations.OrVec128, left, right), + xor: (left: ExpressionRef, right: ExpressionRef): ExpressionRef => JSModule['_BinaryenBinary'](this.ptr, Operations.XorVec128, left, right), + andnot: (left: ExpressionRef, right: ExpressionRef): ExpressionRef => JSModule['_BinaryenBinary'](this.ptr, Operations.AndNotVec128, left, right), + bitselect: (left: ExpressionRef, right: ExpressionRef, cond: ExpressionRef): ExpressionRef => JSModule['_BinaryenBinary'](this.ptr, Operations.BitselectVec128, left, right), + pop: (): ExpressionRef => JSModule['_BinaryenPop'](this.ptr, v128) + }; + } + get i8x16 () { + const unary = (op: Operations, value: ExpressionRef) => + JSModule['_BinaryenUnary'](this.ptr, op, value); + const binary = (op: Operations, left: ExpressionRef, right: ExpressionRef) => + JSModule['_BinaryenBinary'](this.ptr, op, left, right); + return { + shuffle: (left: ExpressionRef, right: ExpressionRef, mask: ArrayLike): ExpressionRef => + preserveStack(() => JSModule['_BinaryenSIMDShuffle'](this.ptr, left, right, i8sToStack(mask))), + swizzle: (left: ExpressionRef, right: ExpressionRef): ExpressionRef => + binary(Operations.SwizzleVecI8x16, left, right), + splat: (value: ExpressionRef): ExpressionRef => + unary(Operations.SplatVecI8x16, value), + extract_lane_s: (vec: ExpressionRef, index: ExpressionRef): ExpressionRef => + JSModule['_BinaryenSIMDExtract'](this.ptr, Operations.ExtractLaneSVecI8x16, vec, index), + extract_lane_u: (vec: ExpressionRef, index: ExpressionRef): ExpressionRef => + JSModule['_BinaryenSIMDExtract'](this.ptr, Operations.ExtractLaneUVecI8x16, vec, index), + replace_lane: (vec: ExpressionRef, index: ExpressionRef, value: ExpressionRef): ExpressionRef => + JSModule['_BinaryenSIMDReplace'](this.ptr, JSModule['ReplaceLaneVecI8x16'], vec, index, value), + eq: (left: ExpressionRef, right: ExpressionRef): ExpressionRef => + binary(Operations.EqVecI8x16, left, right), + ne: (left: ExpressionRef, right: ExpressionRef): ExpressionRef => + binary(Operations.NeVecI8x16, left, right), + lt_s: (left: ExpressionRef, right: ExpressionRef): ExpressionRef => + binary(Operations.LtSVecI8x16, left, right), + lt_u: (left: ExpressionRef, right: ExpressionRef): ExpressionRef => + binary(Operations.LtUVecI8x16, left, right), + gt_s: (left: ExpressionRef, right: ExpressionRef): ExpressionRef => + binary(Operations.GtSVecI8x16, left, right), + gt_u: (left: ExpressionRef, right: ExpressionRef): ExpressionRef => + binary(Operations.GtUVecI8x16, left, right), + le_s: (left: ExpressionRef, right: ExpressionRef): ExpressionRef => + binary(Operations.LeSVecI8x16, left, right), + le_u: (left: ExpressionRef, right: ExpressionRef): ExpressionRef => + binary(Operations.LeUVecI8x16, left, right), + ge_s: (left: ExpressionRef, right: ExpressionRef): ExpressionRef => + binary(Operations.GeSVecI8x16, left, right), + ge_u: (left: ExpressionRef, right: ExpressionRef): ExpressionRef => + binary(Operations.GeUVecI8x16, left, right), + abs: (value: ExpressionRef): ExpressionRef => + unary(Operations.AbsVecI8x16, value), + neg: (value: ExpressionRef): ExpressionRef => + unary(Operations.NegVecI8x16, value), + all_true: (value: ExpressionRef): ExpressionRef => + unary(Operations.AllTrueVecI8x16, value), + bitmask: (value: ExpressionRef): ExpressionRef => + unary(Operations.BitmaskVecI8x16, value), + popcnt: (value: ExpressionRef): ExpressionRef => + unary(Operations.PopcntVecI8x16, value), + shl: (vec: ExpressionRef, shift: ExpressionRef): ExpressionRef => + JSModule['_BinaryenSIMDShift'](this.ptr, Operations.ShlVecI8x16, vec, shift), + shr_s: (vec: ExpressionRef, shift: ExpressionRef): ExpressionRef => + JSModule['_BinaryenSIMDShift'](this.ptr, Operations.ShrSVecI8x16, vec, shift), + shr_u: (vec: ExpressionRef, shift: ExpressionRef): ExpressionRef => + JSModule['_BinaryenSIMDShift'](this.ptr, Operations.ShrUVecI8x16, vec, shift), + add: (left: ExpressionRef, right: ExpressionRef): ExpressionRef => + binary(Operations.AddVecI8x16, left, right), + add_saturate_s: (left: ExpressionRef, right: ExpressionRef): ExpressionRef => + binary(Operations.AddSatSVecI8x16, left, right), + add_saturate_u: (left: ExpressionRef, right: ExpressionRef): ExpressionRef => + binary(Operations.AddSatUVecI8x16, left, right), + sub: (left: ExpressionRef, right: ExpressionRef): ExpressionRef => + binary(Operations.SubVecI8x16, left, right), + sub_saturate_s: (left: ExpressionRef, right: ExpressionRef): ExpressionRef => + binary(Operations.SubSatSVecI8x16, left, right), + sub_saturate_u: (left: ExpressionRef, right: ExpressionRef): ExpressionRef => + binary(Operations.SubSatUVecI8x16, left, right), + min_s: (left: ExpressionRef, right: ExpressionRef): ExpressionRef => + binary(Operations.MinSVecI8x16, left, right), + min_u: (left: ExpressionRef, right: ExpressionRef): ExpressionRef => + binary(Operations.MinUVecI8x16, left, right), + max_s: (left: ExpressionRef, right: ExpressionRef): ExpressionRef => + binary(Operations.MaxSVecI8x16, left, right), + max_u: (left: ExpressionRef, right: ExpressionRef): ExpressionRef => + binary(Operations.MaxUVecI8x16, left, right), + avgr_u: (left: ExpressionRef, right: ExpressionRef): ExpressionRef => + binary(Operations.AvgrUVecI8x16, left, right), + narrow_i16x8_s: (left: ExpressionRef, right: ExpressionRef): ExpressionRef => + binary(Operations.NarrowSVecI16x8ToVecI8x16, left, right), + narrow_i16x8_u: (left: ExpressionRef, right: ExpressionRef): ExpressionRef => + binary(Operations.NarrowUVecI16x8ToVecI8x16, left, right) + }; + } + get i16x8 () { + const unary = (op: Operations, value: ExpressionRef) => + JSModule['_BinaryenUnary'](this.ptr, op, value); + const binary = (op: Operations, left: ExpressionRef, right: ExpressionRef) => + JSModule['_BinaryenBinary'](this.ptr, op, left, right); + return { + splat: (value: ExpressionRef): ExpressionRef => + unary(Operations.SplatVecI16x8, value), + extract_lane_s: (vec: ExpressionRef, index: ExpressionRef): ExpressionRef => + JSModule['_BinaryenSIMDExtract'](this.ptr, Operations.ExtractLaneSVecI16x8, vec, index), + extract_lane_u: (vec: ExpressionRef, index: ExpressionRef): ExpressionRef => + JSModule['_BinaryenSIMDExtract'](this.ptr, Operations.ExtractLaneUVecI16x8, vec, index), + replace_lane: (vec: ExpressionRef, index: ExpressionRef, value: ExpressionRef): ExpressionRef => + JSModule['_BinaryenSIMDReplace'](this.ptr, Operations.ReplaceLaneVecI16x8, vec, index, value), + eq: (left: ExpressionRef, right: ExpressionRef): ExpressionRef => + binary(Operations.EqVecI16x8, left, right), + ne: (left: ExpressionRef, right: ExpressionRef): ExpressionRef => + binary(Operations.NeVecI16x8, left, right), + lt_s: (left: ExpressionRef, right: ExpressionRef): ExpressionRef => + binary(Operations.LtSVecI16x8, left, right), + lt_u: (left: ExpressionRef, right: ExpressionRef): ExpressionRef => + binary(Operations.LtUVecI16x8, left, right), + gt_s: (left: ExpressionRef, right: ExpressionRef): ExpressionRef => + binary(Operations.GtSVecI16x8, left, right), + gt_u: (left: ExpressionRef, right: ExpressionRef): ExpressionRef => + binary(Operations.GtUVecI16x8, left, right), + le_s: (left: ExpressionRef, right: ExpressionRef): ExpressionRef => + binary(Operations.LeSVecI16x8, left, right), + le_u: (left: ExpressionRef, right: ExpressionRef): ExpressionRef => + binary(Operations.LeUVecI16x8, left, right), + ge_s: (left: ExpressionRef, right: ExpressionRef): ExpressionRef => + binary(Operations.GeSVecI16x8, left, right), + ge_u: (left: ExpressionRef, right: ExpressionRef): ExpressionRef => + binary(Operations.GeUVecI16x8, left, right), + abs: (value: ExpressionRef): ExpressionRef => + unary(Operations.AbsVecI16x8, value), + neg: (value: ExpressionRef): ExpressionRef => + unary(Operations.NegVecI16x8, value), + all_true: (value: ExpressionRef): ExpressionRef => + unary(Operations.AllTrueVecI16x8, value), + bitmask: (value: ExpressionRef): ExpressionRef => + unary(Operations.BitmaskVecI16x8, value), + shl: (vec: ExpressionRef, shift: ExpressionRef): ExpressionRef => + JSModule['_BinaryenSIMDShift'](this.ptr, Operations.ShlVecI16x8, vec, shift), + shr_s: (vec: ExpressionRef, shift: ExpressionRef): ExpressionRef => + JSModule['_BinaryenSIMDShift'](this.ptr, Operations.ShrSVecI16x8, vec, shift), + shr_u: (vec: ExpressionRef, shift: ExpressionRef): ExpressionRef => + JSModule['_BinaryenSIMDShift'](this.ptr, Operations.ShrUVecI16x8, vec, shift), + add: (left: ExpressionRef, right: ExpressionRef): ExpressionRef => + binary(Operations.AddVecI16x8, left, right), + add_saturate_s: (left: ExpressionRef, right: ExpressionRef): ExpressionRef => + binary(Operations.AddSatSVecI16x8, left, right), + add_saturate_u: (left: ExpressionRef, right: ExpressionRef): ExpressionRef => + binary(Operations.AddSatUVecI16x8, left, right), + sub: (left: ExpressionRef, right: ExpressionRef): ExpressionRef => + binary(Operations.SubVecI16x8, left, right), + sub_saturate_s: (left: ExpressionRef, right: ExpressionRef): ExpressionRef => + binary(Operations.SubSatSVecI16x8, left, right), + sub_saturate_u: (left: ExpressionRef, right: ExpressionRef): ExpressionRef => + binary(Operations.SubSatUVecI16x8, left, right), + mul: (left: ExpressionRef, right: ExpressionRef): ExpressionRef => + binary(Operations.MulVecI16x8, left, right), + min_s: (left: ExpressionRef, right: ExpressionRef): ExpressionRef => + binary(Operations.MinSVecI16x8, left, right), + min_u: (left: ExpressionRef, right: ExpressionRef): ExpressionRef => + binary(Operations.MinUVecI16x8, left, right), + max_s: (left: ExpressionRef, right: ExpressionRef): ExpressionRef => + binary(Operations.MaxSVecI16x8, left, right), + max_u: (left: ExpressionRef, right: ExpressionRef): ExpressionRef => + binary(Operations.MaxUVecI16x8, left, right), + q15mulr_sat_s: (left: ExpressionRef, right: ExpressionRef): ExpressionRef => + binary(Operations.Q15MulrSatSVecI16x8, left, right), + extmul_low_i8x16_s: (left: ExpressionRef, right: ExpressionRef): ExpressionRef => + binary(Operations.ExtMulLowSVecI16x8, left, right), + extmul_high_i8x16_s: (left: ExpressionRef, right: ExpressionRef): ExpressionRef => + binary(Operations.ExtMulHighSVecI16x8, left, right), + extmul_low_i8x16_u: (left: ExpressionRef, right: ExpressionRef): ExpressionRef => + binary(Operations.ExtMulLowUVecI16x8, left, right), + extmul_high_i8x16_u: (left: ExpressionRef, right: ExpressionRef): ExpressionRef => + binary(Operations.ExtMulHighUVecI16x8, left, right), + extadd_pairwise_i8x16_s: (value: ExpressionRef): ExpressionRef => + unary(Operations.ExtAddPairwiseSVecI8x16ToI16x8, value), + extadd_pairwise_i8x16_u: (value: ExpressionRef): ExpressionRef => + unary(Operations.ExtAddPairwiseUVecI8x16ToI16x8, value), + narrow_i32x4_s: (left: ExpressionRef, right: ExpressionRef): ExpressionRef => + binary(Operations.NarrowSVecI32x4ToVecI16x8, left, right), + narrow_i32x4_u: (left: ExpressionRef, right: ExpressionRef): ExpressionRef => + binary(Operations.NarrowUVecI32x4ToVecI16x8, left, right), + extend_low_i8x16_s: (value: ExpressionRef): ExpressionRef => + unary(Operations.ExtendLowSVecI8x16ToVecI16x8, value), + extend_high_i8x16_s: (value: ExpressionRef): ExpressionRef => + unary(Operations.ExtendHighSVecI8x16ToVecI16x8, value), + extend_low_i8x16_u: (value: ExpressionRef): ExpressionRef => + unary(Operations.ExtendLowUVecI8x16ToVecI16x8, value), + extend_high_i8x16_u: (value: ExpressionRef): ExpressionRef => + unary(Operations.ExtendHighUVecI8x16ToVecI16x8, value) + }; + } + get i32x4 () { + const unary = (op: Operations, value: ExpressionRef) => + JSModule['_BinaryenUnary'](this.ptr, op, value); + const binary = (op: Operations, left: ExpressionRef, right: ExpressionRef) => + JSModule['_BinaryenBinary'](this.ptr, op, left, right); + return { + splat: (value: ExpressionRef): ExpressionRef => + unary(Operations.SplatVecI32x4, value), + extract_lane: (vec: ExpressionRef, index: ExpressionRef): ExpressionRef => + JSModule['_BinaryenSIMDExtract'](this.ptr, Operations.ExtractLaneVecI32x4, vec, index), + replace_lane: (vec: ExpressionRef, index: ExpressionRef, value: ExpressionRef): ExpressionRef => + JSModule['_BinaryenSIMDReplace'](this.ptr, Operations.ReplaceLaneVecI32x4, vec, index, value), + eq: (left: ExpressionRef, right: ExpressionRef): ExpressionRef => + binary(Operations.EqVecI32x4, left, right), + ne: (left: ExpressionRef, right: ExpressionRef): ExpressionRef => + binary(Operations.NeVecI32x4, left, right), + lt_s: (left: ExpressionRef, right: ExpressionRef): ExpressionRef => + binary(Operations.LtSVecI32x4, left, right), + lt_u: (left: ExpressionRef, right: ExpressionRef): ExpressionRef => + binary(Operations.LtUVecI32x4, left, right), + gt_s: (left: ExpressionRef, right: ExpressionRef): ExpressionRef => + binary(Operations.GtSVecI32x4, left, right), + gt_u: (left: ExpressionRef, right: ExpressionRef): ExpressionRef => + binary(Operations.GtUVecI32x4, left, right), + le_s: (left: ExpressionRef, right: ExpressionRef): ExpressionRef => + binary(Operations.LeSVecI32x4, left, right), + le_u: (left: ExpressionRef, right: ExpressionRef): ExpressionRef => + binary(Operations.LeUVecI32x4, left, right), + ge_s: (left: ExpressionRef, right: ExpressionRef): ExpressionRef => + binary(Operations.GeSVecI32x4, left, right), + ge_u: (left: ExpressionRef, right: ExpressionRef): ExpressionRef => + binary(Operations.GeUVecI32x4, left, right), + abs: (value: ExpressionRef): ExpressionRef => + unary(Operations.AbsVecI32x4, value), + neg: (value: ExpressionRef): ExpressionRef => + unary(Operations.NegVecI32x4, value), + all_true: (value: ExpressionRef): ExpressionRef => + unary(Operations.AllTrueVecI32x4, value), + bitmask: (value: ExpressionRef): ExpressionRef => + unary(Operations.BitmaskVecI32x4, value), + shl: (vec: ExpressionRef, shift: ExpressionRef): ExpressionRef => + JSModule['_BinaryenSIMDShift'](this.ptr, Operations.ShlVecI32x4, vec, shift), + shr_s: (vec: ExpressionRef, shift: ExpressionRef): ExpressionRef => + JSModule['_BinaryenSIMDShift'](this.ptr, Operations.ShrSVecI32x4, vec, shift), + shr_u: (vec: ExpressionRef, shift: ExpressionRef): ExpressionRef => + JSModule['_BinaryenSIMDShift'](this.ptr, Operations.ShrUVecI32x4, vec, shift), + add: (left: ExpressionRef, right: ExpressionRef): ExpressionRef => + binary(Operations.AddVecI32x4, left, right), + sub: (left: ExpressionRef, right: ExpressionRef): ExpressionRef => + binary(Operations.SubVecI32x4, left, right), + mul: (left: ExpressionRef, right: ExpressionRef): ExpressionRef => + binary(Operations.MulVecI32x4, left, right), + min_s: (left: ExpressionRef, right: ExpressionRef): ExpressionRef => + binary(Operations.MinSVecI32x4, left, right), + min_u: (left: ExpressionRef, right: ExpressionRef): ExpressionRef => + binary(Operations.MinUVecI32x4, left, right), + max_s: (left: ExpressionRef, right: ExpressionRef): ExpressionRef => + binary(Operations.MaxSVecI32x4, left, right), + max_u: (left: ExpressionRef, right: ExpressionRef): ExpressionRef => + binary(Operations.MaxUVecI32x4, left, right), + dot_i16x8_s: (left: ExpressionRef, right: ExpressionRef): ExpressionRef => + binary(Operations.DotSVecI16x8ToVecI32x4, left, right), + extmul_low_i16x8_s: (left: ExpressionRef, right: ExpressionRef): ExpressionRef => + binary(Operations.ExtMulLowSVecI32x4, left, right), + extmul_high_i16x8_s: (left: ExpressionRef, right: ExpressionRef): ExpressionRef => + binary(Operations.ExtMulHighSVecI32x4, left, right), + extmul_low_i16x8_u: (left: ExpressionRef, right: ExpressionRef): ExpressionRef => + binary(Operations.ExtMulLowUVecI32x4, left, right), + extmul_high_i16x8_u: (left: ExpressionRef, right: ExpressionRef): ExpressionRef => + binary(Operations.ExtMulHighUVecI32x4, left, right), + extadd_pairwise_i16x8_s: (value: ExpressionRef): ExpressionRef => + unary(Operations.ExtAddPairwiseSVecI16x8ToI32x4, value), + extadd_pairwise_i16x8_u: (value: ExpressionRef): ExpressionRef => + unary(Operations.ExtAddPairwiseUVecI16x8ToI32x4, value), + trunc_sat_f32x4_s: (left: ExpressionRef, right: ExpressionRef): ExpressionRef => + binary(Operations.TruncSatSVecF32x4ToVecI32x4, left, right), + trunc_sat_f32x4_u: (left: ExpressionRef, right: ExpressionRef): ExpressionRef => + binary(Operations.TruncSatUVecF32x4ToVecI32x4, left, right), + extend_low_i16x8_s: (value: ExpressionRef): ExpressionRef => + unary(Operations.ExtendLowSVecI16x8ToVecI32x4, value), + extend_high_i16x8_s: (value: ExpressionRef): ExpressionRef => + unary(Operations.ExtendHighSVecI16x8ToVecI32x4, value), + extend_low_i16x8_u: (value: ExpressionRef): ExpressionRef => + unary(Operations.ExtendLowUVecI16x8ToVecI32x4, value), + extend_high_i16x8_u: (value: ExpressionRef): ExpressionRef => + unary(Operations.ExtendHighUVecI16x8ToVecI32x4, value), + trunc_sat_f64x2_s_zero: (left: ExpressionRef, right: ExpressionRef): ExpressionRef => + binary(Operations.TruncSatZeroSVecF64x2ToVecI32x4, left, right), + trunc_sat_f64x2_u_zero: (left: ExpressionRef, right: ExpressionRef): ExpressionRef => + binary(Operations.TruncSatZeroUVecF64x2ToVecI32x4, left, right) + }; + } + get i64x2 () { + const unary = (op: Operations, value: ExpressionRef) => + JSModule['_BinaryenUnary'](this.ptr, op, value); + const binary = (op: Operations, left: ExpressionRef, right: ExpressionRef) => + JSModule['_BinaryenBinary'](this.ptr, op, left, right); + return { + splat: (value: ExpressionRef): ExpressionRef => + unary(Operations.SplatVecI64x2, value), + extract_lane: (vec: ExpressionRef, index: ExpressionRef): ExpressionRef => + JSModule['_BinaryenSIMDExtract'](this.ptr, Operations.ExtractLaneVecI64x2, vec, index), + replace_lane: (vec: ExpressionRef, index: ExpressionRef, value: ExpressionRef): ExpressionRef => + JSModule['_BinaryenSIMDReplace'](this.ptr, Operations.ReplaceLaneVecI64x2, vec, index, value), + eq: (left: ExpressionRef, right: ExpressionRef): ExpressionRef => + binary(Operations.EqVecI64x2, left, right), + ne: (left: ExpressionRef, right: ExpressionRef): ExpressionRef => + binary(Operations.NeVecI64x2, left, right), + lt_s: (left: ExpressionRef, right: ExpressionRef): ExpressionRef => + binary(Operations.LtSVecI64x2, left, right), + gt_s: (left: ExpressionRef, right: ExpressionRef): ExpressionRef => + binary(Operations.GtSVecI64x2, left, right), + le_s: (left: ExpressionRef, right: ExpressionRef): ExpressionRef => + binary(Operations.LeSVecI64x2, left, right), + ge_s: (left: ExpressionRef, right: ExpressionRef): ExpressionRef => + binary(Operations.GeSVecI64x2, left, right), + abs: (value: ExpressionRef): ExpressionRef => + unary(Operations.AbsVecI64x2, value), + neg: (value: ExpressionRef): ExpressionRef => + unary(Operations.NegVecI64x2, value), + all_true: (value: ExpressionRef): ExpressionRef => + unary(Operations.AllTrueVecI64x2, value), + bitmask: (value: ExpressionRef): ExpressionRef => + unary(Operations.BitmaskVecI64x2, value), + shl: (vec: ExpressionRef, shift: ExpressionRef): ExpressionRef => + JSModule['_BinaryenSIMDShift'](this.ptr, Operations.ShlVecI64x2, vec, shift), + shr_s: (vec: ExpressionRef, shift: ExpressionRef): ExpressionRef => + JSModule['_BinaryenSIMDShift'](this.ptr, Operations.ShrSVecI64x2, vec, shift), + shr_u: (vec: ExpressionRef, shift: ExpressionRef): ExpressionRef => + JSModule['_BinaryenSIMDShift'](this.ptr, Operations.ShrUVecI64x2, vec, shift), + add: (left: ExpressionRef, right: ExpressionRef): ExpressionRef => + binary(Operations.AddVecI64x2, left, right), + sub: (left: ExpressionRef, right: ExpressionRef): ExpressionRef => + binary(Operations.SubVecI64x2, left, right), + mul: (left: ExpressionRef, right: ExpressionRef): ExpressionRef => + binary(Operations.MulVecI64x2, left, right), + extmul_low_i32x4_s: (left: ExpressionRef, right: ExpressionRef): ExpressionRef => + binary(Operations.ExtMulLowSVecI64x2, left, right), + extmul_high_i32x4_s: (left: ExpressionRef, right: ExpressionRef): ExpressionRef => + binary(Operations.ExtMulHighSVecI64x2, left, right), + extmul_low_i32x4_u: (left: ExpressionRef, right: ExpressionRef): ExpressionRef => + binary(Operations.ExtMulLowUVecI64x2, left, right), + extmul_high_i32x4_u: (left: ExpressionRef, right: ExpressionRef): ExpressionRef => + binary(Operations.ExtMulHighUVecI64x2, left, right), + extend_low_i32x4_s: (value: ExpressionRef): ExpressionRef => + unary(Operations.ExtendLowSVecI32x4ToVecI64x2, value), + extend_high_i32x4_s: (value: ExpressionRef): ExpressionRef => + unary(Operations.ExtendHighSVecI32x4ToVecI64x2, value), + extend_low_i32x4_u: (value: ExpressionRef): ExpressionRef => + unary(Operations.ExtendLowUVecI32x4ToVecI64x2, value), + extend_high_i32x4_u: (value: ExpressionRef): ExpressionRef => + unary(Operations.ExtendHighUVecI32x4ToVecI64x2, value) + }; + } + get f32x4 () { + const unary = (op: Operations, value: ExpressionRef) => + JSModule['_BinaryenUnary'](this.ptr, op, value); + const binary = (op: Operations, left: ExpressionRef, right: ExpressionRef) => + JSModule['_BinaryenBinary'](this.ptr, op, left, right); + return { + splat: (value: ExpressionRef): ExpressionRef => + unary(Operations.SplatVecF32x4, value), + extract_lane: (vec: ExpressionRef, index: ExpressionRef): ExpressionRef => + JSModule['_BinaryenSIMDExtract'](this.ptr, Operations.ExtractLaneVecF32x4, vec, index), + replace_lane: (vec: ExpressionRef, index: ExpressionRef, value: ExpressionRef): ExpressionRef => + JSModule['_BinaryenSIMDReplace'](this.ptr, Operations.ReplaceLaneVecF32x4, vec, index, value), + eq: (left: ExpressionRef, right: ExpressionRef): ExpressionRef => + binary(Operations.EqVecF32x4, left, right), + ne: (left: ExpressionRef, right: ExpressionRef): ExpressionRef => + binary(Operations.NeVecF32x4, left, right), + lt: (left: ExpressionRef, right: ExpressionRef): ExpressionRef => + binary(Operations.LtVecF32x4, left, right), + gt: (left: ExpressionRef, right: ExpressionRef): ExpressionRef => + binary(Operations.GtVecF32x4, left, right), + le: (left: ExpressionRef, right: ExpressionRef): ExpressionRef => + binary(Operations.LeVecF32x4, left, right), + ge: (left: ExpressionRef, right: ExpressionRef): ExpressionRef => + binary(Operations.GeVecF32x4, left, right), + abs: (value: ExpressionRef): ExpressionRef => + unary(Operations.AbsVecF32x4, value), + neg: (value: ExpressionRef): ExpressionRef => + unary(Operations.NegVecF32x4, value), + sqrt: (value: ExpressionRef): ExpressionRef => + unary(Operations.SqrtVecF32x4, value), + add: (left: ExpressionRef, right: ExpressionRef): ExpressionRef => + binary(Operations.AddVecF32x4, left, right), + sub: (left: ExpressionRef, right: ExpressionRef): ExpressionRef => + binary(Operations.SubVecF32x4, left, right), + mul: (left: ExpressionRef, right: ExpressionRef): ExpressionRef => + binary(Operations.MulVecF32x4, left, right), + div: (left: ExpressionRef, right: ExpressionRef): ExpressionRef => + binary(Operations.DivVecF32x4, left, right), + min: (left: ExpressionRef, right: ExpressionRef): ExpressionRef => + binary(Operations.MinVecF32x4, left, right), + max: (left: ExpressionRef, right: ExpressionRef): ExpressionRef => + binary(Operations.MaxVecF32x4, left, right), + pmin: (left: ExpressionRef, right: ExpressionRef): ExpressionRef => + binary(Operations.PMinVecF32x4, left, right), + pmax: (left: ExpressionRef, right: ExpressionRef): ExpressionRef => + binary(Operations.PMaxVecF32x4, left, right), + ceil: (value: ExpressionRef): ExpressionRef => + unary(Operations.CeilVecF32x4, value), + floor: (value: ExpressionRef): ExpressionRef => + unary(Operations.FloorVecF32x4, value), + trunc: (value: ExpressionRef): ExpressionRef => + unary(Operations.TruncVecF32x4, value), + nearest: (value: ExpressionRef): ExpressionRef => + unary(Operations.NearestVecF32x4, value), + convert_i32x4_s: (value: ExpressionRef): ExpressionRef => + unary(Operations.ConvertSVecI32x4ToVecF32x4, value), + convert_i32x4_u: (value: ExpressionRef): ExpressionRef => + unary(Operations.ConvertUVecI32x4ToVecF32x4, value), + demote_f64x2_zero: (value: ExpressionRef): ExpressionRef => + unary(Operations.DemoteZeroVecF64x2ToVecF32x4, value) + }; + } + get f64x2 () { + const unary = (op: Operations, value: ExpressionRef) => + JSModule['_BinaryenUnary'](this.ptr, op, value); + const binary = (op: Operations, left: ExpressionRef, right: ExpressionRef) => + JSModule['_BinaryenBinary'](this.ptr, op, left, right); + return { + splat: (value: ExpressionRef): ExpressionRef => + unary(Operations.SplatVecF64x2, value), + extract_lane: (vec: ExpressionRef, index: ExpressionRef): ExpressionRef => + JSModule['_BinaryenSIMDExtract'](this.ptr, Operations.ExtractLaneVecF64x2, vec, index), + replace_lane: (vec: ExpressionRef, index: ExpressionRef, value: ExpressionRef): ExpressionRef => + JSModule['_BinaryenSIMDReplace'](this.ptr, Operations.ReplaceLaneVecF64x2, vec, index, value), + eq: (left: ExpressionRef, right: ExpressionRef): ExpressionRef => + binary(Operations.EqVecF64x2, left, right), + ne: (left: ExpressionRef, right: ExpressionRef): ExpressionRef => + binary(Operations.NeVecF64x2, left, right), + lt: (left: ExpressionRef, right: ExpressionRef): ExpressionRef => + binary(Operations.LtVecF64x2, left, right), + gt: (left: ExpressionRef, right: ExpressionRef): ExpressionRef => + binary(Operations.GtVecF64x2, left, right), + le: (left: ExpressionRef, right: ExpressionRef): ExpressionRef => + binary(Operations.LeVecF64x2, left, right), + ge: (left: ExpressionRef, right: ExpressionRef): ExpressionRef => + binary(Operations.GeVecF64x2, left, right), + abs: (value: ExpressionRef): ExpressionRef => + unary(Operations.AbsVecF64x2, value), + neg: (value: ExpressionRef): ExpressionRef => + unary(Operations.NegVecF64x2, value), + sqrt: (value: ExpressionRef): ExpressionRef => + unary(Operations.SqrtVecF64x2, value), + add: (left: ExpressionRef, right: ExpressionRef): ExpressionRef => + binary(Operations.AddVecF64x2, left, right), + sub: (left: ExpressionRef, right: ExpressionRef): ExpressionRef => + binary(Operations.SubVecF64x2, left, right), + mul: (left: ExpressionRef, right: ExpressionRef): ExpressionRef => + binary(Operations.MulVecF64x2, left, right), + div: (left: ExpressionRef, right: ExpressionRef): ExpressionRef => + binary(Operations.DivVecF64x2, left, right), + min: (left: ExpressionRef, right: ExpressionRef): ExpressionRef => + binary(Operations.MinVecF64x2, left, right), + max: (left: ExpressionRef, right: ExpressionRef): ExpressionRef => + binary(Operations.MaxVecF64x2, left, right), + pmin: (left: ExpressionRef, right: ExpressionRef): ExpressionRef => + binary(Operations.PMinVecF64x2, left, right), + pmax: (left: ExpressionRef, right: ExpressionRef): ExpressionRef => + binary(Operations.PMaxVecF64x2, left, right), + ceil: (value: ExpressionRef): ExpressionRef => + unary(Operations.CeilVecF64x2, value), + floor: (value: ExpressionRef): ExpressionRef => + unary(Operations.FloorVecF64x2, value), + trunc: (value: ExpressionRef): ExpressionRef => + unary(Operations.TruncVecF64x2, value), + nearest: (value: ExpressionRef): ExpressionRef => + unary(Operations.NearestVecF64x2, value), + convert_low_i32x4_s: (value: ExpressionRef): ExpressionRef => + unary(Operations.ConvertLowSVecI32x4ToVecF64x2, value), + convert_low_i32x4_u: (value: ExpressionRef): ExpressionRef => + unary(Operations.ConvertLowUVecI32x4ToVecF64x2, value), + promote_low_f32x4: (value: ExpressionRef): ExpressionRef => + unary(Operations.PromoteLowVecF32x4ToVecF64x2, value) + }; + } + get funcref() { + return { + pop: (): ExpressionRef => JSModule['_BinaryenPop'](this.ptr, funcref) + }; + } + get externref() { + return { + pop: (): ExpressionRef => JSModule['_BinaryenPop'](this.ptr, externref) + }; + } + get anyref() { + return { + pop: (): ExpressionRef => JSModule['_BinaryenPop'](this.ptr, anyref) + }; + } + get eqref() { + return { + pop: (): ExpressionRef => JSModule['_BinaryenPop'](this.ptr, eqref) + }; + } + get i31ref() { + return { + pop: (): ExpressionRef => JSModule['_BinaryenPop'](this.ptr, i31ref) + }; + } + get structref() { + return { + pop: (): ExpressionRef => JSModule['_BinaryenPop'](this.ptr, structref) + }; + } + /* explicitly skipping string stuff until it's reprioritized + get stringref() { + return { + pop: () => JSModule['_BinaryenPop'](this.ptr, stringref) + } + } + get stringview_wtf8() { + return { + pop: () => JSModule['_BinaryenPop'](this.ptr, stringview_wtf8) + } + } + get stringview_wtf16() { + return { + pop: () => JSModule['_BinaryenPop'](this.ptr, stringview_wtf16) + } + } + get stringview_iter() { + return { + pop: () => JSModule['_BinaryenPop'](this.ptr, stringview_iter) + } + } + */ + get ref() { + return { + null: (type: Type): ExpressionRef => JSModule['_BinaryenRefNull'](this.ptr, type), + is_null: (value: ExpressionRef): ExpressionRef => JSModule['_BinaryenRefIsNull'](this.ptr, value), + i31: (value: ExpressionRef): ExpressionRef => JSModule['_BinaryenRefI31'](this.ptr, value), + func: (name: string, type: Type): ExpressionRef => JSModule['_BinaryenRefFunc'](this.ptr, strToStack(name), type), + eq: (left: ExpressionRef, right: ExpressionRef): ExpressionRef => JSModule['_BinaryenRefEq'](this.ptr, left, right), + as_non_null: (value: ExpressionRef): ExpressionRef => JSModule['_BinaryenRefAs'](this.ptr, Operations.RefAsNonNull, value) + }; + } + get i31 () { + return { + get_s: (i31: ExpressionRef): ExpressionRef => JSModule['_BinaryenI31Get'](this.ptr, i31, 1), + get_u: (i31: ExpressionRef): ExpressionRef => JSModule['_BinaryenI31Get'](this.ptr, i31, 0) + }; + } + get atomic () { + return { + fence: (): ExpressionRef => JSModule['_BinaryenAtomicFence'](this.ptr) + }; + } + get locals () { + return { + get: (index: number, type: Type): ExpressionRef => JSModule['_BinaryenLocalGet'](this.ptr, index, type), + set: (index: number, value: ExpressionRef): ExpressionRef => JSModule['_BinaryenLocalSet'](this.ptr, index, value), + tee: (index: number, value: ExpressionRef, type: Type): ExpressionRef => { + if (typeof type === 'undefined') { + throw new Error("local.tee's type should be defined"); + } + return JSModule['_BinaryenLocalTee'](this.ptr, index, value, type); + } + }; + } + get globals () { + return { + add: (name: string, type: Type, mutable: boolean, init: ExpressionRef): GlobalRef => + preserveStack(() => JSModule['_BinaryenAddGlobal'](this.ptr, strToStack(name), type, mutable, init)), + getRefByName: (name: string): GlobalRef => preserveStack(() => JSModule['_BinaryenGetGlobal'](this.ptr, strToStack(name))), + getRefByIndex: (index: number): GlobalRef => JSModule['_BinaryenGetGlobalByIndex'](this.ptr, index), + remove: (name: string): void => preserveStack(() => JSModule['_BinaryenRemoveGlobal'](this.ptr, strToStack(name))), + count: (): number => JSModule['_BinaryenGetNumGlobals'](this.ptr), + set: (name: string, value: ExpressionRef): ExpressionRef => JSModule['_BinaryenGlobalSet'](this.ptr, strToStack(name), value), + get: (name: string, type: Type): ExpressionRef => JSModule['_BinaryenGlobalGet'](this.ptr, strToStack(name), type), + addImport: (internalName: string, externalModuleName: string, externalBaseName: string, globalType: Type, mutable: boolean): void => + preserveStack(() => JSModule['_BinaryenAddGlobalImport'](this.ptr, strToStack(internalName), strToStack(externalModuleName), strToStack(externalBaseName), globalType, mutable)), + addExport: (internalName: string, externalName: string): ExportRef => + preserveStack(() => JSModule['_BinaryenAddGlobalExport'](this.ptr, strToStack(internalName), strToStack(externalName))), + getInfo: (ref: GlobalRef): GlobalInfo => { + return { + 'name': UTF8ToString(JSModule['_BinaryenGlobalGetName'](ref)), + 'module': UTF8ToString(JSModule['_BinaryenGlobalImportGetModule'](ref)), + 'base': UTF8ToString(JSModule['_BinaryenGlobalImportGetBase'](ref)), + 'type': JSModule['_BinaryenGlobalGetType'](ref), + 'mutable': Boolean(JSModule['_BinaryenGlobalIsMutable'](ref)), + 'init': JSModule['_BinaryenGlobalGetInitExpr'](ref) + }; + } + }; + } + get tables () { + return { + add: (name: string, initial: number, maximum: number, type: Type): TableRef => + preserveStack(() => JSModule['_BinaryenAddTable'](this.ptr, strToStack(name), initial, maximum, type)), + getRefByName: (name: string): TableRef => + preserveStack(() => JSModule['_BinaryenGetTable'](this.ptr, strToStack(name))), + getRefByIndex: (index: number): TableRef => JSModule['_BinaryenGetTableByIndex'](this.ptr, index), + remove: (name: string): void => + preserveStack(() => JSModule['_BinaryenRemoveTable'](this.ptr, strToStack(name))), + count: (): number => JSModule['_BinaryenGetNumTables'](this.ptr), + get: (name: string, index: ExpressionRef, type: Type): ExpressionRef => JSModule['_BinaryenTableGet'](this.ptr, strToStack(name), index, type), + set: (name: string, index: ExpressionRef, value: ExpressionRef): ExpressionRef => JSModule['_BinaryenTableSet'](this.ptr, strToStack(name), index, value), + size: (name: string): ExpressionRef => JSModule['_BinaryenTableSize'](this.ptr, strToStack(name)), + grow: (name: string, value: ExpressionRef, delta: ExpressionRef): ExpressionRef => JSModule['_BinaryenTableGrow'](this.ptr, strToStack(name), value, delta), + addImport: (internalName: string, externalModuleName: string, externalBaseName: string): void => + preserveStack(() => JSModule['_BinaryenAddTableImport'](this.ptr, strToStack(internalName), strToStack(externalModuleName), strToStack(externalBaseName))), + addExport: (internalName: string, externalName: string): ExportRef => + preserveStack(() => JSModule['_BinaryenAddTableExport'](this.ptr, strToStack(internalName), strToStack(externalName))), + getInfo: (table: TableRef): TableInfo => { + const hasMax = Boolean(JSModule['_BinaryenTableHasMax'](this.ptr, table)); + const withMax = hasMax ? { max: JSModule['_BinaryenTableGetMax'](this.ptr, table)} : {}; + return Object.assign({ + 'name': UTF8ToString(JSModule['_BinaryenTableGetName'](table)), + 'module': UTF8ToString(JSModule['_BinaryenTableImportGetModule'](table)), + 'base': UTF8ToString(JSModule['_BinaryenTableImportGetBase'](table)), + 'initial': JSModule['_BinaryenTableGetInitial'](table), + }, withMax); + } + }; + /* TODO + a._BinaryenTableGetName = Q.My; + a._BinaryenTableSetName = Q.Ny; + a._BinaryenTableGetInitial = Q.Oy; + a._BinaryenTableSetInitial = Q.Py; + a._BinaryenTableHasMax = Q.Qy; + a._BinaryenTableGetMax = Q.Ry; + a._BinaryenTableSetMax = Q.Sy; + a._BinaryenTableGetType = Q.Ty; + a._BinaryenTableSetType = Q.Uy; + */ + } + get tuples () { + return { + make: (elements: ExportRef[]): ExpressionRef => + preserveStack(() => JSModule['_BinaryenTupleMake'](this.ptr, i32sToStack(elements), elements.length)), + extract: (tuple: ExpressionRef, index: number): ExpressionRef => + JSModule['_BinaryenTupleExtract'](this.ptr, tuple, index) + }; + } + get functions () { + return { + add: (name: string, params: Type, results: Type, varTypes: Type[], body: ExpressionRef): FunctionRef => + preserveStack(() => + JSModule['_BinaryenAddFunction'](this.ptr, strToStack(name), params, results, i32sToStack(varTypes), varTypes.length, body)), + getRefByName: (name: string): FunctionRef => + preserveStack(() => JSModule['_BinaryenGetFunction'](this.ptr, strToStack(name))), + getRefByIndex: (index: number): FunctionRef => + JSModule['_BinaryenGetFunctionByIndex'](this.ptr, index), + remove: (name: string): void => + preserveStack(() => JSModule['_BinaryenRemoveFunction'](this.ptr, strToStack(name))), + count: (): number => JSModule['_BinaryenGetNumFunctions'](this.ptr), + addImport: (internalName: string, externalModuleName: string, externalBaseName: string, params: Type, results: Type): void => + preserveStack(() => + JSModule['_BinaryenAddFunctionImport'](this.ptr, strToStack(internalName), strToStack(externalModuleName), strToStack(externalBaseName), params, results) + ), + addExport: (internalName: string, externalName: string): ExportRef => + preserveStack(() => JSModule['_BinaryenAddFunctionExport'](this.ptr, strToStack(internalName), strToStack(externalName))) + }; + } + get tags() { + return { + add: (name: string, params: Type, results: Type): TagRef => + preserveStack(() => JSModule['_BinaryenAddTag'](this.ptr, strToStack(name), params, results)), + getRefByName: (name: string): TagRef => + preserveStack(() => JSModule['_BinaryenGetTag'](this.ptr, strToStack(name))), + remove: (name: string): void => + preserveStack(() => JSModule['_BinaryenRemoveTag'](this.ptr, strToStack(name))), + addImport: (internalName: string, externalModuleName: string, externalBaseName: string, params: Type, results: Type): void => + preserveStack(() => JSModule['_BinaryenAddTagImport'](this.ptr, strToStack(internalName), strToStack(externalModuleName), strToStack(externalBaseName), params, results)), + addExport: (internalName: string, externalName: string): ExportRef => + preserveStack(() => JSModule['_BinaryenAddTagExport'](this.ptr, strToStack(internalName), strToStack(externalName))), + getInfo: (tag: TagRef): TagInfo => { + return { + 'name': UTF8ToString(JSModule['_BinaryenTagGetName'](tag)), + 'module': UTF8ToString(JSModule['_BinaryenTagImportGetModule'](tag)), + 'base': UTF8ToString(JSModule['_BinaryenTagImportGetBase'](tag)), + 'params': JSModule['_BinaryenTagGetParams'](tag), + 'results': JSModule['_BinaryenTagGetResults'](tag) + }; + } + }; + } + get memory () { + return { + init: (data: string, dest: ExpressionRef, offset: ExpressionRef, size: ExpressionRef, name?: string): ExpressionRef => + preserveStack(() => JSModule['_BinaryenMemoryInit'](this.ptr, strToStack(data), dest, offset, size, strToStack(name))), + has: () => Boolean(JSModule['_BinaryenHasMemory'](this.ptr)), + size: (name?: string, memory64?: boolean): ExpressionRef => JSModule['_BinaryenMemorySize'](this.ptr, strToStack(name), memory64), + grow: (value: ExpressionRef, name?: string, memory64?: boolean): ExpressionRef => JSModule['_BinaryenMemoryGrow'](this.ptr, value, strToStack(name), memory64), + copy: (dest: ExpressionRef, source: ExpressionRef, size: ExpressionRef, destName?: string, sourceName?: string): ExpressionRef => + JSModule['_BinaryenMemoryCopy'](this.ptr, dest, source, size, strToStack(destName), strToStack(sourceName)), + fill: (dest: ExpressionRef, value: ExpressionRef, size: ExpressionRef, name?: string): ExpressionRef => + JSModule['_BinaryenMemoryFill'](this.ptr, dest, value, size, strToStack(name)), + set: (initial: number, maximum: number, exportName?: string | null, segments?: SegmentInfo[] | null, shared?: boolean, memory64?: boolean, internalName?: string): void => + preserveStack(() => { + const segmentsLen = segments ? segments.length : 0; + const names = new Array(segmentsLen); + const datas = new Array(segmentsLen); + const lengths = new Array(segmentsLen); + const passives = new Array(segmentsLen); + const offsets = new Array(segmentsLen); + for (let i = 0; i < segmentsLen; i++) { + const { name, data, offset, passive } = segments[i]; + names[i] = strToStack(name); + datas[i] = _malloc(data.length); + HEAP8.set(data, datas[i]); + lengths[i] = data.length; + passives[i] = passive; + offsets[i] = offset; + } + const ret = JSModule['_BinaryenSetMemory']( + this.ptr, initial, maximum, strToStack(exportName), + i32sToStack(names), + i32sToStack(datas), + i8sToStack(passives), + i32sToStack(offsets), + i32sToStack(lengths), + segmentsLen, + shared, + memory64, + strToStack(internalName) + ); + for (let i = segmentsLen - 1; i >= 0; i--) { + _free(datas[i]); + } + return ret; + }), + getInfo: (name?: string): MemoryInfo => { + const hasMax = Boolean(JSModule['_BinaryenMemoryHasMax'](this.ptr, strToStack(name))); + const withMax = hasMax ? { max: JSModule['_BinaryenMemoryGetMax'](this.ptr, strToStack(name))} : {}; + return Object.assign({ + module: UTF8ToString(JSModule['_BinaryenMemoryImportGetModule'](this.ptr, strToStack(name))), + base: UTF8ToString(JSModule['_BinaryenMemoryImportGetBase'](this.ptr, strToStack(name))), + initial: JSModule['_BinaryenMemoryGetInitial'](this.ptr, strToStack(name)), + shared: Boolean(JSModule['_BinaryenMemoryIsShared'](this.ptr, strToStack(name))), + is64: Boolean(JSModule['_BinaryenMemoryIs64'](this.ptr, strToStack(name))), + }, withMax); + }, + countSegments: (): number => JSModule['_BinaryenGetNumMemorySegments'](this.ptr), + getSegmentInfo: (name: string): SegmentInfo => { + const passive = Boolean(JSModule['_BinaryenGetMemorySegmentPassive'](this.ptr, strToStack(name))); + const offset = passive ? 0 : JSModule['_BinaryenGetMemorySegmentByteOffset'](this.ptr, strToStack(name)); + const size = JSModule['_BinaryenGetMemorySegmentByteLength'](this.ptr, strToStack(name)); + const ptr = _malloc(size); + JSModule['_BinaryenCopyMemorySegmentData'](this.ptr, strToStack(name), ptr); + const data = new Uint8Array(size); + data.set(HEAP8.subarray(ptr, ptr + size)); + _free(ptr); + return { name, offset, data, passive }; + }, + countElementSegments: (): number => JSModule['_BinaryenGetNumElementSegments'](this.ptr), + getElementSegmentByIndex: (index: number): ElementSegmentRef => JSModule['_BinaryenGetElementSegmentByIndex'](this.ptr, index), + getElementSegmentInfo: (segment: ElementSegmentRef): ElementSegmentInfo => { + const segmentLength = JSModule['_BinaryenElementSegmentGetLength'](segment); + const names = new Array(segmentLength); + for (let j = 0; j < segmentLength; j++) { + names[j] = UTF8ToString(JSModule['_BinaryenElementSegmentGetData'](segment, j)); + } + return { + 'name': UTF8ToString(JSModule['_BinaryenElementSegmentGetName'](segment)), + 'table': UTF8ToString(JSModule['_BinaryenElementSegmentGetTable'](segment)), + 'offset': JSModule['_BinaryenElementSegmentGetOffset'](segment), + 'data': names + }; + }, + addImport: (internalName: string, externalModuleName: string, externalBaseName: string, shared: boolean): void => + preserveStack(() => JSModule['_BinaryenAddMemoryImport'](this.ptr, strToStack(internalName), strToStack(externalModuleName), strToStack(externalBaseName), shared)), + addExport: (internalName: string, externalName: string): ExportRef => + preserveStack(() => JSModule['_BinaryenAddMemoryExport'](this.ptr, strToStack(internalName), strToStack(externalName))), + atomic: { + notify: (ptr: ExpressionRef, notifyCount: ExpressionRef, name?: string): ExpressionRef => + JSModule['_BinaryenAtomicNotify'](this.ptr, ptr, notifyCount, strToStack(name)), + wait32: (ptr: ExpressionRef, expected: ExpressionRef, timeout: ExpressionRef, name?: string): ExpressionRef => + JSModule['_BinaryenAtomicWait'](this.ptr, ptr, expected, timeout, JSModule['i32'], strToStack(name)), + wait64: (ptr: ExpressionRef, expected: ExpressionRef, timeout: ExpressionRef, name?: string): ExpressionRef => + JSModule['_BinaryenAtomicWait'](this.ptr, ptr, expected, timeout, JSModule['i64'], strToStack(name)) + } + }; + } + get data () { + return { + drop: (segment: string): ExpressionRef => preserveStack(() => JSModule['_BinaryenDataDrop'](this.ptr, strToStack(segment))) + }; + } + get exports () { + return { + getRefByName: (externalName: string): ExportRef => + preserveStack(() => JSModule['_BinaryenGetExport'](this.ptr, strToStack(externalName))), + getRefByIndex: (index: number): ExportRef => JSModule['_BinaryenGetExportByIndex'](this.ptr, index), + remove: (externalName: string): void => preserveStack(() => JSModule['_BinaryenRemoveExport'](this.ptr, strToStack(externalName))), + count: (): number => JSModule['_BinaryenGetNumExports'](this.ptr), + getInfo: (export_: ExportRef): ExportInfo => { + return { + 'kind': JSModule['_BinaryenExportGetKind'](export_), + 'name': UTF8ToString(JSModule['_BinaryenExportGetName'](export_)), + 'value': UTF8ToString(JSModule['_BinaryenExportGetValue'](export_)) + }; + } + + }; + } + get expressions () { + return { + copy: (expr: ExpressionRef): ExpressionRef => JSModule['_BinaryenExpressionCopy'](expr, this.ptr), + getType: (expression: ExpressionRef): Type => JSModule['_BinaryenExpressionGetType'](expression), + getInfo: (expression: ExpressionRef): ExpressionInfo => getExpressionInfo(expression), + getSideEffects: (expression: ExpressionRef): SideEffects => JSModule['_BinaryenExpressionGetSideEffects'](expression, this.ptr), + emitText: (expression: ExpressionRef): string => { + let text = ''; + const old = swapOut(s => { text += s + '\n' }); + JSModule['_BinaryenExpressionPrint'](expression); + swapOut(old); + return text; + } + }; + } + get arrays () { + return { + newFromInit: (heapType: HeapType, size: ExpressionRef, init: ExpressionRef): ExpressionRef => + JSModule['_BinaryenArrayNew'](this.ptr, heapType, size, init), + newFromData: (heapType: HeapType, name: string, offset: ExpressionRef, size: ExpressionRef): ExpressionRef => + JSModule['_BinaryenArrayNewData'](this.ptr, heapType, strToStack(name), offset, size), + newFromItems: (heapType: HeapType, values: ExpressionRef[]): ExpressionRef => { + const ptr = _malloc(Math.max(8, values.length * 4)); + let offset = ptr; + values.forEach(value => { + __i32_store(offset, value); + offset += 4; + }) + const result = JSModule['_BinaryenArrayNewFixed'](this.ptr, heapType, ptr, values.length); + _free(ptr); + return result; + }, + copy: (destArray: ExpressionRef, destItem: ExpressionRef, srcArray: ExpressionRef, srcItem: ExpressionRef, numItems: ExpressionRef): ExpressionRef => + JSModule['_BinaryenArrayCopy'](this.ptr, destArray, destItem, srcArray, srcItem, numItems), + getItem: (array: ExpressionRef, item: ExpressionRef, type: Type, signed: boolean): ExpressionRef => + JSModule['_BinaryenArrayGet'](this.ptr, array, item, type, signed), + setItem: (array: ExpressionRef, item: ExpressionRef, value: ExpressionRef): ExpressionRef => + JSModule['_BinaryenArraySet'](this.ptr, array, item, value), + length: (array: ExpressionRef): ExpressionRef => + JSModule['_BinaryenArrayLen'](this.ptr, array) + } + } + get structs () { + return { + newFromFields: (heapType: HeapType, values: ExpressionRef[]): ExpressionRef => { + const ptr = _malloc(4 * values.length); + let offset = ptr; + values.forEach(value => { + __i32_store(offset, value); + offset += 4; + }); + const result = JSModule['_BinaryenStructNew'](this.ptr, ptr, values.length, heapType); + _free(ptr); + return result; + }, + getMember: (struct: ExpressionRef, memberIndex: number, resultType: Type, signed: boolean) => + JSModule['_BinaryenStructGet'](this.ptr, memberIndex, struct, resultType, signed), + setMember: (struct: ExpressionRef, memberIndex: number, value: ExpressionRef) => + JSModule['_BinaryenStructSet'](this.ptr, memberIndex, struct, value) + } + } +} + +export class Relooper { + + readonly ref: RelooperBlockRef + + constructor(module: Module, ref?: RelooperBlockRef) { + this.ref = ref || JSModule['_RelooperCreate'](module.ptr); + } + addBlock(code: ExpressionRef): RelooperBlockRef { + return JSModule['_RelooperAddBlock'](this.ref, code); + } + addBranch(from: RelooperBlockRef, to: RelooperBlockRef, condition: ExpressionRef, code: ExpressionRef): void { + JSModule['_RelooperAddBranch'](from, to, condition, code); + } + addBlockWithSwitch(code: ExpressionRef, condition: ExpressionRef): RelooperBlockRef { + return JSModule['_RelooperAddBlockWithSwitch'](this.ref, code, condition); + } + addBranchForSwitch(from: RelooperBlockRef, to: RelooperBlockRef, indexes: number[], code: ExpressionRef): void { + preserveStack(() => JSModule['_RelooperAddBranchForSwitch'](from, to, i32sToStack(indexes), indexes.length, code)); + } + renderAndDispose(entry: RelooperBlockRef, labelHelper: number): ExpressionRef { + return JSModule['_RelooperRenderAndDispose'](this.ref, entry, labelHelper); + } +} + +export enum ExpressionRunnerFlags { + Default = JSModule['_ExpressionRunnerFlagsDefault'](), + PreserveSideEffects = JSModule['_ExpressionRunnerFlagsPreserveSideeffects'](), + TraverseCalls = JSModule['_ExpressionRunnerFlagsTraverseCalls']() +} + +export class ExpressionRunner { + + readonly ref: ExpressionRunnerRef; + + constructor(module: Module, flags: ExpressionRunnerFlags, maxDepth: number, maxLoopIterations: number) { + this.ref = JSModule['_ExpressionRunnerCreate'](module.ptr, flags, maxDepth, maxLoopIterations); + } + setLocalValue(index: number, valueExpr: ExpressionRef): boolean { + return Boolean(JSModule['_ExpressionRunnerSetLocalValue'](this.ref, index, valueExpr)); + } + setGlobalValue(name: string, valueExpr: ExpressionRef): boolean { + return preserveStack(() => Boolean(JSModule['_ExpressionRunnerSetGlobalValue'](this.ref, strToStack(name), valueExpr))); + } + runAndDispose(expr: ExpressionRef): ExpressionRef { + return JSModule['_ExpressionRunnerRunAndDispose'](this.ref, expr); + } +} + +export interface TypeBuilderResult { + heapTypes: HeapType[]; + errorIndex: number | null; + errorReason: number | null; +} + +export interface FieldType { + type: Type, + packedType: PackedType, + mutable: boolean +} +export class TypeBuilder { + + static typeFromTempHeapType(heapType: HeapType, nullable: boolean): Type { + return JSModule['_BinaryenTypeFromHeapType'](heapType, nullable); + } + + static heapTypeFromType(type: Type): HeapType { + return JSModule['_BinaryenTypeGetHeapType'](type); + } + + static arrayElementType(heapType: HeapType): Type { + return JSModule['_BinaryenArrayTypeGetElementType'](heapType); + } + + static structMemberCount(heapType: HeapType): number { + return JSModule['_BinaryenStructTypeGetNumFields'](heapType); + } + + static structMemberType(heapType: HeapType, index: number): Type { + return JSModule['_BinaryenStructTypeGetFieldType'](heapType, index); + } + + readonly ref: TypeBuilderRef; + + constructor(slots: number) { + this.ref = JSModule['_TypeBuilderCreate'](slots); + } + + setArrayType(slot: number, elementType: FieldType): TypeBuilder { + JSModule['_TypeBuilderSetArrayType'](this.ref, slot, elementType.type, elementType.packedType, elementType.mutable); + return this; + } + + setStructType(slot: number, fieldTypes: FieldType[]): TypeBuilder { + const types = _malloc(4 * fieldTypes.length); + const packedTypes = _malloc(4 * fieldTypes.length); + // assume sizeof(bool) is 1 + const mutables = _malloc(fieldTypes.length); + let typesPtr = types, packedTypesPtr = packedTypes, mutablesPtr = mutables; + fieldTypes.forEach(field => { + __i32_store(typesPtr, field.type); typesPtr += 4; + __i32_store(packedTypesPtr, field.packedType); packedTypesPtr += 4; + __i32_store(mutablesPtr, field.mutable ? 1 : 0); mutablesPtr ++; + }); + JSModule['_TypeBuilderSetStructType'](this.ref, slot, types, packedTypes, mutables, fieldTypes.length); + _free(mutables); + _free(packedTypes); + _free(types); + return this; + } + + getTempHeapType(slot: number): HeapType { + return JSModule['_TypeBuilderGetTempHeapType'](this.ref, slot); + } + + buildAndDispose(): TypeBuilderResult { + const size = JSModule['_TypeBuilderGetSize'](this.ref) as number; + const ptr = _malloc( 4 + 4 + (4 * size)); // assume 4-bytes memory reference + const errorIndexPtr = ptr; + const errorReasonPtr = ptr + 4; + const heapTypesPtr = ptr + 8; + const ok = JSModule['_TypeBuilderBuildAndDispose'](this.ref, heapTypesPtr, errorIndexPtr, errorReasonPtr); + const errorIndex = __i32_load(errorIndexPtr); + const errorReason = __i32_load(errorReasonPtr); + const heapTypes: HeapType[] = []; + if (ok) { + for(let i=0, offset = heapTypesPtr;i < size; i++, offset += 4) { + const type = __i32_load(offset); + heapTypes.push(type); + } + } + _free(ptr); + return { heapTypes, errorIndex, errorReason}; + } + +} + + +export interface SegmentInfo { + name?: string; + offset: ExpressionRef; + data: Uint8Array; + passive?: boolean; +} + +export interface MemoryInfo { + module: string | null; + base: string | null; + shared: boolean; + is64: boolean; + initial: number; + max?: number; +} + +export interface ExpressionInfo { + id: number; + type: Type; + } + +export interface BlockInfo extends ExpressionInfo { + name: string; + children: ExpressionRef[]; + } + +export interface IfInfo extends ExpressionInfo { + condition: ExpressionRef; + ifTrue: ExpressionRef; + ifFalse: ExpressionRef; + } + +export interface LoopInfo extends ExpressionInfo { + name: string; + body: ExpressionRef; + } + +export interface BreakInfo extends ExpressionInfo { + name: string; + condition: ExpressionRef; + value: ExpressionRef; + } + +export interface SwitchInfo extends ExpressionInfo { + names: string[]; + defaultName: string | null; + condition: ExpressionRef; + value: ExpressionRef; + } + +export interface CallInfo extends ExpressionInfo { + isReturn: boolean; + target: string; + operands: ExpressionRef[]; + } + +export interface CallIndirectInfo extends ExpressionInfo { + isReturn: boolean; + target: ExpressionRef; + operands: ExpressionRef[]; + } + +export interface LocalGetInfo extends ExpressionInfo { + index: number; + } + +export interface LocalSetInfo extends ExpressionInfo { + isTee: boolean; + index: number; + value: ExpressionRef; + } + +export interface GlobalGetInfo extends ExpressionInfo { + name: string; + } + +export interface GlobalSetInfo extends ExpressionInfo { + name: string; + value: ExpressionRef; + } + +export interface TableGetInfo extends ExpressionInfo { + table: string; + index: ExpressionRef; + } + +export interface TableSetInfo extends ExpressionInfo { + table: string; + index: ExpressionRef; + value: ExpressionRef; + } + +export interface TableSizeInfo extends ExpressionInfo { + table: string; + } + +export interface TableGrowInfo extends ExpressionInfo { + table: string; + value: ExpressionRef; + delta: ExpressionRef; + } + +export interface LoadInfo extends ExpressionInfo { + isAtomic: boolean; + isSigned: boolean; + offset: number; + bytes: number; + align: number; + ptr: ExpressionRef; + } + +export interface StoreInfo extends ExpressionInfo { + isAtomic: boolean; + offset: number; + bytes: number; + align: number; + ptr: ExpressionRef; + value: ExpressionRef; + } + +export interface ConstInfo extends ExpressionInfo { + value: number | { low: number, high: number } | Array; + } + +export interface UnaryInfo extends ExpressionInfo { + op: Operations; + value: ExpressionRef; + } + +export interface BinaryInfo extends ExpressionInfo { + op: Operations; + left: ExpressionRef; + right: ExpressionRef; + } + +export interface SelectInfo extends ExpressionInfo { + ifTrue: ExpressionRef; + ifFalse: ExpressionRef; + condition: ExpressionRef; + } + +export interface DropInfo extends ExpressionInfo { + value: ExpressionRef; + } + +export interface ReturnInfo extends ExpressionInfo { + value: ExpressionRef; + } + +export interface NopInfo extends ExpressionInfo { + } + +export interface UnreachableInfo extends ExpressionInfo { + } + +export interface PopInfo extends ExpressionInfo { + } + +export interface MemorySizeInfo extends ExpressionInfo { + } + +export interface MemoryGrowInfo extends ExpressionInfo { + delta: ExpressionRef; + } + +export interface AtomicRMWInfo extends ExpressionInfo { + op: Operations; + bytes: number; + offset: number; + ptr: ExpressionRef; + value: ExpressionRef; + } + +export interface AtomicCmpxchgInfo extends ExpressionInfo { + bytes: number; + offset: number; + ptr: ExpressionRef; + expected: ExpressionRef; + replacement: ExpressionRef; + } + +export interface AtomicWaitInfo extends ExpressionInfo { + ptr: ExpressionRef; + expected: ExpressionRef; + timeout: ExpressionRef; + expectedType: Type; + } + +export interface AtomicNotifyInfo extends ExpressionInfo { + ptr: ExpressionRef; + notifyCount: ExpressionRef; + } + +export interface AtomicFenceInfo extends ExpressionInfo { + order: number; + } + +export interface SIMDExtractInfo extends ExpressionInfo { + op: Operations; + vec: ExpressionRef; + index: ExpressionRef; + } + +export interface SIMDReplaceInfo extends ExpressionInfo { + op: Operations; + vec: ExpressionRef; + index: ExpressionRef; + value: ExpressionRef; + } + +export interface SIMDShuffleInfo extends ExpressionInfo { + left: ExpressionRef; + right: ExpressionRef; + mask: number[]; + } + +export interface SIMDTernaryInfo extends ExpressionInfo { + op: Operations; + a: ExpressionRef; + b: ExpressionRef; + c: ExpressionRef; + } + +export interface SIMDShiftInfo extends ExpressionInfo { + op: Operations; + vec: ExpressionRef; + shift: ExpressionRef; + } + +export interface SIMDLoadInfo extends ExpressionInfo { + op: Operations; + offset: number; + align: number; + ptr: ExpressionRef; + } + +export interface SIMDLoadStoreLaneInfo extends ExpressionInfo { + op: Operations; + offset: number; + align: number; + index: number; + ptr: ExpressionRef; + vec: ExpressionRef; + } + +export interface MemoryInitInfo extends ExpressionInfo { + segment: string; + dest: ExpressionRef; + offset: ExpressionRef; + size: ExpressionRef; + } + +export interface DataDropInfo extends ExpressionInfo { + segment: string; + } + +export interface MemoryCopyInfo extends ExpressionInfo { + dest: ExpressionRef; + source: ExpressionRef; + size: ExpressionRef; + } + +export interface MemoryFillInfo extends ExpressionInfo { + dest: ExpressionRef; + value: ExpressionRef; + size: ExpressionRef; + } + +export interface RefNullInfo extends ExpressionInfo { + } + +export interface RefIsNullInfo extends ExpressionInfo { + op: Operations; + value: ExpressionRef; + } + +export interface RefAsInfo extends ExpressionInfo { + op: Operations; + value: ExpressionRef; + } + +export interface RefFuncInfo extends ExpressionInfo { + func: string; + } + +export interface RefEqInfo extends ExpressionInfo { + left: ExpressionRef; + right: ExpressionRef; + } + +export interface TryInfo extends ExpressionInfo { + name: string; + body: ExpressionRef; + catchTags: string[]; + catchBodies: ExpressionRef[]; + hasCatchAll: boolean; + delegateTarget: string; + isDelegate: boolean; + } + +export interface ThrowInfo extends ExpressionInfo { + tag: string; + operands: ExpressionRef[]; + } + +export interface RethrowInfo extends ExpressionInfo { + target: string; + } + +export interface TupleMakeInfo extends ExpressionInfo { + operands: ExpressionRef[]; + } + +export interface TupleExtractInfo extends ExpressionInfo { + tuple: ExpressionRef; + index: number; + } + +export interface RefI31Info extends ExpressionInfo { + value: ExpressionRef; + } + +export interface I31GetInfo extends ExpressionInfo { + i31: ExpressionRef; + isSigned: boolean; + } + +function getExpressionInfo(expression: ExpressionRef) { + const id = JSModule['_BinaryenExpressionGetId'](expression); + const type = JSModule['_BinaryenExpressionGetType'](expression); + switch (id) { + case JSModule['BlockId']: + return { + 'id': id, + 'type': type, + 'name': UTF8ToString(JSModule['_BinaryenBlockGetName'](expression)), + 'children': getAllNested(expression, JSModule['_BinaryenBlockGetNumChildren'], JSModule['_BinaryenBlockGetChildAt']) + } as BlockInfo; + case JSModule['IfId']: + return { + 'id': id, + 'type': type, + 'condition': JSModule['_BinaryenIfGetCondition'](expression), + 'ifTrue': JSModule['_BinaryenIfGetIfTrue'](expression), + 'ifFalse': JSModule['_BinaryenIfGetIfFalse'](expression) + } as IfInfo; + case JSModule['LoopId']: + return { + 'id': id, + 'type': type, + 'name': UTF8ToString(JSModule['_BinaryenLoopGetName'](expression)), + 'body': JSModule['_BinaryenLoopGetBody'](expression) + } as LoopInfo; + case JSModule['BreakId']: + return { + 'id': id, + 'type': type, + 'name': UTF8ToString(JSModule['_BinaryenBreakGetName'](expression)), + 'condition': JSModule['_BinaryenBreakGetCondition'](expression), + 'value': JSModule['_BinaryenBreakGetValue'](expression) + } as BreakInfo; + case JSModule['SwitchId']: + return { + 'id': id, + 'type': type, + // Do not pass the index as the second parameter to UTF8ToString as that will cut off the string. + 'names': getAllNested(expression, JSModule['_BinaryenSwitchGetNumNames'], JSModule['_BinaryenSwitchGetNameAt']).map(p => UTF8ToString(p)), + 'defaultName': UTF8ToString(JSModule['_BinaryenSwitchGetDefaultName'](expression)), + 'condition': JSModule['_BinaryenSwitchGetCondition'](expression), + 'value': JSModule['_BinaryenSwitchGetValue'](expression) + } as SwitchInfo; + case JSModule['CallId']: + return { + 'id': id, + 'type': type, + 'isReturn': Boolean(JSModule['_BinaryenCallIsReturn'](expression)), + 'target': UTF8ToString(JSModule['_BinaryenCallGetTarget'](expression)), + 'operands': getAllNested(expression, JSModule[ '_BinaryenCallGetNumOperands'], JSModule['_BinaryenCallGetOperandAt']) + } as CallInfo; + case JSModule['CallIndirectId']: + return { + 'id': id, + 'type': type, + 'isReturn': Boolean(JSModule['_BinaryenCallIndirectIsReturn'](expression)), + 'target': JSModule['_BinaryenCallIndirectGetTarget'](expression), + 'table': JSModule['_BinaryenCallIndirectGetTable'](expression), + 'operands': getAllNested(expression, JSModule['_BinaryenCallIndirectGetNumOperands'], JSModule['_BinaryenCallIndirectGetOperandAt']) + } as CallIndirectInfo; + case JSModule['LocalGetId']: + return { + 'id': id, + 'type': type, + 'index': JSModule['_BinaryenLocalGetGetIndex'](expression) + } as LocalGetInfo; + case JSModule['LocalSetId']: + return { + 'id': id, + 'type': type, + 'isTee': Boolean(JSModule['_BinaryenLocalSetIsTee'](expression)), + 'index': JSModule['_BinaryenLocalSetGetIndex'](expression), + 'value': JSModule['_BinaryenLocalSetGetValue'](expression) + } as LocalSetInfo; + case JSModule['GlobalGetId']: + return { + 'id': id, + 'type': type, + 'name': UTF8ToString(JSModule['_BinaryenGlobalGetGetName'](expression)) + } as GlobalGetInfo; + case JSModule['GlobalSetId']: + return { + 'id': id, + 'type': type, + 'name': UTF8ToString(JSModule['_BinaryenGlobalSetGetName'](expression)), + 'value': JSModule['_BinaryenGlobalSetGetValue'](expression) + } as GlobalSetInfo; + case JSModule['TableGetId']: + return { + 'id': id, + 'type': type, + 'table': UTF8ToString(JSModule['_BinaryenTableGetGetTable'](expression)), + 'index': JSModule['_BinaryenTableGetGetIndex'](expression) + } as TableGetInfo; + case JSModule['TableSetId']: + return { + 'id': id, + 'type': type, + 'table': UTF8ToString(JSModule['_BinaryenTableSetGetTable'](expression)), + 'index': JSModule['_BinaryenTableSetGetIndex'](expression), + 'value': JSModule['_BinaryenTableSetGetValue'](expression) + } as TableSetInfo; + case JSModule['TableSizeId']: + return { + 'id': id, + 'type': type, + 'table': UTF8ToString(JSModule['_BinaryenTableSizeGetTable'](expression)), + } as TableSizeInfo; + case JSModule['TableGrowId']: + return { + 'id': id, + 'type': type, + 'table': UTF8ToString(JSModule['_BinaryenTableGrowGetTable'](expression)), + 'value': JSModule['_BinaryenTableGrowGetValue'](expression), + 'delta': JSModule['_BinaryenTableGrowGetDelta'](expression), + } as TableGrowInfo; + case JSModule['LoadId']: + return { + 'id': id, + 'type': type, + 'isAtomic': Boolean(JSModule['_BinaryenLoadIsAtomic'](expression)), + 'isSigned': Boolean(JSModule['_BinaryenLoadIsSigned'](expression)), + 'offset': JSModule['_BinaryenLoadGetOffset'](expression), + 'bytes': JSModule['_BinaryenLoadGetBytes'](expression), + 'align': JSModule['_BinaryenLoadGetAlign'](expression), + 'ptr': JSModule['_BinaryenLoadGetPtr'](expression) + } as LoadInfo; + case JSModule['StoreId']: + return { + 'id': id, + 'type': type, + 'isAtomic': Boolean(JSModule['_BinaryenStoreIsAtomic'](expression)), + 'offset': JSModule['_BinaryenStoreGetOffset'](expression), + 'bytes': JSModule['_BinaryenStoreGetBytes'](expression), + 'align': JSModule['_BinaryenStoreGetAlign'](expression), + 'ptr': JSModule['_BinaryenStoreGetPtr'](expression), + 'value': JSModule['_BinaryenStoreGetValue'](expression) + } as StoreInfo; + case JSModule['ConstId']: { + let value; + switch (type) { + case i32: + value = JSModule['_BinaryenConstGetValueI32'](expression); + break; + case i64: + value = { + 'low': JSModule['_BinaryenConstGetValueI64Low'](expression), + 'high': JSModule['_BinaryenConstGetValueI64High'](expression) + }; + break; + case f32: + value = JSModule['_BinaryenConstGetValueF32'](expression); + break; + case f64: + value = JSModule['_BinaryenConstGetValueF64'](expression); + break; + case v128: { + preserveStack(() => { + const tempBuffer = stackAlloc(16); + JSModule['_BinaryenConstGetValueV128'](expression, tempBuffer); + value = new Array(16); + for (let i = 0; i < 16; i++) { + value[i] = HEAPU8[tempBuffer + i]; + } + }); + } + break; + default: + throw new Error('unexpected type: ' + type); + } + return { + 'id': id, + 'type': type, + 'value': value + } as ConstInfo; + } + case JSModule['UnaryId']: + return { + 'id': id, + 'type': type, + 'op': JSModule['_BinaryenUnaryGetOp'](expression), + 'value': JSModule['_BinaryenUnaryGetValue'](expression) + } as UnaryInfo; + case JSModule['BinaryId']: + return { + 'id': id, + 'type': type, + 'op': JSModule['_BinaryenBinaryGetOp'](expression), + 'left': JSModule['_BinaryenBinaryGetLeft'](expression), + 'right': JSModule['_BinaryenBinaryGetRight'](expression) + } as BinaryInfo; + case JSModule['SelectId']: + return { + 'id': id, + 'type': type, + 'ifTrue': JSModule['_BinaryenSelectGetIfTrue'](expression), + 'ifFalse': JSModule['_BinaryenSelectGetIfFalse'](expression), + 'condition': JSModule['_BinaryenSelectGetCondition'](expression) + } as SelectInfo; + case JSModule['DropId']: + return { + 'id': id, + 'type': type, + 'value': JSModule['_BinaryenDropGetValue'](expression) + } as DropInfo; + case JSModule['ReturnId']: + return { + 'id': id, + 'type': type, + 'value': JSModule['_BinaryenReturnGetValue'](expression) + } as ReturnInfo; + case JSModule['NopId']: + return { + 'id': id, + 'type': type + } as NopInfo; + case JSModule['UnreachableId']: + return { + 'id': id, + 'type': type + } as UnreachableInfo; + case JSModule['PopId']: + return { + 'id': id, + 'type': type + } as PopInfo; + case JSModule['MemorySizeId']: + return { + 'id': id, + 'type': type + } as MemorySizeInfo; + case JSModule['MemoryGrowId']: + return { + 'id': id, + 'type': type, + 'delta': JSModule['_BinaryenMemoryGrowGetDelta'](expression) + } as MemoryGrowInfo; + case JSModule['AtomicRMWId']: + return { + 'id': id, + 'type': type, + 'op': JSModule['_BinaryenAtomicRMWGetOp'](expression), + 'bytes': JSModule['_BinaryenAtomicRMWGetBytes'](expression), + 'offset': JSModule['_BinaryenAtomicRMWGetOffset'](expression), + 'ptr': JSModule['_BinaryenAtomicRMWGetPtr'](expression), + 'value': JSModule['_BinaryenAtomicRMWGetValue'](expression) + } as AtomicRMWInfo; + case JSModule['AtomicCmpxchgId']: + return { + 'id': id, + 'type': type, + 'bytes': JSModule['_BinaryenAtomicCmpxchgGetBytes'](expression), + 'offset': JSModule['_BinaryenAtomicCmpxchgGetOffset'](expression), + 'ptr': JSModule['_BinaryenAtomicCmpxchgGetPtr'](expression), + 'expected': JSModule['_BinaryenAtomicCmpxchgGetExpected'](expression), + 'replacement': JSModule['_BinaryenAtomicCmpxchgGetReplacement'](expression) + } as AtomicCmpxchgInfo; + case JSModule['AtomicWaitId']: + return { + 'id': id, + 'type': type, + 'ptr': JSModule['_BinaryenAtomicWaitGetPtr'](expression), + 'expected': JSModule['_BinaryenAtomicWaitGetExpected'](expression), + 'timeout': JSModule['_BinaryenAtomicWaitGetTimeout'](expression), + 'expectedType': JSModule['_BinaryenAtomicWaitGetExpectedType'](expression) + } as AtomicWaitInfo; + case JSModule['AtomicNotifyId']: + return { + 'id': id, + 'type': type, + 'ptr': JSModule['_BinaryenAtomicNotifyGetPtr'](expression), + 'notifyCount': JSModule['_BinaryenAtomicNotifyGetNotifyCount'](expression) + } as AtomicNotifyInfo; + case JSModule['AtomicFenceId']: + return { + 'id': id, + 'type': type, + 'order': JSModule['_BinaryenAtomicFenceGetOrder'](expression) + } as AtomicFenceInfo; + case JSModule['SIMDExtractId']: + return { + 'id': id, + 'type': type, + 'op': JSModule['_BinaryenSIMDExtractGetOp'](expression), + 'vec': JSModule['_BinaryenSIMDExtractGetVec'](expression), + 'index': JSModule['_BinaryenSIMDExtractGetIndex'](expression) + } as SIMDExtractInfo; + case JSModule['SIMDReplaceId']: + return { + 'id': id, + 'type': type, + 'op': JSModule['_BinaryenSIMDReplaceGetOp'](expression), + 'vec': JSModule['_BinaryenSIMDReplaceGetVec'](expression), + 'index': JSModule['_BinaryenSIMDReplaceGetIndex'](expression), + 'value': JSModule['_BinaryenSIMDReplaceGetValue'](expression) + } as SIMDReplaceInfo; + case JSModule['SIMDShuffleId']: + return preserveStack(() => { + const tempBuffer = stackAlloc(16); + JSModule['_BinaryenSIMDShuffleGetMask'](expression, tempBuffer); + const mask = new Array(16); + for (let i = 0; i < 16; i++) { + mask[i] = HEAPU8[tempBuffer + i]; + } + return { + 'id': id, + 'type': type, + 'left': JSModule['_BinaryenSIMDShuffleGetLeft'](expression), + 'right': JSModule['_BinaryenSIMDShuffleGetRight'](expression), + 'mask': mask + } as SIMDShuffleInfo; + }); + case JSModule['SIMDTernaryId']: + return { + 'id': id, + 'type': type, + 'op': JSModule['_BinaryenSIMDTernaryGetOp'](expression), + 'a': JSModule['_BinaryenSIMDTernaryGetA'](expression), + 'b': JSModule['_BinaryenSIMDTernaryGetB'](expression), + 'c': JSModule['_BinaryenSIMDTernaryGetC'](expression) + } as SIMDTernaryInfo; + case JSModule['SIMDShiftId']: + return { + 'id': id, + 'type': type, + 'op': JSModule['_BinaryenSIMDShiftGetOp'](expression), + 'vec': JSModule['_BinaryenSIMDShiftGetVec'](expression), + 'shift': JSModule['_BinaryenSIMDShiftGetShift'](expression) + } as SIMDShiftInfo; + case JSModule['SIMDLoadId']: + return { + 'id': id, + 'type': type, + 'op': JSModule['_BinaryenSIMDLoadGetOp'](expression), + 'offset': JSModule['_BinaryenSIMDLoadGetOffset'](expression), + 'align': JSModule['_BinaryenSIMDLoadGetAlign'](expression), + 'ptr': JSModule['_BinaryenSIMDLoadGetPtr'](expression) + } as SIMDLoadInfo; + case JSModule['SIMDLoadStoreLaneId']: + return { + 'id': id, + 'type': type, + 'op': JSModule['_BinaryenSIMDLoadStoreLaneGetOp'](expression), + 'offset': JSModule['_BinaryenSIMDLoadStoreLaneGetOffset'](expression), + 'align': JSModule['_BinaryenSIMDLoadStoreLaneGetAlign'](expression), + 'index': JSModule['_BinaryenSIMDLoadStoreLaneGetIndex'](expression), + 'ptr': JSModule['_BinaryenSIMDLoadStoreLaneGetPtr'](expression), + 'vec': JSModule['_BinaryenSIMDLoadStoreLaneGetVec'](expression) + } as SIMDLoadStoreLaneInfo; + case JSModule['MemoryInitId']: + return { + 'id': id, + 'type': type, + 'segment': UTF8ToString(JSModule['_BinaryenMemoryInitGetSegment'](expression)), + 'dest': JSModule['_BinaryenMemoryInitGetDest'](expression), + 'offset': JSModule['_BinaryenMemoryInitGetOffset'](expression), + 'size': JSModule['_BinaryenMemoryInitGetSize'](expression) + } as MemoryInitInfo; + case JSModule['DataDropId']: + return { + 'id': id, + 'type': type, + 'segment': UTF8ToString(JSModule['_BinaryenDataDropGetSegment'](expression)), + } as DataDropInfo; + case JSModule['MemoryCopyId']: + return { + 'id': id, + 'type': type, + 'dest': JSModule['_BinaryenMemoryCopyGetDest'](expression), + 'source': JSModule['_BinaryenMemoryCopyGetSource'](expression), + 'size': JSModule['_BinaryenMemoryCopyGetSize'](expression) + } as MemoryCopyInfo; + case JSModule['MemoryFillId']: + return { + 'id': id, + 'type': type, + 'dest': JSModule['_BinaryenMemoryFillGetDest'](expression), + 'value': JSModule['_BinaryenMemoryFillGetValue'](expression), + 'size': JSModule['_BinaryenMemoryFillGetSize'](expression) + } as MemoryFillInfo; + case JSModule['RefNullId']: + return { + 'id': id, + 'type': type + } as RefNullInfo; + case JSModule['RefIsNullId']: + return { + 'id': id, + 'type': type, + 'value': JSModule['_BinaryenRefIsNullGetValue'](expression) + } as RefIsNullInfo; + case JSModule['RefAsId']: + return { + 'id': id, + 'type': type, + 'op': JSModule['_BinaryenRefAsGetOp'](expression), + 'value': JSModule['_BinaryenRefAsGetValue'](expression) + } as RefAsInfo; + case JSModule['RefFuncId']: + return { + 'id': id, + 'type': type, + 'func': UTF8ToString(JSModule['_BinaryenRefFuncGetFunc'](expression)), + } as RefFuncInfo; + case JSModule['RefEqId']: + return { + 'id': id, + 'type': type, + 'left': JSModule['_BinaryenRefEqGetLeft'](expression), + 'right': JSModule['_BinaryenRefEqGetRight'](expression) + } as RefEqInfo; + case JSModule['TryId']: + return { + 'id': id, + 'type': type, + 'name': UTF8ToString(JSModule['_BinaryenTryGetName'](expression)), + 'body': JSModule['_BinaryenTryGetBody'](expression), + 'catchTags': getAllNested(expression, JSModule['_BinaryenTryGetNumCatchTags'], JSModule['_BinaryenTryGetCatchTagAt']), + 'catchBodies': getAllNested(expression, JSModule['_BinaryenTryGetNumCatchBodies'], JSModule['_BinaryenTryGetCatchBodyAt']), + 'hasCatchAll': JSModule['_BinaryenTryHasCatchAll'](expression) as boolean, + 'delegateTarget': UTF8ToString(JSModule['_BinaryenTryGetDelegateTarget'](expression)) as string, + 'isDelegate': JSModule['_BinaryenTryIsDelegate'](expression) as boolean + } as TryInfo; + case JSModule['ThrowId']: + return { + 'id': id, + 'type': type, + 'tag': UTF8ToString(JSModule['_BinaryenThrowGetTag'](expression)), + 'operands': getAllNested(expression, JSModule['_BinaryenThrowGetNumOperands'], JSModule['_BinaryenThrowGetOperandAt']) + } as ThrowInfo; + case JSModule['RethrowId']: + return { + 'id': id, + 'type': type, + 'target': UTF8ToString(JSModule['_BinaryenRethrowGetTarget'](expression)) + } as RethrowInfo; + case JSModule['TupleMakeId']: + return { + 'id': id, + 'type': type, + 'operands': getAllNested(expression, JSModule['_BinaryenTupleMakeGetNumOperands'], JSModule['_BinaryenTupleMakeGetOperandAt']) + } as TupleMakeInfo; + case JSModule['TupleExtractId']: + return { + 'id': id, + 'type': type, + 'tuple': JSModule['_BinaryenTupleExtractGetTuple'](expression), + 'index': JSModule['_BinaryenTupleExtractGetIndex'](expression) + } as TupleExtractInfo; + case JSModule['RefI31Id']: + return { + 'id': id, + 'type': type, + 'value': JSModule['_BinaryenRefI31GetValue'](expression) + } as RefI31Info; + case JSModule['I31GetId']: + return { + 'id': id, + 'type': type, + 'i31': JSModule['_BinaryenI31GetGetI31'](expression), + 'isSigned': Boolean(JSModule['_BinaryenI31GetIsSigned'](expression)) + } as I31GetInfo; + default: + throw Error('unexpected id: ' + id); + } +} diff --git a/src/ts/binaryen_post.ts b/src/ts/binaryen_post.ts new file mode 100644 index 00000000000..b9d1a4ac09f --- /dev/null +++ b/src/ts/binaryen_post.ts @@ -0,0 +1,28 @@ +type Writer = (...data: any[]) => void; + +declare var Module: object; +declare var out: Writer; +declare var err: Writer; +declare var _BinaryenSizeofLiteral: () => number; +declare var _BinaryenSizeofAllocateAndWriteResult: () => number; + +function swapOut(writer: Writer): Writer { + const saved = out; + out = writer; + return saved; +} + +function swapErr(writer) { + const saved = err; + err = writer; + return saved; +} + +Module['utils'] = { + "out": out, + "err": err, + "swapOut": swapOut, + "swapErr": swapErr, + "_BinaryenSizeofLiteral": _BinaryenSizeofLiteral, + "_BinaryenSizeofAllocateAndWriteResult": _BinaryenSizeofAllocateAndWriteResult +}; \ No newline at end of file diff --git a/src/ts/binaryen_raw_TARGET.js b/src/ts/binaryen_raw_TARGET.js new file mode 100644 index 00000000000..1697e0e1b47 --- /dev/null +++ b/src/ts/binaryen_raw_TARGET.js @@ -0,0 +1,5 @@ +/* this file is not part of the build. Its purpose only to enable local compilation of the binaryen.ts file. +This is done by running: tsc --target ES2020 --module ES2022 --declaration --declarationMap binaryen.ts +Compilation of a target creates the real binary_raw.js file in the build dir */ +var Binaryen_raw = {}; +export default Binaryen_raw; \ No newline at end of file