| // Copyright 2015 the V8 project authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| // Flags: --expose-wasm --experimental-wasm-eh |
| |
| load("test/mjsunit/wasm/wasm-constants.js"); |
| load("test/mjsunit/wasm/wasm-module-builder.js"); |
| |
| // The following method doesn't attempt to catch an raised exception. |
| var test_throw = (function () { |
| var builder = new WasmModuleBuilder(); |
| |
| builder.addException(kSig_v_v); |
| |
| builder.addFunction("throw_if_param_not_zero", kSig_i_i) |
| .addBody([ |
| kExprGetLocal, 0, |
| kExprI32Const, 0, |
| kExprI32Ne, |
| kExprIf, kWasmStmt, |
| kExprThrow, 0, |
| kExprEnd, |
| kExprI32Const, 1 |
| ]).exportFunc(); |
| |
| return builder.instantiate(); |
| })(); |
| |
| // Check the test_throw exists. |
| assertFalse(test_throw === undefined); |
| assertFalse(test_throw === null); |
| assertFalse(test_throw === 0); |
| assertEquals("object", typeof test_throw.exports); |
| assertEquals("function", typeof test_throw.exports.throw_if_param_not_zero); |
| |
| // Test expected behavior of throws |
| assertEquals(1, test_throw.exports.throw_if_param_not_zero(0)); |
| assertWasmThrows(0, [], function() { test_throw.exports.throw_if_param_not_zero(10) }); |
| assertWasmThrows(0, [], function() { test_throw.exports.throw_if_param_not_zero(-1) }); |
| |
| // Now that we know throwing works, we test catching the exceptions we raise. |
| var test_catch = (function () { |
| var builder = new WasmModuleBuilder(); |
| |
| builder.addException(kSig_v_v); |
| builder.addFunction("simple_throw_catch_to_0_1", kSig_i_i) |
| .addBody([ |
| kExprTry, kWasmI32, |
| kExprGetLocal, 0, |
| kExprI32Eqz, |
| kExprIf, kWasmStmt, |
| kExprThrow, 0, |
| kExprEnd, |
| kExprI32Const, 1, |
| kExprCatch, 0, |
| kExprI32Const, 0, |
| kExprEnd |
| ]).exportFunc(); |
| |
| return builder.instantiate(); |
| })(); |
| |
| // Check the test_catch exists. |
| assertFalse(test_catch === undefined); |
| assertFalse(test_catch === null); |
| assertFalse(test_catch === 0); |
| assertEquals("object", typeof test_catch.exports); |
| assertEquals("function", typeof test_catch.exports.simple_throw_catch_to_0_1); |
| |
| // Test expected behavior of simple catch. |
| assertEquals(0, test_catch.exports.simple_throw_catch_to_0_1(0)); |
| assertEquals(1, test_catch.exports.simple_throw_catch_to_0_1(1)); |
| |
| // Test that we can distinguish which exception was thrown. |
| var test_catch_2 = (function () { |
| var builder = new WasmModuleBuilder(); |
| |
| builder.addException(kSig_v_v); |
| builder.addException(kSig_v_v); |
| builder.addException(kSig_v_v); |
| builder.addFunction("catch_different_exceptions", kSig_i_i) |
| .addBody([ |
| kExprTry, kWasmI32, |
| kExprTry, kWasmI32, |
| kExprGetLocal, 0, |
| kExprI32Eqz, |
| kExprIf, kWasmStmt, |
| kExprThrow, 0, |
| kExprElse, |
| kExprGetLocal, 0, |
| kExprI32Const, 1, |
| kExprI32Eq, |
| kExprIf, kWasmStmt, |
| kExprThrow, 1, |
| kExprElse, |
| kExprThrow, 2, |
| kExprEnd, |
| kExprEnd, |
| kExprI32Const, 2, |
| kExprCatch, 0, |
| kExprI32Const, 3, |
| kExprEnd, |
| kExprCatch, 1, |
| kExprI32Const, 4, |
| kExprEnd |
| ]).exportFunc(); |
| return builder.instantiate(); |
| })(); |
| |
| assertFalse(test_catch_2 === undefined); |
| assertFalse(test_catch_2 === null); |
| assertFalse(test_catch_2 === 0); |
| assertEquals("object", typeof test_catch_2.exports); |
| assertEquals("function", typeof test_catch_2.exports.catch_different_exceptions); |
| |
| assertEquals(3, test_catch_2.exports.catch_different_exceptions(0)); |
| assertEquals(4, test_catch_2.exports.catch_different_exceptions(1)); |
| assertWasmThrows(2, [], function() { test_catch_2.exports.catch_different_exceptions(2) }); |
| |
| // Test throwing an exception with multiple values. |
| var test_throw_1_2 = (function() { |
| var builder = new WasmModuleBuilder(); |
| builder.addException(kSig_v_ii); |
| builder.addFunction("throw_1_2", kSig_v_v) |
| .addBody([ |
| kExprI32Const, 1, |
| kExprI32Const, 2, |
| kExprThrow, 0, |
| ]).exportFunc(); |
| |
| return builder.instantiate(); |
| })(); |
| |
| assertFalse(test_throw_1_2 === undefined); |
| assertFalse(test_throw_1_2 === null); |
| assertFalse(test_throw_1_2 === 0); |
| assertEquals("object", typeof test_throw_1_2.exports); |
| assertEquals("function", typeof test_throw_1_2.exports.throw_1_2); |
| |
| assertWasmThrows(0, [0, 1, 0, 2], function() { test_throw_1_2.exports.throw_1_2(); }); |
| |
| // Test throwing/catching the i32 parameter value. |
| var test_throw_catch_param_i = (function () { |
| var builder = new WasmModuleBuilder(); |
| builder.addException(kSig_v_i); |
| builder.addFunction("throw_catch_param", kSig_i_i) |
| .addBody([ |
| kExprTry, kWasmI32, |
| kExprGetLocal, 0, |
| kExprThrow, 0, |
| kExprI32Const, 2, |
| kExprCatch, 0, |
| kExprReturn, |
| kExprEnd, |
| ]).exportFunc(); |
| |
| return builder.instantiate(); |
| })(); |
| |
| assertFalse(test_throw_catch_param_i === undefined); |
| assertFalse(test_throw_catch_param_i === null); |
| assertFalse(test_throw_catch_param_i === 0); |
| assertEquals("object", typeof test_throw_catch_param_i.exports); |
| assertEquals("function", |
| typeof test_throw_catch_param_i.exports.throw_catch_param); |
| |
| assertEquals(0, test_throw_catch_param_i.exports.throw_catch_param(0)); |
| assertEquals(1, test_throw_catch_param_i.exports.throw_catch_param(1)); |
| assertEquals(10, test_throw_catch_param_i.exports.throw_catch_param(10)); |
| |
| // Test the encoding of a thrown exception with an integer exception. |
| |
| var test_throw_param_i = (function () { |
| var builder = new WasmModuleBuilder(); |
| builder.addException(kSig_v_i); |
| builder.addFunction("throw_param", kSig_v_i) |
| .addBody([ |
| kExprGetLocal, 0, |
| kExprThrow, 0, |
| ]).exportFunc(); |
| |
| return builder.instantiate(); |
| })(); |
| |
| assertFalse(test_throw_param_i === undefined); |
| assertFalse(test_throw_param_i === null); |
| assertFalse(test_throw_param_i === 0); |
| assertEquals("object", typeof test_throw_param_i.exports); |
| assertEquals("function", |
| typeof test_throw_param_i.exports.throw_param); |
| |
| assertWasmThrows(0, [0, 5], function() { test_throw_param_i.exports.throw_param(5); }); |
| assertWasmThrows(0, [6, 31026], |
| function() { test_throw_param_i.exports.throw_param(424242); }); |
| |
| // Test throwing/catching the f32 parameter value. |
| var test_throw_catch_param_f = (function () { |
| var builder = new WasmModuleBuilder(); |
| builder.addException(kSig_v_f); |
| builder.addFunction("throw_catch_param", kSig_f_f) |
| .addBody([ |
| kExprTry, kWasmF32, |
| kExprGetLocal, 0, |
| kExprThrow, 0, |
| kExprF32Const, 0, 0, 0, 0, |
| kExprCatch, 0, |
| kExprReturn, |
| kExprEnd, |
| ]).exportFunc(); |
| |
| return builder.instantiate(); |
| })(); |
| |
| assertFalse(test_throw_catch_param_f === undefined); |
| assertFalse(test_throw_catch_param_f === null); |
| assertFalse(test_throw_catch_param_f === 0); |
| assertEquals("object", typeof test_throw_catch_param_f.exports); |
| assertEquals("function", |
| typeof test_throw_catch_param_f.exports.throw_catch_param); |
| |
| assertEquals(5.0, test_throw_catch_param_f.exports.throw_catch_param(5.0)); |
| assertEquals(10.5, test_throw_catch_param_f.exports.throw_catch_param(10.5)); |
| |
| // Test the encoding of a thrown exception with a float value. |
| |
| var test_throw_param_f = (function () { |
| var builder = new WasmModuleBuilder(); |
| builder.addException(kSig_v_f); |
| builder.addFunction("throw_param", kSig_v_f) |
| .addBody([ |
| kExprGetLocal, 0, |
| kExprThrow, 0, |
| ]).exportFunc(); |
| |
| return builder.instantiate(); |
| })(); |
| |
| assertFalse(test_throw_param_f === undefined); |
| assertFalse(test_throw_param_f === null); |
| assertFalse(test_throw_param_f === 0); |
| assertEquals("object", typeof test_throw_param_f.exports); |
| assertEquals("function", |
| typeof test_throw_param_f.exports.throw_param); |
| |
| assertWasmThrows(0, [16544, 0], |
| function() { test_throw_param_f.exports.throw_param(5.0); }); |
| assertWasmThrows(0, [16680, 0], |
| function() { test_throw_param_f.exports.throw_param(10.5); }); |
| |
| // Test throwing/catching an I64 value |
| var test_throw_catch_param_l = (function () { |
| var builder = new WasmModuleBuilder(); |
| builder.addException(kSig_v_l); |
| builder.addFunction("throw_catch_param", kSig_i_i) |
| .addBody([ |
| kExprGetLocal, 0, |
| kExprI64UConvertI32, |
| kExprSetLocal, 1, |
| kExprTry, kWasmI32, |
| kExprGetLocal, 1, |
| kExprThrow, 0, |
| kExprI32Const, 2, |
| kExprCatch, 0, |
| kExprGetLocal, 1, |
| kExprI64Eq, |
| kExprIf, kWasmI32, |
| kExprI32Const, 1, |
| kExprElse, |
| kExprI32Const, 0, |
| kExprEnd, |
| // TODO(kschimpf): Why is this return necessary? |
| kExprReturn, |
| kExprEnd, |
| ]).addLocals({i64_count: 1}).exportFunc(); |
| |
| return builder.instantiate(); |
| })(); |
| |
| assertFalse(test_throw_catch_param_l === undefined); |
| assertFalse(test_throw_catch_param_l === null); |
| assertFalse(test_throw_catch_param_l === 0); |
| assertEquals("object", typeof test_throw_catch_param_l.exports); |
| assertEquals("function", |
| typeof test_throw_catch_param_l.exports.throw_catch_param); |
| |
| assertEquals(1, test_throw_catch_param_l.exports.throw_catch_param(5)); |
| assertEquals(1, test_throw_catch_param_l.exports.throw_catch_param(0)); |
| assertEquals(1, test_throw_catch_param_l.exports.throw_catch_param(-1)); |
| |
| // Test the encoding of a thrown exception with an I64 value. |
| |
| var test_throw_param_l = (function () { |
| var builder = new WasmModuleBuilder(); |
| builder.addException(kSig_v_l); |
| builder.addFunction("throw_param", kSig_v_ii) |
| .addBody([ |
| kExprGetLocal, 0, |
| kExprI64UConvertI32, |
| kExprI64Const, 32, |
| kExprI64Shl, |
| kExprGetLocal, 1, |
| kExprI64UConvertI32, |
| kExprI64Ior, |
| kExprThrow, 0 |
| ]).exportFunc(); |
| |
| return builder.instantiate(); |
| })(); |
| |
| assertFalse(test_throw_param_l === undefined); |
| assertFalse(test_throw_param_l === null); |
| assertFalse(test_throw_param_l === 0); |
| assertEquals("object", typeof test_throw_param_l.exports); |
| assertEquals("function", |
| typeof test_throw_param_l.exports.throw_param); |
| |
| assertWasmThrows(0, [0, 10, 0, 5], |
| function() { test_throw_param_l.exports.throw_param(10, 5); }); |
| assertWasmThrows(0, [65535, 65535, 0, 13], |
| function() { test_throw_param_l.exports.throw_param(-1, 13); }); |
| |
| // Test throwing/catching the F64 parameter value |
| var test_throw_catch_param_d = (function () { |
| var builder = new WasmModuleBuilder(); |
| builder.addException(kSig_v_d); |
| builder.addFunction("throw_catch_param", kSig_d_d) |
| .addBody([ |
| kExprTry, kWasmF64, |
| kExprGetLocal, 0, |
| kExprThrow, 0, |
| kExprF64Const, 0, 0, 0, 0, 0, 0, 0, 0, |
| kExprCatch, 0, |
| kExprReturn, |
| kExprEnd, |
| ]).exportFunc(); |
| |
| return builder.instantiate(); |
| })(); |
| |
| assertFalse(test_throw_catch_param_d === undefined); |
| assertFalse(test_throw_catch_param_d === null); |
| assertFalse(test_throw_catch_param_d === 0); |
| assertEquals("object", typeof test_throw_catch_param_d.exports); |
| assertEquals("function", |
| typeof test_throw_catch_param_d.exports.throw_catch_param); |
| |
| assertEquals(5.0, test_throw_catch_param_d.exports.throw_catch_param(5.0)); |
| assertEquals(10.5, test_throw_catch_param_d.exports.throw_catch_param(10.5)); |
| |
| // Test the encoding of a thrown exception with an f64 value. |
| |
| var test_throw_param_d = (function () { |
| var builder = new WasmModuleBuilder(); |
| builder.addException(kSig_v_d); |
| builder.addFunction("throw_param", kSig_v_f) |
| .addBody([ |
| kExprGetLocal, 0, |
| kExprF64ConvertF32, |
| kExprThrow, 0 |
| ]).exportFunc(); |
| |
| return builder.instantiate(); |
| })(); |
| |
| assertFalse(test_throw_param_d === undefined); |
| assertFalse(test_throw_param_d === null); |
| assertFalse(test_throw_param_d === 0); |
| assertEquals("object", typeof test_throw_param_d.exports); |
| assertEquals("function", |
| typeof test_throw_param_d.exports.throw_param); |
| |
| assertWasmThrows(0, [16404, 0, 0, 0], |
| function() { test_throw_param_d.exports.throw_param(5.0); }); |
| assertWasmThrows(0, [16739, 4816, 0, 0], |
| function() { test_throw_param_d.exports.throw_param(10000000.5); }); |
| |
| /* TODO(kschimpf) Convert these tests to work for the proposed exceptions. |
| |
| // The following methods do not attempt to catch the exception they raise. |
| var test_throw = (function () { |
| var builder = new WasmModuleBuilder(); |
| |
| builder.addFunction("throw_expr_with_params", kSig_v_ddi) |
| .addBody([ |
| // p2 * (p0 + min(p0, p1))|0 - 20 |
| kExprGetLocal, 2, |
| kExprGetLocal, 0, |
| kExprGetLocal, 0, |
| kExprGetLocal, 1, |
| kExprF64Min, |
| kExprF64Add, |
| kExprI32SConvertF64, |
| kExprI32Mul, |
| kExprI32Const, 20, |
| kExprI32Sub, |
| kExprThrow, |
| ]) |
| .exportFunc() |
| |
| return builder.instantiate(); |
| })(); |
| |
| // Check the test_throw exists. |
| assertFalse(test_throw === undefined); |
| assertFalse(test_throw === null); |
| assertFalse(test_throw === 0); |
| assertEquals("object", typeof test_throw.exports); |
| assertEquals("function", typeof test_throw.exports.throw_expr_with_params); |
| |
| assertEquals(1, test_throw.exports.throw_param_if_not_zero(0)); |
| assertWasmThrows( |
| -8, function() { test_throw.exports.throw_expr_with_params(1.5, 2.5, 4); }); |
| assertWasmThrows( |
| 12, function() { test_throw.exports.throw_expr_with_params(5.7, 2.5, 4); }); |
| |
| // Now that we know throwing works, we test catching the exceptions we raise. |
| var test_catch = (function () { |
| var builder = new WasmModuleBuilder(); |
| |
| // Helper function for throwing from js. It is imported by the Wasm module |
| // as throw_i. |
| function throw_value(value) { |
| throw value; |
| } |
| var sig_index = builder.addType(kSig_v_i); |
| var kJSThrowI = builder.addImport("", "throw_i", sig_index); |
| |
| // Helper function that throws a string. Wasm should not catch it. |
| function throw_string() { |
| throw "use wasm;"; |
| } |
| sig_index = builder.addType(kSig_v_v); |
| var kJSThrowString = builder.addImport("", "throw_string", sig_index); |
| |
| // Helper function that throws undefined. Wasm should not catch it. |
| function throw_undefined() { |
| throw undefined; |
| } |
| var kJSThrowUndefined = builder.addImport("", "throw_undefined", sig_index); |
| |
| // Helper function that throws an fp. Wasm should not catch it. |
| function throw_fp() { |
| throw 10.5; |
| } |
| var kJSThrowFP = builder.addImport("", "throw_fp", sig_index); |
| |
| // Helper function that throws a large number. Wasm should not catch it. |
| function throw_large() { |
| throw 1e+28; |
| } |
| var kJSThrowLarge = builder.addImport("", "throw_large", sig_index); |
| |
| // Helper function for throwing from WebAssembly. |
| var kWasmThrowFunction = |
| builder.addFunction("throw", kSig_v_i) |
| .addBody([ |
| kExprGetLocal, 0, |
| kExprThrow |
| ]) |
| .index; |
| |
| // Scenario 1: Throw and catch appear on the same function. This should |
| // happen in case of inlining, for example. |
| builder.addFunction("same_scope", kSig_i_i) |
| .addBody([ |
| kExprTry, kWasmI32, |
| kExprGetLocal, 0, |
| kExprI32Const, 0, |
| kExprI32Ne, |
| kExprIf, kWasmStmt, |
| kExprGetLocal, 0, |
| kExprThrow, |
| kExprUnreachable, |
| kExprEnd, |
| kExprI32Const, 63, |
| kExprCatch, 1, |
| kExprGetLocal, 1, |
| kExprEnd |
| ]) |
| .addLocals({i32_count: 1}) |
| .exportFunc() |
| .index; |
| |
| builder.addFunction("same_scope_ignore", kSig_i_i) |
| .addBody([ |
| kExprTry, kWasmI32, |
| kExprGetLocal, 0, |
| kExprThrow, |
| kExprUnreachable, |
| kExprCatch, 1, |
| kExprGetLocal, 0, |
| kExprEnd, |
| ]) |
| .addLocals({i32_count: 1}) |
| .exportFunc(); |
| |
| builder.addFunction("same_scope_multiple", kSig_i_i) |
| // path = 0; |
| // |
| // try { |
| // try { |
| // try { |
| // if (p == 1) |
| // throw 1; |
| // path |= 2 |
| // } catch (v) { |
| // path |= v | 4; |
| // throw path; |
| // } |
| // if (p == 2) |
| // throw path|8; |
| // path |= 16; |
| // } catch (v) { |
| // path |= v | 32; |
| // throw path; |
| // } |
| // if (p == 3) |
| // throw path|64; |
| // path |= 128 |
| // } catch (v) { |
| // path |= v | 256; |
| // } |
| // |
| // return path; |
| // |
| // p == 1 -> path == 293 |
| // p == 2 -> path == 298 |
| // p == 3 -> path == 338 |
| // else -> path == 146 |
| .addBody([ |
| kExprTry, kWasmI32, |
| kExprTry, kWasmI32, |
| kExprTry, kWasmI32, |
| kExprGetLocal, 0, |
| kExprI32Const, 1, |
| kExprI32Eq, |
| kExprIf, kWasmStmt, |
| kExprI32Const, 1, |
| kExprThrow, |
| kExprUnreachable, |
| kExprEnd, |
| kExprI32Const, 2, |
| kExprCatch, 1, |
| kExprGetLocal, 1, |
| kExprI32Const, 4, |
| kExprI32Ior, |
| kExprThrow, |
| kExprUnreachable, |
| kExprEnd, |
| kExprTeeLocal, 2, |
| kExprGetLocal, 0, |
| kExprI32Const, 2, |
| kExprI32Eq, |
| kExprIf, kWasmStmt, |
| kExprGetLocal, 2, |
| kExprI32Const, 8, |
| kExprI32Ior, |
| kExprThrow, |
| kExprUnreachable, |
| kExprEnd, |
| kExprI32Const, 16, |
| kExprI32Ior, |
| kExprCatch, 1, |
| kExprGetLocal, 1, |
| kExprI32Const, 32, |
| kExprI32Ior, |
| kExprThrow, |
| kExprUnreachable, |
| kExprEnd, |
| kExprTeeLocal, 2, |
| kExprGetLocal, 0, |
| kExprI32Const, 3, |
| kExprI32Eq, |
| kExprIf, kWasmStmt, |
| kExprGetLocal, 2, |
| kExprI32Const, / *64=* / 192, 0, |
| kExprI32Ior, |
| kExprThrow, |
| kExprUnreachable, |
| kExprEnd, |
| kExprI32Const, / *128=* / 128, 1, |
| kExprI32Ior, |
| kExprCatch, 1, |
| kExprGetLocal, 1, |
| kExprI32Const, / *256=* / 128, 2, |
| kExprI32Ior, |
| kExprEnd, |
| ]) |
| .addLocals({i32_count: 2}) |
| .exportFunc(); |
| |
| // Scenario 2: Catches an exception raised from the direct callee. |
| var kFromDirectCallee = |
| builder.addFunction("from_direct_callee", kSig_i_i) |
| .addBody([ |
| kExprTry, kWasmI32, |
| kExprGetLocal, 0, |
| kExprCallFunction, kWasmThrowFunction, |
| kExprI32Const, / *-1=* / 127, |
| kExprCatch, 1, |
| kExprGetLocal, 1, |
| kExprEnd |
| ]) |
| .addLocals({i32_count: 1}) |
| .exportFunc() |
| .index; |
| |
| // Scenario 3: Catches an exception raised from an indirect callee. |
| var kFromIndirectCalleeHelper = kFromDirectCallee + 1; |
| builder.addFunction("from_indirect_callee_helper", kSig_v_ii) |
| .addBody([ |
| kExprGetLocal, 0, |
| kExprI32Const, 0, |
| kExprI32GtS, |
| kExprIf, kWasmStmt, |
| kExprGetLocal, 0, |
| kExprI32Const, 1, |
| kExprI32Sub, |
| kExprGetLocal, 1, |
| kExprI32Const, 1, |
| kExprI32Sub, |
| kExprCallFunction, kFromIndirectCalleeHelper, |
| kExprEnd, |
| kExprGetLocal, 1, |
| kExprCallFunction, kWasmThrowFunction, |
| ]); |
| |
| builder.addFunction("from_indirect_callee", kSig_i_i) |
| .addBody([ |
| kExprTry, kWasmI32, |
| kExprGetLocal, 0, |
| kExprI32Const, 0, |
| kExprCallFunction, kFromIndirectCalleeHelper, |
| kExprI32Const, / *-1=* / 127, |
| kExprCatch, 1, |
| kExprGetLocal, 1, |
| kExprEnd |
| ]) |
| .addLocals({i32_count: 1}) |
| .exportFunc(); |
| |
| // Scenario 4: Catches an exception raised in JS. |
| builder.addFunction("from_js", kSig_i_i) |
| .addBody([ |
| kExprTry, kWasmI32, |
| kExprGetLocal, 0, |
| kExprCallFunction, kJSThrowI, |
| kExprI32Const, / *-1=* / 127, |
| kExprCatch, 1, |
| kExprGetLocal, 1, |
| kExprEnd, |
| ]) |
| .addLocals({i32_count: 1}) |
| .exportFunc(); |
| |
| // Scenario 5: Does not catch an exception raised in JS if it is not a |
| // number. |
| builder.addFunction("string_from_js", kSig_v_v) |
| .addBody([ |
| kExprCallFunction, kJSThrowString |
| ]) |
| .exportFunc(); |
| |
| builder.addFunction("fp_from_js", kSig_v_v) |
| .addBody([ |
| kExprCallFunction, kJSThrowFP |
| ]) |
| .exportFunc(); |
| |
| builder.addFunction("large_from_js", kSig_v_v) |
| .addBody([ |
| kExprCallFunction, kJSThrowLarge |
| ]) |
| .exportFunc(); |
| |
| builder.addFunction("undefined_from_js", kSig_v_v) |
| .addBody([ |
| kExprCallFunction, kJSThrowUndefined |
| ]) |
| .exportFunc(); |
| |
| return builder.instantiate({"": { |
| throw_i: throw_value, |
| throw_string: throw_string, |
| throw_fp: throw_fp, |
| throw_large, throw_large, |
| throw_undefined: throw_undefined |
| }}); |
| })(); |
| |
| // Check the test_catch exists. |
| assertFalse(test_catch === undefined); |
| assertFalse(test_catch === null); |
| assertFalse(test_catch === 0); |
| assertEquals("object", typeof test_catch.exports); |
| assertEquals("function", typeof test_catch.exports.same_scope); |
| assertEquals("function", typeof test_catch.exports.same_scope_ignore); |
| assertEquals("function", typeof test_catch.exports.same_scope_multiple); |
| assertEquals("function", typeof test_catch.exports.from_direct_callee); |
| assertEquals("function", typeof test_catch.exports.from_indirect_callee); |
| assertEquals("function", typeof test_catch.exports.from_js); |
| assertEquals("function", typeof test_catch.exports.string_from_js); |
| |
| assertEquals(63, test_catch.exports.same_scope(0)); |
| assertEquals(1024, test_catch.exports.same_scope(1024)); |
| assertEquals(-3, test_catch.exports.same_scope(-3)); |
| assertEquals(-1, test_catch.exports.same_scope_ignore(-1)); |
| assertEquals(1, test_catch.exports.same_scope_ignore(1)); |
| assertEquals(0x7FFFFFFF, test_catch.exports.same_scope_ignore(0x7FFFFFFF)); |
| assertEquals(1024, test_catch.exports.same_scope_ignore(1024)); |
| assertEquals(-1, test_catch.exports.same_scope_ignore(-1)); |
| assertEquals(293, test_catch.exports.same_scope_multiple(1)); |
| assertEquals(298, test_catch.exports.same_scope_multiple(2)); |
| assertEquals(338, test_catch.exports.same_scope_multiple(3)); |
| assertEquals(146, test_catch.exports.same_scope_multiple(0)); |
| assertEquals(-10024, test_catch.exports.from_direct_callee(-10024)); |
| assertEquals(3334333, test_catch.exports.from_direct_callee(3334333)); |
| assertEquals(-1, test_catch.exports.from_direct_callee(0xFFFFFFFF)); |
| assertEquals(0x7FFFFFFF, test_catch.exports.from_direct_callee(0x7FFFFFFF)); |
| assertEquals(-10, test_catch.exports.from_indirect_callee(10)); |
| assertEquals(-77, test_catch.exports.from_indirect_callee(77)); |
| assertEquals(10, test_catch.exports.from_js(10)); |
| assertEquals(-10, test_catch.exports.from_js(-10)); |
| |
| assertThrowsEquals(test_catch.exports.string_from_js, "use wasm;"); |
| assertThrowsEquals(test_catch.exports.large_from_js, 1e+28); |
| assertThrowsEquals(test_catch.exports.undefined_from_js, undefined); |
| */ |
