GeezerVison

The World Wide Web, restored to 800 pixels of glory.

GeezerVison is showing github.com — binaryen.js API

binaryen.js API

Jump to bottom

Michael Ficarra edited this page Nov 22, 2022 · 13 revisions

Overview

binaryen.js is a port of Binaryen to the Web, allowing you to generate WebAssembly using a JavaScript API. To get a feel for the API, see the hello world test, and other tests in that directory for more examples.

The API is documented in the rest of this document.

Types
Module construction
Module manipulation
Module validation
Module optimization
Module creation
Expression construction
Expression manipulation
Relooper
Source maps
Debugging

Future features 🦄 might not be supported by all runtimes.

Types

none: Type
The none type, e.g., void.
i32: Type
32-bit integer type.
i64: Type
64-bit integer type.
f32: Type
32-bit float type.
f64: Type
64-bit float (double) type.
auto: Type
Special type used in Module#block exclusively. Lets the API figure out a block's result type automatically.
unreachable: Type
Special type indicating unreachable code when obtaining information about an expression.

Module construction

new Module(): Module
Constructs a new module.
parseText(text: string): Module
Creates a module from Binaryen's s-expression text format (not official stack-style text format).
readBinary(data: Uint8Array): Module
Creates a module from binary data.
wrapModule(ptr: number): Module
Wraps a module pointer as used with the underlying C-API as a JS module object.

Module manipulation

