From e76aa6e88ea9bccc15b3946a922767c9bec9bad7 Mon Sep 17 00:00:00 2001 From: Eric Vergnaud Date: Thu, 7 Dec 2023 10:21:38 +0100 Subject: [PATCH 01/38] progress --- .gitignore | 2 + src/ts/BREAKING_CHANGES.md | 3 + src/ts/binaryen.ts | 798 +++++++++++++++++++++++++++++++++++++ 3 files changed, 803 insertions(+) create mode 100644 src/ts/BREAKING_CHANGES.md create mode 100644 src/ts/binaryen.ts diff --git a/.gitignore b/.gitignore index 45a0fcad856..e289b51550d 100644 --- a/.gitignore +++ b/.gitignore @@ -50,3 +50,5 @@ test/lit/lit.site.cfg.py # files related to clangd cache .cache/* +src/ts/binaryen.d.ts +src/ts/binaryen.js diff --git a/src/ts/BREAKING_CHANGES.md b/src/ts/BREAKING_CHANGES.md new file mode 100644 index 00000000000..6ceb7387ac5 --- /dev/null +++ b/src/ts/BREAKING_CHANGES.md @@ -0,0 +1,3 @@ +dropped ExpressionIds +changed i32.reinterpret to i32.reinterpret.f32 +changed i64.reinterpret to i64.reinterpret.f64 diff --git a/src/ts/binaryen.ts b/src/ts/binaryen.ts new file mode 100644 index 00000000000..79348769a73 --- /dev/null +++ b/src/ts/binaryen.ts @@ -0,0 +1,798 @@ +// export friendly API methods + +module binaryen { + + declare var HEAP32: Int32Array; + declare var HEAPU32: Uint32Array; + declare var stackSave: () => number; + declare var stackAlloc: (size: number) => number; + declare var stackRestore: (ref: number) => void; + declare var allocateUTF8OnStack: (s: string) => number; + declare var _BinaryenSizeofLiteral: () => number; + const sizeOfLiteral = _BinaryenSizeofLiteral(); + // avoid name clash with binaryen class Module + const JSModule = self["Module"] as {}; + + function preserveStack(func: () => R): R { + try { + var stack = stackSave(); + return func(); + } finally { + stackRestore(stack); + } + } + + function strToStack(str) { + return str ? allocateUTF8OnStack(str) : 0; + } + + function i32sToStack(i32s: number[]): number { + 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; + } + */ + + 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 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 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 enum ExternalKinds { + Function = JSModule['_BinaryenExternalFunction'](), + Table = JSModule['_BinaryenExternalTable'](), + Memory = JSModule['_BinaryenExternalMemory'](), + Global = JSModule['_BinaryenExternalGlobal'](), + Tag = JSModule['_BinaryenExternalTag']() + } + + export enum Features { + 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 class Module { + + readonly ptr: number; + + constructor() { + this.ptr = JSModule['_BinaryenModuleCreate'](); + } + 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 : binaryen.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) + ); + } + get local () { + return { + get: (index: number, type: Type) => JSModule['_BinaryenLocalGet'](this.ptr, index, type) as ExpressionRef, + set: (index: number, value: ExpressionRef) => JSModule['_BinaryenLocalSet'](this.ptr, index, value) as ExpressionRef, + tee: (index: number, value: ExpressionRef, type: Type) => { + if (typeof type === 'undefined') { + throw new Error("local.tee's type should be defined"); + } + return JSModule['_BinaryenLocalTee'](this.ptr, index, value, type) as ExpressionRef; + } + }; + } + get global () { + return { + get: (name: string, type: Type) => JSModule['_BinaryenLocalGet'](this.ptr, strToStack(name), type) as ExpressionRef, + set: (name: string, value: ExpressionRef) => JSModule['_BinaryenGlobalSet'](this.ptr, strToStack(name), value) as ExpressionRef + }; + } + get table () { + return { + get: (name: string, index: ExpressionRef, type: Type) => JSModule['_BinaryenTableGet'](this.ptr, strToStack(name), index, type) as ExpressionRef, + set: (name: string, index: ExpressionRef, value: ExpressionRef) => JSModule['_BinaryenTableSet'](this.ptr, strToStack(name), index, value) as ExpressionRef, + size: (name: string) => JSModule['_BinaryenTableSize'](this.ptr, strToStack(name)) as ExpressionRef, + grow: (name: string, value: ExpressionRef, delta: ExpressionRef) => JSModule['_BinaryenTableGrow'](this.ptr, strToStack(name), value, delta) as ExpressionRef + }; + /* 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 memory () { + return { + size: (name?: string, memory64?: boolean) => JSModule['_BinaryenMemorySize'](this.ptr, strToStack(name), memory64) as ExpressionRef, + grow: (value: ExpressionRef, name?: string, memory64?: boolean) => JSModule['_BinaryenMemoryGrow'](this.ptr, value, strToStack(name), memory64) as ExpressionRef, + init: (segment: number, dest: ExpressionRef, offset: ExpressionRef, size: ExpressionRef, name?: string) => + preserveStack(() => JSModule['_BinaryenMemoryInit'](this.ptr, strToStack(segment), dest, offset, size, strToStack(name))) as ExpressionRef, + copy: (dest: ExpressionRef, source: ExpressionRef, size: ExpressionRef, destName?: string, sourceName?: string) => + JSModule['_BinaryenMemoryCopy'](this.ptr, dest, source, size, strToStack(destName), strToStack(sourceName)) as ExpressionRef, + fill: (dest: ExpressionRef, value: ExpressionRef, size: ExpressionRef, name?: string) => + JSModule['_BinaryenMemoryFill'](this.ptr, dest, value, size, strToStack(name)) as ExpressionRef, + atomic: { + notify: (ptr: ExpressionRef, notifyCount: ExpressionRef, name?: string) => + JSModule['_BinaryenAtomicNotify'](this.ptr, ptr, notifyCount, strToStack(name)) as ExpressionRef, + wait32: (ptr: ExpressionRef, expected: ExpressionRef, timeout: ExpressionRef, name?: string) => + JSModule['_BinaryenAtomicWait'](this.ptr, ptr, expected, timeout, Module['i32'], strToStack(name)) as ExpressionRef, + wait64: (ptr: ExpressionRef, expected: ExpressionRef, timeout: ExpressionRef, name?: string) => + JSModule['_BinaryenAtomicWait'](this.ptr, ptr, expected, timeout, Module['i64'], strToStack(name)) as ExpressionRef + } + }; + } + get data () { + return { + drop: (segment: number) => preserveStack(() => JSModule['_BinaryenDataDrop'](this.ptr, strToStack(segment))) as ExpressionRef + }; + }; + get i32 () { + 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)) as ExpressionRef;; + 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)) as ExpressionRef;; + const unary = (op: Operations, value: ExpressionRef) => + JSModule['_BinaryenUnary'](this.ptr, op, value) as ExpressionRef; + return { + load: (offset: number, align: number, ptr: ExpressionRef, name?: string) => load(4, true, offset, align, ptr, name) as ExpressionRef, + load8_s: (offset: number, align: number, ptr: ExpressionRef, name?: string) => load(1, true, offset, align, ptr, name) as ExpressionRef, + load8_u: (offset: number, align: number, ptr: ExpressionRef, name?: string) => load(1, false, offset, align, ptr, name) as ExpressionRef, + load16_s: (offset: number, align: number, ptr: ExpressionRef, name?: string) => load(2, true, offset, align, ptr, name) as ExpressionRef, + load16_u: (offset: number, align: number, ptr: ExpressionRef, name?: string) => load(2, false, offset, align, ptr, name) as ExpressionRef, + store: (offset: number, align: number, ptr: ExpressionRef, value: ExpressionRef, name?: string) => store(4, offset, align, ptr, value, name) as ExpressionRef, + store8: (offset: number, align: number, ptr: ExpressionRef, value: ExpressionRef, name?: string) => store(1, offset, align, ptr, value, name) as ExpressionRef, + store16: (offset: number, align: number, ptr: ExpressionRef, value: ExpressionRef, name?: string) => store(2, offset, align, ptr, value, name) as ExpressionRef, + const: (value: number) => preserveStack(() => { + const tempLiteral = stackAlloc(sizeOfLiteral); + JSModule['_BinaryenLiteralInt32'](tempLiteral, value); + return JSModule['_BinaryenConst'](this.ptr, tempLiteral); + }), + clz: (value: ExpressionRef) => unary(Operations.ClzInt32, value), + ctz: (value: ExpressionRef) => unary(Operations.CtzInt32, value), + popcnt: (value: ExpressionRef) => unary(Operations.PopcntInt32, value), + eqz: (value: ExpressionRef) => unary(Operations.EqZInt32, value), + trunc_s: { + f32: (value: ExpressionRef) => unary(Operations.TruncSFloat32ToInt32, value), + f64: (value: ExpressionRef) => unary(Operations.TruncSFloat64ToInt32, value) + }, + trunc_u: { + f32: (value: ExpressionRef) => unary(Operations.TruncUFloat32ToInt32, value), + f64: (value: ExpressionRef) => unary(Operations.TruncUFloat64ToInt32, value) + }, + trunc_s_sat: { + f32: (value: ExpressionRef) => unary(Operations.TruncSatSFloat32ToInt32, value), + f64: (value: ExpressionRef) => unary(Operations.TruncSatSFloat64ToInt32, value) + }, + trunc_u_sat: { + f32: (value: ExpressionRef) => unary(Operations.TruncSatUFloat32ToInt32, value), + f64: (value: ExpressionRef) => unary(Operations.TruncSatUFloat64ToInt32, value) + }/* + reinterpret(value: ExpressionRef): ExpressionRef; + extend8_s(value: ExpressionRef): ExpressionRef; + extend16_s(value: ExpressionRef): ExpressionRef; + wrap(value: ExpressionRef): ExpressionRef; + add(left: ExpressionRef, right: ExpressionRef): ExpressionRef; + sub(left: ExpressionRef, right: ExpressionRef): ExpressionRef; + mul(left: ExpressionRef, right: ExpressionRef): ExpressionRef; + div_s(left: ExpressionRef, right: ExpressionRef): ExpressionRef; + div_u(left: ExpressionRef, right: ExpressionRef): ExpressionRef; + rem_s(left: ExpressionRef, right: ExpressionRef): ExpressionRef; + rem_u(left: ExpressionRef, right: ExpressionRef): ExpressionRef; + and(left: ExpressionRef, right: ExpressionRef): ExpressionRef; + or(left: ExpressionRef, right: ExpressionRef): ExpressionRef; + xor(left: ExpressionRef, right: ExpressionRef): ExpressionRef; + shl(left: ExpressionRef, right: ExpressionRef): ExpressionRef; + shr_u(left: ExpressionRef, right: ExpressionRef): ExpressionRef; + shr_s(left: ExpressionRef, right: ExpressionRef): ExpressionRef; + rotl(left: ExpressionRef, right: ExpressionRef): ExpressionRef; + rotr(left: ExpressionRef, right: ExpressionRef): ExpressionRef; + eq(left: ExpressionRef, right: ExpressionRef): ExpressionRef; + ne(left: ExpressionRef, right: ExpressionRef): ExpressionRef; + lt_s(left: ExpressionRef, right: ExpressionRef): ExpressionRef; + lt_u(left: ExpressionRef, right: ExpressionRef): ExpressionRef; + le_s(left: ExpressionRef, right: ExpressionRef): ExpressionRef; + le_u(left: ExpressionRef, right: ExpressionRef): ExpressionRef; + gt_s(left: ExpressionRef, right: ExpressionRef): ExpressionRef; + gt_u(left: ExpressionRef, right: ExpressionRef): ExpressionRef; + ge_s(left: ExpressionRef, right: ExpressionRef): ExpressionRef; + ge_u(left: ExpressionRef, right: ExpressionRef): ExpressionRef; + atomic: { + load(offset: number, ptr: ExpressionRef, name?: string): ExpressionRef; + load8_u(offset: number, ptr: ExpressionRef, name?: string): ExpressionRef; + load16_u(offset: number, ptr: ExpressionRef, name?: string): ExpressionRef; + store(offset: number, ptr: ExpressionRef, value: ExpressionRef, name?: string): ExpressionRef; + store8(offset: number, ptr: ExpressionRef, value: ExpressionRef, name?: string): ExpressionRef; + store16(offset: number, ptr: ExpressionRef, value: ExpressionRef, name?: string): ExpressionRef; + rmw: { + add(offset: number, ptr: ExpressionRef, value: ExpressionRef, name?: string): ExpressionRef; + sub(offset: number, ptr: ExpressionRef, value: ExpressionRef, name?: string): ExpressionRef; + and(offset: number, ptr: ExpressionRef, value: ExpressionRef, name?: string): ExpressionRef; + or(offset: number, ptr: ExpressionRef, value: ExpressionRef, name?: string): ExpressionRef; + xor(offset: number, ptr: ExpressionRef, value: ExpressionRef, name?: string): ExpressionRef; + xchg(offset: number, ptr: ExpressionRef, value: ExpressionRef, name?: string): ExpressionRef; + cmpxchg(offset: number, ptr: ExpressionRef, expected: ExpressionRef, replacement: ExpressionRef, name?: string): ExpressionRef; + }, + rmw8_u: { + add(offset: number, ptr: ExpressionRef, value: ExpressionRef, name?: string): ExpressionRef; + sub(offset: number, ptr: ExpressionRef, value: ExpressionRef, name?: string): ExpressionRef; + and(offset: number, ptr: ExpressionRef, value: ExpressionRef, name?: string): ExpressionRef; + or(offset: number, ptr: ExpressionRef, value: ExpressionRef, name?: string): ExpressionRef; + xor(offset: number, ptr: ExpressionRef, value: ExpressionRef, name?: string): ExpressionRef; + xchg(offset: number, ptr: ExpressionRef, value: ExpressionRef, name?: string): ExpressionRef; + cmpxchg(offset: number, ptr: ExpressionRef, expected: ExpressionRef, replacement: ExpressionRef, name?: string): ExpressionRef; + }, + rmw16_u: { + add(offset: number, ptr: ExpressionRef, value: ExpressionRef, name?: string): ExpressionRef; + sub(offset: number, ptr: ExpressionRef, value: ExpressionRef, name?: string): ExpressionRef; + and(offset: number, ptr: ExpressionRef, value: ExpressionRef, name?: string): ExpressionRef; + or(offset: number, ptr: ExpressionRef, value: ExpressionRef, name?: string): ExpressionRef; + xor(offset: number, ptr: ExpressionRef, value: ExpressionRef, name?: string): ExpressionRef; + xchg(offset: number, ptr: ExpressionRef, value: ExpressionRef, name?: string): ExpressionRef; + cmpxchg(offset: number, ptr: ExpressionRef, expected: ExpressionRef, replacement: ExpressionRef, name?: string): ExpressionRef; + }, + }, + pop(): ExpressionRef; */ + } + }; + } +} + + From 16cae25966afc56c4a4a440f50034879099e785e Mon Sep 17 00:00:00 2001 From: Eric Vergnaud Date: Thu, 7 Dec 2023 16:59:30 +0100 Subject: [PATCH 02/38] has complete i32, i64, f32 and f64 --- src/ts/binaryen.ts | 433 ++++++++++++++++++++++++++++++++++++++------- 1 file changed, 366 insertions(+), 67 deletions(-) diff --git a/src/ts/binaryen.ts b/src/ts/binaryen.ts index 79348769a73..fc1b3c77369 100644 --- a/src/ts/binaryen.ts +++ b/src/ts/binaryen.ts @@ -685,12 +685,20 @@ module binaryen { }; }; get i32 () { - 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)) as ExpressionRef;; - 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)) as ExpressionRef;; const unary = (op: Operations, value: ExpressionRef) => JSModule['_BinaryenUnary'](this.ptr, op, value) as ExpressionRef; + const binary = (op: Operations, left: ExpressionRef, right: ExpressionRef) => + JSModule['_BinaryenBinary'](this.ptr, op, left, right) as ExpressionRef; + 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)) as ExpressionRef; + 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)) as ExpressionRef; + const atomic_load = (size: number, offset: number, ptr: ExpressionRef, name: string) => + JSModule['_BinaryenAtomicLoad'](this.ptr, size, offset, i32, ptr, strToStack(name)) as ExpressionRef; + const atomic_store = (size: number, offset: number, ptr: ExpressionRef, value: ExpressionRef, name: string) => + JSModule['_BinaryenAtomicStore'](this.ptr, size, offset, ptr, value, i32, strToStack(name)) as ExpressionRef; + 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)) as ExpressionRef; return { load: (offset: number, align: number, ptr: ExpressionRef, name?: string) => load(4, true, offset, align, ptr, name) as ExpressionRef, load8_s: (offset: number, align: number, ptr: ExpressionRef, name?: string) => load(1, true, offset, align, ptr, name) as ExpressionRef, @@ -724,74 +732,365 @@ module binaryen { trunc_u_sat: { f32: (value: ExpressionRef) => unary(Operations.TruncSatUFloat32ToInt32, value), f64: (value: ExpressionRef) => unary(Operations.TruncSatUFloat64ToInt32, value) - }/* - reinterpret(value: ExpressionRef): ExpressionRef; - extend8_s(value: ExpressionRef): ExpressionRef; - extend16_s(value: ExpressionRef): ExpressionRef; - wrap(value: ExpressionRef): ExpressionRef; - add(left: ExpressionRef, right: ExpressionRef): ExpressionRef; - sub(left: ExpressionRef, right: ExpressionRef): ExpressionRef; - mul(left: ExpressionRef, right: ExpressionRef): ExpressionRef; - div_s(left: ExpressionRef, right: ExpressionRef): ExpressionRef; - div_u(left: ExpressionRef, right: ExpressionRef): ExpressionRef; - rem_s(left: ExpressionRef, right: ExpressionRef): ExpressionRef; - rem_u(left: ExpressionRef, right: ExpressionRef): ExpressionRef; - and(left: ExpressionRef, right: ExpressionRef): ExpressionRef; - or(left: ExpressionRef, right: ExpressionRef): ExpressionRef; - xor(left: ExpressionRef, right: ExpressionRef): ExpressionRef; - shl(left: ExpressionRef, right: ExpressionRef): ExpressionRef; - shr_u(left: ExpressionRef, right: ExpressionRef): ExpressionRef; - shr_s(left: ExpressionRef, right: ExpressionRef): ExpressionRef; - rotl(left: ExpressionRef, right: ExpressionRef): ExpressionRef; - rotr(left: ExpressionRef, right: ExpressionRef): ExpressionRef; - eq(left: ExpressionRef, right: ExpressionRef): ExpressionRef; - ne(left: ExpressionRef, right: ExpressionRef): ExpressionRef; - lt_s(left: ExpressionRef, right: ExpressionRef): ExpressionRef; - lt_u(left: ExpressionRef, right: ExpressionRef): ExpressionRef; - le_s(left: ExpressionRef, right: ExpressionRef): ExpressionRef; - le_u(left: ExpressionRef, right: ExpressionRef): ExpressionRef; - gt_s(left: ExpressionRef, right: ExpressionRef): ExpressionRef; - gt_u(left: ExpressionRef, right: ExpressionRef): ExpressionRef; - ge_s(left: ExpressionRef, right: ExpressionRef): ExpressionRef; - ge_u(left: ExpressionRef, right: ExpressionRef): ExpressionRef; + }, + reinterpret_f32: (value: ExpressionRef) => unary(Operations.ReinterpretFloat32, value), + extend8_s: (value: ExpressionRef) => unary(Operations.ExtendS8Int32, value), + extend16_s: (value: ExpressionRef) => unary(Operations.ExtendS16Int32, value), + wrap_int64: (value: ExpressionRef) => unary(Operations.WrapInt64, value), + add: (left: ExpressionRef, right: ExpressionRef) => binary(Operations.AddInt32, left, right), + sub: (left: ExpressionRef, right: ExpressionRef) => binary(Operations.SubInt32, left, right), + mul: (left: ExpressionRef, right: ExpressionRef) => binary(Operations.MulInt32, left, right), + div_s: (left: ExpressionRef, right: ExpressionRef) => binary(Operations.DivSInt32, left, right), + div_u: (left: ExpressionRef, right: ExpressionRef) => binary(Operations.DivUInt32, left, right), + rem_s: (left: ExpressionRef, right: ExpressionRef) => binary(Operations.RemSInt32, left, right), + rem_u: (left: ExpressionRef, right: ExpressionRef) => binary(Operations.RemUInt32, left, right), + and: (left: ExpressionRef, right: ExpressionRef) => binary(Operations.AndInt32, left, right), + or: (left: ExpressionRef, right: ExpressionRef) => binary(Operations.OrInt32, left, right), + xor: (left: ExpressionRef, right: ExpressionRef) => binary(Operations.XorInt32, left, right), + shl: (left: ExpressionRef, right: ExpressionRef) => binary(Operations.ShlInt32, left, right), + shr_u: (left: ExpressionRef, right: ExpressionRef) => binary(Operations.ShrUInt32, left, right), + shr_s: (left: ExpressionRef, right: ExpressionRef) => binary(Operations.ShrSInt32, left, right), + rotl: (left: ExpressionRef, right: ExpressionRef) => binary(Operations.RotLInt32, left, right), + rotr: (left: ExpressionRef, right: ExpressionRef) => binary(Operations.RotRInt32, left, right), + eq: (left: ExpressionRef, right: ExpressionRef) => binary(Operations.EqInt32, left, right), + ne: (left: ExpressionRef, right: ExpressionRef) => binary(Operations.NeInt32, left, right), + lt_s: (left: ExpressionRef, right: ExpressionRef) => binary(Operations.LtSInt32, left, right), + lt_u: (left: ExpressionRef, right: ExpressionRef) => binary(Operations.LtUInt32, left, right), + le_s: (left: ExpressionRef, right: ExpressionRef) => binary(Operations.LeSInt32, left, right), + le_u: (left: ExpressionRef, right: ExpressionRef) => binary(Operations.LeUInt32, left, right), + gt_s: (left: ExpressionRef, right: ExpressionRef) => binary(Operations.GtSInt32, left, right), + gt_u: (left: ExpressionRef, right: ExpressionRef) => binary(Operations.GtUInt32, left, right), + ge_s: (left: ExpressionRef, right: ExpressionRef) => binary(Operations.GeSInt32, left, right), + ge_u: (left: ExpressionRef, right: ExpressionRef) => binary(Operations.GeUInt32, left, right), + pop: () => JSModule['_BinaryenPop'](this.ptr, i32) as ExpressionRef, atomic: { - load(offset: number, ptr: ExpressionRef, name?: string): ExpressionRef; - load8_u(offset: number, ptr: ExpressionRef, name?: string): ExpressionRef; - load16_u(offset: number, ptr: ExpressionRef, name?: string): ExpressionRef; - store(offset: number, ptr: ExpressionRef, value: ExpressionRef, name?: string): ExpressionRef; - store8(offset: number, ptr: ExpressionRef, value: ExpressionRef, name?: string): ExpressionRef; - store16(offset: number, ptr: ExpressionRef, value: ExpressionRef, name?: string): ExpressionRef; - rmw: { - add(offset: number, ptr: ExpressionRef, value: ExpressionRef, name?: string): ExpressionRef; - sub(offset: number, ptr: ExpressionRef, value: ExpressionRef, name?: string): ExpressionRef; - and(offset: number, ptr: ExpressionRef, value: ExpressionRef, name?: string): ExpressionRef; - or(offset: number, ptr: ExpressionRef, value: ExpressionRef, name?: string): ExpressionRef; - xor(offset: number, ptr: ExpressionRef, value: ExpressionRef, name?: string): ExpressionRef; - xchg(offset: number, ptr: ExpressionRef, value: ExpressionRef, name?: string): ExpressionRef; - cmpxchg(offset: number, ptr: ExpressionRef, expected: ExpressionRef, replacement: ExpressionRef, name?: string): ExpressionRef; + load: (offset: number, ptr: ExpressionRef, name?: string) => atomic_load(4, offset, ptr, name), + load8_u: (offset: number, ptr: ExpressionRef, name?: string) => atomic_load(1, offset, ptr, name), + load16_u: (offset: number, ptr: ExpressionRef, name?: string) => atomic_load(2, offset, ptr, name), + store: (offset: number, ptr: ExpressionRef, value: ExpressionRef, name?: string) => atomic_store(4, offset, ptr, value, name), + store8: (offset: number, ptr: ExpressionRef, value: ExpressionRef, name?: string) => atomic_store(1, offset, ptr, value, name), + store16: (offset: number, ptr: ExpressionRef, value: ExpressionRef, name?: string) => atomic_store(2, offset, ptr, value, name), + rmw: { + add: (offset: number, ptr: ExpressionRef, value: ExpressionRef, name?: string) => + atomic_rmw(Operations.AtomicRMWAdd, 4, offset, ptr, value, name), + sub: (offset: number, ptr: ExpressionRef, value: ExpressionRef, name?: string) => + atomic_rmw(Operations.AtomicRMWSub, 4, offset, ptr, value, name), + and: (offset: number, ptr: ExpressionRef, value: ExpressionRef, name?: string) => + atomic_rmw(Operations.AtomicRMWAnd, 4, offset, ptr, value, name), + or: (offset: number, ptr: ExpressionRef, value: ExpressionRef, name?: string) => + atomic_rmw(Operations.AtomicRMWOr, 4, offset, ptr, value, name), + xor: (offset: number, ptr: ExpressionRef, value: ExpressionRef, name?: string) => + atomic_rmw(Operations.AtomicRMWXor, 4, offset, ptr, value, name), + xchg: (offset: number, ptr: ExpressionRef, value: ExpressionRef, name?: string) => + atomic_rmw(Operations.AtomicRMWXchg, 4, offset, ptr, value, name), + cmpxchg: (offset: number, ptr: ExpressionRef, expected: ExpressionRef, replacement: ExpressionRef, name?: string) => + JSModule['_BinaryenAtomicCmpxchg'](this.ptr, 4, offset, ptr, expected, replacement, i32, strToStack(name)) as ExpressionRef + }, + rmw8_u: { + add: (offset: number, ptr: ExpressionRef, value: ExpressionRef, name?: string) => + atomic_rmw(Operations.AtomicRMWAdd, 1, offset, ptr, value, name), + sub: (offset: number, ptr: ExpressionRef, value: ExpressionRef, name?: string) => + atomic_rmw(Operations.AtomicRMWSub, 1, offset, ptr, value, name), + and: (offset: number, ptr: ExpressionRef, value: ExpressionRef, name?: string) => + atomic_rmw(Operations.AtomicRMWAnd, 1, offset, ptr, value, name), + or: (offset: number, ptr: ExpressionRef, value: ExpressionRef, name?: string) => + atomic_rmw(Operations.AtomicRMWOr, 1, offset, ptr, value, name), + xor: (offset: number, ptr: ExpressionRef, value: ExpressionRef, name?: string) => + atomic_rmw(Operations.AtomicRMWXor, 1, offset, ptr, value, name), + xchg: (offset: number, ptr: ExpressionRef, value: ExpressionRef, name?: string) => + atomic_rmw(Operations.AtomicRMWXchg, 1, offset, ptr, value, name), + cmpxchg: (offset: number, ptr: ExpressionRef, expected: ExpressionRef, replacement: ExpressionRef, name?: string) => + JSModule['_BinaryenAtomicCmpxchg'](this.ptr, 1, offset, ptr, expected, replacement, i32, strToStack(name)) as ExpressionRef + }, + rmw16_u: { + add: (offset: number, ptr: ExpressionRef, value: ExpressionRef, name?: string) => + atomic_rmw(Operations.AtomicRMWAdd, 2, offset, ptr, value, name), + sub: (offset: number, ptr: ExpressionRef, value: ExpressionRef, name?: string) => + atomic_rmw(Operations.AtomicRMWSub, 2, offset, ptr, value, name), + and: (offset: number, ptr: ExpressionRef, value: ExpressionRef, name?: string) => + atomic_rmw(Operations.AtomicRMWAnd, 2, offset, ptr, value, name), + or: (offset: number, ptr: ExpressionRef, value: ExpressionRef, name?: string) => + atomic_rmw(Operations.AtomicRMWOr, 2, offset, ptr, value, name), + xor: (offset: number, ptr: ExpressionRef, value: ExpressionRef, name?: string) => + atomic_rmw(Operations.AtomicRMWXor, 2, offset, ptr, value, name), + xchg: (offset: number, ptr: ExpressionRef, value: ExpressionRef, name?: string) => + atomic_rmw(Operations.AtomicRMWXchg, 2, offset, ptr, value, name), + cmpxchg: (offset: number, ptr: ExpressionRef, expected: ExpressionRef, replacement: ExpressionRef, name?: string) => + JSModule['_BinaryenAtomicCmpxchg'](this.ptr, 2, offset, ptr, expected, replacement, i32, strToStack(name)) as ExpressionRef + } + } + }; + } + get i64 () { + const unary = (op: Operations, value: ExpressionRef) => + JSModule['_BinaryenUnary'](this.ptr, op, value) as ExpressionRef; + const binary = (op: Operations, left: ExpressionRef, right: ExpressionRef) => + JSModule['_BinaryenBinary'](this.ptr, op, left, right) as ExpressionRef; + const load = (size: number, signed: boolean, offset: number, align: number, ptr: ExpressionRef, name: string) => + JSModule['_BinaryenLoad'](this.ptr, size, signed, offset, align, i64, ptr, strToStack(name)) as ExpressionRef; + 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)) as ExpressionRef; + const atomic_load = (size: number, offset: number, ptr: ExpressionRef, name: string) => + JSModule['_BinaryenAtomicLoad'](this.ptr, size, offset, i64, ptr, strToStack(name)) as ExpressionRef; + const atomic_store = (size: number, offset: number, ptr: ExpressionRef, value: ExpressionRef, name: string) => + JSModule['_BinaryenAtomicStore'](this.ptr, size, offset, ptr, value, i64, strToStack(name)) as ExpressionRef; + 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)) as ExpressionRef; + return { + load: (offset: number, align: number, ptr: ExpressionRef, name?: string) => load(8, true, offset, align, ptr, name) as ExpressionRef, + load8_s: (offset: number, align: number, ptr: ExpressionRef, name?: string) => load(1, true, offset, align, ptr, name) as ExpressionRef, + load8_u: (offset: number, align: number, ptr: ExpressionRef, name?: string) => load(1, false, offset, align, ptr, name) as ExpressionRef, + load16_s: (offset: number, align: number, ptr: ExpressionRef, name?: string) => load(2, true, offset, align, ptr, name) as ExpressionRef, + load16_u: (offset: number, align: number, ptr: ExpressionRef, name?: string) => load(2, false, offset, align, ptr, name) as ExpressionRef, + load32_s: (offset: number, align: number, ptr: ExpressionRef, name?: string) => load(4, true, offset, align, ptr, name) as ExpressionRef, + load32_u: (offset: number, align: number, ptr: ExpressionRef, name?: string) => load(4, false, offset, align, ptr, name) as ExpressionRef, + store: (offset: number, align: number, ptr: ExpressionRef, value: ExpressionRef, name?: string) => store(4, offset, align, ptr, value, name) as ExpressionRef, + store8: (offset: number, align: number, ptr: ExpressionRef, value: ExpressionRef, name?: string) => store(1, offset, align, ptr, value, name) as ExpressionRef, + store16: (offset: number, align: number, ptr: ExpressionRef, value: ExpressionRef, name?: string) => store(2, offset, align, ptr, value, name) as ExpressionRef, + store32: (offset: number, align: number, ptr: ExpressionRef, value: ExpressionRef, name?: string) => store(4, offset, align, ptr, value, name) as ExpressionRef, + const: (low: number, high: number) => preserveStack(() => { + const tempLiteral = stackAlloc(sizeOfLiteral); + JSModule['_BinaryenLiteralInt64'](tempLiteral, low, high); + return JSModule['_BinaryenConst'](this.ptr, tempLiteral); + }), + clz: (value: ExpressionRef) => unary(Operations.ClzInt64, value), + ctz: (value: ExpressionRef) => unary(Operations.CtzInt64, value), + popcnt: (value: ExpressionRef) => unary(Operations.PopcntInt64, value), + eqz: (value: ExpressionRef) => unary(Operations.EqZInt64, value), + trunc_s: { + f32: (value: ExpressionRef) => unary(Operations.TruncSFloat32ToInt64, value), + f64: (value: ExpressionRef) => unary(Operations.TruncSFloat64ToInt64, value) }, - rmw8_u: { - add(offset: number, ptr: ExpressionRef, value: ExpressionRef, name?: string): ExpressionRef; - sub(offset: number, ptr: ExpressionRef, value: ExpressionRef, name?: string): ExpressionRef; - and(offset: number, ptr: ExpressionRef, value: ExpressionRef, name?: string): ExpressionRef; - or(offset: number, ptr: ExpressionRef, value: ExpressionRef, name?: string): ExpressionRef; - xor(offset: number, ptr: ExpressionRef, value: ExpressionRef, name?: string): ExpressionRef; - xchg(offset: number, ptr: ExpressionRef, value: ExpressionRef, name?: string): ExpressionRef; - cmpxchg(offset: number, ptr: ExpressionRef, expected: ExpressionRef, replacement: ExpressionRef, name?: string): ExpressionRef; + trunc_u: { + f32: (value: ExpressionRef) => unary(Operations.TruncUFloat32ToInt64, value), + f64: (value: ExpressionRef) => unary(Operations.TruncUFloat64ToInt64, value) }, - rmw16_u: { - add(offset: number, ptr: ExpressionRef, value: ExpressionRef, name?: string): ExpressionRef; - sub(offset: number, ptr: ExpressionRef, value: ExpressionRef, name?: string): ExpressionRef; - and(offset: number, ptr: ExpressionRef, value: ExpressionRef, name?: string): ExpressionRef; - or(offset: number, ptr: ExpressionRef, value: ExpressionRef, name?: string): ExpressionRef; - xor(offset: number, ptr: ExpressionRef, value: ExpressionRef, name?: string): ExpressionRef; - xchg(offset: number, ptr: ExpressionRef, value: ExpressionRef, name?: string): ExpressionRef; - cmpxchg(offset: number, ptr: ExpressionRef, expected: ExpressionRef, replacement: ExpressionRef, name?: string): ExpressionRef; + trunc_s_sat: { + f32: (value: ExpressionRef) => unary(Operations.TruncSatSFloat32ToInt64, value), + f64: (value: ExpressionRef) => unary(Operations.TruncSatSFloat64ToInt64, value) }, + trunc_u_sat: { + f32: (value: ExpressionRef) => unary(Operations.TruncSatUFloat32ToInt64, value), + f64: (value: ExpressionRef) => unary(Operations.TruncSatUFloat64ToInt64, value) }, - pop(): ExpressionRef; */ - } - }; + reinterpret_f64: (value: ExpressionRef) => unary(Operations.ReinterpretFloat64, value), + extend8_s: (value: ExpressionRef) => unary(Operations.ExtendS8Int64, value), + extend16_s: (value: ExpressionRef) => unary(Operations.ExtendS16Int64, value), + extend32_s: (value: ExpressionRef) => unary(Operations.ExtendS32Int64, value), + extend_s: (value: ExpressionRef) => unary(Operations.ExtendSInt32, value), + extend_u: (value: ExpressionRef) => unary(Operations.ExtendUInt32, value), + add: (left: ExpressionRef, right: ExpressionRef) => binary(Operations.AddInt64, left, right), + sub: (left: ExpressionRef, right: ExpressionRef) => binary(Operations.SubInt64, left, right), + mul: (left: ExpressionRef, right: ExpressionRef) => binary(Operations.MulInt32, left, right), + div_s: (left: ExpressionRef, right: ExpressionRef) => binary(Operations.DivSInt64, left, right), + div_u: (left: ExpressionRef, right: ExpressionRef) => binary(Operations.DivUInt64, left, right), + rem_s: (left: ExpressionRef, right: ExpressionRef) => binary(Operations.RemSInt64, left, right), + rem_u: (left: ExpressionRef, right: ExpressionRef) => binary(Operations.RemUInt64, left, right), + and: (left: ExpressionRef, right: ExpressionRef) => binary(Operations.AndInt64, left, right), + or: (left: ExpressionRef, right: ExpressionRef) => binary(Operations.OrInt64, left, right), + xor: (left: ExpressionRef, right: ExpressionRef) => binary(Operations.XorInt64, left, right), + shl: (left: ExpressionRef, right: ExpressionRef) => binary(Operations.ShlInt64, left, right), + shr_u: (left: ExpressionRef, right: ExpressionRef) => binary(Operations.ShrUInt64, left, right), + shr_s: (left: ExpressionRef, right: ExpressionRef) => binary(Operations.ShrSInt64, left, right), + rotl: (left: ExpressionRef, right: ExpressionRef) => binary(Operations.RotLInt64, left, right), + rotr: (left: ExpressionRef, right: ExpressionRef) => binary(Operations.RotRInt64, left, right), + eq: (left: ExpressionRef, right: ExpressionRef) => binary(Operations.EqInt64, left, right), + ne: (left: ExpressionRef, right: ExpressionRef) => binary(Operations.NeInt64, left, right), + lt_s: (left: ExpressionRef, right: ExpressionRef) => binary(Operations.LtSInt64, left, right), + lt_u: (left: ExpressionRef, right: ExpressionRef) => binary(Operations.LtUInt64, left, right), + le_s: (left: ExpressionRef, right: ExpressionRef) => binary(Operations.LeSInt64, left, right), + le_u: (left: ExpressionRef, right: ExpressionRef) => binary(Operations.LeUInt64, left, right), + gt_s: (left: ExpressionRef, right: ExpressionRef) => binary(Operations.GtSInt64, left, right), + gt_u: (left: ExpressionRef, right: ExpressionRef) => binary(Operations.GtUInt64, left, right), + ge_s: (left: ExpressionRef, right: ExpressionRef) => binary(Operations.GeSInt64, left, right), + ge_u: (left: ExpressionRef, right: ExpressionRef) => binary(Operations.GeUInt64, left, right), + pop: () => JSModule['_BinaryenPop'](this.ptr, i64) as ExpressionRef, + atomic: { + load: (offset: number, ptr: ExpressionRef, name?: string) => atomic_load(8, offset, ptr, name), + load8_u: (offset: number, ptr: ExpressionRef, name?: string) => atomic_load(1, offset, ptr, name), + load16_u: (offset: number, ptr: ExpressionRef, name?: string) => atomic_load(2, offset, ptr, name), + load32_u: (offset: number, ptr: ExpressionRef, name?: string) => atomic_load(4, offset, ptr, name), + store: (offset: number, ptr: ExpressionRef, value: ExpressionRef, name?: string) => atomic_store(4, offset, ptr, value, name), + store8: (offset: number, ptr: ExpressionRef, value: ExpressionRef, name?: string) => atomic_store(1, offset, ptr, value, name), + store16: (offset: number, ptr: ExpressionRef, value: ExpressionRef, name?: string) => atomic_store(2, offset, ptr, value, name), + store32: (offset: number, ptr: ExpressionRef, value: ExpressionRef, name?: string) => atomic_store(4, offset, ptr, value, name), + rmw: { + add: (offset: number, ptr: ExpressionRef, value: ExpressionRef, name?: string) => + atomic_rmw(Operations.AtomicRMWAdd, 8, offset, ptr, value, name), + sub: (offset: number, ptr: ExpressionRef, value: ExpressionRef, name?: string) => + atomic_rmw(Operations.AtomicRMWSub, 8, offset, ptr, value, name), + and: (offset: number, ptr: ExpressionRef, value: ExpressionRef, name?: string) => + atomic_rmw(Operations.AtomicRMWAnd, 8, offset, ptr, value, name), + or: (offset: number, ptr: ExpressionRef, value: ExpressionRef, name?: string) => + atomic_rmw(Operations.AtomicRMWOr, 8, offset, ptr, value, name), + xor: (offset: number, ptr: ExpressionRef, value: ExpressionRef, name?: string) => + atomic_rmw(Operations.AtomicRMWXor, 8, offset, ptr, value, name), + xchg: (offset: number, ptr: ExpressionRef, value: ExpressionRef, name?: string) => + atomic_rmw(Operations.AtomicRMWXchg, 8, offset, ptr, value, name), + cmpxchg: (offset: number, ptr: ExpressionRef, expected: ExpressionRef, replacement: ExpressionRef, name?: string) => + JSModule['_BinaryenAtomicCmpxchg'](this.ptr, 8, offset, ptr, expected, replacement, i64, strToStack(name)) as ExpressionRef + }, + rmw8_u: { + add: (offset: number, ptr: ExpressionRef, value: ExpressionRef, name?: string) => + atomic_rmw(Operations.AtomicRMWAdd, 1, offset, ptr, value, name), + sub: (offset: number, ptr: ExpressionRef, value: ExpressionRef, name?: string) => + atomic_rmw(Operations.AtomicRMWSub, 1, offset, ptr, value, name), + and: (offset: number, ptr: ExpressionRef, value: ExpressionRef, name?: string) => + atomic_rmw(Operations.AtomicRMWAnd, 1, offset, ptr, value, name), + or: (offset: number, ptr: ExpressionRef, value: ExpressionRef, name?: string) => + atomic_rmw(Operations.AtomicRMWOr, 1, offset, ptr, value, name), + xor: (offset: number, ptr: ExpressionRef, value: ExpressionRef, name?: string) => + atomic_rmw(Operations.AtomicRMWXor, 1, offset, ptr, value, name), + xchg: (offset: number, ptr: ExpressionRef, value: ExpressionRef, name?: string) => + atomic_rmw(Operations.AtomicRMWXchg, 1, offset, ptr, value, name), + cmpxchg: (offset: number, ptr: ExpressionRef, expected: ExpressionRef, replacement: ExpressionRef, name?: string) => + JSModule['_BinaryenAtomicCmpxchg'](this.ptr, 1, offset, ptr, expected, replacement, i64, strToStack(name)) as ExpressionRef + }, + rmw16_u: { + add: (offset: number, ptr: ExpressionRef, value: ExpressionRef, name?: string) => + atomic_rmw(Operations.AtomicRMWAdd, 2, offset, ptr, value, name), + sub: (offset: number, ptr: ExpressionRef, value: ExpressionRef, name?: string) => + atomic_rmw(Operations.AtomicRMWSub, 2, offset, ptr, value, name), + and: (offset: number, ptr: ExpressionRef, value: ExpressionRef, name?: string) => + atomic_rmw(Operations.AtomicRMWAnd, 2, offset, ptr, value, name), + or: (offset: number, ptr: ExpressionRef, value: ExpressionRef, name?: string) => + atomic_rmw(Operations.AtomicRMWOr, 2, offset, ptr, value, name), + xor: (offset: number, ptr: ExpressionRef, value: ExpressionRef, name?: string) => + atomic_rmw(Operations.AtomicRMWXor, 2, offset, ptr, value, name), + xchg: (offset: number, ptr: ExpressionRef, value: ExpressionRef, name?: string) => + atomic_rmw(Operations.AtomicRMWXchg, 2, offset, ptr, value, name), + cmpxchg: (offset: number, ptr: ExpressionRef, expected: ExpressionRef, replacement: ExpressionRef, name?: string) => + JSModule['_BinaryenAtomicCmpxchg'](this.ptr, 2, offset, ptr, expected, replacement, i32, strToStack(name)) as ExpressionRef + }, + rmw32_u: { + add: (offset: number, ptr: ExpressionRef, value: ExpressionRef, name?: string) => + atomic_rmw(Operations.AtomicRMWAdd, 4, offset, ptr, value, name), + sub: (offset: number, ptr: ExpressionRef, value: ExpressionRef, name?: string) => + atomic_rmw(Operations.AtomicRMWSub, 4, offset, ptr, value, name), + and: (offset: number, ptr: ExpressionRef, value: ExpressionRef, name?: string) => + atomic_rmw(Operations.AtomicRMWAnd, 4, offset, ptr, value, name), + or: (offset: number, ptr: ExpressionRef, value: ExpressionRef, name?: string) => + atomic_rmw(Operations.AtomicRMWOr, 4, offset, ptr, value, name), + xor: (offset: number, ptr: ExpressionRef, value: ExpressionRef, name?: string) => + atomic_rmw(Operations.AtomicRMWXor, 4, offset, ptr, value, name), + xchg: (offset: number, ptr: ExpressionRef, value: ExpressionRef, name?: string) => + atomic_rmw(Operations.AtomicRMWXchg, 4, offset, ptr, value, name), + cmpxchg: (offset: number, ptr: ExpressionRef, expected: ExpressionRef, replacement: ExpressionRef, name?: string) => + JSModule['_BinaryenAtomicCmpxchg'](this.ptr, 4, offset, ptr, expected, replacement, i32, strToStack(name)) as ExpressionRef + } + } + }; + } + get f32 () { + const unary = (op: Operations, value: ExpressionRef) => + JSModule['_BinaryenUnary'](this.ptr, op, value) as ExpressionRef; + const binary = (op: Operations, left: ExpressionRef, right: ExpressionRef) => + JSModule['_BinaryenBinary'](this.ptr, op, left, right) as ExpressionRef; + return { + load: (offset: number, align: number, ptr: ExpressionRef, name?: string) => + Module['_BinaryenLoad'](this.ptr, 4, true, offset, align, f32, ptr, strToStack(name)) as ExpressionRef, + store: (offset: number, align: number, ptr: ExpressionRef, value: ExpressionRef, name?: string) => + Module['_BinaryenStore'](this.ptr, 4, offset, align, ptr, value, f32, strToStack(name)) as ExpressionRef, + const: (value: number) => + preserveStack(() => { + const tempLiteral = stackAlloc(sizeOfLiteral); + Module['_BinaryenLiteralFloat32'](tempLiteral, value); + return Module['_BinaryenConst'](this.ptr, tempLiteral); + }) as ExpressionRef, + const_bits: (value: number) => + preserveStack(() => { + const tempLiteral = stackAlloc(sizeOfLiteral); + Module['_BinaryenLiteralFloat32Bits'](tempLiteral, value); + return Module['_BinaryenConst'](this.ptr, tempLiteral); + }) as ExpressionRef, + neg: (value: ExpressionRef) => unary(Operations.NegFloat32, value), + abs: (value: ExpressionRef) => unary(Operations.AbsFloat32, value), + ceil: (value: ExpressionRef) => unary(Operations.CeilFloat32, value), + floor: (value: ExpressionRef) => unary(Operations.FloorFloat32, value), + trunc: (value: ExpressionRef) => unary(Operations.TruncFloat32, value), + nearest: (value: ExpressionRef) => unary(Operations.NearestFloat32, value), + sqrt: (value: ExpressionRef) => unary(Operations.SqrtFloat32, value), + reinterpret_int32: (value: ExpressionRef) => unary(Operations.ReinterpretInt32, value), + convert_s: { + i32: (value: ExpressionRef) => unary(Operations.ConvertSInt32ToFloat32, value), + i64: (value: ExpressionRef) => unary(Operations.ConvertSInt64ToFloat32, value) + }, + convert_u: { + i32: (value: ExpressionRef) => unary(Operations.ConvertUInt32ToFloat32, value), + i64: (value: ExpressionRef) => unary(Operations.ConvertUInt64ToFloat32, value) + }, + demote_f64: (value: ExpressionRef)=> unary(Operations.DemoteFloat64, value), + add: (left: ExpressionRef, right: ExpressionRef) => binary(Operations.AddFloat32, left, right), + sub: (left: ExpressionRef, right: ExpressionRef) => binary(Operations.SubFloat32, left, right), + mul: (left: ExpressionRef, right: ExpressionRef) => binary(Operations.MulFloat32, left, right), + div: (left: ExpressionRef, right: ExpressionRef) => binary(Operations.DivFloat32, left, right), + copysign: (left: ExpressionRef, right: ExpressionRef) => binary(Operations.CopySignFloat32, left, right), + min: (left: ExpressionRef, right: ExpressionRef) => binary(Operations.MinFloat32, left, right), + max: (left: ExpressionRef, right: ExpressionRef) => binary(Operations.MaxFloat32, left, right), + eq: (left: ExpressionRef, right: ExpressionRef) => binary(Operations.EqFloat32, left, right), + ne: (left: ExpressionRef, right: ExpressionRef) => binary(Operations.NeFloat32, left, right), + lt: (left: ExpressionRef, right: ExpressionRef) => binary(Operations.LtFloat32, left, right), + le: (left: ExpressionRef, right: ExpressionRef) => binary(Operations.LeFloat32, left, right), + gt: (left: ExpressionRef, right: ExpressionRef) => binary(Operations.GtFloat32, left, right), + ge: (left: ExpressionRef, right: ExpressionRef) => binary(Operations.GeFloat32, left, right), + pop: () => JSModule['_BinaryenPop'](this.ptr, f32) as ExpressionRef + }; + } + get f64 () { + const unary = (op: Operations, value: ExpressionRef) => + JSModule['_BinaryenUnary'](this.ptr, op, value) as ExpressionRef; + const binary = (op: Operations, left: ExpressionRef, right: ExpressionRef) => + JSModule['_BinaryenBinary'](this.ptr, op, left, right) as ExpressionRef; + return { + load: (offset: number, align: number, ptr: ExpressionRef, name?: string) => + Module['_BinaryenLoad'](this.ptr, 8, true, offset, align, f64, ptr, strToStack(name)) as ExpressionRef, + store: (offset: number, align: number, ptr: ExpressionRef, value: ExpressionRef, name?: string) => + Module['_BinaryenStore'](this.ptr, 8, offset, align, ptr, value, f64, strToStack(name)) as ExpressionRef, + const: (value: number) => + preserveStack(() => { + const tempLiteral = stackAlloc(sizeOfLiteral); + Module['_BinaryenLiteralFloat64'](tempLiteral, value); + return Module['_BinaryenConst'](this.ptr, tempLiteral); + }) as ExpressionRef, + const_bits: (value: number) => + preserveStack(() => { + const tempLiteral = stackAlloc(sizeOfLiteral); + Module['_BinaryenLiteralFloat64Bits'](tempLiteral, value); + return Module['_BinaryenConst'](this.ptr, tempLiteral); + }) as ExpressionRef, + neg: (value: ExpressionRef) => unary(Operations.NegFloat64, value), + abs: (value: ExpressionRef) => unary(Operations.AbsFloat64, value), + ceil: (value: ExpressionRef) => unary(Operations.CeilFloat64, value), + floor: (value: ExpressionRef) => unary(Operations.FloorFloat64, value), + trunc: (value: ExpressionRef) => unary(Operations.TruncFloat64, value), + nearest: (value: ExpressionRef) => unary(Operations.NearestFloat64, value), + sqrt: (value: ExpressionRef) => unary(Operations.SqrtFloat64, value), + reinterpret_int64: (value: ExpressionRef) => unary(Operations.ReinterpretInt64, value), + convert_s: { + i32: (value: ExpressionRef) => unary(Operations.ConvertSInt32ToFloat64, value), + i64: (value: ExpressionRef) => unary(Operations.ConvertSInt64ToFloat64, value) + }, + convert_u: { + i32: (value: ExpressionRef) => unary(Operations.ConvertUInt32ToFloat64, value), + i64: (value: ExpressionRef) => unary(Operations.ConvertUInt64ToFloat64, value) + }, + promote_f32: (value: ExpressionRef)=> unary(Operations.PromoteFloat32, value), + add: (left: ExpressionRef, right: ExpressionRef) => binary(Operations.AddFloat64, left, right), + sub: (left: ExpressionRef, right: ExpressionRef) => binary(Operations.SubFloat64, left, right), + mul: (left: ExpressionRef, right: ExpressionRef) => binary(Operations.MulFloat64, left, right), + div: (left: ExpressionRef, right: ExpressionRef) => binary(Operations.DivFloat64, left, right), + copysign: (left: ExpressionRef, right: ExpressionRef) => binary(Operations.CopySignFloat64, left, right), + min: (left: ExpressionRef, right: ExpressionRef) => binary(Operations.MinFloat64, left, right), + max: (left: ExpressionRef, right: ExpressionRef) => binary(Operations.MaxFloat64, left, right), + eq: (left: ExpressionRef, right: ExpressionRef) => binary(Operations.EqFloat64, left, right), + ne: (left: ExpressionRef, right: ExpressionRef) => binary(Operations.NeFloat64, left, right), + lt: (left: ExpressionRef, right: ExpressionRef) => binary(Operations.LtFloat64, left, right), + le: (left: ExpressionRef, right: ExpressionRef) => binary(Operations.LeFloat64, left, right), + gt: (left: ExpressionRef, right: ExpressionRef) => binary(Operations.GtFloat64, left, right), + ge: (left: ExpressionRef, right: ExpressionRef) => binary(Operations.GeFloat64, left, right), + pop: () => JSModule['_BinaryenPop'](this.ptr, f64) as ExpressionRef + }; + } } } From 19378e64f87a1cc4db48c3dfd3e5853a76ec4b99 Mon Sep 17 00:00:00 2001 From: Eric Vergnaud Date: Thu, 7 Dec 2023 17:05:28 +0100 Subject: [PATCH 03/38] document API changes --- src/ts/BREAKING_CHANGES.md | 15 +++++++++++++-- src/ts/binaryen.ts | 6 +++--- 2 files changed, 16 insertions(+), 5 deletions(-) diff --git a/src/ts/BREAKING_CHANGES.md b/src/ts/BREAKING_CHANGES.md index 6ceb7387ac5..c2bbb889050 100644 --- a/src/ts/BREAKING_CHANGES.md +++ b/src/ts/BREAKING_CHANGES.md @@ -1,3 +1,14 @@ dropped ExpressionIds -changed i32.reinterpret to i32.reinterpret.f32 -changed i64.reinterpret to i64.reinterpret.f64 + +renamed i32.reinterpret to i32.reinterpret_f32 +renamed i32.wrap to i32.wrap_i64 + +renamed i64.reinterpret to i64.reinterpret_f64 + +renamed f32.reinterpret to f32.reinterpret_i32 +renamed f32.demote to f32.demote_f64 + +renamed f64.reinterpret to f64.reinterpret_i64 +renamed f64.promote to f64.promote_f32 + + diff --git a/src/ts/binaryen.ts b/src/ts/binaryen.ts index fc1b3c77369..d81fd65f26e 100644 --- a/src/ts/binaryen.ts +++ b/src/ts/binaryen.ts @@ -736,7 +736,7 @@ module binaryen { reinterpret_f32: (value: ExpressionRef) => unary(Operations.ReinterpretFloat32, value), extend8_s: (value: ExpressionRef) => unary(Operations.ExtendS8Int32, value), extend16_s: (value: ExpressionRef) => unary(Operations.ExtendS16Int32, value), - wrap_int64: (value: ExpressionRef) => unary(Operations.WrapInt64, value), + wrap_i64: (value: ExpressionRef) => unary(Operations.WrapInt64, value), add: (left: ExpressionRef, right: ExpressionRef) => binary(Operations.AddInt32, left, right), sub: (left: ExpressionRef, right: ExpressionRef) => binary(Operations.SubInt32, left, right), mul: (left: ExpressionRef, right: ExpressionRef) => binary(Operations.MulInt32, left, right), @@ -1010,7 +1010,7 @@ module binaryen { trunc: (value: ExpressionRef) => unary(Operations.TruncFloat32, value), nearest: (value: ExpressionRef) => unary(Operations.NearestFloat32, value), sqrt: (value: ExpressionRef) => unary(Operations.SqrtFloat32, value), - reinterpret_int32: (value: ExpressionRef) => unary(Operations.ReinterpretInt32, value), + reinterpret_i32: (value: ExpressionRef) => unary(Operations.ReinterpretInt32, value), convert_s: { i32: (value: ExpressionRef) => unary(Operations.ConvertSInt32ToFloat32, value), i64: (value: ExpressionRef) => unary(Operations.ConvertSInt64ToFloat32, value) @@ -1065,7 +1065,7 @@ module binaryen { trunc: (value: ExpressionRef) => unary(Operations.TruncFloat64, value), nearest: (value: ExpressionRef) => unary(Operations.NearestFloat64, value), sqrt: (value: ExpressionRef) => unary(Operations.SqrtFloat64, value), - reinterpret_int64: (value: ExpressionRef) => unary(Operations.ReinterpretInt64, value), + reinterpret_i64: (value: ExpressionRef) => unary(Operations.ReinterpretInt64, value), convert_s: { i32: (value: ExpressionRef) => unary(Operations.ConvertSInt32ToFloat64, value), i64: (value: ExpressionRef) => unary(Operations.ConvertSInt64ToFloat64, value) From b1be8339d4a90f7946512770b4c5b4c1d0753667 Mon Sep 17 00:00:00 2001 From: Eric Vergnaud Date: Thu, 7 Dec 2023 18:07:32 +0100 Subject: [PATCH 04/38] generates v128 --- src/ts/binaryen.ts | 73 +++++++++++++++++++++++++++++++++++++++++++--- 1 file changed, 69 insertions(+), 4 deletions(-) diff --git a/src/ts/binaryen.ts b/src/ts/binaryen.ts index d81fd65f26e..66c2fb1e525 100644 --- a/src/ts/binaryen.ts +++ b/src/ts/binaryen.ts @@ -2,6 +2,7 @@ module binaryen { + declare var HEAP8: Int8Array; declare var HEAP32: Int32Array; declare var HEAPU32: Uint32Array; declare var stackSave: () => number; @@ -26,18 +27,17 @@ module binaryen { return str ? allocateUTF8OnStack(str) : 0; } - function i32sToStack(i32s: number[]): number { + function i32sToStack(i32s: ArrayLike): number { const ret = stackAlloc(i32s.length << 2); HEAP32.set(i32s, ret >>> 2); return ret; } - /* - function i8sToStack(i8s) { + + function i8sToStack(i8s: ArrayLike): number { const ret = stackAlloc(i8s.length); HEAP8.set(i8s, ret); return ret; } - */ export type Type = number; export type ElementSegmentRef = number; @@ -1091,6 +1091,71 @@ module binaryen { pop: () => JSModule['_BinaryenPop'](this.ptr, f64) as ExpressionRef }; } + get v128 () { + const simd_load = (op: Operations, offset: number, align: number, ptr: ExpressionRef, name: string) => + JSModule['_BinaryenSIMDLoad'](this.ptr, op, offset, align, ptr, strToStack(name)) as ExpressionRef; + const simd_lane = (op: Operations, offset: number, align: number, index: number, ptr: ExpressionRef, vec: number, name: string) => + JSModule['_BinaryenSIMDLoadStoreLane'](this.ptr, op, offset, align, index, ptr, vec, strToStack(name)) as ExpressionRef; + return { + load: (offset: number, align: number, ptr: ExpressionRef, name?: string) => + Module['_BinaryenLoad'](this.ptr, 16, false, offset, align, v128, ptr, strToStack(name)) as ExpressionRef, + load8_splat: (offset: number, align: number, ptr: ExpressionRef, name?: string) => + simd_load(Operations.Load8SplatVec128, offset, align, ptr, name), + load16_splat: (offset: number, align: number, ptr: ExpressionRef, name?: string) => + simd_load(Operations.Load16SplatVec128, offset, align, ptr, name), + load32_splat: (offset: number, align: number, ptr: ExpressionRef, name?: string) => + simd_load(Operations.Load32SplatVec128, offset, align, ptr, name), + load64_splat: (offset: number, align: number, ptr: ExpressionRef, name?: string) => + simd_load(Operations.Load64SplatVec128, offset, align, ptr, name), + load8x8_s: (offset: number, align: number, ptr: ExpressionRef, name?: string) => + simd_load(Operations.Load8x8SVec128, offset, align, ptr, name), + load8x8_u: (offset: number, align: number, ptr: ExpressionRef, name?: string) => + simd_load(Operations.Load8x8UVec128, offset, align, ptr, name), + load16x4_s: (offset: number, align: number, ptr: ExpressionRef, name?: string) => + simd_load(Operations.Load16x4SVec128, offset, align, ptr, name), + load16x4_u: (offset: number, align: number, ptr: ExpressionRef, name?: string) => + simd_load(Operations.Load16x4UVec128, offset, align, ptr, name), + load32x2_s: (offset: number, align: number, ptr: ExpressionRef, name?: string) => + simd_load(Operations.Load32x2SVec128, offset, align, ptr, name), + load32x2_u: (offset: number, align: number, ptr: ExpressionRef, name?: string) => + simd_load(Operations.Load32x2UVec128, offset, align, ptr, name), + load32_zero: (offset: number, align: number, ptr: ExpressionRef, name?: string) => + simd_load(Operations.Load32ZeroVec128, offset, align, ptr, name), + load64_zero: (offset: number, align: number, ptr: ExpressionRef, name?: string) => + simd_load(Operations.Load64ZeroVec128, offset, align, ptr, name), + load8_lane: (offset: number, align: number, index: number, ptr: ExpressionRef, vec: ExpressionRef, name?: string) => + simd_lane(Operations.Load8LaneVec128, offset, align, index, ptr, vec, name), + load16_lane: (offset: number, align: number, index: number, ptr: ExpressionRef, vec: ExpressionRef, name?: string) => + simd_lane(Operations.Load16LaneVec128, offset, align, index, ptr, vec, name), + load32_lane: (offset: number, align: number, index: number, ptr: ExpressionRef, vec: ExpressionRef, name?: string) => + simd_lane(Operations.Load32LaneVec128, offset, align, index, ptr, vec, name), + load64_lane: (offset: number, align: number, index: number, ptr: ExpressionRef, vec: ExpressionRef, name?: string) => + simd_lane(Operations.Load64LaneVec128, offset, align, index, ptr, vec, name), + store8_lane: (offset: number, align: number, index: number, ptr: ExpressionRef, vec: ExpressionRef, name?: string) => + simd_lane(Operations.Store8LaneVec128, offset, align, index, ptr, vec, name), + store16_lane: (offset: number, align: number, index: number, ptr: ExpressionRef, vec: ExpressionRef, name?: string) => + simd_lane(Operations.Store16LaneVec128, offset, align, index, ptr, vec, name), + store32_lane: (offset: number, align: number, index: number, ptr: ExpressionRef, vec: ExpressionRef, name?: string) => + simd_lane(Operations.Store32LaneVec128, offset, align, index, ptr, vec, name), + store64_lane: (offset: number, align: number, index: number, ptr: ExpressionRef, vec: ExpressionRef, name?: string) => + simd_lane(Operations.Store64LaneVec128, offset, align, index, ptr, vec, name), + store: (offset: number, align: number, ptr: ExpressionRef, value: ExpressionRef, name?: string) => + JSModule['_BinaryenStore'](this.ptr, 16, offset, align, ptr, value, v128, strToStack(name)), + const: (i8s: ArrayLike) => { + const tempLiteral = stackAlloc(sizeOfLiteral); + JSModule['_BinaryenLiteralVec128'](tempLiteral, i8sToStack(i8s)); + return JSModule['_BinaryenConst'](this.ptr, tempLiteral) as ExpressionRef; + }, + not: (value: ExpressionRef) => JSModule['_BinaryenUnary'](this.ptr, Operations.NotVec128, value) as ExpressionRef, + any_true: (value: ExpressionRef) => JSModule['_BinaryenUnary'](this.ptr, Operations.AnyTrueVec128, value) as ExpressionRef, + and: (left: ExpressionRef, right: ExpressionRef) => JSModule['_BinaryenBinary'](this.ptr, Operations.AndVec128, left, right) as ExpressionRef, + or: (left: ExpressionRef, right: ExpressionRef) => JSModule['_BinaryenBinary'](this.ptr, Operations.OrVec128, left, right) as ExpressionRef, + xor: (left: ExpressionRef, right: ExpressionRef) => JSModule['_BinaryenBinary'](this.ptr, Operations.XorVec128, left, right) as ExpressionRef, + andnot: (left: ExpressionRef, right: ExpressionRef) => JSModule['_BinaryenBinary'](this.ptr, Operations.AndNotVec128, left, right) as ExpressionRef, + bitselect: (left: ExpressionRef, right: ExpressionRef, cond: ExpressionRef) => JSModule['_BinaryenBinary'](this.ptr, Operations.BitselectVec128, left, right) as ExpressionRef, + pop: () => JSModule['_BinaryenPop'](this.ptr, v128) as ExpressionRef + } + }; } } From 76846ff6200ff0aa80156410320fcccfddb70d3f Mon Sep 17 00:00:00 2001 From: Eric Vergnaud Date: Sun, 10 Dec 2023 09:29:10 +0100 Subject: [PATCH 05/38] support i8x16 --- src/ts/binaryen.ts | 83 ++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 83 insertions(+) diff --git a/src/ts/binaryen.ts b/src/ts/binaryen.ts index 66c2fb1e525..634a40712bf 100644 --- a/src/ts/binaryen.ts +++ b/src/ts/binaryen.ts @@ -1156,6 +1156,89 @@ module binaryen { pop: () => JSModule['_BinaryenPop'](this.ptr, v128) as ExpressionRef } }; + get i8x16 () { + const unary = (op: Operations, value: ExpressionRef) => + JSModule['_BinaryenUnary'](this.ptr, op, value) as ExpressionRef; + const binary = (op: Operations, left: ExpressionRef, right: ExpressionRef) => + JSModule['_BinaryenBinary'](this.ptr, op, left, right) as ExpressionRef; + 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) as ExpressionRef, + extract_lane_u: (vec: ExpressionRef, index: ExpressionRef): ExpressionRef => + JSModule['_BinaryenSIMDExtract'](this.ptr, Operations.ExtractLaneUVecI8x16, vec, index) as ExpressionRef, + replace_lane: (vec: ExpressionRef, index: ExpressionRef, value: ExpressionRef): ExpressionRef => + JSModule['_BinaryenSIMDReplace'](this.ptr, Module['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) + } + }; + } } From 96add7c8e1ce0ef70dcfa878d784c09e1c1709ab Mon Sep 17 00:00:00 2001 From: Eric Vergnaud Date: Sun, 10 Dec 2023 09:42:06 +0100 Subject: [PATCH 06/38] support i16x8 --- src/ts/binaryen.ts | 99 +++++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 98 insertions(+), 1 deletion(-) diff --git a/src/ts/binaryen.ts b/src/ts/binaryen.ts index 634a40712bf..0e7b3b53d78 100644 --- a/src/ts/binaryen.ts +++ b/src/ts/binaryen.ts @@ -1238,7 +1238,104 @@ module binaryen { binary(Operations.NarrowUVecI16x8ToVecI8x16, left, right) } }; - + get i16x8 () { + const unary = (op: Operations, value: ExpressionRef) => + JSModule['_BinaryenUnary'](this.ptr, op, value) as ExpressionRef; + const binary = (op: Operations, left: ExpressionRef, right: ExpressionRef) => + JSModule['_BinaryenBinary'](this.ptr, op, left, right) as ExpressionRef; + 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) as ExpressionRef, + extract_lane_u: (vec: ExpressionRef, index: ExpressionRef): ExpressionRef => + JSModule['_BinaryenSIMDExtract'](this.ptr, Operations.ExtractLaneUVecI16x8, vec, index) as ExpressionRef, + replace_lane: (vec: ExpressionRef, index: ExpressionRef, value: ExpressionRef): ExpressionRef => + JSModule['_BinaryenSIMDReplace'](this.ptr, Module['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.ExtMulHighSVecI16x8, 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) + } + }; } } From b69507ad085f966bc0e14b2b76541bc6950dd66d Mon Sep 17 00:00:00 2001 From: Eric Vergnaud Date: Sun, 10 Dec 2023 09:51:45 +0100 Subject: [PATCH 07/38] support i32x4 --- src/ts/binaryen.ts | 96 +++++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 94 insertions(+), 2 deletions(-) diff --git a/src/ts/binaryen.ts b/src/ts/binaryen.ts index 0e7b3b53d78..34bfd2ff951 100644 --- a/src/ts/binaryen.ts +++ b/src/ts/binaryen.ts @@ -1251,7 +1251,7 @@ module binaryen { extract_lane_u: (vec: ExpressionRef, index: ExpressionRef): ExpressionRef => JSModule['_BinaryenSIMDExtract'](this.ptr, Operations.ExtractLaneUVecI16x8, vec, index) as ExpressionRef, replace_lane: (vec: ExpressionRef, index: ExpressionRef, value: ExpressionRef): ExpressionRef => - JSModule['_BinaryenSIMDReplace'](this.ptr, Module['ReplaceLaneVecI16x8'], vec, index, value), + 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 => @@ -1311,7 +1311,7 @@ module binaryen { q15mulr_sat_s: (left: ExpressionRef, right: ExpressionRef): ExpressionRef => binary(Operations.Q15MulrSatSVecI16x8, left, right), extmul_low_i8x16_s: (left: ExpressionRef, right: ExpressionRef): ExpressionRef => - binary(Operations.ExtMulHighSVecI16x8, left, right), + 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 => @@ -1336,6 +1336,98 @@ module binaryen { unary(Operations.ExtendHighUVecI8x16ToVecI16x8, value) } }; + get i32x4 () { + const unary = (op: Operations, value: ExpressionRef) => + JSModule['_BinaryenUnary'](this.ptr, op, value) as ExpressionRef; + const binary = (op: Operations, left: ExpressionRef, right: ExpressionRef) => + JSModule['_BinaryenBinary'](this.ptr, op, left, right) as ExpressionRef; + return { + splat: (value: ExpressionRef): ExpressionRef => + unary(Operations.SplatVecI32x4, value), + extract_lane: (vec: ExpressionRef, index: ExpressionRef): ExpressionRef => + JSModule['_BinaryenSIMDExtract'](this.ptr, Operations.ExtractLaneVecI32x4, vec, index) as ExpressionRef, + 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) + } + }; } } From 6d99060240811fbc804aba8f40705b7ba7e41e34 Mon Sep 17 00:00:00 2001 From: Eric Vergnaud Date: Sun, 10 Dec 2023 10:03:52 +0100 Subject: [PATCH 08/38] support i64x2 --- src/ts/binaryen.ts | 63 ++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 63 insertions(+) diff --git a/src/ts/binaryen.ts b/src/ts/binaryen.ts index 34bfd2ff951..ab87aed2103 100644 --- a/src/ts/binaryen.ts +++ b/src/ts/binaryen.ts @@ -1428,6 +1428,69 @@ module binaryen { binary(Operations.TruncSatZeroUVecF64x2ToVecI32x4, left, right) } }; + get i64x2 () { + const unary = (op: Operations, value: ExpressionRef) => + JSModule['_BinaryenUnary'](this.ptr, op, value) as ExpressionRef; + const binary = (op: Operations, left: ExpressionRef, right: ExpressionRef) => + JSModule['_BinaryenBinary'](this.ptr, op, left, right) as ExpressionRef; + return { + splat: (value: ExpressionRef): ExpressionRef => + unary(Operations.SplatVecI64x2, value), + extract_lane: (vec: ExpressionRef, index: ExpressionRef): ExpressionRef => + JSModule['_BinaryenSIMDExtract'](this.ptr, Operations.ExtractLaneVecI64x2, vec, index) as ExpressionRef, + 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) + } + }; + } } From 6e6d20923e1b2d28327c47896c30cad2d13796c7 Mon Sep 17 00:00:00 2001 From: Eric Vergnaud Date: Mon, 11 Dec 2023 10:27:56 +0100 Subject: [PATCH 09/38] support f32x4 --- src/ts/binaryen.ts | 63 +++++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 62 insertions(+), 1 deletion(-) diff --git a/src/ts/binaryen.ts b/src/ts/binaryen.ts index ab87aed2103..4c0768e1f02 100644 --- a/src/ts/binaryen.ts +++ b/src/ts/binaryen.ts @@ -1490,7 +1490,68 @@ module binaryen { unary(Operations.ExtendHighUVecI32x4ToVecI64x2, value) } }; - + get f32x4 () { + const unary = (op: Operations, value: ExpressionRef) => + JSModule['_BinaryenUnary'](this.ptr, op, value) as ExpressionRef; + const binary = (op: Operations, left: ExpressionRef, right: ExpressionRef) => + JSModule['_BinaryenBinary'](this.ptr, op, left, right) as ExpressionRef; + return { + splat: (value: ExpressionRef): ExpressionRef => + unary(Operations.SplatVecF32x4, value), + extract_lane: (vec: ExpressionRef, index: ExpressionRef): ExpressionRef => + JSModule['_BinaryenSIMDExtract'](this.ptr, Operations.ExtractLaneVecF32x4, vec, index) as ExpressionRef, + 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) + } + }; } } From f5866e6d7535409458ae12a07116fe225abe6fce Mon Sep 17 00:00:00 2001 From: Eric Vergnaud Date: Mon, 11 Dec 2023 10:30:21 +0100 Subject: [PATCH 10/38] support f64x2 --- src/ts/binaryen.ts | 62 ++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 62 insertions(+) diff --git a/src/ts/binaryen.ts b/src/ts/binaryen.ts index 4c0768e1f02..c148da01bfe 100644 --- a/src/ts/binaryen.ts +++ b/src/ts/binaryen.ts @@ -1552,6 +1552,68 @@ module binaryen { unary(Operations.DemoteZeroVecF64x2ToVecF32x4, value) } }; + get f64x2 () { + const unary = (op: Operations, value: ExpressionRef) => + JSModule['_BinaryenUnary'](this.ptr, op, value) as ExpressionRef; + const binary = (op: Operations, left: ExpressionRef, right: ExpressionRef) => + JSModule['_BinaryenBinary'](this.ptr, op, left, right) as ExpressionRef; + return { + splat: (value: ExpressionRef): ExpressionRef => + unary(Operations.SplatVecF64x2, value), + extract_lane: (vec: ExpressionRef, index: ExpressionRef): ExpressionRef => + JSModule['_BinaryenSIMDExtract'](this.ptr, Operations.ExtractLaneVecF64x2, vec, index) as ExpressionRef, + 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) + } + }; } } From 255b56f2b3feca9cd46d5c826f1cd72d8c5340d2 Mon Sep 17 00:00:00 2001 From: Eric Vergnaud Date: Mon, 11 Dec 2023 11:00:34 +0100 Subject: [PATCH 11/38] more stuff --- src/ts/binaryen.ts | 93 ++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 93 insertions(+) diff --git a/src/ts/binaryen.ts b/src/ts/binaryen.ts index c148da01bfe..2c64481ba48 100644 --- a/src/ts/binaryen.ts +++ b/src/ts/binaryen.ts @@ -622,6 +622,31 @@ module binaryen { 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 local () { return { get: (index: number, type: Type) => JSModule['_BinaryenLocalGet'](this.ptr, index, type) as ExpressionRef, @@ -1614,6 +1639,74 @@ module binaryen { unary(Operations.PromoteLowVecF32x4ToVecF64x2, value) } }; + get funcref() { + return { + pop: () => JSModule['_BinaryenPop'](this.ptr, funcref) as ExpressionRef + } + } + get externref() { + return { + pop: () => JSModule['_BinaryenPop'](this.ptr, externref) as ExpressionRef + } + } + get anyref() { + return { + pop: () => JSModule['_BinaryenPop'](this.ptr, anyref) as ExpressionRef + } + } + get eqref() { + return { + pop: () => JSModule['_BinaryenPop'](this.ptr, eqref) as ExpressionRef + } + } + get i31ref() { + return { + pop: () => JSModule['_BinaryenPop'](this.ptr, i31ref) as ExpressionRef + } + } + get structref() { + return { + pop: () => JSModule['_BinaryenPop'](this.ptr, structref) as ExpressionRef + } + } + /* explicitly skipping string stuff until it's reprioritized + get stringref() { + return { + pop: () => JSModule['_BinaryenPop'](this.ptr, stringref) as ExpressionRef + } + } + get stringview_wtf8() { + return { + pop: () => JSModule['_BinaryenPop'](this.ptr, stringview_wtf8) as ExpressionRef + } + } + get stringview_wtf16() { + return { + pop: () => JSModule['_BinaryenPop'](this.ptr, stringview_wtf16) as ExpressionRef + } + } + get stringview_iter() { + return { + pop: () => JSModule['_BinaryenPop'](this.ptr, stringview_iter) as ExpressionRef + } + } + */ + get ref() { + return { + null: (type: Type) => JSModule['_BinaryenRefNull'](this.ptr, type) as ExpressionRef, + is_null: (value: ExpressionRef) => JSModule['_BinaryenRefIsNull'](this.ptr, value) as ExpressionRef, + i31: (value: ExpressionRef) => JSModule['_BinaryenRefI31'](this.ptr, value) as ExpressionRef, + func: (name: string, type: Type) => JSModule['_BinaryenRefFunc'](this.ptr, strToStack(name), type) as ExpressionRef, + eq: (left: ExpressionRef, right: ExpressionRef) => JSModule['_BinaryenRefEq'](this.ptr, left, right) as ExpressionRef, + as_non_null: (value: ExpressionRef) => JSModule['_BinaryenRefAs'](this.ptr, Operations.RefAsNonNull, value) as ExpressionRef + } + }; + get i31 () { + return { + get_s: (i31: ExpressionRef) => JSModule['_BinaryenI31Get'](this.ptr, i31, 1) as ExpressionRef, + get_u: (i31: ExpressionRef) => JSModule['_BinaryenI31Get'](this.ptr, i31, 0) as ExpressionRef + } + } } } From cc49c4c5f674757908d8706a3f2211dd44e89f18 Mon Sep 17 00:00:00 2001 From: Eric Vergnaud Date: Mon, 11 Dec 2023 13:23:18 +0100 Subject: [PATCH 12/38] more stuff --- src/ts/binaryen.ts | 299 ++++++++++++++++++++++++++++++++------------- 1 file changed, 214 insertions(+), 85 deletions(-) diff --git a/src/ts/binaryen.ts b/src/ts/binaryen.ts index 2c64481ba48..04cab86eef7 100644 --- a/src/ts/binaryen.ts +++ b/src/ts/binaryen.ts @@ -10,6 +10,7 @@ module binaryen { declare var stackRestore: (ref: number) => void; declare var allocateUTF8OnStack: (s: string) => number; declare var _BinaryenSizeofLiteral: () => number; + declare var UTF8ToString: (ptr: number) => string; const sizeOfLiteral = _BinaryenSizeofLiteral(); // avoid name clash with binaryen class Module const JSModule = self["Module"] as {}; @@ -573,6 +574,52 @@ module binaryen { Any = JSModule['_BinaryenSideEffectAny']() } + export class Function { + + readonly func: FunctionRef; + + constructor(func: FunctionRef) { + this.func = func; + } + + getName(func: FunctionRef): string { + return UTF8ToString(JSModule['_BinaryenFunctionGetName'](this.func)); + } + getParams(func: FunctionRef): Type { + return JSModule['_BinaryenFunctionGetParams'](func); + } + getResults(func: FunctionRef): Type { + return Module['_BinaryenFunctionGetResults'](func); + } + getNumVars(func: FunctionRef): number { + return Module['_BinaryenFunctionGetNumVars'](func); + } + getVar(func: FunctionRef, index: number): Type { + return Module['_BinaryenFunctionGetVar'](func, index); + } + getNumLocals(func: FunctionRef): number { + return Module['_BinaryenFunctionGetNumLocals'](func); + } + hasLocalName(func: FunctionRef, index: number): boolean { + return Boolean(Module['_BinaryenFunctionHasLocalName'](func, index)); + } + getLocalName(func: FunctionRef, index: number): string { + return UTF8ToString(Module['_BinaryenFunctionGetLocalName'](func, index)); + } + setLocalName(func: ExpressionRef, index: number, name: string): void { + preserveStack(() => { + Module['_BinaryenFunctionSetLocalName'](func, index, strToStack(name)); + }); + } + getBody(func: FunctionRef): ExpressionRef { + return Module['_BinaryenFunctionGetBody'](func); + } + setBody(func: FunctionRef, bodyExpr: ExpressionRef): void { + Module['_BinaryenFunctionSetBody'](func, bodyExpr); + } + }; + + export class Module { readonly ptr: number; @@ -647,68 +694,6 @@ module binaryen { rethrow(target: string): ExpressionRef { return JSModule['_BinaryenRethrow'](this.ptr, strToStack(target)); } - get local () { - return { - get: (index: number, type: Type) => JSModule['_BinaryenLocalGet'](this.ptr, index, type) as ExpressionRef, - set: (index: number, value: ExpressionRef) => JSModule['_BinaryenLocalSet'](this.ptr, index, value) as ExpressionRef, - tee: (index: number, value: ExpressionRef, type: Type) => { - if (typeof type === 'undefined') { - throw new Error("local.tee's type should be defined"); - } - return JSModule['_BinaryenLocalTee'](this.ptr, index, value, type) as ExpressionRef; - } - }; - } - get global () { - return { - get: (name: string, type: Type) => JSModule['_BinaryenLocalGet'](this.ptr, strToStack(name), type) as ExpressionRef, - set: (name: string, value: ExpressionRef) => JSModule['_BinaryenGlobalSet'](this.ptr, strToStack(name), value) as ExpressionRef - }; - } - get table () { - return { - get: (name: string, index: ExpressionRef, type: Type) => JSModule['_BinaryenTableGet'](this.ptr, strToStack(name), index, type) as ExpressionRef, - set: (name: string, index: ExpressionRef, value: ExpressionRef) => JSModule['_BinaryenTableSet'](this.ptr, strToStack(name), index, value) as ExpressionRef, - size: (name: string) => JSModule['_BinaryenTableSize'](this.ptr, strToStack(name)) as ExpressionRef, - grow: (name: string, value: ExpressionRef, delta: ExpressionRef) => JSModule['_BinaryenTableGrow'](this.ptr, strToStack(name), value, delta) as ExpressionRef - }; - /* 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 memory () { - return { - size: (name?: string, memory64?: boolean) => JSModule['_BinaryenMemorySize'](this.ptr, strToStack(name), memory64) as ExpressionRef, - grow: (value: ExpressionRef, name?: string, memory64?: boolean) => JSModule['_BinaryenMemoryGrow'](this.ptr, value, strToStack(name), memory64) as ExpressionRef, - init: (segment: number, dest: ExpressionRef, offset: ExpressionRef, size: ExpressionRef, name?: string) => - preserveStack(() => JSModule['_BinaryenMemoryInit'](this.ptr, strToStack(segment), dest, offset, size, strToStack(name))) as ExpressionRef, - copy: (dest: ExpressionRef, source: ExpressionRef, size: ExpressionRef, destName?: string, sourceName?: string) => - JSModule['_BinaryenMemoryCopy'](this.ptr, dest, source, size, strToStack(destName), strToStack(sourceName)) as ExpressionRef, - fill: (dest: ExpressionRef, value: ExpressionRef, size: ExpressionRef, name?: string) => - JSModule['_BinaryenMemoryFill'](this.ptr, dest, value, size, strToStack(name)) as ExpressionRef, - atomic: { - notify: (ptr: ExpressionRef, notifyCount: ExpressionRef, name?: string) => - JSModule['_BinaryenAtomicNotify'](this.ptr, ptr, notifyCount, strToStack(name)) as ExpressionRef, - wait32: (ptr: ExpressionRef, expected: ExpressionRef, timeout: ExpressionRef, name?: string) => - JSModule['_BinaryenAtomicWait'](this.ptr, ptr, expected, timeout, Module['i32'], strToStack(name)) as ExpressionRef, - wait64: (ptr: ExpressionRef, expected: ExpressionRef, timeout: ExpressionRef, name?: string) => - JSModule['_BinaryenAtomicWait'](this.ptr, ptr, expected, timeout, Module['i64'], strToStack(name)) as ExpressionRef - } - }; - } - get data () { - return { - drop: (segment: number) => preserveStack(() => JSModule['_BinaryenDataDrop'](this.ptr, strToStack(segment))) as ExpressionRef - }; - }; get i32 () { const unary = (op: Operations, value: ExpressionRef) => JSModule['_BinaryenUnary'](this.ptr, op, value) as ExpressionRef; @@ -1179,8 +1164,8 @@ module binaryen { andnot: (left: ExpressionRef, right: ExpressionRef) => JSModule['_BinaryenBinary'](this.ptr, Operations.AndNotVec128, left, right) as ExpressionRef, bitselect: (left: ExpressionRef, right: ExpressionRef, cond: ExpressionRef) => JSModule['_BinaryenBinary'](this.ptr, Operations.BitselectVec128, left, right) as ExpressionRef, pop: () => JSModule['_BinaryenPop'](this.ptr, v128) as ExpressionRef - } - }; + }; + } get i8x16 () { const unary = (op: Operations, value: ExpressionRef) => JSModule['_BinaryenUnary'](this.ptr, op, value) as ExpressionRef; @@ -1261,8 +1246,8 @@ module binaryen { 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) as ExpressionRef; @@ -1359,8 +1344,8 @@ module binaryen { 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) as ExpressionRef; @@ -1451,8 +1436,8 @@ module binaryen { 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) as ExpressionRef; @@ -1513,8 +1498,8 @@ module binaryen { 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) as ExpressionRef; @@ -1575,8 +1560,8 @@ module binaryen { 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) as ExpressionRef; @@ -1637,37 +1622,37 @@ module binaryen { unary(Operations.ConvertLowUVecI32x4ToVecF64x2, value), promote_low_f32x4: (value: ExpressionRef): ExpressionRef => unary(Operations.PromoteLowVecF32x4ToVecF64x2, value) - } - }; + }; + } get funcref() { return { pop: () => JSModule['_BinaryenPop'](this.ptr, funcref) as ExpressionRef - } + }; } get externref() { return { pop: () => JSModule['_BinaryenPop'](this.ptr, externref) as ExpressionRef - } + }; } get anyref() { return { pop: () => JSModule['_BinaryenPop'](this.ptr, anyref) as ExpressionRef - } + }; } get eqref() { return { pop: () => JSModule['_BinaryenPop'](this.ptr, eqref) as ExpressionRef - } + }; } get i31ref() { return { pop: () => JSModule['_BinaryenPop'](this.ptr, i31ref) as ExpressionRef - } + }; } get structref() { return { pop: () => JSModule['_BinaryenPop'](this.ptr, structref) as ExpressionRef - } + }; } /* explicitly skipping string stuff until it's reprioritized get stringref() { @@ -1699,13 +1684,157 @@ module binaryen { func: (name: string, type: Type) => JSModule['_BinaryenRefFunc'](this.ptr, strToStack(name), type) as ExpressionRef, eq: (left: ExpressionRef, right: ExpressionRef) => JSModule['_BinaryenRefEq'](this.ptr, left, right) as ExpressionRef, as_non_null: (value: ExpressionRef) => JSModule['_BinaryenRefAs'](this.ptr, Operations.RefAsNonNull, value) as ExpressionRef - } - }; + }; + } get i31 () { return { get_s: (i31: ExpressionRef) => JSModule['_BinaryenI31Get'](this.ptr, i31, 1) as ExpressionRef, get_u: (i31: ExpressionRef) => JSModule['_BinaryenI31Get'](this.ptr, i31, 0) as ExpressionRef - } + }; + } + get atomic () { + return { + fence: () => JSModule['_BinaryenAtomicFence'](this.ptr) as ExpressionRef + }; + } + get locals () { + return { + get: (index: number, type: Type) => JSModule['_BinaryenLocalGet'](this.ptr, index, type) as ExpressionRef, + set: (index: number, value: ExpressionRef) => JSModule['_BinaryenLocalSet'](this.ptr, index, value) as ExpressionRef, + tee: (index: number, value: ExpressionRef, type: Type) => { + if (typeof type === 'undefined') { + throw new Error("local.tee's type should be defined"); + } + return JSModule['_BinaryenLocalTee'](this.ptr, index, value, type) as ExpressionRef; + } + }; + } + get globals () { + return { + add: (name: string, type: Type, mutable: boolean, init: ExpressionRef) => + preserveStack(() => JSModule['_BinaryenAddGlobal'](this.ptr, strToStack(name), type, mutable, init)) as GlobalRef, + getRefByName: (name: string) => preserveStack(() => JSModule['_BinaryenGetGlobal'](this.ptr, strToStack(name))) as GlobalRef, + getRefByIndex: (index: number) => JSModule['_BinaryenGetGlobalByIndex'](this.ptr, index) as GlobalRef, + remove: (name: string) => preserveStack(() => JSModule['_BinaryenRemoveGlobal'](this.ptr, strToStack(name))) as void, + count: () => JSModule['_BinaryenGetNumGlobals'](this.ptr) as number, + set: (name: string, value: ExpressionRef) => JSModule['_BinaryenGlobalSet'](this.ptr, strToStack(name), value) as ExpressionRef, + get: (name: string, type: Type) => JSModule['_BinaryenGlobalGet'](this.ptr, strToStack(name), type) as ExpressionRef, + addImport: (internalName: string, externalModuleName: string, externalBaseName: string, globalType: Type, mutable: boolean) => + preserveStack(() => JSModule['_BinaryenAddGlobalImport'](this.ptr, strToStack(internalName), strToStack(externalModuleName), strToStack(externalBaseName), globalType, mutable)) as void, + addExport: (internalName: string, externalName: string) => + preserveStack(() => JSModule['_BinaryenAddGlobalExport'](this.ptr, strToStack(internalName), strToStack(externalName))) as ExportRef + }; + } + get tables () { + return { + add: (name: string, initial: number, maximum: number, type: Type) => + preserveStack(() => JSModule['_BinaryenAddTable'](this.ptr, strToStack(name), initial, maximum, type)) as TableRef, + getRefByName: (name: string) => + preserveStack(() => JSModule['_BinaryenGetTable'](this.ptr, strToStack(name))) as TableRef, + remove: (name: string) => + preserveStack(() => JSModule['_BinaryenRemoveTable'](this.ptr, strToStack(name))) as void, + + get: (name: string, index: ExpressionRef, type: Type) => JSModule['_BinaryenTableGet'](this.ptr, strToStack(name), index, type) as ExpressionRef, + set: (name: string, index: ExpressionRef, value: ExpressionRef) => JSModule['_BinaryenTableSet'](this.ptr, strToStack(name), index, value) as ExpressionRef, + size: (name: string) => JSModule['_BinaryenTableSize'](this.ptr, strToStack(name)) as ExpressionRef, + grow: (name: string, value: ExpressionRef, delta: ExpressionRef) => JSModule['_BinaryenTableGrow'](this.ptr, strToStack(name), value, delta) as ExpressionRef, + addImport: (internalName: string, externalModuleName: string, externalBaseName: string) => + preserveStack(() => JSModule['_BinaryenAddTableImport'](this.ptr, strToStack(internalName), strToStack(externalModuleName), strToStack(externalBaseName))) as void, + addExport: (internalName: string, externalName: string) => + preserveStack(() => JSModule['_BinaryenAddTableExport'](this.ptr, strToStack(internalName), strToStack(externalName))) as ExportRef + }; + /* 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[]) => + preserveStack(() => JSModule['_BinaryenTupleMake'](this.ptr, i32sToStack(elements), elements.length)) as ExpressionRef, + extract: (tuple: ExpressionRef, index: number) => + JSModule['_BinaryenTupleExtract'](this.ptr, tuple, index) as ExpressionRef + }; + } + get functions () { + return { + add: (name: string, params: Type, results: Type, varTypes: Type[], body: ExpressionRef) => + preserveStack(() => + JSModule['_BinaryenAddFunction'](this.ptr, strToStack(name), params, results, i32sToStack(varTypes), varTypes.length, body)) as FunctionRef, + getRefByName: (name: string) => + preserveStack(() => JSModule['_BinaryenGetFunction'](this.ptr, strToStack(name))) as FunctionRef, + getRefByIndex: (index: number) => + JSModule['_BinaryenGetFunctionByIndex'](this.ptr, index) as FunctionRef, + remove: (name: string) => + preserveStack(() => JSModule['_BinaryenRemoveFunction'](this.ptr, strToStack(name))) as void, + count: () => JSModule['_BinaryenGetNumFunctions'](this.ptr) as number, + addImport: (internalName: string, externalModuleName: string, externalBaseName: string, params: Type, results: Type) => + preserveStack(() => + JSModule['_BinaryenAddFunctionImport'](this.ptr, strToStack(internalName), strToStack(externalModuleName), strToStack(externalBaseName), params, results) + ) as void, + addExport: (internalName: string, externalName: string) => + preserveStack(() => JSModule['_BinaryenAddFunctionExport'](this.ptr, strToStack(internalName), strToStack(externalName))) as ExportRef + }; + } + get tags() { + return { + add: (name: string, params: Type, results: Type) => + preserveStack(() => JSModule['_BinaryenAddTag'](this.ptr, strToStack(name), params, results)) as TagRef, + getRefByName: (name: string) => + preserveStack(() => JSModule['_BinaryenGetTag'](this.ptr, strToStack(name))) as TagRef, + remove: (name: string) => + preserveStack(() => JSModule['_BinaryenRemoveTag'](this.ptr, strToStack(name))) as void, + addImport: (internalName: string, externalModuleName: string, externalBaseName: string, params: Type, results: Type) => + preserveStack(() => JSModule['_BinaryenAddTagImport'](this.ptr, strToStack(internalName), strToStack(externalModuleName), strToStack(externalBaseName), params, results)) as void, + addExport: (internalName: string, externalName: string) => + preserveStack(() => JSModule['_BinaryenAddTagExport'](this.ptr, strToStack(internalName), strToStack(externalName))) as ExportRef + }; + } + get memory () { + return { + size: (name?: string, memory64?: boolean) => JSModule['_BinaryenMemorySize'](this.ptr, strToStack(name), memory64) as ExpressionRef, + grow: (value: ExpressionRef, name?: string, memory64?: boolean) => JSModule['_BinaryenMemoryGrow'](this.ptr, value, strToStack(name), memory64) as ExpressionRef, + init: (segment: number, dest: ExpressionRef, offset: ExpressionRef, size: ExpressionRef, name?: string) => + preserveStack(() => JSModule['_BinaryenMemoryInit'](this.ptr, strToStack(segment), dest, offset, size, strToStack(name))) as ExpressionRef, + copy: (dest: ExpressionRef, source: ExpressionRef, size: ExpressionRef, destName?: string, sourceName?: string) => + JSModule['_BinaryenMemoryCopy'](this.ptr, dest, source, size, strToStack(destName), strToStack(sourceName)) as ExpressionRef, + fill: (dest: ExpressionRef, value: ExpressionRef, size: ExpressionRef, name?: string) => + JSModule['_BinaryenMemoryFill'](this.ptr, dest, value, size, strToStack(name)) as ExpressionRef, + addImport: (internalName: string, externalModuleName: string, externalBaseName: string, shared: boolean) => + preserveStack(() => JSModule['_BinaryenAddMemoryImport'](this.ptr, strToStack(internalName), strToStack(externalModuleName), strToStack(externalBaseName), shared)) as void, + addExport: (internalName: string, externalName: string) => + preserveStack(() => JSModule['_BinaryenAddMemoryExport'](this.ptr, strToStack(internalName), strToStack(externalName))) as ExportRef, + atomic: { + notify: (ptr: ExpressionRef, notifyCount: ExpressionRef, name?: string) => + JSModule['_BinaryenAtomicNotify'](this.ptr, ptr, notifyCount, strToStack(name)) as ExpressionRef, + wait32: (ptr: ExpressionRef, expected: ExpressionRef, timeout: ExpressionRef, name?: string) => + JSModule['_BinaryenAtomicWait'](this.ptr, ptr, expected, timeout, Module['i32'], strToStack(name)) as ExpressionRef, + wait64: (ptr: ExpressionRef, expected: ExpressionRef, timeout: ExpressionRef, name?: string) => + JSModule['_BinaryenAtomicWait'](this.ptr, ptr, expected, timeout, Module['i64'], strToStack(name)) as ExpressionRef + } + }; + } + get data () { + return { + drop: (segment: number) => preserveStack(() => JSModule['_BinaryenDataDrop'](this.ptr, strToStack(segment))) as ExpressionRef + }; + } + get exports () { + return { + getRefByName: (externalName: string) => + preserveStack(() => JSModule['_BinaryenGetExport'](this.ptr, strToStack(externalName))) as ExportRef, + getRefByIndex: (index: number) => JSModule['_BinaryenGetExportByIndex'](this.ptr, index) as ExportRef, + remove: (externalName: string) => preserveStack(() => JSModule['_BinaryenRemoveExport'](this.ptr, strToStack(externalName))) as void, + count: () => JSModule['_BinaryenGetNumExports'](this.ptr) as number + + }; } } } From 3a2b2a24cb5ba079513d371740d1e086db5753e4 Mon Sep 17 00:00:00 2001 From: Eric Vergnaud Date: Mon, 11 Dec 2023 14:21:56 +0100 Subject: [PATCH 13/38] progress --- src/ts/binaryen.ts | 51 +++++++++++++++++++++++++--------------------- 1 file changed, 28 insertions(+), 23 deletions(-) diff --git a/src/ts/binaryen.ts b/src/ts/binaryen.ts index 04cab86eef7..a3131c9fe45 100644 --- a/src/ts/binaryen.ts +++ b/src/ts/binaryen.ts @@ -582,41 +582,45 @@ module binaryen { this.func = func; } - getName(func: FunctionRef): string { + getName(): string { return UTF8ToString(JSModule['_BinaryenFunctionGetName'](this.func)); } - getParams(func: FunctionRef): Type { - return JSModule['_BinaryenFunctionGetParams'](func); + getParams(): Type { + return JSModule['_BinaryenFunctionGetParams'](this.func); } - getResults(func: FunctionRef): Type { - return Module['_BinaryenFunctionGetResults'](func); + getResults(): Type { + return JSModule['_BinaryenFunctionGetResults'](this.func); } - getNumVars(func: FunctionRef): number { - return Module['_BinaryenFunctionGetNumVars'](func); + getNumVars(): number { + return JSModule['_BinaryenFunctionGetNumVars'](this.func); } - getVar(func: FunctionRef, index: number): Type { - return Module['_BinaryenFunctionGetVar'](func, index); + getVar(index: number): Type { + return JSModule['_BinaryenFunctionGetVar'](this.func, index); } - getNumLocals(func: FunctionRef): number { - return Module['_BinaryenFunctionGetNumLocals'](func); + getNumLocals(): number { + return JSModule['_BinaryenFunctionGetNumLocals'](this.func); } - hasLocalName(func: FunctionRef, index: number): boolean { - return Boolean(Module['_BinaryenFunctionHasLocalName'](func, index)); + hasLocalName(index: number): boolean { + return Boolean(JSModule['_BinaryenFunctionHasLocalName'](this.func, index)); } - getLocalName(func: FunctionRef, index: number): string { - return UTF8ToString(Module['_BinaryenFunctionGetLocalName'](func, index)); + getLocalName(index: number): string { + return UTF8ToString(JSModule['_BinaryenFunctionGetLocalName'](this.func, index)); } - setLocalName(func: ExpressionRef, index: number, name: string): void { + setLocalName(index: number, name: string): void { preserveStack(() => { - Module['_BinaryenFunctionSetLocalName'](func, index, strToStack(name)); + JSModule['_BinaryenFunctionSetLocalName'](this.func, index, strToStack(name)); }); } - getBody(func: FunctionRef): ExpressionRef { - return Module['_BinaryenFunctionGetBody'](func); + getBody(): ExpressionRef { + return JSModule['_BinaryenFunctionGetBody'](this.func); } - setBody(func: FunctionRef, bodyExpr: ExpressionRef): void { - Module['_BinaryenFunctionSetBody'](func, bodyExpr); + 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); + } + }; @@ -1799,10 +1803,11 @@ module binaryen { } get memory () { return { - size: (name?: string, memory64?: boolean) => JSModule['_BinaryenMemorySize'](this.ptr, strToStack(name), memory64) as ExpressionRef, - grow: (value: ExpressionRef, name?: string, memory64?: boolean) => JSModule['_BinaryenMemoryGrow'](this.ptr, value, strToStack(name), memory64) as ExpressionRef, init: (segment: number, dest: ExpressionRef, offset: ExpressionRef, size: ExpressionRef, name?: string) => preserveStack(() => JSModule['_BinaryenMemoryInit'](this.ptr, strToStack(segment), dest, offset, size, strToStack(name))) as ExpressionRef, + has: () => Boolean(JSModule['_BinaryenHasMemory'](this.ptr)), + size: (name?: string, memory64?: boolean) => JSModule['_BinaryenMemorySize'](this.ptr, strToStack(name), memory64) as ExpressionRef, + grow: (value: ExpressionRef, name?: string, memory64?: boolean) => JSModule['_BinaryenMemoryGrow'](this.ptr, value, strToStack(name), memory64) as ExpressionRef, copy: (dest: ExpressionRef, source: ExpressionRef, size: ExpressionRef, destName?: string, sourceName?: string) => JSModule['_BinaryenMemoryCopy'](this.ptr, dest, source, size, strToStack(destName), strToStack(sourceName)) as ExpressionRef, fill: (dest: ExpressionRef, value: ExpressionRef, size: ExpressionRef, name?: string) => From a52dfe354f45d1cf1558afbe90b63dee2c8857b6 Mon Sep 17 00:00:00 2001 From: Eric Vergnaud Date: Mon, 11 Dec 2023 16:54:35 +0100 Subject: [PATCH 14/38] support ExpressionInfo --- src/ts/binaryen.ts | 963 ++++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 962 insertions(+), 1 deletion(-) diff --git a/src/ts/binaryen.ts b/src/ts/binaryen.ts index a3131c9fe45..069421812ea 100644 --- a/src/ts/binaryen.ts +++ b/src/ts/binaryen.ts @@ -3,13 +3,18 @@ module binaryen { declare var HEAP8: Int8Array; + declare var HEAPU8: Uint8Array; declare var HEAP32: Int32Array; declare var HEAPU32: Uint32Array; + declare var out: (s: string) => void; + declare var _malloc: (size: number) => number; + declare var _free: (size: number) => void; declare var stackSave: () => number; declare var stackAlloc: (size: number) => number; declare var stackRestore: (ref: number) => void; declare var allocateUTF8OnStack: (s: string) => number; declare var _BinaryenSizeofLiteral: () => number; + declare var _BinaryenSizeofAllocateAndWriteResult: () => number; declare var UTF8ToString: (ptr: number) => string; const sizeOfLiteral = _BinaryenSizeofLiteral(); // avoid name clash with binaryen class Module @@ -40,6 +45,13 @@ module binaryen { 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 type Type = number; export type ElementSegmentRef = number; export type ExpressionRef = number; @@ -50,6 +62,20 @@ module binaryen { export type TagRef = number; export type RelooperBlockRef = number; + export interface SegmentInfo { + offset: ExpressionRef; + data: Uint8Array; + passive?: boolean; + } + + export interface MemoryInfo { + module: string | null; + base: string | null; + shared: boolean; + is64: boolean; + initial: number; + max?: number; + } export function createType(types: Type[]): Type { return preserveStack(() => JSModule['_BinaryenTypeCreate'](i32sToStack(types), types.length)); @@ -631,6 +657,100 @@ module binaryen { constructor() { this.ptr = JSModule['_BinaryenModuleCreate'](); } + dispose(): void { + JSModule['_BinaryenModuleDispose'](this.ptr); + } + setStart(start: FunctionRef): void { + JSModule['_BinaryenSetStart'](this.ptr, start); + } + setFeatures(features: Features): void { + JSModule['_BinaryenModuleSetFeatures'](this.ptr, features); + } + getFeatures(): Features { + return JSModule['_BinaryenModuleGetFeatures'](this.ptr); + } + 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))) as number; + } + getDebugInfoFileName(index: number): string | null { + return UTF8ToString(JSModule['_BinaryenModuleGetDebugInfoFileName'](this.ptr, index)); + } + validate(): number { + 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 { + const old = out; + let text = ''; + out = x => { text += x + '\n' }; + JSModule['_BinaryenModulePrintAsmjs'](this.ptr); + out = 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, @@ -1735,9 +1855,10 @@ module binaryen { preserveStack(() => JSModule['_BinaryenAddTable'](this.ptr, strToStack(name), initial, maximum, type)) as TableRef, getRefByName: (name: string) => preserveStack(() => JSModule['_BinaryenGetTable'](this.ptr, strToStack(name))) as TableRef, + getRefByIndex: (index: number) => JSModule['_BinaryenGetTableByIndex'](this.ptr, index) as TableRef, remove: (name: string) => preserveStack(() => JSModule['_BinaryenRemoveTable'](this.ptr, strToStack(name))) as void, - + count: () => JSModule['_BinaryenGetNumTables'](this.ptr) as number, get: (name: string, index: ExpressionRef, type: Type) => JSModule['_BinaryenTableGet'](this.ptr, strToStack(name), index, type) as ExpressionRef, set: (name: string, index: ExpressionRef, value: ExpressionRef) => JSModule['_BinaryenTableSet'](this.ptr, strToStack(name), index, value) as ExpressionRef, size: (name: string) => JSModule['_BinaryenTableSize'](this.ptr, strToStack(name)) as ExpressionRef, @@ -1812,6 +1933,63 @@ module binaryen { JSModule['_BinaryenMemoryCopy'](this.ptr, dest, source, size, strToStack(destName), strToStack(sourceName)) as ExpressionRef, fill: (dest: ExpressionRef, value: ExpressionRef, size: ExpressionRef, name?: string) => JSModule['_BinaryenMemoryFill'](this.ptr, dest, value, size, strToStack(name)) as ExpressionRef, + set: (initial: number, maximum: number, exportName?: string | null, segments?: SegmentInfo[] | null, shared?: boolean, memory64?: boolean, internalName?: string) => + preserveStack(() => { + const segmentsLen = segments ? segments.length : 0; + const segmentData = new Array(segmentsLen); + const segmentDataLen = new Array(segmentsLen); + const segmentPassive = new Array(segmentsLen); + const segmentOffset = new Array(segmentsLen); + for (let i = 0; i < segmentsLen; i++) { + const { data, offset, passive } = segments[i]; + segmentData[i] = _malloc(data.length); + HEAP8.set(data, segmentData[i]); + segmentDataLen[i] = data.length; + segmentPassive[i] = passive; + segmentOffset[i] = offset; + } + const ret = JSModule['_BinaryenSetMemory']( + this.ptr, initial, maximum, strToStack(exportName), + i32sToStack(segmentData), + i8sToStack(segmentPassive), + i32sToStack(segmentOffset), + i32sToStack(segmentDataLen), + segmentsLen, + shared, + memory64, + strToStack(internalName) + ); + for (let i = 0; i < segmentsLen; i++) { + _free(segmentData[i]); + } + return ret; + }) as void, + getInfo: (name?: string) => { + 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) as MemoryInfo; + }, + countSegments: () => JSModule['_BinaryenGetNumMemorySegments'](this.ptr) as number, + getSegmentInfoByIndex: (index: number) => { + const passive = Boolean(JSModule['_BinaryenGetMemorySegmentPassive'](this.ptr, index)); + const offset = passive ? 0 : JSModule['_BinaryenGetMemorySegmentByteOffset'](this.ptr, index); + const size = JSModule['_BinaryenGetMemorySegmentByteLength'](this.ptr, index); + const ptr = _malloc(size); + JSModule['_BinaryenCopyMemorySegmentData'](this.ptr, index, ptr); + const bytes = new Uint8Array(size); + bytes.set(HEAP8.subarray(ptr, ptr + size)); + _free(ptr); + const data = bytes.buffer; + return { offset, data, passive } as SegmentInfo; + }, + countElementSegments: () => JSModule['_BinaryenGetNumElementSegments'](this.ptr) as number, + getElementSegmentByIndex: (index: number) => JSModule['_BinaryenGetElementSegmentByIndex'](this.ptr, index) as ElementSegmentRef, addImport: (internalName: string, externalModuleName: string, externalBaseName: string, shared: boolean) => preserveStack(() => JSModule['_BinaryenAddMemoryImport'](this.ptr, strToStack(internalName), strToStack(externalModuleName), strToStack(externalBaseName), shared)) as void, addExport: (internalName: string, externalName: string) => @@ -1841,7 +2019,790 @@ module binaryen { }; } + copyExpression(expr: ExpressionRef): ExpressionRef { + return JSModule['_BinaryenExpressionCopy'](expr, this.ptr); + } + getExpressionType(expression: ExpressionRef): Type { + return JSModule['_BinaryenExpressionGetType'](expression); + } + getExpressionInfo(expression: ExpressionRef): ExpressionInfo { + const id = JSModule['_BinaryenExpressionGetId'](expression); + const type = Module['_BinaryenExpressionGetType'](expression); + switch (id) { + case JSModule['BlockId']: + return { + 'id': id, + 'type': type, + 'name': UTF8ToString(Module['_BinaryenBlockGetName'](expression)), + 'children': getAllNested(expression, Module['_BinaryenBlockGetNumChildren'], Module['_BinaryenBlockGetChildAt']) + } as BlockInfo; + case Module['IfId']: + return { + 'id': id, + 'type': type, + 'condition': Module['_BinaryenIfGetCondition'](expression), + 'ifTrue': Module['_BinaryenIfGetIfTrue'](expression), + 'ifFalse': Module['_BinaryenIfGetIfFalse'](expression) + } as IfInfo; + case Module['LoopId']: + return { + 'id': id, + 'type': type, + 'name': UTF8ToString(Module['_BinaryenLoopGetName'](expression)), + 'body': Module['_BinaryenLoopGetBody'](expression) + } as LoopInfo; + case Module['BreakId']: + return { + 'id': id, + 'type': type, + 'name': UTF8ToString(Module['_BinaryenBreakGetName'](expression)), + 'condition': Module['_BinaryenBreakGetCondition'](expression), + 'value': Module['_BinaryenBreakGetValue'](expression) + } as BreakInfo; + 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(expression, Module['_BinaryenSwitchGetNumNames'], Module['_BinaryenSwitchGetNameAt']).map(p => UTF8ToString(p)), + 'defaultName': UTF8ToString(Module['_BinaryenSwitchGetDefaultName'](expression)), + 'condition': Module['_BinaryenSwitchGetCondition'](expression), + 'value': Module['_BinaryenSwitchGetValue'](expression) + } as SwitchInfo; + case Module['CallId']: + return { + 'id': id, + 'type': type, + 'isReturn': Boolean(Module['_BinaryenCallIsReturn'](expression)), + 'target': UTF8ToString(Module['_BinaryenCallGetTarget'](expression)), + 'operands': getAllNested(expression, Module[ '_BinaryenCallGetNumOperands'], Module['_BinaryenCallGetOperandAt']) + } as CallInfo; + case Module['CallIndirectId']: + return { + 'id': id, + 'type': type, + 'isReturn': Boolean(Module['_BinaryenCallIndirectIsReturn'](expression)), + 'target': Module['_BinaryenCallIndirectGetTarget'](expression), + 'table': Module['_BinaryenCallIndirectGetTable'](expression), + 'operands': getAllNested(expression, Module['_BinaryenCallIndirectGetNumOperands'], Module['_BinaryenCallIndirectGetOperandAt']) + } as CallIndirectInfo; + case Module['LocalGetId']: + return { + 'id': id, + 'type': type, + 'index': Module['_BinaryenLocalGetGetIndex'](expression) + } as LocalGetInfo; + case Module['LocalSetId']: + return { + 'id': id, + 'type': type, + 'isTee': Boolean(Module['_BinaryenLocalSetIsTee'](expression)), + 'index': Module['_BinaryenLocalSetGetIndex'](expression), + 'value': Module['_BinaryenLocalSetGetValue'](expression) + } as LocalSetInfo; + case Module['GlobalGetId']: + return { + 'id': id, + 'type': type, + 'name': UTF8ToString(Module['_BinaryenGlobalGetGetName'](expression)) + } as GlobalGetInfo; + case Module['GlobalSetId']: + return { + 'id': id, + 'type': type, + 'name': UTF8ToString(Module['_BinaryenGlobalSetGetName'](expression)), + 'value': Module['_BinaryenGlobalSetGetValue'](expression) + } as GlobalSetInfo; + case Module['TableGetId']: + return { + 'id': id, + 'type': type, + 'table': UTF8ToString(Module['_BinaryenTableGetGetTable'](expression)), + 'index': Module['_BinaryenTableGetGetIndex'](expression) + } as TableGetInfo; + case Module['TableSetId']: + return { + 'id': id, + 'type': type, + 'table': UTF8ToString(Module['_BinaryenTableSetGetTable'](expression)), + 'index': Module['_BinaryenTableSetGetIndex'](expression), + 'value': Module['_BinaryenTableSetGetValue'](expression) + } as TableSetInfo; + case Module['TableSizeId']: + return { + 'id': id, + 'type': type, + 'table': UTF8ToString(Module['_BinaryenTableSizeGetTable'](expression)), + } as TableSizeInfo; + case Module['TableGrowId']: + return { + 'id': id, + 'type': type, + 'table': UTF8ToString(Module['_BinaryenTableGrowGetTable'](expression)), + 'value': Module['_BinaryenTableGrowGetValue'](expression), + 'delta': Module['_BinaryenTableGrowGetDelta'](expression), + } as TableGrowInfo; + case Module['LoadId']: + return { + 'id': id, + 'type': type, + 'isAtomic': Boolean(Module['_BinaryenLoadIsAtomic'](expression)), + 'isSigned': Boolean(Module['_BinaryenLoadIsSigned'](expression)), + 'offset': Module['_BinaryenLoadGetOffset'](expression), + 'bytes': Module['_BinaryenLoadGetBytes'](expression), + 'align': Module['_BinaryenLoadGetAlign'](expression), + 'ptr': Module['_BinaryenLoadGetPtr'](expression) + } as LoadInfo; + case Module['StoreId']: + return { + 'id': id, + 'type': type, + 'isAtomic': Boolean(Module['_BinaryenStoreIsAtomic'](expression)), + 'offset': Module['_BinaryenStoreGetOffset'](expression), + 'bytes': Module['_BinaryenStoreGetBytes'](expression), + 'align': Module['_BinaryenStoreGetAlign'](expression), + 'ptr': Module['_BinaryenStoreGetPtr'](expression), + 'value': Module['_BinaryenStoreGetValue'](expression) + } as StoreInfo; + case Module['ConstId']: { + let value; + switch (type) { + case i32: + value = Module['_BinaryenConstGetValueI32'](expression); + break; + case i64: + value = { + 'low': Module['_BinaryenConstGetValueI64Low'](expression), + 'high': Module['_BinaryenConstGetValueI64High'](expression) + }; + break; + case f32: + value = Module['_BinaryenConstGetValueF32'](expression); + break; + case f64: + value = Module['_BinaryenConstGetValueF64'](expression); + break; + case v128: { + preserveStack(() => { + const tempBuffer = stackAlloc(16); + Module['_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 Module['UnaryId']: + return { + 'id': id, + 'type': type, + 'op': Module['_BinaryenUnaryGetOp'](expression), + 'value': Module['_BinaryenUnaryGetValue'](expression) + } as UnaryInfo; + case Module['BinaryId']: + return { + 'id': id, + 'type': type, + 'op': Module['_BinaryenBinaryGetOp'](expression), + 'left': Module['_BinaryenBinaryGetLeft'](expression), + 'right': Module['_BinaryenBinaryGetRight'](expression) + } as BinaryInfo; + case Module['SelectId']: + return { + 'id': id, + 'type': type, + 'ifTrue': Module['_BinaryenSelectGetIfTrue'](expression), + 'ifFalse': Module['_BinaryenSelectGetIfFalse'](expression), + 'condition': Module['_BinaryenSelectGetCondition'](expression) + } as SelectInfo; + case Module['DropId']: + return { + 'id': id, + 'type': type, + 'value': Module['_BinaryenDropGetValue'](expression) + } as DropInfo; + case Module['ReturnId']: + return { + 'id': id, + 'type': type, + 'value': Module['_BinaryenReturnGetValue'](expression) + } as ReturnInfo; + case Module['NopId']: + return { + 'id': id, + 'type': type + } as NopInfo; + case Module['UnreachableId']: + return { + 'id': id, + 'type': type + } as UnreachableInfo; + case Module['PopId']: + return { + 'id': id, + 'type': type + } as PopInfo; + case Module['MemorySizeId']: + return { + 'id': id, + 'type': type + } as MemorySizeInfo; + case Module['MemoryGrowId']: + return { + 'id': id, + 'type': type, + 'delta': Module['_BinaryenMemoryGrowGetDelta'](expression) + } as MemoryGrowInfo; + case Module['AtomicRMWId']: + return { + 'id': id, + 'type': type, + 'op': Module['_BinaryenAtomicRMWGetOp'](expression), + 'bytes': Module['_BinaryenAtomicRMWGetBytes'](expression), + 'offset': Module['_BinaryenAtomicRMWGetOffset'](expression), + 'ptr': Module['_BinaryenAtomicRMWGetPtr'](expression), + 'value': Module['_BinaryenAtomicRMWGetValue'](expression) + } as AtomicRMWInfo; + case Module['AtomicCmpxchgId']: + return { + 'id': id, + 'type': type, + 'bytes': Module['_BinaryenAtomicCmpxchgGetBytes'](expression), + 'offset': Module['_BinaryenAtomicCmpxchgGetOffset'](expression), + 'ptr': Module['_BinaryenAtomicCmpxchgGetPtr'](expression), + 'expected': Module['_BinaryenAtomicCmpxchgGetExpected'](expression), + 'replacement': Module['_BinaryenAtomicCmpxchgGetReplacement'](expression) + } as AtomicCmpxchgInfo; + case Module['AtomicWaitId']: + return { + 'id': id, + 'type': type, + 'ptr': Module['_BinaryenAtomicWaitGetPtr'](expression), + 'expected': Module['_BinaryenAtomicWaitGetExpected'](expression), + 'timeout': Module['_BinaryenAtomicWaitGetTimeout'](expression), + 'expectedType': Module['_BinaryenAtomicWaitGetExpectedType'](expression) + } as AtomicWaitInfo; + case Module['AtomicNotifyId']: + return { + 'id': id, + 'type': type, + 'ptr': Module['_BinaryenAtomicNotifyGetPtr'](expression), + 'notifyCount': Module['_BinaryenAtomicNotifyGetNotifyCount'](expression) + } as AtomicNotifyInfo; + case Module['AtomicFenceId']: + return { + 'id': id, + 'type': type, + 'order': Module['_BinaryenAtomicFenceGetOrder'](expression) + } as AtomicFenceInfo; + case Module['SIMDExtractId']: + return { + 'id': id, + 'type': type, + 'op': Module['_BinaryenSIMDExtractGetOp'](expression), + 'vec': Module['_BinaryenSIMDExtractGetVec'](expression), + 'index': Module['_BinaryenSIMDExtractGetIndex'](expression) + } as SIMDExtractInfo; + case Module['SIMDReplaceId']: + return { + 'id': id, + 'type': type, + 'op': Module['_BinaryenSIMDReplaceGetOp'](expression), + 'vec': Module['_BinaryenSIMDReplaceGetVec'](expression), + 'index': Module['_BinaryenSIMDReplaceGetIndex'](expression), + 'value': Module['_BinaryenSIMDReplaceGetValue'](expression) + } as SIMDReplaceInfo; + case Module['SIMDShuffleId']: + return preserveStack(() => { + const tempBuffer = stackAlloc(16); + Module['_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': Module['_BinaryenSIMDShuffleGetLeft'](expression), + 'right': Module['_BinaryenSIMDShuffleGetRight'](expression), + 'mask': mask + } as SIMDShuffleInfo; + }); + case Module['SIMDTernaryId']: + return { + 'id': id, + 'type': type, + 'op': Module['_BinaryenSIMDTernaryGetOp'](expression), + 'a': Module['_BinaryenSIMDTernaryGetA'](expression), + 'b': Module['_BinaryenSIMDTernaryGetB'](expression), + 'c': Module['_BinaryenSIMDTernaryGetC'](expression) + } as SIMDTernaryInfo; + case Module['SIMDShiftId']: + return { + 'id': id, + 'type': type, + 'op': Module['_BinaryenSIMDShiftGetOp'](expression), + 'vec': Module['_BinaryenSIMDShiftGetVec'](expression), + 'shift': Module['_BinaryenSIMDShiftGetShift'](expression) + } as SIMDShiftInfo; + case Module['SIMDLoadId']: + return { + 'id': id, + 'type': type, + 'op': Module['_BinaryenSIMDLoadGetOp'](expression), + 'offset': Module['_BinaryenSIMDLoadGetOffset'](expression), + 'align': Module['_BinaryenSIMDLoadGetAlign'](expression), + 'ptr': Module['_BinaryenSIMDLoadGetPtr'](expression) + } as SIMDLoadInfo; + case Module['SIMDLoadStoreLaneId']: + return { + 'id': id, + 'type': type, + 'op': Module['_BinaryenSIMDLoadStoreLaneGetOp'](expression), + 'offset': Module['_BinaryenSIMDLoadStoreLaneGetOffset'](expression), + 'align': Module['_BinaryenSIMDLoadStoreLaneGetAlign'](expression), + 'index': Module['_BinaryenSIMDLoadStoreLaneGetIndex'](expression), + 'ptr': Module['_BinaryenSIMDLoadStoreLaneGetPtr'](expression), + 'vec': Module['_BinaryenSIMDLoadStoreLaneGetVec'](expression) + } as SIMDLoadStoreLaneInfo; + case Module['MemoryInitId']: + return { + 'id': id, + 'type': type, + 'segment': UTF8ToString(Module['_BinaryenMemoryInitGetSegment'](expression)), + 'dest': Module['_BinaryenMemoryInitGetDest'](expression) as ExpressionRef, + 'offset': Module['_BinaryenMemoryInitGetOffset'](expression) as ExpressionRef, + 'size': Module['_BinaryenMemoryInitGetSize'](expression) as ExpressionRef + } as MemoryInitInfo; + case Module['DataDropId']: + return { + 'id': id, + 'type': type, + 'segment': UTF8ToString(Module['_BinaryenDataDropGetSegment'](expression)), + } as DataDropInfo; + case Module['MemoryCopyId']: + return { + 'id': id, + 'type': type, + 'dest': Module['_BinaryenMemoryCopyGetDest'](expression), + 'source': Module['_BinaryenMemoryCopyGetSource'](expression), + 'size': Module['_BinaryenMemoryCopyGetSize'](expression) + } as MemoryCopyInfo; + case Module['MemoryFillId']: + return { + 'id': id, + 'type': type, + 'dest': Module['_BinaryenMemoryFillGetDest'](expression), + 'value': Module['_BinaryenMemoryFillGetValue'](expression), + 'size': Module['_BinaryenMemoryFillGetSize'](expression) + } as MemoryFillInfo; + case Module['RefNullId']: + return { + 'id': id, + 'type': type + } as RefNullInfo; + case Module['RefIsNullId']: + return { + 'id': id, + 'type': type, + 'value': Module['_BinaryenRefIsNullGetValue'](expression) + } as RefIsNullInfo; + case Module['RefAsId']: + return { + 'id': id, + 'type': type, + 'op': Module['_BinaryenRefAsGetOp'](expression), + 'value': Module['_BinaryenRefAsGetValue'](expression) + } as RefAsInfo; + case Module['RefFuncId']: + return { + 'id': id, + 'type': type, + 'func': UTF8ToString(Module['_BinaryenRefFuncGetFunc'](expression)), + } as RefFuncInfo; + case Module['RefEqId']: + return { + 'id': id, + 'type': type, + 'left': Module['_BinaryenRefEqGetLeft'](expression), + 'right': Module['_BinaryenRefEqGetRight'](expression) + } as RefEqInfo; + case Module['TryId']: + return { + 'id': id, + 'type': type, + 'name': UTF8ToString(Module['_BinaryenTryGetName'](expression)), + 'body': Module['_BinaryenTryGetBody'](expression) as ExpressionRef, + 'catchTags': getAllNested(expression, Module['_BinaryenTryGetNumCatchTags'], Module['_BinaryenTryGetCatchTagAt']), + 'catchBodies': getAllNested(expression, Module['_BinaryenTryGetNumCatchBodies'], Module['_BinaryenTryGetCatchBodyAt']), + 'hasCatchAll': Module['_BinaryenTryHasCatchAll'](expression) as boolean, + 'delegateTarget': UTF8ToString(Module['_BinaryenTryGetDelegateTarget'](expression)) as string, + 'isDelegate': Module['_BinaryenTryIsDelegate'](expression) as boolean + } as TryInfo; + case Module['ThrowId']: + return { + 'id': id, + 'type': type, + 'tag': UTF8ToString(Module['_BinaryenThrowGetTag'](expression)), + 'operands': getAllNested(expression, Module['_BinaryenThrowGetNumOperands'], Module['_BinaryenThrowGetOperandAt']) + } as ThrowInfo; + case Module['RethrowId']: + return { + 'id': id, + 'type': type, + 'target': UTF8ToString(Module['_BinaryenRethrowGetTarget'](expression)) + } as RethrowInfo; + case Module['TupleMakeId']: + return { + 'id': id, + 'type': type, + 'operands': getAllNested(expression, Module['_BinaryenTupleMakeGetNumOperands'], Module['_BinaryenTupleMakeGetOperandAt']) + } as TupleMakeInfo; + case Module['TupleExtractId']: + return { + 'id': id, + 'type': type, + 'tuple': Module['_BinaryenTupleExtractGetTuple'](expression), + 'index': Module['_BinaryenTupleExtractGetIndex'](expression) + } as TupleExtractInfo; + case Module['RefI31Id']: + return { + 'id': id, + 'type': type, + 'value': Module['_BinaryenRefI31GetValue'](expression) + } as RefI31Info; + case Module['I31GetId']: + return { + 'id': id, + 'type': type, + 'i31': Module['_BinaryenI31GetGetI31'](expression), + 'isSigned': Boolean(Module['_BinaryenI31GetIsSigned'](expression)) + } as I31GetInfo; + default: + throw Error('unexpected id: ' + id); + } + } } + 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; + } } From 4b4460e9b02189f36a10fdefe17bbcb7310ae0ba Mon Sep 17 00:00:00 2001 From: Eric Vergnaud Date: Mon, 11 Dec 2023 19:28:53 +0100 Subject: [PATCH 15/38] migration of index.d.ts from binaryen.js complete --- src/ts/binaryen.ts | 1217 +++++++++++++++++++++++++++----------------- 1 file changed, 739 insertions(+), 478 deletions(-) diff --git a/src/ts/binaryen.ts b/src/ts/binaryen.ts index 069421812ea..5f00aaa60a1 100644 --- a/src/ts/binaryen.ts +++ b/src/ts/binaryen.ts @@ -7,6 +7,7 @@ module binaryen { declare var HEAP32: Int32Array; declare var HEAPU32: Uint32Array; declare var out: (s: string) => void; + declare var stringToAscii: (s: string, ptr: number) => void; declare var _malloc: (size: number) => number; declare var _free: (size: number) => void; declare var stackSave: () => number; @@ -61,6 +62,7 @@ module binaryen { export type TableRef = number; export type TagRef = number; export type RelooperBlockRef = number; + export type ExpressionRunnerRef = number; export interface SegmentInfo { offset: ExpressionRef; @@ -646,16 +648,166 @@ module binaryen { setDebugLocation(expr: ExpressionRef, fileIndex: number, lineNumber: number, columnNumber: number): void { JSModule['_BinaryenFunctionSetDebugLocation'](this.func, expr, fileIndex, lineNumber, columnNumber); } - + getInfo() { + return { + 'name': this.getName(), + 'module': UTF8ToString(Module['_BinaryenFunctionImportGetModule'](this.func)), + 'base': UTF8ToString(Module['_BinaryenFunctionImportGetBase'](this.func)), + 'params': this.getParams(), + 'results': this.getResults(), + 'vars': getAllNested(this.func, this.getNumVars, this.getVar), + 'body':this.getBody() + } as FunctionInfo; + } }; + 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 Module['_BinaryenGetOptimizeLevel'](); + } + function setOptimizeLevel(level: number): void { + Module['_BinaryenSetOptimizeLevel'](level); + } + function getShrinkLevel(): number { + return Module['_BinaryenGetShrinkLevel'](); + } + function setShrinkLevel(level: number): void { + Module['_BinaryenSetShrinkLevel'](level); + } + function getDebugInfo(): boolean { + return Boolean(Module['_BinaryenGetDebugInfo']()); + } + function setDebugInfo(on: boolean): void { + Module['_BinaryenSetDebugInfo'](on); + } + function getLowMemoryUnused(): boolean { + return Boolean(Module['_BinaryenGetLowMemoryUnused']()); + } + function setLowMemoryUnused(on: boolean): void { + Module['_BinaryenSetLowMemoryUnused'](on); + } + function getZeroFilledMemory(): boolean { + return Boolean(Module['_BinaryenGetZeroFilledMemory']()); + } + function setZeroFilledMemory(on: boolean): void { + Module['_BinaryenSetZeroFilledMemory'](on); + } + function getFastMath(): boolean { + return Boolean(Module['_BinaryenGetFastMath']()); + } + function setFastMath(on: boolean): void { + Module['_BinaryenSetFastMath'](on); + } + function getPassArgument(key: string): string | null { + return preserveStack(() => { + const ret = Module['_BinaryenGetPassArgument'](strToStack(key)); + return ret !== 0 ? UTF8ToString(ret) : null; + }); + } + function setPassArgument(key: string, value: string | null): void { + preserveStack(() => { Module['_BinaryenSetPassArgument'](strToStack(key), strToStack(value)) }); + } + function clearPassArguments(): void { + Module['_BinaryenClearPassArguments'](); + } + function getAlwaysInlineMaxSize(): number { + return Module['_BinaryenGetAlwaysInlineMaxSize'](); + } + function setAlwaysInlineMaxSize(size: number): void { + Module['_BinaryenSetAlwaysInlineMaxSize'](size); + } + function getFlexibleInlineMaxSize(): number { + return Module['_BinaryenGetFlexibleInlineMaxSize'](); + } + function setFlexibleInlineMaxSize(size: number): void { + Module['_BinaryenSetFlexibleInlineMaxSize'](size); + } + function getOneCallerInlineMaxSize(): number { + return Module['_BinaryenGetOneCallerInlineMaxSize'](); + } + function setOneCallerInlineMaxSize(size: number): void { + Module['_BinaryenSetOneCallerInlineMaxSize'](size); + } + function getAllowInliningFunctionsWithLoops(): boolean { + return Boolean(Module['_BinaryenGetAllowInliningFunctionsWithLoops']()); + } + function setAllowInliningFunctionsWithLoops(on: boolean): void { + Module['_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 = Module['_BinaryenModuleParse'](buffer); + _free(buffer); + return new Module(ptr); + } + readonly ptr: number; - constructor() { - this.ptr = JSModule['_BinaryenModuleCreate'](); + constructor(ptr?: number) { + this.ptr = ptr || JSModule['_BinaryenModuleCreate'](); } dispose(): void { JSModule['_BinaryenModuleDispose'](this.ptr); @@ -1846,7 +1998,17 @@ module binaryen { addImport: (internalName: string, externalModuleName: string, externalBaseName: string, globalType: Type, mutable: boolean) => preserveStack(() => JSModule['_BinaryenAddGlobalImport'](this.ptr, strToStack(internalName), strToStack(externalModuleName), strToStack(externalBaseName), globalType, mutable)) as void, addExport: (internalName: string, externalName: string) => - preserveStack(() => JSModule['_BinaryenAddGlobalExport'](this.ptr, strToStack(internalName), strToStack(externalName))) as ExportRef + preserveStack(() => JSModule['_BinaryenAddGlobalExport'](this.ptr, strToStack(internalName), strToStack(externalName))) as ExportRef, + getInfo: (ref: GlobalRef) => { + return { + 'name': UTF8ToString(Module['_BinaryenGlobalGetName'](ref)) as string, + 'module': UTF8ToString(Module['_BinaryenGlobalImportGetModule'](ref)) as string | null, + 'base': UTF8ToString(Module['_BinaryenGlobalImportGetBase'](ref)) as string | null, + 'type': Module['_BinaryenGlobalGetType'](ref) as Type, + 'mutable': Boolean(Module['_BinaryenGlobalIsMutable'](ref)), + 'init': Module['_BinaryenGlobalGetInitExpr'](ref) as ExpressionRef + } as GlobalInfo; + } }; } get tables () { @@ -1866,7 +2028,17 @@ module binaryen { addImport: (internalName: string, externalModuleName: string, externalBaseName: string) => preserveStack(() => JSModule['_BinaryenAddTableImport'](this.ptr, strToStack(internalName), strToStack(externalModuleName), strToStack(externalBaseName))) as void, addExport: (internalName: string, externalName: string) => - preserveStack(() => JSModule['_BinaryenAddTableExport'](this.ptr, strToStack(internalName), strToStack(externalName))) as ExportRef + preserveStack(() => JSModule['_BinaryenAddTableExport'](this.ptr, strToStack(internalName), strToStack(externalName))) as ExportRef, + getInfo: (table: TableRef) => { + const hasMax = Boolean(JSModule['_BinaryenTableHasMax'](this.ptr, strToStack(name))); + const withMax = hasMax ? { max: JSModule['_BinaryenTableGetMax'](this.ptr, strToStack(name))} : {}; + return Object.assign({ + 'name': UTF8ToString(Module['_BinaryenTableGetName'](table)), + 'module': UTF8ToString(Module['_BinaryenTableImportGetModule'](table)), + 'base': UTF8ToString(Module['_BinaryenTableImportGetBase'](table)), + 'initial': Module['_BinaryenTableGetInitial'](table), + }, withMax) as TableInfo; + } }; /* TODO a._BinaryenTableGetName = Q.My; @@ -1919,7 +2091,16 @@ module binaryen { addImport: (internalName: string, externalModuleName: string, externalBaseName: string, params: Type, results: Type) => preserveStack(() => JSModule['_BinaryenAddTagImport'](this.ptr, strToStack(internalName), strToStack(externalModuleName), strToStack(externalBaseName), params, results)) as void, addExport: (internalName: string, externalName: string) => - preserveStack(() => JSModule['_BinaryenAddTagExport'](this.ptr, strToStack(internalName), strToStack(externalName))) as ExportRef + preserveStack(() => JSModule['_BinaryenAddTagExport'](this.ptr, strToStack(internalName), strToStack(externalName))) as ExportRef, + getInfo: (tag: TagRef) => { + return { + 'name': UTF8ToString(Module['_BinaryenTagGetName'](tag)), + 'module': UTF8ToString(Module['_BinaryenTagImportGetModule'](tag)), + 'base': UTF8ToString(Module['_BinaryenTagImportGetBase'](tag)), + 'params': Module['_BinaryenTagGetParams'](tag), + 'results': Module['_BinaryenTagGetResults'](tag) + } as TagInfo; + } }; } get memory () { @@ -1990,6 +2171,19 @@ module binaryen { }, countElementSegments: () => JSModule['_BinaryenGetNumElementSegments'](this.ptr) as number, getElementSegmentByIndex: (index: number) => JSModule['_BinaryenGetElementSegmentByIndex'](this.ptr, index) as ElementSegmentRef, + getElementSegmentInfo: (segment: ElementSegmentRef) => { + const segmentLength = Module['_BinaryenElementSegmentGetLength'](segment); + const names = new Array(segmentLength); + for (let j = 0; j < segmentLength; j++) { + names[j] = UTF8ToString(Module['_BinaryenElementSegmentGetData'](segment, j)); + } + return { + 'name': UTF8ToString(Module['_BinaryenElementSegmentGetName'](segment)), + 'table': UTF8ToString(Module['_BinaryenElementSegmentGetTable'](segment)), + 'offset': Module['_BinaryenElementSegmentGetOffset'](segment), + 'data': names + } as ElementSegmentInfo; + }, addImport: (internalName: string, externalModuleName: string, externalBaseName: string, shared: boolean) => preserveStack(() => JSModule['_BinaryenAddMemoryImport'](this.ptr, strToStack(internalName), strToStack(externalModuleName), strToStack(externalBaseName), shared)) as void, addExport: (internalName: string, externalName: string) => @@ -2015,484 +2209,83 @@ module binaryen { preserveStack(() => JSModule['_BinaryenGetExport'](this.ptr, strToStack(externalName))) as ExportRef, getRefByIndex: (index: number) => JSModule['_BinaryenGetExportByIndex'](this.ptr, index) as ExportRef, remove: (externalName: string) => preserveStack(() => JSModule['_BinaryenRemoveExport'](this.ptr, strToStack(externalName))) as void, - count: () => JSModule['_BinaryenGetNumExports'](this.ptr) as number + count: () => JSModule['_BinaryenGetNumExports'](this.ptr) as number, + getInfo: (export_: ExportRef) => { + return { + 'kind': Module['_BinaryenExportGetKind'](export_), + 'name': UTF8ToString(Module['_BinaryenExportGetName'](export_)), + 'value': UTF8ToString(Module['_BinaryenExportGetValue'](export_)) + } as ExportInfo; + } }; } - copyExpression(expr: ExpressionRef): ExpressionRef { - return JSModule['_BinaryenExpressionCopy'](expr, this.ptr); - } - getExpressionType(expression: ExpressionRef): Type { - return JSModule['_BinaryenExpressionGetType'](expression); - } - getExpressionInfo(expression: ExpressionRef): ExpressionInfo { - const id = JSModule['_BinaryenExpressionGetId'](expression); - const type = Module['_BinaryenExpressionGetType'](expression); - switch (id) { - case JSModule['BlockId']: - return { - 'id': id, - 'type': type, - 'name': UTF8ToString(Module['_BinaryenBlockGetName'](expression)), - 'children': getAllNested(expression, Module['_BinaryenBlockGetNumChildren'], Module['_BinaryenBlockGetChildAt']) - } as BlockInfo; - case Module['IfId']: - return { - 'id': id, - 'type': type, - 'condition': Module['_BinaryenIfGetCondition'](expression), - 'ifTrue': Module['_BinaryenIfGetIfTrue'](expression), - 'ifFalse': Module['_BinaryenIfGetIfFalse'](expression) - } as IfInfo; - case Module['LoopId']: - return { - 'id': id, - 'type': type, - 'name': UTF8ToString(Module['_BinaryenLoopGetName'](expression)), - 'body': Module['_BinaryenLoopGetBody'](expression) - } as LoopInfo; - case Module['BreakId']: - return { - 'id': id, - 'type': type, - 'name': UTF8ToString(Module['_BinaryenBreakGetName'](expression)), - 'condition': Module['_BinaryenBreakGetCondition'](expression), - 'value': Module['_BinaryenBreakGetValue'](expression) - } as BreakInfo; - 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(expression, Module['_BinaryenSwitchGetNumNames'], Module['_BinaryenSwitchGetNameAt']).map(p => UTF8ToString(p)), - 'defaultName': UTF8ToString(Module['_BinaryenSwitchGetDefaultName'](expression)), - 'condition': Module['_BinaryenSwitchGetCondition'](expression), - 'value': Module['_BinaryenSwitchGetValue'](expression) - } as SwitchInfo; - case Module['CallId']: - return { - 'id': id, - 'type': type, - 'isReturn': Boolean(Module['_BinaryenCallIsReturn'](expression)), - 'target': UTF8ToString(Module['_BinaryenCallGetTarget'](expression)), - 'operands': getAllNested(expression, Module[ '_BinaryenCallGetNumOperands'], Module['_BinaryenCallGetOperandAt']) - } as CallInfo; - case Module['CallIndirectId']: - return { - 'id': id, - 'type': type, - 'isReturn': Boolean(Module['_BinaryenCallIndirectIsReturn'](expression)), - 'target': Module['_BinaryenCallIndirectGetTarget'](expression), - 'table': Module['_BinaryenCallIndirectGetTable'](expression), - 'operands': getAllNested(expression, Module['_BinaryenCallIndirectGetNumOperands'], Module['_BinaryenCallIndirectGetOperandAt']) - } as CallIndirectInfo; - case Module['LocalGetId']: - return { - 'id': id, - 'type': type, - 'index': Module['_BinaryenLocalGetGetIndex'](expression) - } as LocalGetInfo; - case Module['LocalSetId']: - return { - 'id': id, - 'type': type, - 'isTee': Boolean(Module['_BinaryenLocalSetIsTee'](expression)), - 'index': Module['_BinaryenLocalSetGetIndex'](expression), - 'value': Module['_BinaryenLocalSetGetValue'](expression) - } as LocalSetInfo; - case Module['GlobalGetId']: - return { - 'id': id, - 'type': type, - 'name': UTF8ToString(Module['_BinaryenGlobalGetGetName'](expression)) - } as GlobalGetInfo; - case Module['GlobalSetId']: - return { - 'id': id, - 'type': type, - 'name': UTF8ToString(Module['_BinaryenGlobalSetGetName'](expression)), - 'value': Module['_BinaryenGlobalSetGetValue'](expression) - } as GlobalSetInfo; - case Module['TableGetId']: - return { - 'id': id, - 'type': type, - 'table': UTF8ToString(Module['_BinaryenTableGetGetTable'](expression)), - 'index': Module['_BinaryenTableGetGetIndex'](expression) - } as TableGetInfo; - case Module['TableSetId']: - return { - 'id': id, - 'type': type, - 'table': UTF8ToString(Module['_BinaryenTableSetGetTable'](expression)), - 'index': Module['_BinaryenTableSetGetIndex'](expression), - 'value': Module['_BinaryenTableSetGetValue'](expression) - } as TableSetInfo; - case Module['TableSizeId']: - return { - 'id': id, - 'type': type, - 'table': UTF8ToString(Module['_BinaryenTableSizeGetTable'](expression)), - } as TableSizeInfo; - case Module['TableGrowId']: - return { - 'id': id, - 'type': type, - 'table': UTF8ToString(Module['_BinaryenTableGrowGetTable'](expression)), - 'value': Module['_BinaryenTableGrowGetValue'](expression), - 'delta': Module['_BinaryenTableGrowGetDelta'](expression), - } as TableGrowInfo; - case Module['LoadId']: - return { - 'id': id, - 'type': type, - 'isAtomic': Boolean(Module['_BinaryenLoadIsAtomic'](expression)), - 'isSigned': Boolean(Module['_BinaryenLoadIsSigned'](expression)), - 'offset': Module['_BinaryenLoadGetOffset'](expression), - 'bytes': Module['_BinaryenLoadGetBytes'](expression), - 'align': Module['_BinaryenLoadGetAlign'](expression), - 'ptr': Module['_BinaryenLoadGetPtr'](expression) - } as LoadInfo; - case Module['StoreId']: - return { - 'id': id, - 'type': type, - 'isAtomic': Boolean(Module['_BinaryenStoreIsAtomic'](expression)), - 'offset': Module['_BinaryenStoreGetOffset'](expression), - 'bytes': Module['_BinaryenStoreGetBytes'](expression), - 'align': Module['_BinaryenStoreGetAlign'](expression), - 'ptr': Module['_BinaryenStoreGetPtr'](expression), - 'value': Module['_BinaryenStoreGetValue'](expression) - } as StoreInfo; - case Module['ConstId']: { - let value; - switch (type) { - case i32: - value = Module['_BinaryenConstGetValueI32'](expression); - break; - case i64: - value = { - 'low': Module['_BinaryenConstGetValueI64Low'](expression), - 'high': Module['_BinaryenConstGetValueI64High'](expression) - }; - break; - case f32: - value = Module['_BinaryenConstGetValueF32'](expression); - break; - case f64: - value = Module['_BinaryenConstGetValueF64'](expression); - break; - case v128: { - preserveStack(() => { - const tempBuffer = stackAlloc(16); - Module['_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); + get expressions () { + return { + copy: (expr: ExpressionRef) => JSModule['_BinaryenExpressionCopy'](expr, this.ptr) as ExpressionRef, + getType: (expression: ExpressionRef) => JSModule['_BinaryenExpressionGetType'](expression) as Type, + getInfo: (expression: ExpressionRef) => getExpressionInfo(expression) as ExpressionInfo, + getSideEffects: (expression: ExpressionRef) => JSModule['_BinaryenExpressionGetSideEffects'](expression, this.ptr) as SideEffects, + emitText: (expression: ExpressionRef) => { + const old = out; + let text = ''; + out = x => { text += x + '\n' }; + JSModule['_BinaryenExpressionPrint'](expression); + out = old; + return text; } - return { - 'id': id, - 'type': type, - 'value': value - } as ConstInfo; - } - case Module['UnaryId']: - return { - 'id': id, - 'type': type, - 'op': Module['_BinaryenUnaryGetOp'](expression), - 'value': Module['_BinaryenUnaryGetValue'](expression) - } as UnaryInfo; - case Module['BinaryId']: - return { - 'id': id, - 'type': type, - 'op': Module['_BinaryenBinaryGetOp'](expression), - 'left': Module['_BinaryenBinaryGetLeft'](expression), - 'right': Module['_BinaryenBinaryGetRight'](expression) - } as BinaryInfo; - case Module['SelectId']: - return { - 'id': id, - 'type': type, - 'ifTrue': Module['_BinaryenSelectGetIfTrue'](expression), - 'ifFalse': Module['_BinaryenSelectGetIfFalse'](expression), - 'condition': Module['_BinaryenSelectGetCondition'](expression) - } as SelectInfo; - case Module['DropId']: - return { - 'id': id, - 'type': type, - 'value': Module['_BinaryenDropGetValue'](expression) - } as DropInfo; - case Module['ReturnId']: - return { - 'id': id, - 'type': type, - 'value': Module['_BinaryenReturnGetValue'](expression) - } as ReturnInfo; - case Module['NopId']: - return { - 'id': id, - 'type': type - } as NopInfo; - case Module['UnreachableId']: - return { - 'id': id, - 'type': type - } as UnreachableInfo; - case Module['PopId']: - return { - 'id': id, - 'type': type - } as PopInfo; - case Module['MemorySizeId']: - return { - 'id': id, - 'type': type - } as MemorySizeInfo; - case Module['MemoryGrowId']: - return { - 'id': id, - 'type': type, - 'delta': Module['_BinaryenMemoryGrowGetDelta'](expression) - } as MemoryGrowInfo; - case Module['AtomicRMWId']: - return { - 'id': id, - 'type': type, - 'op': Module['_BinaryenAtomicRMWGetOp'](expression), - 'bytes': Module['_BinaryenAtomicRMWGetBytes'](expression), - 'offset': Module['_BinaryenAtomicRMWGetOffset'](expression), - 'ptr': Module['_BinaryenAtomicRMWGetPtr'](expression), - 'value': Module['_BinaryenAtomicRMWGetValue'](expression) - } as AtomicRMWInfo; - case Module['AtomicCmpxchgId']: - return { - 'id': id, - 'type': type, - 'bytes': Module['_BinaryenAtomicCmpxchgGetBytes'](expression), - 'offset': Module['_BinaryenAtomicCmpxchgGetOffset'](expression), - 'ptr': Module['_BinaryenAtomicCmpxchgGetPtr'](expression), - 'expected': Module['_BinaryenAtomicCmpxchgGetExpected'](expression), - 'replacement': Module['_BinaryenAtomicCmpxchgGetReplacement'](expression) - } as AtomicCmpxchgInfo; - case Module['AtomicWaitId']: - return { - 'id': id, - 'type': type, - 'ptr': Module['_BinaryenAtomicWaitGetPtr'](expression), - 'expected': Module['_BinaryenAtomicWaitGetExpected'](expression), - 'timeout': Module['_BinaryenAtomicWaitGetTimeout'](expression), - 'expectedType': Module['_BinaryenAtomicWaitGetExpectedType'](expression) - } as AtomicWaitInfo; - case Module['AtomicNotifyId']: - return { - 'id': id, - 'type': type, - 'ptr': Module['_BinaryenAtomicNotifyGetPtr'](expression), - 'notifyCount': Module['_BinaryenAtomicNotifyGetNotifyCount'](expression) - } as AtomicNotifyInfo; - case Module['AtomicFenceId']: - return { - 'id': id, - 'type': type, - 'order': Module['_BinaryenAtomicFenceGetOrder'](expression) - } as AtomicFenceInfo; - case Module['SIMDExtractId']: - return { - 'id': id, - 'type': type, - 'op': Module['_BinaryenSIMDExtractGetOp'](expression), - 'vec': Module['_BinaryenSIMDExtractGetVec'](expression), - 'index': Module['_BinaryenSIMDExtractGetIndex'](expression) - } as SIMDExtractInfo; - case Module['SIMDReplaceId']: - return { - 'id': id, - 'type': type, - 'op': Module['_BinaryenSIMDReplaceGetOp'](expression), - 'vec': Module['_BinaryenSIMDReplaceGetVec'](expression), - 'index': Module['_BinaryenSIMDReplaceGetIndex'](expression), - 'value': Module['_BinaryenSIMDReplaceGetValue'](expression) - } as SIMDReplaceInfo; - case Module['SIMDShuffleId']: - return preserveStack(() => { - const tempBuffer = stackAlloc(16); - Module['_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': Module['_BinaryenSIMDShuffleGetLeft'](expression), - 'right': Module['_BinaryenSIMDShuffleGetRight'](expression), - 'mask': mask - } as SIMDShuffleInfo; - }); - case Module['SIMDTernaryId']: - return { - 'id': id, - 'type': type, - 'op': Module['_BinaryenSIMDTernaryGetOp'](expression), - 'a': Module['_BinaryenSIMDTernaryGetA'](expression), - 'b': Module['_BinaryenSIMDTernaryGetB'](expression), - 'c': Module['_BinaryenSIMDTernaryGetC'](expression) - } as SIMDTernaryInfo; - case Module['SIMDShiftId']: - return { - 'id': id, - 'type': type, - 'op': Module['_BinaryenSIMDShiftGetOp'](expression), - 'vec': Module['_BinaryenSIMDShiftGetVec'](expression), - 'shift': Module['_BinaryenSIMDShiftGetShift'](expression) - } as SIMDShiftInfo; - case Module['SIMDLoadId']: - return { - 'id': id, - 'type': type, - 'op': Module['_BinaryenSIMDLoadGetOp'](expression), - 'offset': Module['_BinaryenSIMDLoadGetOffset'](expression), - 'align': Module['_BinaryenSIMDLoadGetAlign'](expression), - 'ptr': Module['_BinaryenSIMDLoadGetPtr'](expression) - } as SIMDLoadInfo; - case Module['SIMDLoadStoreLaneId']: - return { - 'id': id, - 'type': type, - 'op': Module['_BinaryenSIMDLoadStoreLaneGetOp'](expression), - 'offset': Module['_BinaryenSIMDLoadStoreLaneGetOffset'](expression), - 'align': Module['_BinaryenSIMDLoadStoreLaneGetAlign'](expression), - 'index': Module['_BinaryenSIMDLoadStoreLaneGetIndex'](expression), - 'ptr': Module['_BinaryenSIMDLoadStoreLaneGetPtr'](expression), - 'vec': Module['_BinaryenSIMDLoadStoreLaneGetVec'](expression) - } as SIMDLoadStoreLaneInfo; - case Module['MemoryInitId']: - return { - 'id': id, - 'type': type, - 'segment': UTF8ToString(Module['_BinaryenMemoryInitGetSegment'](expression)), - 'dest': Module['_BinaryenMemoryInitGetDest'](expression) as ExpressionRef, - 'offset': Module['_BinaryenMemoryInitGetOffset'](expression) as ExpressionRef, - 'size': Module['_BinaryenMemoryInitGetSize'](expression) as ExpressionRef - } as MemoryInitInfo; - case Module['DataDropId']: - return { - 'id': id, - 'type': type, - 'segment': UTF8ToString(Module['_BinaryenDataDropGetSegment'](expression)), - } as DataDropInfo; - case Module['MemoryCopyId']: - return { - 'id': id, - 'type': type, - 'dest': Module['_BinaryenMemoryCopyGetDest'](expression), - 'source': Module['_BinaryenMemoryCopyGetSource'](expression), - 'size': Module['_BinaryenMemoryCopyGetSize'](expression) - } as MemoryCopyInfo; - case Module['MemoryFillId']: - return { - 'id': id, - 'type': type, - 'dest': Module['_BinaryenMemoryFillGetDest'](expression), - 'value': Module['_BinaryenMemoryFillGetValue'](expression), - 'size': Module['_BinaryenMemoryFillGetSize'](expression) - } as MemoryFillInfo; - case Module['RefNullId']: - return { - 'id': id, - 'type': type - } as RefNullInfo; - case Module['RefIsNullId']: - return { - 'id': id, - 'type': type, - 'value': Module['_BinaryenRefIsNullGetValue'](expression) - } as RefIsNullInfo; - case Module['RefAsId']: - return { - 'id': id, - 'type': type, - 'op': Module['_BinaryenRefAsGetOp'](expression), - 'value': Module['_BinaryenRefAsGetValue'](expression) - } as RefAsInfo; - case Module['RefFuncId']: - return { - 'id': id, - 'type': type, - 'func': UTF8ToString(Module['_BinaryenRefFuncGetFunc'](expression)), - } as RefFuncInfo; - case Module['RefEqId']: - return { - 'id': id, - 'type': type, - 'left': Module['_BinaryenRefEqGetLeft'](expression), - 'right': Module['_BinaryenRefEqGetRight'](expression) - } as RefEqInfo; - case Module['TryId']: - return { - 'id': id, - 'type': type, - 'name': UTF8ToString(Module['_BinaryenTryGetName'](expression)), - 'body': Module['_BinaryenTryGetBody'](expression) as ExpressionRef, - 'catchTags': getAllNested(expression, Module['_BinaryenTryGetNumCatchTags'], Module['_BinaryenTryGetCatchTagAt']), - 'catchBodies': getAllNested(expression, Module['_BinaryenTryGetNumCatchBodies'], Module['_BinaryenTryGetCatchBodyAt']), - 'hasCatchAll': Module['_BinaryenTryHasCatchAll'](expression) as boolean, - 'delegateTarget': UTF8ToString(Module['_BinaryenTryGetDelegateTarget'](expression)) as string, - 'isDelegate': Module['_BinaryenTryIsDelegate'](expression) as boolean - } as TryInfo; - case Module['ThrowId']: - return { - 'id': id, - 'type': type, - 'tag': UTF8ToString(Module['_BinaryenThrowGetTag'](expression)), - 'operands': getAllNested(expression, Module['_BinaryenThrowGetNumOperands'], Module['_BinaryenThrowGetOperandAt']) - } as ThrowInfo; - case Module['RethrowId']: - return { - 'id': id, - 'type': type, - 'target': UTF8ToString(Module['_BinaryenRethrowGetTarget'](expression)) - } as RethrowInfo; - case Module['TupleMakeId']: - return { - 'id': id, - 'type': type, - 'operands': getAllNested(expression, Module['_BinaryenTupleMakeGetNumOperands'], Module['_BinaryenTupleMakeGetOperandAt']) - } as TupleMakeInfo; - case Module['TupleExtractId']: - return { - 'id': id, - 'type': type, - 'tuple': Module['_BinaryenTupleExtractGetTuple'](expression), - 'index': Module['_BinaryenTupleExtractGetIndex'](expression) - } as TupleExtractInfo; - case Module['RefI31Id']: - return { - 'id': id, - 'type': type, - 'value': Module['_BinaryenRefI31GetValue'](expression) - } as RefI31Info; - case Module['I31GetId']: - return { - 'id': id, - 'type': type, - 'i31': Module['_BinaryenI31GetGetI31'](expression), - 'isSigned': Boolean(Module['_BinaryenI31GetIsSigned'](expression)) - } as I31GetInfo; - default: - throw Error('unexpected id: ' + id); - } + }; + } + } + + 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 { + Module['_RelooperAddBranch'](from, to, condition, code); + } + addBlockWithSwitch(code: ExpressionRef, condition: ExpressionRef): RelooperBlockRef { + return Module['_RelooperAddBlockWithSwitch'](this.ref, code, condition); + } + addBranchForSwitch(from: RelooperBlockRef, to: RelooperBlockRef, indexes: number[], code: ExpressionRef): void { + preserveStack(() => Module['_RelooperAddBranchForSwitch'](from, to, i32sToStack(indexes), indexes.length, code)); + } + renderAndDispose(entry: RelooperBlockRef, labelHelper: number): ExpressionRef { + return Module['_RelooperRenderAndDispose'](this.ref, entry, labelHelper); } } + + export enum ExpressionRunnerFlags { + Default, + PreserveSideeffects, + TraverseCalls + } + + export class ExpressionRunner { + + readonly ref: ExpressionRunnerRef; + + constructor(module: Module, flags: ExpressionRunnerFlags, maxDepth: number, maxLoopIterations: number) { + this.ref = Module['_ExpressionRunnerCreate'](module.ptr, flags, maxDepth, maxLoopIterations); + } + setLocalValue(index: number, valueExpr: ExpressionRef): boolean { + return Boolean(Module['_ExpressionRunnerSetLocalValue'](this.ref, index, valueExpr)); + } + setGlobalValue(name: string, valueExpr: ExpressionRef): boolean { + return preserveStack(() => Boolean(Module['_ExpressionRunnerSetGlobalValue'](this.ref, strToStack(name), valueExpr))); + } + runAndDispose(expr: ExpressionRef): ExpressionRef { + return Module['_ExpressionRunnerRunAndDispose'](this.ref, expr); + } + } + export interface ExpressionInfo { id: number; type: Type; @@ -2803,6 +2596,474 @@ module binaryen { i31: ExpressionRef; isSigned: boolean; } + + function getExpressionInfo(expression: ExpressionRef) { + const id = JSModule['_BinaryenExpressionGetId'](expression); + const type = Module['_BinaryenExpressionGetType'](expression); + switch (id) { + case JSModule['BlockId']: + return { + 'id': id, + 'type': type, + 'name': UTF8ToString(Module['_BinaryenBlockGetName'](expression)), + 'children': getAllNested(expression, Module['_BinaryenBlockGetNumChildren'], Module['_BinaryenBlockGetChildAt']) + } as BlockInfo; + case Module['IfId']: + return { + 'id': id, + 'type': type, + 'condition': Module['_BinaryenIfGetCondition'](expression), + 'ifTrue': Module['_BinaryenIfGetIfTrue'](expression), + 'ifFalse': Module['_BinaryenIfGetIfFalse'](expression) + } as IfInfo; + case Module['LoopId']: + return { + 'id': id, + 'type': type, + 'name': UTF8ToString(Module['_BinaryenLoopGetName'](expression)), + 'body': Module['_BinaryenLoopGetBody'](expression) + } as LoopInfo; + case Module['BreakId']: + return { + 'id': id, + 'type': type, + 'name': UTF8ToString(Module['_BinaryenBreakGetName'](expression)), + 'condition': Module['_BinaryenBreakGetCondition'](expression), + 'value': Module['_BinaryenBreakGetValue'](expression) + } as BreakInfo; + 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(expression, Module['_BinaryenSwitchGetNumNames'], Module['_BinaryenSwitchGetNameAt']).map(p => UTF8ToString(p)), + 'defaultName': UTF8ToString(Module['_BinaryenSwitchGetDefaultName'](expression)), + 'condition': Module['_BinaryenSwitchGetCondition'](expression), + 'value': Module['_BinaryenSwitchGetValue'](expression) + } as SwitchInfo; + case Module['CallId']: + return { + 'id': id, + 'type': type, + 'isReturn': Boolean(Module['_BinaryenCallIsReturn'](expression)), + 'target': UTF8ToString(Module['_BinaryenCallGetTarget'](expression)), + 'operands': getAllNested(expression, Module[ '_BinaryenCallGetNumOperands'], Module['_BinaryenCallGetOperandAt']) + } as CallInfo; + case Module['CallIndirectId']: + return { + 'id': id, + 'type': type, + 'isReturn': Boolean(Module['_BinaryenCallIndirectIsReturn'](expression)), + 'target': Module['_BinaryenCallIndirectGetTarget'](expression), + 'table': Module['_BinaryenCallIndirectGetTable'](expression), + 'operands': getAllNested(expression, Module['_BinaryenCallIndirectGetNumOperands'], Module['_BinaryenCallIndirectGetOperandAt']) + } as CallIndirectInfo; + case Module['LocalGetId']: + return { + 'id': id, + 'type': type, + 'index': Module['_BinaryenLocalGetGetIndex'](expression) + } as LocalGetInfo; + case Module['LocalSetId']: + return { + 'id': id, + 'type': type, + 'isTee': Boolean(Module['_BinaryenLocalSetIsTee'](expression)), + 'index': Module['_BinaryenLocalSetGetIndex'](expression), + 'value': Module['_BinaryenLocalSetGetValue'](expression) + } as LocalSetInfo; + case Module['GlobalGetId']: + return { + 'id': id, + 'type': type, + 'name': UTF8ToString(Module['_BinaryenGlobalGetGetName'](expression)) + } as GlobalGetInfo; + case Module['GlobalSetId']: + return { + 'id': id, + 'type': type, + 'name': UTF8ToString(Module['_BinaryenGlobalSetGetName'](expression)), + 'value': Module['_BinaryenGlobalSetGetValue'](expression) + } as GlobalSetInfo; + case Module['TableGetId']: + return { + 'id': id, + 'type': type, + 'table': UTF8ToString(Module['_BinaryenTableGetGetTable'](expression)), + 'index': Module['_BinaryenTableGetGetIndex'](expression) + } as TableGetInfo; + case Module['TableSetId']: + return { + 'id': id, + 'type': type, + 'table': UTF8ToString(Module['_BinaryenTableSetGetTable'](expression)), + 'index': Module['_BinaryenTableSetGetIndex'](expression), + 'value': Module['_BinaryenTableSetGetValue'](expression) + } as TableSetInfo; + case Module['TableSizeId']: + return { + 'id': id, + 'type': type, + 'table': UTF8ToString(Module['_BinaryenTableSizeGetTable'](expression)), + } as TableSizeInfo; + case Module['TableGrowId']: + return { + 'id': id, + 'type': type, + 'table': UTF8ToString(Module['_BinaryenTableGrowGetTable'](expression)), + 'value': Module['_BinaryenTableGrowGetValue'](expression), + 'delta': Module['_BinaryenTableGrowGetDelta'](expression), + } as TableGrowInfo; + case Module['LoadId']: + return { + 'id': id, + 'type': type, + 'isAtomic': Boolean(Module['_BinaryenLoadIsAtomic'](expression)), + 'isSigned': Boolean(Module['_BinaryenLoadIsSigned'](expression)), + 'offset': Module['_BinaryenLoadGetOffset'](expression), + 'bytes': Module['_BinaryenLoadGetBytes'](expression), + 'align': Module['_BinaryenLoadGetAlign'](expression), + 'ptr': Module['_BinaryenLoadGetPtr'](expression) + } as LoadInfo; + case Module['StoreId']: + return { + 'id': id, + 'type': type, + 'isAtomic': Boolean(Module['_BinaryenStoreIsAtomic'](expression)), + 'offset': Module['_BinaryenStoreGetOffset'](expression), + 'bytes': Module['_BinaryenStoreGetBytes'](expression), + 'align': Module['_BinaryenStoreGetAlign'](expression), + 'ptr': Module['_BinaryenStoreGetPtr'](expression), + 'value': Module['_BinaryenStoreGetValue'](expression) + } as StoreInfo; + case Module['ConstId']: { + let value; + switch (type) { + case i32: + value = Module['_BinaryenConstGetValueI32'](expression); + break; + case i64: + value = { + 'low': Module['_BinaryenConstGetValueI64Low'](expression), + 'high': Module['_BinaryenConstGetValueI64High'](expression) + }; + break; + case f32: + value = Module['_BinaryenConstGetValueF32'](expression); + break; + case f64: + value = Module['_BinaryenConstGetValueF64'](expression); + break; + case v128: { + preserveStack(() => { + const tempBuffer = stackAlloc(16); + Module['_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 Module['UnaryId']: + return { + 'id': id, + 'type': type, + 'op': Module['_BinaryenUnaryGetOp'](expression), + 'value': Module['_BinaryenUnaryGetValue'](expression) + } as UnaryInfo; + case Module['BinaryId']: + return { + 'id': id, + 'type': type, + 'op': Module['_BinaryenBinaryGetOp'](expression), + 'left': Module['_BinaryenBinaryGetLeft'](expression), + 'right': Module['_BinaryenBinaryGetRight'](expression) + } as BinaryInfo; + case Module['SelectId']: + return { + 'id': id, + 'type': type, + 'ifTrue': Module['_BinaryenSelectGetIfTrue'](expression), + 'ifFalse': Module['_BinaryenSelectGetIfFalse'](expression), + 'condition': Module['_BinaryenSelectGetCondition'](expression) + } as SelectInfo; + case Module['DropId']: + return { + 'id': id, + 'type': type, + 'value': Module['_BinaryenDropGetValue'](expression) + } as DropInfo; + case Module['ReturnId']: + return { + 'id': id, + 'type': type, + 'value': Module['_BinaryenReturnGetValue'](expression) + } as ReturnInfo; + case Module['NopId']: + return { + 'id': id, + 'type': type + } as NopInfo; + case Module['UnreachableId']: + return { + 'id': id, + 'type': type + } as UnreachableInfo; + case Module['PopId']: + return { + 'id': id, + 'type': type + } as PopInfo; + case Module['MemorySizeId']: + return { + 'id': id, + 'type': type + } as MemorySizeInfo; + case Module['MemoryGrowId']: + return { + 'id': id, + 'type': type, + 'delta': Module['_BinaryenMemoryGrowGetDelta'](expression) + } as MemoryGrowInfo; + case Module['AtomicRMWId']: + return { + 'id': id, + 'type': type, + 'op': Module['_BinaryenAtomicRMWGetOp'](expression), + 'bytes': Module['_BinaryenAtomicRMWGetBytes'](expression), + 'offset': Module['_BinaryenAtomicRMWGetOffset'](expression), + 'ptr': Module['_BinaryenAtomicRMWGetPtr'](expression), + 'value': Module['_BinaryenAtomicRMWGetValue'](expression) + } as AtomicRMWInfo; + case Module['AtomicCmpxchgId']: + return { + 'id': id, + 'type': type, + 'bytes': Module['_BinaryenAtomicCmpxchgGetBytes'](expression), + 'offset': Module['_BinaryenAtomicCmpxchgGetOffset'](expression), + 'ptr': Module['_BinaryenAtomicCmpxchgGetPtr'](expression), + 'expected': Module['_BinaryenAtomicCmpxchgGetExpected'](expression), + 'replacement': Module['_BinaryenAtomicCmpxchgGetReplacement'](expression) + } as AtomicCmpxchgInfo; + case Module['AtomicWaitId']: + return { + 'id': id, + 'type': type, + 'ptr': Module['_BinaryenAtomicWaitGetPtr'](expression), + 'expected': Module['_BinaryenAtomicWaitGetExpected'](expression), + 'timeout': Module['_BinaryenAtomicWaitGetTimeout'](expression), + 'expectedType': Module['_BinaryenAtomicWaitGetExpectedType'](expression) + } as AtomicWaitInfo; + case Module['AtomicNotifyId']: + return { + 'id': id, + 'type': type, + 'ptr': Module['_BinaryenAtomicNotifyGetPtr'](expression), + 'notifyCount': Module['_BinaryenAtomicNotifyGetNotifyCount'](expression) + } as AtomicNotifyInfo; + case Module['AtomicFenceId']: + return { + 'id': id, + 'type': type, + 'order': Module['_BinaryenAtomicFenceGetOrder'](expression) + } as AtomicFenceInfo; + case Module['SIMDExtractId']: + return { + 'id': id, + 'type': type, + 'op': Module['_BinaryenSIMDExtractGetOp'](expression), + 'vec': Module['_BinaryenSIMDExtractGetVec'](expression), + 'index': Module['_BinaryenSIMDExtractGetIndex'](expression) + } as SIMDExtractInfo; + case Module['SIMDReplaceId']: + return { + 'id': id, + 'type': type, + 'op': Module['_BinaryenSIMDReplaceGetOp'](expression), + 'vec': Module['_BinaryenSIMDReplaceGetVec'](expression), + 'index': Module['_BinaryenSIMDReplaceGetIndex'](expression), + 'value': Module['_BinaryenSIMDReplaceGetValue'](expression) + } as SIMDReplaceInfo; + case Module['SIMDShuffleId']: + return preserveStack(() => { + const tempBuffer = stackAlloc(16); + Module['_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': Module['_BinaryenSIMDShuffleGetLeft'](expression), + 'right': Module['_BinaryenSIMDShuffleGetRight'](expression), + 'mask': mask + } as SIMDShuffleInfo; + }); + case Module['SIMDTernaryId']: + return { + 'id': id, + 'type': type, + 'op': Module['_BinaryenSIMDTernaryGetOp'](expression), + 'a': Module['_BinaryenSIMDTernaryGetA'](expression), + 'b': Module['_BinaryenSIMDTernaryGetB'](expression), + 'c': Module['_BinaryenSIMDTernaryGetC'](expression) + } as SIMDTernaryInfo; + case Module['SIMDShiftId']: + return { + 'id': id, + 'type': type, + 'op': Module['_BinaryenSIMDShiftGetOp'](expression), + 'vec': Module['_BinaryenSIMDShiftGetVec'](expression), + 'shift': Module['_BinaryenSIMDShiftGetShift'](expression) + } as SIMDShiftInfo; + case Module['SIMDLoadId']: + return { + 'id': id, + 'type': type, + 'op': Module['_BinaryenSIMDLoadGetOp'](expression), + 'offset': Module['_BinaryenSIMDLoadGetOffset'](expression), + 'align': Module['_BinaryenSIMDLoadGetAlign'](expression), + 'ptr': Module['_BinaryenSIMDLoadGetPtr'](expression) + } as SIMDLoadInfo; + case Module['SIMDLoadStoreLaneId']: + return { + 'id': id, + 'type': type, + 'op': Module['_BinaryenSIMDLoadStoreLaneGetOp'](expression), + 'offset': Module['_BinaryenSIMDLoadStoreLaneGetOffset'](expression), + 'align': Module['_BinaryenSIMDLoadStoreLaneGetAlign'](expression), + 'index': Module['_BinaryenSIMDLoadStoreLaneGetIndex'](expression), + 'ptr': Module['_BinaryenSIMDLoadStoreLaneGetPtr'](expression), + 'vec': Module['_BinaryenSIMDLoadStoreLaneGetVec'](expression) + } as SIMDLoadStoreLaneInfo; + case Module['MemoryInitId']: + return { + 'id': id, + 'type': type, + 'segment': UTF8ToString(Module['_BinaryenMemoryInitGetSegment'](expression)), + 'dest': Module['_BinaryenMemoryInitGetDest'](expression) as ExpressionRef, + 'offset': Module['_BinaryenMemoryInitGetOffset'](expression) as ExpressionRef, + 'size': Module['_BinaryenMemoryInitGetSize'](expression) as ExpressionRef + } as MemoryInitInfo; + case Module['DataDropId']: + return { + 'id': id, + 'type': type, + 'segment': UTF8ToString(Module['_BinaryenDataDropGetSegment'](expression)), + } as DataDropInfo; + case Module['MemoryCopyId']: + return { + 'id': id, + 'type': type, + 'dest': Module['_BinaryenMemoryCopyGetDest'](expression), + 'source': Module['_BinaryenMemoryCopyGetSource'](expression), + 'size': Module['_BinaryenMemoryCopyGetSize'](expression) + } as MemoryCopyInfo; + case Module['MemoryFillId']: + return { + 'id': id, + 'type': type, + 'dest': Module['_BinaryenMemoryFillGetDest'](expression), + 'value': Module['_BinaryenMemoryFillGetValue'](expression), + 'size': Module['_BinaryenMemoryFillGetSize'](expression) + } as MemoryFillInfo; + case Module['RefNullId']: + return { + 'id': id, + 'type': type + } as RefNullInfo; + case Module['RefIsNullId']: + return { + 'id': id, + 'type': type, + 'value': Module['_BinaryenRefIsNullGetValue'](expression) + } as RefIsNullInfo; + case Module['RefAsId']: + return { + 'id': id, + 'type': type, + 'op': Module['_BinaryenRefAsGetOp'](expression), + 'value': Module['_BinaryenRefAsGetValue'](expression) + } as RefAsInfo; + case Module['RefFuncId']: + return { + 'id': id, + 'type': type, + 'func': UTF8ToString(Module['_BinaryenRefFuncGetFunc'](expression)), + } as RefFuncInfo; + case Module['RefEqId']: + return { + 'id': id, + 'type': type, + 'left': Module['_BinaryenRefEqGetLeft'](expression), + 'right': Module['_BinaryenRefEqGetRight'](expression) + } as RefEqInfo; + case Module['TryId']: + return { + 'id': id, + 'type': type, + 'name': UTF8ToString(Module['_BinaryenTryGetName'](expression)), + 'body': Module['_BinaryenTryGetBody'](expression) as ExpressionRef, + 'catchTags': getAllNested(expression, Module['_BinaryenTryGetNumCatchTags'], Module['_BinaryenTryGetCatchTagAt']), + 'catchBodies': getAllNested(expression, Module['_BinaryenTryGetNumCatchBodies'], Module['_BinaryenTryGetCatchBodyAt']), + 'hasCatchAll': Module['_BinaryenTryHasCatchAll'](expression) as boolean, + 'delegateTarget': UTF8ToString(Module['_BinaryenTryGetDelegateTarget'](expression)) as string, + 'isDelegate': Module['_BinaryenTryIsDelegate'](expression) as boolean + } as TryInfo; + case Module['ThrowId']: + return { + 'id': id, + 'type': type, + 'tag': UTF8ToString(Module['_BinaryenThrowGetTag'](expression)), + 'operands': getAllNested(expression, Module['_BinaryenThrowGetNumOperands'], Module['_BinaryenThrowGetOperandAt']) + } as ThrowInfo; + case Module['RethrowId']: + return { + 'id': id, + 'type': type, + 'target': UTF8ToString(Module['_BinaryenRethrowGetTarget'](expression)) + } as RethrowInfo; + case Module['TupleMakeId']: + return { + 'id': id, + 'type': type, + 'operands': getAllNested(expression, Module['_BinaryenTupleMakeGetNumOperands'], Module['_BinaryenTupleMakeGetOperandAt']) + } as TupleMakeInfo; + case Module['TupleExtractId']: + return { + 'id': id, + 'type': type, + 'tuple': Module['_BinaryenTupleExtractGetTuple'](expression), + 'index': Module['_BinaryenTupleExtractGetIndex'](expression) + } as TupleExtractInfo; + case Module['RefI31Id']: + return { + 'id': id, + 'type': type, + 'value': Module['_BinaryenRefI31GetValue'](expression) + } as RefI31Info; + case Module['I31GetId']: + return { + 'id': id, + 'type': type, + 'i31': Module['_BinaryenI31GetGetI31'](expression), + 'isSigned': Boolean(Module['_BinaryenI31GetIsSigned'](expression)) + } as I31GetInfo; + default: + throw Error('unexpected id: ' + id); + } + } } From 0520e325f98b06c602c9939b5f62fc5a334ab24f Mon Sep 17 00:00:00 2001 From: Eric Vergnaud Date: Tue, 12 Dec 2023 09:45:36 +0100 Subject: [PATCH 16/38] reinstate deprecated methods --- src/ts/BREAKING_CHANGES.md | 14 -------------- src/ts/binaryen.ts | 14 ++++++++++++++ 2 files changed, 14 insertions(+), 14 deletions(-) delete mode 100644 src/ts/BREAKING_CHANGES.md diff --git a/src/ts/BREAKING_CHANGES.md b/src/ts/BREAKING_CHANGES.md deleted file mode 100644 index c2bbb889050..00000000000 --- a/src/ts/BREAKING_CHANGES.md +++ /dev/null @@ -1,14 +0,0 @@ -dropped ExpressionIds - -renamed i32.reinterpret to i32.reinterpret_f32 -renamed i32.wrap to i32.wrap_i64 - -renamed i64.reinterpret to i64.reinterpret_f64 - -renamed f32.reinterpret to f32.reinterpret_i32 -renamed f32.demote to f32.demote_f64 - -renamed f64.reinterpret to f64.reinterpret_i64 -renamed f64.promote to f64.promote_f32 - - diff --git a/src/ts/binaryen.ts b/src/ts/binaryen.ts index 5f00aaa60a1..2e425b19ca1 100644 --- a/src/ts/binaryen.ts +++ b/src/ts/binaryen.ts @@ -1019,9 +1019,13 @@ module binaryen { f32: (value: ExpressionRef) => unary(Operations.TruncSatUFloat32ToInt32, value), f64: (value: ExpressionRef) => unary(Operations.TruncSatUFloat64ToInt32, value) }, + /** @deprecated use reinterpret_f32 */ + reinterpret: (value: ExpressionRef) => unary(Operations.ReinterpretFloat32, value), reinterpret_f32: (value: ExpressionRef) => unary(Operations.ReinterpretFloat32, value), extend8_s: (value: ExpressionRef) => unary(Operations.ExtendS8Int32, value), extend16_s: (value: ExpressionRef) => unary(Operations.ExtendS16Int32, value), + /** @deprecated use wrap_i64 */ + wrap: (value: ExpressionRef) => unary(Operations.WrapInt64, value), wrap_i64: (value: ExpressionRef) => unary(Operations.WrapInt64, value), add: (left: ExpressionRef, right: ExpressionRef) => binary(Operations.AddInt32, left, right), sub: (left: ExpressionRef, right: ExpressionRef) => binary(Operations.SubInt32, left, right), @@ -1159,6 +1163,8 @@ module binaryen { f32: (value: ExpressionRef) => unary(Operations.TruncSatUFloat32ToInt64, value), f64: (value: ExpressionRef) => unary(Operations.TruncSatUFloat64ToInt64, value) }, + /** @deprecated use reinterpret_f64 */ + reinterpret: (value: ExpressionRef) => unary(Operations.ReinterpretFloat64, value), reinterpret_f64: (value: ExpressionRef) => unary(Operations.ReinterpretFloat64, value), extend8_s: (value: ExpressionRef) => unary(Operations.ExtendS8Int64, value), extend16_s: (value: ExpressionRef) => unary(Operations.ExtendS16Int64, value), @@ -1296,6 +1302,8 @@ module binaryen { trunc: (value: ExpressionRef) => unary(Operations.TruncFloat32, value), nearest: (value: ExpressionRef) => unary(Operations.NearestFloat32, value), sqrt: (value: ExpressionRef) => unary(Operations.SqrtFloat32, value), + /** @deprecated use reinterpret_i32 */ + reinterpret: (value: ExpressionRef) => unary(Operations.ReinterpretInt32, value), reinterpret_i32: (value: ExpressionRef) => unary(Operations.ReinterpretInt32, value), convert_s: { i32: (value: ExpressionRef) => unary(Operations.ConvertSInt32ToFloat32, value), @@ -1305,6 +1313,8 @@ module binaryen { i32: (value: ExpressionRef) => unary(Operations.ConvertUInt32ToFloat32, value), i64: (value: ExpressionRef) => unary(Operations.ConvertUInt64ToFloat32, value) }, + /** @deprecated use demote_f64 */ + demote: (value: ExpressionRef)=> unary(Operations.DemoteFloat64, value), demote_f64: (value: ExpressionRef)=> unary(Operations.DemoteFloat64, value), add: (left: ExpressionRef, right: ExpressionRef) => binary(Operations.AddFloat32, left, right), sub: (left: ExpressionRef, right: ExpressionRef) => binary(Operations.SubFloat32, left, right), @@ -1351,6 +1361,8 @@ module binaryen { trunc: (value: ExpressionRef) => unary(Operations.TruncFloat64, value), nearest: (value: ExpressionRef) => unary(Operations.NearestFloat64, value), sqrt: (value: ExpressionRef) => unary(Operations.SqrtFloat64, value), + /** @deprecated use reinterpret_i64 */ + reinterpret: (value: ExpressionRef) => unary(Operations.ReinterpretInt64, value), reinterpret_i64: (value: ExpressionRef) => unary(Operations.ReinterpretInt64, value), convert_s: { i32: (value: ExpressionRef) => unary(Operations.ConvertSInt32ToFloat64, value), @@ -1360,6 +1372,8 @@ module binaryen { i32: (value: ExpressionRef) => unary(Operations.ConvertUInt32ToFloat64, value), i64: (value: ExpressionRef) => unary(Operations.ConvertUInt64ToFloat64, value) }, + /** @deprecated use promote_f32 */ + promote: (value: ExpressionRef)=> unary(Operations.PromoteFloat32, value), promote_f32: (value: ExpressionRef)=> unary(Operations.PromoteFloat32, value), add: (left: ExpressionRef, right: ExpressionRef) => binary(Operations.AddFloat64, left, right), sub: (left: ExpressionRef, right: ExpressionRef) => binary(Operations.SubFloat64, left, right), From e370f1c43f065a284d3c243fd74b2e9f0b37aca5 Mon Sep 17 00:00:00 2001 From: Eric Vergnaud Date: Tue, 12 Dec 2023 12:31:53 +0100 Subject: [PATCH 17/38] fix return types --- src/ts/binaryen.ts | 1024 ++++++++++++++++++++++---------------------- 1 file changed, 512 insertions(+), 512 deletions(-) diff --git a/src/ts/binaryen.ts b/src/ts/binaryen.ts index 2e425b19ca1..6cef32d90b9 100644 --- a/src/ts/binaryen.ts +++ b/src/ts/binaryen.ts @@ -16,10 +16,11 @@ module binaryen { declare var allocateUTF8OnStack: (s: string) => number; declare var _BinaryenSizeofLiteral: () => number; declare var _BinaryenSizeofAllocateAndWriteResult: () => number; - declare var UTF8ToString: (ptr: number) => string; + declare var UTF8ToString: (ptr: number) => string | null; + const sizeOfLiteral = _BinaryenSizeofLiteral(); // avoid name clash with binaryen class Module - const JSModule = self["Module"] as {}; + const JSModule: object = self["Module"]; function preserveStack(func: () => R): R { try { @@ -64,37 +65,6 @@ module binaryen { export type RelooperBlockRef = number; export type ExpressionRunnerRef = number; - export interface SegmentInfo { - offset: ExpressionRef; - data: Uint8Array; - passive?: boolean; - } - - export interface MemoryInfo { - module: string | null; - base: string | null; - shared: boolean; - is64: boolean; - initial: number; - max?: number; - } - - 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 const none: Type = JSModule['_BinaryenTypeNone'](); export const i32: Type = JSModule['_BinaryenTypeInt32'](); export const i64: Type = JSModule['_BinaryenTypeInt64'](); @@ -116,6 +86,22 @@ module binaryen { 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'](), @@ -648,7 +634,7 @@ module binaryen { setDebugLocation(expr: ExpressionRef, fileIndex: number, lineNumber: number, columnNumber: number): void { JSModule['_BinaryenFunctionSetDebugLocation'](this.func, expr, fileIndex, lineNumber, columnNumber); } - getInfo() { + getInfo(): FunctionInfo { return { 'name': this.getName(), 'module': UTF8ToString(Module['_BinaryenFunctionImportGetModule'](this.func)), @@ -657,7 +643,7 @@ module binaryen { 'results': this.getResults(), 'vars': getAllNested(this.func, this.getNumVars, this.getVar), 'body':this.getBody() - } as FunctionInfo; + }; } }; @@ -830,7 +816,7 @@ module binaryen { ); } addDebugInfoFileName(filename: string): number { - return preserveStack(() => JSModule['_BinaryenModuleAddDebugInfoFileName'](this.ptr, strToStack(filename))) as number; + return preserveStack(() => JSModule['_BinaryenModuleAddDebugInfoFileName'](this.ptr, strToStack(filename))); } getDebugInfoFileName(index: number): string | null { return UTF8ToString(JSModule['_BinaryenModuleGetDebugInfoFileName'](this.ptr, index)); @@ -972,495 +958,495 @@ module binaryen { } get i32 () { const unary = (op: Operations, value: ExpressionRef) => - JSModule['_BinaryenUnary'](this.ptr, op, value) as ExpressionRef; + JSModule['_BinaryenUnary'](this.ptr, op, value); const binary = (op: Operations, left: ExpressionRef, right: ExpressionRef) => - JSModule['_BinaryenBinary'](this.ptr, op, left, right) as 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)) as ExpressionRef; + 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)) as ExpressionRef; + 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)) as ExpressionRef; + 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)) as ExpressionRef; + 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)) as ExpressionRef; + JSModule['_BinaryenAtomicRMW'](this.ptr, op, size, offset, ptr, value, i32, strToStack(name)); return { - load: (offset: number, align: number, ptr: ExpressionRef, name?: string) => load(4, true, offset, align, ptr, name) as ExpressionRef, - load8_s: (offset: number, align: number, ptr: ExpressionRef, name?: string) => load(1, true, offset, align, ptr, name) as ExpressionRef, - load8_u: (offset: number, align: number, ptr: ExpressionRef, name?: string) => load(1, false, offset, align, ptr, name) as ExpressionRef, - load16_s: (offset: number, align: number, ptr: ExpressionRef, name?: string) => load(2, true, offset, align, ptr, name) as ExpressionRef, - load16_u: (offset: number, align: number, ptr: ExpressionRef, name?: string) => load(2, false, offset, align, ptr, name) as ExpressionRef, - store: (offset: number, align: number, ptr: ExpressionRef, value: ExpressionRef, name?: string) => store(4, offset, align, ptr, value, name) as ExpressionRef, - store8: (offset: number, align: number, ptr: ExpressionRef, value: ExpressionRef, name?: string) => store(1, offset, align, ptr, value, name) as ExpressionRef, - store16: (offset: number, align: number, ptr: ExpressionRef, value: ExpressionRef, name?: string) => store(2, offset, align, ptr, value, name) as ExpressionRef, - const: (value: number) => preserveStack(() => { + 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) => unary(Operations.ClzInt32, value), - ctz: (value: ExpressionRef) => unary(Operations.CtzInt32, value), - popcnt: (value: ExpressionRef) => unary(Operations.PopcntInt32, value), - eqz: (value: ExpressionRef) => unary(Operations.EqZInt32, value), + 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) => unary(Operations.TruncSFloat32ToInt32, value), - f64: (value: ExpressionRef) => unary(Operations.TruncSFloat64ToInt32, value) + f32: (value: ExpressionRef): ExpressionRef => unary(Operations.TruncSFloat32ToInt32, value), + f64: (value: ExpressionRef): ExpressionRef => unary(Operations.TruncSFloat64ToInt32, value) }, trunc_u: { - f32: (value: ExpressionRef) => unary(Operations.TruncUFloat32ToInt32, value), - f64: (value: ExpressionRef) => unary(Operations.TruncUFloat64ToInt32, value) + f32: (value: ExpressionRef): ExpressionRef => unary(Operations.TruncUFloat32ToInt32, value), + f64: (value: ExpressionRef): ExpressionRef => unary(Operations.TruncUFloat64ToInt32, value) }, trunc_s_sat: { - f32: (value: ExpressionRef) => unary(Operations.TruncSatSFloat32ToInt32, value), - f64: (value: ExpressionRef) => unary(Operations.TruncSatSFloat64ToInt32, value) + f32: (value: ExpressionRef): ExpressionRef => unary(Operations.TruncSatSFloat32ToInt32, value), + f64: (value: ExpressionRef): ExpressionRef => unary(Operations.TruncSatSFloat64ToInt32, value) }, trunc_u_sat: { - f32: (value: ExpressionRef) => unary(Operations.TruncSatUFloat32ToInt32, value), - f64: (value: ExpressionRef) => unary(Operations.TruncSatUFloat64ToInt32, value) + f32: (value: ExpressionRef): ExpressionRef => unary(Operations.TruncSatUFloat32ToInt32, value), + f64: (value: ExpressionRef): ExpressionRef => unary(Operations.TruncSatUFloat64ToInt32, value) }, /** @deprecated use reinterpret_f32 */ - reinterpret: (value: ExpressionRef) => unary(Operations.ReinterpretFloat32, value), - reinterpret_f32: (value: ExpressionRef) => unary(Operations.ReinterpretFloat32, value), - extend8_s: (value: ExpressionRef) => unary(Operations.ExtendS8Int32, value), - extend16_s: (value: ExpressionRef) => unary(Operations.ExtendS16Int32, value), + reinterpret: (value: ExpressionRef): ExpressionRef => unary(Operations.ReinterpretFloat32, 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), /** @deprecated use wrap_i64 */ - wrap: (value: ExpressionRef) => unary(Operations.WrapInt64, value), - wrap_i64: (value: ExpressionRef) => unary(Operations.WrapInt64, value), - add: (left: ExpressionRef, right: ExpressionRef) => binary(Operations.AddInt32, left, right), - sub: (left: ExpressionRef, right: ExpressionRef) => binary(Operations.SubInt32, left, right), - mul: (left: ExpressionRef, right: ExpressionRef) => binary(Operations.MulInt32, left, right), - div_s: (left: ExpressionRef, right: ExpressionRef) => binary(Operations.DivSInt32, left, right), - div_u: (left: ExpressionRef, right: ExpressionRef) => binary(Operations.DivUInt32, left, right), - rem_s: (left: ExpressionRef, right: ExpressionRef) => binary(Operations.RemSInt32, left, right), - rem_u: (left: ExpressionRef, right: ExpressionRef) => binary(Operations.RemUInt32, left, right), - and: (left: ExpressionRef, right: ExpressionRef) => binary(Operations.AndInt32, left, right), - or: (left: ExpressionRef, right: ExpressionRef) => binary(Operations.OrInt32, left, right), - xor: (left: ExpressionRef, right: ExpressionRef) => binary(Operations.XorInt32, left, right), - shl: (left: ExpressionRef, right: ExpressionRef) => binary(Operations.ShlInt32, left, right), - shr_u: (left: ExpressionRef, right: ExpressionRef) => binary(Operations.ShrUInt32, left, right), - shr_s: (left: ExpressionRef, right: ExpressionRef) => binary(Operations.ShrSInt32, left, right), - rotl: (left: ExpressionRef, right: ExpressionRef) => binary(Operations.RotLInt32, left, right), - rotr: (left: ExpressionRef, right: ExpressionRef) => binary(Operations.RotRInt32, left, right), - eq: (left: ExpressionRef, right: ExpressionRef) => binary(Operations.EqInt32, left, right), - ne: (left: ExpressionRef, right: ExpressionRef) => binary(Operations.NeInt32, left, right), - lt_s: (left: ExpressionRef, right: ExpressionRef) => binary(Operations.LtSInt32, left, right), - lt_u: (left: ExpressionRef, right: ExpressionRef) => binary(Operations.LtUInt32, left, right), - le_s: (left: ExpressionRef, right: ExpressionRef) => binary(Operations.LeSInt32, left, right), - le_u: (left: ExpressionRef, right: ExpressionRef) => binary(Operations.LeUInt32, left, right), - gt_s: (left: ExpressionRef, right: ExpressionRef) => binary(Operations.GtSInt32, left, right), - gt_u: (left: ExpressionRef, right: ExpressionRef) => binary(Operations.GtUInt32, left, right), - ge_s: (left: ExpressionRef, right: ExpressionRef) => binary(Operations.GeSInt32, left, right), - ge_u: (left: ExpressionRef, right: ExpressionRef) => binary(Operations.GeUInt32, left, right), - pop: () => JSModule['_BinaryenPop'](this.ptr, i32) as ExpressionRef, + wrap: (value: ExpressionRef): ExpressionRef => unary(Operations.WrapInt64, 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) => atomic_load(4, offset, ptr, name), - load8_u: (offset: number, ptr: ExpressionRef, name?: string) => atomic_load(1, offset, ptr, name), - load16_u: (offset: number, ptr: ExpressionRef, name?: string) => atomic_load(2, offset, ptr, name), - store: (offset: number, ptr: ExpressionRef, value: ExpressionRef, name?: string) => atomic_store(4, offset, ptr, value, name), - store8: (offset: number, ptr: ExpressionRef, value: ExpressionRef, name?: string) => atomic_store(1, offset, ptr, value, name), - store16: (offset: number, ptr: ExpressionRef, value: ExpressionRef, name?: string) => atomic_store(2, offset, ptr, value, name), + 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) => + 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) => + 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) => + 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) => + 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) => + 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) => + 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) => - JSModule['_BinaryenAtomicCmpxchg'](this.ptr, 4, offset, ptr, expected, replacement, i32, strToStack(name)) as ExpressionRef + 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) => + 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) => + 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) => + 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) => + 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) => + 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) => + 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) => - JSModule['_BinaryenAtomicCmpxchg'](this.ptr, 1, offset, ptr, expected, replacement, i32, strToStack(name)) as ExpressionRef + 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) => + 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) => + 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) => + 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) => + 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) => + 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) => + 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) => - JSModule['_BinaryenAtomicCmpxchg'](this.ptr, 2, offset, ptr, expected, replacement, i32, strToStack(name)) as ExpressionRef + 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) as ExpressionRef; + JSModule['_BinaryenUnary'](this.ptr, op, value); const binary = (op: Operations, left: ExpressionRef, right: ExpressionRef) => - JSModule['_BinaryenBinary'](this.ptr, op, left, right) as ExpressionRef; - const load = (size: number, signed: boolean, offset: number, align: number, ptr: ExpressionRef, name: string) => - JSModule['_BinaryenLoad'](this.ptr, size, signed, offset, align, i64, ptr, strToStack(name)) as 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)) as ExpressionRef; + 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)) as ExpressionRef; + 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)) as ExpressionRef; + 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)) as ExpressionRef; + JSModule['_BinaryenAtomicRMW'](this.ptr, op, size, offset, ptr, value, i64, strToStack(name)); return { - load: (offset: number, align: number, ptr: ExpressionRef, name?: string) => load(8, true, offset, align, ptr, name) as ExpressionRef, - load8_s: (offset: number, align: number, ptr: ExpressionRef, name?: string) => load(1, true, offset, align, ptr, name) as ExpressionRef, - load8_u: (offset: number, align: number, ptr: ExpressionRef, name?: string) => load(1, false, offset, align, ptr, name) as ExpressionRef, - load16_s: (offset: number, align: number, ptr: ExpressionRef, name?: string) => load(2, true, offset, align, ptr, name) as ExpressionRef, - load16_u: (offset: number, align: number, ptr: ExpressionRef, name?: string) => load(2, false, offset, align, ptr, name) as ExpressionRef, - load32_s: (offset: number, align: number, ptr: ExpressionRef, name?: string) => load(4, true, offset, align, ptr, name) as ExpressionRef, - load32_u: (offset: number, align: number, ptr: ExpressionRef, name?: string) => load(4, false, offset, align, ptr, name) as ExpressionRef, - store: (offset: number, align: number, ptr: ExpressionRef, value: ExpressionRef, name?: string) => store(4, offset, align, ptr, value, name) as ExpressionRef, - store8: (offset: number, align: number, ptr: ExpressionRef, value: ExpressionRef, name?: string) => store(1, offset, align, ptr, value, name) as ExpressionRef, - store16: (offset: number, align: number, ptr: ExpressionRef, value: ExpressionRef, name?: string) => store(2, offset, align, ptr, value, name) as ExpressionRef, - store32: (offset: number, align: number, ptr: ExpressionRef, value: ExpressionRef, name?: string) => store(4, offset, align, ptr, value, name) as ExpressionRef, - const: (low: number, high: number) => preserveStack(() => { + 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) => unary(Operations.ClzInt64, value), - ctz: (value: ExpressionRef) => unary(Operations.CtzInt64, value), - popcnt: (value: ExpressionRef) => unary(Operations.PopcntInt64, value), - eqz: (value: ExpressionRef) => unary(Operations.EqZInt64, value), + 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) => unary(Operations.TruncSFloat32ToInt64, value), - f64: (value: ExpressionRef) => unary(Operations.TruncSFloat64ToInt64, value) + f32: (value: ExpressionRef): ExpressionRef => unary(Operations.TruncSFloat32ToInt64, value), + f64: (value: ExpressionRef): ExpressionRef => unary(Operations.TruncSFloat64ToInt64, value) }, trunc_u: { - f32: (value: ExpressionRef) => unary(Operations.TruncUFloat32ToInt64, value), - f64: (value: ExpressionRef) => unary(Operations.TruncUFloat64ToInt64, value) + f32: (value: ExpressionRef): ExpressionRef => unary(Operations.TruncUFloat32ToInt64, value), + f64: (value: ExpressionRef): ExpressionRef => unary(Operations.TruncUFloat64ToInt64, value) }, trunc_s_sat: { - f32: (value: ExpressionRef) => unary(Operations.TruncSatSFloat32ToInt64, value), - f64: (value: ExpressionRef) => unary(Operations.TruncSatSFloat64ToInt64, value) + f32: (value: ExpressionRef): ExpressionRef => unary(Operations.TruncSatSFloat32ToInt64, value), + f64: (value: ExpressionRef): ExpressionRef => unary(Operations.TruncSatSFloat64ToInt64, value) }, trunc_u_sat: { - f32: (value: ExpressionRef) => unary(Operations.TruncSatUFloat32ToInt64, value), - f64: (value: ExpressionRef) => unary(Operations.TruncSatUFloat64ToInt64, value) + f32: (value: ExpressionRef): ExpressionRef => unary(Operations.TruncSatUFloat32ToInt64, value), + f64: (value: ExpressionRef): ExpressionRef => unary(Operations.TruncSatUFloat64ToInt64, value) }, /** @deprecated use reinterpret_f64 */ - reinterpret: (value: ExpressionRef) => unary(Operations.ReinterpretFloat64, value), - reinterpret_f64: (value: ExpressionRef) => unary(Operations.ReinterpretFloat64, value), - extend8_s: (value: ExpressionRef) => unary(Operations.ExtendS8Int64, value), - extend16_s: (value: ExpressionRef) => unary(Operations.ExtendS16Int64, value), - extend32_s: (value: ExpressionRef) => unary(Operations.ExtendS32Int64, value), - extend_s: (value: ExpressionRef) => unary(Operations.ExtendSInt32, value), - extend_u: (value: ExpressionRef) => unary(Operations.ExtendUInt32, value), - add: (left: ExpressionRef, right: ExpressionRef) => binary(Operations.AddInt64, left, right), - sub: (left: ExpressionRef, right: ExpressionRef) => binary(Operations.SubInt64, left, right), - mul: (left: ExpressionRef, right: ExpressionRef) => binary(Operations.MulInt32, left, right), - div_s: (left: ExpressionRef, right: ExpressionRef) => binary(Operations.DivSInt64, left, right), - div_u: (left: ExpressionRef, right: ExpressionRef) => binary(Operations.DivUInt64, left, right), - rem_s: (left: ExpressionRef, right: ExpressionRef) => binary(Operations.RemSInt64, left, right), - rem_u: (left: ExpressionRef, right: ExpressionRef) => binary(Operations.RemUInt64, left, right), - and: (left: ExpressionRef, right: ExpressionRef) => binary(Operations.AndInt64, left, right), - or: (left: ExpressionRef, right: ExpressionRef) => binary(Operations.OrInt64, left, right), - xor: (left: ExpressionRef, right: ExpressionRef) => binary(Operations.XorInt64, left, right), - shl: (left: ExpressionRef, right: ExpressionRef) => binary(Operations.ShlInt64, left, right), - shr_u: (left: ExpressionRef, right: ExpressionRef) => binary(Operations.ShrUInt64, left, right), - shr_s: (left: ExpressionRef, right: ExpressionRef) => binary(Operations.ShrSInt64, left, right), - rotl: (left: ExpressionRef, right: ExpressionRef) => binary(Operations.RotLInt64, left, right), - rotr: (left: ExpressionRef, right: ExpressionRef) => binary(Operations.RotRInt64, left, right), - eq: (left: ExpressionRef, right: ExpressionRef) => binary(Operations.EqInt64, left, right), - ne: (left: ExpressionRef, right: ExpressionRef) => binary(Operations.NeInt64, left, right), - lt_s: (left: ExpressionRef, right: ExpressionRef) => binary(Operations.LtSInt64, left, right), - lt_u: (left: ExpressionRef, right: ExpressionRef) => binary(Operations.LtUInt64, left, right), - le_s: (left: ExpressionRef, right: ExpressionRef) => binary(Operations.LeSInt64, left, right), - le_u: (left: ExpressionRef, right: ExpressionRef) => binary(Operations.LeUInt64, left, right), - gt_s: (left: ExpressionRef, right: ExpressionRef) => binary(Operations.GtSInt64, left, right), - gt_u: (left: ExpressionRef, right: ExpressionRef) => binary(Operations.GtUInt64, left, right), - ge_s: (left: ExpressionRef, right: ExpressionRef) => binary(Operations.GeSInt64, left, right), - ge_u: (left: ExpressionRef, right: ExpressionRef) => binary(Operations.GeUInt64, left, right), - pop: () => JSModule['_BinaryenPop'](this.ptr, i64) as ExpressionRef, + reinterpret: (value: ExpressionRef): ExpressionRef => unary(Operations.ReinterpretFloat64, 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) => atomic_load(8, offset, ptr, name), - load8_u: (offset: number, ptr: ExpressionRef, name?: string) => atomic_load(1, offset, ptr, name), - load16_u: (offset: number, ptr: ExpressionRef, name?: string) => atomic_load(2, offset, ptr, name), - load32_u: (offset: number, ptr: ExpressionRef, name?: string) => atomic_load(4, offset, ptr, name), - store: (offset: number, ptr: ExpressionRef, value: ExpressionRef, name?: string) => atomic_store(4, offset, ptr, value, name), - store8: (offset: number, ptr: ExpressionRef, value: ExpressionRef, name?: string) => atomic_store(1, offset, ptr, value, name), - store16: (offset: number, ptr: ExpressionRef, value: ExpressionRef, name?: string) => atomic_store(2, offset, ptr, value, name), - store32: (offset: number, ptr: ExpressionRef, value: ExpressionRef, name?: string) => atomic_store(4, offset, ptr, value, name), + 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) => + 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) => + 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) => + 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) => + 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) => + 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) => + 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) => - JSModule['_BinaryenAtomicCmpxchg'](this.ptr, 8, offset, ptr, expected, replacement, i64, strToStack(name)) as ExpressionRef + 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) => + 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) => + 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) => + 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) => + 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) => + 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) => + 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) => - JSModule['_BinaryenAtomicCmpxchg'](this.ptr, 1, offset, ptr, expected, replacement, i64, strToStack(name)) as ExpressionRef + 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) => + 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) => + 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) => + 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) => + 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) => + 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) => + 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) => - JSModule['_BinaryenAtomicCmpxchg'](this.ptr, 2, offset, ptr, expected, replacement, i32, strToStack(name)) as ExpressionRef + 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) => + 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) => + 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) => + 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) => + 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) => + 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) => + 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) => - JSModule['_BinaryenAtomicCmpxchg'](this.ptr, 4, offset, ptr, expected, replacement, i32, strToStack(name)) as ExpressionRef + 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) as ExpressionRef; + JSModule['_BinaryenUnary'](this.ptr, op, value); const binary = (op: Operations, left: ExpressionRef, right: ExpressionRef) => - JSModule['_BinaryenBinary'](this.ptr, op, left, right) as ExpressionRef; + JSModule['_BinaryenBinary'](this.ptr, op, left, right); return { - load: (offset: number, align: number, ptr: ExpressionRef, name?: string) => - Module['_BinaryenLoad'](this.ptr, 4, true, offset, align, f32, ptr, strToStack(name)) as ExpressionRef, - store: (offset: number, align: number, ptr: ExpressionRef, value: ExpressionRef, name?: string) => - Module['_BinaryenStore'](this.ptr, 4, offset, align, ptr, value, f32, strToStack(name)) as ExpressionRef, - const: (value: number) => + load: (offset: number, align: number, ptr: ExpressionRef, name?: string): ExpressionRef => + Module['_BinaryenLoad'](this.ptr, 4, true, offset, align, f32, ptr, strToStack(name)), + store: (offset: number, align: number, ptr: ExpressionRef, value: ExpressionRef, name?: string): ExpressionRef => + Module['_BinaryenStore'](this.ptr, 4, offset, align, ptr, value, f32, strToStack(name)), + const: (value: number): ExpressionRef => preserveStack(() => { const tempLiteral = stackAlloc(sizeOfLiteral); Module['_BinaryenLiteralFloat32'](tempLiteral, value); return Module['_BinaryenConst'](this.ptr, tempLiteral); - }) as ExpressionRef, - const_bits: (value: number) => + }), + const_bits: (value: number): ExpressionRef => preserveStack(() => { const tempLiteral = stackAlloc(sizeOfLiteral); Module['_BinaryenLiteralFloat32Bits'](tempLiteral, value); return Module['_BinaryenConst'](this.ptr, tempLiteral); - }) as ExpressionRef, - neg: (value: ExpressionRef) => unary(Operations.NegFloat32, value), - abs: (value: ExpressionRef) => unary(Operations.AbsFloat32, value), - ceil: (value: ExpressionRef) => unary(Operations.CeilFloat32, value), - floor: (value: ExpressionRef) => unary(Operations.FloorFloat32, value), - trunc: (value: ExpressionRef) => unary(Operations.TruncFloat32, value), - nearest: (value: ExpressionRef) => unary(Operations.NearestFloat32, value), - sqrt: (value: ExpressionRef) => unary(Operations.SqrtFloat32, value), + }), + 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), /** @deprecated use reinterpret_i32 */ - reinterpret: (value: ExpressionRef) => unary(Operations.ReinterpretInt32, value), - reinterpret_i32: (value: ExpressionRef) => unary(Operations.ReinterpretInt32, value), + reinterpret: (value: ExpressionRef): ExpressionRef => unary(Operations.ReinterpretInt32, value), + reinterpret_i32: (value: ExpressionRef): ExpressionRef => unary(Operations.ReinterpretInt32, value), convert_s: { - i32: (value: ExpressionRef) => unary(Operations.ConvertSInt32ToFloat32, value), - i64: (value: ExpressionRef) => unary(Operations.ConvertSInt64ToFloat32, value) + i32: (value: ExpressionRef): ExpressionRef => unary(Operations.ConvertSInt32ToFloat32, value), + i64: (value: ExpressionRef): ExpressionRef => unary(Operations.ConvertSInt64ToFloat32, value) }, convert_u: { - i32: (value: ExpressionRef) => unary(Operations.ConvertUInt32ToFloat32, value), - i64: (value: ExpressionRef) => unary(Operations.ConvertUInt64ToFloat32, value) + i32: (value: ExpressionRef): ExpressionRef => unary(Operations.ConvertUInt32ToFloat32, value), + i64: (value: ExpressionRef): ExpressionRef => unary(Operations.ConvertUInt64ToFloat32, value) }, /** @deprecated use demote_f64 */ - demote: (value: ExpressionRef)=> unary(Operations.DemoteFloat64, value), - demote_f64: (value: ExpressionRef)=> unary(Operations.DemoteFloat64, value), - add: (left: ExpressionRef, right: ExpressionRef) => binary(Operations.AddFloat32, left, right), - sub: (left: ExpressionRef, right: ExpressionRef) => binary(Operations.SubFloat32, left, right), - mul: (left: ExpressionRef, right: ExpressionRef) => binary(Operations.MulFloat32, left, right), - div: (left: ExpressionRef, right: ExpressionRef) => binary(Operations.DivFloat32, left, right), - copysign: (left: ExpressionRef, right: ExpressionRef) => binary(Operations.CopySignFloat32, left, right), - min: (left: ExpressionRef, right: ExpressionRef) => binary(Operations.MinFloat32, left, right), - max: (left: ExpressionRef, right: ExpressionRef) => binary(Operations.MaxFloat32, left, right), - eq: (left: ExpressionRef, right: ExpressionRef) => binary(Operations.EqFloat32, left, right), - ne: (left: ExpressionRef, right: ExpressionRef) => binary(Operations.NeFloat32, left, right), - lt: (left: ExpressionRef, right: ExpressionRef) => binary(Operations.LtFloat32, left, right), - le: (left: ExpressionRef, right: ExpressionRef) => binary(Operations.LeFloat32, left, right), - gt: (left: ExpressionRef, right: ExpressionRef) => binary(Operations.GtFloat32, left, right), - ge: (left: ExpressionRef, right: ExpressionRef) => binary(Operations.GeFloat32, left, right), - pop: () => JSModule['_BinaryenPop'](this.ptr, f32) as ExpressionRef + demote: (value: ExpressionRef): ExpressionRef => unary(Operations.DemoteFloat64, 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) as ExpressionRef; + JSModule['_BinaryenUnary'](this.ptr, op, value); const binary = (op: Operations, left: ExpressionRef, right: ExpressionRef) => - JSModule['_BinaryenBinary'](this.ptr, op, left, right) as ExpressionRef; + JSModule['_BinaryenBinary'](this.ptr, op, left, right); return { - load: (offset: number, align: number, ptr: ExpressionRef, name?: string) => - Module['_BinaryenLoad'](this.ptr, 8, true, offset, align, f64, ptr, strToStack(name)) as ExpressionRef, - store: (offset: number, align: number, ptr: ExpressionRef, value: ExpressionRef, name?: string) => - Module['_BinaryenStore'](this.ptr, 8, offset, align, ptr, value, f64, strToStack(name)) as ExpressionRef, - const: (value: number) => + load: (offset: number, align: number, ptr: ExpressionRef, name?: string): ExpressionRef => + Module['_BinaryenLoad'](this.ptr, 8, true, offset, align, f64, ptr, strToStack(name)), + store: (offset: number, align: number, ptr: ExpressionRef, value: ExpressionRef, name?: string): ExpressionRef => + Module['_BinaryenStore'](this.ptr, 8, offset, align, ptr, value, f64, strToStack(name)), + const: (value: number): ExpressionRef => preserveStack(() => { const tempLiteral = stackAlloc(sizeOfLiteral); Module['_BinaryenLiteralFloat64'](tempLiteral, value); return Module['_BinaryenConst'](this.ptr, tempLiteral); - }) as ExpressionRef, - const_bits: (value: number) => + }), + const_bits: (value: number): ExpressionRef => preserveStack(() => { const tempLiteral = stackAlloc(sizeOfLiteral); Module['_BinaryenLiteralFloat64Bits'](tempLiteral, value); return Module['_BinaryenConst'](this.ptr, tempLiteral); - }) as ExpressionRef, - neg: (value: ExpressionRef) => unary(Operations.NegFloat64, value), - abs: (value: ExpressionRef) => unary(Operations.AbsFloat64, value), - ceil: (value: ExpressionRef) => unary(Operations.CeilFloat64, value), - floor: (value: ExpressionRef) => unary(Operations.FloorFloat64, value), - trunc: (value: ExpressionRef) => unary(Operations.TruncFloat64, value), - nearest: (value: ExpressionRef) => unary(Operations.NearestFloat64, value), - sqrt: (value: ExpressionRef) => unary(Operations.SqrtFloat64, value), + }), + 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), /** @deprecated use reinterpret_i64 */ - reinterpret: (value: ExpressionRef) => unary(Operations.ReinterpretInt64, value), - reinterpret_i64: (value: ExpressionRef) => unary(Operations.ReinterpretInt64, value), + reinterpret: (value: ExpressionRef): ExpressionRef => unary(Operations.ReinterpretInt64, value), + reinterpret_i64: (value: ExpressionRef): ExpressionRef => unary(Operations.ReinterpretInt64, value), convert_s: { - i32: (value: ExpressionRef) => unary(Operations.ConvertSInt32ToFloat64, value), - i64: (value: ExpressionRef) => unary(Operations.ConvertSInt64ToFloat64, value) + i32: (value: ExpressionRef): ExpressionRef => unary(Operations.ConvertSInt32ToFloat64, value), + i64: (value: ExpressionRef): ExpressionRef => unary(Operations.ConvertSInt64ToFloat64, value) }, convert_u: { - i32: (value: ExpressionRef) => unary(Operations.ConvertUInt32ToFloat64, value), - i64: (value: ExpressionRef) => unary(Operations.ConvertUInt64ToFloat64, value) + i32: (value: ExpressionRef): ExpressionRef => unary(Operations.ConvertUInt32ToFloat64, value), + i64: (value: ExpressionRef): ExpressionRef => unary(Operations.ConvertUInt64ToFloat64, value) }, /** @deprecated use promote_f32 */ - promote: (value: ExpressionRef)=> unary(Operations.PromoteFloat32, value), - promote_f32: (value: ExpressionRef)=> unary(Operations.PromoteFloat32, value), - add: (left: ExpressionRef, right: ExpressionRef) => binary(Operations.AddFloat64, left, right), - sub: (left: ExpressionRef, right: ExpressionRef) => binary(Operations.SubFloat64, left, right), - mul: (left: ExpressionRef, right: ExpressionRef) => binary(Operations.MulFloat64, left, right), - div: (left: ExpressionRef, right: ExpressionRef) => binary(Operations.DivFloat64, left, right), - copysign: (left: ExpressionRef, right: ExpressionRef) => binary(Operations.CopySignFloat64, left, right), - min: (left: ExpressionRef, right: ExpressionRef) => binary(Operations.MinFloat64, left, right), - max: (left: ExpressionRef, right: ExpressionRef) => binary(Operations.MaxFloat64, left, right), - eq: (left: ExpressionRef, right: ExpressionRef) => binary(Operations.EqFloat64, left, right), - ne: (left: ExpressionRef, right: ExpressionRef) => binary(Operations.NeFloat64, left, right), - lt: (left: ExpressionRef, right: ExpressionRef) => binary(Operations.LtFloat64, left, right), - le: (left: ExpressionRef, right: ExpressionRef) => binary(Operations.LeFloat64, left, right), - gt: (left: ExpressionRef, right: ExpressionRef) => binary(Operations.GtFloat64, left, right), - ge: (left: ExpressionRef, right: ExpressionRef) => binary(Operations.GeFloat64, left, right), - pop: () => JSModule['_BinaryenPop'](this.ptr, f64) as ExpressionRef + promote: (value: ExpressionRef): ExpressionRef => unary(Operations.PromoteFloat32, 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) => - JSModule['_BinaryenSIMDLoad'](this.ptr, op, offset, align, ptr, strToStack(name)) as ExpressionRef; - const simd_lane = (op: Operations, offset: number, align: number, index: number, ptr: ExpressionRef, vec: number, name: string) => - JSModule['_BinaryenSIMDLoadStoreLane'](this.ptr, op, offset, align, index, ptr, vec, strToStack(name)) as ExpressionRef; + 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) => - Module['_BinaryenLoad'](this.ptr, 16, false, offset, align, v128, ptr, strToStack(name)) as ExpressionRef, - load8_splat: (offset: number, align: number, ptr: ExpressionRef, name?: string) => + 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) => + 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) => + 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) => + 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) => + 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) => + 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) => + 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) => + 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) => + 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) => + 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) => + 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) => + 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) => + 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) => + 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) => + 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) => + 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) => + 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) => + 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) => + 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) => + 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) => + 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) => { + const: (i8s: ArrayLike): ExpressionRef => { const tempLiteral = stackAlloc(sizeOfLiteral); JSModule['_BinaryenLiteralVec128'](tempLiteral, i8sToStack(i8s)); - return JSModule['_BinaryenConst'](this.ptr, tempLiteral) as ExpressionRef; + return JSModule['_BinaryenConst'](this.ptr, tempLiteral); }, - not: (value: ExpressionRef) => JSModule['_BinaryenUnary'](this.ptr, Operations.NotVec128, value) as ExpressionRef, - any_true: (value: ExpressionRef) => JSModule['_BinaryenUnary'](this.ptr, Operations.AnyTrueVec128, value) as ExpressionRef, - and: (left: ExpressionRef, right: ExpressionRef) => JSModule['_BinaryenBinary'](this.ptr, Operations.AndVec128, left, right) as ExpressionRef, - or: (left: ExpressionRef, right: ExpressionRef) => JSModule['_BinaryenBinary'](this.ptr, Operations.OrVec128, left, right) as ExpressionRef, - xor: (left: ExpressionRef, right: ExpressionRef) => JSModule['_BinaryenBinary'](this.ptr, Operations.XorVec128, left, right) as ExpressionRef, - andnot: (left: ExpressionRef, right: ExpressionRef) => JSModule['_BinaryenBinary'](this.ptr, Operations.AndNotVec128, left, right) as ExpressionRef, - bitselect: (left: ExpressionRef, right: ExpressionRef, cond: ExpressionRef) => JSModule['_BinaryenBinary'](this.ptr, Operations.BitselectVec128, left, right) as ExpressionRef, - pop: () => JSModule['_BinaryenPop'](this.ptr, v128) as ExpressionRef + 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) as ExpressionRef; + JSModule['_BinaryenUnary'](this.ptr, op, value); const binary = (op: Operations, left: ExpressionRef, right: ExpressionRef) => - JSModule['_BinaryenBinary'](this.ptr, op, left, right) as 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))), @@ -1469,9 +1455,9 @@ module binaryen { splat: (value: ExpressionRef): ExpressionRef => unary(Operations.SplatVecI8x16, value), extract_lane_s: (vec: ExpressionRef, index: ExpressionRef): ExpressionRef => - JSModule['_BinaryenSIMDExtract'](this.ptr, Operations.ExtractLaneSVecI8x16, vec, index) as 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) as ExpressionRef, + JSModule['_BinaryenSIMDExtract'](this.ptr, Operations.ExtractLaneUVecI8x16, vec, index), replace_lane: (vec: ExpressionRef, index: ExpressionRef, value: ExpressionRef): ExpressionRef => JSModule['_BinaryenSIMDReplace'](this.ptr, Module['ReplaceLaneVecI8x16'], vec, index, value), eq: (left: ExpressionRef, right: ExpressionRef): ExpressionRef => @@ -1540,16 +1526,16 @@ module binaryen { } get i16x8 () { const unary = (op: Operations, value: ExpressionRef) => - JSModule['_BinaryenUnary'](this.ptr, op, value) as ExpressionRef; + JSModule['_BinaryenUnary'](this.ptr, op, value); const binary = (op: Operations, left: ExpressionRef, right: ExpressionRef) => - JSModule['_BinaryenBinary'](this.ptr, op, left, right) as 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) as 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) as 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 => @@ -1638,14 +1624,14 @@ module binaryen { } get i32x4 () { const unary = (op: Operations, value: ExpressionRef) => - JSModule['_BinaryenUnary'](this.ptr, op, value) as ExpressionRef; + JSModule['_BinaryenUnary'](this.ptr, op, value); const binary = (op: Operations, left: ExpressionRef, right: ExpressionRef) => - JSModule['_BinaryenBinary'](this.ptr, op, left, right) as 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) as 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 => @@ -1730,14 +1716,14 @@ module binaryen { } get i64x2 () { const unary = (op: Operations, value: ExpressionRef) => - JSModule['_BinaryenUnary'](this.ptr, op, value) as ExpressionRef; + JSModule['_BinaryenUnary'](this.ptr, op, value); const binary = (op: Operations, left: ExpressionRef, right: ExpressionRef) => - JSModule['_BinaryenBinary'](this.ptr, op, left, right) as 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) as 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 => @@ -1792,14 +1778,14 @@ module binaryen { } get f32x4 () { const unary = (op: Operations, value: ExpressionRef) => - JSModule['_BinaryenUnary'](this.ptr, op, value) as ExpressionRef; + JSModule['_BinaryenUnary'](this.ptr, op, value); const binary = (op: Operations, left: ExpressionRef, right: ExpressionRef) => - JSModule['_BinaryenBinary'](this.ptr, op, left, right) as 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) as 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 => @@ -1854,14 +1840,14 @@ module binaryen { } get f64x2 () { const unary = (op: Operations, value: ExpressionRef) => - JSModule['_BinaryenUnary'](this.ptr, op, value) as ExpressionRef; + JSModule['_BinaryenUnary'](this.ptr, op, value); const binary = (op: Operations, left: ExpressionRef, right: ExpressionRef) => - JSModule['_BinaryenBinary'](this.ptr, op, left, right) as 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) as 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 => @@ -1916,134 +1902,134 @@ module binaryen { } get funcref() { return { - pop: () => JSModule['_BinaryenPop'](this.ptr, funcref) as ExpressionRef + pop: (): ExpressionRef => JSModule['_BinaryenPop'](this.ptr, funcref) }; } get externref() { return { - pop: () => JSModule['_BinaryenPop'](this.ptr, externref) as ExpressionRef + pop: (): ExpressionRef => JSModule['_BinaryenPop'](this.ptr, externref) }; } get anyref() { return { - pop: () => JSModule['_BinaryenPop'](this.ptr, anyref) as ExpressionRef + pop: (): ExpressionRef => JSModule['_BinaryenPop'](this.ptr, anyref) }; } get eqref() { return { - pop: () => JSModule['_BinaryenPop'](this.ptr, eqref) as ExpressionRef + pop: (): ExpressionRef => JSModule['_BinaryenPop'](this.ptr, eqref) }; } get i31ref() { return { - pop: () => JSModule['_BinaryenPop'](this.ptr, i31ref) as ExpressionRef + pop: (): ExpressionRef => JSModule['_BinaryenPop'](this.ptr, i31ref) }; } get structref() { return { - pop: () => JSModule['_BinaryenPop'](this.ptr, structref) as ExpressionRef + pop: (): ExpressionRef => JSModule['_BinaryenPop'](this.ptr, structref) }; } /* explicitly skipping string stuff until it's reprioritized get stringref() { return { - pop: () => JSModule['_BinaryenPop'](this.ptr, stringref) as ExpressionRef + pop: () => JSModule['_BinaryenPop'](this.ptr, stringref) } } get stringview_wtf8() { return { - pop: () => JSModule['_BinaryenPop'](this.ptr, stringview_wtf8) as ExpressionRef + pop: () => JSModule['_BinaryenPop'](this.ptr, stringview_wtf8) } } get stringview_wtf16() { return { - pop: () => JSModule['_BinaryenPop'](this.ptr, stringview_wtf16) as ExpressionRef + pop: () => JSModule['_BinaryenPop'](this.ptr, stringview_wtf16) } } get stringview_iter() { return { - pop: () => JSModule['_BinaryenPop'](this.ptr, stringview_iter) as ExpressionRef + pop: () => JSModule['_BinaryenPop'](this.ptr, stringview_iter) } } */ get ref() { return { - null: (type: Type) => JSModule['_BinaryenRefNull'](this.ptr, type) as ExpressionRef, - is_null: (value: ExpressionRef) => JSModule['_BinaryenRefIsNull'](this.ptr, value) as ExpressionRef, - i31: (value: ExpressionRef) => JSModule['_BinaryenRefI31'](this.ptr, value) as ExpressionRef, - func: (name: string, type: Type) => JSModule['_BinaryenRefFunc'](this.ptr, strToStack(name), type) as ExpressionRef, - eq: (left: ExpressionRef, right: ExpressionRef) => JSModule['_BinaryenRefEq'](this.ptr, left, right) as ExpressionRef, - as_non_null: (value: ExpressionRef) => JSModule['_BinaryenRefAs'](this.ptr, Operations.RefAsNonNull, value) as ExpressionRef + 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) => JSModule['_BinaryenI31Get'](this.ptr, i31, 1) as ExpressionRef, - get_u: (i31: ExpressionRef) => JSModule['_BinaryenI31Get'](this.ptr, i31, 0) as ExpressionRef + 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: () => JSModule['_BinaryenAtomicFence'](this.ptr) as ExpressionRef + fence: (): ExpressionRef => JSModule['_BinaryenAtomicFence'](this.ptr) }; } get locals () { return { - get: (index: number, type: Type) => JSModule['_BinaryenLocalGet'](this.ptr, index, type) as ExpressionRef, - set: (index: number, value: ExpressionRef) => JSModule['_BinaryenLocalSet'](this.ptr, index, value) as ExpressionRef, - tee: (index: number, value: ExpressionRef, type: Type) => { + 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) as ExpressionRef; + return JSModule['_BinaryenLocalTee'](this.ptr, index, value, type); } }; } get globals () { return { - add: (name: string, type: Type, mutable: boolean, init: ExpressionRef) => - preserveStack(() => JSModule['_BinaryenAddGlobal'](this.ptr, strToStack(name), type, mutable, init)) as GlobalRef, - getRefByName: (name: string) => preserveStack(() => JSModule['_BinaryenGetGlobal'](this.ptr, strToStack(name))) as GlobalRef, - getRefByIndex: (index: number) => JSModule['_BinaryenGetGlobalByIndex'](this.ptr, index) as GlobalRef, - remove: (name: string) => preserveStack(() => JSModule['_BinaryenRemoveGlobal'](this.ptr, strToStack(name))) as void, - count: () => JSModule['_BinaryenGetNumGlobals'](this.ptr) as number, - set: (name: string, value: ExpressionRef) => JSModule['_BinaryenGlobalSet'](this.ptr, strToStack(name), value) as ExpressionRef, - get: (name: string, type: Type) => JSModule['_BinaryenGlobalGet'](this.ptr, strToStack(name), type) as ExpressionRef, - addImport: (internalName: string, externalModuleName: string, externalBaseName: string, globalType: Type, mutable: boolean) => - preserveStack(() => JSModule['_BinaryenAddGlobalImport'](this.ptr, strToStack(internalName), strToStack(externalModuleName), strToStack(externalBaseName), globalType, mutable)) as void, - addExport: (internalName: string, externalName: string) => - preserveStack(() => JSModule['_BinaryenAddGlobalExport'](this.ptr, strToStack(internalName), strToStack(externalName))) as ExportRef, - getInfo: (ref: GlobalRef) => { + 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(Module['_BinaryenGlobalGetName'](ref)) as string, - 'module': UTF8ToString(Module['_BinaryenGlobalImportGetModule'](ref)) as string | null, - 'base': UTF8ToString(Module['_BinaryenGlobalImportGetBase'](ref)) as string | null, - 'type': Module['_BinaryenGlobalGetType'](ref) as Type, + 'name': UTF8ToString(Module['_BinaryenGlobalGetName'](ref)), + 'module': UTF8ToString(Module['_BinaryenGlobalImportGetModule'](ref)), + 'base': UTF8ToString(Module['_BinaryenGlobalImportGetBase'](ref)), + 'type': Module['_BinaryenGlobalGetType'](ref), 'mutable': Boolean(Module['_BinaryenGlobalIsMutable'](ref)), - 'init': Module['_BinaryenGlobalGetInitExpr'](ref) as ExpressionRef - } as GlobalInfo; + 'init': Module['_BinaryenGlobalGetInitExpr'](ref) + }; } }; } get tables () { return { - add: (name: string, initial: number, maximum: number, type: Type) => - preserveStack(() => JSModule['_BinaryenAddTable'](this.ptr, strToStack(name), initial, maximum, type)) as TableRef, - getRefByName: (name: string) => - preserveStack(() => JSModule['_BinaryenGetTable'](this.ptr, strToStack(name))) as TableRef, - getRefByIndex: (index: number) => JSModule['_BinaryenGetTableByIndex'](this.ptr, index) as TableRef, - remove: (name: string) => - preserveStack(() => JSModule['_BinaryenRemoveTable'](this.ptr, strToStack(name))) as void, - count: () => JSModule['_BinaryenGetNumTables'](this.ptr) as number, - get: (name: string, index: ExpressionRef, type: Type) => JSModule['_BinaryenTableGet'](this.ptr, strToStack(name), index, type) as ExpressionRef, - set: (name: string, index: ExpressionRef, value: ExpressionRef) => JSModule['_BinaryenTableSet'](this.ptr, strToStack(name), index, value) as ExpressionRef, - size: (name: string) => JSModule['_BinaryenTableSize'](this.ptr, strToStack(name)) as ExpressionRef, - grow: (name: string, value: ExpressionRef, delta: ExpressionRef) => JSModule['_BinaryenTableGrow'](this.ptr, strToStack(name), value, delta) as ExpressionRef, - addImport: (internalName: string, externalModuleName: string, externalBaseName: string) => - preserveStack(() => JSModule['_BinaryenAddTableImport'](this.ptr, strToStack(internalName), strToStack(externalModuleName), strToStack(externalBaseName))) as void, - addExport: (internalName: string, externalName: string) => - preserveStack(() => JSModule['_BinaryenAddTableExport'](this.ptr, strToStack(internalName), strToStack(externalName))) as ExportRef, - getInfo: (table: TableRef) => { + 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, strToStack(name))); const withMax = hasMax ? { max: JSModule['_BinaryenTableGetMax'](this.ptr, strToStack(name))} : {}; return Object.assign({ @@ -2051,7 +2037,7 @@ module binaryen { 'module': UTF8ToString(Module['_BinaryenTableImportGetModule'](table)), 'base': UTF8ToString(Module['_BinaryenTableImportGetBase'](table)), 'initial': Module['_BinaryenTableGetInitial'](table), - }, withMax) as TableInfo; + }, withMax); } }; /* TODO @@ -2068,67 +2054,67 @@ module binaryen { } get tuples () { return { - make: (elements: ExportRef[]) => - preserveStack(() => JSModule['_BinaryenTupleMake'](this.ptr, i32sToStack(elements), elements.length)) as ExpressionRef, - extract: (tuple: ExpressionRef, index: number) => - JSModule['_BinaryenTupleExtract'](this.ptr, tuple, index) as ExpressionRef + 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) => + 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)) as FunctionRef, - getRefByName: (name: string) => - preserveStack(() => JSModule['_BinaryenGetFunction'](this.ptr, strToStack(name))) as FunctionRef, - getRefByIndex: (index: number) => - JSModule['_BinaryenGetFunctionByIndex'](this.ptr, index) as FunctionRef, - remove: (name: string) => - preserveStack(() => JSModule['_BinaryenRemoveFunction'](this.ptr, strToStack(name))) as void, - count: () => JSModule['_BinaryenGetNumFunctions'](this.ptr) as number, - addImport: (internalName: string, externalModuleName: string, externalBaseName: string, params: Type, results: Type) => + 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) - ) as void, - addExport: (internalName: string, externalName: string) => - preserveStack(() => JSModule['_BinaryenAddFunctionExport'](this.ptr, strToStack(internalName), strToStack(externalName))) as ExportRef + ), + 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) => - preserveStack(() => JSModule['_BinaryenAddTag'](this.ptr, strToStack(name), params, results)) as TagRef, - getRefByName: (name: string) => - preserveStack(() => JSModule['_BinaryenGetTag'](this.ptr, strToStack(name))) as TagRef, - remove: (name: string) => - preserveStack(() => JSModule['_BinaryenRemoveTag'](this.ptr, strToStack(name))) as void, - addImport: (internalName: string, externalModuleName: string, externalBaseName: string, params: Type, results: Type) => - preserveStack(() => JSModule['_BinaryenAddTagImport'](this.ptr, strToStack(internalName), strToStack(externalModuleName), strToStack(externalBaseName), params, results)) as void, - addExport: (internalName: string, externalName: string) => - preserveStack(() => JSModule['_BinaryenAddTagExport'](this.ptr, strToStack(internalName), strToStack(externalName))) as ExportRef, - getInfo: (tag: TagRef) => { + 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(Module['_BinaryenTagGetName'](tag)), 'module': UTF8ToString(Module['_BinaryenTagImportGetModule'](tag)), 'base': UTF8ToString(Module['_BinaryenTagImportGetBase'](tag)), 'params': Module['_BinaryenTagGetParams'](tag), 'results': Module['_BinaryenTagGetResults'](tag) - } as TagInfo; + }; } }; } get memory () { return { - init: (segment: number, dest: ExpressionRef, offset: ExpressionRef, size: ExpressionRef, name?: string) => - preserveStack(() => JSModule['_BinaryenMemoryInit'](this.ptr, strToStack(segment), dest, offset, size, strToStack(name))) as ExpressionRef, + init: (segment: number, dest: ExpressionRef, offset: ExpressionRef, size: ExpressionRef, name?: string): ExpressionRef => + preserveStack(() => JSModule['_BinaryenMemoryInit'](this.ptr, strToStack(segment), dest, offset, size, strToStack(name))), has: () => Boolean(JSModule['_BinaryenHasMemory'](this.ptr)), - size: (name?: string, memory64?: boolean) => JSModule['_BinaryenMemorySize'](this.ptr, strToStack(name), memory64) as ExpressionRef, - grow: (value: ExpressionRef, name?: string, memory64?: boolean) => JSModule['_BinaryenMemoryGrow'](this.ptr, value, strToStack(name), memory64) as ExpressionRef, - copy: (dest: ExpressionRef, source: ExpressionRef, size: ExpressionRef, destName?: string, sourceName?: string) => - JSModule['_BinaryenMemoryCopy'](this.ptr, dest, source, size, strToStack(destName), strToStack(sourceName)) as ExpressionRef, - fill: (dest: ExpressionRef, value: ExpressionRef, size: ExpressionRef, name?: string) => - JSModule['_BinaryenMemoryFill'](this.ptr, dest, value, size, strToStack(name)) as ExpressionRef, - set: (initial: number, maximum: number, exportName?: string | null, segments?: SegmentInfo[] | null, shared?: boolean, memory64?: boolean, internalName?: string) => + 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 segmentData = new Array(segmentsLen); @@ -2158,8 +2144,8 @@ module binaryen { _free(segmentData[i]); } return ret; - }) as void, - getInfo: (name?: string) => { + }), + 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({ @@ -2168,24 +2154,23 @@ module binaryen { initial: JSModule['_BinaryenMemoryGetInitial'](this.ptr, strToStack(name)), shared: Boolean(JSModule['_BinaryenMemoryIsShared'](this.ptr, strToStack(name))), is64: Boolean(JSModule['_BinaryenMemoryIs64'](this.ptr, strToStack(name))), - }, withMax) as MemoryInfo; + }, withMax); }, - countSegments: () => JSModule['_BinaryenGetNumMemorySegments'](this.ptr) as number, - getSegmentInfoByIndex: (index: number) => { + countSegments: (): number => JSModule['_BinaryenGetNumMemorySegments'](this.ptr), + getSegmentInfoByIndex: (index: number): SegmentInfo => { const passive = Boolean(JSModule['_BinaryenGetMemorySegmentPassive'](this.ptr, index)); const offset = passive ? 0 : JSModule['_BinaryenGetMemorySegmentByteOffset'](this.ptr, index); const size = JSModule['_BinaryenGetMemorySegmentByteLength'](this.ptr, index); const ptr = _malloc(size); JSModule['_BinaryenCopyMemorySegmentData'](this.ptr, index, ptr); - const bytes = new Uint8Array(size); - bytes.set(HEAP8.subarray(ptr, ptr + size)); + const data = new Uint8Array(size); + data.set(HEAP8.subarray(ptr, ptr + size)); _free(ptr); - const data = bytes.buffer; - return { offset, data, passive } as SegmentInfo; + return { offset, data, passive }; }, - countElementSegments: () => JSModule['_BinaryenGetNumElementSegments'](this.ptr) as number, - getElementSegmentByIndex: (index: number) => JSModule['_BinaryenGetElementSegmentByIndex'](this.ptr, index) as ElementSegmentRef, - getElementSegmentInfo: (segment: ElementSegmentRef) => { + countElementSegments: (): number => JSModule['_BinaryenGetNumElementSegments'](this.ptr), + getElementSegmentByIndex: (index: number): ElementSegmentRef => JSModule['_BinaryenGetElementSegmentByIndex'](this.ptr, index), + getElementSegmentInfo: (segment: ElementSegmentRef): ElementSegmentInfo => { const segmentLength = Module['_BinaryenElementSegmentGetLength'](segment); const names = new Array(segmentLength); for (let j = 0; j < segmentLength; j++) { @@ -2196,51 +2181,51 @@ module binaryen { 'table': UTF8ToString(Module['_BinaryenElementSegmentGetTable'](segment)), 'offset': Module['_BinaryenElementSegmentGetOffset'](segment), 'data': names - } as ElementSegmentInfo; + }; }, - addImport: (internalName: string, externalModuleName: string, externalBaseName: string, shared: boolean) => - preserveStack(() => JSModule['_BinaryenAddMemoryImport'](this.ptr, strToStack(internalName), strToStack(externalModuleName), strToStack(externalBaseName), shared)) as void, - addExport: (internalName: string, externalName: string) => - preserveStack(() => JSModule['_BinaryenAddMemoryExport'](this.ptr, strToStack(internalName), strToStack(externalName))) as ExportRef, + 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) => - JSModule['_BinaryenAtomicNotify'](this.ptr, ptr, notifyCount, strToStack(name)) as ExpressionRef, - wait32: (ptr: ExpressionRef, expected: ExpressionRef, timeout: ExpressionRef, name?: string) => - JSModule['_BinaryenAtomicWait'](this.ptr, ptr, expected, timeout, Module['i32'], strToStack(name)) as ExpressionRef, - wait64: (ptr: ExpressionRef, expected: ExpressionRef, timeout: ExpressionRef, name?: string) => - JSModule['_BinaryenAtomicWait'](this.ptr, ptr, expected, timeout, Module['i64'], strToStack(name)) as ExpressionRef + 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, Module['i32'], strToStack(name)), + wait64: (ptr: ExpressionRef, expected: ExpressionRef, timeout: ExpressionRef, name?: string): ExpressionRef => + JSModule['_BinaryenAtomicWait'](this.ptr, ptr, expected, timeout, Module['i64'], strToStack(name)) } }; } get data () { return { - drop: (segment: number) => preserveStack(() => JSModule['_BinaryenDataDrop'](this.ptr, strToStack(segment))) as ExpressionRef + drop: (segment: number): ExpressionRef => preserveStack(() => JSModule['_BinaryenDataDrop'](this.ptr, strToStack(segment))) }; } get exports () { return { - getRefByName: (externalName: string) => - preserveStack(() => JSModule['_BinaryenGetExport'](this.ptr, strToStack(externalName))) as ExportRef, - getRefByIndex: (index: number) => JSModule['_BinaryenGetExportByIndex'](this.ptr, index) as ExportRef, - remove: (externalName: string) => preserveStack(() => JSModule['_BinaryenRemoveExport'](this.ptr, strToStack(externalName))) as void, - count: () => JSModule['_BinaryenGetNumExports'](this.ptr) as number, - getInfo: (export_: ExportRef) => { + 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': Module['_BinaryenExportGetKind'](export_), 'name': UTF8ToString(Module['_BinaryenExportGetName'](export_)), 'value': UTF8ToString(Module['_BinaryenExportGetValue'](export_)) - } as ExportInfo; + }; } }; } get expressions () { return { - copy: (expr: ExpressionRef) => JSModule['_BinaryenExpressionCopy'](expr, this.ptr) as ExpressionRef, - getType: (expression: ExpressionRef) => JSModule['_BinaryenExpressionGetType'](expression) as Type, - getInfo: (expression: ExpressionRef) => getExpressionInfo(expression) as ExpressionInfo, - getSideEffects: (expression: ExpressionRef) => JSModule['_BinaryenExpressionGetSideEffects'](expression, this.ptr) as SideEffects, - emitText: (expression: ExpressionRef) => { + 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 => { const old = out; let text = ''; out = x => { text += x + '\n' }; @@ -2263,16 +2248,16 @@ module binaryen { return JSModule['_RelooperAddBlock'](this.ref, code); } addBranch(from: RelooperBlockRef, to: RelooperBlockRef, condition: ExpressionRef, code: ExpressionRef): void { - Module['_RelooperAddBranch'](from, to, condition, code); + JSModule['_RelooperAddBranch'](from, to, condition, code); } addBlockWithSwitch(code: ExpressionRef, condition: ExpressionRef): RelooperBlockRef { - return Module['_RelooperAddBlockWithSwitch'](this.ref, code, condition); + return JSModule['_RelooperAddBlockWithSwitch'](this.ref, code, condition); } addBranchForSwitch(from: RelooperBlockRef, to: RelooperBlockRef, indexes: number[], code: ExpressionRef): void { - preserveStack(() => Module['_RelooperAddBranchForSwitch'](from, to, i32sToStack(indexes), indexes.length, code)); + preserveStack(() => JSModule['_RelooperAddBranchForSwitch'](from, to, i32sToStack(indexes), indexes.length, code)); } renderAndDispose(entry: RelooperBlockRef, labelHelper: number): ExpressionRef { - return Module['_RelooperRenderAndDispose'](this.ref, entry, labelHelper); + return JSModule['_RelooperRenderAndDispose'](this.ref, entry, labelHelper); } } @@ -2287,19 +2272,34 @@ module binaryen { readonly ref: ExpressionRunnerRef; constructor(module: Module, flags: ExpressionRunnerFlags, maxDepth: number, maxLoopIterations: number) { - this.ref = Module['_ExpressionRunnerCreate'](module.ptr, flags, maxDepth, maxLoopIterations); + this.ref = JSModule['_ExpressionRunnerCreate'](module.ptr, flags, maxDepth, maxLoopIterations); } setLocalValue(index: number, valueExpr: ExpressionRef): boolean { - return Boolean(Module['_ExpressionRunnerSetLocalValue'](this.ref, index, valueExpr)); + return Boolean(JSModule['_ExpressionRunnerSetLocalValue'](this.ref, index, valueExpr)); } setGlobalValue(name: string, valueExpr: ExpressionRef): boolean { - return preserveStack(() => Boolean(Module['_ExpressionRunnerSetGlobalValue'](this.ref, strToStack(name), valueExpr))); + return preserveStack(() => Boolean(JSModule['_ExpressionRunnerSetGlobalValue'](this.ref, strToStack(name), valueExpr))); } runAndDispose(expr: ExpressionRef): ExpressionRef { - return Module['_ExpressionRunnerRunAndDispose'](this.ref, expr); + return JSModule['_ExpressionRunnerRunAndDispose'](this.ref, expr); } } + export interface SegmentInfo { + 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; @@ -2966,9 +2966,9 @@ module binaryen { 'id': id, 'type': type, 'segment': UTF8ToString(Module['_BinaryenMemoryInitGetSegment'](expression)), - 'dest': Module['_BinaryenMemoryInitGetDest'](expression) as ExpressionRef, - 'offset': Module['_BinaryenMemoryInitGetOffset'](expression) as ExpressionRef, - 'size': Module['_BinaryenMemoryInitGetSize'](expression) as ExpressionRef + 'dest': Module['_BinaryenMemoryInitGetDest'](expression), + 'offset': Module['_BinaryenMemoryInitGetOffset'](expression), + 'size': Module['_BinaryenMemoryInitGetSize'](expression) } as MemoryInitInfo; case Module['DataDropId']: return { @@ -3028,7 +3028,7 @@ module binaryen { 'id': id, 'type': type, 'name': UTF8ToString(Module['_BinaryenTryGetName'](expression)), - 'body': Module['_BinaryenTryGetBody'](expression) as ExpressionRef, + 'body': Module['_BinaryenTryGetBody'](expression), 'catchTags': getAllNested(expression, Module['_BinaryenTryGetNumCatchTags'], Module['_BinaryenTryGetCatchTagAt']), 'catchBodies': getAllNested(expression, Module['_BinaryenTryGetNumCatchBodies'], Module['_BinaryenTryGetCatchBodyAt']), 'hasCatchAll': Module['_BinaryenTryHasCatchAll'](expression) as boolean, From 839b665ea3fb3115f55b98bfc02ba94083209ff4 Mon Sep 17 00:00:00 2001 From: Eric Vergnaud Date: Wed, 13 Dec 2023 01:31:23 +0100 Subject: [PATCH 18/38] a base version i.e. symbols are exported, but not tested yet --- .gitignore | 9 +- CMakeLists.txt | 39 + src/ts/binaryen-post.ts | 23 + src/ts/binaryen-wrapper.ts | 3062 +++++++++++++++++++++++++++++++++++ src/ts/binaryen.ts | 3083 ------------------------------------ src/ts/binaryen_wasm_ts.js | 4 + 6 files changed, 3135 insertions(+), 3085 deletions(-) create mode 100644 src/ts/binaryen-post.ts create mode 100644 src/ts/binaryen-wrapper.ts delete mode 100644 src/ts/binaryen.ts create mode 100644 src/ts/binaryen_wasm_ts.js diff --git a/.gitignore b/.gitignore index e289b51550d..969e07ac92b 100644 --- a/.gitignore +++ b/.gitignore @@ -50,5 +50,10 @@ test/lit/lit.site.cfg.py # files related to clangd cache .cache/* -src/ts/binaryen.d.ts -src/ts/binaryen.js + +# files related to tsc compilation +/src/ts/binaryen-post.js +/src/ts/binaryen-post.d.ts +/src/ts/binaryen-wrapper.d.ts +/src/ts/binaryen-wrapper.js +/*.map diff --git a/CMakeLists.txt b/CMakeLists.txt index 4e8e780bfe8..15a1d04d521 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -464,6 +464,8 @@ if(EMSCRIPTEN) target_link_libraries(binaryen_wasm "-sEXPORT_ES6") target_link_libraries(binaryen_wasm "-sEXPORTED_RUNTIME_METHODS=allocateUTF8OnStack,stringToAscii") target_link_libraries(binaryen_wasm "-sEXPORTED_FUNCTIONS=_malloc,_free") + # useful when working on --post-js file + # target_link_libraries(binaryen_wasm "--minify=0") target_link_libraries(binaryen_wasm "--post-js=${CMAKE_CURRENT_SOURCE_DIR}/src/js/binaryen.js-post.js") target_link_libraries(binaryen_wasm "-msign-ext") target_link_libraries(binaryen_wasm "-mbulk-memory") @@ -503,6 +505,8 @@ if(EMSCRIPTEN) endif() target_link_libraries(binaryen_js "-sEXPORTED_RUNTIME_METHODS=allocateUTF8OnStack,stringToAscii") target_link_libraries(binaryen_js "-sEXPORTED_FUNCTIONS=_malloc,_free") + # useful when working on --post-js file + # target_link_libraries(binaryen_js "--minify=0") target_link_libraries(binaryen_js "--post-js=${CMAKE_CURRENT_SOURCE_DIR}/src/js/binaryen.js-post.js") # js_of_ocaml needs a specified variable with special comment to provide the library to consumers if(JS_OF_OCAML) @@ -521,6 +525,41 @@ if(EMSCRIPTEN) target_link_libraries(binaryen_js debug "--profiling") target_link_libraries(binaryen_js debug "-sASSERTIONS") install(TARGETS binaryen_js DESTINATION ${CMAKE_INSTALL_BINDIR}) + + # binaryen.ts TypeScript variant (leverages the wasm variant) + # compile the typescript file that wraps the wasm + add_custom_target(binaryen_wrap_ts + COMMAND tsc --target ES2020 --module ES2022 --declaration --declarationMap + ${CMAKE_CURRENT_SOURCE_DIR}/src/ts/binaryen-wrapper.ts && + mv ${CMAKE_CURRENT_SOURCE_DIR}/src/ts/binaryen-wrapper.js ${CMAKE_BINARY_DIR}/bin/binaryen_ts.js && + mv ${CMAKE_CURRENT_SOURCE_DIR}/src/ts/binaryen-wrapper.d.ts ${CMAKE_BINARY_DIR}/bin/binaryen_ts.d.ts && + mv ${CMAKE_CURRENT_SOURCE_DIR}/src/ts/binaryen-wrapper.d.ts.map ${CMAKE_BINARY_DIR}/bin/binaryen_ts.d.ts.map) + add_custom_target(binaryen_post_ts + COMMAND tsc --target ES2020 --module ES2022 + ${CMAKE_CURRENT_SOURCE_DIR}/src/ts/binaryen-post.ts) + add_executable(binaryen_wasm_ts + ${binaryen_emscripten_SOURCES}) + add_dependencies(binaryen_wasm_ts binaryen_wrap_ts binaryen_post_ts) + target_link_libraries(binaryen_wasm_ts wasm asmjs emscripten-optimizer passes ir cfg support analysis parser wasm) + target_link_libraries(binaryen_wasm_ts "-sFILESYSTEM") + target_link_libraries(binaryen_wasm_ts "-sEXPORT_NAME=Binaryen") + target_link_libraries(binaryen_wasm_ts "-sNODERAWFS=0") + target_link_libraries(binaryen_wasm_ts "-sEXPORT_ES6") + target_link_libraries(binaryen_wasm_ts "-sEXPORTED_RUNTIME_METHODS=allocateUTF8OnStack,stringToAscii") + target_link_libraries(binaryen_wasm_ts "-sEXPORTED_FUNCTIONS=_malloc,_free") + # useful when working on --post-js file + # target_link_libraries(binaryen_wasm_ts "--minify=0") + target_link_libraries(binaryen_wasm_ts "--post-js=${CMAKE_CURRENT_SOURCE_DIR}/src/ts/binaryen-post.js") + target_link_libraries(binaryen_wasm_ts "-msign-ext") + target_link_libraries(binaryen_wasm_ts "-mbulk-memory") + target_link_libraries(binaryen_wasm_ts optimized "--closure=1") + target_link_libraries(binaryen_wasm_ts optimized "--closure-args=\"--language_in=ECMASCRIPT6 --language_out=ECMASCRIPT6\"") + # TODO: Fix closure warnings! (#5062) + target_link_libraries(binaryen_wasm_ts optimized "-Wno-error=closure") + target_link_libraries(binaryen_wasm_ts optimized "-flto") + target_link_libraries(binaryen_wasm_ts debug "--profiling") + install(TARGETS binaryen_wasm_ts DESTINATION ${CMAKE_INSTALL_BINDIR}) + endif() configure_file(scripts/binaryen-lit.in ${CMAKE_BINARY_DIR}/bin/binaryen-lit @ONLY) diff --git a/src/ts/binaryen-post.ts b/src/ts/binaryen-post.ts new file mode 100644 index 00000000000..e52bee0cec6 --- /dev/null +++ b/src/ts/binaryen-post.ts @@ -0,0 +1,23 @@ +declare var Module: object; +declare var HEAP8: Int8Array; +declare var HEAPU8: Uint8Array; +declare var HEAP32: Int32Array; +declare var HEAPU32: Uint32Array; +declare var out: (s: string) => void; +declare var stringToAscii: (s: string, ptr: number) => void; +declare var stackSave: () => number; +declare var stackAlloc: (size: number) => number; +declare var stackRestore: (ref: number) => void; +declare var allocateUTF8OnStack: (s: string) => number; +declare var _BinaryenSizeofLiteral: () => number; +declare var _BinaryenSizeofAllocateAndWriteResult: () => number; +declare var UTF8ToString: (ptr: number) => string | null; + +type Writer = (s: string) => void; +function swapOut(writer: Writer): Writer { + const saved = out; + out = writer; + return saved; +} + +Module['utils'] = { HEAP8, HEAPU8, HEAP32, HEAPU32, swapOut, stringToAscii, stackSave, stackAlloc, stackRestore, allocateUTF8OnStack, _BinaryenSizeofLiteral, _BinaryenSizeofAllocateAndWriteResult, UTF8ToString }; \ No newline at end of file diff --git a/src/ts/binaryen-wrapper.ts b/src/ts/binaryen-wrapper.ts new file mode 100644 index 00000000000..7219d736395 --- /dev/null +++ b/src/ts/binaryen-wrapper.ts @@ -0,0 +1,3062 @@ +import Binaryen from "./binaryen_wasm_ts.js" +const JSModule = await Binaryen(); +const _malloc: (size: number) => number = JSModule._malloc; +const _free: (size: number) => void = JSModule._free; +type Writer = (s: string) => void; +const utils = JSModule['utils']; +const HEAP8: Int8Array = utils.HEAP8; +const HEAPU8: Uint8Array = utils.HEAPU8; +const HEAP32: Int32Array = utils.HEAP32; +const HEAPU32: Uint32Array = utils.HEAPU32; +const swapOut: (func: Writer) => Writer = utils.swapOut; +const stringToAscii: (s: string, ptr: number) => void = utils.stringToAscii; +const stackSave: () => number = utils.stackSave; +const stackAlloc: (size: number) => number = utils.stackAlloc; +const stackRestore: (ref: number) => void = utils.stackRestore; +const allocateUTF8OnStack: (s: string) => number = utils.allocateUTF8OnStack; +const _BinaryenSizeofLiteral: () => number = utils._BinaryenSizeofLiteral; +const _BinaryenSizeofAllocateAndWriteResult: () => number = utils._BinaryenSizeofAllocateAndWriteResult; +const UTF8ToString: (ptr: number) => string | null = utils.UTF8ToString; + +function preserveStack(func: () => R): R { + try { + var stack = stackSave(); + return func(); + } finally { + stackRestore(stack); + } +} + +function strToStack(str) { + 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 = 0; + +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 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 Features { + 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 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: Features): void { + JSModule['_BinaryenModuleSetFeatures'](this.ptr, features); + } + getFeatures(): Features { + return JSModule['_BinaryenModuleGetFeatures'](this.ptr); + } + 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(): number { + 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: (segment: number, dest: ExpressionRef, offset: ExpressionRef, size: ExpressionRef, name?: string): ExpressionRef => + preserveStack(() => JSModule['_BinaryenMemoryInit'](this.ptr, strToStack(segment), 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 segmentData = new Array(segmentsLen); + const segmentDataLen = new Array(segmentsLen); + const segmentPassive = new Array(segmentsLen); + const segmentOffset = new Array(segmentsLen); + for (let i = 0; i < segmentsLen; i++) { + const { data, offset, passive } = segments[i]; + segmentData[i] = _malloc(data.length); + HEAP8.set(data, segmentData[i]); + segmentDataLen[i] = data.length; + segmentPassive[i] = passive; + segmentOffset[i] = offset; + } + const ret = JSModule['_BinaryenSetMemory']( + this.ptr, initial, maximum, strToStack(exportName), + i32sToStack(segmentData), + i8sToStack(segmentPassive), + i32sToStack(segmentOffset), + i32sToStack(segmentDataLen), + segmentsLen, + shared, + memory64, + strToStack(internalName) + ); + for (let i = 0; i < segmentsLen; i++) { + _free(segmentData[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), + getSegmentInfoByIndex: (index: number): SegmentInfo => { + const passive = Boolean(JSModule['_BinaryenGetMemorySegmentPassive'](this.ptr, index)); + const offset = passive ? 0 : JSModule['_BinaryenGetMemorySegmentByteOffset'](this.ptr, index); + const size = JSModule['_BinaryenGetMemorySegmentByteLength'](this.ptr, index); + const ptr = _malloc(size); + JSModule['_BinaryenCopyMemorySegmentData'](this.ptr, index, ptr); + const data = new Uint8Array(size); + data.set(HEAP8.subarray(ptr, ptr + size)); + _free(ptr); + return { 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: number): 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; + } + }; + } +} + +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 SegmentInfo { + 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.ts b/src/ts/binaryen.ts deleted file mode 100644 index 6cef32d90b9..00000000000 --- a/src/ts/binaryen.ts +++ /dev/null @@ -1,3083 +0,0 @@ -// export friendly API methods - -module binaryen { - - declare var HEAP8: Int8Array; - declare var HEAPU8: Uint8Array; - declare var HEAP32: Int32Array; - declare var HEAPU32: Uint32Array; - declare var out: (s: string) => void; - declare var stringToAscii: (s: string, ptr: number) => void; - declare var _malloc: (size: number) => number; - declare var _free: (size: number) => void; - declare var stackSave: () => number; - declare var stackAlloc: (size: number) => number; - declare var stackRestore: (ref: number) => void; - declare var allocateUTF8OnStack: (s: string) => number; - declare var _BinaryenSizeofLiteral: () => number; - declare var _BinaryenSizeofAllocateAndWriteResult: () => number; - declare var UTF8ToString: (ptr: number) => string | null; - - const sizeOfLiteral = _BinaryenSizeofLiteral(); - // avoid name clash with binaryen class Module - const JSModule: object = self["Module"]; - - function preserveStack(func: () => R): R { - try { - var stack = stackSave(); - return func(); - } finally { - stackRestore(stack); - } - } - - function strToStack(str) { - 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 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 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 Features { - 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 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(Module['_BinaryenFunctionImportGetModule'](this.func)), - 'base': UTF8ToString(Module['_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 Module['_BinaryenGetOptimizeLevel'](); - } - function setOptimizeLevel(level: number): void { - Module['_BinaryenSetOptimizeLevel'](level); - } - function getShrinkLevel(): number { - return Module['_BinaryenGetShrinkLevel'](); - } - function setShrinkLevel(level: number): void { - Module['_BinaryenSetShrinkLevel'](level); - } - function getDebugInfo(): boolean { - return Boolean(Module['_BinaryenGetDebugInfo']()); - } - function setDebugInfo(on: boolean): void { - Module['_BinaryenSetDebugInfo'](on); - } - function getLowMemoryUnused(): boolean { - return Boolean(Module['_BinaryenGetLowMemoryUnused']()); - } - function setLowMemoryUnused(on: boolean): void { - Module['_BinaryenSetLowMemoryUnused'](on); - } - function getZeroFilledMemory(): boolean { - return Boolean(Module['_BinaryenGetZeroFilledMemory']()); - } - function setZeroFilledMemory(on: boolean): void { - Module['_BinaryenSetZeroFilledMemory'](on); - } - function getFastMath(): boolean { - return Boolean(Module['_BinaryenGetFastMath']()); - } - function setFastMath(on: boolean): void { - Module['_BinaryenSetFastMath'](on); - } - function getPassArgument(key: string): string | null { - return preserveStack(() => { - const ret = Module['_BinaryenGetPassArgument'](strToStack(key)); - return ret !== 0 ? UTF8ToString(ret) : null; - }); - } - function setPassArgument(key: string, value: string | null): void { - preserveStack(() => { Module['_BinaryenSetPassArgument'](strToStack(key), strToStack(value)) }); - } - function clearPassArguments(): void { - Module['_BinaryenClearPassArguments'](); - } - function getAlwaysInlineMaxSize(): number { - return Module['_BinaryenGetAlwaysInlineMaxSize'](); - } - function setAlwaysInlineMaxSize(size: number): void { - Module['_BinaryenSetAlwaysInlineMaxSize'](size); - } - function getFlexibleInlineMaxSize(): number { - return Module['_BinaryenGetFlexibleInlineMaxSize'](); - } - function setFlexibleInlineMaxSize(size: number): void { - Module['_BinaryenSetFlexibleInlineMaxSize'](size); - } - function getOneCallerInlineMaxSize(): number { - return Module['_BinaryenGetOneCallerInlineMaxSize'](); - } - function setOneCallerInlineMaxSize(size: number): void { - Module['_BinaryenSetOneCallerInlineMaxSize'](size); - } - function getAllowInliningFunctionsWithLoops(): boolean { - return Boolean(Module['_BinaryenGetAllowInliningFunctionsWithLoops']()); - } - function setAllowInliningFunctionsWithLoops(on: boolean): void { - Module['_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 = Module['_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: Features): void { - JSModule['_BinaryenModuleSetFeatures'](this.ptr, features); - } - getFeatures(): Features { - return JSModule['_BinaryenModuleGetFeatures'](this.ptr); - } - 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(): number { - 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 { - const old = out; - let text = ''; - out = x => { text += x + '\n' }; - JSModule['_BinaryenModulePrintAsmjs'](this.ptr); - out = 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 : binaryen.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) - }, - /** @deprecated use reinterpret_f32 */ - reinterpret: (value: ExpressionRef): ExpressionRef => unary(Operations.ReinterpretFloat32, 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), - /** @deprecated use wrap_i64 */ - wrap: (value: ExpressionRef): ExpressionRef => unary(Operations.WrapInt64, 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) - }, - /** @deprecated use reinterpret_f64 */ - reinterpret: (value: ExpressionRef): ExpressionRef => unary(Operations.ReinterpretFloat64, 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 => - Module['_BinaryenLoad'](this.ptr, 4, true, offset, align, f32, ptr, strToStack(name)), - store: (offset: number, align: number, ptr: ExpressionRef, value: ExpressionRef, name?: string): ExpressionRef => - Module['_BinaryenStore'](this.ptr, 4, offset, align, ptr, value, f32, strToStack(name)), - const: (value: number): ExpressionRef => - preserveStack(() => { - const tempLiteral = stackAlloc(sizeOfLiteral); - Module['_BinaryenLiteralFloat32'](tempLiteral, value); - return Module['_BinaryenConst'](this.ptr, tempLiteral); - }), - const_bits: (value: number): ExpressionRef => - preserveStack(() => { - const tempLiteral = stackAlloc(sizeOfLiteral); - Module['_BinaryenLiteralFloat32Bits'](tempLiteral, value); - return Module['_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), - /** @deprecated use reinterpret_i32 */ - reinterpret: (value: ExpressionRef): ExpressionRef => unary(Operations.ReinterpretInt32, 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) - }, - /** @deprecated use demote_f64 */ - demote: (value: ExpressionRef): ExpressionRef => unary(Operations.DemoteFloat64, 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 => - Module['_BinaryenLoad'](this.ptr, 8, true, offset, align, f64, ptr, strToStack(name)), - store: (offset: number, align: number, ptr: ExpressionRef, value: ExpressionRef, name?: string): ExpressionRef => - Module['_BinaryenStore'](this.ptr, 8, offset, align, ptr, value, f64, strToStack(name)), - const: (value: number): ExpressionRef => - preserveStack(() => { - const tempLiteral = stackAlloc(sizeOfLiteral); - Module['_BinaryenLiteralFloat64'](tempLiteral, value); - return Module['_BinaryenConst'](this.ptr, tempLiteral); - }), - const_bits: (value: number): ExpressionRef => - preserveStack(() => { - const tempLiteral = stackAlloc(sizeOfLiteral); - Module['_BinaryenLiteralFloat64Bits'](tempLiteral, value); - return Module['_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), - /** @deprecated use reinterpret_i64 */ - reinterpret: (value: ExpressionRef): ExpressionRef => unary(Operations.ReinterpretInt64, 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) - }, - /** @deprecated use promote_f32 */ - promote: (value: ExpressionRef): ExpressionRef => unary(Operations.PromoteFloat32, 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, Module['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(Module['_BinaryenGlobalGetName'](ref)), - 'module': UTF8ToString(Module['_BinaryenGlobalImportGetModule'](ref)), - 'base': UTF8ToString(Module['_BinaryenGlobalImportGetBase'](ref)), - 'type': Module['_BinaryenGlobalGetType'](ref), - 'mutable': Boolean(Module['_BinaryenGlobalIsMutable'](ref)), - 'init': Module['_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, strToStack(name))); - const withMax = hasMax ? { max: JSModule['_BinaryenTableGetMax'](this.ptr, strToStack(name))} : {}; - return Object.assign({ - 'name': UTF8ToString(Module['_BinaryenTableGetName'](table)), - 'module': UTF8ToString(Module['_BinaryenTableImportGetModule'](table)), - 'base': UTF8ToString(Module['_BinaryenTableImportGetBase'](table)), - 'initial': Module['_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(Module['_BinaryenTagGetName'](tag)), - 'module': UTF8ToString(Module['_BinaryenTagImportGetModule'](tag)), - 'base': UTF8ToString(Module['_BinaryenTagImportGetBase'](tag)), - 'params': Module['_BinaryenTagGetParams'](tag), - 'results': Module['_BinaryenTagGetResults'](tag) - }; - } - }; - } - get memory () { - return { - init: (segment: number, dest: ExpressionRef, offset: ExpressionRef, size: ExpressionRef, name?: string): ExpressionRef => - preserveStack(() => JSModule['_BinaryenMemoryInit'](this.ptr, strToStack(segment), 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 segmentData = new Array(segmentsLen); - const segmentDataLen = new Array(segmentsLen); - const segmentPassive = new Array(segmentsLen); - const segmentOffset = new Array(segmentsLen); - for (let i = 0; i < segmentsLen; i++) { - const { data, offset, passive } = segments[i]; - segmentData[i] = _malloc(data.length); - HEAP8.set(data, segmentData[i]); - segmentDataLen[i] = data.length; - segmentPassive[i] = passive; - segmentOffset[i] = offset; - } - const ret = JSModule['_BinaryenSetMemory']( - this.ptr, initial, maximum, strToStack(exportName), - i32sToStack(segmentData), - i8sToStack(segmentPassive), - i32sToStack(segmentOffset), - i32sToStack(segmentDataLen), - segmentsLen, - shared, - memory64, - strToStack(internalName) - ); - for (let i = 0; i < segmentsLen; i++) { - _free(segmentData[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), - getSegmentInfoByIndex: (index: number): SegmentInfo => { - const passive = Boolean(JSModule['_BinaryenGetMemorySegmentPassive'](this.ptr, index)); - const offset = passive ? 0 : JSModule['_BinaryenGetMemorySegmentByteOffset'](this.ptr, index); - const size = JSModule['_BinaryenGetMemorySegmentByteLength'](this.ptr, index); - const ptr = _malloc(size); - JSModule['_BinaryenCopyMemorySegmentData'](this.ptr, index, ptr); - const data = new Uint8Array(size); - data.set(HEAP8.subarray(ptr, ptr + size)); - _free(ptr); - return { offset, data, passive }; - }, - countElementSegments: (): number => JSModule['_BinaryenGetNumElementSegments'](this.ptr), - getElementSegmentByIndex: (index: number): ElementSegmentRef => JSModule['_BinaryenGetElementSegmentByIndex'](this.ptr, index), - getElementSegmentInfo: (segment: ElementSegmentRef): ElementSegmentInfo => { - const segmentLength = Module['_BinaryenElementSegmentGetLength'](segment); - const names = new Array(segmentLength); - for (let j = 0; j < segmentLength; j++) { - names[j] = UTF8ToString(Module['_BinaryenElementSegmentGetData'](segment, j)); - } - return { - 'name': UTF8ToString(Module['_BinaryenElementSegmentGetName'](segment)), - 'table': UTF8ToString(Module['_BinaryenElementSegmentGetTable'](segment)), - 'offset': Module['_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, Module['i32'], strToStack(name)), - wait64: (ptr: ExpressionRef, expected: ExpressionRef, timeout: ExpressionRef, name?: string): ExpressionRef => - JSModule['_BinaryenAtomicWait'](this.ptr, ptr, expected, timeout, Module['i64'], strToStack(name)) - } - }; - } - get data () { - return { - drop: (segment: number): 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': Module['_BinaryenExportGetKind'](export_), - 'name': UTF8ToString(Module['_BinaryenExportGetName'](export_)), - 'value': UTF8ToString(Module['_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 => { - const old = out; - let text = ''; - out = x => { text += x + '\n' }; - JSModule['_BinaryenExpressionPrint'](expression); - out = old; - return text; - } - }; - } - } - - 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, - PreserveSideeffects, - TraverseCalls - } - - 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 SegmentInfo { - 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 = Module['_BinaryenExpressionGetType'](expression); - switch (id) { - case JSModule['BlockId']: - return { - 'id': id, - 'type': type, - 'name': UTF8ToString(Module['_BinaryenBlockGetName'](expression)), - 'children': getAllNested(expression, Module['_BinaryenBlockGetNumChildren'], Module['_BinaryenBlockGetChildAt']) - } as BlockInfo; - case Module['IfId']: - return { - 'id': id, - 'type': type, - 'condition': Module['_BinaryenIfGetCondition'](expression), - 'ifTrue': Module['_BinaryenIfGetIfTrue'](expression), - 'ifFalse': Module['_BinaryenIfGetIfFalse'](expression) - } as IfInfo; - case Module['LoopId']: - return { - 'id': id, - 'type': type, - 'name': UTF8ToString(Module['_BinaryenLoopGetName'](expression)), - 'body': Module['_BinaryenLoopGetBody'](expression) - } as LoopInfo; - case Module['BreakId']: - return { - 'id': id, - 'type': type, - 'name': UTF8ToString(Module['_BinaryenBreakGetName'](expression)), - 'condition': Module['_BinaryenBreakGetCondition'](expression), - 'value': Module['_BinaryenBreakGetValue'](expression) - } as BreakInfo; - 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(expression, Module['_BinaryenSwitchGetNumNames'], Module['_BinaryenSwitchGetNameAt']).map(p => UTF8ToString(p)), - 'defaultName': UTF8ToString(Module['_BinaryenSwitchGetDefaultName'](expression)), - 'condition': Module['_BinaryenSwitchGetCondition'](expression), - 'value': Module['_BinaryenSwitchGetValue'](expression) - } as SwitchInfo; - case Module['CallId']: - return { - 'id': id, - 'type': type, - 'isReturn': Boolean(Module['_BinaryenCallIsReturn'](expression)), - 'target': UTF8ToString(Module['_BinaryenCallGetTarget'](expression)), - 'operands': getAllNested(expression, Module[ '_BinaryenCallGetNumOperands'], Module['_BinaryenCallGetOperandAt']) - } as CallInfo; - case Module['CallIndirectId']: - return { - 'id': id, - 'type': type, - 'isReturn': Boolean(Module['_BinaryenCallIndirectIsReturn'](expression)), - 'target': Module['_BinaryenCallIndirectGetTarget'](expression), - 'table': Module['_BinaryenCallIndirectGetTable'](expression), - 'operands': getAllNested(expression, Module['_BinaryenCallIndirectGetNumOperands'], Module['_BinaryenCallIndirectGetOperandAt']) - } as CallIndirectInfo; - case Module['LocalGetId']: - return { - 'id': id, - 'type': type, - 'index': Module['_BinaryenLocalGetGetIndex'](expression) - } as LocalGetInfo; - case Module['LocalSetId']: - return { - 'id': id, - 'type': type, - 'isTee': Boolean(Module['_BinaryenLocalSetIsTee'](expression)), - 'index': Module['_BinaryenLocalSetGetIndex'](expression), - 'value': Module['_BinaryenLocalSetGetValue'](expression) - } as LocalSetInfo; - case Module['GlobalGetId']: - return { - 'id': id, - 'type': type, - 'name': UTF8ToString(Module['_BinaryenGlobalGetGetName'](expression)) - } as GlobalGetInfo; - case Module['GlobalSetId']: - return { - 'id': id, - 'type': type, - 'name': UTF8ToString(Module['_BinaryenGlobalSetGetName'](expression)), - 'value': Module['_BinaryenGlobalSetGetValue'](expression) - } as GlobalSetInfo; - case Module['TableGetId']: - return { - 'id': id, - 'type': type, - 'table': UTF8ToString(Module['_BinaryenTableGetGetTable'](expression)), - 'index': Module['_BinaryenTableGetGetIndex'](expression) - } as TableGetInfo; - case Module['TableSetId']: - return { - 'id': id, - 'type': type, - 'table': UTF8ToString(Module['_BinaryenTableSetGetTable'](expression)), - 'index': Module['_BinaryenTableSetGetIndex'](expression), - 'value': Module['_BinaryenTableSetGetValue'](expression) - } as TableSetInfo; - case Module['TableSizeId']: - return { - 'id': id, - 'type': type, - 'table': UTF8ToString(Module['_BinaryenTableSizeGetTable'](expression)), - } as TableSizeInfo; - case Module['TableGrowId']: - return { - 'id': id, - 'type': type, - 'table': UTF8ToString(Module['_BinaryenTableGrowGetTable'](expression)), - 'value': Module['_BinaryenTableGrowGetValue'](expression), - 'delta': Module['_BinaryenTableGrowGetDelta'](expression), - } as TableGrowInfo; - case Module['LoadId']: - return { - 'id': id, - 'type': type, - 'isAtomic': Boolean(Module['_BinaryenLoadIsAtomic'](expression)), - 'isSigned': Boolean(Module['_BinaryenLoadIsSigned'](expression)), - 'offset': Module['_BinaryenLoadGetOffset'](expression), - 'bytes': Module['_BinaryenLoadGetBytes'](expression), - 'align': Module['_BinaryenLoadGetAlign'](expression), - 'ptr': Module['_BinaryenLoadGetPtr'](expression) - } as LoadInfo; - case Module['StoreId']: - return { - 'id': id, - 'type': type, - 'isAtomic': Boolean(Module['_BinaryenStoreIsAtomic'](expression)), - 'offset': Module['_BinaryenStoreGetOffset'](expression), - 'bytes': Module['_BinaryenStoreGetBytes'](expression), - 'align': Module['_BinaryenStoreGetAlign'](expression), - 'ptr': Module['_BinaryenStoreGetPtr'](expression), - 'value': Module['_BinaryenStoreGetValue'](expression) - } as StoreInfo; - case Module['ConstId']: { - let value; - switch (type) { - case i32: - value = Module['_BinaryenConstGetValueI32'](expression); - break; - case i64: - value = { - 'low': Module['_BinaryenConstGetValueI64Low'](expression), - 'high': Module['_BinaryenConstGetValueI64High'](expression) - }; - break; - case f32: - value = Module['_BinaryenConstGetValueF32'](expression); - break; - case f64: - value = Module['_BinaryenConstGetValueF64'](expression); - break; - case v128: { - preserveStack(() => { - const tempBuffer = stackAlloc(16); - Module['_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 Module['UnaryId']: - return { - 'id': id, - 'type': type, - 'op': Module['_BinaryenUnaryGetOp'](expression), - 'value': Module['_BinaryenUnaryGetValue'](expression) - } as UnaryInfo; - case Module['BinaryId']: - return { - 'id': id, - 'type': type, - 'op': Module['_BinaryenBinaryGetOp'](expression), - 'left': Module['_BinaryenBinaryGetLeft'](expression), - 'right': Module['_BinaryenBinaryGetRight'](expression) - } as BinaryInfo; - case Module['SelectId']: - return { - 'id': id, - 'type': type, - 'ifTrue': Module['_BinaryenSelectGetIfTrue'](expression), - 'ifFalse': Module['_BinaryenSelectGetIfFalse'](expression), - 'condition': Module['_BinaryenSelectGetCondition'](expression) - } as SelectInfo; - case Module['DropId']: - return { - 'id': id, - 'type': type, - 'value': Module['_BinaryenDropGetValue'](expression) - } as DropInfo; - case Module['ReturnId']: - return { - 'id': id, - 'type': type, - 'value': Module['_BinaryenReturnGetValue'](expression) - } as ReturnInfo; - case Module['NopId']: - return { - 'id': id, - 'type': type - } as NopInfo; - case Module['UnreachableId']: - return { - 'id': id, - 'type': type - } as UnreachableInfo; - case Module['PopId']: - return { - 'id': id, - 'type': type - } as PopInfo; - case Module['MemorySizeId']: - return { - 'id': id, - 'type': type - } as MemorySizeInfo; - case Module['MemoryGrowId']: - return { - 'id': id, - 'type': type, - 'delta': Module['_BinaryenMemoryGrowGetDelta'](expression) - } as MemoryGrowInfo; - case Module['AtomicRMWId']: - return { - 'id': id, - 'type': type, - 'op': Module['_BinaryenAtomicRMWGetOp'](expression), - 'bytes': Module['_BinaryenAtomicRMWGetBytes'](expression), - 'offset': Module['_BinaryenAtomicRMWGetOffset'](expression), - 'ptr': Module['_BinaryenAtomicRMWGetPtr'](expression), - 'value': Module['_BinaryenAtomicRMWGetValue'](expression) - } as AtomicRMWInfo; - case Module['AtomicCmpxchgId']: - return { - 'id': id, - 'type': type, - 'bytes': Module['_BinaryenAtomicCmpxchgGetBytes'](expression), - 'offset': Module['_BinaryenAtomicCmpxchgGetOffset'](expression), - 'ptr': Module['_BinaryenAtomicCmpxchgGetPtr'](expression), - 'expected': Module['_BinaryenAtomicCmpxchgGetExpected'](expression), - 'replacement': Module['_BinaryenAtomicCmpxchgGetReplacement'](expression) - } as AtomicCmpxchgInfo; - case Module['AtomicWaitId']: - return { - 'id': id, - 'type': type, - 'ptr': Module['_BinaryenAtomicWaitGetPtr'](expression), - 'expected': Module['_BinaryenAtomicWaitGetExpected'](expression), - 'timeout': Module['_BinaryenAtomicWaitGetTimeout'](expression), - 'expectedType': Module['_BinaryenAtomicWaitGetExpectedType'](expression) - } as AtomicWaitInfo; - case Module['AtomicNotifyId']: - return { - 'id': id, - 'type': type, - 'ptr': Module['_BinaryenAtomicNotifyGetPtr'](expression), - 'notifyCount': Module['_BinaryenAtomicNotifyGetNotifyCount'](expression) - } as AtomicNotifyInfo; - case Module['AtomicFenceId']: - return { - 'id': id, - 'type': type, - 'order': Module['_BinaryenAtomicFenceGetOrder'](expression) - } as AtomicFenceInfo; - case Module['SIMDExtractId']: - return { - 'id': id, - 'type': type, - 'op': Module['_BinaryenSIMDExtractGetOp'](expression), - 'vec': Module['_BinaryenSIMDExtractGetVec'](expression), - 'index': Module['_BinaryenSIMDExtractGetIndex'](expression) - } as SIMDExtractInfo; - case Module['SIMDReplaceId']: - return { - 'id': id, - 'type': type, - 'op': Module['_BinaryenSIMDReplaceGetOp'](expression), - 'vec': Module['_BinaryenSIMDReplaceGetVec'](expression), - 'index': Module['_BinaryenSIMDReplaceGetIndex'](expression), - 'value': Module['_BinaryenSIMDReplaceGetValue'](expression) - } as SIMDReplaceInfo; - case Module['SIMDShuffleId']: - return preserveStack(() => { - const tempBuffer = stackAlloc(16); - Module['_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': Module['_BinaryenSIMDShuffleGetLeft'](expression), - 'right': Module['_BinaryenSIMDShuffleGetRight'](expression), - 'mask': mask - } as SIMDShuffleInfo; - }); - case Module['SIMDTernaryId']: - return { - 'id': id, - 'type': type, - 'op': Module['_BinaryenSIMDTernaryGetOp'](expression), - 'a': Module['_BinaryenSIMDTernaryGetA'](expression), - 'b': Module['_BinaryenSIMDTernaryGetB'](expression), - 'c': Module['_BinaryenSIMDTernaryGetC'](expression) - } as SIMDTernaryInfo; - case Module['SIMDShiftId']: - return { - 'id': id, - 'type': type, - 'op': Module['_BinaryenSIMDShiftGetOp'](expression), - 'vec': Module['_BinaryenSIMDShiftGetVec'](expression), - 'shift': Module['_BinaryenSIMDShiftGetShift'](expression) - } as SIMDShiftInfo; - case Module['SIMDLoadId']: - return { - 'id': id, - 'type': type, - 'op': Module['_BinaryenSIMDLoadGetOp'](expression), - 'offset': Module['_BinaryenSIMDLoadGetOffset'](expression), - 'align': Module['_BinaryenSIMDLoadGetAlign'](expression), - 'ptr': Module['_BinaryenSIMDLoadGetPtr'](expression) - } as SIMDLoadInfo; - case Module['SIMDLoadStoreLaneId']: - return { - 'id': id, - 'type': type, - 'op': Module['_BinaryenSIMDLoadStoreLaneGetOp'](expression), - 'offset': Module['_BinaryenSIMDLoadStoreLaneGetOffset'](expression), - 'align': Module['_BinaryenSIMDLoadStoreLaneGetAlign'](expression), - 'index': Module['_BinaryenSIMDLoadStoreLaneGetIndex'](expression), - 'ptr': Module['_BinaryenSIMDLoadStoreLaneGetPtr'](expression), - 'vec': Module['_BinaryenSIMDLoadStoreLaneGetVec'](expression) - } as SIMDLoadStoreLaneInfo; - case Module['MemoryInitId']: - return { - 'id': id, - 'type': type, - 'segment': UTF8ToString(Module['_BinaryenMemoryInitGetSegment'](expression)), - 'dest': Module['_BinaryenMemoryInitGetDest'](expression), - 'offset': Module['_BinaryenMemoryInitGetOffset'](expression), - 'size': Module['_BinaryenMemoryInitGetSize'](expression) - } as MemoryInitInfo; - case Module['DataDropId']: - return { - 'id': id, - 'type': type, - 'segment': UTF8ToString(Module['_BinaryenDataDropGetSegment'](expression)), - } as DataDropInfo; - case Module['MemoryCopyId']: - return { - 'id': id, - 'type': type, - 'dest': Module['_BinaryenMemoryCopyGetDest'](expression), - 'source': Module['_BinaryenMemoryCopyGetSource'](expression), - 'size': Module['_BinaryenMemoryCopyGetSize'](expression) - } as MemoryCopyInfo; - case Module['MemoryFillId']: - return { - 'id': id, - 'type': type, - 'dest': Module['_BinaryenMemoryFillGetDest'](expression), - 'value': Module['_BinaryenMemoryFillGetValue'](expression), - 'size': Module['_BinaryenMemoryFillGetSize'](expression) - } as MemoryFillInfo; - case Module['RefNullId']: - return { - 'id': id, - 'type': type - } as RefNullInfo; - case Module['RefIsNullId']: - return { - 'id': id, - 'type': type, - 'value': Module['_BinaryenRefIsNullGetValue'](expression) - } as RefIsNullInfo; - case Module['RefAsId']: - return { - 'id': id, - 'type': type, - 'op': Module['_BinaryenRefAsGetOp'](expression), - 'value': Module['_BinaryenRefAsGetValue'](expression) - } as RefAsInfo; - case Module['RefFuncId']: - return { - 'id': id, - 'type': type, - 'func': UTF8ToString(Module['_BinaryenRefFuncGetFunc'](expression)), - } as RefFuncInfo; - case Module['RefEqId']: - return { - 'id': id, - 'type': type, - 'left': Module['_BinaryenRefEqGetLeft'](expression), - 'right': Module['_BinaryenRefEqGetRight'](expression) - } as RefEqInfo; - case Module['TryId']: - return { - 'id': id, - 'type': type, - 'name': UTF8ToString(Module['_BinaryenTryGetName'](expression)), - 'body': Module['_BinaryenTryGetBody'](expression), - 'catchTags': getAllNested(expression, Module['_BinaryenTryGetNumCatchTags'], Module['_BinaryenTryGetCatchTagAt']), - 'catchBodies': getAllNested(expression, Module['_BinaryenTryGetNumCatchBodies'], Module['_BinaryenTryGetCatchBodyAt']), - 'hasCatchAll': Module['_BinaryenTryHasCatchAll'](expression) as boolean, - 'delegateTarget': UTF8ToString(Module['_BinaryenTryGetDelegateTarget'](expression)) as string, - 'isDelegate': Module['_BinaryenTryIsDelegate'](expression) as boolean - } as TryInfo; - case Module['ThrowId']: - return { - 'id': id, - 'type': type, - 'tag': UTF8ToString(Module['_BinaryenThrowGetTag'](expression)), - 'operands': getAllNested(expression, Module['_BinaryenThrowGetNumOperands'], Module['_BinaryenThrowGetOperandAt']) - } as ThrowInfo; - case Module['RethrowId']: - return { - 'id': id, - 'type': type, - 'target': UTF8ToString(Module['_BinaryenRethrowGetTarget'](expression)) - } as RethrowInfo; - case Module['TupleMakeId']: - return { - 'id': id, - 'type': type, - 'operands': getAllNested(expression, Module['_BinaryenTupleMakeGetNumOperands'], Module['_BinaryenTupleMakeGetOperandAt']) - } as TupleMakeInfo; - case Module['TupleExtractId']: - return { - 'id': id, - 'type': type, - 'tuple': Module['_BinaryenTupleExtractGetTuple'](expression), - 'index': Module['_BinaryenTupleExtractGetIndex'](expression) - } as TupleExtractInfo; - case Module['RefI31Id']: - return { - 'id': id, - 'type': type, - 'value': Module['_BinaryenRefI31GetValue'](expression) - } as RefI31Info; - case Module['I31GetId']: - return { - 'id': id, - 'type': type, - 'i31': Module['_BinaryenI31GetGetI31'](expression), - 'isSigned': Boolean(Module['_BinaryenI31GetIsSigned'](expression)) - } as I31GetInfo; - default: - throw Error('unexpected id: ' + id); - } - } -} - - diff --git a/src/ts/binaryen_wasm_ts.js b/src/ts/binaryen_wasm_ts.js new file mode 100644 index 00000000000..25ba1a97602 --- /dev/null +++ b/src/ts/binaryen_wasm_ts.js @@ -0,0 +1,4 @@ +/* the purpose of this file is simply to enable compilation of the binaryen-wrapper.ts file. +Compilation of the binaryen_ts target creates the real binary_wasm_ts.js file in the build dir */ +var Binaryen = {}; +export default Binaryen; \ No newline at end of file From 76a0e7cb823ef7f9dba3711fbd403ebdb40c54a6 Mon Sep 17 00:00:00 2001 From: Eric Vergnaud Date: Wed, 13 Dec 2023 14:01:21 +0100 Subject: [PATCH 19/38] Works for all existing tests in my project --- src/ts/binaryen-post.ts | 16 +++++-- src/ts/binaryen-wrapper.ts | 95 ++++++++++++++++++++++++++++++++++---- 2 files changed, 97 insertions(+), 14 deletions(-) diff --git a/src/ts/binaryen-post.ts b/src/ts/binaryen-post.ts index e52bee0cec6..23a5a2d6d7e 100644 --- a/src/ts/binaryen-post.ts +++ b/src/ts/binaryen-post.ts @@ -1,8 +1,4 @@ declare var Module: object; -declare var HEAP8: Int8Array; -declare var HEAPU8: Uint8Array; -declare var HEAP32: Int32Array; -declare var HEAPU32: Uint32Array; declare var out: (s: string) => void; declare var stringToAscii: (s: string, ptr: number) => void; declare var stackSave: () => number; @@ -20,4 +16,14 @@ function swapOut(writer: Writer): Writer { return saved; } -Module['utils'] = { HEAP8, HEAPU8, HEAP32, HEAPU32, swapOut, stringToAscii, stackSave, stackAlloc, stackRestore, allocateUTF8OnStack, _BinaryenSizeofLiteral, _BinaryenSizeofAllocateAndWriteResult, UTF8ToString }; \ No newline at end of file +Module['utils'] = { + "swapOut": swapOut, + "stringToAscii": stringToAscii, + "stackSave": stackSave, + "stackAlloc": stackAlloc, + "stackRestore": stackRestore, + "allocateUTF8OnStack": allocateUTF8OnStack, + "_BinaryenSizeofLiteral": _BinaryenSizeofLiteral, + "_BinaryenSizeofAllocateAndWriteResult": _BinaryenSizeofAllocateAndWriteResult, + "UTF8ToString": UTF8ToString +}; \ No newline at end of file diff --git a/src/ts/binaryen-wrapper.ts b/src/ts/binaryen-wrapper.ts index 7219d736395..838d26888f2 100644 --- a/src/ts/binaryen-wrapper.ts +++ b/src/ts/binaryen-wrapper.ts @@ -1,13 +1,14 @@ +// @ts-ignore import Binaryen from "./binaryen_wasm_ts.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; type Writer = (s: string) => void; const utils = JSModule['utils']; -const HEAP8: Int8Array = utils.HEAP8; -const HEAPU8: Uint8Array = utils.HEAPU8; -const HEAP32: Int32Array = utils.HEAP32; -const HEAPU32: Uint32Array = utils.HEAPU32; const swapOut: (func: Writer) => Writer = utils.swapOut; const stringToAscii: (s: string, ptr: number) => void = utils.stringToAscii; const stackSave: () => number = utils.stackSave; @@ -17,6 +18,9 @@ const allocateUTF8OnStack: (s: string) => number = utils.allocateUTF8OnStack; const _BinaryenSizeofLiteral: () => number = utils._BinaryenSizeofLiteral; const _BinaryenSizeofAllocateAndWriteResult: () => number = utils._BinaryenSizeofAllocateAndWriteResult; const UTF8ToString: (ptr: number) => string | null = utils.UTF8ToString; +const __i32_store: (offset: number, value: number) => void = JSModule['__i32_store']; +const __i32_load: (offset: number) => number = JSModule['__i32_load']; + function preserveStack(func: () => R): R { try { @@ -27,7 +31,7 @@ function preserveStack(func: () => R): R { } } -function strToStack(str) { +function strToStack(str: string) { return str ? allocateUTF8OnStack(str) : 0; } @@ -50,7 +54,7 @@ function getAllNested(ref: ExpressionRef, numFn: (ref: ExpressionRef) => numb return ret; } -export const sizeOfLiteral: number = 0; +export const sizeOfLiteral: number = _BinaryenSizeofLiteral(); export type Type = number; export type ElementSegmentRef = number; @@ -62,6 +66,8 @@ 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'](); @@ -586,6 +592,12 @@ export enum SideEffects { Any = JSModule['_BinaryenSideEffectAny']() } +export enum PackedType { + NotPacked = JSModule['_BinaryenPackedTypeNotPacked'](), + Int8 = JSModule['_BinaryenPackedTypeInt8'](), + Int16 = JSModule['_BinaryenPackedTypeInt16']() +} + export class Function { readonly func: FunctionRef; @@ -643,7 +655,7 @@ export class Function { 'body':this.getBody() }; } -}; +} export interface FunctionInfo { name: string; @@ -2088,7 +2100,7 @@ export class Module { } get memory () { return { - init: (segment: number, dest: ExpressionRef, offset: ExpressionRef, size: ExpressionRef, name?: string): ExpressionRef => + init: (segment: string, dest: ExpressionRef, offset: ExpressionRef, size: ExpressionRef, name?: string): ExpressionRef => preserveStack(() => JSModule['_BinaryenMemoryInit'](this.ptr, strToStack(segment), dest, offset, size, strToStack(name))), has: () => Boolean(JSModule['_BinaryenHasMemory'](this.ptr)), size: (name?: string, memory64?: boolean): ExpressionRef => JSModule['_BinaryenMemorySize'](this.ptr, strToStack(name), memory64), @@ -2182,7 +2194,7 @@ export class Module { } get data () { return { - drop: (segment: number): ExpressionRef => preserveStack(() => JSModule['_BinaryenDataDrop'](this.ptr, strToStack(segment))) + drop: (segment: string): ExpressionRef => preserveStack(() => JSModule['_BinaryenDataDrop'](this.ptr, strToStack(segment))) }; } get exports () { @@ -2217,6 +2229,21 @@ export class Module { } }; } + get arrays () { + return { + fromValues: (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; + }) + return JSModule['_BinaryenArrayNewFixed'](this.ptr, heapType, ptr, values.length); + } + + + } + } } export class Relooper { @@ -2267,6 +2294,56 @@ export class ExpressionRunner { } } +export interface TypeBuilderResult { + heapTypes: HeapType[]; + errorIndex: number | null; + errorReason: number | null; +} + +export class TypeBuilder { + + static typeFromTempHeapType(heapType: HeapType, nullable: boolean): Type { + return JSModule['_BinaryenTypeFromHeapType'](heapType, nullable); + } + + readonly ref: TypeBuilderRef; + + constructor(slots: number) { + this.ref = JSModule['_TypeBuilderCreate'](slots); + } + + setArrayType(slot: number, elementType: Type, elementPackedType: PackedType, mutable: boolean): TypeBuilder { + JSModule['_TypeBuilderSetArrayType'](this.ref, slot, elementType, elementPackedType, mutable); + 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 { offset: ExpressionRef; data: Uint8Array; From ec80d0168e9d0cb7f728c3f739a2ef6d9028007d Mon Sep 17 00:00:00 2001 From: Eric Vergnaud Date: Wed, 13 Dec 2023 14:39:40 +0100 Subject: [PATCH 20/38] rename for consistency --- CMakeLists.txt | 12 ++++++------ src/ts/{binaryen-wrapper.ts => binaryen_ts.ts} | 0 2 files changed, 6 insertions(+), 6 deletions(-) rename src/ts/{binaryen-wrapper.ts => binaryen_ts.ts} (100%) diff --git a/CMakeLists.txt b/CMakeLists.txt index 15a1d04d521..2bbcbb799aa 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -528,18 +528,18 @@ if(EMSCRIPTEN) # binaryen.ts TypeScript variant (leverages the wasm variant) # compile the typescript file that wraps the wasm - add_custom_target(binaryen_wrap_ts + add_custom_target(binaryen_ts_wrapper COMMAND tsc --target ES2020 --module ES2022 --declaration --declarationMap - ${CMAKE_CURRENT_SOURCE_DIR}/src/ts/binaryen-wrapper.ts && - mv ${CMAKE_CURRENT_SOURCE_DIR}/src/ts/binaryen-wrapper.js ${CMAKE_BINARY_DIR}/bin/binaryen_ts.js && - mv ${CMAKE_CURRENT_SOURCE_DIR}/src/ts/binaryen-wrapper.d.ts ${CMAKE_BINARY_DIR}/bin/binaryen_ts.d.ts && - mv ${CMAKE_CURRENT_SOURCE_DIR}/src/ts/binaryen-wrapper.d.ts.map ${CMAKE_BINARY_DIR}/bin/binaryen_ts.d.ts.map) + ${CMAKE_CURRENT_SOURCE_DIR}/src/ts/binaryen_ts.ts && + mv ${CMAKE_CURRENT_SOURCE_DIR}/src/ts/binaryen_ts.js ${CMAKE_BINARY_DIR}/bin/binaryen_ts.js && + mv ${CMAKE_CURRENT_SOURCE_DIR}/src/ts/binaryen_ts.d.ts ${CMAKE_BINARY_DIR}/bin/binaryen_ts.d.ts && + mv ${CMAKE_CURRENT_SOURCE_DIR}/src/ts/binaryen_ts.d.ts.map ${CMAKE_BINARY_DIR}/bin/binaryen_ts.d.ts.map) add_custom_target(binaryen_post_ts COMMAND tsc --target ES2020 --module ES2022 ${CMAKE_CURRENT_SOURCE_DIR}/src/ts/binaryen-post.ts) add_executable(binaryen_wasm_ts ${binaryen_emscripten_SOURCES}) - add_dependencies(binaryen_wasm_ts binaryen_wrap_ts binaryen_post_ts) + add_dependencies(binaryen_wasm_ts binaryen_ts_wrapper binaryen_post_ts) target_link_libraries(binaryen_wasm_ts wasm asmjs emscripten-optimizer passes ir cfg support analysis parser wasm) target_link_libraries(binaryen_wasm_ts "-sFILESYSTEM") target_link_libraries(binaryen_wasm_ts "-sEXPORT_NAME=Binaryen") diff --git a/src/ts/binaryen-wrapper.ts b/src/ts/binaryen_ts.ts similarity index 100% rename from src/ts/binaryen-wrapper.ts rename to src/ts/binaryen_ts.ts From 898cb2d817af67bb2a32168e6f58a5a1f8cb1cdb Mon Sep 17 00:00:00 2001 From: Eric Vergnaud Date: Wed, 13 Dec 2023 14:44:16 +0100 Subject: [PATCH 21/38] Fix typos --- .gitignore | 4 ++-- src/ts/binaryen_wasm_ts.js | 4 ++-- 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/.gitignore b/.gitignore index 969e07ac92b..5a9aa9c3ad0 100644 --- a/.gitignore +++ b/.gitignore @@ -54,6 +54,6 @@ test/lit/lit.site.cfg.py # files related to tsc compilation /src/ts/binaryen-post.js /src/ts/binaryen-post.d.ts -/src/ts/binaryen-wrapper.d.ts -/src/ts/binaryen-wrapper.js +/src/ts/binaryen_ts.d.ts +/src/ts/binaryen_ts.js /*.map diff --git a/src/ts/binaryen_wasm_ts.js b/src/ts/binaryen_wasm_ts.js index 25ba1a97602..f2ebcfddb79 100644 --- a/src/ts/binaryen_wasm_ts.js +++ b/src/ts/binaryen_wasm_ts.js @@ -1,4 +1,4 @@ -/* the purpose of this file is simply to enable compilation of the binaryen-wrapper.ts file. -Compilation of the binaryen_ts target creates the real binary_wasm_ts.js file in the build dir */ +/* the purpose of this file is simply to enable local compilation of the binaryen_ts.ts file. +Compilation of the binaryen_wasm_ts target creates the real binary_wasm_ts.js file in the build dir */ var Binaryen = {}; export default Binaryen; \ No newline at end of file From 36c07477caf37f4b010983d41ed4df3ec1cd3449 Mon Sep 17 00:00:00 2001 From: Eric Vergnaud Date: Wed, 13 Dec 2023 20:53:55 +0100 Subject: [PATCH 22/38] Fix Feature API --- src/ts/binaryen_ts.ts | 32 +++++++++++++++++++++++++++----- 1 file changed, 27 insertions(+), 5 deletions(-) diff --git a/src/ts/binaryen_ts.ts b/src/ts/binaryen_ts.ts index 838d26888f2..c347c68d0df 100644 --- a/src/ts/binaryen_ts.ts +++ b/src/ts/binaryen_ts.ts @@ -114,7 +114,7 @@ export enum ExternalKinds { Tag = JSModule['_BinaryenExternalTag']() } -export enum Features { +export enum Feature { MVP = JSModule['_BinaryenFeatureMVP'](), Atomics = JSModule['_BinaryenFeatureAtomics'](), BulkMemory = JSModule['_BinaryenFeatureBulkMemory'](), @@ -811,12 +811,34 @@ export class Module { setStart(start: FunctionRef): void { JSModule['_BinaryenSetStart'](this.ptr, start); } - setFeatures(features: Features): void { - JSModule['_BinaryenModuleSetFeatures'](this.ptr, features); + setFeatures(... features: Feature[]): void { + const flags = features.reduce((previous, current) => previous |= current, 0); + JSModule['_BinaryenModuleSetFeatures'](this.ptr, flags); } - getFeatures(): Features { - return JSModule['_BinaryenModuleGetFeatures'](this.ptr); + 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); } From 4036adec01550de96b79f0114ce558f4eb5509ca Mon Sep 17 00:00:00 2001 From: Eric Vergnaud Date: Thu, 21 Dec 2023 18:33:32 +0100 Subject: [PATCH 23/38] implements a new approach --- CMakeLists.txt | 55 +- src/js/binaryen.js-post.js | 4935 ----------------- src/ts/README.md | 19 + src/ts/{binaryen_ts.ts => binaryen.ts} | 3 +- src/ts/{binaryen-post.ts => binaryen_post.ts} | 0 src/ts/binaryen_raw_TARGET.js | 5 + src/ts/binaryen_wasm_ts.js | 4 - 7 files changed, 44 insertions(+), 4977 deletions(-) delete mode 100644 src/js/binaryen.js-post.js create mode 100644 src/ts/README.md rename src/ts/{binaryen_ts.ts => binaryen.ts} (99%) rename src/ts/{binaryen-post.ts => binaryen_post.ts} (100%) create mode 100644 src/ts/binaryen_raw_TARGET.js delete mode 100644 src/ts/binaryen_wasm_ts.js diff --git a/CMakeLists.txt b/CMakeLists.txt index 2bbcbb799aa..797e8990f6b 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -455,8 +455,18 @@ 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 + 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) 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") @@ -466,7 +476,7 @@ if(EMSCRIPTEN) target_link_libraries(binaryen_wasm "-sEXPORTED_FUNCTIONS=_malloc,_free") # useful when working on --post-js file # target_link_libraries(binaryen_wasm "--minify=0") - target_link_libraries(binaryen_wasm "--post-js=${CMAKE_CURRENT_SOURCE_DIR}/src/js/binaryen.js-post.js") + 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=1") @@ -478,8 +488,15 @@ if(EMSCRIPTEN) install(TARGETS binaryen_wasm DESTINATION ${CMAKE_INSTALL_BINDIR}) # binaryen.js JavaScript variant + # compile the TypeScript file that wraps the generated js + 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) 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") @@ -507,7 +524,7 @@ if(EMSCRIPTEN) target_link_libraries(binaryen_js "-sEXPORTED_FUNCTIONS=_malloc,_free") # useful when working on --post-js file # target_link_libraries(binaryen_js "--minify=0") - target_link_libraries(binaryen_js "--post-js=${CMAKE_CURRENT_SOURCE_DIR}/src/js/binaryen.js-post.js") + 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") @@ -526,40 +543,6 @@ if(EMSCRIPTEN) target_link_libraries(binaryen_js debug "-sASSERTIONS") install(TARGETS binaryen_js DESTINATION ${CMAKE_INSTALL_BINDIR}) - # binaryen.ts TypeScript variant (leverages the wasm variant) - # compile the typescript file that wraps the wasm - add_custom_target(binaryen_ts_wrapper - COMMAND tsc --target ES2020 --module ES2022 --declaration --declarationMap - ${CMAKE_CURRENT_SOURCE_DIR}/src/ts/binaryen_ts.ts && - mv ${CMAKE_CURRENT_SOURCE_DIR}/src/ts/binaryen_ts.js ${CMAKE_BINARY_DIR}/bin/binaryen_ts.js && - mv ${CMAKE_CURRENT_SOURCE_DIR}/src/ts/binaryen_ts.d.ts ${CMAKE_BINARY_DIR}/bin/binaryen_ts.d.ts && - mv ${CMAKE_CURRENT_SOURCE_DIR}/src/ts/binaryen_ts.d.ts.map ${CMAKE_BINARY_DIR}/bin/binaryen_ts.d.ts.map) - add_custom_target(binaryen_post_ts - COMMAND tsc --target ES2020 --module ES2022 - ${CMAKE_CURRENT_SOURCE_DIR}/src/ts/binaryen-post.ts) - add_executable(binaryen_wasm_ts - ${binaryen_emscripten_SOURCES}) - add_dependencies(binaryen_wasm_ts binaryen_ts_wrapper binaryen_post_ts) - target_link_libraries(binaryen_wasm_ts wasm asmjs emscripten-optimizer passes ir cfg support analysis parser wasm) - target_link_libraries(binaryen_wasm_ts "-sFILESYSTEM") - target_link_libraries(binaryen_wasm_ts "-sEXPORT_NAME=Binaryen") - target_link_libraries(binaryen_wasm_ts "-sNODERAWFS=0") - target_link_libraries(binaryen_wasm_ts "-sEXPORT_ES6") - target_link_libraries(binaryen_wasm_ts "-sEXPORTED_RUNTIME_METHODS=allocateUTF8OnStack,stringToAscii") - target_link_libraries(binaryen_wasm_ts "-sEXPORTED_FUNCTIONS=_malloc,_free") - # useful when working on --post-js file - # target_link_libraries(binaryen_wasm_ts "--minify=0") - target_link_libraries(binaryen_wasm_ts "--post-js=${CMAKE_CURRENT_SOURCE_DIR}/src/ts/binaryen-post.js") - target_link_libraries(binaryen_wasm_ts "-msign-ext") - target_link_libraries(binaryen_wasm_ts "-mbulk-memory") - target_link_libraries(binaryen_wasm_ts optimized "--closure=1") - target_link_libraries(binaryen_wasm_ts optimized "--closure-args=\"--language_in=ECMASCRIPT6 --language_out=ECMASCRIPT6\"") - # TODO: Fix closure warnings! (#5062) - target_link_libraries(binaryen_wasm_ts optimized "-Wno-error=closure") - target_link_libraries(binaryen_wasm_ts optimized "-flto") - target_link_libraries(binaryen_wasm_ts debug "--profiling") - install(TARGETS binaryen_wasm_ts 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 4ff719b305d..00000000000 --- a/src/js/binaryen.js-post.js +++ /dev/null @@ -1,4935 +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 segmentData = new Array(segmentsLen); - const segmentDataLen = new Array(segmentsLen); - const segmentPassive = new Array(segmentsLen); - const segmentOffset = new Array(segmentsLen); - for (let i = 0; i < segmentsLen; i++) { - const { data, offset, passive } = segments[i]; - segmentData[i] = _malloc(data.length); - HEAP8.set(data, segmentData[i]); - segmentDataLen[i] = data.length; - segmentPassive[i] = passive; - segmentOffset[i] = offset; - } - const ret = Module['_BinaryenSetMemory']( - module, initial, maximum, strToStack(exportName), - i32sToStack(segmentData), - i8sToStack(segmentPassive), - i32sToStack(segmentOffset), - i32sToStack(segmentDataLen), - segmentsLen, - shared, - memory64, - strToStack(internalName) - ); - for (let i = 0; i < segmentsLen; i++) { - _free(segmentData[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['getMemorySegmentInfoByIndex'] = function(id) { - const passive = Boolean(Module['_BinaryenGetMemorySegmentPassive'](module, id)); - let offset = null; - if (!passive) { - offset = Module['_BinaryenGetMemorySegmentByteOffset'](module, id); - } - return { - 'offset': offset, - 'data': (function(){ - const size = Module['_BinaryenGetMemorySegmentByteLength'](module, id); - const ptr = _malloc(size); - Module['_BinaryenCopyMemorySegmentData'](module, id, 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.ts b/src/ts/binaryen.ts similarity index 99% rename from src/ts/binaryen_ts.ts rename to src/ts/binaryen.ts index c347c68d0df..8facbb90665 100644 --- a/src/ts/binaryen_ts.ts +++ b/src/ts/binaryen.ts @@ -1,6 +1,5 @@ // @ts-ignore -import Binaryen from "./binaryen_wasm_ts.js" -const JSModule = await Binaryen(); +const JSModule = await import("./binaryen_raw_TARGET.js"); const _malloc: (size: number) => number = JSModule._malloc; const _free: (size: number) => void = JSModule._free; const HEAP8: Int8Array = JSModule.HEAP8; diff --git a/src/ts/binaryen-post.ts b/src/ts/binaryen_post.ts similarity index 100% rename from src/ts/binaryen-post.ts rename to src/ts/binaryen_post.ts 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 diff --git a/src/ts/binaryen_wasm_ts.js b/src/ts/binaryen_wasm_ts.js deleted file mode 100644 index f2ebcfddb79..00000000000 --- a/src/ts/binaryen_wasm_ts.js +++ /dev/null @@ -1,4 +0,0 @@ -/* the purpose of this file is simply to enable local compilation of the binaryen_ts.ts file. -Compilation of the binaryen_wasm_ts target creates the real binary_wasm_ts.js file in the build dir */ -var Binaryen = {}; -export default Binaryen; \ No newline at end of file From 95f3df37e28c38d7a6e3c7ac5e86777b9b7ecaf6 Mon Sep 17 00:00:00 2001 From: Eric Vergnaud Date: Thu, 21 Dec 2023 19:21:55 +0100 Subject: [PATCH 24/38] need to await on the imported function, not the import --- src/ts/binaryen.ts | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/src/ts/binaryen.ts b/src/ts/binaryen.ts index 8facbb90665..9ea3e75fa7b 100644 --- a/src/ts/binaryen.ts +++ b/src/ts/binaryen.ts @@ -1,5 +1,6 @@ // @ts-ignore -const JSModule = await import("./binaryen_raw_TARGET.js"); +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; From b0c24cda981fee06d98b48b33ed2d82d7fda9bed Mon Sep 17 00:00:00 2001 From: Eric Vergnaud Date: Thu, 21 Dec 2023 19:48:32 +0100 Subject: [PATCH 25/38] house keeping --- .gitignore | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/.gitignore b/.gitignore index 5a9aa9c3ad0..93c9356846b 100644 --- a/.gitignore +++ b/.gitignore @@ -52,8 +52,8 @@ test/lit/lit.site.cfg.py .cache/* # files related to tsc compilation -/src/ts/binaryen-post.js -/src/ts/binaryen-post.d.ts -/src/ts/binaryen_ts.d.ts -/src/ts/binaryen_ts.js +/src/ts/binaryen_post.js +/src/ts/binaryen_post.d.ts +/src/ts/binaryen.d.ts +/src/ts/binaryen.js /*.map From 67b9213da5b25d7de4981a25909fb496a9289c21 Mon Sep 17 00:00:00 2001 From: Eric Vergnaud Date: Sat, 6 Jan 2024 14:37:20 +0100 Subject: [PATCH 26/38] fix memory leak and add support for get array item --- src/ts/binaryen.ts | 10 ++++++---- 1 file changed, 6 insertions(+), 4 deletions(-) diff --git a/src/ts/binaryen.ts b/src/ts/binaryen.ts index 9ea3e75fa7b..00244eabaa2 100644 --- a/src/ts/binaryen.ts +++ b/src/ts/binaryen.ts @@ -2260,10 +2260,12 @@ export class Module { __i32_store(offset, value); offset += 4; }) - return JSModule['_BinaryenArrayNewFixed'](this.ptr, heapType, ptr, values.length); - } - - + const result = JSModule['_BinaryenArrayNewFixed'](this.ptr, heapType, ptr, values.length); + _free(ptr); + return result; + }, + getItem: (array: ExpressionRef, item: ExpressionRef, type: Type, signed: boolean): ExpressionRef => + JSModule['_BinaryenArrayGet'](this.ptr, array, item, type, signed) } } } From cbb6c008107d3a8d982c3ad6a4ce48cd6d2b26c0 Mon Sep 17 00:00:00 2001 From: Eric Vergnaud Date: Tue, 9 Jan 2024 16:08:15 +0100 Subject: [PATCH 27/38] more arrays API --- src/ts/binaryen.ts | 12 ++++++++++-- 1 file changed, 10 insertions(+), 2 deletions(-) diff --git a/src/ts/binaryen.ts b/src/ts/binaryen.ts index 00244eabaa2..770eeb5521d 100644 --- a/src/ts/binaryen.ts +++ b/src/ts/binaryen.ts @@ -2253,7 +2253,9 @@ export class Module { } get arrays () { return { - fromValues: (heapType: HeapType, values: ExpressionRef[]): ExpressionRef => { + newWithInit: (heapType: HeapType, size: ExpressionRef, init: ExpressionRef): ExpressionRef => + JSModule['BinaryenArrayNew'](this.ptr, heapType, size, init), + newFromValues: (heapType: HeapType, values: ExpressionRef[]): ExpressionRef => { const ptr = _malloc(Math.max(8, values.length * 4)); let offset = ptr; values.forEach(value => { @@ -2264,8 +2266,14 @@ export class Module { _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) + 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) } } } From b779e22fe1a0ab1ad220a0981c62d1385ac346f8 Mon Sep 17 00:00:00 2001 From: Eric Vergnaud Date: Sat, 13 Jan 2024 21:59:37 +0100 Subject: [PATCH 28/38] add support for structs, unify GC field type --- src/ts/binaryen.ts | 48 +++++++++++++++++++++++++++++++++++++++++++--- 1 file changed, 45 insertions(+), 3 deletions(-) diff --git a/src/ts/binaryen.ts b/src/ts/binaryen.ts index 770eeb5521d..ecf64a01da2 100644 --- a/src/ts/binaryen.ts +++ b/src/ts/binaryen.ts @@ -2255,7 +2255,7 @@ export class Module { return { newWithInit: (heapType: HeapType, size: ExpressionRef, init: ExpressionRef): ExpressionRef => JSModule['BinaryenArrayNew'](this.ptr, heapType, size, init), - newFromValues: (heapType: HeapType, values: ExpressionRef[]): ExpressionRef => { + newFromItems: (heapType: HeapType, values: ExpressionRef[]): ExpressionRef => { const ptr = _malloc(Math.max(8, values.length * 4)); let offset = ptr; values.forEach(value => { @@ -2276,6 +2276,25 @@ export class Module { 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 { @@ -2332,6 +2351,11 @@ export interface TypeBuilderResult { errorReason: number | null; } +export interface FieldType { + type: Type, + packedType: PackedType, + mutable: boolean +} export class TypeBuilder { static typeFromTempHeapType(heapType: HeapType, nullable: boolean): Type { @@ -2344,8 +2368,26 @@ export class TypeBuilder { this.ref = JSModule['_TypeBuilderCreate'](slots); } - setArrayType(slot: number, elementType: Type, elementPackedType: PackedType, mutable: boolean): TypeBuilder { - JSModule['_TypeBuilderSetArrayType'](this.ref, slot, elementType, elementPackedType, mutable); + 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 4 + const mutables = _malloc(4 * 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 += 4; + }); + JSModule['_TypeBuilderSetStructType'](this.ref, slot, types, packedTypes, mutables, fieldTypes.length); + _free(mutables); + _free(packedTypes); + _free(types); return this; } From d1b34d2179bb51d61052fc398da1de2adf8f6023 Mon Sep 17 00:00:00 2001 From: Eric Vergnaud Date: Sat, 13 Jan 2024 22:37:28 +0100 Subject: [PATCH 29/38] use powershell commands on windows --- CMakeLists.txt | 14 ++++++++++++++ 1 file changed, 14 insertions(+) diff --git a/CMakeLists.txt b/CMakeLists.txt index 797e8990f6b..5caa62e75e5 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -459,10 +459,17 @@ if(EMSCRIPTEN) 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) @@ -489,10 +496,17 @@ if(EMSCRIPTEN) # 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) From deea92de7ba1217fd501dc4e9ffb97c28c0113eb Mon Sep 17 00:00:00 2001 From: Eric Vergnaud Date: Sun, 14 Jan 2024 02:32:36 +0100 Subject: [PATCH 30/38] rely on built-in exports mechanism --- CMakeLists.txt | 8 ++++---- src/ts/binaryen.ts | 18 +++++++++--------- src/ts/binaryen_post.ts | 14 +------------- 3 files changed, 14 insertions(+), 26 deletions(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index 5caa62e75e5..850970d146c 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -465,7 +465,7 @@ if(EMSCRIPTEN) 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 + 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) @@ -479,7 +479,7 @@ if(EMSCRIPTEN) 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") # useful when working on --post-js file # target_link_libraries(binaryen_wasm "--minify=0") @@ -502,7 +502,7 @@ if(EMSCRIPTEN) 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 + 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) @@ -534,7 +534,7 @@ 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") # useful when working on --post-js file # target_link_libraries(binaryen_js "--minify=0") diff --git a/src/ts/binaryen.ts b/src/ts/binaryen.ts index ecf64a01da2..91abc2ad34a 100644 --- a/src/ts/binaryen.ts +++ b/src/ts/binaryen.ts @@ -7,19 +7,19 @@ const HEAP8: Int8Array = JSModule.HEAP8; const HEAPU8: Uint8Array = JSModule.HEAPU8; const HEAP32: Int32Array = JSModule.HEAP32; const HEAPU32: Uint32Array = JSModule.HEAPU32; -type Writer = (s: string) => void; +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 = (s: string) => void; const swapOut: (func: Writer) => Writer = utils.swapOut; -const stringToAscii: (s: string, ptr: number) => void = utils.stringToAscii; -const stackSave: () => number = utils.stackSave; -const stackAlloc: (size: number) => number = utils.stackAlloc; -const stackRestore: (ref: number) => void = utils.stackRestore; -const allocateUTF8OnStack: (s: string) => number = utils.allocateUTF8OnStack; const _BinaryenSizeofLiteral: () => number = utils._BinaryenSizeofLiteral; const _BinaryenSizeofAllocateAndWriteResult: () => number = utils._BinaryenSizeofAllocateAndWriteResult; -const UTF8ToString: (ptr: number) => string | null = utils.UTF8ToString; -const __i32_store: (offset: number, value: number) => void = JSModule['__i32_store']; -const __i32_load: (offset: number) => number = JSModule['__i32_load']; function preserveStack(func: () => R): R { diff --git a/src/ts/binaryen_post.ts b/src/ts/binaryen_post.ts index 23a5a2d6d7e..9f798e1fb72 100644 --- a/src/ts/binaryen_post.ts +++ b/src/ts/binaryen_post.ts @@ -1,13 +1,7 @@ declare var Module: object; declare var out: (s: string) => void; -declare var stringToAscii: (s: string, ptr: number) => void; -declare var stackSave: () => number; -declare var stackAlloc: (size: number) => number; -declare var stackRestore: (ref: number) => void; -declare var allocateUTF8OnStack: (s: string) => number; declare var _BinaryenSizeofLiteral: () => number; declare var _BinaryenSizeofAllocateAndWriteResult: () => number; -declare var UTF8ToString: (ptr: number) => string | null; type Writer = (s: string) => void; function swapOut(writer: Writer): Writer { @@ -18,12 +12,6 @@ function swapOut(writer: Writer): Writer { Module['utils'] = { "swapOut": swapOut, - "stringToAscii": stringToAscii, - "stackSave": stackSave, - "stackAlloc": stackAlloc, - "stackRestore": stackRestore, - "allocateUTF8OnStack": allocateUTF8OnStack, "_BinaryenSizeofLiteral": _BinaryenSizeofLiteral, - "_BinaryenSizeofAllocateAndWriteResult": _BinaryenSizeofAllocateAndWriteResult, - "UTF8ToString": UTF8ToString + "_BinaryenSizeofAllocateAndWriteResult": _BinaryenSizeofAllocateAndWriteResult }; \ No newline at end of file From 76d7f08ff89f421b2dd0427c7fbbc56743815ef9 Mon Sep 17 00:00:00 2001 From: Eric Vergnaud Date: Tue, 23 Jan 2024 22:41:32 +0100 Subject: [PATCH 31/38] more GC methods Signed-off-by: Eric Vergnaud --- src/ts/binaryen.ts | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/ts/binaryen.ts b/src/ts/binaryen.ts index 91abc2ad34a..9b36bc4f3eb 100644 --- a/src/ts/binaryen.ts +++ b/src/ts/binaryen.ts @@ -2253,7 +2253,7 @@ export class Module { } get arrays () { return { - newWithInit: (heapType: HeapType, size: ExpressionRef, init: ExpressionRef): ExpressionRef => + newFromInit: (heapType: HeapType, size: ExpressionRef, init: ExpressionRef): ExpressionRef => JSModule['BinaryenArrayNew'](this.ptr, heapType, size, init), newFromItems: (heapType: HeapType, values: ExpressionRef[]): ExpressionRef => { const ptr = _malloc(Math.max(8, values.length * 4)); @@ -2362,6 +2362,22 @@ export class TypeBuilder { 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) { From 4199884b148ea62c693991484b0e82c433c503ec Mon Sep 17 00:00:00 2001 From: Eric Vergnaud Date: Wed, 24 Jan 2024 14:21:40 +0100 Subject: [PATCH 32/38] add support for BinaryenArrayNewData Signed-off-by: Eric Vergnaud (cherry picked from commit 0e1c3f305815a3417a97aa75bbd9e6b4ed5d739d) --- src/binaryen-c.cpp | 10 ++++++++++ src/binaryen-c.h | 6 +++++- 2 files changed, 15 insertions(+), 1 deletion(-) diff --git a/src/binaryen-c.cpp b/src/binaryen-c.cpp index b53f5fd0c11..4b7d8cb6a9a 100644 --- a/src/binaryen-c.cpp +++ b/src/binaryen-c.cpp @@ -1815,6 +1815,16 @@ BinaryenExpressionRef BinaryenArrayNew(BinaryenModuleRef module, Builder(*(Module*)module) .makeArrayNew(HeapType(type), (Expression*)size, (Expression*)init)); } +BinaryenExpressionRef BinaryenArrayNewData(BinaryenModuleRef module, + BinaryenHeapType type, + const char* name, + BinaryenExpressionRef offset, + BinaryenExpressionRef size) { +return static_cast( + Builder(*(Module*)module) + .makeArrayNewData(HeapType(type), name, (Expression*)offset, (Expression*)size)); +} + BinaryenExpressionRef BinaryenArrayNewFixed(BinaryenModuleRef module, BinaryenHeapType type, BinaryenExpressionRef* values, diff --git a/src/binaryen-c.h b/src/binaryen-c.h index 82de2dae934..4f47b9d34ab 100644 --- a/src/binaryen-c.h +++ b/src/binaryen-c.h @@ -1073,7 +1073,11 @@ BINARYEN_API BinaryenExpressionRef BinaryenArrayNew(BinaryenModuleRef module, BinaryenExpressionRef size, BinaryenExpressionRef init); -// TODO: BinaryenArrayNewSeg +BINARYEN_API BinaryenExpressionRef BinaryenArrayNewData(BinaryenModuleRef module, + BinaryenHeapType type, + const char* name, + BinaryenExpressionRef offset, + BinaryenExpressionRef size) BINARYEN_API BinaryenExpressionRef BinaryenArrayNewFixed(BinaryenModuleRef module, From 59a05f07de410dbedbabd9e1ea990e4b3f7c864a Mon Sep 17 00:00:00 2001 From: Eric Vergnaud Date: Wed, 24 Jan 2024 14:48:09 +0100 Subject: [PATCH 33/38] add entry point for BinaryenArrayNewData Signed-off-by: Eric Vergnaud --- src/ts/binaryen.ts | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/src/ts/binaryen.ts b/src/ts/binaryen.ts index 9b36bc4f3eb..766d4c20acf 100644 --- a/src/ts/binaryen.ts +++ b/src/ts/binaryen.ts @@ -2254,7 +2254,9 @@ export class Module { get arrays () { return { newFromInit: (heapType: HeapType, size: ExpressionRef, init: ExpressionRef): ExpressionRef => - JSModule['BinaryenArrayNew'](this.ptr, heapType, size, init), + 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; From 34b692f369ea3d5903bdc7016cfc148b292b30ef Mon Sep 17 00:00:00 2001 From: Eric Vergnaud Date: Wed, 24 Jan 2024 14:49:04 +0100 Subject: [PATCH 34/38] fix missing semicolon (cherry picked from commit 6eb31b93a3a28aa8678f7d9dde3ed97c728cc449) --- src/binaryen-c.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/binaryen-c.h b/src/binaryen-c.h index 4f47b9d34ab..df9661b0450 100644 --- a/src/binaryen-c.h +++ b/src/binaryen-c.h @@ -1077,7 +1077,7 @@ BINARYEN_API BinaryenExpressionRef BinaryenArrayNewData(BinaryenModuleRef module BinaryenHeapType type, const char* name, BinaryenExpressionRef offset, - BinaryenExpressionRef size) + BinaryenExpressionRef size); BINARYEN_API BinaryenExpressionRef BinaryenArrayNewFixed(BinaryenModuleRef module, From 8efbe18a7e9b935004b1576d720395ce5cc91991 Mon Sep 17 00:00:00 2001 From: Eric Vergnaud Date: Tue, 30 Jan 2024 10:48:30 +0100 Subject: [PATCH 35/38] simplify --- CMakeLists.txt | 8 ++++---- src/ts/binaryen.ts | 36 ++++++++++++++++++------------------ 2 files changed, 22 insertions(+), 22 deletions(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index 850970d146c..ff47f794a39 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") @@ -482,11 +482,11 @@ if(EMSCRIPTEN) target_link_libraries(binaryen_wasm "-sEXPORTED_RUNTIME_METHODS=allocateUTF8OnStack,stringToAscii,stackSave,stackAlloc,stackRestore,UTF8ToString") target_link_libraries(binaryen_wasm "-sEXPORTED_FUNCTIONS=_malloc,_free") # useful when working on --post-js file - # target_link_libraries(binaryen_wasm "--minify=0") + 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=1") + target_link_libraries(binaryen_wasm optimized "--closure=0") target_link_libraries(binaryen_wasm optimized "--closure-args=\"--language_in=ECMASCRIPT6 --language_out=ECMASCRIPT6\"") # TODO: Fix closure warnings! (#5062) target_link_libraries(binaryen_wasm optimized "-Wno-error=closure") diff --git a/src/ts/binaryen.ts b/src/ts/binaryen.ts index 766d4c20acf..a49588416c9 100644 --- a/src/ts/binaryen.ts +++ b/src/ts/binaryen.ts @@ -2134,31 +2134,31 @@ export class Module { 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 segmentData = new Array(segmentsLen); - const segmentDataLen = new Array(segmentsLen); - const segmentPassive = new Array(segmentsLen); - const segmentOffset = 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 { data, offset, passive } = segments[i]; - segmentData[i] = _malloc(data.length); - HEAP8.set(data, segmentData[i]); - segmentDataLen[i] = data.length; - segmentPassive[i] = passive; - segmentOffset[i] = offset; + 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(segmentData), - i8sToStack(segmentPassive), - i32sToStack(segmentOffset), - i32sToStack(segmentDataLen), + i32sToStack(datas), + i8sToStack(passives), + i32sToStack(offsets), + i32sToStack(lengths), segmentsLen, shared, memory64, strToStack(internalName) ); - for (let i = 0; i < segmentsLen; i++) { - _free(segmentData[i]); + for (let i = segmentsLen - 1; i >= 0; i--) { + _free(datas[i]); } return ret; }), @@ -2394,13 +2394,13 @@ export class TypeBuilder { setStructType(slot: number, fieldTypes: FieldType[]): TypeBuilder { const types = _malloc(4 * fieldTypes.length); const packedTypes = _malloc(4 * fieldTypes.length); - // assume sizeof(bool) is 4 - const mutables = _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 += 4; + __i32_store(mutablesPtr, field.mutable ? 1 : 0); mutablesPtr ++; }); JSModule['_TypeBuilderSetStructType'](this.ref, slot, types, packedTypes, mutables, fieldTypes.length); _free(mutables); From f2019de8fed2fb9cf4b7173fcdf6360e68e89f73 Mon Sep 17 00:00:00 2001 From: Eric Vergnaud Date: Thu, 1 Feb 2024 22:53:20 +0100 Subject: [PATCH 36/38] update memory API --- src/ts/binaryen.ts | 28 ++++++++++++++++------------ 1 file changed, 16 insertions(+), 12 deletions(-) diff --git a/src/ts/binaryen.ts b/src/ts/binaryen.ts index a49588416c9..b56baed0580 100644 --- a/src/ts/binaryen.ts +++ b/src/ts/binaryen.ts @@ -2122,8 +2122,8 @@ export class Module { } get memory () { return { - init: (segment: string, dest: ExpressionRef, offset: ExpressionRef, size: ExpressionRef, name?: string): ExpressionRef => - preserveStack(() => JSModule['_BinaryenMemoryInit'](this.ptr, strToStack(segment), dest, offset, size, strToStack(name))), + 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), @@ -2134,20 +2134,23 @@ export class Module { 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 { data, offset, passive } = segments[i]; - datas[i] = _malloc(data.length); + 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; + 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), @@ -2174,12 +2177,12 @@ export class Module { }, withMax); }, countSegments: (): number => JSModule['_BinaryenGetNumMemorySegments'](this.ptr), - getSegmentInfoByIndex: (index: number): SegmentInfo => { - const passive = Boolean(JSModule['_BinaryenGetMemorySegmentPassive'](this.ptr, index)); - const offset = passive ? 0 : JSModule['_BinaryenGetMemorySegmentByteOffset'](this.ptr, index); - const size = JSModule['_BinaryenGetMemorySegmentByteLength'](this.ptr, index); + 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, index, ptr); + JSModule['_BinaryenCopyMemorySegmentData'](this.ptr, strToStack(name), ptr); const data = new Uint8Array(size); data.set(HEAP8.subarray(ptr, ptr + size)); _free(ptr); @@ -2437,6 +2440,7 @@ export class TypeBuilder { export interface SegmentInfo { + name: string; offset: ExpressionRef; data: Uint8Array; passive?: boolean; From 9be8b9c436b202f801ebf387dedc67e6b98b01be Mon Sep 17 00:00:00 2001 From: Eric Vergnaud Date: Thu, 1 Feb 2024 22:57:47 +0100 Subject: [PATCH 37/38] make name optional in SegmentInfo --- src/ts/binaryen.ts | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/ts/binaryen.ts b/src/ts/binaryen.ts index b56baed0580..2c40d25a47d 100644 --- a/src/ts/binaryen.ts +++ b/src/ts/binaryen.ts @@ -2186,7 +2186,7 @@ export class Module { const data = new Uint8Array(size); data.set(HEAP8.subarray(ptr, ptr + size)); _free(ptr); - return { offset, data, passive }; + return { name, offset, data, passive }; }, countElementSegments: (): number => JSModule['_BinaryenGetNumElementSegments'](this.ptr), getElementSegmentByIndex: (index: number): ElementSegmentRef => JSModule['_BinaryenGetElementSegmentByIndex'](this.ptr, index), @@ -2440,7 +2440,7 @@ export class TypeBuilder { export interface SegmentInfo { - name: string; + name?: string; offset: ExpressionRef; data: Uint8Array; passive?: boolean; From e6bbbc1cadce319eacec6ac6ebbd71d86f3d1082 Mon Sep 17 00:00:00 2001 From: Eric Vergnaud Date: Mon, 5 Feb 2024 22:20:46 +0100 Subject: [PATCH 38/38] make it possible to capture the validator error stream --- src/ts/binaryen.ts | 16 +++++++++++++--- src/ts/binaryen_post.ts | 15 +++++++++++++-- 2 files changed, 26 insertions(+), 5 deletions(-) diff --git a/src/ts/binaryen.ts b/src/ts/binaryen.ts index 2c40d25a47d..03adcc3dc04 100644 --- a/src/ts/binaryen.ts +++ b/src/ts/binaryen.ts @@ -16,8 +16,9 @@ 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 = (s: string) => void; +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; @@ -853,8 +854,17 @@ export class Module { getDebugInfoFileName(index: number): string | null { return UTF8ToString(JSModule['_BinaryenModuleGetDebugInfoFileName'](this.ptr, index)); } - validate(): number { - return JSModule['_BinaryenModuleValidate'](this.ptr); + 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); diff --git a/src/ts/binaryen_post.ts b/src/ts/binaryen_post.ts index 9f798e1fb72..b9d1a4ac09f 100644 --- a/src/ts/binaryen_post.ts +++ b/src/ts/binaryen_post.ts @@ -1,17 +1,28 @@ +type Writer = (...data: any[]) => void; + declare var Module: object; -declare var out: (s: string) => void; +declare var out: Writer; +declare var err: Writer; declare var _BinaryenSizeofLiteral: () => number; declare var _BinaryenSizeofAllocateAndWriteResult: () => number; -type Writer = (s: string) => void; 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