/**

* A thin wrapper around Binaryen's C-API.

* @module module

*//***/

import {

Target

} from "./compiler";

export type ModuleRef = usize;

export type FunctionTypeRef = usize;

export type FunctionRef = usize;

export type ExpressionRef = usize;

export type GlobalRef = usize;

export type ImportRef = usize;

export type ExportRef = usize;

export type RelooperRef = usize;

export type RelooperBlockRef = usize;

export type Index = u32;

export const enum NativeType {

None = 0, // _BinaryenTypeNone(),

I32 = 1, // _BinaryenTypeInt32(),

I64 = 2, // _BinaryenTypeInt64(),

F32 = 3, // _BinaryenTypeFloat32(),

F64 = 4, // _BinaryenTypeFloat64(),

Unreachable = 5, // _BinaryenTypeUnreachable(),

Auto = -1 // _BinaryenTypeAuto()

}

export enum ExpressionId {

Invalid = _BinaryenInvalidId(),

Block = _BinaryenBlockId(),

If = _BinaryenIfId(),

Loop = _BinaryenLoopId(),

Break = _BinaryenBreakId(),

Switch = _BinaryenSwitchId(),

Call = _BinaryenCallId(),

CallIndirect = _BinaryenCallIndirectId(),

GetLocal = _BinaryenGetLocalId(),

SetLocal = _BinaryenSetLocalId(),

GetGlobal = _BinaryenGetGlobalId(),

SetGlobal = _BinaryenSetGlobalId(),

Load = _BinaryenLoadId(),

Store = _BinaryenStoreId(),

Const = _BinaryenConstId(),

Unary = _BinaryenUnaryId(),

Binary = _BinaryenBinaryId(),

Select = _BinaryenSelectId(),

Drop = _BinaryenDropId(),

Return = _BinaryenReturnId(),

Host = _BinaryenHostId(),

Nop = _BinaryenNopId(),

Unreachable = _BinaryenUnreachableId(),

AtomicCmpxchg = _BinaryenAtomicCmpxchgId(),

AtomicRMW = _BinaryenAtomicRMWId(),

AtomicWait = _BinaryenAtomicWaitId(),

AtomicWake = _BinaryenAtomicWakeId()

// SIMDExtract = _BinaryenSIMDExtractId(),

// SIMDReplace = _BinaryenSIMDReplaceId(),

// SIMDShuffle = _BinaryenSIMDShuffleId(),

// SIMDBitselect = _BinaryenSIMDBitselectId(),

// SIMDShift = _BinaryenSIMDShiftId()

}

export enum UnaryOp {

ClzI32 = _BinaryenClzInt32(),

CtzI32 = _BinaryenCtzInt32(),

PopcntI32 = _BinaryenPopcntInt32(),

NegF32 = _BinaryenNegFloat32(),

AbsF32 = _BinaryenAbsFloat32(),

CeilF32 = _BinaryenCeilFloat32(),

FloorF32 = _BinaryenFloorFloat32(),

TruncF32 = _BinaryenTruncFloat32(),

NearestF32 = _BinaryenNearestFloat32(),

SqrtF32 = _BinaryenSqrtFloat32(),

EqzI32 = _BinaryenEqZInt32(),

ClzI64 = _BinaryenClzInt64(),

CtzI64 = _BinaryenCtzInt64(),

PopcntI64 = _BinaryenPopcntInt64(),

NegF64 = _BinaryenNegFloat64(),

AbsF64 = _BinaryenAbsFloat64(),

CeilF64 = _BinaryenCeilFloat64(),

FloorF64 = _BinaryenFloorFloat64(),

TruncF64 = _BinaryenTruncFloat64(),

NearestF64 = _BinaryenNearestFloat64(),

SqrtF64 = _BinaryenSqrtFloat64(),

EqzI64 = _BinaryenEqZInt64(),

ExtendI32 = _BinaryenExtendSInt32(),

ExtendU32 = _BinaryenExtendUInt32(),

WrapI64 = _BinaryenWrapInt64(),

TruncF32ToI32 = _BinaryenTruncSFloat32ToInt32(),

TruncF32ToI64 = _BinaryenTruncSFloat32ToInt64(),

TruncF32ToU32 = _BinaryenTruncUFloat32ToInt32(),

TruncF32ToU64 = _BinaryenTruncUFloat32ToInt64(),

TruncF64ToI32 = _BinaryenTruncSFloat64ToInt32(),

TruncF64ToI64 = _BinaryenTruncSFloat64ToInt64(),

TruncF64ToU32 = _BinaryenTruncUFloat64ToInt32(),

TruncF64ToU64 = _BinaryenTruncUFloat64ToInt64(),

ReinterpretF32 = _BinaryenReinterpretFloat32(),

ReinterpretF64 = _BinaryenReinterpretFloat64(),

ConvertI32ToF32 = _BinaryenConvertSInt32ToFloat32(),

ConvertI32ToF64 = _BinaryenConvertSInt32ToFloat64(),

ConvertU32ToF32 = _BinaryenConvertUInt32ToFloat32(),

ConvertU32ToF64 = _BinaryenConvertUInt32ToFloat64(),

ConvertI64ToF32 = _BinaryenConvertSInt64ToFloat32(),

ConvertI64ToF64 = _BinaryenConvertSInt64ToFloat64(),

ConvertU64ToF32 = _BinaryenConvertUInt64ToFloat32(),

ConvertU64ToF64 = _BinaryenConvertUInt64ToFloat64(),

PromoteF32 = _BinaryenPromoteFloat32(),

DemoteF64 = _BinaryenDemoteFloat64(),

ReinterpretI32 = _BinaryenReinterpretInt32(),

ReinterpretI64 = _BinaryenReinterpretInt64(),

// see: https://github.com/WebAssembly/sign-extension-ops

ExtendI8ToI32 = _BinaryenExtendS8Int32(),

ExtendI16ToI32 = _BinaryenExtendS16Int32(),

ExtendI8ToI64 = _BinaryenExtendS8Int64(),

ExtendI16ToI64 = _BinaryenExtendS16Int64(),

ExtendI32ToI64 = _BinaryenExtendS32Int64()

// see: https://github.com/WebAssembly/nontrapping-float-to-int-conversions

// TruncF32ToI32Sat

// TruncF32ToU32Sat

// TruncF64ToI32Sat

// TruncF64ToU32Sat

// TruncF32ToI64Sat

// TruncF32ToU64Sat

// TruncF64ToI64Sat

// TruncF64ToU64Sat

}

