Magic-Mirror/gecko-dev
1
0
Fork 0
mirror of https://github.com/mozilla/gecko-dev.git synced 2024-10-18 07:45:30 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Bug 1495609 - Baldr: let non-trapping float-to-int conversions ride the trains (r=sunfish,lth)

Browse Source
This commit is contained in:
Luke Wagner 2018-10-13 13:18:12 -05:00
parent 32f9fcc2d3
commit 28fdba8988
11 changed files with 1755 additions and 529 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

18
js/src/builtin/TestingFunctions.cpp
View File

@ -668,19 +668,6 @@ WasmThreadsSupported(JSContext* cx, unsigned argc, Value* vp)
return true;
}
static bool
WasmSaturatingTruncationSupported(JSContext* cx, unsigned argc, Value* vp)
{
CallArgs args = CallArgsFromVp(argc, vp);
#ifdef ENABLE_WASM_SATURATING_TRUNC_OPS
bool isSupported = true;
#else
bool isSupported = false;
#endif
args.rval().setBoolean(isSupported);
return true;
}
static bool
WasmBulkMemSupported(JSContext* cx, unsigned argc, Value* vp)
{
@ -5981,11 +5968,6 @@ gc::ZealModeHelpText),
JS_FN_HELP("wasmThreadsSupported", WasmThreadsSupported, 0, 0,
"wasmThreadsSupported()",
" Returns a boolean indicating whether the WebAssembly threads proposal is\n"
" supported on the current device."),
JS_FN_HELP("wasmSaturatingTruncationSupported", WasmSaturatingTruncationSupported, 0, 0,
"wasmSaturatingTruncationSupported()",
" Returns a boolean indicating whether the WebAssembly saturating truncates opcodes are\n"
" supported on the current device."),
JS_FN_HELP("wasmBulkMemSupported", WasmBulkMemSupported, 0, 0,

92
js/src/jit-test/tests/wasm/conversion.js
View File

@ -240,61 +240,59 @@ testTrap('i64', 'trunc_u', 'f32', "-infinity");
testConversion('i64', 'reinterpret', 'f64', 40.09999999999968, "0x40440ccccccccca0");
testConversion('f64', 'reinterpret', 'i64', "0x40440ccccccccca0", 40.09999999999968);
if (wasmSaturatingTruncationSupported()) {
var u64max = '0xffffffffffffffff';
var s64max = '0x7fffffffffffffff';
var s64min = '-0x8000000000000000';
var s32max = 2147483647;
var s32min = -2147483648;
var u64max = '0xffffffffffffffff';
var s64max = '0x7fffffffffffffff';
var s64min = '-0x8000000000000000';
var s32max = 2147483647;
var s32min = -2147483648;
testConversion('i32', 'trunc_s:sat', 'f32', NaN, 0);
testConversion('i32', 'trunc_s:sat', 'f32', Infinity, s32max);
testConversion('i32', 'trunc_s:sat', 'f32', -Infinity, s32min);
testConversion('i32', 'trunc_s:sat', 'f32', p(2, 31), s32max);
testConversion('i32', 'trunc_s:sat', 'f32', -p(2, 31) - 256, s32min);
testConversion('i32', 'trunc_s:sat', 'f32', NaN, 0);
testConversion('i32', 'trunc_s:sat', 'f32', Infinity, s32max);
testConversion('i32', 'trunc_s:sat', 'f32', -Infinity, s32min);
testConversion('i32', 'trunc_s:sat', 'f32', p(2, 31), s32max);
testConversion('i32', 'trunc_s:sat', 'f32', -p(2, 31) - 256, s32min);
testConversion('i32', 'trunc_s:sat', 'f64', NaN, 0);
testConversion('i32', 'trunc_s:sat', 'f64', Infinity, s32max);
testConversion('i32', 'trunc_s:sat', 'f64', -Infinity, s32min);
testConversion('i32', 'trunc_s:sat', 'f64', p(2, 31), s32max);
testConversion('i32', 'trunc_s:sat', 'f64', -p(2, 31) - 1, s32min);
testConversion('i32', 'trunc_s:sat', 'f64', NaN, 0);
testConversion('i32', 'trunc_s:sat', 'f64', Infinity, s32max);
testConversion('i32', 'trunc_s:sat', 'f64', -Infinity, s32min);
testConversion('i32', 'trunc_s:sat', 'f64', p(2, 31), s32max);
testConversion('i32', 'trunc_s:sat', 'f64', -p(2, 31) - 1, s32min);
testConversion('i32', 'trunc_u:sat', 'f32', NaN, 0);
testConversion('i32', 'trunc_u:sat', 'f32', Infinity, -1);
testConversion('i32', 'trunc_u:sat', 'f32', -Infinity, 0);
testConversion('i32', 'trunc_u:sat', 'f32', -1, 0);
testConversion('i32', 'trunc_u:sat', 'f32', p(2, 32), -1);
testConversion('i32', 'trunc_u:sat', 'f32', NaN, 0);
testConversion('i32', 'trunc_u:sat', 'f32', Infinity, -1);
testConversion('i32', 'trunc_u:sat', 'f32', -Infinity, 0);
testConversion('i32', 'trunc_u:sat', 'f32', -1, 0);
testConversion('i32', 'trunc_u:sat', 'f32', p(2, 32), -1);
testConversion('i32', 'trunc_u:sat', 'f64', NaN, 0);
testConversion('i32', 'trunc_u:sat', 'f64', Infinity, -1);
testConversion('i32', 'trunc_u:sat', 'f64', -Infinity, 0);
testConversion('i32', 'trunc_u:sat', 'f64', -1, 0);
testConversion('i32', 'trunc_u:sat', 'f64', p(2, 32), -1);
testConversion('i32', 'trunc_u:sat', 'f64', NaN, 0);
testConversion('i32', 'trunc_u:sat', 'f64', Infinity, -1);
testConversion('i32', 'trunc_u:sat', 'f64', -Infinity, 0);
testConversion('i32', 'trunc_u:sat', 'f64', -1, 0);
testConversion('i32', 'trunc_u:sat', 'f64', p(2, 32), -1);
testConversion('i64', 'trunc_s:sat', 'f64', 9223372036854776000.0, s64max);
testConversion('i64', 'trunc_s:sat', 'f64', -9223372036854778000.0, s64min);
testConversion('i64', 'trunc_s:sat', 'f64', 'nan', '0');
testConversion('i64', 'trunc_s:sat', 'f64', 'infinity', s64max);
testConversion('i64', 'trunc_s:sat', 'f64', '-infinity', s64min);
testConversion('i64', 'trunc_s:sat', 'f64', 9223372036854776000.0, s64max);
testConversion('i64', 'trunc_s:sat', 'f64', -9223372036854778000.0, s64min);
testConversion('i64', 'trunc_s:sat', 'f64', 'nan', '0');
testConversion('i64', 'trunc_s:sat', 'f64', 'infinity', s64max);
testConversion('i64', 'trunc_s:sat', 'f64', '-infinity', s64min);
testConversion('i64', 'trunc_u:sat', 'f64', -1, '0');
testConversion('i64', 'trunc_u:sat', 'f64', 18446744073709551616.0, u64max);
testConversion('i64', 'trunc_u:sat', 'f64', 'nan', '0');
testConversion('i64', 'trunc_u:sat', 'f64', 'infinity', u64max);
testConversion('i64', 'trunc_u:sat', 'f64', '-infinity', '0');
testConversion('i64', 'trunc_u:sat', 'f64', -1, '0');
testConversion('i64', 'trunc_u:sat', 'f64', 18446744073709551616.0, u64max);
testConversion('i64', 'trunc_u:sat', 'f64', 'nan', '0');
testConversion('i64', 'trunc_u:sat', 'f64', 'infinity', u64max);
testConversion('i64', 'trunc_u:sat', 'f64', '-infinity', '0');
testConversion('i64', 'trunc_s:sat', 'f32', 9223372036854776000.0, s64max);
testConversion('i64', 'trunc_s:sat', 'f32', -9223372586610630000.0, s64min);
testConversion('i64', 'trunc_s:sat', 'f32', 'nan', '0');
testConversion('i64', 'trunc_s:sat', 'f32', 'infinity', s64max);
testConversion('i64', 'trunc_s:sat', 'f32', '-infinity', s64min);
testConversion('i64', 'trunc_s:sat', 'f32', 9223372036854776000.0, s64max);
testConversion('i64', 'trunc_s:sat', 'f32', -9223372586610630000.0, s64min);
testConversion('i64', 'trunc_s:sat', 'f32', 'nan', '0');
testConversion('i64', 'trunc_s:sat', 'f32', 'infinity', s64max);
testConversion('i64', 'trunc_s:sat', 'f32', '-infinity', s64min);
testConversion('i64', 'trunc_u:sat', 'f32', 18446744073709551616.0, u64max);
testConversion('i64', 'trunc_u:sat', 'f32', -1, '0');
testConversion('i64', 'trunc_u:sat', 'f32', 'nan', '0');
testConversion('i64', 'trunc_u:sat', 'f32', 'infinity', u64max);
testConversion('i64', 'trunc_u:sat', 'f32', '-infinity', '0');
}
testConversion('i64', 'trunc_u:sat', 'f32', 18446744073709551616.0, u64max);
testConversion('i64', 'trunc_u:sat', 'f32', -1, '0');
testConversion('i64', 'trunc_u:sat', 'f32', 'nan', '0');
testConversion('i64', 'trunc_u:sat', 'f32', 'infinity', u64max);
testConversion('i64', 'trunc_u:sat', 'f32', '-infinity', '0');
testSignExtension('i32', 'extend8_s', 'i32', 0x7F, 0x7F);
testSignExtension('i32', 'extend8_s', 'i32', 0x80, -0x80);

1472
js/src/jit-test/tests/wasm/spec/conversions.wast.js
View File

File diff suppressed because it is too large Load Diff

659
js/src/jit-test/tests/wasm/spec/src/conversions.wast Normal file
View File

@ -0,0 +1,659 @@
(module
(func (export "i64.extend_s_i32") (param $x i32) (result i64) (i64.extend_s/i32 (get_local $x)))
(func (export "i64.extend_u_i32") (param $x i32) (result i64) (i64.extend_u/i32 (get_local $x)))
(func (export "i32.wrap_i64") (param $x i64) (result i32) (i32.wrap/i64 (get_local $x)))
(func (export "i32.trunc_s_f32") (param $x f32) (result i32) (i32.trunc_s/f32 (get_local $x)))
(func (export "i32.trunc_u_f32") (param $x f32) (result i32) (i32.trunc_u/f32 (get_local $x)))
(func (export "i32.trunc_s_f64") (param $x f64) (result i32) (i32.trunc_s/f64 (get_local $x)))
(func (export "i32.trunc_u_f64") (param $x f64) (result i32) (i32.trunc_u/f64 (get_local $x)))
(func (export "i64.trunc_s_f32") (param $x f32) (result i64) (i64.trunc_s/f32 (get_local $x)))
(func (export "i64.trunc_u_f32") (param $x f32) (result i64) (i64.trunc_u/f32 (get_local $x)))
(func (export "i64.trunc_s_f64") (param $x f64) (result i64) (i64.trunc_s/f64 (get_local $x)))
(func (export "i64.trunc_u_f64") (param $x f64) (result i64) (i64.trunc_u/f64 (get_local $x)))
(func (export "i32.trunc_s:sat_f32") (param $x f32) (result i32) (i32.trunc_s:sat/f32 (get_local $x)))
(func (export "i32.trunc_u:sat_f32") (param $x f32) (result i32) (i32.trunc_u:sat/f32 (get_local $x)))
(func (export "i32.trunc_s:sat_f64") (param $x f64) (result i32) (i32.trunc_s:sat/f64 (get_local $x)))
(func (export "i32.trunc_u:sat_f64") (param $x f64) (result i32) (i32.trunc_u:sat/f64 (get_local $x)))
(func (export "i64.trunc_s:sat_f32") (param $x f32) (result i64) (i64.trunc_s:sat/f32 (get_local $x)))
(func (export "i64.trunc_u:sat_f32") (param $x f32) (result i64) (i64.trunc_u:sat/f32 (get_local $x)))
(func (export "i64.trunc_s:sat_f64") (param $x f64) (result i64) (i64.trunc_s:sat/f64 (get_local $x)))
(func (export "i64.trunc_u:sat_f64") (param $x f64) (result i64) (i64.trunc_u:sat/f64 (get_local $x)))
(func (export "f32.convert_s_i32") (param $x i32) (result f32) (f32.convert_s/i32 (get_local $x)))
(func (export "f32.convert_s_i64") (param $x i64) (result f32) (f32.convert_s/i64 (get_local $x)))
(func (export "f64.convert_s_i32") (param $x i32) (result f64) (f64.convert_s/i32 (get_local $x)))
(func (export "f64.convert_s_i64") (param $x i64) (result f64) (f64.convert_s/i64 (get_local $x)))
(func (export "f32.convert_u_i32") (param $x i32) (result f32) (f32.convert_u/i32 (get_local $x)))
(func (export "f32.convert_u_i64") (param $x i64) (result f32) (f32.convert_u/i64 (get_local $x)))
(func (export "f64.convert_u_i32") (param $x i32) (result f64) (f64.convert_u/i32 (get_local $x)))
(func (export "f64.convert_u_i64") (param $x i64) (result f64) (f64.convert_u/i64 (get_local $x)))
(func (export "f64.promote_f32") (param $x f32) (result f64) (f64.promote/f32 (get_local $x)))
(func (export "f32.demote_f64") (param $x f64) (result f32) (f32.demote/f64 (get_local $x)))
(func (export "f32.reinterpret_i32") (param $x i32) (result f32) (f32.reinterpret/i32 (get_local $x)))
(func (export "f64.reinterpret_i64") (param $x i64) (result f64) (f64.reinterpret/i64 (get_local $x)))
(func (export "i32.reinterpret_f32") (param $x f32) (result i32) (i32.reinterpret/f32 (get_local $x)))
(func (export "i64.reinterpret_f64") (param $x f64) (result i64) (i64.reinterpret/f64 (get_local $x)))
)
(assert_return (invoke "i64.extend_s_i32" (i32.const 0)) (i64.const 0))
(assert_return (invoke "i64.extend_s_i32" (i32.const 10000)) (i64.const 10000))
(assert_return (invoke "i64.extend_s_i32" (i32.const -10000)) (i64.const -10000))
(assert_return (invoke "i64.extend_s_i32" (i32.const -1)) (i64.const -1))
(assert_return (invoke "i64.extend_s_i32" (i32.const 0x7fffffff)) (i64.const 0x000000007fffffff))
(assert_return (invoke "i64.extend_s_i32" (i32.const 0x80000000)) (i64.const 0xffffffff80000000))
(assert_return (invoke "i64.extend_u_i32" (i32.const 0)) (i64.const 0))
(assert_return (invoke "i64.extend_u_i32" (i32.const 10000)) (i64.const 10000))
(assert_return (invoke "i64.extend_u_i32" (i32.const -10000)) (i64.const 0x00000000ffffd8f0))
(assert_return (invoke "i64.extend_u_i32" (i32.const -1)) (i64.const 0xffffffff))
(assert_return (invoke "i64.extend_u_i32" (i32.const 0x7fffffff)) (i64.const 0x000000007fffffff))
(assert_return (invoke "i64.extend_u_i32" (i32.const 0x80000000)) (i64.const 0x0000000080000000))
(assert_return (invoke "i32.wrap_i64" (i64.const -1)) (i32.const -1))
(assert_return (invoke "i32.wrap_i64" (i64.const -100000)) (i32.const -100000))
(assert_return (invoke "i32.wrap_i64" (i64.const 0x80000000)) (i32.const 0x80000000))
(assert_return (invoke "i32.wrap_i64" (i64.const 0xffffffff7fffffff)) (i32.const 0x7fffffff))
(assert_return (invoke "i32.wrap_i64" (i64.const 0xffffffff00000000)) (i32.const 0x00000000))
(assert_return (invoke "i32.wrap_i64" (i64.const 0xfffffffeffffffff)) (i32.const 0xffffffff))
(assert_return (invoke "i32.wrap_i64" (i64.const 0xffffffff00000001)) (i32.const 0x00000001))
(assert_return (invoke "i32.wrap_i64" (i64.const 0)) (i32.const 0))
(assert_return (invoke "i32.wrap_i64" (i64.const 1311768467463790320)) (i32.const 0x9abcdef0))
(assert_return (invoke "i32.wrap_i64" (i64.const 0x00000000ffffffff)) (i32.const 0xffffffff))
(assert_return (invoke "i32.wrap_i64" (i64.const 0x0000000100000000)) (i32.const 0x00000000))
(assert_return (invoke "i32.wrap_i64" (i64.const 0x0000000100000001)) (i32.const 0x00000001))
(assert_return (invoke "i32.trunc_s_f32" (f32.const 0.0)) (i32.const 0))
(assert_return (invoke "i32.trunc_s_f32" (f32.const -0.0)) (i32.const 0))
(assert_return (invoke "i32.trunc_s_f32" (f32.const 0x1p-149)) (i32.const 0))
(assert_return (invoke "i32.trunc_s_f32" (f32.const -0x1p-149)) (i32.const 0))
(assert_return (invoke "i32.trunc_s_f32" (f32.const 1.0)) (i32.const 1))
(assert_return (invoke "i32.trunc_s_f32" (f32.const 0x1.19999ap+0)) (i32.const 1))
(assert_return (invoke "i32.trunc_s_f32" (f32.const 1.5)) (i32.const 1))
(assert_return (invoke "i32.trunc_s_f32" (f32.const -1.0)) (i32.const -1))
(assert_return (invoke "i32.trunc_s_f32" (f32.const -0x1.19999ap+0)) (i32.const -1))
(assert_return (invoke "i32.trunc_s_f32" (f32.const -1.5)) (i32.const -1))
(assert_return (invoke "i32.trunc_s_f32" (f32.const -1.9)) (i32.const -1))
(assert_return (invoke "i32.trunc_s_f32" (f32.const -2.0)) (i32.const -2))
(assert_return (invoke "i32.trunc_s_f32" (f32.const 2147483520.0)) (i32.const 2147483520))
(assert_return (invoke "i32.trunc_s_f32" (f32.const -2147483648.0)) (i32.const -2147483648))
(assert_trap (invoke "i32.trunc_s_f32" (f32.const 2147483648.0)) "integer overflow")
(assert_trap (invoke "i32.trunc_s_f32" (f32.const -2147483904.0)) "integer overflow")
(assert_trap (invoke "i32.trunc_s_f32" (f32.const inf)) "integer overflow")
(assert_trap (invoke "i32.trunc_s_f32" (f32.const -inf)) "integer overflow")
(assert_trap (invoke "i32.trunc_s_f32" (f32.const nan)) "invalid conversion to integer")
(assert_trap (invoke "i32.trunc_s_f32" (f32.const nan:0x200000)) "invalid conversion to integer")
(assert_trap (invoke "i32.trunc_s_f32" (f32.const -nan)) "invalid conversion to integer")
(assert_trap (invoke "i32.trunc_s_f32" (f32.const -nan:0x200000)) "invalid conversion to integer")
(assert_return (invoke "i32.trunc_u_f32" (f32.const 0.0)) (i32.const 0))
(assert_return (invoke "i32.trunc_u_f32" (f32.const -0.0)) (i32.const 0))
(assert_return (invoke "i32.trunc_u_f32" (f32.const 0x1p-149)) (i32.const 0))
(assert_return (invoke "i32.trunc_u_f32" (f32.const -0x1p-149)) (i32.const 0))
(assert_return (invoke "i32.trunc_u_f32" (f32.const 1.0)) (i32.const 1))
(assert_return (invoke "i32.trunc_u_f32" (f32.const 0x1.19999ap+0)) (i32.const 1))
(assert_return (invoke "i32.trunc_u_f32" (f32.const 1.5)) (i32.const 1))
(assert_return (invoke "i32.trunc_u_f32" (f32.const 1.9)) (i32.const 1))
(assert_return (invoke "i32.trunc_u_f32" (f32.const 2.0)) (i32.const 2))
(assert_return (invoke "i32.trunc_u_f32" (f32.const 2147483648)) (i32.const -2147483648)) ;; 0x1.00000p+31 -> 8000 0000
(assert_return (invoke "i32.trunc_u_f32" (f32.const 4294967040.0)) (i32.const -256))
(assert_return (invoke "i32.trunc_u_f32" (f32.const -0x1.ccccccp-1)) (i32.const 0))
(assert_return (invoke "i32.trunc_u_f32" (f32.const -0x1.fffffep-1)) (i32.const 0))
(assert_trap (invoke "i32.trunc_u_f32" (f32.const 4294967296.0)) "integer overflow")
(assert_trap (invoke "i32.trunc_u_f32" (f32.const -1.0)) "integer overflow")
(assert_trap (invoke "i32.trunc_u_f32" (f32.const inf)) "integer overflow")
(assert_trap (invoke "i32.trunc_u_f32" (f32.const -inf)) "integer overflow")
(assert_trap (invoke "i32.trunc_u_f32" (f32.const nan)) "invalid conversion to integer")
(assert_trap (invoke "i32.trunc_u_f32" (f32.const nan:0x200000)) "invalid conversion to integer")
(assert_trap (invoke "i32.trunc_u_f32" (f32.const -nan)) "invalid conversion to integer")
(assert_trap (invoke "i32.trunc_u_f32" (f32.const -nan:0x200000)) "invalid conversion to integer")
(assert_return (invoke "i32.trunc_s_f64" (f64.const 0.0)) (i32.const 0))
(assert_return (invoke "i32.trunc_s_f64" (f64.const -0.0)) (i32.const 0))
(assert_return (invoke "i32.trunc_s_f64" (f64.const 0x0.0000000000001p-1022)) (i32.const 0))
(assert_return (invoke "i32.trunc_s_f64" (f64.const -0x0.0000000000001p-1022)) (i32.const 0))
(assert_return (invoke "i32.trunc_s_f64" (f64.const 1.0)) (i32.const 1))
(assert_return (invoke "i32.trunc_s_f64" (f64.const 0x1.199999999999ap+0)) (i32.const 1))
(assert_return (invoke "i32.trunc_s_f64" (f64.const 1.5)) (i32.const 1))
(assert_return (invoke "i32.trunc_s_f64" (f64.const -1.0)) (i32.const -1))
(assert_return (invoke "i32.trunc_s_f64" (f64.const -0x1.199999999999ap+0)) (i32.const -1))
(assert_return (invoke "i32.trunc_s_f64" (f64.const -1.5)) (i32.const -1))
(assert_return (invoke "i32.trunc_s_f64" (f64.const -1.9)) (i32.const -1))
(assert_return (invoke "i32.trunc_s_f64" (f64.const -2.0)) (i32.const -2))
(assert_return (invoke "i32.trunc_s_f64" (f64.const 2147483647.0)) (i32.const 2147483647))
(assert_return (invoke "i32.trunc_s_f64" (f64.const -2147483648.0)) (i32.const -2147483648))
(assert_trap (invoke "i32.trunc_s_f64" (f64.const 2147483648.0)) "integer overflow")
(assert_trap (invoke "i32.trunc_s_f64" (f64.const -2147483649.0)) "integer overflow")
(assert_trap (invoke "i32.trunc_s_f64" (f64.const inf)) "integer overflow")
(assert_trap (invoke "i32.trunc_s_f64" (f64.const -inf)) "integer overflow")
(assert_trap (invoke "i32.trunc_s_f64" (f64.const nan)) "invalid conversion to integer")
(assert_trap (invoke "i32.trunc_s_f64" (f64.const nan:0x4000000000000)) "invalid conversion to integer")
(assert_trap (invoke "i32.trunc_s_f64" (f64.const -nan)) "invalid conversion to integer")
(assert_trap (invoke "i32.trunc_s_f64" (f64.const -nan:0x4000000000000)) "invalid conversion to integer")
(assert_return (invoke "i32.trunc_u_f64" (f64.const 0.0)) (i32.const 0))
(assert_return (invoke "i32.trunc_u_f64" (f64.const -0.0)) (i32.const 0))
(assert_return (invoke "i32.trunc_u_f64" (f64.const 0x0.0000000000001p-1022)) (i32.const 0))
(assert_return (invoke "i32.trunc_u_f64" (f64.const -0x0.0000000000001p-1022)) (i32.const 0))
(assert_return (invoke "i32.trunc_u_f64" (f64.const 1.0)) (i32.const 1))
(assert_return (invoke "i32.trunc_u_f64" (f64.const 0x1.199999999999ap+0)) (i32.const 1))
(assert_return (invoke "i32.trunc_u_f64" (f64.const 1.5)) (i32.const 1))
(assert_return (invoke "i32.trunc_u_f64" (f64.const 1.9)) (i32.const 1))
(assert_return (invoke "i32.trunc_u_f64" (f64.const 2.0)) (i32.const 2))
(assert_return (invoke "i32.trunc_u_f64" (f64.const 2147483648)) (i32.const -2147483648)) ;; 0x1.00000p+31 -> 8000 0000
(assert_return (invoke "i32.trunc_u_f64" (f64.const 4294967295.0)) (i32.const -1))
(assert_return (invoke "i32.trunc_u_f64" (f64.const -0x1.ccccccccccccdp-1)) (i32.const 0))
(assert_return (invoke "i32.trunc_u_f64" (f64.const -0x1.fffffffffffffp-1)) (i32.const 0))
(assert_return (invoke "i32.trunc_u_f64" (f64.const 1e8)) (i32.const 100000000))
(assert_trap (invoke "i32.trunc_u_f64" (f64.const 4294967296.0)) "integer overflow")
(assert_trap (invoke "i32.trunc_u_f64" (f64.const -1.0)) "integer overflow")
(assert_trap (invoke "i32.trunc_u_f64" (f64.const 1e16)) "integer overflow")
(assert_trap (invoke "i32.trunc_u_f64" (f64.const 1e30)) "integer overflow")
(assert_trap (invoke "i32.trunc_u_f64" (f64.const 9223372036854775808)) "integer overflow")
(assert_trap (invoke "i32.trunc_u_f64" (f64.const inf)) "integer overflow")
(assert_trap (invoke "i32.trunc_u_f64" (f64.const -inf)) "integer overflow")
(assert_trap (invoke "i32.trunc_u_f64" (f64.const nan)) "invalid conversion to integer")
(assert_trap (invoke "i32.trunc_u_f64" (f64.const nan:0x4000000000000)) "invalid conversion to integer")
(assert_trap (invoke "i32.trunc_u_f64" (f64.const -nan)) "invalid conversion to integer")
(assert_trap (invoke "i32.trunc_u_f64" (f64.const -nan:0x4000000000000)) "invalid conversion to integer")
(assert_return (invoke "i64.trunc_s_f32" (f32.const 0.0)) (i64.const 0))
(assert_return (invoke "i64.trunc_s_f32" (f32.const -0.0)) (i64.const 0))
(assert_return (invoke "i64.trunc_s_f32" (f32.const 0x1p-149)) (i64.const 0))
(assert_return (invoke "i64.trunc_s_f32" (f32.const -0x1p-149)) (i64.const 0))
(assert_return (invoke "i64.trunc_s_f32" (f32.const 1.0)) (i64.const 1))
(assert_return (invoke "i64.trunc_s_f32" (f32.const 0x1.19999ap+0)) (i64.const 1))
(assert_return (invoke "i64.trunc_s_f32" (f32.const 1.5)) (i64.const 1))
(assert_return (invoke "i64.trunc_s_f32" (f32.const -1.0)) (i64.const -1))
(assert_return (invoke "i64.trunc_s_f32" (f32.const -0x1.19999ap+0)) (i64.const -1))
(assert_return (invoke "i64.trunc_s_f32" (f32.const -1.5)) (i64.const -1))
(assert_return (invoke "i64.trunc_s_f32" (f32.const -1.9)) (i64.const -1))
(assert_return (invoke "i64.trunc_s_f32" (f32.const -2.0)) (i64.const -2))
(assert_return (invoke "i64.trunc_s_f32" (f32.const 4294967296)) (i64.const 4294967296)) ;; 0x1.00000p+32 -> 1 0000 0000
(assert_return (invoke "i64.trunc_s_f32" (f32.const -4294967296)) (i64.const -4294967296)) ;; -0x1.00000p+32 -> ffff ffff 0000 0000
(assert_return (invoke "i64.trunc_s_f32" (f32.const 9223371487098961920.0)) (i64.const 9223371487098961920))
(assert_return (invoke "i64.trunc_s_f32" (f32.const -9223372036854775808.0)) (i64.const -9223372036854775808))
(assert_trap (invoke "i64.trunc_s_f32" (f32.const 9223372036854775808.0)) "integer overflow")
(assert_trap (invoke "i64.trunc_s_f32" (f32.const -9223373136366403584.0)) "integer overflow")
(assert_trap (invoke "i64.trunc_s_f32" (f32.const inf)) "integer overflow")
(assert_trap (invoke "i64.trunc_s_f32" (f32.const -inf)) "integer overflow")
(assert_trap (invoke "i64.trunc_s_f32" (f32.const nan)) "invalid conversion to integer")
(assert_trap (invoke "i64.trunc_s_f32" (f32.const nan:0x200000)) "invalid conversion to integer")
(assert_trap (invoke "i64.trunc_s_f32" (f32.const -nan)) "invalid conversion to integer")
(assert_trap (invoke "i64.trunc_s_f32" (f32.const -nan:0x200000)) "invalid conversion to integer")
(assert_return (invoke "i64.trunc_u_f32" (f32.const 0.0)) (i64.const 0))
(assert_return (invoke "i64.trunc_u_f32" (f32.const -0.0)) (i64.const 0))
(assert_return (invoke "i64.trunc_u_f32" (f32.const 0x1p-149)) (i64.const 0))
(assert_return (invoke "i64.trunc_u_f32" (f32.const -0x1p-149)) (i64.const 0))
(assert_return (invoke "i64.trunc_u_f32" (f32.const 1.0)) (i64.const 1))
(assert_return (invoke "i64.trunc_u_f32" (f32.const 0x1.19999ap+0)) (i64.const 1))
(assert_return (invoke "i64.trunc_u_f32" (f32.const 1.5)) (i64.const 1))
(assert_return (invoke "i64.trunc_u_f32" (f32.const 4294967296)) (i64.const 4294967296))
(assert_return (invoke "i64.trunc_u_f32" (f32.const 18446742974197923840.0)) (i64.const -1099511627776))
(assert_return (invoke "i64.trunc_u_f32" (f32.const -0x1.ccccccp-1)) (i64.const 0))
(assert_return (invoke "i64.trunc_u_f32" (f32.const -0x1.fffffep-1)) (i64.const 0))
(assert_trap (invoke "i64.trunc_u_f32" (f32.const 18446744073709551616.0)) "integer overflow")
(assert_trap (invoke "i64.trunc_u_f32" (f32.const -1.0)) "integer overflow")
(assert_trap (invoke "i64.trunc_u_f32" (f32.const inf)) "integer overflow")
(assert_trap (invoke "i64.trunc_u_f32" (f32.const -inf)) "integer overflow")
(assert_trap (invoke "i64.trunc_u_f32" (f32.const nan)) "invalid conversion to integer")
(assert_trap (invoke "i64.trunc_u_f32" (f32.const nan:0x200000)) "invalid conversion to integer")
(assert_trap (invoke "i64.trunc_u_f32" (f32.const -nan)) "invalid conversion to integer")
(assert_trap (invoke "i64.trunc_u_f32" (f32.const -nan:0x200000)) "invalid conversion to integer")
(assert_return (invoke "i64.trunc_s_f64" (f64.const 0.0)) (i64.const 0))
(assert_return (invoke "i64.trunc_s_f64" (f64.const -0.0)) (i64.const 0))
(assert_return (invoke "i64.trunc_s_f64" (f64.const 0x0.0000000000001p-1022)) (i64.const 0))
(assert_return (invoke "i64.trunc_s_f64" (f64.const -0x0.0000000000001p-1022)) (i64.const 0))
(assert_return (invoke "i64.trunc_s_f64" (f64.const 1.0)) (i64.const 1))
(assert_return (invoke "i64.trunc_s_f64" (f64.const 0x1.199999999999ap+0)) (i64.const 1))
(assert_return (invoke "i64.trunc_s_f64" (f64.const 1.5)) (i64.const 1))
(assert_return (invoke "i64.trunc_s_f64" (f64.const -1.0)) (i64.const -1))
(assert_return (invoke "i64.trunc_s_f64" (f64.const -0x1.199999999999ap+0)) (i64.const -1))
(assert_return (invoke "i64.trunc_s_f64" (f64.const -1.5)) (i64.const -1))
(assert_return (invoke "i64.trunc_s_f64" (f64.const -1.9)) (i64.const -1))
(assert_return (invoke "i64.trunc_s_f64" (f64.const -2.0)) (i64.const -2))
(assert_return (invoke "i64.trunc_s_f64" (f64.const 4294967296)) (i64.const 4294967296)) ;; 0x1.00000p+32 -> 1 0000 0000
(assert_return (invoke "i64.trunc_s_f64" (f64.const -4294967296)) (i64.const -4294967296)) ;; -0x1.00000p+32 -> ffff ffff 0000 0000
(assert_return (invoke "i64.trunc_s_f64" (f64.const 9223372036854774784.0)) (i64.const 9223372036854774784))
(assert_return (invoke "i64.trunc_s_f64" (f64.const -9223372036854775808.0)) (i64.const -9223372036854775808))
(assert_trap (invoke "i64.trunc_s_f64" (f64.const 9223372036854775808.0)) "integer overflow")
(assert_trap (invoke "i64.trunc_s_f64" (f64.const -9223372036854777856.0)) "integer overflow")
(assert_trap (invoke "i64.trunc_s_f64" (f64.const inf)) "integer overflow")
(assert_trap (invoke "i64.trunc_s_f64" (f64.const -inf)) "integer overflow")
(assert_trap (invoke "i64.trunc_s_f64" (f64.const nan)) "invalid conversion to integer")
(assert_trap (invoke "i64.trunc_s_f64" (f64.const nan:0x4000000000000)) "invalid conversion to integer")
(assert_trap (invoke "i64.trunc_s_f64" (f64.const -nan)) "invalid conversion to integer")
(assert_trap (invoke "i64.trunc_s_f64" (f64.const -nan:0x4000000000000)) "invalid conversion to integer")
(assert_return (invoke "i64.trunc_u_f64" (f64.const 0.0)) (i64.const 0))
(assert_return (invoke "i64.trunc_u_f64" (f64.const -0.0)) (i64.const 0))
(assert_return (invoke "i64.trunc_u_f64" (f64.const 0x0.0000000000001p-1022)) (i64.const 0))
(assert_return (invoke "i64.trunc_u_f64" (f64.const -0x0.0000000000001p-1022)) (i64.const 0))
(assert_return (invoke "i64.trunc_u_f64" (f64.const 1.0)) (i64.const 1))
(assert_return (invoke "i64.trunc_u_f64" (f64.const 0x1.199999999999ap+0)) (i64.const 1))
(assert_return (invoke "i64.trunc_u_f64" (f64.const 1.5)) (i64.const 1))
(assert_return (invoke "i64.trunc_u_f64" (f64.const 4294967295)) (i64.const 0xffffffff))
(assert_return (invoke "i64.trunc_u_f64" (f64.const 4294967296)) (i64.const 0x100000000))
(assert_return (invoke "i64.trunc_u_f64" (f64.const 18446744073709549568.0)) (i64.const -2048))
(assert_return (invoke "i64.trunc_u_f64" (f64.const -0x1.ccccccccccccdp-1)) (i64.const 0))
(assert_return (invoke "i64.trunc_u_f64" (f64.const -0x1.fffffffffffffp-1)) (i64.const 0))
(assert_return (invoke "i64.trunc_u_f64" (f64.const 1e8)) (i64.const 100000000))
(assert_return (invoke "i64.trunc_u_f64" (f64.const 1e16)) (i64.const 10000000000000000))
(assert_return (invoke "i64.trunc_u_f64" (f64.const 9223372036854775808)) (i64.const -9223372036854775808))
(assert_trap (invoke "i64.trunc_u_f64" (f64.const 18446744073709551616.0)) "integer overflow")
(assert_trap (invoke "i64.trunc_u_f64" (f64.const -1.0)) "integer overflow")
(assert_trap (invoke "i64.trunc_u_f64" (f64.const inf)) "integer overflow")
(assert_trap (invoke "i64.trunc_u_f64" (f64.const -inf)) "integer overflow")
(assert_trap (invoke "i64.trunc_u_f64" (f64.const nan)) "invalid conversion to integer")
(assert_trap (invoke "i64.trunc_u_f64" (f64.const nan:0x4000000000000)) "invalid conversion to integer")
(assert_trap (invoke "i64.trunc_u_f64" (f64.const -nan)) "invalid conversion to integer")
(assert_trap (invoke "i64.trunc_u_f64" (f64.const -nan:0x4000000000000)) "invalid conversion to integer")
;; Saturating conversions: test all the same values as the non-saturating conversions.
(assert_return (invoke "i32.trunc_s:sat_f32" (f32.const 0.0)) (i32.const 0))
(assert_return (invoke "i32.trunc_s:sat_f32" (f32.const -0.0)) (i32.const 0))
(assert_return (invoke "i32.trunc_s:sat_f32" (f32.const 0x1p-149)) (i32.const 0))
(assert_return (invoke "i32.trunc_s:sat_f32" (f32.const -0x1p-149)) (i32.const 0))
(assert_return (invoke "i32.trunc_s:sat_f32" (f32.const 1.0)) (i32.const 1))
(assert_return (invoke "i32.trunc_s:sat_f32" (f32.const 0x1.19999ap+0)) (i32.const 1))
(assert_return (invoke "i32.trunc_s:sat_f32" (f32.const 1.5)) (i32.const 1))
(assert_return (invoke "i32.trunc_s:sat_f32" (f32.const -1.0)) (i32.const -1))
(assert_return (invoke "i32.trunc_s:sat_f32" (f32.const -0x1.19999ap+0)) (i32.const -1))
(assert_return (invoke "i32.trunc_s:sat_f32" (f32.const -1.5)) (i32.const -1))
(assert_return (invoke "i32.trunc_s:sat_f32" (f32.const -1.9)) (i32.const -1))
(assert_return (invoke "i32.trunc_s:sat_f32" (f32.const -2.0)) (i32.const -2))
(assert_return (invoke "i32.trunc_s:sat_f32" (f32.const 2147483520.0)) (i32.const 2147483520))
(assert_return (invoke "i32.trunc_s:sat_f32" (f32.const -2147483648.0)) (i32.const -2147483648))
(assert_return (invoke "i32.trunc_s:sat_f32" (f32.const 2147483648.0)) (i32.const 0x7fffffff))
(assert_return (invoke "i32.trunc_s:sat_f32" (f32.const -2147483904.0)) (i32.const 0x80000000))
(assert_return (invoke "i32.trunc_s:sat_f32" (f32.const inf)) (i32.const 0x7fffffff))
(assert_return (invoke "i32.trunc_s:sat_f32" (f32.const -inf)) (i32.const 0x80000000))
(assert_return (invoke "i32.trunc_s:sat_f32" (f32.const nan)) (i32.const 0))
(assert_return (invoke "i32.trunc_s:sat_f32" (f32.const nan:0x200000)) (i32.const 0))
(assert_return (invoke "i32.trunc_s:sat_f32" (f32.const -nan)) (i32.const 0))
(assert_return (invoke "i32.trunc_s:sat_f32" (f32.const -nan:0x200000)) (i32.const 0))
(assert_return (invoke "i32.trunc_u:sat_f32" (f32.const 0.0)) (i32.const 0))
(assert_return (invoke "i32.trunc_u:sat_f32" (f32.const -0.0)) (i32.const 0))
(assert_return (invoke "i32.trunc_u:sat_f32" (f32.const 0x1p-149)) (i32.const 0))
(assert_return (invoke "i32.trunc_u:sat_f32" (f32.const -0x1p-149)) (i32.const 0))
(assert_return (invoke "i32.trunc_u:sat_f32" (f32.const 1.0)) (i32.const 1))
(assert_return (invoke "i32.trunc_u:sat_f32" (f32.const 0x1.19999ap+0)) (i32.const 1))
(assert_return (invoke "i32.trunc_u:sat_f32" (f32.const 1.5)) (i32.const 1))
(assert_return (invoke "i32.trunc_u:sat_f32" (f32.const 1.9)) (i32.const 1))
(assert_return (invoke "i32.trunc_u:sat_f32" (f32.const 2.0)) (i32.const 2))
(assert_return (invoke "i32.trunc_u:sat_f32" (f32.const 2147483648)) (i32.const -2147483648)) ;; 0x1.00000p+31 -> 8000 0000
(assert_return (invoke "i32.trunc_u:sat_f32" (f32.const 4294967040.0)) (i32.const -256))
(assert_return (invoke "i32.trunc_u:sat_f32" (f32.const -0x1.ccccccp-1)) (i32.const 0))
(assert_return (invoke "i32.trunc_u:sat_f32" (f32.const -0x1.fffffep-1)) (i32.const 0))
(assert_return (invoke "i32.trunc_u:sat_f32" (f32.const 4294967296.0)) (i32.const 0xffffffff))
(assert_return (invoke "i32.trunc_u:sat_f32" (f32.const -1.0)) (i32.const 0x00000000))
(assert_return (invoke "i32.trunc_u:sat_f32" (f32.const inf)) (i32.const 0xffffffff))
(assert_return (invoke "i32.trunc_u:sat_f32" (f32.const -inf)) (i32.const 0x00000000))
(assert_return (invoke "i32.trunc_u:sat_f32" (f32.const nan)) (i32.const 0))
(assert_return (invoke "i32.trunc_u:sat_f32" (f32.const nan:0x200000)) (i32.const 0))
(assert_return (invoke "i32.trunc_u:sat_f32" (f32.const -nan)) (i32.const 0))
(assert_return (invoke "i32.trunc_u:sat_f32" (f32.const -nan:0x200000)) (i32.const 0))
(assert_return (invoke "i32.trunc_s:sat_f64" (f64.const 0.0)) (i32.const 0))
(assert_return (invoke "i32.trunc_s:sat_f64" (f64.const -0.0)) (i32.const 0))
(assert_return (invoke "i32.trunc_s:sat_f64" (f64.const 0x0.0000000000001p-1022)) (i32.const 0))
(assert_return (invoke "i32.trunc_s:sat_f64" (f64.const -0x0.0000000000001p-1022)) (i32.const 0))
(assert_return (invoke "i32.trunc_s:sat_f64" (f64.const 1.0)) (i32.const 1))
(assert_return (invoke "i32.trunc_s:sat_f64" (f64.const 0x1.199999999999ap+0)) (i32.const 1))
(assert_return (invoke "i32.trunc_s:sat_f64" (f64.const 1.5)) (i32.const 1))
(assert_return (invoke "i32.trunc_s:sat_f64" (f64.const -1.0)) (i32.const -1))
(assert_return (invoke "i32.trunc_s:sat_f64" (f64.const -0x1.199999999999ap+0)) (i32.const -1))
(assert_return (invoke "i32.trunc_s:sat_f64" (f64.const -1.5)) (i32.const -1))
(assert_return (invoke "i32.trunc_s:sat_f64" (f64.const -1.9)) (i32.const -1))
(assert_return (invoke "i32.trunc_s:sat_f64" (f64.const -2.0)) (i32.const -2))
(assert_return (invoke "i32.trunc_s:sat_f64" (f64.const 2147483647.0)) (i32.const 2147483647))
(assert_return (invoke "i32.trunc_s:sat_f64" (f64.const -2147483648.0)) (i32.const -2147483648))
(assert_return (invoke "i32.trunc_s:sat_f64" (f64.const 2147483648.0)) (i32.const 0x7fffffff))
(assert_return (invoke "i32.trunc_s:sat_f64" (f64.const -2147483649.0)) (i32.const 0x80000000))
(assert_return (invoke "i32.trunc_s:sat_f64" (f64.const inf)) (i32.const 0x7fffffff))
(assert_return (invoke "i32.trunc_s:sat_f64" (f64.const -inf)) (i32.const 0x80000000))
(assert_return (invoke "i32.trunc_s:sat_f64" (f64.const nan)) (i32.const 0))
(assert_return (invoke "i32.trunc_s:sat_f64" (f64.const nan:0x4000000000000)) (i32.const 0))
(assert_return (invoke "i32.trunc_s:sat_f64" (f64.const -nan)) (i32.const 0))
(assert_return (invoke "i32.trunc_s:sat_f64" (f64.const -nan:0x4000000000000)) (i32.const 0))
(assert_return (invoke "i32.trunc_u:sat_f64" (f64.const 0.0)) (i32.const 0))
(assert_return (invoke "i32.trunc_u:sat_f64" (f64.const -0.0)) (i32.const 0))
(assert_return (invoke "i32.trunc_u:sat_f64" (f64.const 0x0.0000000000001p-1022)) (i32.const 0))
(assert_return (invoke "i32.trunc_u:sat_f64" (f64.const -0x0.0000000000001p-1022)) (i32.const 0))
(assert_return (invoke "i32.trunc_u:sat_f64" (f64.const 1.0)) (i32.const 1))
(assert_return (invoke "i32.trunc_u:sat_f64" (f64.const 0x1.199999999999ap+0)) (i32.const 1))
(assert_return (invoke "i32.trunc_u:sat_f64" (f64.const 1.5)) (i32.const 1))
(assert_return (invoke "i32.trunc_u:sat_f64" (f64.const 1.9)) (i32.const 1))
(assert_return (invoke "i32.trunc_u:sat_f64" (f64.const 2.0)) (i32.const 2))
(assert_return (invoke "i32.trunc_u:sat_f64" (f64.const 2147483648)) (i32.const -2147483648)) ;; 0x1.00000p+31 -> 8000 0000
(assert_return (invoke "i32.trunc_u:sat_f64" (f64.const 4294967295.0)) (i32.const -1))
(assert_return (invoke "i32.trunc_u:sat_f64" (f64.const -0x1.ccccccccccccdp-1)) (i32.const 0))
(assert_return (invoke "i32.trunc_u:sat_f64" (f64.const -0x1.fffffffffffffp-1)) (i32.const 0))
(assert_return (invoke "i32.trunc_u:sat_f64" (f64.const 1e8)) (i32.const 100000000))
(assert_return (invoke "i32.trunc_u:sat_f64" (f64.const 4294967296.0)) (i32.const 0xffffffff))
(assert_return (invoke "i32.trunc_u:sat_f64" (f64.const -1.0)) (i32.const 0x00000000))
(assert_return (invoke "i32.trunc_u:sat_f64" (f64.const 1e16)) (i32.const 0xffffffff))
(assert_return (invoke "i32.trunc_u:sat_f64" (f64.const 1e30)) (i32.const 0xffffffff))
(assert_return (invoke "i32.trunc_u:sat_f64" (f64.const 9223372036854775808)) (i32.const 0xffffffff))
(assert_return (invoke "i32.trunc_u:sat_f64" (f64.const inf)) (i32.const 0xffffffff))
(assert_return (invoke "i32.trunc_u:sat_f64" (f64.const -inf)) (i32.const 0x00000000))
(assert_return (invoke "i32.trunc_u:sat_f64" (f64.const nan)) (i32.const 0))
(assert_return (invoke "i32.trunc_u:sat_f64" (f64.const nan:0x4000000000000)) (i32.const 0))
(assert_return (invoke "i32.trunc_u:sat_f64" (f64.const -nan)) (i32.const 0))
(assert_return (invoke "i32.trunc_u:sat_f64" (f64.const -nan:0x4000000000000)) (i32.const 0))
(assert_return (invoke "i64.trunc_s:sat_f32" (f32.const 0.0)) (i64.const 0))
(assert_return (invoke "i64.trunc_s:sat_f32" (f32.const -0.0)) (i64.const 0))
(assert_return (invoke "i64.trunc_s:sat_f32" (f32.const 0x1p-149)) (i64.const 0))
(assert_return (invoke "i64.trunc_s:sat_f32" (f32.const -0x1p-149)) (i64.const 0))
(assert_return (invoke "i64.trunc_s:sat_f32" (f32.const 1.0)) (i64.const 1))
(assert_return (invoke "i64.trunc_s:sat_f32" (f32.const 0x1.19999ap+0)) (i64.const 1))
(assert_return (invoke "i64.trunc_s:sat_f32" (f32.const 1.5)) (i64.const 1))
(assert_return (invoke "i64.trunc_s:sat_f32" (f32.const -1.0)) (i64.const -1))
(assert_return (invoke "i64.trunc_s:sat_f32" (f32.const -0x1.19999ap+0)) (i64.const -1))
(assert_return (invoke "i64.trunc_s:sat_f32" (f32.const -1.5)) (i64.const -1))
(assert_return (invoke "i64.trunc_s:sat_f32" (f32.const -1.9)) (i64.const -1))
(assert_return (invoke "i64.trunc_s:sat_f32" (f32.const -2.0)) (i64.const -2))
(assert_return (invoke "i64.trunc_s:sat_f32" (f32.const 4294967296)) (i64.const 4294967296)) ;; 0x1.00000p+32 -> 1 0000 0000
(assert_return (invoke "i64.trunc_s:sat_f32" (f32.const -4294967296)) (i64.const -4294967296)) ;; -0x1.00000p+32 -> ffff ffff 0000 0000
(assert_return (invoke "i64.trunc_s:sat_f32" (f32.const 9223371487098961920.0)) (i64.const 9223371487098961920))
(assert_return (invoke "i64.trunc_s:sat_f32" (f32.const -9223372036854775808.0)) (i64.const -9223372036854775808))
(assert_return (invoke "i64.trunc_s:sat_f32" (f32.const 9223372036854775808.0)) (i64.const 0x7fffffffffffffff))
(assert_return (invoke "i64.trunc_s:sat_f32" (f32.const -9223373136366403584.0)) (i64.const 0x8000000000000000))
(assert_return (invoke "i64.trunc_s:sat_f32" (f32.const inf)) (i64.const 0x7fffffffffffffff))
(assert_return (invoke "i64.trunc_s:sat_f32" (f32.const -inf)) (i64.const 0x8000000000000000))
(assert_return (invoke "i64.trunc_s:sat_f32" (f32.const nan)) (i64.const 0))
(assert_return (invoke "i64.trunc_s:sat_f32" (f32.const nan:0x200000)) (i64.const 0))
(assert_return (invoke "i64.trunc_s:sat_f32" (f32.const -nan)) (i64.const 0))
(assert_return (invoke "i64.trunc_s:sat_f32" (f32.const -nan:0x200000)) (i64.const 0))
(assert_return (invoke "i64.trunc_u:sat_f32" (f32.const 0.0)) (i64.const 0))
(assert_return (invoke "i64.trunc_u:sat_f32" (f32.const -0.0)) (i64.const 0))
(assert_return (invoke "i64.trunc_u:sat_f32" (f32.const 0x1p-149)) (i64.const 0))
(assert_return (invoke "i64.trunc_u:sat_f32" (f32.const -0x1p-149)) (i64.const 0))
(assert_return (invoke "i64.trunc_u:sat_f32" (f32.const 1.0)) (i64.const 1))
(assert_return (invoke "i64.trunc_u:sat_f32" (f32.const 0x1.19999ap+0)) (i64.const 1))
(assert_return (invoke "i64.trunc_u:sat_f32" (f32.const 1.5)) (i64.const 1))
(assert_return (invoke "i64.trunc_u:sat_f32" (f32.const 4294967296)) (i64.const 4294967296))
(assert_return (invoke "i64.trunc_u:sat_f32" (f32.const 18446742974197923840.0)) (i64.const -1099511627776))
(assert_return (invoke "i64.trunc_u:sat_f32" (f32.const -0x1.ccccccp-1)) (i64.const 0))
(assert_return (invoke "i64.trunc_u:sat_f32" (f32.const -0x1.fffffep-1)) (i64.const 0))
(assert_return (invoke "i64.trunc_u:sat_f32" (f32.const 18446744073709551616.0)) (i64.const 0xffffffffffffffff))
(assert_return (invoke "i64.trunc_u:sat_f32" (f32.const -1.0)) (i64.const 0x0000000000000000))
(assert_return (invoke "i64.trunc_u:sat_f32" (f32.const inf)) (i64.const 0xffffffffffffffff))
(assert_return (invoke "i64.trunc_u:sat_f32" (f32.const -inf)) (i64.const 0x0000000000000000))
(assert_return (invoke "i64.trunc_u:sat_f32" (f32.const nan)) (i64.const 0))
(assert_return (invoke "i64.trunc_u:sat_f32" (f32.const nan:0x200000)) (i64.const 0))
(assert_return (invoke "i64.trunc_u:sat_f32" (f32.const -nan)) (i64.const 0))
(assert_return (invoke "i64.trunc_u:sat_f32" (f32.const -nan:0x200000)) (i64.const 0))
(assert_return (invoke "i64.trunc_s:sat_f64" (f64.const 0.0)) (i64.const 0))
(assert_return (invoke "i64.trunc_s:sat_f64" (f64.const -0.0)) (i64.const 0))
(assert_return (invoke "i64.trunc_s:sat_f64" (f64.const 0x0.0000000000001p-1022)) (i64.const 0))
(assert_return (invoke "i64.trunc_s:sat_f64" (f64.const -0x0.0000000000001p-1022)) (i64.const 0))
(assert_return (invoke "i64.trunc_s:sat_f64" (f64.const 1.0)) (i64.const 1))
(assert_return (invoke "i64.trunc_s:sat_f64" (f64.const 0x1.199999999999ap+0)) (i64.const 1))
(assert_return (invoke "i64.trunc_s:sat_f64" (f64.const 1.5)) (i64.const 1))
(assert_return (invoke "i64.trunc_s:sat_f64" (f64.const -1.0)) (i64.const -1))
(assert_return (invoke "i64.trunc_s:sat_f64" (f64.const -0x1.199999999999ap+0)) (i64.const -1))
(assert_return (invoke "i64.trunc_s:sat_f64" (f64.const -1.5)) (i64.const -1))
(assert_return (invoke "i64.trunc_s:sat_f64" (f64.const -1.9)) (i64.const -1))
(assert_return (invoke "i64.trunc_s:sat_f64" (f64.const -2.0)) (i64.const -2))
(assert_return (invoke "i64.trunc_s:sat_f64" (f64.const 4294967296)) (i64.const 4294967296)) ;; 0x1.00000p+32 -> 1 0000 0000
(assert_return (invoke "i64.trunc_s:sat_f64" (f64.const -4294967296)) (i64.const -4294967296)) ;; -0x1.00000p+32 -> ffff ffff 0000 0000
(assert_return (invoke "i64.trunc_s:sat_f64" (f64.const 9223372036854774784.0)) (i64.const 9223372036854774784))
(assert_return (invoke "i64.trunc_s:sat_f64" (f64.const -9223372036854775808.0)) (i64.const -9223372036854775808))
(assert_return (invoke "i64.trunc_s:sat_f64" (f64.const 9223372036854775808.0)) (i64.const 0x7fffffffffffffff))
(assert_return (invoke "i64.trunc_s:sat_f64" (f64.const -9223372036854777856.0)) (i64.const 0x8000000000000000))
(assert_return (invoke "i64.trunc_s:sat_f64" (f64.const inf)) (i64.const 0x7fffffffffffffff))
(assert_return (invoke "i64.trunc_s:sat_f64" (f64.const -inf)) (i64.const 0x8000000000000000))
(assert_return (invoke "i64.trunc_s:sat_f64" (f64.const nan)) (i64.const 0))
(assert_return (invoke "i64.trunc_s:sat_f64" (f64.const nan:0x4000000000000)) (i64.const 0))
(assert_return (invoke "i64.trunc_s:sat_f64" (f64.const -nan)) (i64.const 0))
(assert_return (invoke "i64.trunc_s:sat_f64" (f64.const -nan:0x4000000000000)) (i64.const 0))
(assert_return (invoke "i64.trunc_u:sat_f64" (f64.const 0.0)) (i64.const 0))
(assert_return (invoke "i64.trunc_u:sat_f64" (f64.const -0.0)) (i64.const 0))
(assert_return (invoke "i64.trunc_u:sat_f64" (f64.const 0x0.0000000000001p-1022)) (i64.const 0))
(assert_return (invoke "i64.trunc_u:sat_f64" (f64.const -0x0.0000000000001p-1022)) (i64.const 0))
(assert_return (invoke "i64.trunc_u:sat_f64" (f64.const 1.0)) (i64.const 1))
(assert_return (invoke "i64.trunc_u:sat_f64" (f64.const 0x1.199999999999ap+0)) (i64.const 1))
(assert_return (invoke "i64.trunc_u:sat_f64" (f64.const 1.5)) (i64.const 1))
(assert_return (invoke "i64.trunc_u:sat_f64" (f64.const 4294967295)) (i64.const 0xffffffff))
(assert_return (invoke "i64.trunc_u:sat_f64" (f64.const 4294967296)) (i64.const 0x100000000))
(assert_return (invoke "i64.trunc_u:sat_f64" (f64.const 18446744073709549568.0)) (i64.const -2048))
(assert_return (invoke "i64.trunc_u:sat_f64" (f64.const -0x1.ccccccccccccdp-1)) (i64.const 0))
(assert_return (invoke "i64.trunc_u:sat_f64" (f64.const -0x1.fffffffffffffp-1)) (i64.const 0))
(assert_return (invoke "i64.trunc_u:sat_f64" (f64.const 1e8)) (i64.const 100000000))
(assert_return (invoke "i64.trunc_u:sat_f64" (f64.const 1e16)) (i64.const 10000000000000000))
(assert_return (invoke "i64.trunc_u:sat_f64" (f64.const 9223372036854775808)) (i64.const -9223372036854775808))
(assert_return (invoke "i64.trunc_u:sat_f64" (f64.const 18446744073709551616.0)) (i64.const 0xffffffffffffffff))
(assert_return (invoke "i64.trunc_u:sat_f64" (f64.const -1.0)) (i64.const 0x0000000000000000))
(assert_return (invoke "i64.trunc_u:sat_f64" (f64.const inf)) (i64.const 0xffffffffffffffff))
(assert_return (invoke "i64.trunc_u:sat_f64" (f64.const -inf)) (i64.const 0x0000000000000000))
(assert_return (invoke "i64.trunc_u:sat_f64" (f64.const nan)) (i64.const 0))
(assert_return (invoke "i64.trunc_u:sat_f64" (f64.const nan:0x4000000000000)) (i64.const 0))
(assert_return (invoke "i64.trunc_u:sat_f64" (f64.const -nan)) (i64.const 0))
(assert_return (invoke "i64.trunc_u:sat_f64" (f64.const -nan:0x4000000000000)) (i64.const 0))
(assert_return (invoke "f32.convert_s_i32" (i32.const 1)) (f32.const 1.0))
(assert_return (invoke "f32.convert_s_i32" (i32.const -1)) (f32.const -1.0))
(assert_return (invoke "f32.convert_s_i32" (i32.const 0)) (f32.const 0.0))
(assert_return (invoke "f32.convert_s_i32" (i32.const 2147483647)) (f32.const 2147483648))
(assert_return (invoke "f32.convert_s_i32" (i32.const -2147483648)) (f32.const -2147483648))
(assert_return (invoke "f32.convert_s_i32" (i32.const 1234567890)) (f32.const 0x1.26580cp+30))
;; Test rounding directions.
(assert_return (invoke "f32.convert_s_i32" (i32.const 16777217)) (f32.const 16777216.0))
(assert_return (invoke "f32.convert_s_i32" (i32.const -16777217)) (f32.const -16777216.0))
(assert_return (invoke "f32.convert_s_i32" (i32.const 16777219)) (f32.const 16777220.0))
(assert_return (invoke "f32.convert_s_i32" (i32.const -16777219)) (f32.const -16777220.0))
(assert_return (invoke "f32.convert_s_i64" (i64.const 1)) (f32.const 1.0))
(assert_return (invoke "f32.convert_s_i64" (i64.const -1)) (f32.const -1.0))
(assert_return (invoke "f32.convert_s_i64" (i64.const 0)) (f32.const 0.0))
(assert_return (invoke "f32.convert_s_i64" (i64.const 9223372036854775807)) (f32.const 9223372036854775807))
(assert_return (invoke "f32.convert_s_i64" (i64.const -9223372036854775808)) (f32.const -9223372036854775808))
(assert_return (invoke "f32.convert_s_i64" (i64.const 314159265358979)) (f32.const 0x1.1db9e8p+48)) ;; PI
;; Test rounding directions.
(assert_return (invoke "f32.convert_s_i64" (i64.const 16777217)) (f32.const 16777216.0))
(assert_return (invoke "f32.convert_s_i64" (i64.const -16777217)) (f32.const -16777216.0))
(assert_return (invoke "f32.convert_s_i64" (i64.const 16777219)) (f32.const 16777220.0))
(assert_return (invoke "f32.convert_s_i64" (i64.const -16777219)) (f32.const -16777220.0))
(assert_return (invoke "f64.convert_s_i32" (i32.const 1)) (f64.const 1.0))
(assert_return (invoke "f64.convert_s_i32" (i32.const -1)) (f64.const -1.0))
(assert_return (invoke "f64.convert_s_i32" (i32.const 0)) (f64.const 0.0))
(assert_return (invoke "f64.convert_s_i32" (i32.const 2147483647)) (f64.const 2147483647))
(assert_return (invoke "f64.convert_s_i32" (i32.const -2147483648)) (f64.const -2147483648))
(assert_return (invoke "f64.convert_s_i32" (i32.const 987654321)) (f64.const 987654321))
(assert_return (invoke "f64.convert_s_i64" (i64.const 1)) (f64.const 1.0))
(assert_return (invoke "f64.convert_s_i64" (i64.const -1)) (f64.const -1.0))
(assert_return (invoke "f64.convert_s_i64" (i64.const 0)) (f64.const 0.0))
(assert_return (invoke "f64.convert_s_i64" (i64.const 9223372036854775807)) (f64.const 9223372036854775807))
(assert_return (invoke "f64.convert_s_i64" (i64.const -9223372036854775808)) (f64.const -9223372036854775808))
(assert_return (invoke "f64.convert_s_i64" (i64.const 4669201609102990)) (f64.const 4669201609102990)) ;; Feigenbaum
;; Test rounding directions.
(assert_return (invoke "f64.convert_s_i64" (i64.const 9007199254740993)) (f64.const 9007199254740992))
(assert_return (invoke "f64.convert_s_i64" (i64.const -9007199254740993)) (f64.const -9007199254740992))
(assert_return (invoke "f64.convert_s_i64" (i64.const 9007199254740995)) (f64.const 9007199254740996))
(assert_return (invoke "f64.convert_s_i64" (i64.const -9007199254740995)) (f64.const -9007199254740996))
(assert_return (invoke "f32.convert_u_i32" (i32.const 1)) (f32.const 1.0))
(assert_return (invoke "f32.convert_u_i32" (i32.const 0)) (f32.const 0.0))
(assert_return (invoke "f32.convert_u_i32" (i32.const 2147483647)) (f32.const 2147483648))
(assert_return (invoke "f32.convert_u_i32" (i32.const -2147483648)) (f32.const 2147483648))
(assert_return (invoke "f32.convert_u_i32" (i32.const 0x12345678)) (f32.const 0x1.234568p+28))
(assert_return (invoke "f32.convert_u_i32" (i32.const 0xffffffff)) (f32.const 4294967296.0))
(assert_return (invoke "f32.convert_u_i32" (i32.const 0x80000080)) (f32.const 0x1.000000p+31))
(assert_return (invoke "f32.convert_u_i32" (i32.const 0x80000081)) (f32.const 0x1.000002p+31))
(assert_return (invoke "f32.convert_u_i32" (i32.const 0x80000082)) (f32.const 0x1.000002p+31))
(assert_return (invoke "f32.convert_u_i32" (i32.const 0xfffffe80)) (f32.const 0x1.fffffcp+31))
(assert_return (invoke "f32.convert_u_i32" (i32.const 0xfffffe81)) (f32.const 0x1.fffffep+31))
(assert_return (invoke "f32.convert_u_i32" (i32.const 0xfffffe82)) (f32.const 0x1.fffffep+31))
;; Test rounding directions.
(assert_return (invoke "f32.convert_u_i32" (i32.const 16777217)) (f32.const 16777216.0))
(assert_return (invoke "f32.convert_u_i32" (i32.const 16777219)) (f32.const 16777220.0))
(assert_return (invoke "f32.convert_u_i64" (i64.const 1)) (f32.const 1.0))
(assert_return (invoke "f32.convert_u_i64" (i64.const 0)) (f32.const 0.0))
(assert_return (invoke "f32.convert_u_i64" (i64.const 9223372036854775807)) (f32.const 9223372036854775807))
(assert_return (invoke "f32.convert_u_i64" (i64.const -9223372036854775808)) (f32.const 9223372036854775808))
(assert_return (invoke "f32.convert_u_i64" (i64.const 0xffffffffffffffff)) (f32.const 18446744073709551616.0))
;; Test rounding directions.
(assert_return (invoke "f32.convert_u_i64" (i64.const 16777217)) (f32.const 16777216.0))
(assert_return (invoke "f32.convert_u_i64" (i64.const 16777219)) (f32.const 16777220.0))
(assert_return (invoke "f64.convert_u_i32" (i32.const 1)) (f64.const 1.0))
(assert_return (invoke "f64.convert_u_i32" (i32.const 0)) (f64.const 0.0))
(assert_return (invoke "f64.convert_u_i32" (i32.const 2147483647)) (f64.const 2147483647))
(assert_return (invoke "f64.convert_u_i32" (i32.const -2147483648)) (f64.const 2147483648))
(assert_return (invoke "f64.convert_u_i32" (i32.const 0xffffffff)) (f64.const 4294967295.0))
(assert_return (invoke "f64.convert_u_i64" (i64.const 1)) (f64.const 1.0))
(assert_return (invoke "f64.convert_u_i64" (i64.const 0)) (f64.const 0.0))
(assert_return (invoke "f64.convert_u_i64" (i64.const 9223372036854775807)) (f64.const 9223372036854775807))
(assert_return (invoke "f64.convert_u_i64" (i64.const -9223372036854775808)) (f64.const 9223372036854775808))
(assert_return (invoke "f64.convert_u_i64" (i64.const 0xffffffffffffffff)) (f64.const 18446744073709551616.0))
(assert_return (invoke "f64.convert_u_i64" (i64.const 0x8000000000000400)) (f64.const 0x1.0000000000000p+63))
(assert_return (invoke "f64.convert_u_i64" (i64.const 0x8000000000000401)) (f64.const 0x1.0000000000001p+63))
(assert_return (invoke "f64.convert_u_i64" (i64.const 0x8000000000000402)) (f64.const 0x1.0000000000001p+63))
(assert_return (invoke "f64.convert_u_i64" (i64.const 0xfffffffffffff400)) (f64.const 0x1.ffffffffffffep+63))
(assert_return (invoke "f64.convert_u_i64" (i64.const 0xfffffffffffff401)) (f64.const 0x1.fffffffffffffp+63))
(assert_return (invoke "f64.convert_u_i64" (i64.const 0xfffffffffffff402)) (f64.const 0x1.fffffffffffffp+63))
;; Test rounding directions.
(assert_return (invoke "f64.convert_u_i64" (i64.const 9007199254740993)) (f64.const 9007199254740992))
(assert_return (invoke "f64.convert_u_i64" (i64.const 9007199254740995)) (f64.const 9007199254740996))
(assert_return (invoke "f64.promote_f32" (f32.const 0.0)) (f64.const 0.0))
(assert_return (invoke "f64.promote_f32" (f32.const -0.0)) (f64.const -0.0))
(assert_return (invoke "f64.promote_f32" (f32.const 0x1p-149)) (f64.const 0x1p-149))
(assert_return (invoke "f64.promote_f32" (f32.const -0x1p-149)) (f64.const -0x1p-149))
(assert_return (invoke "f64.promote_f32" (f32.const 1.0)) (f64.const 1.0))
(assert_return (invoke "f64.promote_f32" (f32.const -1.0)) (f64.const -1.0))
(assert_return (invoke "f64.promote_f32" (f32.const -0x1.fffffep+127)) (f64.const -0x1.fffffep+127))
(assert_return (invoke "f64.promote_f32" (f32.const 0x1.fffffep+127)) (f64.const 0x1.fffffep+127))
;; Generated randomly by picking a random int and reinterpret it to float.
(assert_return (invoke "f64.promote_f32" (f32.const 0x1p-119)) (f64.const 0x1p-119))
;; Generated randomly by picking a random float.
(assert_return (invoke "f64.promote_f32" (f32.const 0x1.8f867ep+125)) (f64.const 6.6382536710104395e+37))
(assert_return (invoke "f64.promote_f32" (f32.const inf)) (f64.const inf))
(assert_return (invoke "f64.promote_f32" (f32.const -inf)) (f64.const -inf))
(assert_return_canonical_nan (invoke "f64.promote_f32" (f32.const nan)))
(assert_return_arithmetic_nan (invoke "f64.promote_f32" (f32.const nan:0x200000)))
(assert_return_canonical_nan (invoke "f64.promote_f32" (f32.const -nan)))
(assert_return_arithmetic_nan (invoke "f64.promote_f32" (f32.const -nan:0x200000)))
(assert_return (invoke "f32.demote_f64" (f64.const 0.0)) (f32.const 0.0))
(assert_return (invoke "f32.demote_f64" (f64.const -0.0)) (f32.const -0.0))
(assert_return (invoke "f32.demote_f64" (f64.const 0x0.0000000000001p-1022)) (f32.const 0.0))
(assert_return (invoke "f32.demote_f64" (f64.const -0x0.0000000000001p-1022)) (f32.const -0.0))
(assert_return (invoke "f32.demote_f64" (f64.const 1.0)) (f32.const 1.0))
(assert_return (invoke "f32.demote_f64" (f64.const -1.0)) (f32.const -1.0))
(assert_return (invoke "f32.demote_f64" (f64.const 0x1.fffffe0000000p-127)) (f32.const 0x1p-126))
(assert_return (invoke "f32.demote_f64" (f64.const -0x1.fffffe0000000p-127)) (f32.const -0x1p-126))
(assert_return (invoke "f32.demote_f64" (f64.const 0x1.fffffdfffffffp-127)) (f32.const 0x1.fffffcp-127))
(assert_return (invoke "f32.demote_f64" (f64.const -0x1.fffffdfffffffp-127)) (f32.const -0x1.fffffcp-127))
(assert_return (invoke "f32.demote_f64" (f64.const 0x1p-149)) (f32.const 0x1p-149))
(assert_return (invoke "f32.demote_f64" (f64.const -0x1p-149)) (f32.const -0x1p-149))
(assert_return (invoke "f32.demote_f64" (f64.const 0x1.fffffd0000000p+127)) (f32.const 0x1.fffffcp+127))
(assert_return (invoke "f32.demote_f64" (f64.const -0x1.fffffd0000000p+127)) (f32.const -0x1.fffffcp+127))
(assert_return (invoke "f32.demote_f64" (f64.const 0x1.fffffd0000001p+127)) (f32.const 0x1.fffffep+127))
(assert_return (invoke "f32.demote_f64" (f64.const -0x1.fffffd0000001p+127)) (f32.const -0x1.fffffep+127))
(assert_return (invoke "f32.demote_f64" (f64.const 0x1.fffffep+127)) (f32.const 0x1.fffffep+127))
(assert_return (invoke "f32.demote_f64" (f64.const -0x1.fffffep+127)) (f32.const -0x1.fffffep+127))
(assert_return (invoke "f32.demote_f64" (f64.const 0x1.fffffefffffffp+127)) (f32.const 0x1.fffffep+127))
(assert_return (invoke "f32.demote_f64" (f64.const -0x1.fffffefffffffp+127)) (f32.const -0x1.fffffep+127))
(assert_return (invoke "f32.demote_f64" (f64.const 0x1.ffffffp+127)) (f32.const inf))
(assert_return (invoke "f32.demote_f64" (f64.const -0x1.ffffffp+127)) (f32.const -inf))
(assert_return (invoke "f32.demote_f64" (f64.const 0x1p-119)) (f32.const 0x1p-119))
(assert_return (invoke "f32.demote_f64" (f64.const 0x1.8f867ep+125)) (f32.const 0x1.8f867ep+125))
(assert_return (invoke "f32.demote_f64" (f64.const inf)) (f32.const inf))
(assert_return (invoke "f32.demote_f64" (f64.const -inf)) (f32.const -inf))
(assert_return (invoke "f32.demote_f64" (f64.const 0x1.0000000000001p+0)) (f32.const 1.0))
(assert_return (invoke "f32.demote_f64" (f64.const 0x1.fffffffffffffp-1)) (f32.const 1.0))
(assert_return (invoke "f32.demote_f64" (f64.const 0x1.0000010000000p+0)) (f32.const 0x1.000000p+0))
(assert_return (invoke "f32.demote_f64" (f64.const 0x1.0000010000001p+0)) (f32.const 0x1.000002p+0))
(assert_return (invoke "f32.demote_f64" (f64.const 0x1.000002fffffffp+0)) (f32.const 0x1.000002p+0))
(assert_return (invoke "f32.demote_f64" (f64.const 0x1.0000030000000p+0)) (f32.const 0x1.000004p+0))
(assert_return (invoke "f32.demote_f64" (f64.const 0x1.0000050000000p+0)) (f32.const 0x1.000004p+0))
(assert_return (invoke "f32.demote_f64" (f64.const 0x1.0000010000000p+24)) (f32.const 0x1.0p+24))
(assert_return (invoke "f32.demote_f64" (f64.const 0x1.0000010000001p+24)) (f32.const 0x1.000002p+24))
(assert_return (invoke "f32.demote_f64" (f64.const 0x1.000002fffffffp+24)) (f32.const 0x1.000002p+24))
(assert_return (invoke "f32.demote_f64" (f64.const 0x1.0000030000000p+24)) (f32.const 0x1.000004p+24))
(assert_return (invoke "f32.demote_f64" (f64.const 0x1.4eae4f7024c7p+108)) (f32.const 0x1.4eae5p+108))
(assert_return (invoke "f32.demote_f64" (f64.const 0x1.a12e71e358685p-113)) (f32.const 0x1.a12e72p-113))
(assert_return (invoke "f32.demote_f64" (f64.const 0x1.cb98354d521ffp-127)) (f32.const 0x1.cb9834p-127))
(assert_return (invoke "f32.demote_f64" (f64.const -0x1.6972b30cfb562p+1)) (f32.const -0x1.6972b4p+1))
(assert_return (invoke "f32.demote_f64" (f64.const -0x1.bedbe4819d4c4p+112)) (f32.const -0x1.bedbe4p+112))
(assert_return_canonical_nan (invoke "f32.demote_f64" (f64.const nan)))
(assert_return_arithmetic_nan (invoke "f32.demote_f64" (f64.const nan:0x4000000000000)))
(assert_return_canonical_nan (invoke "f32.demote_f64" (f64.const -nan)))
(assert_return_arithmetic_nan (invoke "f32.demote_f64" (f64.const -nan:0x4000000000000)))
(assert_return (invoke "f32.demote_f64" (f64.const 0x1p-1022)) (f32.const 0.0))
(assert_return (invoke "f32.demote_f64" (f64.const -0x1p-1022)) (f32.const -0.0))
(assert_return (invoke "f32.demote_f64" (f64.const 0x1.0p-150)) (f32.const 0.0))
(assert_return (invoke "f32.demote_f64" (f64.const -0x1.0p-150)) (f32.const -0.0))
(assert_return (invoke "f32.demote_f64" (f64.const 0x1.0000000000001p-150)) (f32.const 0x1p-149))
(assert_return (invoke "f32.demote_f64" (f64.const -0x1.0000000000001p-150)) (f32.const -0x1p-149))
(assert_return (invoke "f32.reinterpret_i32" (i32.const 0)) (f32.const 0.0))
(assert_return (invoke "f32.reinterpret_i32" (i32.const 0x80000000)) (f32.const -0.0))
(assert_return (invoke "f32.reinterpret_i32" (i32.const 1)) (f32.const 0x1p-149))
(assert_return (invoke "f32.reinterpret_i32" (i32.const -1)) (f32.const -nan:0x7fffff))
(assert_return (invoke "f32.reinterpret_i32" (i32.const 123456789)) (f32.const 0x1.b79a2ap-113))
(assert_return (invoke "f32.reinterpret_i32" (i32.const -2147483647)) (f32.const -0x1p-149))
(assert_return (invoke "f32.reinterpret_i32" (i32.const 0x7f800000)) (f32.const inf))
(assert_return (invoke "f32.reinterpret_i32" (i32.const 0xff800000)) (f32.const -inf))
(assert_return (invoke "f32.reinterpret_i32" (i32.const 0x7fc00000)) (f32.const nan))
(assert_return (invoke "f32.reinterpret_i32" (i32.const 0xffc00000)) (f32.const -nan))
(assert_return (invoke "f32.reinterpret_i32" (i32.const 0x7fa00000)) (f32.const nan:0x200000))
(assert_return (invoke "f32.reinterpret_i32" (i32.const 0xffa00000)) (f32.const -nan:0x200000))
(assert_return (invoke "f64.reinterpret_i64" (i64.const 0)) (f64.const 0.0))
(assert_return (invoke "f64.reinterpret_i64" (i64.const 1)) (f64.const 0x0.0000000000001p-1022))
(assert_return (invoke "f64.reinterpret_i64" (i64.const -1)) (f64.const -nan:0xfffffffffffff))
(assert_return (invoke "f64.reinterpret_i64" (i64.const 0x8000000000000000)) (f64.const -0.0))
(assert_return (invoke "f64.reinterpret_i64" (i64.const 1234567890)) (f64.const 0x0.00000499602d2p-1022))
(assert_return (invoke "f64.reinterpret_i64" (i64.const -9223372036854775807)) (f64.const -0x0.0000000000001p-1022))
(assert_return (invoke "f64.reinterpret_i64" (i64.const 0x7ff0000000000000)) (f64.const inf))
(assert_return (invoke "f64.reinterpret_i64" (i64.const 0xfff0000000000000)) (f64.const -inf))
(assert_return (invoke "f64.reinterpret_i64" (i64.const 0x7ff8000000000000)) (f64.const nan))
(assert_return (invoke "f64.reinterpret_i64" (i64.const 0xfff8000000000000)) (f64.const -nan))
(assert_return (invoke "f64.reinterpret_i64" (i64.const 0x7ff4000000000000)) (f64.const nan:0x4000000000000))
(assert_return (invoke "f64.reinterpret_i64" (i64.const 0xfff4000000000000)) (f64.const -nan:0x4000000000000))
(assert_return (invoke "i32.reinterpret_f32" (f32.const 0.0)) (i32.const 0))
(assert_return (invoke "i32.reinterpret_f32" (f32.const -0.0)) (i32.const 0x80000000))
(assert_return (invoke "i32.reinterpret_f32" (f32.const 0x1p-149)) (i32.const 1))
(assert_return (invoke "i32.reinterpret_f32" (f32.const -nan:0x7fffff)) (i32.const -1))
(assert_return (invoke "i32.reinterpret_f32" (f32.const -0x1p-149)) (i32.const 0x80000001))
(assert_return (invoke "i32.reinterpret_f32" (f32.const 1.0)) (i32.const 1065353216))
(assert_return (invoke "i32.reinterpret_f32" (f32.const 3.1415926)) (i32.const 1078530010))
(assert_return (invoke "i32.reinterpret_f32" (f32.const 0x1.fffffep+127)) (i32.const 2139095039))
(assert_return (invoke "i32.reinterpret_f32" (f32.const -0x1.fffffep+127)) (i32.const -8388609))
(assert_return (invoke "i32.reinterpret_f32" (f32.const inf)) (i32.const 0x7f800000))
(assert_return (invoke "i32.reinterpret_f32" (f32.const -inf)) (i32.const 0xff800000))
(assert_return (invoke "i32.reinterpret_f32" (f32.const nan)) (i32.const 0x7fc00000))
(assert_return (invoke "i32.reinterpret_f32" (f32.const -nan)) (i32.const 0xffc00000))
(assert_return (invoke "i32.reinterpret_f32" (f32.const nan:0x200000)) (i32.const 0x7fa00000))
(assert_return (invoke "i32.reinterpret_f32" (f32.const -nan:0x200000)) (i32.const 0xffa00000))
(assert_return (invoke "i64.reinterpret_f64" (f64.const 0.0)) (i64.const 0))
(assert_return (invoke "i64.reinterpret_f64" (f64.const -0.0)) (i64.const 0x8000000000000000))
(assert_return (invoke "i64.reinterpret_f64" (f64.const 0x0.0000000000001p-1022)) (i64.const 1))
(assert_return (invoke "i64.reinterpret_f64" (f64.const -nan:0xfffffffffffff)) (i64.const -1))
(assert_return (invoke "i64.reinterpret_f64" (f64.const -0x0.0000000000001p-1022)) (i64.const 0x8000000000000001))
(assert_return (invoke "i64.reinterpret_f64" (f64.const 1.0)) (i64.const 4607182418800017408))
(assert_return (invoke "i64.reinterpret_f64" (f64.const 3.14159265358979)) (i64.const 4614256656552045841))
(assert_return (invoke "i64.reinterpret_f64" (f64.const 0x1.fffffffffffffp+1023)) (i64.const 9218868437227405311))
(assert_return (invoke "i64.reinterpret_f64" (f64.const -0x1.fffffffffffffp+1023)) (i64.const -4503599627370497))
(assert_return (invoke "i64.reinterpret_f64" (f64.const inf)) (i64.const 0x7ff0000000000000))
(assert_return (invoke "i64.reinterpret_f64" (f64.const -inf)) (i64.const 0xfff0000000000000))
(assert_return (invoke "i64.reinterpret_f64" (f64.const nan)) (i64.const 0x7ff8000000000000))
(assert_return (invoke "i64.reinterpret_f64" (f64.const -nan)) (i64.const 0xfff8000000000000))
(assert_return (invoke "i64.reinterpret_f64" (f64.const nan:0x4000000000000)) (i64.const 0x7ff4000000000000))
(assert_return (invoke "i64.reinterpret_f64" (f64.const -nan:0x4000000000000)) (i64.const 0xfff4000000000000))

1
js/src/js-config.mozbuild
View File

@ -8,7 +8,6 @@
if CONFIG['NIGHTLY_BUILD']:
DEFINES['ENABLE_BINARYDATA'] = True
DEFINES['ENABLE_WASM_BULKMEM_OPS'] = True
DEFINES['ENABLE_WASM_SATURATING_TRUNC_OPS'] = True
DEFINES['ENABLE_WASM_THREAD_OPS'] = True
DEFINES['ENABLE_WASM_GC'] = True
DEFINES['WASM_PRIVATE_REFTYPES'] = True

4
js/src/wasm/WasmAST.h
View File

@ -483,9 +483,7 @@ enum class AstExprKind
ConversionOperator,
CurrentMemory,
Drop,
#ifdef ENABLE_WASM_SATURATING_TRUNC_OPS
ExtraConversionOperator,
#endif
First,
GetGlobal,
GetLocal,
@ -1639,7 +1637,6 @@ class AstConversionOperator final : public AstExpr
AstExpr* operand() const { return operand_; }
};
#ifdef ENABLE_WASM_SATURATING_TRUNC_OPS
// Like AstConversionOperator, but for opcodes encoded with the Misc prefix.
class AstExtraConversionOperator final : public AstExpr
{
@ -1656,7 +1653,6 @@ class AstExtraConversionOperator final : public AstExpr
MiscOp op() const { return op_; }
AstExpr* operand() const { return operand_; }
};
#endif
class AstRefNull final : public AstExpr
{

2
js/src/wasm/WasmBaselineCompile.cpp
View File

@ -10696,7 +10696,6 @@ BaseCompiler::emitBody()
// "Miscellaneous" operations
case uint16_t(Op::MiscPrefix): {
switch (op.b1) {
#ifdef ENABLE_WASM_SATURATING_TRUNC_OPS
case uint16_t(MiscOp::I32TruncSSatF32):
CHECK_NEXT(emitConversionOOM(emitTruncateF32ToI32<TRUNC_SATURATING>,
ValType::F32, ValType::I32));
@ -10745,7 +10744,6 @@ BaseCompiler::emitBody()
CHECK_NEXT(emitConversionOOM(emitTruncateF64ToI64<TRUNC_UNSIGNED | TRUNC_SATURATING>,
ValType::F64, ValType::I64));
#endif
#endif // ENABLE_WASM_SATURATING_TRUNC_OPS
#ifdef ENABLE_WASM_BULKMEM_OPS
case uint16_t(MiscOp::MemCopy):
CHECK_NEXT(emitMemOrTableCopy(/*isMem=*/true));

2
js/src/wasm/WasmIonCompile.cpp
View File

@ -3594,7 +3594,6 @@ EmitBodyExprs(FunctionCompiler& f)
// Miscellaneous operations
case uint16_t(Op::MiscPrefix): {
switch (op.b1) {
#ifdef ENABLE_WASM_SATURATING_TRUNC_OPS
case uint16_t(MiscOp::I32TruncSSatF32):
case uint16_t(MiscOp::I32TruncUSatF32):
CHECK(EmitTruncate(f, ValType::F32, ValType::I32,
@ -3611,7 +3610,6 @@ EmitBodyExprs(FunctionCompiler& f)
case uint16_t(MiscOp::I64TruncUSatF64):
CHECK(EmitTruncate(f, ValType::F64, ValType::I64,
MiscOp(op.b1) == MiscOp::I64TruncUSatF64, true));
#endif
#ifdef ENABLE_WASM_BULKMEM_OPS
case uint16_t(MiscOp::MemCopy):
CHECK(EmitMemOrTableCopy(f, /*isMem=*/true));

8
js/src/wasm/WasmOpIter.cpp
View File

@ -29,11 +29,6 @@ using namespace js::wasm;
# else
# define WASM_GC_OP(code) break
# endif
# ifdef ENABLE_WASM_SATURATING_TRUNC_OPS
# define WASM_TRUNC_OP(code) return code
# else
# define WASM_TRUNC_OP(code) break
# endif
# ifdef ENABLE_WASM_BULKMEM_OPS
# define WASM_BULK_OP(code) return code
# else
@ -277,7 +272,7 @@ wasm::Classify(OpBytes op)
case MiscOp::I64TruncUSatF32:
case MiscOp::I64TruncSSatF64:
case MiscOp::I64TruncUSatF64:
WASM_TRUNC_OP(OpKind::Conversion);
return OpKind::Conversion;
case MiscOp::MemCopy:
case MiscOp::TableCopy:
WASM_BULK_OP(OpKind::MemOrTableCopy);
@ -432,7 +427,6 @@ wasm::Classify(OpBytes op)
}
# undef WASM_GC_OP
# undef WASM_TRUNC_OP
# undef WASM_BULK_OP
# undef WASM_THREAD_OP

24
js/src/wasm/WasmTextToBinary.cpp
View File

@ -91,9 +91,7 @@ class WasmToken
Equal,
Error,
Export,
#ifdef ENABLE_WASM_SATURATING_TRUNC_OPS
ExtraConversionOpcode,
#endif
Field,
Float,
Func,
@ -249,7 +247,6 @@ class WasmToken
kind_ == Load || kind_ == Store);
u.op_ = op;
}
#ifdef ENABLE_WASM_SATURATING_TRUNC_OPS
explicit WasmToken(Kind kind, MiscOp op, const char16_t* begin, const char16_t* end)
: kind_(kind),
begin_(begin),
@ -259,7 +256,6 @@ class WasmToken
MOZ_ASSERT(kind_ == ExtraConversionOpcode);
u.miscOp_ = op;
}
#endif
explicit WasmToken(Kind kind, ThreadOp op, const char16_t* begin, const char16_t* end)
: kind_(kind),
begin_(begin),
@ -322,12 +318,10 @@ class WasmToken
kind_ == Load || kind_ == Store);
return u.op_;
}
#ifdef ENABLE_WASM_SATURATING_TRUNC_OPS
MiscOp miscOp() const {
MOZ_ASSERT(kind_ == ExtraConversionOpcode);
return u.miscOp_;
}
#endif
ThreadOp threadOp() const {
MOZ_ASSERT(kind_ == AtomicCmpXchg || kind_ == AtomicLoad || kind_ == AtomicRMW ||
kind_ == AtomicStore || kind_ == Wait || kind_ == Wake);
@ -349,9 +343,7 @@ class WasmToken
case ComparisonOpcode:
case Const:
case ConversionOpcode:
#ifdef ENABLE_WASM_SATURATING_TRUNC_OPS
case ExtraConversionOpcode:
#endif
case CurrentMemory:
case Drop:
case GetGlobal:
@ -1606,7 +1598,6 @@ WasmTokenStream::next()
return WasmToken(WasmToken::ConversionOpcode, Op::I32TruncUF64,
begin, cur_);
}
#ifdef ENABLE_WASM_SATURATING_TRUNC_OPS
if (consume(u"trunc_s:sat/f32")) {
return WasmToken(WasmToken::ExtraConversionOpcode, MiscOp::I32TruncSSatF32,
begin, cur_);
@ -1623,7 +1614,6 @@ WasmTokenStream::next()
return WasmToken(WasmToken::ExtraConversionOpcode, MiscOp::I32TruncUSatF64,
begin, cur_);
}
#endif
break;
case 'w':
if (consume(u"wrap/i64")) {
@ -1948,7 +1938,6 @@ WasmTokenStream::next()
return WasmToken(WasmToken::ConversionOpcode, Op::I64TruncUF64,
begin, cur_);
}
#ifdef ENABLE_WASM_SATURATING_TRUNC_OPS
if (consume(u"trunc_s:sat/f32")) {
return WasmToken(WasmToken::ExtraConversionOpcode, MiscOp::I64TruncSSatF32,
begin, cur_);
@ -1965,7 +1954,6 @@ WasmTokenStream::next()
return WasmToken(WasmToken::ExtraConversionOpcode, MiscOp::I64TruncUSatF64,
begin, cur_);
}
#endif
break;
case 'w':
break;
@ -2986,7 +2974,6 @@ ParseConversionOperator(WasmParseContext& c, Op op, bool inParens)
return new(c.lifo) AstConversionOperator(op, operand);
}
#ifdef ENABLE_WASM_SATURATING_TRUNC_OPS
static AstExtraConversionOperator*
ParseExtraConversionOperator(WasmParseContext& c, MiscOp op, bool inParens)
{
@ -2997,7 +2984,6 @@ ParseExtraConversionOperator(WasmParseContext& c, MiscOp op, bool inParens)
return new(c.lifo) AstExtraConversionOperator(op, operand);
}
#endif
static AstDrop*
ParseDrop(WasmParseContext& c, bool inParens)
@ -3782,10 +3768,8 @@ ParseExprBody(WasmParseContext& c, WasmToken token, bool inParens)
return ParseConst(c, token);
case WasmToken::ConversionOpcode:
return ParseConversionOperator(c, token.op(), inParens);
#ifdef ENABLE_WASM_SATURATING_TRUNC_OPS
case WasmToken::ExtraConversionOpcode:
return ParseExtraConversionOperator(c, token.miscOp(), inParens);
#endif
case WasmToken::Drop:
return ParseDrop(c, inParens);
case WasmToken::If:
@ -5340,13 +5324,11 @@ ResolveConversionOperator(Resolver& r, AstConversionOperator& b)
return ResolveExpr(r, *b.operand());
}
#ifdef ENABLE_WASM_SATURATING_TRUNC_OPS
static bool
ResolveExtraConversionOperator(Resolver& r, AstExtraConversionOperator& b)
{
return ResolveExpr(r, *b.operand());
}
#endif
static bool
ResolveIfElse(Resolver& r, AstIf& i)
@ -5579,10 +5561,8 @@ ResolveExpr(Resolver& r, AstExpr& expr)
return true;
case AstExprKind::ConversionOperator:
return ResolveConversionOperator(r, expr.as<AstConversionOperator>());
#ifdef ENABLE_WASM_SATURATING_TRUNC_OPS
case AstExprKind::ExtraConversionOperator:
return ResolveExtraConversionOperator(r, expr.as<AstExtraConversionOperator>());
#endif
case AstExprKind::First:
return ResolveFirst(r, expr.as<AstFirst>());
case AstExprKind::GetGlobal:
@ -6108,14 +6088,12 @@ EncodeConversionOperator(Encoder& e, AstConversionOperator& b)
e.writeOp(b.op());
}
#ifdef ENABLE_WASM_SATURATING_TRUNC_OPS
static bool
EncodeExtraConversionOperator(Encoder& e, AstExtraConversionOperator& b)
{
return EncodeExpr(e, *b.operand()) &&
e.writeOp(b.op());
}
#endif
static bool
EncodeIf(Encoder& e, AstIf& i)
@ -6462,10 +6440,8 @@ EncodeExpr(Encoder& e, AstExpr& expr)
return EncodeConversionOperator(e, expr.as<AstConversionOperator>());
case AstExprKind::Drop:
return EncodeDrop(e, expr.as<AstDrop>());
#ifdef ENABLE_WASM_SATURATING_TRUNC_OPS
case AstExprKind::ExtraConversionOperator:
return EncodeExtraConversionOperator(e, expr.as<AstExtraConversionOperator>());
#endif
case AstExprKind::First:
return EncodeFirst(e, expr.as<AstFirst>());
case AstExprKind::GetLocal:

2
js/src/wasm/WasmValidate.cpp
View File

@ -891,7 +891,6 @@ DecodeFunctionBodyExprs(const ModuleEnvironment& env, const FuncType& funcType,
CHECK(iter.readUnreachable());
case uint16_t(Op::MiscPrefix): {
switch (op.b1) {
#ifdef ENABLE_WASM_SATURATING_TRUNC_OPS
case uint16_t(MiscOp::I32TruncSSatF32):
case uint16_t(MiscOp::I32TruncUSatF32):
CHECK(iter.readConversion(ValType::F32, ValType::I32, &nothing));
@ -904,7 +903,6 @@ DecodeFunctionBodyExprs(const ModuleEnvironment& env, const FuncType& funcType,
case uint16_t(MiscOp::I64TruncSSatF64):
case uint16_t(MiscOp::I64TruncUSatF64):
CHECK(iter.readConversion(ValType::F64, ValType::I64, &nothing));
#endif
#ifdef ENABLE_WASM_BULKMEM_OPS
case uint16_t(MiscOp::MemCopy):
CHECK(iter.readMemOrTableCopy(/*isMem=*/true,