summaryrefslogtreecommitdiffstats
path: root/js/src/jit-test/tests/wasm/spec/spec/int_exprs.wast.js
diff options
context:
space:
mode:
Diffstat (limited to 'js/src/jit-test/tests/wasm/spec/spec/int_exprs.wast.js')
-rw-r--r--js/src/jit-test/tests/wasm/spec/spec/int_exprs.wast.js534
1 files changed, 534 insertions, 0 deletions
diff --git a/js/src/jit-test/tests/wasm/spec/spec/int_exprs.wast.js b/js/src/jit-test/tests/wasm/spec/spec/int_exprs.wast.js
new file mode 100644
index 0000000000..811712a794
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/spec/spec/int_exprs.wast.js
@@ -0,0 +1,534 @@
+/* Copyright 2021 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// ./test/core/int_exprs.wast
+
+// ./test/core/int_exprs.wast:6
+let $0 = instantiate(`(module
+ (func (export "i32.no_fold_cmp_s_offset") (param $$x i32) (param $$y i32) (result i32)
+ (i32.lt_s (i32.add (local.get $$x) (i32.const 1)) (i32.add (local.get $$y) (i32.const 1))))
+ (func (export "i32.no_fold_cmp_u_offset") (param $$x i32) (param $$y i32) (result i32)
+ (i32.lt_u (i32.add (local.get $$x) (i32.const 1)) (i32.add (local.get $$y) (i32.const 1))))
+
+ (func (export "i64.no_fold_cmp_s_offset") (param $$x i64) (param $$y i64) (result i32)
+ (i64.lt_s (i64.add (local.get $$x) (i64.const 1)) (i64.add (local.get $$y) (i64.const 1))))
+ (func (export "i64.no_fold_cmp_u_offset") (param $$x i64) (param $$y i64) (result i32)
+ (i64.lt_u (i64.add (local.get $$x) (i64.const 1)) (i64.add (local.get $$y) (i64.const 1))))
+)`);
+
+// ./test/core/int_exprs.wast:18
+assert_return(() => invoke($0, `i32.no_fold_cmp_s_offset`, [2147483647, 0]), [value("i32", 1)]);
+
+// ./test/core/int_exprs.wast:19
+assert_return(() => invoke($0, `i32.no_fold_cmp_u_offset`, [-1, 0]), [value("i32", 1)]);
+
+// ./test/core/int_exprs.wast:20
+assert_return(
+ () => invoke($0, `i64.no_fold_cmp_s_offset`, [9223372036854775807n, 0n]),
+ [value("i32", 1)],
+);
+
+// ./test/core/int_exprs.wast:21
+assert_return(() => invoke($0, `i64.no_fold_cmp_u_offset`, [-1n, 0n]), [value("i32", 1)]);
+
+// ./test/core/int_exprs.wast:25
+let $1 = instantiate(`(module
+ (func (export "i64.no_fold_wrap_extend_s") (param $$x i64) (result i64)
+ (i64.extend_i32_s (i32.wrap_i64 (local.get $$x))))
+)`);
+
+// ./test/core/int_exprs.wast:30
+assert_return(
+ () => invoke($1, `i64.no_fold_wrap_extend_s`, [4538991236898928n]),
+ [value("i64", 1079009392n)],
+);
+
+// ./test/core/int_exprs.wast:31
+assert_return(
+ () => invoke($1, `i64.no_fold_wrap_extend_s`, [45230338458316960n]),
+ [value("i64", -790564704n)],
+);
+
+// ./test/core/int_exprs.wast:35
+let $2 = instantiate(`(module
+ (func (export "i64.no_fold_wrap_extend_u") (param $$x i64) (result i64)
+ (i64.extend_i32_u (i32.wrap_i64 (local.get $$x))))
+)`);
+
+// ./test/core/int_exprs.wast:40
+assert_return(
+ () => invoke($2, `i64.no_fold_wrap_extend_u`, [4538991236898928n]),
+ [value("i64", 1079009392n)],
+);
+
+// ./test/core/int_exprs.wast:44
+let $3 = instantiate(`(module
+ (func (export "i32.no_fold_shl_shr_s") (param $$x i32) (result i32)
+ (i32.shr_s (i32.shl (local.get $$x) (i32.const 1)) (i32.const 1)))
+ (func (export "i32.no_fold_shl_shr_u") (param $$x i32) (result i32)
+ (i32.shr_u (i32.shl (local.get $$x) (i32.const 1)) (i32.const 1)))
+
+ (func (export "i64.no_fold_shl_shr_s") (param $$x i64) (result i64)
+ (i64.shr_s (i64.shl (local.get $$x) (i64.const 1)) (i64.const 1)))
+ (func (export "i64.no_fold_shl_shr_u") (param $$x i64) (result i64)
+ (i64.shr_u (i64.shl (local.get $$x) (i64.const 1)) (i64.const 1)))
+)`);
+
+// ./test/core/int_exprs.wast:56
+assert_return(() => invoke($3, `i32.no_fold_shl_shr_s`, [-2147483648]), [value("i32", 0)]);
+
+// ./test/core/int_exprs.wast:57
+assert_return(() => invoke($3, `i32.no_fold_shl_shr_u`, [-2147483648]), [value("i32", 0)]);
+
+// ./test/core/int_exprs.wast:58
+assert_return(() => invoke($3, `i64.no_fold_shl_shr_s`, [-9223372036854775808n]), [value("i64", 0n)]);
+
+// ./test/core/int_exprs.wast:59
+assert_return(() => invoke($3, `i64.no_fold_shl_shr_u`, [-9223372036854775808n]), [value("i64", 0n)]);
+
+// ./test/core/int_exprs.wast:63
+let $4 = instantiate(`(module
+ (func (export "i32.no_fold_shr_s_shl") (param $$x i32) (result i32)
+ (i32.shl (i32.shr_s (local.get $$x) (i32.const 1)) (i32.const 1)))
+ (func (export "i32.no_fold_shr_u_shl") (param $$x i32) (result i32)
+ (i32.shl (i32.shr_u (local.get $$x) (i32.const 1)) (i32.const 1)))
+
+ (func (export "i64.no_fold_shr_s_shl") (param $$x i64) (result i64)
+ (i64.shl (i64.shr_s (local.get $$x) (i64.const 1)) (i64.const 1)))
+ (func (export "i64.no_fold_shr_u_shl") (param $$x i64) (result i64)
+ (i64.shl (i64.shr_u (local.get $$x) (i64.const 1)) (i64.const 1)))
+)`);
+
+// ./test/core/int_exprs.wast:75
+assert_return(() => invoke($4, `i32.no_fold_shr_s_shl`, [1]), [value("i32", 0)]);
+
+// ./test/core/int_exprs.wast:76
+assert_return(() => invoke($4, `i32.no_fold_shr_u_shl`, [1]), [value("i32", 0)]);
+
+// ./test/core/int_exprs.wast:77
+assert_return(() => invoke($4, `i64.no_fold_shr_s_shl`, [1n]), [value("i64", 0n)]);
+
+// ./test/core/int_exprs.wast:78
+assert_return(() => invoke($4, `i64.no_fold_shr_u_shl`, [1n]), [value("i64", 0n)]);
+
+// ./test/core/int_exprs.wast:82
+let $5 = instantiate(`(module
+ (func (export "i32.no_fold_div_s_mul") (param $$x i32) (result i32)
+ (i32.mul (i32.div_s (local.get $$x) (i32.const 6)) (i32.const 6)))
+ (func (export "i32.no_fold_div_u_mul") (param $$x i32) (result i32)
+ (i32.mul (i32.div_u (local.get $$x) (i32.const 6)) (i32.const 6)))
+
+ (func (export "i64.no_fold_div_s_mul") (param $$x i64) (result i64)
+ (i64.mul (i64.div_s (local.get $$x) (i64.const 6)) (i64.const 6)))
+ (func (export "i64.no_fold_div_u_mul") (param $$x i64) (result i64)
+ (i64.mul (i64.div_u (local.get $$x) (i64.const 6)) (i64.const 6)))
+)`);
+
+// ./test/core/int_exprs.wast:94
+assert_return(() => invoke($5, `i32.no_fold_div_s_mul`, [1]), [value("i32", 0)]);
+
+// ./test/core/int_exprs.wast:95
+assert_return(() => invoke($5, `i32.no_fold_div_u_mul`, [1]), [value("i32", 0)]);
+
+// ./test/core/int_exprs.wast:96
+assert_return(() => invoke($5, `i64.no_fold_div_s_mul`, [1n]), [value("i64", 0n)]);
+
+// ./test/core/int_exprs.wast:97
+assert_return(() => invoke($5, `i64.no_fold_div_u_mul`, [1n]), [value("i64", 0n)]);
+
+// ./test/core/int_exprs.wast:101
+let $6 = instantiate(`(module
+ (func (export "i32.no_fold_div_s_self") (param $$x i32) (result i32)
+ (i32.div_s (local.get $$x) (local.get $$x)))
+ (func (export "i32.no_fold_div_u_self") (param $$x i32) (result i32)
+ (i32.div_u (local.get $$x) (local.get $$x)))
+
+ (func (export "i64.no_fold_div_s_self") (param $$x i64) (result i64)
+ (i64.div_s (local.get $$x) (local.get $$x)))
+ (func (export "i64.no_fold_div_u_self") (param $$x i64) (result i64)
+ (i64.div_u (local.get $$x) (local.get $$x)))
+)`);
+
+// ./test/core/int_exprs.wast:113
+assert_trap(() => invoke($6, `i32.no_fold_div_s_self`, [0]), `integer divide by zero`);
+
+// ./test/core/int_exprs.wast:114
+assert_trap(() => invoke($6, `i32.no_fold_div_u_self`, [0]), `integer divide by zero`);
+
+// ./test/core/int_exprs.wast:115
+assert_trap(() => invoke($6, `i64.no_fold_div_s_self`, [0n]), `integer divide by zero`);
+
+// ./test/core/int_exprs.wast:116
+assert_trap(() => invoke($6, `i64.no_fold_div_u_self`, [0n]), `integer divide by zero`);
+
+// ./test/core/int_exprs.wast:120
+let $7 = instantiate(`(module
+ (func (export "i32.no_fold_rem_s_self") (param $$x i32) (result i32)
+ (i32.rem_s (local.get $$x) (local.get $$x)))
+ (func (export "i32.no_fold_rem_u_self") (param $$x i32) (result i32)
+ (i32.rem_u (local.get $$x) (local.get $$x)))
+
+ (func (export "i64.no_fold_rem_s_self") (param $$x i64) (result i64)
+ (i64.rem_s (local.get $$x) (local.get $$x)))
+ (func (export "i64.no_fold_rem_u_self") (param $$x i64) (result i64)
+ (i64.rem_u (local.get $$x) (local.get $$x)))
+)`);
+
+// ./test/core/int_exprs.wast:132
+assert_trap(() => invoke($7, `i32.no_fold_rem_s_self`, [0]), `integer divide by zero`);
+
+// ./test/core/int_exprs.wast:133
+assert_trap(() => invoke($7, `i32.no_fold_rem_u_self`, [0]), `integer divide by zero`);
+
+// ./test/core/int_exprs.wast:134
+assert_trap(() => invoke($7, `i64.no_fold_rem_s_self`, [0n]), `integer divide by zero`);
+
+// ./test/core/int_exprs.wast:135
+assert_trap(() => invoke($7, `i64.no_fold_rem_u_self`, [0n]), `integer divide by zero`);
+
+// ./test/core/int_exprs.wast:139
+let $8 = instantiate(`(module
+ (func (export "i32.no_fold_mul_div_s") (param $$x i32) (result i32)
+ (i32.div_s (i32.mul (local.get $$x) (i32.const 6)) (i32.const 6)))
+ (func (export "i32.no_fold_mul_div_u") (param $$x i32) (result i32)
+ (i32.div_u (i32.mul (local.get $$x) (i32.const 6)) (i32.const 6)))
+
+ (func (export "i64.no_fold_mul_div_s") (param $$x i64) (result i64)
+ (i64.div_s (i64.mul (local.get $$x) (i64.const 6)) (i64.const 6)))
+ (func (export "i64.no_fold_mul_div_u") (param $$x i64) (result i64)
+ (i64.div_u (i64.mul (local.get $$x) (i64.const 6)) (i64.const 6)))
+)`);
+
+// ./test/core/int_exprs.wast:151
+assert_return(() => invoke($8, `i32.no_fold_mul_div_s`, [-2147483648]), [value("i32", 0)]);
+
+// ./test/core/int_exprs.wast:152
+assert_return(() => invoke($8, `i32.no_fold_mul_div_u`, [-2147483648]), [value("i32", 0)]);
+
+// ./test/core/int_exprs.wast:153
+assert_return(() => invoke($8, `i64.no_fold_mul_div_s`, [-9223372036854775808n]), [value("i64", 0n)]);
+
+// ./test/core/int_exprs.wast:154
+assert_return(() => invoke($8, `i64.no_fold_mul_div_u`, [-9223372036854775808n]), [value("i64", 0n)]);
+
+// ./test/core/int_exprs.wast:158
+let $9 = instantiate(`(module
+ (func (export "i32.no_fold_div_s_2") (param $$x i32) (result i32)
+ (i32.div_s (local.get $$x) (i32.const 2)))
+
+ (func (export "i64.no_fold_div_s_2") (param $$x i64) (result i64)
+ (i64.div_s (local.get $$x) (i64.const 2)))
+)`);
+
+// ./test/core/int_exprs.wast:166
+assert_return(() => invoke($9, `i32.no_fold_div_s_2`, [-11]), [value("i32", -5)]);
+
+// ./test/core/int_exprs.wast:167
+assert_return(() => invoke($9, `i64.no_fold_div_s_2`, [-11n]), [value("i64", -5n)]);
+
+// ./test/core/int_exprs.wast:171
+let $10 = instantiate(`(module
+ (func (export "i32.no_fold_rem_s_2") (param $$x i32) (result i32)
+ (i32.rem_s (local.get $$x) (i32.const 2)))
+
+ (func (export "i64.no_fold_rem_s_2") (param $$x i64) (result i64)
+ (i64.rem_s (local.get $$x) (i64.const 2)))
+)`);
+
+// ./test/core/int_exprs.wast:179
+assert_return(() => invoke($10, `i32.no_fold_rem_s_2`, [-11]), [value("i32", -1)]);
+
+// ./test/core/int_exprs.wast:180
+assert_return(() => invoke($10, `i64.no_fold_rem_s_2`, [-11n]), [value("i64", -1n)]);
+
+// ./test/core/int_exprs.wast:184
+let $11 = instantiate(`(module
+ (func (export "i32.div_s_0") (param $$x i32) (result i32)
+ (i32.div_s (local.get $$x) (i32.const 0)))
+ (func (export "i32.div_u_0") (param $$x i32) (result i32)
+ (i32.div_u (local.get $$x) (i32.const 0)))
+
+ (func (export "i64.div_s_0") (param $$x i64) (result i64)
+ (i64.div_s (local.get $$x) (i64.const 0)))
+ (func (export "i64.div_u_0") (param $$x i64) (result i64)
+ (i64.div_u (local.get $$x) (i64.const 0)))
+)`);
+
+// ./test/core/int_exprs.wast:196
+assert_trap(() => invoke($11, `i32.div_s_0`, [71]), `integer divide by zero`);
+
+// ./test/core/int_exprs.wast:197
+assert_trap(() => invoke($11, `i32.div_u_0`, [71]), `integer divide by zero`);
+
+// ./test/core/int_exprs.wast:198
+assert_trap(() => invoke($11, `i64.div_s_0`, [71n]), `integer divide by zero`);
+
+// ./test/core/int_exprs.wast:199
+assert_trap(() => invoke($11, `i64.div_u_0`, [71n]), `integer divide by zero`);
+
+// ./test/core/int_exprs.wast:203
+let $12 = instantiate(`(module
+ (func (export "i32.div_s_3") (param $$x i32) (result i32)
+ (i32.div_s (local.get $$x) (i32.const 3)))
+ (func (export "i32.div_u_3") (param $$x i32) (result i32)
+ (i32.div_u (local.get $$x) (i32.const 3)))
+
+ (func (export "i64.div_s_3") (param $$x i64) (result i64)
+ (i64.div_s (local.get $$x) (i64.const 3)))
+ (func (export "i64.div_u_3") (param $$x i64) (result i64)
+ (i64.div_u (local.get $$x) (i64.const 3)))
+)`);
+
+// ./test/core/int_exprs.wast:215
+assert_return(() => invoke($12, `i32.div_s_3`, [71]), [value("i32", 23)]);
+
+// ./test/core/int_exprs.wast:216
+assert_return(() => invoke($12, `i32.div_s_3`, [1610612736]), [value("i32", 536870912)]);
+
+// ./test/core/int_exprs.wast:217
+assert_return(() => invoke($12, `i32.div_u_3`, [71]), [value("i32", 23)]);
+
+// ./test/core/int_exprs.wast:218
+assert_return(() => invoke($12, `i32.div_u_3`, [-1073741824]), [value("i32", 1073741824)]);
+
+// ./test/core/int_exprs.wast:219
+assert_return(() => invoke($12, `i64.div_s_3`, [71n]), [value("i64", 23n)]);
+
+// ./test/core/int_exprs.wast:220
+assert_return(
+ () => invoke($12, `i64.div_s_3`, [3458764513820540928n]),
+ [value("i64", 1152921504606846976n)],
+);
+
+// ./test/core/int_exprs.wast:221
+assert_return(() => invoke($12, `i64.div_u_3`, [71n]), [value("i64", 23n)]);
+
+// ./test/core/int_exprs.wast:222
+assert_return(
+ () => invoke($12, `i64.div_u_3`, [-4611686018427387904n]),
+ [value("i64", 4611686018427387904n)],
+);
+
+// ./test/core/int_exprs.wast:226
+let $13 = instantiate(`(module
+ (func (export "i32.div_s_5") (param $$x i32) (result i32)
+ (i32.div_s (local.get $$x) (i32.const 5)))
+ (func (export "i32.div_u_5") (param $$x i32) (result i32)
+ (i32.div_u (local.get $$x) (i32.const 5)))
+
+ (func (export "i64.div_s_5") (param $$x i64) (result i64)
+ (i64.div_s (local.get $$x) (i64.const 5)))
+ (func (export "i64.div_u_5") (param $$x i64) (result i64)
+ (i64.div_u (local.get $$x) (i64.const 5)))
+)`);
+
+// ./test/core/int_exprs.wast:238
+assert_return(() => invoke($13, `i32.div_s_5`, [71]), [value("i32", 14)]);
+
+// ./test/core/int_exprs.wast:239
+assert_return(() => invoke($13, `i32.div_s_5`, [1342177280]), [value("i32", 268435456)]);
+
+// ./test/core/int_exprs.wast:240
+assert_return(() => invoke($13, `i32.div_u_5`, [71]), [value("i32", 14)]);
+
+// ./test/core/int_exprs.wast:241
+assert_return(() => invoke($13, `i32.div_u_5`, [-1610612736]), [value("i32", 536870912)]);
+
+// ./test/core/int_exprs.wast:242
+assert_return(() => invoke($13, `i64.div_s_5`, [71n]), [value("i64", 14n)]);
+
+// ./test/core/int_exprs.wast:243
+assert_return(
+ () => invoke($13, `i64.div_s_5`, [5764607523034234880n]),
+ [value("i64", 1152921504606846976n)],
+);
+
+// ./test/core/int_exprs.wast:244
+assert_return(() => invoke($13, `i64.div_u_5`, [71n]), [value("i64", 14n)]);
+
+// ./test/core/int_exprs.wast:245
+assert_return(
+ () => invoke($13, `i64.div_u_5`, [-6917529027641081856n]),
+ [value("i64", 2305843009213693952n)],
+);
+
+// ./test/core/int_exprs.wast:249
+let $14 = instantiate(`(module
+ (func (export "i32.div_s_7") (param $$x i32) (result i32)
+ (i32.div_s (local.get $$x) (i32.const 7)))
+ (func (export "i32.div_u_7") (param $$x i32) (result i32)
+ (i32.div_u (local.get $$x) (i32.const 7)))
+
+ (func (export "i64.div_s_7") (param $$x i64) (result i64)
+ (i64.div_s (local.get $$x) (i64.const 7)))
+ (func (export "i64.div_u_7") (param $$x i64) (result i64)
+ (i64.div_u (local.get $$x) (i64.const 7)))
+)`);
+
+// ./test/core/int_exprs.wast:261
+assert_return(() => invoke($14, `i32.div_s_7`, [71]), [value("i32", 10)]);
+
+// ./test/core/int_exprs.wast:262
+assert_return(() => invoke($14, `i32.div_s_7`, [1879048192]), [value("i32", 268435456)]);
+
+// ./test/core/int_exprs.wast:263
+assert_return(() => invoke($14, `i32.div_u_7`, [71]), [value("i32", 10)]);
+
+// ./test/core/int_exprs.wast:264
+assert_return(() => invoke($14, `i32.div_u_7`, [-536870912]), [value("i32", 536870912)]);
+
+// ./test/core/int_exprs.wast:265
+assert_return(() => invoke($14, `i64.div_s_7`, [71n]), [value("i64", 10n)]);
+
+// ./test/core/int_exprs.wast:266
+assert_return(
+ () => invoke($14, `i64.div_s_7`, [8070450532247928832n]),
+ [value("i64", 1152921504606846976n)],
+);
+
+// ./test/core/int_exprs.wast:267
+assert_return(() => invoke($14, `i64.div_u_7`, [71n]), [value("i64", 10n)]);
+
+// ./test/core/int_exprs.wast:268
+assert_return(
+ () => invoke($14, `i64.div_u_7`, [-2305843009213693952n]),
+ [value("i64", 2305843009213693952n)],
+);
+
+// ./test/core/int_exprs.wast:272
+let $15 = instantiate(`(module
+ (func (export "i32.rem_s_3") (param $$x i32) (result i32)
+ (i32.rem_s (local.get $$x) (i32.const 3)))
+ (func (export "i32.rem_u_3") (param $$x i32) (result i32)
+ (i32.rem_u (local.get $$x) (i32.const 3)))
+
+ (func (export "i64.rem_s_3") (param $$x i64) (result i64)
+ (i64.rem_s (local.get $$x) (i64.const 3)))
+ (func (export "i64.rem_u_3") (param $$x i64) (result i64)
+ (i64.rem_u (local.get $$x) (i64.const 3)))
+)`);
+
+// ./test/core/int_exprs.wast:284
+assert_return(() => invoke($15, `i32.rem_s_3`, [71]), [value("i32", 2)]);
+
+// ./test/core/int_exprs.wast:285
+assert_return(() => invoke($15, `i32.rem_s_3`, [1610612736]), [value("i32", 0)]);
+
+// ./test/core/int_exprs.wast:286
+assert_return(() => invoke($15, `i32.rem_u_3`, [71]), [value("i32", 2)]);
+
+// ./test/core/int_exprs.wast:287
+assert_return(() => invoke($15, `i32.rem_u_3`, [-1073741824]), [value("i32", 0)]);
+
+// ./test/core/int_exprs.wast:288
+assert_return(() => invoke($15, `i64.rem_s_3`, [71n]), [value("i64", 2n)]);
+
+// ./test/core/int_exprs.wast:289
+assert_return(() => invoke($15, `i64.rem_s_3`, [3458764513820540928n]), [value("i64", 0n)]);
+
+// ./test/core/int_exprs.wast:290
+assert_return(() => invoke($15, `i64.rem_u_3`, [71n]), [value("i64", 2n)]);
+
+// ./test/core/int_exprs.wast:291
+assert_return(() => invoke($15, `i64.rem_u_3`, [-4611686018427387904n]), [value("i64", 0n)]);
+
+// ./test/core/int_exprs.wast:295
+let $16 = instantiate(`(module
+ (func (export "i32.rem_s_5") (param $$x i32) (result i32)
+ (i32.rem_s (local.get $$x) (i32.const 5)))
+ (func (export "i32.rem_u_5") (param $$x i32) (result i32)
+ (i32.rem_u (local.get $$x) (i32.const 5)))
+
+ (func (export "i64.rem_s_5") (param $$x i64) (result i64)
+ (i64.rem_s (local.get $$x) (i64.const 5)))
+ (func (export "i64.rem_u_5") (param $$x i64) (result i64)
+ (i64.rem_u (local.get $$x) (i64.const 5)))
+)`);
+
+// ./test/core/int_exprs.wast:307
+assert_return(() => invoke($16, `i32.rem_s_5`, [71]), [value("i32", 1)]);
+
+// ./test/core/int_exprs.wast:308
+assert_return(() => invoke($16, `i32.rem_s_5`, [1342177280]), [value("i32", 0)]);
+
+// ./test/core/int_exprs.wast:309
+assert_return(() => invoke($16, `i32.rem_u_5`, [71]), [value("i32", 1)]);
+
+// ./test/core/int_exprs.wast:310
+assert_return(() => invoke($16, `i32.rem_u_5`, [-1610612736]), [value("i32", 0)]);
+
+// ./test/core/int_exprs.wast:311
+assert_return(() => invoke($16, `i64.rem_s_5`, [71n]), [value("i64", 1n)]);
+
+// ./test/core/int_exprs.wast:312
+assert_return(() => invoke($16, `i64.rem_s_5`, [5764607523034234880n]), [value("i64", 0n)]);
+
+// ./test/core/int_exprs.wast:313
+assert_return(() => invoke($16, `i64.rem_u_5`, [71n]), [value("i64", 1n)]);
+
+// ./test/core/int_exprs.wast:314
+assert_return(() => invoke($16, `i64.rem_u_5`, [-6917529027641081856n]), [value("i64", 0n)]);
+
+// ./test/core/int_exprs.wast:318
+let $17 = instantiate(`(module
+ (func (export "i32.rem_s_7") (param $$x i32) (result i32)
+ (i32.rem_s (local.get $$x) (i32.const 7)))
+ (func (export "i32.rem_u_7") (param $$x i32) (result i32)
+ (i32.rem_u (local.get $$x) (i32.const 7)))
+
+ (func (export "i64.rem_s_7") (param $$x i64) (result i64)
+ (i64.rem_s (local.get $$x) (i64.const 7)))
+ (func (export "i64.rem_u_7") (param $$x i64) (result i64)
+ (i64.rem_u (local.get $$x) (i64.const 7)))
+)`);
+
+// ./test/core/int_exprs.wast:330
+assert_return(() => invoke($17, `i32.rem_s_7`, [71]), [value("i32", 1)]);
+
+// ./test/core/int_exprs.wast:331
+assert_return(() => invoke($17, `i32.rem_s_7`, [1879048192]), [value("i32", 0)]);
+
+// ./test/core/int_exprs.wast:332
+assert_return(() => invoke($17, `i32.rem_u_7`, [71]), [value("i32", 1)]);
+
+// ./test/core/int_exprs.wast:333
+assert_return(() => invoke($17, `i32.rem_u_7`, [-536870912]), [value("i32", 0)]);
+
+// ./test/core/int_exprs.wast:334
+assert_return(() => invoke($17, `i64.rem_s_7`, [71n]), [value("i64", 1n)]);
+
+// ./test/core/int_exprs.wast:335
+assert_return(() => invoke($17, `i64.rem_s_7`, [8070450532247928832n]), [value("i64", 0n)]);
+
+// ./test/core/int_exprs.wast:336
+assert_return(() => invoke($17, `i64.rem_u_7`, [71n]), [value("i64", 1n)]);
+
+// ./test/core/int_exprs.wast:337
+assert_return(() => invoke($17, `i64.rem_u_7`, [-2305843009213693952n]), [value("i64", 0n)]);
+
+// ./test/core/int_exprs.wast:341
+let $18 = instantiate(`(module
+ (func (export "i32.no_fold_div_neg1") (param $$x i32) (result i32)
+ (i32.div_s (local.get $$x) (i32.const -1)))
+
+ (func (export "i64.no_fold_div_neg1") (param $$x i64) (result i64)
+ (i64.div_s (local.get $$x) (i64.const -1)))
+)`);
+
+// ./test/core/int_exprs.wast:349
+assert_trap(() => invoke($18, `i32.no_fold_div_neg1`, [-2147483648]), `integer overflow`);
+
+// ./test/core/int_exprs.wast:350
+assert_trap(() => invoke($18, `i64.no_fold_div_neg1`, [-9223372036854775808n]), `integer overflow`);
generated by cgit v1.2.3 (git 2.39.1) at 2024-06-20 06:22:31 +0000