export enum BinaryOp {

AddI32 = _BinaryenAddInt32(),

SubI32 = _BinaryenSubInt32(),

MulI32 = _BinaryenMulInt32(),

DivI32 = _BinaryenDivSInt32(),

DivU32 = _BinaryenDivUInt32(),

RemI32 = _BinaryenRemSInt32(),

RemU32 = _BinaryenRemUInt32(),

AndI32 = _BinaryenAndInt32(),

OrI32 = _BinaryenOrInt32(),

XorI32 = _BinaryenXorInt32(),

ShlI32 = _BinaryenShlInt32(),

ShrU32 = _BinaryenShrUInt32(),

ShrI32 = _BinaryenShrSInt32(),

RotlI32 = _BinaryenRotLInt32(),

RotrI32 = _BinaryenRotRInt32(),

EqI32 = _BinaryenEqInt32(),

NeI32 = _BinaryenNeInt32(),

LtI32 = _BinaryenLtSInt32(),

LtU32 = _BinaryenLtUInt32(),

LeI32 = _BinaryenLeSInt32(),

LeU32 = _BinaryenLeUInt32(),

GtI32 = _BinaryenGtSInt32(),

GtU32 = _BinaryenGtUInt32(),

GeI32 = _BinaryenGeSInt32(),

GeU32 = _BinaryenGeUInt32(),

AddI64 = _BinaryenAddInt64(),

SubI64 = _BinaryenSubInt64(),

MulI64 = _BinaryenMulInt64(),

DivI64 = _BinaryenDivSInt64(),

DivU64 = _BinaryenDivUInt64(),

RemI64 = _BinaryenRemSInt64(),

RemU64 = _BinaryenRemUInt64(),

AndI64 = _BinaryenAndInt64(),

OrI64 = _BinaryenOrInt64(),

XorI64 = _BinaryenXorInt64(),

ShlI64 = _BinaryenShlInt64(),

ShrU64 = _BinaryenShrUInt64(),

ShrI64 = _BinaryenShrSInt64(),

RotlI64 = _BinaryenRotLInt64(),

RotrI64 = _BinaryenRotRInt64(),

EqI64 = _BinaryenEqInt64(),

NeI64 = _BinaryenNeInt64(),

LtI64 = _BinaryenLtSInt64(),

LtU64 = _BinaryenLtUInt64(),

LeI64 = _BinaryenLeSInt64(),

LeU64 = _BinaryenLeUInt64(),

GtI64 = _BinaryenGtSInt64(),

GtU64 = _BinaryenGtUInt64(),

GeI64 = _BinaryenGeSInt64(),

GeU64 = _BinaryenGeUInt64(),

AddF32 = _BinaryenAddFloat32(),

SubF32 = _BinaryenSubFloat32(),

MulF32 = _BinaryenMulFloat32(),

DivF32 = _BinaryenDivFloat32(),

CopysignF32 = _BinaryenCopySignFloat32(),

MinF32 = _BinaryenMinFloat32(),

MaxF32 = _BinaryenMaxFloat32(),

EqF32 = _BinaryenEqFloat32(),

NeF32 = _BinaryenNeFloat32(),

LtF32 = _BinaryenLtFloat32(),

LeF32 = _BinaryenLeFloat32(),

GtF32 = _BinaryenGtFloat32(),

GeF32 = _BinaryenGeFloat32(),

AddF64 = _BinaryenAddFloat64(),

SubF64 = _BinaryenSubFloat64(),

MulF64 = _BinaryenMulFloat64(),

DivF64 = _BinaryenDivFloat64(),

CopysignF64 = _BinaryenCopySignFloat64(),

MinF64 = _BinaryenMinFloat64(),

MaxF64 = _BinaryenMaxFloat64(),

EqF64 = _BinaryenEqFloat64(),

NeF64 = _BinaryenNeFloat64(),

LtF64 = _BinaryenLtFloat64(),

LeF64 = _BinaryenLeFloat64(),

GtF64 = _BinaryenGtFloat64(),

GeF64 = _BinaryenGeFloat64()

}

