@grain/libbinaryen
Version:
Libbinaryen packaged for OCaml.
1,362 lines (1,336 loc) • 195 kB
JavaScript
#preprocess
// export friendly API methods
function preserveStack(func) {
try {
var stack = stackSave();
return func();
} finally {
stackRestore(stack);
}
}
function strToStack(str) {
return str ? stringToUTF8OnStack(str) : 0;
}
function i32sToStack(i32s) {
const ret = stackAlloc(i32s.length << 2);
HEAP32.set(i32s, ret >>> 2);
return ret;
}
function i8sToStack(i8s) {
const ret = stackAlloc(i8s.length);
HEAP8.set(i8s, ret);
return ret;
}
function initializeConstants() {
// Types
[ ['none', 'None'],
['i32', 'Int32'],
['i64', 'Int64'],
['f32', 'Float32'],
['f64', 'Float64'],
['v128', 'Vec128'],
['funcref', 'Funcref'],
['externref', 'Externref'],
['anyref', 'Anyref'],
['eqref', 'Eqref'],
['i31ref', 'I31ref'],
['structref', 'Structref'],
['arrayref', 'Arrayref'],
['stringref', 'Stringref'],
['nullref', 'Nullref'],
['nullexternref', 'NullExternref'],
['nullfuncref', 'NullFuncref'],
['unreachable', 'Unreachable'],
['auto', 'Auto']
].forEach(entry => {
Module[entry[0]] = Module['_BinaryenType' + entry[1]]();
});
[ ['notPacked', 'NotPacked'],
['i8', 'Int8'],
['i16', 'Int16']
].forEach(entry => {
Module[entry[0]] = Module['_BinaryenPackedType' + entry[1]]();
});
// Expression ids
Module['ExpressionIds'] = {};
[ 'Invalid',
'Block',
'If',
'Loop',
'Break',
'Switch',
'Call',
'CallIndirect',
'LocalGet',
'LocalSet',
'GlobalGet',
'GlobalSet',
'Load',
'Store',
'Const',
'Unary',
'Binary',
'Select',
'Drop',
'Return',
'MemorySize',
'MemoryGrow',
'Nop',
'Unreachable',
'AtomicCmpxchg',
'AtomicRMW',
'AtomicWait',
'AtomicNotify',
'AtomicFence',
'SIMDExtract',
'SIMDReplace',
'SIMDShuffle',
'SIMDTernary',
'SIMDShift',
'SIMDLoad',
'SIMDLoadStoreLane',
'MemoryInit',
'DataDrop',
'MemoryCopy',
'MemoryFill',
'RefNull',
'RefIsNull',
'RefFunc',
'RefEq',
'TableGet',
'TableSet',
'TableSize',
'TableGrow',
'Try',
'Throw',
'Rethrow',
'TupleMake',
'TupleExtract',
'Pop',
'RefI31',
'I31Get',
'CallRef',
'RefTest',
'RefCast',
'BrOn',
'StructNew',
'StructGet',
'StructSet',
'ArrayNew',
'ArrayNewFixed',
'ArrayNewData',
'ArrayNewElem',
'ArrayGet',
'ArraySet',
'ArrayLen',
'ArrayFill',
'ArrayCopy',
'ArrayInitData',
'ArrayInitElem',
'RefAs',
'StringNew',
'StringConst',
'StringMeasure',
'StringEncode',
'StringConcat',
'StringEq',
'StringWTF16Get',
'StringSliceWTF',
].forEach(name => {
Module['ExpressionIds'][name] = Module[name + 'Id'] = Module['_Binaryen' + name + 'Id']();
});
// External kinds
Module['ExternalKinds'] = {};
[ 'Function',
'Table',
'Memory',
'Global',
'Tag'
].forEach(name => {
Module['ExternalKinds'][name] = Module['External' + name] = Module['_BinaryenExternal' + name]();
});
// MemoryOrder for atomic operations
Module['MemoryOrder'] = {};
[ 'Unordered',
'SeqCst',
'AcqRel'
].forEach(name => {
Module['MemoryOrder'][name.toLowerCase()] = Module['_BinaryenMemoryOrder' + name]()
});
// Features
Module['Features'] = {};
[ 'MVP',
'Atomics',
'MutableGlobals',
'NontrappingFPToInt',
'SIMD128',
'BulkMemory',
'SignExt',
'ExceptionHandling',
'TailCall',
'ReferenceTypes',
'Multivalue',
'GC',
'Memory64',
'RelaxedSIMD',
'ExtendedConst',
'Strings',
'MultiMemory',
'StackSwitching',
'SharedEverything',
'FP16',
'BulkMemoryOpt',
'CallIndirectOverlong',
'RelaxedAtomics',
'CustomPageSizes',
'All'
].forEach(name => {
Module['Features'][name] = Module['_BinaryenFeature' + name]();
});
// Operations
Module['Operations'] = {};
[ 'ClzInt32',
'CtzInt32',
'PopcntInt32',
'NegFloat32',
'AbsFloat32',
'CeilFloat32',
'FloorFloat32',
'TruncFloat32',
'NearestFloat32',
'SqrtFloat32',
'EqZInt32',
'ClzInt64',
'CtzInt64',
'PopcntInt64',
'NegFloat64',
'AbsFloat64',
'CeilFloat64',
'FloorFloat64',
'TruncFloat64',
'NearestFloat64',
'SqrtFloat64',
'EqZInt64',
'ExtendSInt32',
'ExtendUInt32',
'WrapInt64',
'TruncSFloat32ToInt32',
'TruncSFloat32ToInt64',
'TruncUFloat32ToInt32',
'TruncUFloat32ToInt64',
'TruncSFloat64ToInt32',
'TruncSFloat64ToInt64',
'TruncUFloat64ToInt32',
'TruncUFloat64ToInt64',
'TruncSatSFloat32ToInt32',
'TruncSatSFloat32ToInt64',
'TruncSatUFloat32ToInt32',
'TruncSatUFloat32ToInt64',
'TruncSatSFloat64ToInt32',
'TruncSatSFloat64ToInt64',
'TruncSatUFloat64ToInt32',
'TruncSatUFloat64ToInt64',
'ReinterpretFloat32',
'ReinterpretFloat64',
'ConvertSInt32ToFloat32',
'ConvertSInt32ToFloat64',
'ConvertUInt32ToFloat32',
'ConvertUInt32ToFloat64',
'ConvertSInt64ToFloat32',
'ConvertSInt64ToFloat64',
'ConvertUInt64ToFloat32',
'ConvertUInt64ToFloat64',
'PromoteFloat32',
'DemoteFloat64',
'ReinterpretInt32',
'ReinterpretInt64',
'ExtendS8Int32',
'ExtendS16Int32',
'ExtendS8Int64',
'ExtendS16Int64',
'ExtendS32Int64',
'AddInt32',
'SubInt32',
'MulInt32',
'DivSInt32',
'DivUInt32',
'RemSInt32',
'RemUInt32',
'AndInt32',
'OrInt32',
'XorInt32',
'ShlInt32',
'ShrUInt32',
'ShrSInt32',
'RotLInt32',
'RotRInt32',
'EqInt32',
'NeInt32',
'LtSInt32',
'LtUInt32',
'LeSInt32',
'LeUInt32',
'GtSInt32',
'GtUInt32',
'GeSInt32',
'GeUInt32',
'AddInt64',
'SubInt64',
'MulInt64',
'DivSInt64',
'DivUInt64',
'RemSInt64',
'RemUInt64',
'AndInt64',
'OrInt64',
'XorInt64',
'ShlInt64',
'ShrUInt64',
'ShrSInt64',
'RotLInt64',
'RotRInt64',
'EqInt64',
'NeInt64',
'LtSInt64',
'LtUInt64',
'LeSInt64',
'LeUInt64',
'GtSInt64',
'GtUInt64',
'GeSInt64',
'GeUInt64',
'AddFloat32',
'SubFloat32',
'MulFloat32',
'DivFloat32',
'CopySignFloat32',
'MinFloat32',
'MaxFloat32',
'EqFloat32',
'NeFloat32',
'LtFloat32',
'LeFloat32',
'GtFloat32',
'GeFloat32',
'AddFloat64',
'SubFloat64',
'MulFloat64',
'DivFloat64',
'CopySignFloat64',
'MinFloat64',
'MaxFloat64',
'EqFloat64',
'NeFloat64',
'LtFloat64',
'LeFloat64',
'GtFloat64',
'GeFloat64',
'AtomicRMWAdd',
'AtomicRMWSub',
'AtomicRMWAnd',
'AtomicRMWOr',
'AtomicRMWXor',
'AtomicRMWXchg',
'SplatVecI8x16',
'ExtractLaneSVecI8x16',
'ExtractLaneUVecI8x16',
'ReplaceLaneVecI8x16',
'SplatVecI16x8',
'ExtractLaneSVecI16x8',
'ExtractLaneUVecI16x8',
'ReplaceLaneVecI16x8',
'SplatVecI32x4',
'ExtractLaneVecI32x4',
'ReplaceLaneVecI32x4',
'SplatVecI64x2',
'ExtractLaneVecI64x2',
'ReplaceLaneVecI64x2',
'SplatVecF32x4',
'ExtractLaneVecF32x4',
'ReplaceLaneVecF32x4',
'SplatVecF64x2',
'ExtractLaneVecF64x2',
'ReplaceLaneVecF64x2',
'EqVecI8x16',
'NeVecI8x16',
'LtSVecI8x16',
'LtUVecI8x16',
'GtSVecI8x16',
'GtUVecI8x16',
'LeSVecI8x16',
'LeUVecI8x16',
'GeSVecI8x16',
'GeUVecI8x16',
'EqVecI16x8',
'NeVecI16x8',
'LtSVecI16x8',
'LtUVecI16x8',
'GtSVecI16x8',
'GtUVecI16x8',
'LeSVecI16x8',
'LeUVecI16x8',
'GeSVecI16x8',
'GeUVecI16x8',
'EqVecI32x4',
'NeVecI32x4',
'LtSVecI32x4',
'LtUVecI32x4',
'GtSVecI32x4',
'GtUVecI32x4',
'LeSVecI32x4',
'LeUVecI32x4',
'GeSVecI32x4',
'GeUVecI32x4',
'EqVecI64x2',
'NeVecI64x2',
'LtSVecI64x2',
'GtSVecI64x2',
'LeSVecI64x2',
'GeSVecI64x2',
'EqVecF32x4',
'NeVecF32x4',
'LtVecF32x4',
'GtVecF32x4',
'LeVecF32x4',
'GeVecF32x4',
'EqVecF64x2',
'NeVecF64x2',
'LtVecF64x2',
'GtVecF64x2',
'LeVecF64x2',
'GeVecF64x2',
'NotVec128',
'AndVec128',
'OrVec128',
'XorVec128',
'AndNotVec128',
'BitselectVec128',
'RelaxedMaddVecF32x4',
'RelaxedNmaddVecF32x4',
'RelaxedMaddVecF64x2',
'RelaxedNmaddVecF64x2',
'LaneselectI8x16',
'LaneselectI16x8',
'LaneselectI32x4',
'LaneselectI64x2',
'DotI8x16I7x16AddSToVecI32x4',
'AnyTrueVec128',
'PopcntVecI8x16',
'AbsVecI8x16',
'NegVecI8x16',
'AllTrueVecI8x16',
'BitmaskVecI8x16',
'ShlVecI8x16',
'ShrSVecI8x16',
'ShrUVecI8x16',
'AddVecI8x16',
'AddSatSVecI8x16',
'AddSatUVecI8x16',
'SubVecI8x16',
'SubSatSVecI8x16',
'SubSatUVecI8x16',
'MinSVecI8x16',
'MinUVecI8x16',
'MaxSVecI8x16',
'MaxUVecI8x16',
'AvgrUVecI8x16',
'AbsVecI16x8',
'NegVecI16x8',
'AllTrueVecI16x8',
'BitmaskVecI16x8',
'ShlVecI16x8',
'ShrSVecI16x8',
'ShrUVecI16x8',
'AddVecI16x8',
'AddSatSVecI16x8',
'AddSatUVecI16x8',
'SubVecI16x8',
'SubSatSVecI16x8',
'SubSatUVecI16x8',
'MulVecI16x8',
'MinSVecI16x8',
'MinUVecI16x8',
'MaxSVecI16x8',
'MaxUVecI16x8',
'AvgrUVecI16x8',
'Q15MulrSatSVecI16x8',
'ExtMulLowSVecI16x8',
'ExtMulHighSVecI16x8',
'ExtMulLowUVecI16x8',
'ExtMulHighUVecI16x8',
'DotSVecI16x8ToVecI32x4',
'ExtMulLowSVecI32x4',
'ExtMulHighSVecI32x4',
'ExtMulLowUVecI32x4',
'ExtMulHighUVecI32x4',
'AbsVecI32x4',
'NegVecI32x4',
'AllTrueVecI32x4',
'BitmaskVecI32x4',
'ShlVecI32x4',
'ShrSVecI32x4',
'ShrUVecI32x4',
'AddVecI32x4',
'SubVecI32x4',
'MulVecI32x4',
'MinSVecI32x4',
'MinUVecI32x4',
'MaxSVecI32x4',
'MaxUVecI32x4',
'AbsVecI64x2',
'NegVecI64x2',
'AllTrueVecI64x2',
'BitmaskVecI64x2',
'ShlVecI64x2',
'ShrSVecI64x2',
'ShrUVecI64x2',
'AddVecI64x2',
'SubVecI64x2',
'MulVecI64x2',
'ExtMulLowSVecI64x2',
'ExtMulHighSVecI64x2',
'ExtMulLowUVecI64x2',
'ExtMulHighUVecI64x2',
'AbsVecF32x4',
'NegVecF32x4',
'SqrtVecF32x4',
'AddVecF32x4',
'SubVecF32x4',
'MulVecF32x4',
'DivVecF32x4',
'MinVecF32x4',
'MaxVecF32x4',
'PMinVecF32x4',
'PMaxVecF32x4',
'CeilVecF32x4',
'FloorVecF32x4',
'TruncVecF32x4',
'NearestVecF32x4',
'AbsVecF64x2',
'NegVecF64x2',
'SqrtVecF64x2',
'AddVecF64x2',
'SubVecF64x2',
'MulVecF64x2',
'DivVecF64x2',
'MinVecF64x2',
'MaxVecF64x2',
'PMinVecF64x2',
'PMaxVecF64x2',
'CeilVecF64x2',
'FloorVecF64x2',
'TruncVecF64x2',
'NearestVecF64x2',
'ExtAddPairwiseSVecI8x16ToI16x8',
'ExtAddPairwiseUVecI8x16ToI16x8',
'ExtAddPairwiseSVecI16x8ToI32x4',
'ExtAddPairwiseUVecI16x8ToI32x4',
'TruncSatSVecF32x4ToVecI32x4',
'TruncSatUVecF32x4ToVecI32x4',
'ConvertSVecI32x4ToVecF32x4',
'ConvertUVecI32x4ToVecF32x4',
'Load8SplatVec128',
'Load16SplatVec128',
'Load32SplatVec128',
'Load64SplatVec128',
'Load8x8SVec128',
'Load8x8UVec128',
'Load16x4SVec128',
'Load16x4UVec128',
'Load32x2SVec128',
'Load32x2UVec128',
'Load32ZeroVec128',
'Load64ZeroVec128',
'Load8LaneVec128',
'Load16LaneVec128',
'Load32LaneVec128',
'Load64LaneVec128',
'Store8LaneVec128',
'Store16LaneVec128',
'Store32LaneVec128',
'Store64LaneVec128',
'NarrowSVecI16x8ToVecI8x16',
'NarrowUVecI16x8ToVecI8x16',
'NarrowSVecI32x4ToVecI16x8',
'NarrowUVecI32x4ToVecI16x8',
'ExtendLowSVecI8x16ToVecI16x8',
'ExtendHighSVecI8x16ToVecI16x8',
'ExtendLowUVecI8x16ToVecI16x8',
'ExtendHighUVecI8x16ToVecI16x8',
'ExtendLowSVecI16x8ToVecI32x4',
'ExtendHighSVecI16x8ToVecI32x4',
'ExtendLowUVecI16x8ToVecI32x4',
'ExtendHighUVecI16x8ToVecI32x4',
'ExtendLowSVecI32x4ToVecI64x2',
'ExtendHighSVecI32x4ToVecI64x2',
'ExtendLowUVecI32x4ToVecI64x2',
'ExtendHighUVecI32x4ToVecI64x2',
'ConvertLowSVecI32x4ToVecF64x2',
'ConvertLowUVecI32x4ToVecF64x2',
'TruncSatZeroSVecF64x2ToVecI32x4',
'TruncSatZeroUVecF64x2ToVecI32x4',
'DemoteZeroVecF64x2ToVecF32x4',
'PromoteLowVecF32x4ToVecF64x2',
'RelaxedTruncSVecF32x4ToVecI32x4',
'RelaxedTruncUVecF32x4ToVecI32x4',
'RelaxedTruncZeroSVecF64x2ToVecI32x4',
'RelaxedTruncZeroUVecF64x2ToVecI32x4',
'SwizzleVecI8x16',
'RelaxedSwizzleVecI8x16',
'RelaxedMinVecF32x4',
'RelaxedMaxVecF32x4',
'RelaxedMinVecF64x2',
'RelaxedMaxVecF64x2',
'RelaxedQ15MulrSVecI16x8',
'DotI8x16I7x16SToVecI16x8',
'RefAsNonNull',
'RefAsExternInternalize',
'RefAsExternExternalize',
'RefAsAnyConvertExtern',
'RefAsExternConvertAny',
'BrOnNull',
'BrOnNonNull',
'BrOnCast',
'BrOnCastFail',
'StringNewLossyUTF8Array',
'StringNewWTF16Array',
'StringNewFromCodePoint',
'StringMeasureUTF8',
'StringMeasureWTF16',
'StringEncodeLossyUTF8Array',
'StringEncodeWTF16Array',
'StringEqEqual',
'StringEqCompare'
].forEach(name => {
Module['Operations'][name] = Module[name] = Module['_Binaryen' + name]();
});
// Expression side effects
Module['SideEffects'] = {};
[ 'None',
'Branches',
'Calls',
'ReadsLocal',
'WritesLocal',
'ReadsGlobal',
'WritesGlobal',
'ReadsMemory',
'WritesMemory',
'ReadsTable',
'WritesTable',
'ImplicitTrap',
'IsAtomic',
'Throws',
'DanglingPop',
'TrapsNeverHappen',
'Any'
].forEach(name => {
Module['SideEffects'][name] = Module['_BinaryenSideEffect' + name]();
});
// ExpressionRunner flags
Module['ExpressionRunner']['Flags'] = {
'Default': Module['_ExpressionRunnerFlagsDefault'](),
'PreserveSideeffects': Module['_ExpressionRunnerFlagsPreserveSideeffects'](),
};
}
// 'Module' interface
Module['Module'] = function(module) {
assert(!module); // guard against incorrect old API usage
wrapModule(Module['_BinaryenModuleCreate'](), this);
};
// Receives a C pointer to a C Module and a JS object, and creates
// the JS wrappings on the object to access the C data.
// This is meant for internal use only, and is necessary as we
// want to access Module from JS that were perhaps not created
// from JS.
function wrapModule(module, self = {}) {
assert(module); // guard against incorrect old API usage
self['ptr'] = module;
// The size of a single literal in memory as used in Const creation,
// which is a little different: we don't want users to need to make
// their own Literals, as the C API handles them by value, which means
// we would leak them. Instead, Const creation is fused together with
// an intermediate stack allocation of this size to pass the value.
const sizeOfLiteral = _BinaryenSizeofLiteral();
// 'Expression' creation
self['block'] = function(name, children, type) {
return preserveStack(() =>
Module['_BinaryenBlock'](module, name ? strToStack(name) : 0,
i32sToStack(children), children.length,
typeof type !== 'undefined' ? type : Module['none'])
);
};
self['if'] = function(condition, ifTrue, ifFalse) {
return Module['_BinaryenIf'](module, condition, ifTrue, ifFalse);
};
self['loop'] = function(label, body) {
return preserveStack(() => Module['_BinaryenLoop'](module, strToStack(label), body));
};
self['break'] = self['br'] = function(label, condition, value) {
return preserveStack(() => Module['_BinaryenBreak'](module, strToStack(label), condition, value));
};
self['br_if'] = function(label, condition, value) {
return self['br'](label, condition, value);
};
self['switch'] = function(names, defaultName, condition, value) {
return preserveStack(() =>
Module['_BinaryenSwitch'](module, i32sToStack(names.map(strToStack)), names.length, strToStack(defaultName), condition, value)
);
};
self['call'] = function(name, operands, type) {
return preserveStack(() => Module['_BinaryenCall'](module, strToStack(name), i32sToStack(operands), operands.length, type));
};
// 'callIndirect', 'returnCall', 'returnCallIndirect' are deprecated and may
// be removed in a future release. Please use the the snake_case names
// instead.
self['callIndirect'] = self['call_indirect'] = function(table, target, operands, params, results) {
return preserveStack(() =>
Module['_BinaryenCallIndirect'](module, strToStack(table), target, i32sToStack(operands), operands.length, params, results)
);
};
self['returnCall'] = self['return_call'] = function(name, operands, type) {
return preserveStack(() =>
Module['_BinaryenReturnCall'](module, strToStack(name), i32sToStack(operands), operands.length, type)
);
};
self['returnCallIndirect'] = self['return_call_indirect'] = function(table, target, operands, params, results) {
return preserveStack(() =>
Module['_BinaryenReturnCallIndirect'](module, strToStack(table), target, i32sToStack(operands), operands.length, params, results)
);
};
self['local'] = {
'get'(index, type) {
return Module['_BinaryenLocalGet'](module, index, type);
},
'set'(index, value) {
return Module['_BinaryenLocalSet'](module, index, value);
},
'tee'(index, value, type) {
if (typeof type === 'undefined') {
throw new Error("local.tee's type should be defined");
}
return Module['_BinaryenLocalTee'](module, index, value, type);
}
}
self['global'] = {
'get'(name, type) {
return preserveStack(() => Module['_BinaryenGlobalGet'](module, strToStack(name), type));
},
'set'(name, value) {
return preserveStack(() => Module['_BinaryenGlobalSet'](module, strToStack(name), value));
}
}
self['table'] = {
'get'(name, index, type) {
return preserveStack(() => Module['_BinaryenTableGet'](module, strToStack(name), index, type));
},
'set'(name, index, value) {
return preserveStack(() => Module['_BinaryenTableSet'](module, strToStack(name), index, value));
},
'size'(name) {
return preserveStack(() => Module['_BinaryenTableSize'](module, strToStack(name)));
},
'grow'(name, value, delta) {
return preserveStack(() => Module['_BinaryenTableGrow'](module, strToStack(name), value, delta));
}
}
self['memory'] = {
// memory64 defaults to undefined/false.
'size'(name, memory64) {
return preserveStack(() => Module['_BinaryenMemorySize'](module, strToStack(name), memory64));
},
'grow'(value, name, memory64) {
return preserveStack(() => Module['_BinaryenMemoryGrow'](module, value, strToStack(name), memory64));
},
'init'(segment, dest, offset, size, name) {
return preserveStack(() => Module['_BinaryenMemoryInit'](module, strToStack(segment), dest, offset, size, strToStack(name)));
},
'copy'(dest, source, size, destMemory, sourceMemory) {
return preserveStack(() => Module['_BinaryenMemoryCopy'](module, dest, source, size, strToStack(destMemory), strToStack(sourceMemory)));
},
'fill'(dest, value, size, name) {
return preserveStack(() => Module['_BinaryenMemoryFill'](module, dest, value, size, strToStack(name)));
},
'atomic': {
'notify'(ptr, notifyCount, name) {
return preserveStack(() => Module['_BinaryenAtomicNotify'](module, ptr, notifyCount, strToStack(name)));
},
'wait32'(ptr, expected, timeout, name) {
return preserveStack(() => Module['_BinaryenAtomicWait'](module, ptr, expected, timeout, Module['i32'], strToStack(name)));
},
'wait64'(ptr, expected, timeout, name) {
return preserveStack(() => Module['_BinaryenAtomicWait'](module, ptr, expected, timeout, Module['i64'], strToStack(name)));
}
}
}
self['data'] = {
'drop'(segment) {
return preserveStack(() => Module['_BinaryenDataDrop'](module, strToStack(segment)));
}
}
self['i32'] = {
'load'(offset, align, ptr, name) {
return preserveStack(() => Module['_BinaryenLoad'](module, 4, true, offset, align, Module['i32'], ptr, strToStack(name)));
},
'load8_s'(offset, align, ptr, name) {
return preserveStack(() => Module['_BinaryenLoad'](module, 1, true, offset, align, Module['i32'], ptr, strToStack(name)));
},
'load8_u'(offset, align, ptr, name) {
return preserveStack(() => Module['_BinaryenLoad'](module, 1, false, offset, align, Module['i32'], ptr, strToStack(name)));
},
'load16_s'(offset, align, ptr, name) {
return preserveStack(() => Module['_BinaryenLoad'](module, 2, true, offset, align, Module['i32'], ptr, strToStack(name)));
},
'load16_u'(offset, align, ptr, name) {
return preserveStack(() => Module['_BinaryenLoad'](module, 2, false, offset, align, Module['i32'], ptr, strToStack(name)));
},
'store'(offset, align, ptr, value, name) {
return preserveStack(() => Module['_BinaryenStore'](module, 4, offset, align, ptr, value, Module['i32'], strToStack(name)));
},
'store8'(offset, align, ptr, value, name) {
return preserveStack(() => Module['_BinaryenStore'](module, 1, offset, align, ptr, value, Module['i32'], strToStack(name)));
},
'store16'(offset, align, ptr, value, name) {
return preserveStack(() => Module['_BinaryenStore'](module, 2, offset, align, ptr, value, Module['i32'], strToStack(name)));
},
'const'(x) {
return preserveStack(() => {
const tempLiteral = stackAlloc(sizeOfLiteral);
Module['_BinaryenLiteralInt32'](tempLiteral, x);
return Module['_BinaryenConst'](module, tempLiteral);
});
},
'clz'(value) {
return Module['_BinaryenUnary'](module, Module['ClzInt32'], value);
},
'ctz'(value) {
return Module['_BinaryenUnary'](module, Module['CtzInt32'], value);
},
'popcnt'(value) {
return Module['_BinaryenUnary'](module, Module['PopcntInt32'], value);
},
'eqz'(value) {
return Module['_BinaryenUnary'](module, Module['EqZInt32'], value);
},
'trunc_s': {
'f32'(value) {
return Module['_BinaryenUnary'](module, Module['TruncSFloat32ToInt32'], value);
},
'f64'(value) {
return Module['_BinaryenUnary'](module, Module['TruncSFloat64ToInt32'], value);
},
},
'trunc_u': {
'f32'(value) {
return Module['_BinaryenUnary'](module, Module['TruncUFloat32ToInt32'], value);
},
'f64'(value) {
return Module['_BinaryenUnary'](module, Module['TruncUFloat64ToInt32'], value);
},
},
'trunc_s_sat': {
'f32'(value) {
return Module['_BinaryenUnary'](module, Module['TruncSatSFloat32ToInt32'], value);
},
'f64'(value) {
return Module['_BinaryenUnary'](module, Module['TruncSatSFloat64ToInt32'], value);
},
},
'trunc_u_sat': {
'f32'(value) {
return Module['_BinaryenUnary'](module, Module['TruncSatUFloat32ToInt32'], value);
},
'f64'(value) {
return Module['_BinaryenUnary'](module, Module['TruncSatUFloat64ToInt32'], value);
},
},
'reinterpret'(value) {
return Module['_BinaryenUnary'](module, Module['ReinterpretFloat32'], value);
},
'extend8_s'(value) {
return Module['_BinaryenUnary'](module, Module['ExtendS8Int32'], value);
},
'extend16_s'(value) {
return Module['_BinaryenUnary'](module, Module['ExtendS16Int32'], value);
},
'wrap'(value) {
return Module['_BinaryenUnary'](module, Module['WrapInt64'], value);
},
'add'(left, right) {
return Module['_BinaryenBinary'](module, Module['AddInt32'], left, right);
},
'sub'(left, right) {
return Module['_BinaryenBinary'](module, Module['SubInt32'], left, right);
},
'mul'(left, right) {
return Module['_BinaryenBinary'](module, Module['MulInt32'], left, right);
},
'div_s'(left, right) {
return Module['_BinaryenBinary'](module, Module['DivSInt32'], left, right);
},
'div_u'(left, right) {
return Module['_BinaryenBinary'](module, Module['DivUInt32'], left, right);
},
'rem_s'(left, right) {
return Module['_BinaryenBinary'](module, Module['RemSInt32'], left, right);
},
'rem_u'(left, right) {
return Module['_BinaryenBinary'](module, Module['RemUInt32'], left, right);
},
'and'(left, right) {
return Module['_BinaryenBinary'](module, Module['AndInt32'], left, right);
},
'or'(left, right) {
return Module['_BinaryenBinary'](module, Module['OrInt32'], left, right);
},
'xor'(left, right) {
return Module['_BinaryenBinary'](module, Module['XorInt32'], left, right);
},
'shl'(left, right) {
return Module['_BinaryenBinary'](module, Module['ShlInt32'], left, right);
},
'shr_u'(left, right) {
return Module['_BinaryenBinary'](module, Module['ShrUInt32'], left, right);
},
'shr_s'(left, right) {
return Module['_BinaryenBinary'](module, Module['ShrSInt32'], left, right);
},
'rotl'(left, right) {
return Module['_BinaryenBinary'](module, Module['RotLInt32'], left, right);
},
'rotr'(left, right) {
return Module['_BinaryenBinary'](module, Module['RotRInt32'], left, right);
},
'eq'(left, right) {
return Module['_BinaryenBinary'](module, Module['EqInt32'], left, right);
},
'ne'(left, right) {
return Module['_BinaryenBinary'](module, Module['NeInt32'], left, right);
},
'lt_s'(left, right) {
return Module['_BinaryenBinary'](module, Module['LtSInt32'], left, right);
},
'lt_u'(left, right) {
return Module['_BinaryenBinary'](module, Module['LtUInt32'], left, right);
},
'le_s'(left, right) {
return Module['_BinaryenBinary'](module, Module['LeSInt32'], left, right);
},
'le_u'(left, right) {
return Module['_BinaryenBinary'](module, Module['LeUInt32'], left, right);
},
'gt_s'(left, right) {
return Module['_BinaryenBinary'](module, Module['GtSInt32'], left, right);
},
'gt_u'(left, right) {
return Module['_BinaryenBinary'](module, Module['GtUInt32'], left, right);
},
'ge_s'(left, right) {
return Module['_BinaryenBinary'](module, Module['GeSInt32'], left, right);
},
'ge_u'(left, right) {
return Module['_BinaryenBinary'](module, Module['GeUInt32'], left, right);
},
'atomic': {
'load'(offset, ptr, name, order) {
return preserveStack(() => Module['_BinaryenAtomicLoad'](module, 4, offset, Module['i32'], ptr, strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
},
'load8_u'(offset, ptr, name, order) {
return preserveStack(() => Module['_BinaryenAtomicLoad'](module, 1, offset, Module['i32'], ptr, strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
},
'load16_u'(offset, ptr, name) {
return preserveStack(() => Module['_BinaryenAtomicLoad'](module, 2, offset, Module['i32'], ptr, strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
},
'store'(offset, ptr, value, name, order) {
return preserveStack(() => Module['_BinaryenAtomicStore'](module, 4, offset, ptr, value, Module['i32'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
},
'store8'(offset, ptr, value, name, order) {
return preserveStack(() => Module['_BinaryenAtomicStore'](module, 1, offset, ptr, value, Module['i32'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
},
'store16'(offset, ptr, value, name, order) {
return preserveStack(() => Module['_BinaryenAtomicStore'](module, 2, offset, ptr, value, Module['i32'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
},
'rmw': {
'add'(offset, ptr, value, name, order) {
return preserveStack(() =>
Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWAdd'], 4, offset, ptr, value, Module['i32'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
},
'sub'(offset, ptr, value, name, order) {
return preserveStack(() =>
Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWSub'], 4, offset, ptr, value, Module['i32'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
},
'and'(offset, ptr, value, name, order) {
return preserveStack(() =>
Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWAnd'], 4, offset, ptr, value, Module['i32'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
},
'or'(offset, ptr, value, name, order) {
return preserveStack(() =>
Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWOr'], 4, offset, ptr, value, Module['i32'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
},
'xor'(offset, ptr, value, name, order) {
return preserveStack(() =>
Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWXor'], 4, offset, ptr, value, Module['i32'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
},
'xchg'(offset, ptr, value, name, order) {
return preserveStack(() =>
Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWXchg'], 4, offset, ptr, value, Module['i32'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
},
'cmpxchg'(offset, ptr, expected, replacement, name, order) {
return preserveStack(() =>
Module['_BinaryenAtomicCmpxchg'](module, 4, offset, ptr, expected, replacement, Module['i32'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
},
},
'rmw8_u': {
'add'(offset, ptr, value, name, order) {
return preserveStack(() =>
Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWAdd'], 1, offset, ptr, value, Module['i32'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
},
'sub'(offset, ptr, value, name, order) {
return preserveStack(() =>
Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWSub'], 1, offset, ptr, value, Module['i32'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
},
'and'(offset, ptr, value, name, order) {
return preserveStack(() =>
Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWAnd'], 1, offset, ptr, value, Module['i32'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
},
'or'(offset, ptr, value, name, order) {
return preserveStack(() =>
Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWOr'], 1, offset, ptr, value, Module['i32'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
},
'xor'(offset, ptr, value, name, order) {
return preserveStack(() =>
Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWXor'], 1, offset, ptr, value, Module['i32'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
},
'xchg'(offset, ptr, value, name, order) {
return preserveStack(() =>
Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWXchg'], 1, offset, ptr, value, Module['i32'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
},
'cmpxchg'(offset, ptr, expected, replacement, name, order) {
return preserveStack(() =>
Module['_BinaryenAtomicCmpxchg'](module, 1, offset, ptr, expected, replacement, Module['i32'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
},
},
'rmw16_u': {
'add'(offset, ptr, value, name, order) {
return preserveStack(() =>
Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWAdd'], 2, offset, ptr, value, Module['i32'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
},
'sub'(offset, ptr, value, name, order) {
return preserveStack(() =>
Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWSub'], 2, offset, ptr, value, Module['i32'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
},
'and'(offset, ptr, value, name, order) {
return preserveStack(() =>
Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWAnd'], 2, offset, ptr, value, Module['i32'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
},
'or'(offset, ptr, value, name, order) {
return preserveStack(() =>
Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWOr'], 2, offset, ptr, value, Module['i32'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
},
'xor'(offset, ptr, value, name, order) {
return preserveStack(() =>
Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWXor'], 2, offset, ptr, value, Module['i32'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
},
'xchg'(offset, ptr, value, name, order) {
return preserveStack(() =>
Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWXchg'], 2, offset, ptr, value, Module['i32'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
},
'cmpxchg'(offset, ptr, expected, replacement, name, order) {
return preserveStack(() =>
Module['_BinaryenAtomicCmpxchg'](module, 2, offset, ptr, expected, replacement, Module['i32'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
},
},
},
'pop'() {
return Module['_BinaryenPop'](module, Module['i32']);
}
};
self['i64'] = {
'load'(offset, align, ptr, name) {
return preserveStack(() => Module['_BinaryenLoad'](module, 8, true, offset, align, Module['i64'], ptr, strToStack(name)));
},
'load8_s'(offset, align, ptr, name) {
return preserveStack(() => Module['_BinaryenLoad'](module, 1, true, offset, align, Module['i64'], ptr, strToStack(name)));
},
'load8_u'(offset, align, ptr, name) {
return preserveStack(() => Module['_BinaryenLoad'](module, 1, false, offset, align, Module['i64'], ptr, strToStack(name)));
},
'load16_s'(offset, align, ptr, name) {
return preserveStack(() => Module['_BinaryenLoad'](module, 2, true, offset, align, Module['i64'], ptr, strToStack(name)));
},
'load16_u'(offset, align, ptr, name) {
return preserveStack(() => Module['_BinaryenLoad'](module, 2, false, offset, align, Module['i64'], ptr, strToStack(name)));
},
'load32_s'(offset, align, ptr, name) {
return preserveStack(() => Module['_BinaryenLoad'](module, 4, true, offset, align, Module['i64'], ptr, strToStack(name)));
},
'load32_u'(offset, align, ptr, name) {
return preserveStack(() => Module['_BinaryenLoad'](module, 4, false, offset, align, Module['i64'], ptr, strToStack(name)));
},
'store'(offset, align, ptr, value, name) {
return preserveStack(() => Module['_BinaryenStore'](module, 8, offset, align, ptr, value, Module['i64'], strToStack(name)));
},
'store8'(offset, align, ptr, value, name) {
return preserveStack(() => Module['_BinaryenStore'](module, 1, offset, align, ptr, value, Module['i64'], strToStack(name)));
},
'store16'(offset, align, ptr, value, name) {
return preserveStack(() => Module['_BinaryenStore'](module, 2, offset, align, ptr, value, Module['i64'], strToStack(name)));
},
'store32'(offset, align, ptr, value, name) {
return preserveStack(() => Module['_BinaryenStore'](module, 4, offset, align, ptr, value, Module['i64'], strToStack(name)));
},
'const'(x, y = undefined) {
return preserveStack(() => {
const tempLiteral = stackAlloc(sizeOfLiteral);
#if WASM_BIGINT
assert(typeof y == 'undefined', 'i64.const now takes a single argument (which can be a bigint)');
// We insert a cast to BigInt here in an attempt to be backwards
// compatible with callers who passed a single `number` here.
Module['_BinaryenLiteralInt64'](tempLiteral, BigInt(x));
#else
Module['_BinaryenLiteralInt64'](tempLiteral, x, y);
#endif
return Module['_BinaryenConst'](module, tempLiteral);
});
},
'clz'(value) {
return Module['_BinaryenUnary'](module, Module['ClzInt64'], value);
},
'ctz'(value) {
return Module['_BinaryenUnary'](module, Module['CtzInt64'], value);
},
'popcnt'(value) {
return Module['_BinaryenUnary'](module, Module['PopcntInt64'], value);
},
'eqz'(value) {
return Module['_BinaryenUnary'](module, Module['EqZInt64'], value);
},
'trunc_s': {
'f32'(value) {
return Module['_BinaryenUnary'](module, Module['TruncSFloat32ToInt64'], value);
},
'f64'(value) {
return Module['_BinaryenUnary'](module, Module['TruncSFloat64ToInt64'], value);
},
},
'trunc_u': {
'f32'(value) {
return Module['_BinaryenUnary'](module, Module['TruncUFloat32ToInt64'], value);
},
'f64'(value) {
return Module['_BinaryenUnary'](module, Module['TruncUFloat64ToInt64'], value);
},
},
'trunc_s_sat': {
'f32'(value) {
return Module['_BinaryenUnary'](module, Module['TruncSatSFloat32ToInt64'], value);
},
'f64'(value) {
return Module['_BinaryenUnary'](module, Module['TruncSatSFloat64ToInt64'], value);
},
},
'trunc_u_sat': {
'f32'(value) {
return Module['_BinaryenUnary'](module, Module['TruncSatUFloat32ToInt64'], value);
},
'f64'(value) {
return Module['_BinaryenUnary'](module, Module['TruncSatUFloat64ToInt64'], value);
},
},
'reinterpret'(value) {
return Module['_BinaryenUnary'](module, Module['ReinterpretFloat64'], value);
},
'extend8_s'(value) {
return Module['_BinaryenUnary'](module, Module['ExtendS8Int64'], value);
},
'extend16_s'(value) {
return Module['_BinaryenUnary'](module, Module['ExtendS16Int64'], value);
},
'extend32_s'(value) {
return Module['_BinaryenUnary'](module, Module['ExtendS32Int64'], value);
},
'extend_s'(value) {
return Module['_BinaryenUnary'](module, Module['ExtendSInt32'], value);
},
'extend_u'(value) {
return Module['_BinaryenUnary'](module, Module['ExtendUInt32'], value);
},
'add'(left, right) {
return Module['_BinaryenBinary'](module, Module['AddInt64'], left, right);
},
'sub'(left, right) {
return Module['_BinaryenBinary'](module, Module['SubInt64'], left, right);
},
'mul'(left, right) {
return Module['_BinaryenBinary'](module, Module['MulInt64'], left, right);
},
'div_s'(left, right) {
return Module['_BinaryenBinary'](module, Module['DivSInt64'], left, right);
},
'div_u'(left, right) {
return Module['_BinaryenBinary'](module, Module['DivUInt64'], left, right);
},
'rem_s'(left, right) {
return Module['_BinaryenBinary'](module, Module['RemSInt64'], left, right);
},
'rem_u'(left, right) {
return Module['_BinaryenBinary'](module, Module['RemUInt64'], left, right);
},
'and'(left, right) {
return Module['_BinaryenBinary'](module, Module['AndInt64'], left, right);
},
'or'(left, right) {
return Module['_BinaryenBinary'](module, Module['OrInt64'], left, right);
},
'xor'(left, right) {
return Module['_BinaryenBinary'](module, Module['XorInt64'], left, right);
},
'shl'(left, right) {
return Module['_BinaryenBinary'](module, Module['ShlInt64'], left, right);
},
'shr_u'(left, right) {
return Module['_BinaryenBinary'](module, Module['ShrUInt64'], left, right);
},
'shr_s'(left, right) {
return Module['_BinaryenBinary'](module, Module['ShrSInt64'], left, right);
},
'rotl'(left, right) {
return Module['_BinaryenBinary'](module, Module['RotLInt64'], left, right);
},
'rotr'(left, right) {
return Module['_BinaryenBinary'](module, Module['RotRInt64'], left, right);
},
'eq'(left, right) {
return Module['_BinaryenBinary'](module, Module['EqInt64'], left, right);
},
'ne'(left, right) {
return Module['_BinaryenBinary'](module, Module['NeInt64'], left, right);
},
'lt_s'(left, right) {
return Module['_BinaryenBinary'](module, Module['LtSInt64'], left, right);
},
'lt_u'(left, right) {
return Module['_BinaryenBinary'](module, Module['LtUInt64'], left, right);
},
'le_s'(left, right) {
return Module['_BinaryenBinary'](module, Module['LeSInt64'], left, right);
},
'le_u'(left, right) {
return Module['_BinaryenBinary'](module, Module['LeUInt64'], left, right);
},
'gt_s'(left, right) {
return Module['_BinaryenBinary'](module, Module['GtSInt64'], left, right);
},
'gt_u'(left, right) {
return Module['_BinaryenBinary'](module, Module['GtUInt64'], left, right);
},
'ge_s'(left, right) {
return Module['_BinaryenBinary'](module, Module['GeSInt64'], left, right);
},
'ge_u'(left, right) {
return Module['_BinaryenBinary'](module, Module['GeUInt64'], left, right);
},
'atomic': {
'load'(offset, ptr, name, order) {
return preserveStack(() => Module['_BinaryenAtomicLoad'](module, 8, offset, Module['i64'], ptr, strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
},
'load8_u'(offset, ptr, name, order) {
return preserveStack(() => Module['_BinaryenAtomicLoad'](module, 1, offset, Module['i64'], ptr, strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
},
'load16_u'(offset, ptr, name, order) {
return preserveStack(() => Module['_BinaryenAtomicLoad'](module, 2, offset, Module['i64'], ptr, strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
},
'load32_u'(offset, ptr, name, order) {
return preserveStack(() => Module['_BinaryenAtomicLoad'](module, 4, offset, Module['i64'], ptr, strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
},
'store'(offset, ptr, value, name, order) {
return preserveStack(() => Module['_BinaryenAtomicStore'](module, 8, offset, ptr, value, Module['i64'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
},
'store8'(offset, ptr, value, name, order) {
return preserveStack(() => Module['_BinaryenAtomicStore'](module, 1, offset, ptr, value, Module['i64'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
},
'store16'(offset, ptr, value, name, order) {
return preserveStack(() => Module['_BinaryenAtomicStore'](module, 2, offset, ptr, value, Module['i64'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
},
'store32'(offset, ptr, value, name, order) {
return preserveStack(() => Module['_BinaryenAtomicStore'](module, 4, offset, ptr, value, Module['i64'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
},
'rmw': {
'add'(offset, ptr, value, name, order) {
return preserveStack(() =>
Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWAdd'], 8, offset, ptr, value, Module['i64'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
},
'sub'(offset, ptr, value, name, order) {
return preserveStack(() =>
Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWSub'], 8, offset, ptr, value, Module['i64'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
},
'and'(offset, ptr, value, name, order) {
return preserveStack(() =>
Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWAnd'], 8, offset, ptr, value, Module['i64'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
},
'or'(offset, ptr, value, name, order) {
return preserveStack(() =>
Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWOr'], 8, offset, ptr, value, Module['i64'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
},
'xor'(offset, ptr, value, name, order) {
return preserveStack(() =>
Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWXor'], 8, offset, ptr, value, Module['i64'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
},
'xchg'(offset, ptr, value, name, order) {
return preserveStack(() =>
Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWXchg'], 8, offset, ptr, value, Module['i64'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
},
'cmpxchg'(offset, ptr, expected, replacement, name, order) {
return preserveStack(() =>
Module['_BinaryenAtomicCmpxchg'](module, 8, offset, ptr, expected, replacement, Module['i64'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
},
},
'rmw8_u': {
'add'(offset, ptr, value, name, order) {
return preserveStack(() =>
Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWAdd'], 1, offset, ptr, value, Module['i64'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
},
'sub'(offset, ptr, value, name, order) {
return preserveStack(() =>
Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWSub'], 1, offset, ptr, value, Module['i64'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
},
'and'(offset, ptr, value, name, order) {
return preserveStack(() =>
Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWAnd'], 1, offset, ptr, value, Module['i64'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
},
'or'(offset, ptr, value, name, order) {
return preserveStack(() =>
Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWOr'], 1, offset, ptr, value, Module['i64'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
},
'xor'(offset, ptr, value, name, order) {
return preserveStack(() =>
Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWXor'], 1, offset, ptr, value, Module['i64'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
},
'xchg'(offset, ptr, value, name, order) {
return preserveStack(() =>
Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWXchg'], 1, offset, ptr, value, Module['i64'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
},
'cmpxchg'(offset, ptr, expected, replacement, name, order) {
return preserveStack(() =>
Module['_BinaryenAtomicCmpxchg'](module, 1, offset, ptr, expected, replacement, Module['i64'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
},
},
'rmw16_u': {
'add'(offset, ptr, value, name, order) {
return preserveStack(() =>
Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWAdd'], 2, offset, ptr, value, Module['i64'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
},
'sub'(offset, ptr, value, name, order) {
return preserveStack(() =>
Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWSub'], 2, offset, ptr, value, Module['i64'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
},
'and'(offset, ptr, value, name, order) {
return preserveStack(() =>
Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWAnd'], 2, offset, ptr, value, Module['i64'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
},
'or'(offset, ptr, value, name, order) {
return preserveStack(() =>
Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWOr'], 2, offset, ptr, value, Module['i64'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
},
'xor'(offset, ptr, value, name, order) {
return preserveStack(() =>
Module['_BinaryenAtomicRMW'](module, Module['Atomic