Module#addFunctionType(name: string, resultType: Type, paramTypes: Type[]): Signature
Adds a new function type.
Module#getFunctionTypeBySignature(resultType: Type, paramTypes: Type[]): Signature
Gets an existing function type by its parametric signature. Returns 0 if there is no such function type.
Module#removeFunctionType(name: string): void
Removes a function type.
Module#addFunction(name: string, functionType: Signature, varTypes: Type[], body: Expression): Function
Adds a function. varTypes indicate additional locals, in the given order.
Module#getFunction(name: string): Function
Gets a function, by name,
Module#removeFunction(name: string): void
Removes a function, by name.
Module#addFunctionImport(internalName: string, externalModuleName: string, externalBaseName: string, functionType: Signature): Import
Adds a function import.
Module#addTableImport(internalName: string, externalModuleName: string, externalBaseName: string): Import
Adds a table import. There's just one table for now, using name "0".
Module#addMemoryImport(internalName: string, externalModuleName: string, externalBaseName: string): Import
Adds a memory import. There's just one memory for now, using name "0".
Module#addGlobalImport(internalName: string, externalModuleName: string, externalBaseName: string, globalType: Type): Import
Adds a global variable import. Imported globals must be immutable.
Module#addFunctionExport(internalName: string, externalName: string): Export
Adds a function export.
Module#addTableExport(internalName: string, externalName: string): Export
Adds a table export. There's just one table for now, using name "0".
Module#addMemoryExport(internalName: string, externalName: string): Export
Adds a memory export. There's just one memory for now, using name "0".
Module#addGlobalExport(internalName: string, externalName: string): Export
Adds a global variable export. Exported globals must be immutable.
Module#addGlobal(name: string, type: Type, mutable: number, value: Expression): Global
Adds a global instance variable.
Module#removeExport(externalName: string): void
Removes an export, by external name.
Module#setFunctionTable(initial: number, maximum: number, funcs: string[]): void
Sets the contents of the function table. There's just one table for now, using name "0".
Module#setMemory(initial: number, maximum: number, exportName: string | null, segments: MemorySegment[]): void
Sets the memory. There's just one memory for now, using name "0". Providing exportName also creates a memory export.
Module#setStart(start: Function): void
Sets the start function.
Module#autoDrop(): void
Enables automatic insertion of drop operations where needed. Lets you not worry about dropping when creating your code.
getFunctionTypeInfo(ftype: FunctionType: FunctionTypeInfo
Obtains information about a function type.
- FunctionTypeInfo#name: string | null
- FunctionTypeInfo#params: Type[]
- FunctionTypeInfo#result: Type
getFunctionInfo(ftype: Function: FunctionInfo
Obtains information about a function.
- FunctionInfo#name: string
- FunctionInfo#module: string | null (if imported)
- FunctionInfo#base: string | null (if imported)
- FunctionInfo#type: FunctionType
- FunctionInfo#params: Type[]
- FunctionInfo#result: Type
- FunctionInfo#vars: Type
- FunctionInfo#body: Expression
getGlobalInfo(global: Global): GlobalInfo
Obtains information about a global.
- GlobalInfo#name: string
- GlobalInfo#module: string | null (if imported)
- GlobalInfo#base: string | null (if imported)
- GlobalInfo#type: Type
getExportInfo(export_: Export): ExportInfo
Obtains information about an export.
ExportInfo#kind: ExternalKind
ExportInfo#name: string
ExportInfo#value: string

Possible ExternalKind values are:

ExternalFunction: ExternalKind
ExternalTable: ExternalKind
ExternalMemory: ExternalKind
ExternalGlobal: ExternalKind

Module validation

Module#validate(): boolean
Validates the module. Returns true if valid, otherwise prints validation errors and returns false.

Module optimization

Module#optimize(): void
Optimizes the module using the default optimization passes.
Module#optimizeFunction(func: Function | string): void
Optimizes a single function using the default optimization passes.
Module#runPasses(passes: string[]): void
Runs the specified passes on the module.
Module#runPassesOnFunction(func: Function | string, passes: string[]): void
Runs the specified passes on a single function.
getOptimizeLevel(): number
Gets the currently set optimize level. 0, 1, 2 correspond to -O0, -O1, -O2 (default), etc.
setOptimizeLevel(level: number): void
Sets the optimization level to use. 0, 1, 2 correspond to -O0, -O1, -O2 (default), etc.
getShrinkLevel(): number
Gets the currently set shrink level. 0, 1, 2 correspond to -O0, -Os (default), -Oz.
setShrinkLevel(level: number): void
Sets the shrink level to use. 0, 1, 2 correspond to -O0, -Os (default), -Oz.
getDebugInfo(): boolean
Gets whether generating debug information is currently enabled or not.
setDebugInfo(on: boolean): void
Enables or disables debug information in emitted binaries.

Module creation

Module#emitBinary(): Uint8Array
Returns the module in binary format.
Module#emitBinary(sourceMapUrl: string | null): BinaryWithSourceMap
Returns the module in binary format with its source map. If sourceMapUrl is null, source map generation is skipped.
- BinaryWithSourceMap#binary: Uint8Array
- BinaryWithSourceMap#sourceMap: string | null
Module#emitText(): string
Returns the module in Binaryen's s-expression text format (not official stack-style text format).
Module#emitAsmjs(): string
Returns the asm.js representation of the module.
Module#dispose(): void
Releases the resources held by the module once it isn't needed anymore.

Expression construction

Control flow

Module#block(label: string | null, children: Expression[], resultType?: Type): Expression
Creates a block. resultType defaults to none.
Module#if(condition: Expression, ifTrue: Expression, ifFalse?: Expression): Expression
Creates an if or if/else combination.
Module#loop(label: string | null, body: Expression): Expression
Creates a loop.
Module#break(label: string, condition?: Expression, value?: Expression): Expression
Creates a break (br) to a label.
Module#switch(labels: string[], defaultLabel: string, condition: Expression, value?: Expression): Expression
Creates a switch (br_table).
Module#nop(): Expression
Creates a no-operation (nop) instruction.
Module#return(value?: Expression): Expression Creates a return.
Module#unreachable(): Expression
Creates an unreachable instruction that will always trap.
Module#drop(value: Expression): Expression
Creates a drop of a value.
Module#select(condition: Expression, ifTrue: Expression, ifFalse: Expression): Expression
Creates a select of one of two values.

Constants

Module#i32.const(value: number): Expression

Module#i64.const(low: number, high: number): Expression

Module#f32.const(value: number): Expression
Module#f32.const_bits(value: number): Expression

Module#f64.const(value: number): Expression
Module#f64.const_bits(low: number, high: number): Expression

Variable accesses

Module#local.get(index: number, type: Type): Expression
Creates a get for the local at the specified index. Note that we must specify the type here as we may not have created the local being called yet.
Module#local.set(index: number, value: Expression): Expression
Creates a set for the local at the specified index.
Module#local.tee(index: number, value: Expression): Expression
Creates a tee for the local at the specified index. A tee differs from a set in that the value remains on the stack.
Module#global.get(name: string, type: Type): Expression
Creates a get for the global with the specified name. Note that we must specify the type here as we may not have created the global being called yet.
Module#global.set(name: string, value: Expression): Expression
Creates a set for the global with the specified name.

Integer operations

Module#i32.clz(value: Expression): Expression
Module#i32.ctz(value: Expression): Expression
Module#i32.popcnt(value: Expression): Expression
Module#i32.eqz(value: Expression): Expression
Module#i32.add(left: Expression, right: Expression): Expression
Module#i32.sub(left: Expression, right: Expression): Expression
Module#i32.mul(left: Expression, right: Expression): Expression
Module#i32.div_s(left: Expression, right: Expression): Expression
Module#i32.div_u(left: Expression, right: Expression): Expression
Module#i32.rem_s(left: Expression, right: Expression): Expression
Module#i32.rem_u(left: Expression, right: Expression): Expression
Module#i32.and(left: Expression, right: Expression): Expression
Module#i32.or(left: Expression, right: Expression): Expression
Module#i32.xor(left: Expression, right: Expression): Expression
Module#i32.shl(left: Expression, right: Expression): Expression
Module#i32.shr_u(left: Expression, right: Expression): Expression
Module#i32.shr_s(left: Expression, right: Expression): Expression
Module#i32.rotl(left: Expression, right: Expression): Expression
Module#i32.rotr(left: Expression, right: Expression): Expression
Module#i32.eq(left: Expression, right: Expression): Expression
Module#i32.ne(left: Expression, right: Expression): Expression
Module#i32.lt_s(left: Expression, right: Expression): Expression
Module#i32.lt_u(left: Expression, right: Expression): Expression
Module#i32.le_s(left: Expression, right: Expression): Expression
Module#i32.le_u(left: Expression, right: Expression): Expression
Module#i32.gt_s(left: Expression, right: Expression): Expression
Module#i32.gt_u(left: Expression, right: Expression): Expression
Module#i32.ge_s(left: Expression, right: Expression): Expression
Module#i32.ge_u(left: Expression, right: Expression): Expression

Module#i64.clz(value: Expression): Expression
Module#i64.ctz(value: Expression): Expression
Module#i64.popcnt(value: Expression): Expression
Module#i64.eqz(value: Expression): Expression
Module#i64.add(left: Expression, right: Expression): Expression
Module#i64.sub(left: Expression, right: Expression): Expression
Module#i64.mul(left: Expression, right: Expression): Expression
Module#i64.div_s(left: Expression, right: Expression): Expression
Module#i64.div_u(left: Expression, right: Expression): Expression
Module#i64.rem_s(left: Expression, right: Expression): Expression
Module#i64.rem_u(left: Expression, right: Expression): Expression
Module#i64.and(left: Expression, right: Expression): Expression
Module#i64.or(left: Expression, right: Expression): Expression
Module#i64.xor(left: Expression, right: Expression): Expression
Module#i64.shl(left: Expression, right: Expression): Expression
Module#i64.shr_u(left: Expression, right: Expression): Expression
Module#i64.shr_s(left: Expression, right: Expression): Expression
Module#i64.rotl(left: Expression, right: Expression): Expression
Module#i64.rotr(left: Expression, right: Expression): Expression
Module#i64.eq(left: Expression, right: Expression): Expression
Module#i64.ne(left: Expression, right: Expression): Expression
Module#i64.lt_s(left: Expression, right: Expression): Expression
Module#i64.lt_u(left: Expression, right: Expression): Expression
Module#i64.le_s(left: Expression, right: Expression): Expression
Module#i64.le_u(left: Expression, right: Expression): Expression
Module#i64.gt_s(left: Expression, right: Expression): Expression
Module#i64.gt_u(left: Expression, right: Expression): Expression
Module#i64.ge_s(left: Expression, right: Expression): Expression
Module#i64.ge_u(left: Expression, right: Expression): Expression

Floating point operations

Module#f32.neg(value: Expression): Expression
Module#f32.abs(value: Expression): Expression
Module#f32.ceil(value: Expression): Expression
Module#f32.floor(value: Expression): Expression
Module#f32.trunc(value: Expression): Expression
Module#f32.nearest(value: Expression): Expression
Module#f32.sqrt(value: Expression): Expression
Module#f32.add(left: Expression, right: Expression): Expression
Module#f32.sub(left: Expression, right: Expression): Expression
Module#f32.mul(left: Expression, right: Expression): Expression
Module#f32.div(left: Expression, right: Expression): Expression
Module#f32.copysign(left: Expression, right: Expression): Expression
Module#f32.min(left: Expression, right: Expression): Expression
Module#f32.max(left: Expression, right: Expression): Expression
Module#f32.eq(left: Expression, right: Expression): Expression
Module#f32.ne(left: Expression, right: Expression): Expression
Module#f32.lt(left: Expression, right: Expression): Expression
Module#f32.le(left: Expression, right: Expression): Expression
Module#f32.gt(left: Expression, right: Expression): Expression
Module#f32.ge(left: Expression, right: Expression): Expression

Module#f64.neg(value: Expression): Expression
Module#f64.abs(value: Expression): Expression
Module#f64.ceil(value: Expression): Expression
Module#f64.floor(value: Expression): Expression
Module#f64.trunc(value: Expression): Expression
Module#f64.nearest(value: Expression): Expression
Module#f64.sqrt(value: Expression): Expression
Module#f64.add(left: Expression, right: Expression): Expression
Module#f64.sub(left: Expression, right: Expression): Expression
Module#f64.mul(left: Expression, right: Expression): Expression
Module#f64.div(left: Expression, right: Expression): Expression
Module#f64.copysign(left: Expression, right: Expression): Expression
Module#f64.min(left: Expression, right: Expression): Expression
Module#f64.max(left: Expression, right: Expression): Expression
Module#f64.eq(left: Expression, right: Expression): Expression
Module#f64.ne(left: Expression, right: Expression): Expression
Module#f64.lt(left: Expression, right: Expression): Expression
Module#f64.le(left: Expression, right: Expression): Expression
Module#f64.gt(left: Expression, right: Expression): Expression
Module#f64.ge(left: Expression, right: Expression): Expression

Datatype conversions

Module#i32.trunc_s.f32(value: Expression): Expression
Module#i32.trunc_s.f64(value: Expression): Expression
Module#i32.trunc_u.f32(value: Expression): Expression
Module#i32.trunc_u.f64(value: Expression): Expression
Module#i32.reinterpret(value: Expression): Expression
Module#i32.wrap(value: Expression): Expression

Module#i64.trunc_s.f32(value: Expression): Expression
Module#i64.trunc_s.f64(value: Expression): Expression
Module#i64.trunc_u.f32(value: Expression): Expression
Module#i64.trunc_u.f64(value: Expression): Expression
Module#i64.reinterpret(value: Expression): Expression
Module#i64.extend_s(value: Expression): Expression
Module#i64.extend_u(value: Expression): Expression

Module#f32.reinterpret(value: Expression): Expression
Module#f32.convert_s.i32(value: Expression): Expression
Module#f32.convert_s.i64(value: Expression): Expression
Module#f32.convert_u.i32(value: Expression): Expression
Module#f32.convert_u.i64(value: Expression): Expression
Module#f32.demote(value: Expression): Expression

Module#f64.reinterpret(value: Expression): Expression
Module#f64.convert_s.i32(value: Expression): Expression
Module#f64.convert_s.i64(value: Expression): Expression
Module#f64.convert_u.i32(value: Expression): Expression
Module#f64.convert_u.i64(value: Expression): Expression
Module#f64.promote(value: Expression): Expression

Function calls

Module#call(name: string, operands: Expression[], returnType: Type): Expression
Creates a call to a function. Note that we must specify the return type here as we may not have created the function being called yet.
Module#call_indirect/callIndirect(target: Expression, operands: Expression[], returnType: Type): Expression
Similar to call, but calls indirectly, i.e., via a function pointer, so an expression replaces the name as the called value.

Linear memory accesses

Module#i32.load(offset: number, align: number, ptr: Expression): Expression
Module#i32.load8_s(offset: number, align: number, ptr: Expression): Expression
Module#i32.load8_u(offset: number, align: number, ptr: Expression): Expression
Module#i32.load16_s(offset: number, align: number, ptr: Expression): Expression
Module#i32.load16_u(offset: number, align: number, ptr: Expression): Expression
Module#i32.store(offset: number, align: number, ptr: Expression, value: Expression): Expression
Module#i32.store8(offset: number, align: number, ptr: Expression, value: Expression): Expression
Module#i32.store16(offset: number, align: number, ptr: Expression, value: Expression): Expression

Module#i64.load(offset: number, align: number, ptr: Expression): Expression
Module#i64.load8_s(offset: number, align: number, ptr: Expression): Expression
Module#i64.load8_u(offset: number, align: number, ptr: Expression): Expression
Module#i64.load16_s(offset: number, align: number, ptr: Expression): Expression
Module#i64.load16_u(offset: number, align: number, ptr: Expression): Expression
Module#i64.load32_s(offset: number, align: number, ptr: Expression): Expression
Module#i64.load32_u(offset: number, align: number, ptr: Expression): Expression
Module#i64.store(offset: number, align: number, ptr: Expression, value: Expression): Expression
Module#i64.store8(offset: number, align: number, ptr: Expression, value: Expression): Expression
Module#i64.store16(offset: number, align: number, ptr: Expression, value: Expression): Expression
Module#i64.store32(offset: number, align: number, ptr: Expression, value: Expression): Expression

Module#f32.load(offset: number, align: number, ptr: Expression): Expression
Module#f32.store(offset: number, align: number, ptr: Expression, value: Expression): Expression

Module#f64.load(offset: number, align: number, ptr: Expression): Expression
Module#f64.store(offset: number, align: number, ptr: Expression, value: Expression): Expression

Host operations

Module#current_memory/currentMemory(): Expression
Module#grow_memory/growMemory(value: number): Expression
Module#has_feature/hasFeature(name: string): Expression 🦄

Atomic memory accesses 🦄

Module#i32.atomic.load(offset: number, ptr: Expression): Expression
Module#i32.atomic.load8_u(offset: number, ptr: Expression): Expression
Module#i32.atomic.load16_u(offset: number, ptr: Expression): Expression
Module#i32.atomic.store(offset: number, ptr: Expression, value: Expression): Expression
Module#i32.atomic.store8(offset: number, ptr: Expression, value: Expression): Expression
Module#i32.atomic.store16(offset: number, ptr: Expression, value: Expression): Expression

Module#i64.atomic.load(offset: number, ptr: Expression): Expression
Module#i64.atomic.load8_u(offset: number, ptr: Expression): Expression
Module#i64.atomic.load16_u(offset: number, ptr: Expression): Expression
Module#i64.atomic.load32_u(offset: number, ptr: Expression): Expression
Module#i64.atomic.store(offset: number, ptr: Expression, value: Expression): Expression
Module#i64.atomic.store8(offset: number, ptr: Expression, value: Expression): Expression
Module#i64.atomic.store16(offset: number, ptr: Expression, value: Expression): Expression
Module#i64.atomic.store32(offset: number, ptr: Expression, value: Expression): Expression

Atomic read-modify-write operations 🦄

Module#i32.atomic.rmw.add(offset: number, ptr: Expression, value: Expression): Expression
Module#i32.atomic.rmw.sub(offset: number, ptr: Expression, value: Expression): Expression
Module#i32.atomic.rmw.and(offset: number, ptr: Expression, value: Expression): Expression
Module#i32.atomic.rmw.or(offset: number, ptr: Expression, value: Expression): Expression
Module#i32.atomic.rmw.xor(offset: number, ptr: Expression, value: Expression): Expression
Module#i32.atomic.rmw.xchg(offset: number, ptr: Expression, value: Expression): Expression
Module#i32.atomic.rmw.cmpxchg(offset: number, ptr: Expression, expected: Expression, replacement: Expression): Expression
Module#i32.atomic.rmw8_u.add(offset: number, ptr: Expression, value: Expression): Expression
Module#i32.atomic.rmw8_u.sub(offset: number, ptr: Expression, value: Expression): Expression
Module#i32.atomic.rmw8_u.and(offset: number, ptr: Expression, value: Expression): Expression
Module#i32.atomic.rmw8_u.or(offset: number, ptr: Expression, value: Expression): Expression
Module#i32.atomic.rmw8_u.xor(offset: number, ptr: Expression, value: Expression): Expression
Module#i32.atomic.rmw8_u.xchg(offset: number, ptr: Expression, value: Expression): Expression
Module#i32.atomic.rmw8_u.cmpxchg(offset: number, ptr: Expression, expected: Expression, replacement: Expression): Expression
Module#i32.atomic.rmw16_u.add(offset: number, ptr: Expression, value: Expression): Expression
Module#i32.atomic.rmw16_u.sub(offset: number, ptr: Expression, value: Expression): Expression
Module#i32.atomic.rmw16_u.and(offset: number, ptr: Expression, value: Expression): Expression
Module#i32.atomic.rmw16_u.or(offset: number, ptr: Expression, value: Expression): Expression
Module#i32.atomic.rmw16_u.xor(offset: number, ptr: Expression, value: Expression): Expression
Module#i32.atomic.rmw16_u.xchg(offset: number, ptr: Expression, value: Expression): Expression
Module#i32.atomic.rmw16_u.cmpxchg(offset: number, ptr: Expression, expected: Expression, replacement: Expression): Expression

Module#i64.atomic.rmw.add(offset: number, ptr: Expression, value: Expression): Expression
Module#i64.atomic.rmw.sub(offset: number, ptr: Expression, value: Expression): Expression
Module#i64.atomic.rmw.and(offset: number, ptr: Expression, value: Expression): Expression
Module#i64.atomic.rmw.or(offset: number, ptr: Expression, value: Expression): Expression
Module#i64.atomic.rmw.xor(offset: number, ptr: Expression, value: Expression): Expression
Module#i64.atomic.rmw.xchg(offset: number, ptr: Expression, value: Expression): Expression
Module#i64.atomic.rmw.cmpxchg(offset: number, ptr: Expression, expected: Expression, replacement: Expression): Expression
Module#i64.atomic.rmw8_u.add(offset: number, ptr: Expression, value: Expression): Expression
Module#i64.atomic.rmw8_u.sub(offset: number, ptr: Expression, value: Expression): Expression
Module#i64.atomic.rmw8_u.and(offset: number, ptr: Expression, value: Expression): Expression
Module#i64.atomic.rmw8_u.or(offset: number, ptr: Expression, value: Expression): Expression
Module#i64.atomic.rmw8_u.xor(offset: number, ptr: Expression, value: Expression): Expression
Module#i64.atomic.rmw8_u.xchg(offset: number, ptr: Expression, value: Expression): Expression
Module#i64.atomic.rmw8_u.cmpxchg(offset: number, ptr: Expression, expected: Expression, replacement: Expression): Expression
Module#i64.atomic.rmw16_u.add(offset: number, ptr: Expression, value: Expression): Expression
Module#i64.atomic.rmw16_u.sub(offset: number, ptr: Expression, value: Expression): Expression
Module#i64.atomic.rmw16_u.and(offset: number, ptr: Expression, value: Expression): Expression
Module#i64.atomic.rmw16_u.or(offset: number, ptr: Expression, value: Expression): Expression
Module#i64.atomic.rmw16_u.xor(offset: number, ptr: Expression, value: Expression): Expression
Module#i64.atomic.rmw16_u.xchg(offset: number, ptr: Expression, value: Expression): Expression
Module#i64.atomic.rmw16_u.cmpxchg(offset: number, ptr: Expression, expected: Expression, replacement: Expression): Expression
Module#i64.atomic.rmw32_u.add(offset: number, ptr: Expression, value: Expression): Expression
Module#i64.atomic.rmw32_u.sub(offset: number, ptr: Expression, value: Expression): Expression
Module#i64.atomic.rmw32_u.and(offset: number, ptr: Expression, value: Expression): Expression
Module#i64.atomic.rmw32_u.or(offset: number, ptr: Expression, value: Expression): Expression
Module#i64.atomic.rmw32_u.xor(offset: number, ptr: Expression, value: Expression): Expression
Module#i64.atomic.rmw32_u.xchg(offset: number, ptr: Expression, value: Expression): Expression
Module#i64.atomic.rmw32_u.cmpxchg(offset: number, ptr: Expression, expected: Expression, replacement: Expression): Expression

Atomic wait and wake operations 🦄

Module#i32.wait(ptr: Expression, expected: Expression, timeout: Expression): Expression
Module#i64.wait(ptr: Expression, expected: Expression, timeout: Expression): Expression
Module#wake(ptr: Expression, wakeCount: Expression): Expression

Sign extension operations 🦄

Module#i32.extend8_s(value: Expression): Expression
Module#i32.extend16_s(value: Expression): Expression

Module#i64.extend8_s(value: Expression): Expression
Module#i64.extend16_s(value: Expression): Expression
Module#i64.extend32_s(value: Expression): Expression

Expression manipulation

getExpressionId(expr: Expression): ExpressionId
Gets the id (kind) of the specified expression. Possible values are:
- InvalidId: ExpressionId
- BlockId: ExpressionId
- IfId: ExpressionId
- LoopId: ExpressionId
- BreakId: ExpressionId
- SwitchId: ExpressionId
- CallId: ExpressionId
- CallImportId: ExpressionId
- CallIndirectId: ExpressionId
- GetLocalId: ExpressionId
- SetLocalId: ExpressionId
- GetGlobalId: ExpressionId
- SetGlobalId: ExpressionId
- LoadId: ExpressionId
- StoreId: ExpressionId
- ConstId: ExpressionId
- UnaryId: ExpressionId
- BinaryId: ExpressionId
- SelectId: ExpressionId
- DropId: ExpressionId
- ReturnId: ExpressionId
- HostId: ExpressionId
- NopId: ExpressionId
- UnreachableId: ExpressionId
- AtomicCmpxchgId: ExpressionId
- AtomicRMWId: ExpressionId
- AtomicWaitId: ExpressionId
- AtomicWakeId: ExpressionId
getExpressionType(expr: Expression): Type
Gets the type of the specified expression.
getExpressionInfo(expr: Expression: ExpressionInfo
Obtains information about an expression, always including:
- Info#id: ExpressionId
- Info#type: Type
Additional properties depend on the expression's id and are usually equivalent to the respective parameters when creating such an expression:
- BlockInfo#name: string
- BlockInfo#children: Expression[]
- IfInfo#condition: Expression
- IfInfo#ifTrue: Expression
- IfInfo#ifFalse: Expression | null
- LoopInfo#name: string
- LoopInfo#body: Expression
- BreakInfo#name: string
- BreakInfo#condition: Expression | null
- BreakInfo#value: Expression | null
- SwitchInfo#names: string[]
- SwitchInfo#defaultName: string | null
- SwitchInfo#condition: Expression
- SwitchInfo#value: Expression | null
- CallInfo#target: string
- CallInfo#operands: Expression[]
- CallImportInfo#target: string
- CallImportInfo#operands: Expression[]
- CallIndirectInfo#target: Expression
- CallIndirectInfo#operands: Expression[]
- GetLocalInfo#index: number
- SetLocalInfo#isTee: boolean
- SetLocalInfo#index: number
- SetLocalInfo#value: Expression
- GetGlobalInfo#name: string
- SetGlobalInfo#name: string
- SetGlobalValue#value: Expression
- LoadInfo#isAtomic: boolean
- LoadInfo#isSigned: boolean
- LoadInfo#offset: number
- LoadInfo#bytes: number
- LoadInfo#align: number
- LoadInfo#ptr: Expression
- StoreInfo#isAtomic: boolean
- StoreInfo#offset: number
- StoreInfo#bytes: number
- StoreInfo#align: number
- StoreInfo#ptr: Expression
- StoreInfo#value: Expression
- ConstInfo#value: number | { low: number, high: number }
- UnaryInfo#op: number
- UnaryInfo#value: Expression
- BinaryInfo#op: number
- BinaryInfo#left: Expression
- BinaryInfo#right: Expression
- SelectInfo#ifTrue: Expression
- SelectInfo#ifFalse: Expression
- SelectInfo#condition: Expression
- DropInfo#value: Expression
- ReturnInfo#value: Expression | null
- HostInfo#op: number
- HostInfo#nameOperand: string | null
- HostInfo#operands: Expression[]
- AtomicRMWInfo#op: number
- AtomicRMWInfo#bytes: number
- AtomicRMWInfo#offset: number
- AtomicRMWInfo#ptr: Expression
- AtomicRMWInfo#value: Expression
- AtomicCmpxchgInfo#bytes: number
- AtomicCmpxchgInfo#offset: number
- AtomicCmpxchgInfo#ptr: Expression
- AtomicCmpxchgInfo#expected: Expression
- AtomicCmpxchgInfo#replacement: Expression
- AtomicWaitInfo#ptr: Expression
- AtomicWaitInfo#expected: Expression
- AtomicWaitInfo#timeout: Expression
- AtomicWaitInfo#expectedType: Type
- AtomicWakeInfo#ptr: Expression
- AtomicWakeInfo#wakeCount: Expression
NopInfo and UnreachableInfo do not include any additional properties.

Relooper

new Relooper(module: Module): Relooper
Constructs a relooper instance. This lets you provide an arbitrary CFG, and the relooper will structure it for WebAssembly.
Relooper#addBlock(code: Expression): RelooperBlock
Adds a new block to the CFG, containing the provided code as its body.
Relooper#addBranch(from: RelooperBlock, to: RelooperBlock, condition: Expression, code: Expression): void
Adds a branch from a block to another block, with a condition (or nothing, if this is the default branch to take from the origin - each block must have one such branch), and optional code to execute on the branch (useful for phis).
Relooper#addBlockWithSwitch(code: Expression, condition: Expression): RelooperBlock
Adds a new block, which ends with a switch/br_table, with provided code and condition (that determines where we go in the switch).
Relooper#addBranchForSwitch(from: RelooperBlock, to: RelooperBlock, indexes: number[], code: Expression): void
Adds a branch from a block ending in a switch, to another block, using an array of indexes that determine where to go, and optional code to execute on the branch.
Relooper#renderAndDispose(entry: RelooperBlock, labelHelper: number): Expression
Renders and cleans up the Relooper instance. Call this after you have created all the blocks and branches, giving it the entry block (where control flow begins) and a label helper variable (an index of a local we can use, necessary for irreducible control flow). This returns an expression - normal WebAssembly code - that you can use normally anywhere.

Source maps

Module#addDebugInfoFileName(filename: string): number
Adds a debug info file name to the module and returns its index.
Module#getDebugInfoFileName(index: number): string | null
Gets the name of the debug info file at the specified index.
Module#setDebugLocation(func: Function, expr: Expression, fileIndex: number, lineNumber: number, columnNumber: number): void
Sets the debug location of the specified Expression within the specified Function.

Debugging

Module#setAPITracing(on: boolean): void
Enables tracing of the C-API in the console. Can be very useful when filing bug reports.
Module#interpret(): void
Runs the module in the interpreter, calling the start function.

Clone this wiki locally

You are visitor 01402503 — GeezerVison does not store the pages you look up.
Best viewed with Netscape Navigator 4.7 or Internet Explorer 6 at 800×600. No cookies required.