export enum HostOp {

CurrentMemory = _BinaryenCurrentMemory(),

GrowMemory = _BinaryenGrowMemory(),

// see: https://github.com/WebAssembly/bulk-memory-operations

// MoveMemory

// SetMemory

}

export enum AtomicRMWOp {

Add = _BinaryenAtomicRMWAdd(),

Sub = _BinaryenAtomicRMWSub(),

And = _BinaryenAtomicRMWAnd(),

Or = _BinaryenAtomicRMWOr(),

Xor = _BinaryenAtomicRMWXor(),

Xchg = _BinaryenAtomicRMWXchg()

}

// export enum SIMDOp {

// SplatVecI8x16 = _BinaryenSplatVecI8x16(),

// SplatVecI16x8 = _BinaryenSplatVecI16x8(),

// SplatVecI32x4 = _BinaryenSplatVecI32x4(),

// SplatVecI64x2 = _BinaryenSplatVecI64x2(),

// SplatVecF32x4 = _BinaryenSplatVecF32x4(),

// SplatVecF64x2 = _BinaryenSplatVecF64x2(),

// NotVec128 = _BinaryenNotVec128(),

// NegVecI8x16 = _BinaryenNegVecI8x16(),

// AnyTrueVecI8x16 = _BinaryenAnyTrueVecI8x16(),

// AllTrueVecI8x16 = _BinaryenAllTrueVecI8x16(),

// NegVecI16x8 = _BinaryenNegVecI16x8(),

// AnyTrueVecI16x8 = _BinaryenAnyTrueVecI16x8(),

// AllTrueVecI16x8 = _BinaryenAllTrueVecI16x8(),

// NegVecI32x4 = _BinaryenNegVecI32x4(),

// AnyTrueVecI32x4 = _BinaryenAnyTrueVecI32x4(),

// AllTrueVecI32x4 = _BinaryenAllTrueVecI32x4(),

// NegVecI64x2 = _BinaryenNegVecI64x2(),

// AnyTrueVecI64x2 = _BinaryenAnyTrueVecI64x2(),

// AllTrueVecI64x2 = _BinaryenAllTrueVecI64x2(),

// AbsVecF32x4 = _BinaryenAbsVecF32x4(),

// NegVecF32x4 = _BinaryenNegVecF32x4(),

// SqrtVecF32x4 = _BinaryenSqrtVecF32x4(),

// AbsVecF64x2 = _BinaryenAbsVecF64x2(),

// NegVecF64x2 = _BinaryenNegVecF64x2(),

// SqrtVecF64x2 = _BinaryenSqrtVecF64x2(),

// TruncSatSVecF32x4ToVecI32x4 = _BinaryenTruncSatSVecF32x4ToVecI32x4(),

// TruncSatUVecF32x4ToVecI32x4 = _BinaryenTruncSatUVecF32x4ToVecI32x4(),

// TruncSatSVecF64x2ToVecI64x2 = _BinaryenTruncSatSVecF64x2ToVecI64x2(),

// TruncSatUVecF64x2ToVecI64x2 = _BinaryenTruncSatUVecF64x2ToVecI64x2(),

// ConvertSVecI32x4ToVecF32x4 = _BinaryenConvertSVecI32x4ToVecF32x4(),

// ConvertUVecI32x4ToVecF32x4 = _BinaryenConvertUVecI32x4ToVecF32x4(),

// ConvertSVecI64x2ToVecF64x2 = _BinaryenConvertSVecI64x2ToVecF64x2(),

// ConvertUVecI64x2ToVecF64x2 = _BinaryenConvertUVecI64x2ToVecF64x2(),

// EqVecI8x16 = _BinaryenEqVecI8x16(),

// NeVecI8x16 = _BinaryenNeVecI8x16(),

// LtSVecI8x16 = _BinaryenLtSVecI8x16(),

