| // export friendly API methods |
| |
| function preserveStack(func) { |
| try { |
| var stack = Runtime.stackSave(); |
| return func(); |
| } finally { |
| Runtime.stackRestore(stack); |
| } |
| }; |
| |
| function strToStack(str) { |
| if (!str) return 0; |
| return allocate(intArrayFromString(str), 'i8', ALLOC_STACK); |
| } |
| |
| function i32sToStack(i32s) { |
| var ret = Runtime.stackAlloc(i32s.length << 2); |
| for (var i = 0; i < i32s.length; i++) { |
| HEAP32[ret + (i << 2) >> 2] = i32s[i]; |
| } |
| return ret; |
| } |
| |
| Module['none'] = Module['_BinaryenNone'](); |
| Module['i32'] = Module['_BinaryenInt32'](); |
| Module['i64'] = Module['_BinaryenInt64'](); |
| Module['f32'] = Module['_BinaryenFloat32'](); |
| Module['f64'] = Module['_BinaryenFloat64'](); |
| |
| Module['ClzInt32'] = Module['_BinaryenClzInt32'](); |
| Module['CtzInt32'] = Module['_BinaryenCtzInt32'](); |
| Module['PopcntInt32'] = Module['_BinaryenPopcntInt32'](); |
| Module['NegFloat32'] = Module['_BinaryenNegFloat32'](); |
| Module['AbsFloat32'] = Module['_BinaryenAbsFloat32'](); |
| Module['CeilFloat32'] = Module['_BinaryenCeilFloat32'](); |
| Module['FloorFloat32'] = Module['_BinaryenFloorFloat32'](); |
| Module['TruncFloat32'] = Module['_BinaryenTruncFloat32'](); |
| Module['NearestFloat32'] = Module['_BinaryenNearestFloat32'](); |
| Module['SqrtFloat32'] = Module['_BinaryenSqrtFloat32'](); |
| Module['EqZInt32'] = Module['_BinaryenEqZInt32'](); |
| Module['ClzInt64'] = Module['_BinaryenClzInt64'](); |
| Module['CtzInt64'] = Module['_BinaryenCtzInt64'](); |
| Module['PopcntInt64'] = Module['_BinaryenPopcntInt64'](); |
| Module['NegFloat64'] = Module['_BinaryenNegFloat64'](); |
| Module['AbsFloat64'] = Module['_BinaryenAbsFloat64'](); |
| Module['CeilFloat64'] = Module['_BinaryenCeilFloat64'](); |
| Module['FloorFloat64'] = Module['_BinaryenFloorFloat64'](); |
| Module['TruncFloat64'] = Module['_BinaryenTruncFloat64'](); |
| Module['NearestFloat64'] = Module['_BinaryenNearestFloat64'](); |
| Module['SqrtFloat64'] = Module['_BinaryenSqrtFloat64'](); |
| Module['EqZInt64'] = Module['_BinaryenEqZInt64'](); |
| Module['ExtendSInt32'] = Module['_BinaryenExtendSInt32'](); |
| Module['ExtendUInt32'] = Module['_BinaryenExtendUInt32'](); |
| Module['WrapInt64'] = Module['_BinaryenWrapInt64'](); |
| Module['TruncSFloat32ToInt32'] = Module['_BinaryenTruncSFloat32ToInt32'](); |
| Module['TruncSFloat32ToInt64'] = Module['_BinaryenTruncSFloat32ToInt64'](); |
| Module['TruncUFloat32ToInt32'] = Module['_BinaryenTruncUFloat32ToInt32'](); |
| Module['TruncUFloat32ToInt64'] = Module['_BinaryenTruncUFloat32ToInt64'](); |
| Module['TruncSFloat64ToInt32'] = Module['_BinaryenTruncSFloat64ToInt32'](); |
| Module['TruncSFloat64ToInt64'] = Module['_BinaryenTruncSFloat64ToInt64'](); |
| Module['TruncUFloat64ToInt32'] = Module['_BinaryenTruncUFloat64ToInt32'](); |
| Module['TruncUFloat64ToInt64'] = Module['_BinaryenTruncUFloat64ToInt64'](); |
| Module['ReinterpretFloat32'] = Module['_BinaryenReinterpretFloat32'](); |
| Module['ReinterpretFloat64'] = Module['_BinaryenReinterpretFloat64'](); |
| Module['ConvertSInt32ToFloat32'] = Module['_BinaryenConvertSInt32ToFloat32'](); |
| Module['ConvertSInt32ToFloat64'] = Module['_BinaryenConvertSInt32ToFloat64'](); |
| Module['ConvertUInt32ToFloat32'] = Module['_BinaryenConvertUInt32ToFloat32'](); |
| Module['ConvertUInt32ToFloat64'] = Module['_BinaryenConvertUInt32ToFloat64'](); |
| Module['ConvertSInt64ToFloat32'] = Module['_BinaryenConvertSInt64ToFloat32'](); |
| Module['ConvertSInt64ToFloat64'] = Module['_BinaryenConvertSInt64ToFloat64'](); |
| Module['ConvertUInt64ToFloat32'] = Module['_BinaryenConvertUInt64ToFloat32'](); |
| Module['ConvertUInt64ToFloat64'] = Module['_BinaryenConvertUInt64ToFloat64'](); |
| Module['PromoteFloat32'] = Module['_BinaryenPromoteFloat32'](); |
| Module['DemoteFloat64'] = Module['_BinaryenDemoteFloat64'](); |
| Module['ReinterpretInt32'] = Module['_BinaryenReinterpretInt32'](); |
| Module['ReinterpretInt64'] = Module['_BinaryenReinterpretInt64'](); |
| Module['AddInt32'] = Module['_BinaryenAddInt32'](); |
| Module['SubInt32'] = Module['_BinaryenSubInt32'](); |
| Module['MulInt32'] = Module['_BinaryenMulInt32'](); |
| Module['DivSInt32'] = Module['_BinaryenDivSInt32'](); |
| Module['DivUInt32'] = Module['_BinaryenDivUInt32'](); |
| Module['RemSInt32'] = Module['_BinaryenRemSInt32'](); |
| Module['RemUInt32'] = Module['_BinaryenRemUInt32'](); |
| Module['AndInt32'] = Module['_BinaryenAndInt32'](); |
| Module['OrInt32'] = Module['_BinaryenOrInt32'](); |
| Module['XorInt32'] = Module['_BinaryenXorInt32'](); |
| Module['ShlInt32'] = Module['_BinaryenShlInt32'](); |
| Module['ShrUInt32'] = Module['_BinaryenShrUInt32'](); |
| Module['ShrSInt32'] = Module['_BinaryenShrSInt32'](); |
| Module['RotLInt32'] = Module['_BinaryenRotLInt32'](); |
| Module['RotRInt32'] = Module['_BinaryenRotRInt32'](); |
| Module['EqInt32'] = Module['_BinaryenEqInt32'](); |
| Module['NeInt32'] = Module['_BinaryenNeInt32'](); |
| Module['LtSInt32'] = Module['_BinaryenLtSInt32'](); |
| Module['LtUInt32'] = Module['_BinaryenLtUInt32'](); |
| Module['LeSInt32'] = Module['_BinaryenLeSInt32'](); |
| Module['LeUInt32'] = Module['_BinaryenLeUInt32'](); |
| Module['GtSInt32'] = Module['_BinaryenGtSInt32'](); |
| Module['GtUInt32'] = Module['_BinaryenGtUInt32'](); |
| Module['GeSInt32'] = Module['_BinaryenGeSInt32'](); |
| Module['GeUInt32'] = Module['_BinaryenGeUInt32'](); |
| Module['AddInt64'] = Module['_BinaryenAddInt64'](); |
| Module['SubInt64'] = Module['_BinaryenSubInt64'](); |
| Module['MulInt64'] = Module['_BinaryenMulInt64'](); |
| Module['DivSInt64'] = Module['_BinaryenDivSInt64'](); |
| Module['DivUInt64'] = Module['_BinaryenDivUInt64'](); |
| Module['RemSInt64'] = Module['_BinaryenRemSInt64'](); |
| Module['RemUInt64'] = Module['_BinaryenRemUInt64'](); |
| Module['AndInt64'] = Module['_BinaryenAndInt64'](); |
| Module['OrInt64'] = Module['_BinaryenOrInt64'](); |
| Module['XorInt64'] = Module['_BinaryenXorInt64'](); |
| Module['ShlInt64'] = Module['_BinaryenShlInt64'](); |
| Module['ShrUInt64'] = Module['_BinaryenShrUInt64'](); |
| Module['ShrSInt64'] = Module['_BinaryenShrSInt64'](); |
| Module['RotLInt64'] = Module['_BinaryenRotLInt64'](); |
| Module['RotRInt64'] = Module['_BinaryenRotRInt64'](); |
| Module['EqInt64'] = Module['_BinaryenEqInt64'](); |
| Module['NeInt64'] = Module['_BinaryenNeInt64'](); |
| Module['LtSInt64'] = Module['_BinaryenLtSInt64'](); |
| Module['LtUInt64'] = Module['_BinaryenLtUInt64'](); |
| Module['LeSInt64'] = Module['_BinaryenLeSInt64'](); |
| Module['LeUInt64'] = Module['_BinaryenLeUInt64'](); |
| Module['GtSInt64'] = Module['_BinaryenGtSInt64'](); |
| Module['GtUInt64'] = Module['_BinaryenGtUInt64'](); |
| Module['GeSInt64'] = Module['_BinaryenGeSInt64'](); |
| Module['GeUInt64'] = Module['_BinaryenGeUInt64'](); |
| Module['AddFloat32'] = Module['_BinaryenAddFloat32'](); |
| Module['SubFloat32'] = Module['_BinaryenSubFloat32'](); |
| Module['MulFloat32'] = Module['_BinaryenMulFloat32'](); |
| Module['DivFloat32'] = Module['_BinaryenDivFloat32'](); |
| Module['CopySignFloat32'] = Module['_BinaryenCopySignFloat32'](); |
| Module['MinFloat32'] = Module['_BinaryenMinFloat32'](); |
| Module['MaxFloat32'] = Module['_BinaryenMaxFloat32'](); |
| Module['EqFloat32'] = Module['_BinaryenEqFloat32'](); |
| Module['NeFloat32'] = Module['_BinaryenNeFloat32'](); |
| Module['LtFloat32'] = Module['_BinaryenLtFloat32'](); |
| Module['LeFloat32'] = Module['_BinaryenLeFloat32'](); |
| Module['GtFloat32'] = Module['_BinaryenGtFloat32'](); |
| Module['GeFloat32'] = Module['_BinaryenGeFloat32'](); |
| Module['AddFloat64'] = Module['_BinaryenAddFloat64'](); |
| Module['SubFloat64'] = Module['_BinaryenSubFloat64'](); |
| Module['MulFloat64'] = Module['_BinaryenMulFloat64'](); |
| Module['DivFloat64'] = Module['_BinaryenDivFloat64'](); |
| Module['CopySignFloat64'] = Module['_BinaryenCopySignFloat64'](); |
| Module['MinFloat64'] = Module['_BinaryenMinFloat64'](); |
| Module['MaxFloat64'] = Module['_BinaryenMaxFloat64'](); |
| Module['EqFloat64'] = Module['_BinaryenEqFloat64'](); |
| Module['NeFloat64'] = Module['_BinaryenNeFloat64'](); |
| Module['LtFloat64'] = Module['_BinaryenLtFloat64'](); |
| Module['LeFloat64'] = Module['_BinaryenLeFloat64'](); |
| Module['GtFloat64'] = Module['_BinaryenGtFloat64'](); |
| Module['GeFloat64'] = Module['_BinaryenGeFloat64'](); |
| Module['PageSize'] = Module['_BinaryenPageSize'](); |
| Module['CurrentMemory'] = Module['_BinaryenCurrentMemory'](); |
| Module['GrowMemory'] = Module['_BinaryenGrowMemory'](); |
| Module['HasFeature'] = Module['_BinaryenHasFeature'](); |
| |
| // we provide a JS Module() object interface |
| Module['Module'] = function(module) { |
| if (!module) module = Module['_BinaryenModuleCreate'](); |
| this['ptr'] = module; |
| |
| this['dispose'] = function() { |
| Module['_BinaryenModuleDispose'](module); |
| }; |
| this['addFunctionType'] = function(name, result, paramTypes) { |
| return preserveStack(function() { |
| return Module['_BinaryenAddFunctionType'](module, strToStack(name), result, |
| i32sToStack(paramTypes), paramTypes.length); |
| }); |
| }; |
| |
| this['block'] = function(name, children) { |
| return preserveStack(function() { |
| return Module['_BinaryenBlock'](module, name ? strToStack(name) : 0, |
| i32sToStack(children), children.length); |
| }); |
| }; |
| this['if'] = function(condition, ifTrue, ifFalse) { |
| return Module['_BinaryenIf'](module, condition, ifTrue, ifFalse); |
| }; |
| this['loop'] = function(label, body) { |
| return preserveStack(function() { |
| return Module['_BinaryenLoop'](module, strToStack(label), body); |
| }); |
| }; |
| this['break'] = function(label, condition, value) { |
| return preserveStack(function() { |
| return Module['_BinaryenBreak'](module, strToStack(label), condition, value); |
| }); |
| }; |
| this['switch'] = function(names, defaultName, condition, value) { |
| return preserveStack(function() { |
| var namei32s = []; |
| names.forEach(function(name) { |
| namei32s.push(strToStack(name)); |
| }); |
| return Module['_BinaryenSwitch'](module, i32sToStack(namei32s), namei32s.length, |
| strToStack(defaultName), condition, value); |
| }); |
| }; |
| this['call'] = function(name, operands, type) { |
| return preserveStack(function() { |
| return Module['_BinaryenCall'](module, strToStack(name), i32sToStack(operands), operands.length, type); |
| }); |
| }; |
| this['callImport'] = function(name, operands, type) { |
| return preserveStack(function() { |
| return Module['_BinaryenCallImport'](module, strToStack(name), i32sToStack(operands), operands.length, type); |
| }); |
| }; |
| this['callIndirect'] = function(target, operands, type) { |
| return preserveStack(function() { |
| return Module['_BinaryenCallIndirect'](module, target, i32sToStack(operands), operands.length, strToStack(type)); |
| }); |
| }; |
| this['getLocal'] = function(index, type) { |
| return Module['_BinaryenGetLocal'](module, index, type); |
| }; |
| this['setLocal'] = function(index, value) { |
| return Module['_BinaryenSetLocal'](module, index, value); |
| }; |
| this['teeLocal'] = function(index, value) { |
| return Module['_BinaryenTeeLocal'](module, index, value); |
| }; |
| |
| // The Const creation API 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, this is the only API that |
| // accepts Literals, so fuse it with Literal creation |
| var literal = _malloc(16); // a single literal in memory. the LLVM C ABI |
| // makes us pass pointers to this. |
| |
| this['i32'] = { |
| 'load': function(offset, align, ptr) { |
| return Module['_BinaryenLoad'](module, 4, true, offset, align, Module['i32'], ptr); |
| }, |
| 'load8_s': function(offset, align, ptr) { |
| return Module['_BinaryenLoad'](module, 1, true, offset, align, Module['i32'], ptr); |
| }, |
| 'load8_u': function(offset, align, ptr) { |
| return Module['_BinaryenLoad'](module, 1, false, offset, align, Module['i32'], ptr); |
| }, |
| 'load16_s': function(offset, align, ptr) { |
| return Module['_BinaryenLoad'](module, 2, true, offset, align, Module['i32'], ptr); |
| }, |
| 'load16_u': function(offset, align, ptr) { |
| return Module['_BinaryenLoad'](module, 2, false, offset, align, Module['i32'], ptr); |
| }, |
| 'store': function(offset, align, ptr, value) { |
| return Module['_BinaryenStore'](module, 4, offset, align, ptr, value, Module['i32']); |
| }, |
| 'store8': function(offset, align, ptr, value) { |
| return Module['_BinaryenStore'](module, 1, offset, align, ptr, value, Module['i32']); |
| }, |
| 'store16': function(offset, align, ptr, value) { |
| return Module['_BinaryenStore'](module, 2, offset, align, ptr, value, Module['i32']); |
| }, |
| 'const': function(x) { |
| Module['_BinaryenLiteralInt32'](literal, x); |
| return Module['_BinaryenConst'](module, literal); |
| }, |
| 'clz': function(value) { |
| return Module['_BinaryenUnary'](module, Module['ClzInt32'], value); |
| }, |
| 'ctz': function(value) { |
| return Module['_BinaryenUnary'](module, Module['CtzInt32'], value); |
| }, |
| 'popcnt': function(value) { |
| return Module['_BinaryenUnary'](module, Module['PopcntInt32'], value); |
| }, |
| 'eqz': function(value) { |
| return Module['_BinaryenUnary'](module, Module['EqZInt32'], value); |
| }, |
| 'trunc_s': { |
| 'f32': function(value) { |
| return Module['_BinaryenUnary'](module, Module['TruncSFloat32ToInt32'], value); |
| }, |
| 'f64': function(value) { |
| return Module['_BinaryenUnary'](module, Module['TruncSFloat64ToInt32'], value); |
| }, |
| }, |
| 'trunc_u': { |
| 'f32': function(value) { |
| return Module['_BinaryenUnary'](module, Module['TruncUFloat32ToInt32'], value); |
| }, |
| 'f64': function(value) { |
| return Module['_BinaryenUnary'](module, Module['TruncUFloat64ToInt32'], value); |
| }, |
| }, |
| 'reinterpret': function(value) { |
| return Module['_BinaryenUnary'](module, Module['ReinterpretFloat32'], value); |
| }, |
| 'wrap': function(value) { |
| return Module['_BinaryenUnary'](module, Module['WrapInt64'], value); |
| }, |
| 'add': function(left, right) { |
| return Module['_BinaryenBinary'](module, Module['AddInt32'], left, right); |
| }, |
| 'sub': function(left, right) { |
| return Module['_BinaryenBinary'](module, Module['SubInt32'], left, right); |
| }, |
| 'mul': function(left, right) { |
| return Module['_BinaryenBinary'](module, Module['MulInt32'], left, right); |
| }, |
| 'div_s': function(left, right) { |
| return Module['_BinaryenBinary'](module, Module['DivSInt32'], left, right); |
| }, |
| 'div_u': function(left, right) { |
| return Module['_BinaryenBinary'](module, Module['DivUInt32'], left, right); |
| }, |
| 'rem_s': function(left, right) { |
| return Module['_BinaryenBinary'](module, Module['RemSInt32'], left, right); |
| }, |
| 'rem_u': function(left, right) { |
| return Module['_BinaryenBinary'](module, Module['RemUInt32'], left, right); |
| }, |
| 'and': function(left, right) { |
| return Module['_BinaryenBinary'](module, Module['AndInt32'], left, right); |
| }, |
| 'or': function(left, right) { |
| return Module['_BinaryenBinary'](module, Module['OrInt32'], left, right); |
| }, |
| 'xor': function(left, right) { |
| return Module['_BinaryenBinary'](module, Module['XorInt32'], left, right); |
| }, |
| 'shl': function(left, right) { |
| return Module['_BinaryenBinary'](module, Module['ShlInt32'], left, right); |
| }, |
| 'shr_u': function(left, right) { |
| return Module['_BinaryenBinary'](module, Module['ShrUInt32'], left, right); |
| }, |
| 'shr_s': function(left, right) { |
| return Module['_BinaryenBinary'](module, Module['ShrSInt32'], left, right); |
| }, |
| 'rotl': function(left, right) { |
| return Module['_BinaryenBinary'](module, Module['RotLInt32'], left, right); |
| }, |
| 'rotr': function(left, right) { |
| return Module['_BinaryenBinary'](module, Module['RotRInt32'], left, right); |
| }, |
| 'eq': function(left, right) { |
| return Module['_BinaryenBinary'](module, Module['EqInt32'], left, right); |
| }, |
| 'ne': function(left, right) { |
| return Module['_BinaryenBinary'](module, Module['NeInt32'], left, right); |
| }, |
| 'lt_s': function(left, right) { |
| return Module['_BinaryenBinary'](module, Module['LtSInt32'], left, right); |
| }, |
| 'lt_u': function(left, right) { |
| return Module['_BinaryenBinary'](module, Module['LtUInt32'], left, right); |
| }, |
| 'le_s': function(left, right) { |
| return Module['_BinaryenBinary'](module, Module['LeSInt32'], left, right); |
| }, |
| 'le_u': function(left, right) { |
| return Module['_BinaryenBinary'](module, Module['LeUInt32'], left, right); |
| }, |
| 'gt_s': function(left, right) { |
| return Module['_BinaryenBinary'](module, Module['GtSInt32'], left, right); |
| }, |
| 'gt_u': function(left, right) { |
| return Module['_BinaryenBinary'](module, Module['GtUInt32'], left, right); |
| }, |
| 'ge_s': function(left, right) { |
| return Module['_BinaryenBinary'](module, Module['GeSInt32'], left, right); |
| }, |
| 'ge_u': function(left, right) { |
| return Module['_BinaryenBinary'](module, Module['GeUInt32'], left, right); |
| }, |
| }; |
| |
| this['i64'] = { |
| 'load': function(offset, align, ptr) { |
| return Module['_BinaryenLoad'](module, 8, true, offset, align, Module['i64'], ptr); |
| }, |
| 'load8_s': function(offset, align, ptr) { |
| return Module['_BinaryenLoad'](module, 1, true, offset, align, Module['i64'], ptr); |
| }, |
| 'load8_u': function(offset, align, ptr) { |
| return Module['_BinaryenLoad'](module, 1, false, offset, align, Module['i64'], ptr); |
| }, |
| 'load16_s': function(offset, align, ptr) { |
| return Module['_BinaryenLoad'](module, 2, true, offset, align, Module['i64'], ptr); |
| }, |
| 'load16_u': function(offset, align, ptr) { |
| return Module['_BinaryenLoad'](module, 2, false, offset, align, Module['i64'], ptr); |
| }, |
| 'load32_s': function(offset, align, ptr) { |
| return Module['_BinaryenLoad'](module, 4, true, offset, align, Module['i64'], ptr); |
| }, |
| 'load32_u': function(offset, align, ptr) { |
| return Module['_BinaryenLoad'](module, 4, false, offset, align, Module['i64'], ptr); |
| }, |
| 'store': function(offset, align, ptr, value) { |
| return Module['_BinaryenStore'](module, 8, offset, align, ptr, value, Module['i64']); |
| }, |
| 'store8': function(offset, align, ptr, value) { |
| return Module['_BinaryenStore'](module, 1, offset, align, ptr, value, Module['i64']); |
| }, |
| 'store16': function(offset, align, ptr, value) { |
| return Module['_BinaryenStore'](module, 2, offset, align, ptr, value, Module['i64']); |
| }, |
| 'store32': function(offset, align, ptr, value) { |
| return Module['_BinaryenStore'](module, 4, offset, align, ptr, value, Module['i64']); |
| }, |
| 'const': function(x, y) { |
| Module['_BinaryenLiteralInt64'](literal, x, y); |
| return Module['_BinaryenConst'](module, literal); |
| }, |
| 'clz': function(value) { |
| return Module['_BinaryenUnary'](module, Module['ClzInt64'], value); |
| }, |
| 'ctz': function(value) { |
| return Module['_BinaryenUnary'](module, Module['CtzInt64'], value); |
| }, |
| 'popcnt': function(value) { |
| return Module['_BinaryenUnary'](module, Module['PopcntInt64'], value); |
| }, |
| 'eqz': function(value) { |
| return Module['_BinaryenUnary'](module, Module['EqZInt64'], value); |
| }, |
| 'trunc_s': { |
| 'f32': function(value) { |
| return Module['_BinaryenUnary'](module, Module['TruncSFloat32ToInt64'], value); |
| }, |
| 'f64': function(value) { |
| return Module['_BinaryenUnary'](module, Module['TruncSFloat64ToInt64'], value); |
| }, |
| }, |
| 'trunc_u': { |
| 'f32': function(value) { |
| return Module['_BinaryenUnary'](module, Module['TruncUFloat32ToInt64'], value); |
| }, |
| 'f64': function(value) { |
| return Module['_BinaryenUnary'](module, Module['TruncUFloat64ToInt64'], value); |
| }, |
| }, |
| 'reinterpret': function(value) { |
| return Module['_BinaryenUnary'](module, Module['ReinterpretFloat64'], value); |
| }, |
| 'extend_s': function(value) { |
| return Module['_BinaryenUnary'](module, Module['ExtendSInt32'], value); |
| }, |
| 'extend_u': function(value) { |
| return Module['_BinaryenUnary'](module, Module['ExtendUInt32'], value); |
| }, |
| 'add': function(left, right) { |
| return Module['_BinaryenBinary'](module, Module['AddInt64'], left, right); |
| }, |
| 'sub': function(left, right) { |
| return Module['_BinaryenBinary'](module, Module['SubInt64'], left, right); |
| }, |
| 'mul': function(left, right) { |
| return Module['_BinaryenBinary'](module, Module['MulInt64'], left, right); |
| }, |
| 'div_s': function(left, right) { |
| return Module['_BinaryenBinary'](module, Module['DivSInt64'], left, right); |
| }, |
| 'div_u': function(left, right) { |
| return Module['_BinaryenBinary'](module, Module['DivUInt64'], left, right); |
| }, |
| 'rem_s': function(left, right) { |
| return Module['_BinaryenBinary'](module, Module['RemSInt64'], left, right); |
| }, |
| 'rem_u': function(left, right) { |
| return Module['_BinaryenBinary'](module, Module['RemUInt64'], left, right); |
| }, |
| 'and': function(left, right) { |
| return Module['_BinaryenBinary'](module, Module['AndInt64'], left, right); |
| }, |
| 'or': function(left, right) { |
| return Module['_BinaryenBinary'](module, Module['OrInt64'], left, right); |
| }, |
| 'xor': function(left, right) { |
| return Module['_BinaryenBinary'](module, Module['XorInt64'], left, right); |
| }, |
| 'shl': function(left, right) { |
| return Module['_BinaryenBinary'](module, Module['ShlInt64'], left, right); |
| }, |
| 'shr_u': function(left, right) { |
| return Module['_BinaryenBinary'](module, Module['ShrUInt64'], left, right); |
| }, |
| 'shr_s': function(left, right) { |
| return Module['_BinaryenBinary'](module, Module['ShrSInt64'], left, right); |
| }, |
| 'rotl': function(left, right) { |
| return Module['_BinaryenBinary'](module, Module['RotLInt64'], left, right); |
| }, |
| 'rotr': function(left, right) { |
| return Module['_BinaryenBinary'](module, Module['RotRInt64'], left, right); |
| }, |
| 'eq': function(left, right) { |
| return Module['_BinaryenBinary'](module, Module['EqInt64'], left, right); |
| }, |
| 'ne': function(left, right) { |
| return Module['_BinaryenBinary'](module, Module['NeInt64'], left, right); |
| }, |
| 'lt_s': function(left, right) { |
| return Module['_BinaryenBinary'](module, Module['LtSInt64'], left, right); |
| }, |
| 'lt_u': function(left, right) { |
| return Module['_BinaryenBinary'](module, Module['LtUInt64'], left, right); |
| }, |
| 'le_s': function(left, right) { |
| return Module['_BinaryenBinary'](module, Module['LeSInt64'], left, right); |
| }, |
| 'le_u': function(left, right) { |
| return Module['_BinaryenBinary'](module, Module['LeUInt64'], left, right); |
| }, |
| 'gt_s': function(left, right) { |
| return Module['_BinaryenBinary'](module, Module['GtSInt64'], left, right); |
| }, |
| 'gt_u': function(left, right) { |
| return Module['_BinaryenBinary'](module, Module['GtUInt64'], left, right); |
| }, |
| 'ge_s': function(left, right) { |
| return Module['_BinaryenBinary'](module, Module['GeSInt64'], left, right); |
| }, |
| 'ge_u': function(left, right) { |
| return Module['_BinaryenBinary'](module, Module['GeUInt64'], left, right); |
| }, |
| }; |
| |
| this['f32'] = { |
| 'load': function(offset, align, ptr) { |
| return Module['_BinaryenLoad'](module, 4, true, offset, align, Module['f32'], ptr); |
| }, |
| 'store': function(offset, align, ptr, value) { |
| return Module['_BinaryenStore'](module, 4, offset, align, ptr, value, Module['f32']); |
| }, |
| 'const': function(x) { |
| Module['_BinaryenLiteralFloat32'](literal, x); |
| return Module['_BinaryenConst'](module, literal); |
| }, |
| 'const_bits': function(x) { |
| Module['_BinaryenLiteralFloat32Bits'](literal, x); |
| return Module['_BinaryenConst'](module, literal); |
| }, |
| 'neg': function(value) { |
| return Module['_BinaryenUnary'](module, Module['NegFloat32'], value); |
| }, |
| 'abs': function(value) { |
| return Module['_BinaryenUnary'](module, Module['AbsFloat32'], value); |
| }, |
| 'ceil': function(value) { |
| return Module['_BinaryenUnary'](module, Module['CeilFloat32'], value); |
| }, |
| 'floor': function(value) { |
| return Module['_BinaryenUnary'](module, Module['FloorFloat32'], value); |
| }, |
| 'trunc': function(value) { |
| return Module['_BinaryenUnary'](module, Module['TruncFloat32'], value); |
| }, |
| 'nearest': function(value) { |
| return Module['_BinaryenUnary'](module, Module['NearestFloat32'], value); |
| }, |
| 'sqrt': function(value) { |
| return Module['_BinaryenUnary'](module, Module['SqrtFloat32'], value); |
| }, |
| 'reinterpret': function(value) { |
| return Module['_BinaryenUnary'](module, Module['ReinterpretInt32'], value); |
| }, |
| 'convert_s': { |
| 'i32': function(value) { |
| return Module['_BinaryenUnary'](module, Module['ConvertSInt32ToFloat32'], value); |
| }, |
| 'i64': function(value) { |
| return Module['_BinaryenUnary'](module, Module['ConvertSInt64ToFloat32'], value); |
| }, |
| }, |
| 'convert_u': { |
| 'i32': function(value) { |
| return Module['_BinaryenUnary'](module, Module['ConvertUInt32ToFloat32'], value); |
| }, |
| 'i64': function(value) { |
| return Module['_BinaryenUnary'](module, Module['ConvertUInt64ToFloat32'], value); |
| }, |
| }, |
| 'demote': function(value) { |
| return Module['_BinaryenUnary'](module, Module['DemoteFloat64'], value); |
| }, |
| 'add': function(left, right) { |
| return Module['_BinaryenBinary'](module, Module['AddFloat32'], left, right); |
| }, |
| 'sub': function(left, right) { |
| return Module['_BinaryenBinary'](module, Module['SubFloat32'], left, right); |
| }, |
| 'mul': function(left, right) { |
| return Module['_BinaryenBinary'](module, Module['MulFloat32'], left, right); |
| }, |
| 'div': function(left, right) { |
| return Module['_BinaryenBinary'](module, Module['DivFloat32'], left, right); |
| }, |
| 'copysign': function(left, right) { |
| return Module['_BinaryenBinary'](module, Module['CopySignFloat32'], left, right); |
| }, |
| 'min': function(left, right) { |
| return Module['_BinaryenBinary'](module, Module['MinFloat32'], left, right); |
| }, |
| 'max': function(left, right) { |
| return Module['_BinaryenBinary'](module, Module['MaxFloat32'], left, right); |
| }, |
| 'eq': function(left, right) { |
| return Module['_BinaryenBinary'](module, Module['EqFloat32'], left, right); |
| }, |
| 'ne': function(left, right) { |
| return Module['_BinaryenBinary'](module, Module['NeFloat32'], left, right); |
| }, |
| 'lt': function(left, right) { |
| return Module['_BinaryenBinary'](module, Module['LtFloat32'], left, right); |
| }, |
| 'le': function(left, right) { |
| return Module['_BinaryenBinary'](module, Module['LeFloat32'], left, right); |
| }, |
| 'gt': function(left, right) { |
| return Module['_BinaryenBinary'](module, Module['GtFloat32'], left, right); |
| }, |
| 'ge': function(left, right) { |
| return Module['_BinaryenBinary'](module, Module['GeFloat32'], left, right); |
| }, |
| }; |
| |
| this['f64'] = { |
| 'load': function(offset, align, ptr) { |
| return Module['_BinaryenLoad'](module, 8, true, offset, align, Module['f64'], ptr); |
| }, |
| 'store': function(offset, align, ptr, value) { |
| return Module['_BinaryenStore'](module, 8, offset, align, ptr, value, Module['f64']); |
| }, |
| 'const': function(x) { |
| Module['_BinaryenLiteralFloat64'](literal, x); |
| return Module['_BinaryenConst'](module, literal); |
| }, |
| 'const_bits': function(x, y) { |
| Module['_BinaryenLiteralFloat64Bits'](literal, x, y); |
| return Module['_BinaryenConst'](module, literal); |
| }, |
| 'neg': function(value) { |
| return Module['_BinaryenUnary'](module, Module['NegFloat64'], value); |
| }, |
| 'abs': function(value) { |
| return Module['_BinaryenUnary'](module, Module['AbsFloat64'], value); |
| }, |
| 'ceil': function(value) { |
| return Module['_BinaryenUnary'](module, Module['CeilFloat64'], value); |
| }, |
| 'floor': function(value) { |
| return Module['_BinaryenUnary'](module, Module['FloorFloat64'], value); |
| }, |
| 'trunc': function(value) { |
| return Module['_BinaryenUnary'](module, Module['TruncFloat64'], value); |
| }, |
| 'nearest': function(value) { |
| return Module['_BinaryenUnary'](module, Module['NearestFloat64'], value); |
| }, |
| 'sqrt': function(value) { |
| return Module['_BinaryenUnary'](module, Module['SqrtFloat64'], value); |
| }, |
| 'reinterpret': function(value) { |
| return Module['_BinaryenUnary'](module, Module['ReinterpretInt64'], value); |
| }, |
| 'convert_s': { |
| 'i32': function(value) { |
| return Module['_BinaryenUnary'](module, Module['ConvertSInt32ToFloat64'], value); |
| }, |
| 'i64': function(value) { |
| return Module['_BinaryenUnary'](module, Module['ConvertSInt64ToFloat64'], value); |
| }, |
| }, |
| 'convert_u': { |
| 'i32': function(value) { |
| return Module['_BinaryenUnary'](module, Module['ConvertUInt32ToFloat64'], value); |
| }, |
| 'i64': function(value) { |
| return Module['_BinaryenUnary'](module, Module['ConvertUInt64ToFloat64'], value); |
| }, |
| }, |
| 'promote': function(value) { |
| return Module['_BinaryenUnary'](module, Module['PromoteFloat32'], value); |
| }, |
| 'add': function(left, right) { |
| return Module['_BinaryenBinary'](module, Module['AddFloat64'], left, right); |
| }, |
| 'sub': function(left, right) { |
| return Module['_BinaryenBinary'](module, Module['SubFloat64'], left, right); |
| }, |
| 'mul': function(left, right) { |
| return Module['_BinaryenBinary'](module, Module['MulFloat64'], left, right); |
| }, |
| 'div': function(left, right) { |
| return Module['_BinaryenBinary'](module, Module['DivFloat64'], left, right); |
| }, |
| 'copysign': function(left, right) { |
| return Module['_BinaryenBinary'](module, Module['CopySignFloat64'], left, right); |
| }, |
| 'min': function(left, right) { |
| return Module['_BinaryenBinary'](module, Module['MinFloat64'], left, right); |
| }, |
| 'max': function(left, right) { |
| return Module['_BinaryenBinary'](module, Module['MaxFloat64'], left, right); |
| }, |
| 'eq': function(left, right) { |
| return Module['_BinaryenBinary'](module, Module['EqFloat64'], left, right); |
| }, |
| 'ne': function(left, right) { |
| return Module['_BinaryenBinary'](module, Module['NeFloat64'], left, right); |
| }, |
| 'lt': function(left, right) { |
| return Module['_BinaryenBinary'](module, Module['LtFloat64'], left, right); |
| }, |
| 'le': function(left, right) { |
| return Module['_BinaryenBinary'](module, Module['LeFloat64'], left, right); |
| }, |
| 'gt': function(left, right) { |
| return Module['_BinaryenBinary'](module, Module['GtFloat64'], left, right); |
| }, |
| 'ge': function(left, right) { |
| return Module['_BinaryenBinary'](module, Module['GeFloat64'], left, right); |
| }, |
| }; |
| |
| this['select'] = function(condition, ifTrue, ifFalse) { |
| return Module['_BinaryenSelect'](module, condition, ifTrue, ifFalse); |
| }; |
| this['drop'] = function(value) { |
| return Module['_BinaryenDrop'](module, value); |
| }; |
| this['return'] = function(value) { |
| return Module['_BinaryenReturn'](module, value); |
| }; |
| this['host'] = function() { |
| throw 'TODO'; |
| }; |
| this['nop'] = function() { |
| return Module['_BinaryenNop'](module); |
| }; |
| this['unreachable'] = function() { |
| return Module['_BinaryenUnreachable'](module); |
| }; |
| this['addFunction'] = function(name, functionType, varTypes, body) { |
| return preserveStack(function() { |
| return Module['_BinaryenAddFunction'](module, strToStack(name), functionType, i32sToStack(varTypes), varTypes.length, body); |
| }); |
| }; |
| this['addImport'] = function(internalName, externalModuleName, externalBaseName, type) { |
| return preserveStack(function() { |
| return Module['_BinaryenAddImport'](module, strToStack(internalName), strToStack(externalModuleName), strToStack(externalBaseName), type); |
| }); |
| }; |
| this['addExport'] = function(internalName, externalName) { |
| return preserveStack(function() { |
| return Module['_BinaryenAddExport'](module, strToStack(internalName), strToStack(externalName)); |
| }); |
| }; |
| this['setFunctionTable'] = function(funcs) { |
| return preserveStack(function() { |
| return Module['_BinaryenSetFunctionTable'](module, i32sToStack(funcs), funcs.length); |
| }); |
| }; |
| this['setMemory'] = function(initial, maximum, exportName, segments) { |
| // segments are assumed to be { offset: expression ref, data: array of 8-bit data } |
| return preserveStack(function() { |
| return Module['_BinaryenSetMemory']( |
| module, initial, maximum, strToStack(exportName), |
| i32sToStack( |
| segments.map(function(segment) { |
| return allocate(segment.data, 'i8', ALLOC_STACK); |
| }) |
| ), |
| i32sToStack( |
| segments.map(function(segment) { |
| return segment.offset; |
| }) |
| ), |
| i32sToStack( |
| segments.map(function(segment) { |
| return segment.data.length; |
| }) |
| ), |
| segments.length |
| ); |
| }); |
| }; |
| this['setStart'] = function(start) { |
| return Module['_BinaryenSetStart'](module, start); |
| }; |
| this['emitText'] = function() { |
| var old = Module['print']; |
| var ret = ''; |
| Module['print'] = function(x) { ret += x + '\n' }; |
| Module['_BinaryenModulePrint'](module); |
| Module['print'] = old; |
| return ret; |
| }; |
| this['validate'] = function() { |
| return Module['_BinaryenModuleValidate'](module); |
| }; |
| this['optimize'] = function() { |
| return Module['_BinaryenModuleOptimize'](module); |
| }; |
| this['autoDrop'] = function() { |
| return Module['_BinaryenModuleAutoDrop'](module); |
| }; |
| |
| // TODO: fix this hard-wired limit |
| var MAX = 1024*1024; |
| var writeBuffer = null; |
| this['emitBinary'] = function() { |
| if (!writeBuffer) writeBuffer = _malloc(MAX); |
| var bytes = Module['_BinaryenModuleWrite'](module, writeBuffer, MAX); |
| assert(bytes < MAX, 'FIXME: hardcoded limit on module size'); // we should not use the whole buffer |
| return new Uint8Array(HEAPU8.subarray(writeBuffer, writeBuffer + bytes)); |
| }; |
| this['interpret'] = function() { |
| return Module['_BinaryenModuleInterpret'](module); |
| }; |
| }; |
| |
| Module['Relooper'] = function() { |
| var relooper = this.ptr = Module['_RelooperCreate'](); |
| |
| this['addBlock'] = function(code) { |
| return Module['_RelooperAddBlock'](relooper, code); |
| }; |
| this['addBranch'] = function(from, to, condition, code) { |
| return Module['_RelooperAddBranch'](from, to, condition, code); |
| }; |
| this['addBlockWithSwitch'] = function(code, condition) { |
| return Module['_RelooperAddBlockWithSwitch'](relooper, code, condition); |
| }; |
| this['addBranchForSwitch'] = function(from, to, indexes, code) { |
| return preserveStack(function() { |
| return Module['_RelooperAddBranchForSwitch'](from, to, i32sToStack(indexes), indexes.length, code); |
| }); |
| }; |
| this['renderAndDispose'] = function(entry, labelHelper, module) { |
| return Module['_RelooperRenderAndDispose'](relooper, entry, labelHelper, module['ptr']); |
| }; |
| }; |
| |
| // emit text of an expression or a module |
| Module['emitText'] = function(expr) { |
| if (typeof expr === 'object') { |
| return expr.emitText(); |
| } |
| var old = Module['print']; |
| var ret = ''; |
| Module['print'] = function(x) { ret += x + '\n' }; |
| Module['_BinaryenExpressionPrint'](expr); |
| Module['print'] = old; |
| return ret; |
| }; |
| |
| Module['readBinary'] = function(data) { |
| var buffer = allocate(data, 'i8', ALLOC_NORMAL); |
| var ptr = Module['_BinaryenModuleRead'](buffer, data.length); |
| _free(buffer); |
| return new Module['Module'](ptr); |
| }; |
| |
| Module['setAPITracing'] = function(on) { |
| return Module['_BinaryenSetAPITracing'](on); |
| }; |
| |
| return Module; |
| }; |
| |
| if (typeof exports != 'undefined') { |
| (function(){ |
| var a = Binaryen(); |
| if (typeof module === 'object') { |
| module.exports = a; |
| } else { |
| for (var k in a) { |
| exports[k] = a[k]; |
| } |
| } |
| })(); |
| } |
| (typeof window !== 'undefined' ? window : |
| typeof global !== 'undefined' && ( |
| typeof process === 'undefined' || |
| |
| // Note: We must export "Binaryen" even inside a CommonJS/AMD/UMD module |
| // space because check.py generates a.js which requires Binaryen global var |
| ( process.argv && |
| Array.isArray(process.argv) && |
| process.argv[1] && |
| (process.argv[1].substr(-5) === '/a.js' || |
| process.argv[1].substr(-5) === '\\a.js') |
| ) |
| |
| ) ? global : |
| this |
| )['Binaryen'] = Binaryen(); |
