Permalink
Switch branches/tags
Nothing to show
Find file Copy path
Fetching contributors…
Cannot retrieve contributors at this time
1250 lines (1056 sloc) 49.5 KB
import {utf8} from './utf8'
import {Emittable, Emitter} from './emit'
// For some reason we can't import basic-types into this module.
// import {uint1,uint7,uint8,uint16,uint32,int7,int32,int64,float32,float64} from './basic-types'
export type uint1 = number
export type uint7 = number
export type uint8 = number
export type uint16 = number
export type uint32 = number
export type int7 = number
export type int32 = number
export type int64 = number
export type float32 = number
export type float64 = number
const DEBUG = false
const assert = DEBUG ? function(cond :any, msg? :any) {
if (!cond) { throw new Error('assertion failure'); }
} : function(){}
//——————————————————————————————————————————————————————————————————————————————
// Basic node types
export type TypeTag = symbol
export interface N extends Emittable {
readonly t :TypeTag // type
readonly z :uint32 // size in bytes (includes size of any children)
readonly v :any // value
}
export interface Atom<T> extends N {
readonly v :T
}
export interface Cell<T extends N> extends N {
readonly v :T[]
}
//—————————————————————————————————————
// Formal types
// We use a trick here to get the most out of TypeScripts type checker,
// namely we specify interfaces that have "type tag" properties.
// However, concrete types doesn't actually have these properties, so any
// attempts to access these properties will always yield `undefined`.
export interface Module extends Cell<Section> { readonly _Module: undefined
readonly version :uint32
}
export type Section = CustomSection
| TypeSection // Function signature declarations
| ImportSection // Import declarations
| FunctionSection // Function declarations
| TableSection // Indirect function table and other tables
| MemorySection // Memory attributes
| GlobalSection // Global declarations
| ExportSection // Exports
| StartSection // Start function declaration
| ElementSection // Elements section
| CodeSection // Function bodies (code)
| DataSection // Data segments
export interface CustomSection extends Cell<N> { readonly _CustomSection: undefined }
export interface TypeSection extends Cell<FuncType> { readonly _TypeSection: undefined }
export interface ImportSection extends Cell<ImportEntry> { readonly _ImportSection: undefined }
export interface FunctionSection extends Cell<VarUint32> { readonly _FunctionSection: undefined }
export interface TableSection extends Cell<TableType> { readonly _TableSection: undefined }
export interface MemorySection extends Cell<ResizableLimits>{readonly _MemorySection:undefined}
export interface GlobalSection extends Cell<GlobalVariable> {readonly _GlobalSection:undefined}
export interface ExportSection extends Cell<ExportEntry> { readonly _ExportSection: undefined }
export interface StartSection extends Cell<Void> { readonly _StartSection: undefined }
export interface ElementSection extends Cell<ElemSegment> { readonly _ElementSection: undefined}
export interface CodeSection extends Cell<FunctionBody> { readonly _CodeSection: undefined }
export interface DataSection extends Cell<DataSegment> { readonly _DataSection: undefined }
export interface ImportEntry extends Cell<N> { readonly _ImportEntry: undefined }
export interface ExportEntry extends Cell<N> { readonly _ExportEntry: undefined }
export interface FuncType extends Cell<N> { readonly _FuncType: undefined }
export interface TableType extends Cell<N> { readonly _TableType: undefined }
export interface GlobalType extends Cell<N> { readonly _GlobalType: undefined }
export interface ResizableLimits extends Cell<N> { readonly _ResizableLimits: undefined }
export interface GlobalVariable extends Cell<N> { readonly _GlobalVariable: undefined }
export interface ElemSegment extends Cell<N> { readonly _ElemSegment: undefined }
export interface DataSegment extends Cell<N> { readonly _DataSegment: undefined }
export interface InitExpr extends Cell<N> { readonly _InitExpr: undefined }
export interface FunctionBody extends Cell<N> { readonly _FunctionBody: undefined }
export interface LocalEntry extends Cell<N> { readonly _LocalEntry: undefined }
export interface Str extends Atom<ArrayLike<uint8>> { readonly _Str: undefined
readonly len :VarUint32
}
export interface Data extends Atom<ArrayLike<uint8>> { readonly _Data: undefined }
export interface Uint8 extends Atom<uint8> {}
export interface Uint16 extends Atom<uint16> {}
export interface Uint32 extends Atom<uint32> {}
export interface VarUint32 extends Atom<uint32> {}
export interface VarUint7 extends Atom<uint7> {}
export interface VarUint1 extends Atom<uint1> {}
export interface VarInt7 extends Atom<int7> {}
export interface VarInt32 extends Atom<int32> {}
export interface VarInt64 extends Atom<int64> {}
export interface Float32 extends Atom<float32> {}
export interface Float64 extends Atom<float64> {}
export interface I32 extends VarInt32 { readonly _I32: undefined }
export interface I64 extends VarInt64 { readonly _I64: undefined }
export interface F32 extends Float32 { readonly _F32: undefined }
export interface F64 extends Float64 { readonly _F64: undefined }
export interface Void extends VarInt7 { readonly _Void :undefined }
export type Int = I32 | I64 // wasm32 | wasm64
export type Result = I32 | I64 | F32 | F64
export type AnyResult = Result | Void
export type AnyOp = Op<AnyResult>
export interface ValueType extends Atom<int32|int64|float32|float64> {}
type AnyFunc = VarInt7
type Func = VarInt7
type EmptyBlock = VarInt7
type ElemType = AnyFunc
type ExternalKind = Uint8
type BlockType = ValueType | EmptyBlock
// Memory immediate.
// In wasm32, address operands and offset attributes have type i32
export type MemImm = [
// flags - a bitfield which currently contains the alignment in the least
// significant bits, encoded as log2(alignment)
VarUint32,
// offset - added to the address to form effective address.
// Useful when the address is dynamic and the compiler wants to add some
// constant amount of offset to the dynamically-produced address.
// I.e. effective_address = address + offset
Int
]
// Instruction opcodes
export type OpCode = uint8
export interface Op<R> extends N {
readonly _Op :R
readonly r :AnyResult
readonly v :OpCode
readonly pre? :N[] | N // instrs. pushing values onto the stack, used by "pre" types
readonly imm? :N[] | N // immediates, used by "imm" types
readonly post? :N[] // used by "post" types
}
// Operations on all number types
export interface NumOps<R extends Result> {
const(v :number) :Op<R>
load(mi :MemImm, addr :Op<Int>) :Op<R>
store(mi :MemImm, addr :Op<Int>, v :Op<R>) :Op<Void>
addrIsAligned(mi :MemImm, addr :number) :boolean
eq(a :Op<R>, b :Op<R>) :Op<I32>
ne(a :Op<R>, b :Op<R>) :Op<I32>
add(a :Op<R>, b :Op<R>) :Op<R>
sub(a :Op<R>, b :Op<R>) :Op<R>
mul(a :Op<R>, b :Op<R>) :Op<R>
}
// Operations on all integer number types
export interface IntOps<R extends Result> extends NumOps<R> {
// Memory
load8_s(mi :MemImm, addr :Op<Int>) :Op<R>
load8_u(mi :MemImm, addr :Op<Int>) :Op<R>
load16_s(mi :MemImm, addr :Op<Int>) :Op<R>
load16_u(mi :MemImm, addr :Op<Int>) :Op<R>
store8(mi :MemImm, addr :Op<Int>, v :Op<R>) :Op<Void>
store16(mi :MemImm, addr :Op<Int>, v :Op<R>) :Op<Void>
// Comparison
eqz (a :Op<R>) :Op<I32>
lt_s(a :Op<R>, b :Op<R>) :Op<I32>
lt_u(a :Op<R>, b :Op<R>) :Op<I32>
gt_s(a :Op<R>, b :Op<R>) :Op<I32>
gt_u(a :Op<R>, b :Op<R>) :Op<I32>
le_s(a :Op<R>, b :Op<R>) :Op<I32>
le_u(a :Op<R>, b :Op<R>) :Op<I32>
ge_s(a :Op<R>, b :Op<R>) :Op<I32>
ge_u(a :Op<R>, b :Op<R>) :Op<I32>
// Numeric
clz (a :Op<R>) :Op<R>
ctz (a :Op<R>) :Op<R>
popcnt(a :Op<R>) :Op<R>
add (a :Op<R>, b :Op<R>) :Op<R>
sub (a :Op<R>, b :Op<R>) :Op<R>
mul (a :Op<R>, b :Op<R>) :Op<R>
div_s (a :Op<R>, b :Op<R>) :Op<R>
div_u (a :Op<R>, b :Op<R>) :Op<R>
rem_s (a :Op<R>, b :Op<R>) :Op<R>
rem_u (a :Op<R>, b :Op<R>) :Op<R>
and (a :Op<R>, b :Op<R>) :Op<R>
or (a :Op<R>, b :Op<R>) :Op<R>
xor (a :Op<R>, b :Op<R>) :Op<R>
shl (a :Op<R>, b :Op<R>) :Op<R>
shr_s (a :Op<R>, b :Op<R>) :Op<R>
shr_u (a :Op<R>, b :Op<R>) :Op<R>
rotl (a :Op<R>, b :Op<R>) :Op<R>
rotr (a :Op<R>, b :Op<R>) :Op<R>
// Conversion
trunc_s_f32(a :Op<F32>) :Op<R>
trunc_u_f32(a :Op<F32>) :Op<R>
trunc_s_f64(a :Op<F64>) :Op<R>
trunc_u_f64(a :Op<F64>) :Op<R>
}
export interface FloatOps<R extends Result> extends NumOps<R> {
// Comparison
eq(a :Op<R>, b :Op<R>) :Op<I32>
ne(a :Op<R>, b :Op<R>) :Op<I32>
lt(a :Op<R>, b :Op<R>) :Op<I32>
gt(a :Op<R>, b :Op<R>) :Op<I32>
le(a :Op<R>, b :Op<R>) :Op<I32>
ge(a :Op<R>, b :Op<R>) :Op<I32>
// Numeric
add (a :Op<R>, b :Op<R>) :Op<R>
sub (a :Op<R>, b :Op<R>) :Op<R>
mul (a :Op<R>, b :Op<R>) :Op<R>
abs (a :Op<R>) :Op<R>
neg (a :Op<R>) :Op<R>
ceil (a :Op<R>) :Op<R>
floor (a :Op<R>) :Op<R>
trunc (a :Op<R>) :Op<R>
nearest (a :Op<R>) :Op<R>
sqrt (a :Op<R>) :Op<R>
div (a :Op<R>, b :Op<R>) :Op<R>
min (a :Op<R>, b :Op<R>) :Op<R>
max (a :Op<R>, b :Op<R>) :Op<R>
copysign(a :Op<R>, b :Op<R>) :Op<R>
// Conversion
convert_s_i32(a :Op<I32>) :Op<R>
convert_u_i32(a :Op<I32>) :Op<R>
convert_s_i64(a :Op<I64>) :Op<R>
convert_u_i64(a :Op<I64>) :Op<R>
}
export interface I32ops extends I32, IntOps<I32> {
constv(v :VarInt32) :Op<I32>
const(v :int32) :Op<I32>
wrap_i64(a :Op<I64>) :Op<I32>
reinterpret_f32(a :Op<F32>) :Op<I32>
}
export interface I64ops extends I64, IntOps<I64> {
constv(v :VarInt64) :Op<I64>
const(v :int64) :Op<I64>
load32_s(mi :MemImm, addr :Op<Int>) :Op<I64>
load32_u(mi :MemImm, addr :Op<Int>) :Op<I64>
store32(mi :MemImm, addr :Op<Int>, v :Op<Result>) :Op<Void>
extend_s_i32(a :Op<I32>) :Op<I64>
extend_u_i32(a :Op<I32>) :Op<I64>
reinterpret_f64(a :Op<F64>) :Op<I64>
}
export interface F32ops extends F32, FloatOps<F32> {
constv(v :Float32) :Op<F32>
const(v :float32) :Op<F32>
demote_f64(a :Op<F64>) :Op<F32>
reinterpret_i32(a :Op<I32>) :Op<F32>
}
export interface F64ops extends F64, FloatOps<F64> {
constv(v :Float64) :Op<F64>
const(v :float64) :Op<F64>
promote_f32(a :Op<F32>) :Op<F64>
reinterpret_i64(a :Op<I64>) :Op<F64>
}
//——————————————————————————————————————————————————————————————————————————————
// Type tags
const T = {
// Atoms
uint8: Symbol('u8'),
uint16: Symbol('u16'),
uint32: Symbol('u32'),
varuint1: Symbol('vu1'),
varuint7: Symbol('vu7'),
varuint32: Symbol('vu32'),
varint7: Symbol('vs7'),
varint32: Symbol('vs32'),
varint64: Symbol('vs64'),
float32: Symbol('f32'), // non-standard
float64: Symbol('f64'), // non-standard
data: Symbol('data'), // non-standard
type: Symbol('type'), // non-standard, signifies a varint7 type constant
external_kind: Symbol('type'),
// Instructions
instr: Symbol('instr'), // non-standard
instr_pre: Symbol('instr_pre'), // non-standard
instr_pre1: Symbol('instr_pre1'), // non-standard
instr_imm1: Symbol('instr_imm1'), // non-standard
instr_imm1_post: Symbol('instr_imm1_post'), // non-standard
instr_pre_imm: Symbol('instr_pre_imm'), // non-standard
instr_pre_imm_post: Symbol('instr_pre_imm_post'), // non-standard
// Cells
module: Symbol('module'),
section: Symbol('section'),
import_entry: Symbol('import_entry'),
export_entry: Symbol('export_entry'),
local_entry: Symbol('local_entry'),
func_type: Symbol('func_type'),
table_type: Symbol('table_type'),
memory_type: Symbol('memory_type'),
global_type: Symbol('global_type'),
resizable_limits: Symbol('resizable_limits'),
global_variable: Symbol('global_variable'),
init_expr: Symbol('init_expr'),
elem_segment: Symbol('elem_segment'),
data_segment: Symbol('data_segment'),
function_body: Symbol('function_body'),
str: Symbol('str'), // non-standard
}
//——————————————————————————————————————————————————————————————————————————————
// node structs
const writev = (e :Emitter, objs :Emittable[]) :Emitter => objs.reduce((e, n) => n.emit(e), e)
const sumz = function(n :N[]) {
let sum = 0
for (let i = 0, L = n.length; i != L; ++i) {
sum += n[i].z
}
return sum
}
const readVarInt7 = (byte :uint8) :int7 =>
byte < 64 ? byte : -(128 - byte)
class bytes_atom implements Atom<ArrayLike<uint8>> {
readonly t :TypeTag
readonly z :uint32
readonly v :ArrayLike<uint8>
constructor(t :TypeTag, v :ArrayLike<uint8>) {
this.t = t
this.z = v.length
this.v = v
}
emit(e :Emitter) { return e.writeBytes(this.v) }
}
class val_atom<T> implements Atom<T> {
readonly t :TypeTag
readonly z :uint32
readonly v :T
constructor(t :TypeTag, z :uint32, v :T) { this.t = t; this.z = z; this.v = v }
emit(e :Emitter) { return e } // override in subclasses
}
class bytesval_atom<T extends number> extends val_atom<T> {
readonly bytes :ArrayLike<uint8>
constructor(t :TypeTag, v :T, bytes :ArrayLike<uint8>) {
super(t, bytes.length, v)
this.bytes = bytes
}
emit(e :Emitter) { return e.writeBytes(this.bytes) }
}
class u32_atom extends val_atom<uint32> {
constructor(v :uint32) { super(T.uint32, 4, v) }
emit(e :Emitter) { return e.writeU32(this.v) }
}
class f32_atom extends val_atom<float32> {
constructor(v :number) { super(T.float32, 4, v) }
emit(e :Emitter) { return e.writeF32(this.v) }
}
class f64_atom extends val_atom<float64> {
constructor(v :number) { super(T.float64, 8, v) }
emit(e :Emitter) { return e.writeF64(this.v) }
}
class u8_atom<T extends number> extends val_atom<T> {
constructor(t :TypeTag, v :T) { super(t, 1, v) }
emit(e :Emitter) { return e.writeU8(this.v) }
}
class type_atom extends u8_atom<int7> {
readonly b :uint8
constructor(v :int7, b :uint8) { super(T.type, v); this.b = b }
emit(e :Emitter) { return e.writeU8(this.b) }
}
class str_atom implements Atom<ArrayLike<uint8>> {
readonly t :TypeTag
readonly z :uint32
readonly v :ArrayLike<uint8>
readonly len :VarUint32
constructor(len: VarUint32, v :ArrayLike<uint8>) {
assert(len.v == v.length)
this.t = T.str
this.z = len.z + v.length
this.v = v
this.len = len
}
emit(e :Emitter) { return this.len.emit(e).writeBytes(this.v) }
}
class cell<T extends N> implements Cell<T> {
readonly t :TypeTag
readonly z :uint32
readonly v :T[]
constructor(t :TypeTag, v :T[]) {
this.t = t
this.z = sumz(v)
this.v = v
}
emit(e :Emitter) { return writev(e, this.v) }
}
//—————————————————————————————————————————————
// Instructions
class instr_atom extends u8_atom<uint8> {
readonly r :AnyResult
constructor(v :uint8, r :AnyResult) { super(T.instr, v); this.r = r }
}
class instr_cell implements N {
readonly t :TypeTag
readonly z :uint32
readonly v :OpCode
readonly r :AnyResult
constructor(t :TypeTag, op :uint8, r :AnyResult, z :uint32) {
this.t = t
this.z = z
this.v = op
this.r = r
}
emit(e :Emitter) { return e }
}
class instr_pre1 extends instr_cell {
readonly pre :N
constructor(op :uint8, r :AnyResult, pre :N) {
super(T.instr_pre1, op, r, 1 + pre.z)
this.pre = pre
}
emit(e :Emitter) { return this.pre.emit(e).writeU8(this.v) }
}
class instr_imm1 extends instr_cell {
readonly imm :N
constructor(op :uint8, r :AnyResult, imm :N) {
super(T.instr_imm1, op, r, 1 + imm.z)
this.imm = imm
}
emit(e :Emitter) { return this.imm.emit(e.writeU8(this.v)) }
}
class instr_pre extends instr_cell {
readonly pre :N[]
constructor(op :uint8, r :AnyResult, pre :N[]) {
super(T.instr_pre, op, r, 1 + sumz(pre))
this.pre = pre
}
emit(e :Emitter) { return writev(e, this.pre).writeU8(this.v) }
}
class instr_imm1_post extends instr_cell {
readonly imm :N
readonly post :N[]
constructor(op :uint8, r :AnyResult, imm :N, post :N[]) {
super(T.instr_imm1_post, op, r, 1 + imm.z + sumz(post))
this.imm = imm
this.post = post
}
emit(e :Emitter) { return writev(this.imm.emit(e.writeU8(this.v)), this.post) }
}
class instr_pre_imm extends instr_cell {
readonly pre :N[]
readonly imm :N[]
constructor(op :uint8, r :AnyResult, pre :N[], imm :N[]) {
super(T.instr_pre_imm, op, r, 1 + sumz(pre) + sumz(imm))
this.pre = pre
this.imm = imm
}
emit(e :Emitter) { return writev(writev(e, this.pre).writeU8(this.v), this.imm) }
}
class instr_pre_imm_post extends instr_cell {
readonly pre :N[]
readonly imm :N[]
readonly post :N[]
constructor(op :uint8, r :AnyResult, pre :N[], imm :N[], post :N[]) {
super(T.instr_pre_imm_post, op, r, 1 + sumz(pre) + sumz(imm) + sumz(post))
this.pre = pre
this.imm = imm
this.post = post
}
emit(e :Emitter) {
return writev(writev(writev(e, this.pre).writeU8(this.v), this.imm), this.post)
}
}
function maprange<R>(start:number, stop:number, fn:(v:number)=>R|undefined) :Array<R> {
let a :R[] = []
while (start < stop) {
let v :R = fn(start)
if (v !== undefined) {
a.push(v)
}
start += 1
}
return a
}
//——————————————————————————————————————————————————————————————————————————————
// constructors
const uint8Cache :Uint8[] = maprange(0,16, v =>
new u8_atom<uint8>(T.uint8, v as uint8))
const varUint7Cache :VarUint7[] = maprange(0,16, v =>
new u8_atom<uint7>(T.varuint7, v as uint8))
const varUint32Cache :VarUint7[] = maprange(0,16, v =>
new u8_atom<uint32>(T.varuint32, v as uint8))
const varuint1_0 = new u8_atom<uint1>(T.varuint1, 0) as Atom<uint1>
const varuint1_1 = new u8_atom<uint1>(T.varuint1, 1) as Atom<uint1>
function uint8(v :uint8) {
return uint8Cache[v] || new u8_atom<uint8>(T.uint8, v) as Uint8
}
function uint32(v :uint32) { return new u32_atom(v) as Uint32 }
function float32(v :float32) { return new f32_atom(v) as Float32 }
function float64(v :float64) { return new f64_atom(v) as Float64 }
// LEB128-encoded variable-length integers: (N = bits)
// unsigned range: [0, 2^N-1]
// signed range: [-2^(N-1), +2^(N-1)-1]
function varuint1(v :any) {
return v ? varuint1_1 : varuint1_0
}
function varuint7(v :uint7) {
assert(v >= 0 && v <= 128)
return varUint7Cache[v] || new u8_atom<uint7>(T.varuint7, v) as VarUint7
}
function varuint32(value :uint32) {
const c = varUint32Cache[value]
if (c) { return c }
assert(value >= 0 && value <= 0xffffffff)
let v = value
const bytes :uint8[] = []
while (v >= 0x80) {
bytes.push((v & 0x7f) | 0x80)
v >>>= 7
}
bytes.push(v)
return new bytesval_atom<uint32>(T.varuint32, value, bytes) as VarUint32
}
function varint7(value :int7) {
assert(value >= -64 && value <= 63);
return new u8_atom<int7>(T.varint7, value < 0 ? (128 + value) : value) as VarInt7
}
function encVarIntN(v :int64) :uint8[] {
// FIXME: broken for values larger than uint32
const bytes :uint8[] = []
while (true) {
let b = v & 0x7f
if (-64 <= v && v < 64) {
bytes.push(b)
break
}
v >>= 7 // Note: sign-propagating right shift
bytes.push(b | 0x80)
}
return bytes
}
function varint32(value :int32) :VarInt32 {
assert(value >= -0x80000000 && value <= 0x7fffffff)
return new bytesval_atom<int32>(T.varint32, value, encVarIntN(value)) as VarInt32
}
function varint64(value :int64) :VarInt64 {
// Here be dragons! Not all negative 64bit numbers can be represented with
// JavaScript numbers. The ECMAScript double type has 53 bits of integer
// precision. We thus assert this range
assert(value >= Number.MIN_SAFE_INTEGER && value <= Number.MAX_SAFE_INTEGER)
return new bytesval_atom<int64>(T.varint64, value, encVarIntN(value)) as VarInt64
}
// Language types
const AnyFunc = new type_atom(-0x10, 0x70) as any as AnyFunc
const Func = new type_atom(-0x20, 0x60) as any as Func
const EmptyBlock = new type_atom(-0x40, 0x40) as any as EmptyBlock
const Void = EmptyBlock as any as Void
const external_kind_function = new u8_atom<uint8>(T.external_kind, 0) as any as ExternalKind
const external_kind_table = new u8_atom<uint8>(T.external_kind, 1) as any as ExternalKind
const external_kind_memory = new u8_atom<uint8>(T.external_kind, 2) as any as ExternalKind
const external_kind_global = new u8_atom<uint8>(T.external_kind, 3) as any as ExternalKind
const str = (data: ArrayLike<uint8>) =>
new str_atom(varuint32(data.length), data) as any as Str
const sect_id_custom = varuint7(0)
const sect_id_type = varuint7(1)
const sect_id_import = varuint7(2)
const sect_id_function = varuint7(3)
const sect_id_table = varuint7(4)
const sect_id_memory = varuint7(5)
const sect_id_global = varuint7(6)
const sect_id_export = varuint7(7)
const sect_id_start = varuint7(8)
const sect_id_element = varuint7(9)
const sect_id_code = varuint7(10)
const sect_id_data = varuint7(11)
export const sect_id = {
custom: sect_id_custom,
type: sect_id_type,
import: sect_id_import,
function: sect_id_function,
table: sect_id_table,
memory: sect_id_memory,
global: sect_id_global,
export: sect_id_export,
start: sect_id_start,
element: sect_id_element,
code: sect_id_code,
data: sect_id_data,
}
function section(id :VarUint7, imm :N, payload :N[]) {
return new cell<N>(T.section,
[id, varuint32(imm.z + sumz(payload)), imm, ...payload]
)
}
const memload = <R extends Result>(op :OpCode, r :R, mi :MemImm, addr :Op<Int>) =>
new instr_pre_imm(op, r, [addr], mi) as any as Op<R>
const memstore = (op :OpCode, mi :MemImm, addr :Op<Int>, v :Op<Result>) =>
new instr_pre_imm(op, Void, [addr, v], mi) as any as Op<Void>
// memAddrIsAligned returns true if the memory operation will actually be aligned.
// Note: natAl and al should be encoded as log2(bits), i.e. 32bit = 2
const addrIsAligned = (natAl :uint32, al :uint32, offs :number, addr :number) =>
al <= natAl &&
((addr + offs) % [1, 2, 4, 8][al]) == 0
class i32ops extends type_atom implements I32ops { readonly _I32: undefined;
// Constants
constv(v :VarInt32) { return new instr_imm1(0x41, this, v) as any as Op<I32> }
const(v :int32) :Op<I32> { return this.constv(varint32(v)) }
// Memory
load(mi :MemImm, addr :Op<Int>) { return memload(0x28, this, mi, addr) }
load8_s(mi :MemImm, addr :Op<Int>) { return memload(0x2c, this, mi, addr) }
load8_u(mi :MemImm, addr :Op<Int>) { return memload(0x2d, this, mi, addr) }
load16_s(mi :MemImm, addr :Op<Int>) { return memload(0x2e, this, mi, addr) }
load16_u(mi :MemImm, addr :Op<Int>) { return memload(0x2f, this, mi, addr) }
store(mi :MemImm, addr :Op<Int>, v :Op<I32>) { return memstore(0x36, mi, addr, v) }
store8(mi :MemImm, addr :Op<Int>, v :Op<I32>) { return memstore(0x3a, mi, addr, v) }
store16(mi :MemImm, addr :Op<Int>, v :Op<I32>) { return memstore(0x3b, mi, addr, v) }
addrIsAligned(mi :MemImm, addr :number) { return addrIsAligned(2, mi[0].v, mi[1].v, addr) }
// Comparison
eqz (a :Op<I32>) { return new instr_pre1(0x45,this,a) as any as Op<I32> }
eq (a :Op<I32>, b :Op<I32>) { return new instr_pre(0x46,this,[a,b]) as any as Op<I32> }
ne (a :Op<I32>, b :Op<I32>) { return new instr_pre(0x47,this,[a,b]) as any as Op<I32> }
lt_s(a :Op<I32>, b :Op<I32>) { return new instr_pre(0x48,this,[a,b]) as any as Op<I32> }
lt_u(a :Op<I32>, b :Op<I32>) { return new instr_pre(0x49,this,[a,b]) as any as Op<I32> }
gt_s(a :Op<I32>, b :Op<I32>) { return new instr_pre(0x4a,this,[a,b]) as any as Op<I32> }
gt_u(a :Op<I32>, b :Op<I32>) { return new instr_pre(0x4b,this,[a,b]) as any as Op<I32> }
le_s(a :Op<I32>, b :Op<I32>) { return new instr_pre(0x4c,this,[a,b]) as any as Op<I32> }
le_u(a :Op<I32>, b :Op<I32>) { return new instr_pre(0x4d,this,[a,b]) as any as Op<I32> }
ge_s(a :Op<I32>, b :Op<I32>) { return new instr_pre(0x4e,this,[a,b]) as any as Op<I32> }
ge_u(a :Op<I32>, b :Op<I32>) { return new instr_pre(0x4f,this,[a,b]) as any as Op<I32> }
// Numeric
clz (a :Op<I32>) { return new instr_pre1(0x67,this,a) as any as Op<I32> }
ctz (a :Op<I32>) { return new instr_pre1(0x68,this,a) as any as Op<I32> }
popcnt(a :Op<I32>) { return new instr_pre1(0x69,this,a) as any as Op<I32> }
add (a :Op<I32>, b :Op<I32>) { return new instr_pre(0x6a,this,[a,b]) as any as Op<I32> }
sub (a :Op<I32>, b :Op<I32>) { return new instr_pre(0x6b,this,[a,b]) as any as Op<I32> }
mul (a :Op<I32>, b :Op<I32>) { return new instr_pre(0x6c,this,[a,b]) as any as Op<I32> }
div_s (a :Op<I32>, b :Op<I32>) { return new instr_pre(0x6d,this,[a,b]) as any as Op<I32> }
div_u (a :Op<I32>, b :Op<I32>) { return new instr_pre(0x6e,this,[a,b]) as any as Op<I32> }
rem_s (a :Op<I32>, b :Op<I32>) { return new instr_pre(0x6f,this,[a,b]) as any as Op<I32> }
rem_u (a :Op<I32>, b :Op<I32>) { return new instr_pre(0x70,this,[a,b]) as any as Op<I32> }
and (a :Op<I32>, b :Op<I32>) { return new instr_pre(0x71,this,[a,b]) as any as Op<I32> }
or (a :Op<I32>, b :Op<I32>) { return new instr_pre(0x72,this,[a,b]) as any as Op<I32> }
xor (a :Op<I32>, b :Op<I32>) { return new instr_pre(0x73,this,[a,b]) as any as Op<I32> }
shl (a :Op<I32>, b :Op<I32>) { return new instr_pre(0x74,this,[a,b]) as any as Op<I32> }
shr_s (a :Op<I32>, b :Op<I32>) { return new instr_pre(0x75,this,[a,b]) as any as Op<I32> }
shr_u (a :Op<I32>, b :Op<I32>) { return new instr_pre(0x76,this,[a,b]) as any as Op<I32> }
rotl (a :Op<I32>, b :Op<I32>) { return new instr_pre(0x77,this,[a,b]) as any as Op<I32> }
rotr (a :Op<I32>, b :Op<I32>) { return new instr_pre(0x78,this,[a,b]) as any as Op<I32> }
// Conversion
wrap_i64 (a :Op<I64>) { return new instr_pre1(0xa7,this,a) as any as Op<I32> }
trunc_s_f32 (a :Op<F32>) { return new instr_pre1(0xa8,this,a) as any as Op<I32> }
trunc_u_f32 (a :Op<F32>) { return new instr_pre1(0xa9,this,a) as any as Op<I32> }
trunc_s_f64 (a :Op<F64>) { return new instr_pre1(0xaa,this,a) as any as Op<I32> }
trunc_u_f64 (a :Op<F64>) { return new instr_pre1(0xab,this,a) as any as Op<I32> }
reinterpret_f32 (a :Op<F32>) { return new instr_pre1(0xbc,this,a) as any as Op<I32> }
}
class i64ops extends type_atom implements I64ops { readonly _I64: undefined
// Constants
constv(v :VarInt64) { return new instr_imm1(0x42, this, v) as any as Op<I64> }
const(v :int64) :Op<I64> { return this.constv(varint64(v)) }
// Memory
load(mi :MemImm, addr :Op<Int>) { return memload(0x29, this, mi, addr) }
load8_s(mi :MemImm, addr :Op<Int>) { return memload(0x30, this, mi, addr) }
load8_u(mi :MemImm, addr :Op<Int>) { return memload(0x31, this, mi, addr) }
load16_s(mi :MemImm, addr :Op<Int>) { return memload(0x32, this, mi, addr) }
load16_u(mi :MemImm, addr :Op<Int>) { return memload(0x33, this, mi, addr) }
load32_s(mi :MemImm, addr :Op<Int>) { return memload(0x34, this, mi, addr) }
load32_u(mi :MemImm, addr :Op<Int>) { return memload(0x35, this, mi, addr) }
store(mi :MemImm, addr :Op<Int>, v :Op<I64>) { return memstore(0x37, mi, addr, v) }
store8 (mi :MemImm, addr :Op<Int>, v :Op<I64>) { return memstore(0x3c, mi, addr, v) }
store16(mi :MemImm, addr :Op<Int>, v :Op<I64>) { return memstore(0x3d, mi, addr, v) }
store32(mi :MemImm, addr :Op<Int>, v :Op<I64>) { return memstore(0x3e, mi, addr, v) }
addrIsAligned(mi :MemImm, addr :number) { return addrIsAligned(3, mi[0].v, mi[1].v, addr) }
// Comparison
eqz (a :Op<I64>) { return new instr_pre1(0x50,this,a) as any as Op<I32> }
eq (a :Op<I64>, b :Op<I64>) { return new instr_pre(0x51,this,[a,b]) as any as Op<I32> }
ne (a :Op<I64>, b :Op<I64>) { return new instr_pre(0x52,this,[a,b]) as any as Op<I32> }
lt_s(a :Op<I64>, b :Op<I64>) { return new instr_pre(0x53,this,[a,b]) as any as Op<I32> }
lt_u(a :Op<I64>, b :Op<I64>) { return new instr_pre(0x54,this,[a,b]) as any as Op<I32> }
gt_s(a :Op<I64>, b :Op<I64>) { return new instr_pre(0x55,this,[a,b]) as any as Op<I32> }
gt_u(a :Op<I64>, b :Op<I64>) { return new instr_pre(0x56,this,[a,b]) as any as Op<I32> }
le_s(a :Op<I64>, b :Op<I64>) { return new instr_pre(0x57,this,[a,b]) as any as Op<I32> }
le_u(a :Op<I64>, b :Op<I64>) { return new instr_pre(0x58,this,[a,b]) as any as Op<I32> }
ge_s(a :Op<I64>, b :Op<I64>) { return new instr_pre(0x59,this,[a,b]) as any as Op<I32> }
ge_u(a :Op<I64>, b :Op<I64>) { return new instr_pre(0x5a,this,[a,b]) as any as Op<I32> }
// Numeric
clz (a :Op<I64>) { return new instr_pre1(0x79,this,a) as any as Op<I64> }
ctz (a :Op<I64>) { return new instr_pre1(0x7a,this,a) as any as Op<I64> }
popcnt(a :Op<I64>) { return new instr_pre1(0x7b,this,a) as any as Op<I64> }
add (a :Op<I64>, b :Op<I64>) { return new instr_pre(0x7c,this,[a,b]) as any as Op<I64> }
sub (a :Op<I64>, b :Op<I64>) { return new instr_pre(0x7d,this,[a,b]) as any as Op<I64> }
mul (a :Op<I64>, b :Op<I64>) { return new instr_pre(0x7e,this,[a,b]) as any as Op<I64> }
div_s (a :Op<I64>, b :Op<I64>) { return new instr_pre(0x7f,this,[a,b]) as any as Op<I64> }
div_u (a :Op<I64>, b :Op<I64>) { return new instr_pre(0x80,this,[a,b]) as any as Op<I64> }
rem_s (a :Op<I64>, b :Op<I64>) { return new instr_pre(0x81,this,[a,b]) as any as Op<I64> }
rem_u (a :Op<I64>, b :Op<I64>) { return new instr_pre(0x82,this,[a,b]) as any as Op<I64> }
and (a :Op<I64>, b :Op<I64>) { return new instr_pre(0x83,this,[a,b]) as any as Op<I64> }
or (a :Op<I64>, b :Op<I64>) { return new instr_pre(0x84,this,[a,b]) as any as Op<I64> }
xor (a :Op<I64>, b :Op<I64>) { return new instr_pre(0x85,this,[a,b]) as any as Op<I64> }
shl (a :Op<I64>, b :Op<I64>) { return new instr_pre(0x86,this,[a,b]) as any as Op<I64> }
shr_s (a :Op<I64>, b :Op<I64>) { return new instr_pre(0x87,this,[a,b]) as any as Op<I64> }
shr_u (a :Op<I64>, b :Op<I64>) { return new instr_pre(0x88,this,[a,b]) as any as Op<I64> }
rotl (a :Op<I64>, b :Op<I64>) { return new instr_pre(0x89,this,[a,b]) as any as Op<I64> }
rotr (a :Op<I64>, b :Op<I64>) { return new instr_pre(0x8a,this,[a,b]) as any as Op<I64> }
// Conversions
extend_s_i32 (a :Op<I32>) { return new instr_pre1(0xac,this,a) as any as Op<I64> }
extend_u_i32 (a :Op<I32>) { return new instr_pre1(0xad,this,a) as any as Op<I64> }
trunc_s_f32 (a :Op<F32>) { return new instr_pre1(0xae,this,a) as any as Op<I64> }
trunc_u_f32 (a :Op<F32>) { return new instr_pre1(0xaf,this,a) as any as Op<I64> }
trunc_s_f64 (a :Op<F64>) { return new instr_pre1(0xb0,this,a) as any as Op<I64> }
trunc_u_f64 (a :Op<F64>) { return new instr_pre1(0xb1,this,a) as any as Op<I64> }
reinterpret_f64 (a :Op<F64>) { return new instr_pre1(0xbd,this,a) as any as Op<I64> }
}
class f32ops extends type_atom implements F32ops { readonly _F32: undefined;
// Constants
constv(v :Float32) { return new instr_imm1(0x43, this, v) as any as Op<F32> }
const(v :float32) :Op<F32> { return this.constv(float32(v)) }
// Memory
load(mi :MemImm, addr :Op<Int>) { return memload(0x2a, this, mi, addr) }
store(mi :MemImm, addr :Op<Int>, v :Op<F32>) { return memstore(0x38, mi, addr, v) }
addrIsAligned(mi :MemImm, addr :number) { return addrIsAligned(2, mi[0].v, mi[1].v, addr) }
// Comparison
eq(a :Op<F32>, b :Op<F32>) { return new instr_pre(0x5b,this,[a,b]) as any as Op<I32> }
ne(a :Op<F32>, b :Op<F32>) { return new instr_pre(0x5c,this,[a,b]) as any as Op<I32> }
lt(a :Op<F32>, b :Op<F32>) { return new instr_pre(0x5d,this,[a,b]) as any as Op<I32> }
gt(a :Op<F32>, b :Op<F32>) { return new instr_pre(0x5e,this,[a,b]) as any as Op<I32> }
le(a :Op<F32>, b :Op<F32>) { return new instr_pre(0x5f,this,[a,b]) as any as Op<I32> }
ge(a :Op<F32>, b :Op<F32>) { return new instr_pre(0x60,this,[a,b]) as any as Op<I32> }
// Numeric
abs (a :Op<F32>) { return new instr_pre1(0x8b,this,a) as any as Op<F32> }
neg (a :Op<F32>) { return new instr_pre1(0x8c,this,a) as any as Op<F32> }
ceil (a :Op<F32>) { return new instr_pre1(0x8d,this,a) as any as Op<F32> }
floor (a :Op<F32>) { return new instr_pre1(0x8e,this,a) as any as Op<F32> }
trunc (a :Op<F32>) { return new instr_pre1(0x8f,this,a) as any as Op<F32> }
nearest (a :Op<F32>) { return new instr_pre1(0x90,this,a) as any as Op<F32> }
sqrt (a :Op<F32>) { return new instr_pre1(0x91,this,a) as any as Op<F32> }
add (a :Op<F32>, b :Op<F32>) { return new instr_pre(0x92,this,[a,b]) as any as Op<F32> }
sub (a :Op<F32>, b :Op<F32>) { return new instr_pre(0x93,this,[a,b]) as any as Op<F32> }
mul (a :Op<F32>, b :Op<F32>) { return new instr_pre(0x94,this,[a,b]) as any as Op<F32> }
div (a :Op<F32>, b :Op<F32>) { return new instr_pre(0x95,this,[a,b]) as any as Op<F32> }
min (a :Op<F32>, b :Op<F32>) { return new instr_pre(0x96,this,[a,b]) as any as Op<F32> }
max (a :Op<F32>, b :Op<F32>) { return new instr_pre(0x97,this,[a,b]) as any as Op<F32> }
copysign(a :Op<F32>, b :Op<F32>) { return new instr_pre(0x98,this,[a,b]) as any as Op<F32> }
// Conversion
convert_s_i32 (a :Op<I32>) { return new instr_pre1(0xb2,this,a) as any as Op<F32> }
convert_u_i32 (a :Op<I32>) { return new instr_pre1(0xb3,this,a) as any as Op<F32> }
convert_s_i64 (a :Op<I64>) { return new instr_pre1(0xb4,this,a) as any as Op<F32> }
convert_u_i64 (a :Op<I64>) { return new instr_pre1(0xb5,this,a) as any as Op<F32> }
demote_f64 (a :Op<F64>) { return new instr_pre1(0xb6,this,a) as any as Op<F32> }
reinterpret_i32(a :Op<I32>) { return new instr_pre1(0xbe,this,a) as any as Op<F32> }
}
class f64ops extends type_atom implements F64ops { readonly _F64: undefined;
// Constants
constv(v :Float64) { return new instr_imm1(0x44, this, v) as any as Op<F64> }
const(v :float64) :Op<F64> { return this.constv(float64(v)) }
// Memory
load(mi :MemImm, addr :Op<Int>) { return memload(0x2b, this, mi, addr) }
store(mi :MemImm, addr :Op<Int>, v :Op<F64>) { return memstore(0x39, mi, addr, v) }
addrIsAligned(mi :MemImm, addr :number) { return addrIsAligned(3, mi[0].v, mi[1].v, addr) }
// Comparison
eq(a :Op<F64>, b :Op<F64>) { return new instr_pre(0x61,this,[a,b]) as any as Op<I32> }
ne(a :Op<F64>, b :Op<F64>) { return new instr_pre(0x62,this,[a,b]) as any as Op<I32> }
lt(a :Op<F64>, b :Op<F64>) { return new instr_pre(0x63,this,[a,b]) as any as Op<I32> }
gt(a :Op<F64>, b :Op<F64>) { return new instr_pre(0x64,this,[a,b]) as any as Op<I32> }
le(a :Op<F64>, b :Op<F64>) { return new instr_pre(0x65,this,[a,b]) as any as Op<I32> }
ge(a :Op<F64>, b :Op<F64>) { return new instr_pre(0x66,this,[a,b]) as any as Op<I32> }
// Numeric
abs (a :Op<F64>) { return new instr_pre1(0x99,this,a) as any as Op<F64> }
neg (a :Op<F64>) { return new instr_pre1(0x9a,this,a) as any as Op<F64> }
ceil (a :Op<F64>) { return new instr_pre1(0x9b,this,a) as any as Op<F64> }
floor (a :Op<F64>) { return new instr_pre1(0x9c,this,a) as any as Op<F64> }
trunc (a :Op<F64>) { return new instr_pre1(0x9d,this,a) as any as Op<F64> }
nearest (a :Op<F64>) { return new instr_pre1(0x9e,this,a) as any as Op<F64> }
sqrt (a :Op<F64>) { return new instr_pre1(0x9f,this,a) as any as Op<F64> }
add (a :Op<F64>, b :Op<F64>) { return new instr_pre(0xa0,this,[a,b]) as any as Op<F64> }
sub (a :Op<F64>, b :Op<F64>) { return new instr_pre(0xa1,this,[a,b]) as any as Op<F64> }
mul (a :Op<F64>, b :Op<F64>) { return new instr_pre(0xa2,this,[a,b]) as any as Op<F64> }
div (a :Op<F64>, b :Op<F64>) { return new instr_pre(0xa3,this,[a,b]) as any as Op<F64> }
min (a :Op<F64>, b :Op<F64>) { return new instr_pre(0xa4,this,[a,b]) as any as Op<F64> }
max (a :Op<F64>, b :Op<F64>) { return new instr_pre(0xa5,this,[a,b]) as any as Op<F64> }
copysign(a :Op<F64>, b :Op<F64>) { return new instr_pre(0xa6,this,[a,b]) as any as Op<F64> }
// Conversions
convert_s_i32 (a :Op<I32>) { return new instr_pre1(0xb7,this,a) as any as Op<F64> }
convert_u_i32 (a :Op<I32>) { return new instr_pre1(0xb8,this,a) as any as Op<F64> }
convert_s_i64 (a :Op<I64>) { return new instr_pre1(0xb9,this,a) as any as Op<F64> }
convert_u_i64 (a :Op<I64>) { return new instr_pre1(0xba,this,a) as any as Op<F64> }
promote_f32 (a :Op<F32>) { return new instr_pre1(0xbb,this,a) as any as Op<F64> }
reinterpret_i64(a :Op<I64>) { return new instr_pre1(0xbf,this,a) as any as Op<F64> }
}
const magic = uint32(0x6d736100)
const latestVersion = uint32(0x1)
const end = new instr_atom(0x0b, Void) as any as Op<Void>
const elseOp = new instr_atom(0x05, Void) as any as Op<Void>
function if_<R extends AnyResult>(r :R, cond :Op<I32>, then_ :AnyOp[], else_? :AnyOp[]) {
assert(r === then_[then_.length-1].r)
assert(!else_ || else_.length == 0 || r === else_[else_.length-1].r)
return new instr_pre_imm_post(0x04, r,
[cond], // pre
[r], // imm
// post:
else_ ? [...then_, elseOp, ...else_, end] :
[...then_, end]
) as any as Op<R>
}
const return_ = <R extends Result>(value :Op<R>) =>
new instr_pre1(0x0f, value.r, value) as any as Op<R>
export const t = T
export const c = {
uint8,
uint32,
float32,
float64,
varuint1,
varuint7,
varuint32,
varint7,
varint32,
varint64,
any_func: AnyFunc,
func: Func,
empty_block: EmptyBlock,
void: Void, void_: Void,
external_kind: {
function: external_kind_function, // Function import or definition
table: external_kind_table, // Table import or definition
memory: external_kind_memory, // Memory import or definition
global: external_kind_global, // Global import or definition
},
data(buf: ArrayLike<uint8>) {
return new bytes_atom(T.data, buf) as any as Data
},
str,
str_ascii(text: string) {
const bytes :uint8[] = []
for (let i = 0, L = text.length; i != L; ++i) {
bytes[i] = 0xff & text.charCodeAt(i);
}
return str(bytes)
},
str_utf8: (text: string) =>
str(utf8.encode(text)),
// If you are targeting a pre-MVP version, provide the desired version number (e.g. `0xd`).
// If not provided or falsy, the latest stable version is used.
module(sections :Section[], version? :uint32) {
const v = version ? uint32(version) : latestVersion
return new cell<Section>(T.module,
[magic, v, ...sections] as Section[]) as any as Module
},
custom_section: (name :Str, payload :N[]) =>
section(sect_id_custom, name, payload) as any as CustomSection,
type_section: (types: FuncType[]) =>
section(sect_id_type, varuint32(types.length), types) as any as TypeSection,
import_section: (entries: ImportEntry[]) =>
section(sect_id_import, varuint32(entries.length), entries) as any as ImportSection,
function_section: (types: VarUint32[]) =>
section(sect_id_function, varuint32(types.length), types) as any as FunctionSection,
table_section: (types: TableType[]) =>
section(sect_id_table, varuint32(types.length), types) as any as TableSection,
memory_section: (limits: ResizableLimits[]) =>
section(sect_id_memory, varuint32(limits.length), limits) as any as MemorySection,
global_section: (globals: GlobalVariable[]) =>
section(sect_id_global, varuint32(globals.length), globals) as any as GlobalSection,
export_section: (exports: ExportEntry[]) =>
section(sect_id_export, varuint32(exports.length), exports) as any as ExportSection,
start_section: (funcIndex: VarUint32) =>
section(sect_id_start, funcIndex, []) as any as StartSection,
element_section: (entries: ElemSegment[]) =>
section(sect_id_element, varuint32(entries.length), entries) as any as ElementSection,
code_section: (bodies: FunctionBody[]) =>
section(sect_id_code, varuint32(bodies.length), bodies) as any as CodeSection,
data_section: (entries: DataSegment[]) =>
section(sect_id_data, varuint32(entries.length), entries) as any as DataSection,
function_import_entry: (module :Str, field :Str, typeIndex: VarUint32) =>
new cell<N>(T.import_entry, [
module, field, external_kind_function, typeIndex
]) as any as ImportEntry,
table_import_entry: (module :Str, field :Str, type: TableType) =>
new cell<N>(T.import_entry,
[module, field, external_kind_table, type]) as any as ImportEntry,
memory_import_entry: (module :Str, field :Str, limits: ResizableLimits) =>
new cell<N>(T.import_entry,
[module, field, external_kind_memory, limits]) as any as ImportEntry,
global_import_entry: (module :Str, field :Str, type: GlobalType) =>
new cell<N>(T.import_entry,
[module, field, external_kind_global, type]) as any as ImportEntry,
export_entry: (field :Str, kind :ExternalKind, index :VarUint32) =>
new cell<N>(T.export_entry, [field, kind, index]) as any as ExportEntry,
elem_segment: (index :VarUint32, offset :InitExpr, funcIndex :VarUint32[]) =>
new cell<N>(T.elem_segment, [
index, offset, varuint32(funcIndex.length), ...funcIndex
]) as any as ElemSegment,
data_segment: (index :VarUint32, offset :InitExpr, data :Data) =>
new cell<N>(T.data_segment, [index, offset, varuint32(data.z), data]) as any as DataSegment,
func_type(paramTypes :ValueType[], returnType? :ValueType|null) {
const paramLen = varuint32(paramTypes.length)
return new cell(T.func_type,
returnType ? [Func, paramLen, ...paramTypes, varuint1_1, returnType]
: [Func, paramLen, ...paramTypes, varuint1_0]) as any as FuncType
},
table_type(type :ElemType, limits :ResizableLimits) {
assert(type.v == AnyFunc.v) // WASM MVP limitation
return new cell<N>(T.table_type, [type, limits]) as any as TableType
},
global_type: (contentType :ValueType, mutable? :boolean) =>
new cell<N>(T.global_type, [
contentType, mutable ? varuint1_1 : varuint1_0
]) as any as GlobalType,
// expressed in number of memory pages (not bytes; pagesize=64KiB)
resizable_limits: (initial :VarUint32, maximum? :VarUint32) =>
new cell<N>(T.resizable_limits, maximum ?
[varuint1_1, initial, maximum] : [varuint1_0, initial]
) as any as ResizableLimits,
global_variable: (type :GlobalType, init :InitExpr) =>
new cell<N>(T.global_variable, [type, init]) as any as GlobalVariable,
init_expr: (expr :N[]) =>
new cell<N>(T.init_expr, [...expr, end]) as any as InitExpr,
function_body(locals :LocalEntry[], code :N[]) {
const localCount = varuint32(locals.length)
return new cell<N>(T.function_body, [
varuint32(localCount.z + sumz(locals) + sumz(code) + 1), // body_size
localCount, ...locals, ...code, end
]) as any as FunctionBody
},
local_entry: (count :VarUint32, type :ValueType) =>
new cell<N>(T.local_entry, [count, type]) as any as LocalEntry,
// Semantics of the WebAssembly stack machine:
// - Control instructions pop their argument value(s) off the stack, may change
// the program counter, and push result value(s) onto the stack.
// - Simple instructions pop their argument value(s) from the stack, apply an
// operator to the values, and then push the result value(s) onto the stack,
// followed by an implicit advancement of the program counter.
unreachable: new instr_atom(0x00, Void) as any as Op<Void>,
nop: new instr_atom(0x01, Void) as any as Op<Void>,
// begin a block which can also form CF loops
block<R extends AnyResult>(r :R, body :AnyOp[]) {
assert(r === body[body.length-1].r)
return new instr_imm1_post(0x02, r, r as N, [...body, end]) as any as Op<R>
},
void_block(body :AnyOp[]) {
assert(body.length == 0 || Void === body[body.length-1].r)
return new instr_imm1_post(0x02, Void, EmptyBlock, [...body, end]) as any as Op<Void>
},
// begin a block which can also form CF loops
loop<R extends AnyResult>(r :R, body :AnyOp[]) {
assert(r === body[body.length-1].r)
return new instr_imm1_post(0x03, r, r as N, [...body, end]) as any as Op<R>
},
void_loop(body :AnyOp[]) {
assert(body.length == 0 || Void === body[body.length-1].r)
return new instr_imm1_post(0x03, Void, EmptyBlock, [...body, end]) as any as Op<Void>
},
if: if_, if_,
end: end,
// Branch to a given label (relative depth) in an enclosing construct.
// Note:
// - "branching" to a block correspond to a "break" statement
// - "branching" to a loop correspond to a "continue" statement
br: (relDepth :uint32) =>
new instr_imm1(0x0c, Void, varuint32(relDepth)) as any as Op<Void>,
// Conditionall branch to a given label in an enclosing construct.
// When condition is false, this is equivalent to a "Nop" operation.
// When condition is true, this is equivalent to a "Br" operation.
br_if: (relDepth :uint32, cond :Op<I32>) =>
new instr_pre_imm(0x0d, Void, [cond], [varuint32(relDepth)]) as any as Op<Void>,
// Jump table which jumps to a label in an enclosing construct.
// A br_table consists of a zero-based array of labels, a default label,
// and an index operand. A br_table jumps to the label indexed in the
// array or the default label if the index is out of bounds.
br_table: (targetLabels :VarUint32[], defaultLabel :VarUint32, index :AnyOp) =>
new instr_pre_imm(0x0e, Void,
[index],
[varuint32(targetLabels.length), ...targetLabels, defaultLabel]
) as any as Op<Void>,
// return zero or one value from this function
return: return_, return_,
return_void: new instr_atom(0x0f, Void) as Op<Void>,
// Calling
call<R extends Result>(r :R, funcIndex: VarUint32, args :AnyOp[]) {
return new instr_pre_imm(0x10, r, args, [funcIndex]) as any as Op<R>
},
call_indirect<R extends Result>(r :R, funcIndex: VarUint32, args :AnyOp[]) {
return new instr_pre_imm(0x11, r, args, [funcIndex, varuint1_0]) as any as Op<R>
},
// drop discards the value of its operand
// R should be the value on the stack "under" the operand. E.g. with a stack:
// I32 top
// F64 ...
// F32 bottom
// drop
// F64 top
// F32 bottom
// i.e. R=F64
drop<R extends AnyResult>(r :R, n :Op<Result>) {
return new instr_pre1(0x1a, r, n) as any as Op<R>
},
// select one of two values based on condition
select<R extends Result>(cond :Op<I32>, trueRes :Op<R>, falseRes :Op<R>) {
assert(trueRes.r === falseRes.r)
return new instr_pre(0x1b, trueRes.r, [trueRes, falseRes, cond]) as any as Op<R>
},
// Variable access
get_local<R extends Result>(r :R, localIndex :uint32) {
return new instr_imm1(0x20, r, varuint32(localIndex)) as any as Op<R>
},
set_local(localIndex :uint32, expr :Op<Result>) {
return new instr_pre_imm(0x21, Void, [expr], [varuint32(localIndex)]) as any as Op<Void>
},
tee_local<R extends Result>(localIndex :uint32, expr :Op<R>) {
return new instr_pre_imm(0x22, expr.r, [expr], [varuint32(localIndex)]) as any as Op<R>
},
get_global<R extends Result>(r :R, globalIndex :uint32) {
return new instr_imm1(0x23, r, varuint32(globalIndex)) as any as Op<R>
},
set_global(globalIndex :uint32, expr :Op<Result>) {
return new instr_pre_imm(0x24, Void, [expr], [varuint32(globalIndex)]) as any as Op<Void>
},
// Memory
current_memory() { // query the size of memory (number of pages)
return new instr_imm1(0x3f, c.i32, varuint1_0) as any as Op<Int>
},
// Grow the size of memory by `delta` memory pages.
// Returns the previous memory size in units of pages or -1 on failure.
grow_memory(delta :Op<Int>) {
assert(delta.v >= 0)
return new instr_pre_imm(0x40, c.i32, [delta], [varuint1_0]) as any as Op<Int>
},
// MemImm: Alignment Offset
align8: [ varUint32Cache[0], varUint32Cache[0] ] as [VarUint32,Int],
align16: [ varUint32Cache[1], varUint32Cache[0] ] as [VarUint32,Int],
align32: [ varUint32Cache[2], varUint32Cache[0] ] as [VarUint32,Int],
align64: [ varUint32Cache[3], varUint32Cache[0] ] as [VarUint32,Int],
i32: new i32ops(-0x01, 0x7f) as I32ops,
i64: new i64ops(-0x02, 0x7e) as I64ops,
f32: new f32ops(-0x03, 0x7d) as F32ops,
f64: new f64ops(-0x04, 0x7c) as F64ops,
}
export interface FunctionBodyInfo {
index :number // module function index
locals :N[]
code :AnyOp[]
}
// access helpers
export const get = {
sections(m :Module) :Section[] {
return m.v.slice(2) // 0=magic, 1=version, 2...=Section[]
},
section(m :Module, id :VarUint7|uint7) :Section {
let ido = (typeof id != 'object') ? varuint7(id as uint7) : (id as VarUint7)
for (let i = 2; i < m.v.length; ++i) {
let section = m.v[i]
if (section.v[0] === ido) {
return section
}
}
},
function_bodies(s :CodeSection) :Iterable<FunctionBodyInfo> {
return {
[Symbol.iterator](startIndex? :number) {
let index = 3 + (startIndex || 0)
return {
next() {
const funcBody = s.v[index]
if (!funcBody) {
return {done: true, value: null}
}
let localCount = funcBody.v[1]
return {
done: false,
value: {
index: index++,
locals: funcBody.v.slice(2, localCount.v + 2),
code: funcBody.v.slice(2 + localCount.v, funcBody.v.length - 1) as AnyOp[]
// -1 to skip terminating `end`
}
}
}
}
}
}
},
}