// LtUVecI8x16 = _BinaryenLtUVecI8x16(),

// LeSVecI8x16 = _BinaryenLeSVecI8x16(),

// LeUVecI8x16 = _BinaryenLeUVecI8x16(),

// GtSVecI8x16 = _BinaryenGtSVecI8x16(),

// GtUVecI8x16 = _BinaryenGtUVecI8x16(),

// GeSVecI8x16 = _BinaryenGeSVecI8x16(),

// GeUVecI8x16 = _BinaryenGeUVecI8x16(),

// EqVecI16x8 = _BinaryenEqVecI16x8(),

// NeVecI16x8 = _BinaryenNeVecI16x8(),

// LtSVecI16x8 = _BinaryenLtSVecI16x8(),

// LtUVecI16x8 = _BinaryenLtUVecI16x8(),

// LeSVecI16x8 = _BinaryenLeSVecI16x8(),

// LeUVecI16x8 = _BinaryenLeUVecI16x8(),

// GtSVecI16x8 = _BinaryenGtSVecI16x8(),

// GtUVecI16x8 = _BinaryenGtUVecI16x8(),

// GeSVecI16x8 = _BinaryenGeSVecI16x8(),

// GeUVecI16x8 = _BinaryenGeUVecI16x8(),

// EqVecI32x4 = _BinaryenEqVecI32x4(),

// NeVecI32x4 = _BinaryenNeVecI32x4(),

// LtSVecI32x4 = _BinaryenLtSVecI32x4(),

// LtUVecI32x4 = _BinaryenLtUVecI32x4(),

// LeSVecI32x4 = _BinaryenLeSVecI32x4(),

// LeUVecI32x4 = _BinaryenLeUVecI32x4(),

// GtSVecI32x4 = _BinaryenGtSVecI32x4(),

// GtUVecI32x4 = _BinaryenGtUVecI32x4(),

// GeSVecI32x4 = _BinaryenGeSVecI32x4(),

// GeUVecI32x4 = _BinaryenGeUVecI32x4(),

// EqVecF32x4 = _BinaryenEqVecF32x4(),

// NeVecF32x4 = _BinaryenNeVecF32x4(),

// LtVecF32x4 = _BinaryenLtVecF32x4(),

// LeVecF32x4 = _BinaryenLeVecF32x4(),

// GtVecF32x4 = _BinaryenGtVecF32x4(),

// GeVecF32x4 = _BinaryenGeVecF32x4(),

// EqVecF64x2 = _BinaryenEqVecF64x2(),

// NeVecF64x2 = _BinaryenNeVecF64x2(),

// LtVecF64x2 = _BinaryenLtVecF64x2(),

// LeVecF64x2 = _BinaryenLeVecF64x2(),

// GtVecF64x2 = _BinaryenGtVecF64x2(),

// GeVecF64x2 = _BinaryenGeVecF64x2(),

// AndVec128 = _BinaryenAndVec128(),

// OrVec128 = _BinaryenOrVec128(),

// XorVec128 = _BinaryenXorVec128(),

// AddVecI8x16 = _BinaryenAddVecI8x16(),

// AddSatSVecI8x16 = _BinaryenAddSatSVecI8x16(),

// AddSatUVecI8x16 = _BinaryenAddSatUVecI8x16(),

// SubVecI8x16 = _BinaryenSubVecI8x16(),

// SubSatSVecI8x16 = _BinaryenSubSatSVecI8x16(),

// SubSatUVecI8x16 = _BinaryenSubSatUVecI8x16(),

// MulVecI8x16 = _BinaryenMulVecI8x16(),

// AddVecI16x8 = _BinaryenAddVecI16x8(),

// AddSatSVecI16x8 = _BinaryenAddSatSVecI16x8(),

// AddSatUVecI16x8 = _BinaryenAddSatUVecI16x8(),

// SubVecI16x8 = _BinaryenSubVecI16x8(),

// SubSatSVecI16x8 = _BinaryenSubSatSVecI16x8(),

// SubSatUVecI16x8 = _BinaryenSubSatUVecI16x8(),

// MulVecI16x8 = _BinaryenMulVecI16x8(),

// AddVecI32x4 = _BinaryenAddVecI32x4(),

// SubVecI32x4 = _BinaryenSubVecI32x4(),

// MulVecI32x4 = _BinaryenMulVecI32x4(),

// AddVecI64x2 = _BinaryenAddVecI64x2(),

// SubVecI64x2 = _BinaryenSubVecI64x2(),

// AddVecF32x4 = _BinaryenAddVecF32x4(),

// SubVecF32x4 = _BinaryenSubVecF32x4(),

// MulVecF32x4 = _BinaryenMulVecF32x4(),

// DivVecF32x4 = _BinaryenDivVecF32x4(),

// MinVecF32x4 = _BinaryenMinVecF32x4(),

// MaxVecF32x4 = _BinaryenMaxVecF32x4(),

// AddVecF64x2 = _BinaryenAddVecF64x2(),

// SubVecF64x2 = _BinaryenSubVecF64x2(),

// MulVecF64x2 = _BinaryenMulVecF64x2(),

// DivVecF64x2 = _BinaryenDivVecF64x2(),

// MinVecF64x2 = _BinaryenMinVecF64x2(),

// MaxVecF64x2 = _BinaryenMaxVecF64x2()

// }

export class MemorySegment {

buffer: Uint8Array;

offset: I64;

static create(buffer: Uint8Array, offset: I64): MemorySegment {

var segment = new MemorySegment();

segment.buffer = buffer;

segment.offset = offset;

return segment;

}

}

export class Module {

ref: ModuleRef;

private cachedByValue: usize;

static create(): Module {

var module = new Module();

module.ref = _BinaryenModuleCreate();

module.cachedByValue = memory.allocate(16);

return module;

}

static createFrom(buffer: Uint8Array): Module {

var cArr = allocU8Array(buffer);

try {

let module = new Module();

module.ref = _BinaryenModuleRead(cArr, buffer.length);

module.cachedByValue = memory.allocate(3 * 8); // LLVM C-ABI, max used is 3 * usize

return module;

} finally {

memory.free(changetype<usize>(cArr));

}

}

private constructor() { }

// types

addFunctionType(

name: string,

result: NativeType,

paramTypes: NativeType[] | null

): FunctionRef {

var cStr = this.allocStringCached(name);

var cArr = allocI32Array(paramTypes);

try {

return _BinaryenAddFunctionType(this.ref, cStr, result, cArr, paramTypes ? paramTypes.length : 0);

} finally {

memory.free(cArr);

}

}

getFunctionTypeBySignature(

result: NativeType,

paramTypes: NativeType[] | null

): FunctionTypeRef {

var cArr = allocI32Array(paramTypes);

try {

return _BinaryenGetFunctionTypeBySignature(this.ref, result, cArr, paramTypes ? paramTypes.length : 0);

} finally {

memory.free(cArr);

}

}

removeFunctionType(name: string): void {

var cStr = this.allocStringCached(name);

_BinaryenRemoveFunctionType(this.ref, cStr);

}

// constants

createI32(value: i32): ExpressionRef {

var out = this.cachedByValue;

_BinaryenLiteralInt32(out, value);

return _BinaryenConst(this.ref, out);

}

createI64(valueLow: i32, valueHigh: i32 = 0): ExpressionRef {

var out = this.cachedByValue;

_BinaryenLiteralInt64(out, valueLow, valueHigh);

return _BinaryenConst(this.ref, out);

}

createF32(value: f32): ExpressionRef {

var out = this.cachedByValue;

_BinaryenLiteralFloat32(out, value);

return _BinaryenConst(this.ref, out);

}

createF64(value: f64): ExpressionRef {

var out = this.cachedByValue;

_BinaryenLiteralFloat64(out, value);

return _BinaryenConst(this.ref, out);

}

// expressions

createUnary(

op: UnaryOp,

expr: ExpressionRef

): ExpressionRef {

return _BinaryenUnary(this.ref, op, expr);

}

createBinary(

op: BinaryOp,

left: ExpressionRef,

right: ExpressionRef

): ExpressionRef {

return _BinaryenBinary(this.ref, op, left, right);

}

createHost(

op: HostOp,

name: string | null = null,

operands: ExpressionRef[] | null = null

): ExpressionRef {

var cStr = this.allocStringCached(name);

var cArr = allocPtrArray(operands);

try {

return _BinaryenHost(this.ref, op, cStr, cArr, operands ? (<ExpressionRef[]>operands).length : 0);

} finally {

memory.free(cArr);

}

}

createGetLocal(

index: i32,

type: NativeType

): ExpressionRef {

return _BinaryenGetLocal(this.ref, index, type);

}

createTeeLocal(

index: i32,

value: ExpressionRef

): ExpressionRef {

return _BinaryenTeeLocal(this.ref, index, value);

}

createGetGlobal(

name: string,

type: NativeType

): ExpressionRef {

var cStr = this.allocStringCached(name);

return _BinaryenGetGlobal(this.ref, cStr, type);

}

createLoad(

bytes: Index,

signed: bool,

ptr: ExpressionRef,

type: NativeType,

offset: Index = 0

): ExpressionRef {

return _BinaryenLoad(this.ref, bytes, signed ? 1 : 0, offset, /* always aligned */ bytes, type, ptr);

}

createStore(

bytes: Index,

ptr: ExpressionRef,

value: ExpressionRef,

type: NativeType,

offset: Index = 0

): ExpressionRef {

return _BinaryenStore(this.ref, bytes, offset, /* always aligned */ bytes, ptr, value, type);

}

createAtomicLoad(

bytes: Index,

ptr: ExpressionRef,

type: NativeType,

offset: Index = 0

): ExpressionRef {

return _BinaryenAtomicLoad(this.ref, bytes, offset, type, ptr);

}

createAtomicStore(

bytes: Index,

ptr: ExpressionRef,

value: ExpressionRef,

type: NativeType,

offset: Index = 0

): ExpressionRef {

return _BinaryenAtomicStore(this.ref, bytes, offset, ptr, value, type);

}

createAtomicRMW(

op: AtomicRMWOp,

bytes: Index,

offset: Index,

ptr: ExpressionRef,

value: ExpressionRef,

type: NativeType

): ExpressionRef {

return _BinaryenAtomicRMW(this.ref, op, bytes, offset, ptr, value, type);

}

createAtomicCmpxchg(

bytes: Index,

offset: Index,

ptr: ExpressionRef,

expected: ExpressionRef,

replacement: ExpressionRef,

type: NativeType

): ExpressionRef {

return _BinaryenAtomicCmpxchg(this.ref, bytes, offset, ptr, expected, replacement, type);

}

createAtomicWait(

ptr: ExpressionRef,

expected: ExpressionRef,

timeout: ExpressionRef,

expectedType: NativeType

): ExpressionRef {

return _BinaryenAtomicWait(this.ref, ptr, expected, timeout, expectedType);

}

createAtomicWake(

ptr: ExpressionRef,

wakeCount: ExpressionRef

): ExpressionRef {

return _BinaryenAtomicWake(this.ref, ptr, wakeCount);

}

// statements

createSetLocal(

index: Index,

value: ExpressionRef

): ExpressionRef {

return _BinaryenSetLocal(this.ref, index, value);

}

createSetGlobal(

name: string,

value: ExpressionRef

): ExpressionRef {

var cStr = this.allocStringCached(name);

return _BinaryenSetGlobal(this.ref, cStr, value);

}

createBlock(

label: string | null,

children: ExpressionRef[],

type: NativeType = NativeType.None

): ExpressionRef {

var cStr = this.allocStringCached(label);

var cArr = allocPtrArray(children);

try {

return _BinaryenBlock(this.ref, cStr, cArr, children.length, type);

} finally {

memory.free(cArr);

}

}

createBreak(

label: string | null,

condition: ExpressionRef = 0,

value: ExpressionRef = 0

): ExpressionRef {

var cStr = this.allocStringCached(label);

return _BinaryenBreak(this.ref, cStr, condition, value);

}

createDrop(

expression: ExpressionRef

): ExpressionRef {

return _BinaryenDrop(this.ref, expression);

}

createLoop(

label: string | null,

body: ExpressionRef

): ExpressionRef {

var cStr = this.allocStringCached(label);

return _BinaryenLoop(this.ref, cStr, body);

}

createIf(

condition: ExpressionRef,

ifTrue: ExpressionRef,

ifFalse: ExpressionRef = 0

): ExpressionRef {

return _BinaryenIf(this.ref, condition, ifTrue, ifFalse);

}

createNop(): ExpressionRef {

return _BinaryenNop(this.ref);

}

createReturn(

expression: ExpressionRef = 0

): ExpressionRef {

return _BinaryenReturn(this.ref, expression);

}

createSelect(

ifTrue: ExpressionRef,

ifFalse: ExpressionRef,

condition: ExpressionRef

): ExpressionRef {

return _BinaryenSelect(this.ref, condition, ifTrue, ifFalse);

}

createSwitch(

names: string[],

defaultName: string | null,

condition: ExpressionRef,

value: ExpressionRef = 0

): ExpressionRef {

var numNames = names.length;

var strs = new Array<usize>(numNames);

for (let i = 0; i < numNames; ++i) {

strs[i] = this.allocStringCached(names[i]);

}

var cArr = allocI32Array(strs);

var cStr = this.allocStringCached(defaultName);

try {

return _BinaryenSwitch(this.ref, cArr, numNames, cStr, condition, value);

} finally {

memory.free(cArr);

}

}

createCall(

target: string,

operands: ExpressionRef[] | null,

returnType: NativeType

): ExpressionRef {

var cStr = this.allocStringCached(target);

var cArr = allocPtrArray(operands);

try {

return _BinaryenCall(this.ref, cStr, cArr, operands && operands.length || 0, returnType);

} finally {

memory.free(cArr);

}

}

createCallIndirect(

index: ExpressionRef,

operands: ExpressionRef[] | null,

typeName: string

): ExpressionRef {

var cStr = this.allocStringCached(typeName);

var cArr = allocPtrArray(operands);

try {

return _BinaryenCallIndirect(this.ref, index, cArr, operands && operands.length || 0, cStr);

} finally {

memory.free(cArr);

}

}

createUnreachable(): ExpressionRef {

return _BinaryenUnreachable(this.ref);

}

// meta

addGlobal(

name: string,

type: NativeType,

mutable: bool,

initializer: ExpressionRef

): GlobalRef {

var cStr = this.allocStringCached(name);

return _BinaryenAddGlobal(this.ref, cStr, type, mutable ? 1 : 0, initializer);

}

removeGlobal(

name: string

): void {

var cStr = this.allocStringCached(name);

_BinaryenRemoveGlobal(this.ref, cStr);

}

addFunction(

name: string,

type: FunctionTypeRef,

varTypes: NativeType[] | null,

body: ExpressionRef

): FunctionRef {

var cStr = this.allocStringCached(name);

var cArr = allocI32Array(varTypes);

try {

return _BinaryenAddFunction(this.ref, cStr, type, cArr, varTypes ? varTypes.length : 0, body);

} finally {

memory.free(cArr);

}

}

removeFunction(name: string): void {

var cStr = this.allocStringCached(name);

_BinaryenRemoveFunction(this.ref, cStr);

}

private hasTemporaryFunction: bool = false;

addTemporaryFunction(result: NativeType, paramTypes: NativeType[] | null, body: ExpressionRef): FunctionRef {

this.hasTemporaryFunction = assert(!this.hasTemporaryFunction);

var tempName = this.allocStringCached("");

var cArr = allocI32Array(paramTypes);

try {

let typeRef = _BinaryenAddFunctionType(this.ref, tempName, result, cArr, paramTypes ? paramTypes.length : 0);

return _BinaryenAddFunction(this.ref, tempName, typeRef, 0, 0, body);

} finally {

memory.free(cArr);

}

}

removeTemporaryFunction(): void {

this.hasTemporaryFunction = !assert(this.hasTemporaryFunction);

var tempName = this.allocStringCached("");

_BinaryenRemoveFunction(this.ref, tempName);

_BinaryenRemoveFunctionType(this.ref, tempName);

}

addFunctionExport(

internalName: string,

externalName: string

): ExportRef {

var cStr1 = this.allocStringCached(internalName);

var cStr2 = this.allocStringCached(externalName);

return _BinaryenAddFunctionExport(this.ref, cStr1, cStr2);

}

addTableExport(

internalName: string,

externalName: string

): ExportRef {

var cStr1 = this.allocStringCached(internalName);

var cStr2 = this.allocStringCached(externalName);

return _BinaryenAddTableExport(this.ref, cStr1, cStr2);

}

addMemoryExport(

internalName: string,

externalName: string

): ExportRef {

var cStr1 = this.allocStringCached(internalName);

var cStr2 = this.allocStringCached(externalName);

return _BinaryenAddMemoryExport(this.ref, cStr1, cStr2);

}

addGlobalExport(

internalName: string,

externalName: string

): ExportRef {

var cStr1 = this.allocStringCached(internalName);

var cStr2 = this.allocStringCached(externalName);

return _BinaryenAddGlobalExport(this.ref, cStr1, cStr2);

}

removeExport(externalName: string): void {

var cStr = this.allocStringCached(externalName);

_BinaryenRemoveExport(this.ref, cStr);

}

addFunctionImport(

internalName: string,

externalModuleName: string,

externalBaseName: string,

functionType: FunctionTypeRef

): ImportRef {

var cStr1 = this.allocStringCached(internalName);

var cStr2 = this.allocStringCached(externalModuleName);

var cStr3 = this.allocStringCached(externalBaseName);

return _BinaryenAddFunctionImport(this.ref, cStr1, cStr2, cStr3, functionType);

}

addTableImport(

internalName: string,

externalModuleName: string,

externalBaseName: string

): ImportRef {

var cStr1 = this.allocStringCached(internalName);

var cStr2 = this.allocStringCached(externalModuleName);

var cStr3 = this.allocStringCached(externalBaseName);

return _BinaryenAddTableImport(this.ref, cStr1, cStr2, cStr3);

}

addMemoryImport(

internalName: string,

externalModuleName: string,

externalBaseName: string,

shared: bool = false,

): ImportRef {

var cStr1 = this.allocStringCached(internalName);

var cStr2 = this.allocStringCached(externalModuleName);

var cStr3 = this.allocStringCached(externalBaseName);

return _BinaryenAddMemoryImport(this.ref, cStr1, cStr2, cStr3, shared);

}

addGlobalImport(

internalName: string,

externalModuleName: string,

externalBaseName: string,

globalType: NativeType

): ImportRef {

var cStr1 = this.allocStringCached(internalName);

var cStr2 = this.allocStringCached(externalModuleName);

var cStr3 = this.allocStringCached(externalBaseName);

return _BinaryenAddGlobalImport(this.ref, cStr1, cStr2, cStr3, globalType);

}

/** Unlimited memory constant. */

static readonly UNLIMITED_MEMORY: Index = <Index>-1;

setMemory(

initial: Index,

maximum: Index,

segments: MemorySegment[],

target: Target,

exportName: string | null = null,

shared: bool = false

): void {

var cStr = this.allocStringCached(exportName);

var k = segments.length;

var segs = new Array<usize>(k);

var offs = new Array<ExpressionRef>(k);

var sizs = new Array<Index>(k);

for (let i = 0; i < k; ++i) {

let buffer = segments[i].buffer;

let offset = segments[i].offset;

segs[i] = allocU8Array(buffer);

offs[i] = target == Target.WASM64

? this.createI64(i64_low(offset), i64_high(offset))

: this.createI32(i64_low(offset));

sizs[i] = buffer.length;

}

var cArr1 = allocI32Array(segs);

var cArr2 = allocI32Array(offs);

var cArr3 = allocI32Array(sizs);

try {

_BinaryenSetMemory(this.ref, initial, maximum, cStr, cArr1, cArr2, cArr3, k, shared);

} finally {

memory.free(cArr3);

memory.free(cArr2);

memory.free(cArr1);

for (let i = k - 1; i >= 0; --i) memory.free(segs[i]);

}

}

setFunctionTable(

initial: Index,

maximum: Index,

funcs: string[]

): void {

var numNames = funcs.length;

var names = new Array<usize>(numNames);

for (let i = 0; i < numNames; ++i) {

names[i] = this.allocStringCached(funcs[i]);

}

var cArr = allocI32Array(names);

try {

_BinaryenSetFunctionTable(this.ref, initial, maximum, cArr, numNames);

} finally {

memory.free(cArr);

}

}

setStart(func: FunctionRef): void {

_BinaryenSetStart(this.ref, func);

}

forceInline(func: FunctionRef, call: ExpressionRef): bool {

return _BinaryenForceInline(this.ref, func, call);

}

getOptimizeLevel(): i32 {

return _BinaryenGetOptimizeLevel();

}

setOptimizeLevel(level: i32 = 2): void {

_BinaryenSetOptimizeLevel(level);

}

getShrinkLevel(): i32 {

return _BinaryenGetShrinkLevel();

}

setShrinkLevel(level: i32 = 1): void {

_BinaryenSetShrinkLevel(level);

}

setDebugInfo(on: bool = false): void {

_BinaryenSetDebugInfo(on);

}

optimize(func: FunctionRef = 0): void {

if (func) {

_BinaryenFunctionOptimize(func, this.ref);

} else {

_BinaryenModuleOptimize(this.ref);

}

}

runPasses(passes: string[], func: FunctionRef = 0): void {

var numNames = passes.length;

var names = new Array<usize>(numNames);

for (let i = 0; i < numNames; ++i) {

names[i] = allocString(passes[i]);

}

var cArr = allocI32Array(names);

try {

if (func) {

_BinaryenFunctionRunPasses(func, this.ref, cArr, numNames);

} else {

_BinaryenModuleRunPasses(this.ref, cArr, numNames);

}

} finally {

memory.free(cArr);

for (let i = numNames; i >= 0; --i) memory.free(names[i]);

}

}

private cachedPrecomputeNames: usize = 0;

precomputeExpression(expr: ExpressionRef): ExpressionRef {

// remember the previous optimize levels and set to max instead, to be sure

var previousOptimizeLevel = _BinaryenGetOptimizeLevel();

var previousShrinkLevel = _BinaryenGetShrinkLevel();

var previousDebugInfo = _BinaryenGetDebugInfo();

_BinaryenSetOptimizeLevel(4);

_BinaryenSetShrinkLevel(0);

_BinaryenSetDebugInfo(false);

// wrap the expression in a temp. function and run the precompute pass on it

var type = _BinaryenExpressionGetType(expr);

var func = this.addTemporaryFunction(type, null, expr);

var names = this.cachedPrecomputeNames;

if (!names) {

this.cachedPrecomputeNames = names = allocI32Array([ this.allocStringCached("precompute") ]);

}

_BinaryenFunctionRunPasses(func, this.ref, names, 1);

expr = _BinaryenFunctionGetBody(func);

this.removeTemporaryFunction();

// reset optimize levels to previous

_BinaryenSetOptimizeLevel(previousOptimizeLevel);

_BinaryenSetShrinkLevel(previousShrinkLevel);

_BinaryenSetDebugInfo(previousDebugInfo);

return expr;

}

validate(): bool {

return _BinaryenModuleValidate(this.ref) == 1;

}

interpret(): void {

_BinaryenModuleInterpret(this.ref);

}

toBinary(sourceMapUrl: string | null): BinaryModule {

var out = this.cachedByValue;