Magic-Mirror/gecko-dev
1
0
Fork 0
mirror of https://github.com/mozilla/gecko-dev.git synced 2024-10-25 11:15:34 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Bug 1265461: Import wast files; r=mbx

Browse Source 
MozReview-Commit-ID: 6ad3QkZMYkS

--HG--
extra : rebase_source : a9e6048bffa86dd17c41eb8c421244219bf30983
extra : histedit_source : ed1625830738716b40bdc1db882edf42da9240b1
This commit is contained in:
Benjamin Bouvier 2016-05-10 12:38:20 +02:00
parent 50e90e1537
commit b687699fa6
42 changed files with 15615 additions and 6 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

34
js/src/jit-test/tests/wasm/spec/address.wast Normal file
View File

@ -0,0 +1,34 @@
(module
(memory 1 (segment 0 "abcdefghijklmnopqrstuvwxyz"))
(import $print "spectest" "print" (param i32))
(func $good (param $i i32)
(call_import $print (i32.load8_u offset=0 (get_local $i))) ;; 97 'a'
(call_import $print (i32.load8_u offset=1 (get_local $i))) ;; 98 'b'
(call_import $print (i32.load8_u offset=2 (get_local $i))) ;; 99 'c'
(call_import $print (i32.load8_u offset=25 (get_local $i))) ;; 122 'z'
(call_import $print (i32.load16_u offset=0 (get_local $i))) ;; 25185 'ab'
(call_import $print (i32.load16_u align=1 (get_local $i))) ;; 25185 'ab'
(call_import $print (i32.load16_u offset=1 align=1 (get_local $i))) ;; 25442 'bc'
(call_import $print (i32.load16_u offset=2 (get_local $i))) ;; 25699 'cd'
(call_import $print (i32.load16_u offset=25 align=1 (get_local $i))) ;; 122 'z\0'
(call_import $print (i32.load offset=0 (get_local $i))) ;; 1684234849 'abcd'
(call_import $print (i32.load offset=1 align=1 (get_local $i))) ;; 1701077858 'bcde'
(call_import $print (i32.load offset=2 align=2 (get_local $i))) ;; 1717920867 'cdef'
(call_import $print (i32.load offset=25 align=1 (get_local $i))) ;; 122 'z\0\0\0'
)
(export "good" $good)
(func $bad2 (param $i i32) (i32.load offset=4294967295 (get_local $i)))
(export "bad2" $bad2)
)
(invoke "good" (i32.const 0))
(invoke "good" (i32.const 65507))
(assert_trap (invoke "good" (i32.const 65508)) "out of bounds memory access")
(assert_trap (invoke "bad2" (i32.const 0)) "out of bounds memory access")
(assert_trap (invoke "bad2" (i32.const 1)) "out of bounds memory access")
(assert_invalid (module (memory 1) (func $bad1 (param $i i32) (i32.load offset=4294967296 (get_local $i))) ) "offset too large")

14
js/src/jit-test/tests/wasm/spec/binary.wast Normal file
View File

@ -0,0 +1,14 @@
(module "\00asm\0b\00\00\00")
(module "\00asm" "\0b\00\00\00")
(assert_invalid (module "") "unexpected end")
(assert_invalid (module "\01") "unexpected end")
(assert_invalid (module "\00as") "unexpected end")
(assert_invalid (module "\01") "unexpected end")
(assert_invalid (module "asm\00") "magic header not detected")
(assert_invalid (module "\00asm") "unexpected end")
(assert_invalid (module "\00asm\0b") "unexpected end")
(assert_invalid (module "\00asm\0b\00\00") "unexpected end")
(assert_invalid (module "\00asm\10\00\00\00") "unknown binary version")

35
js/src/jit-test/tests/wasm/spec/block.wast Normal file
View File

@ -0,0 +1,35 @@
(module
(func $empty
(block)
(block $l)
)
(func $singular (result i32)
(block (i32.const 7))
)
(func $multi (result i32)
(block (i32.const 5) (i32.const 6) (i32.const 7) (i32.const 8))
)
(func $effects (result i32)
(local i32)
(block
(set_local 0 (i32.const 1))
(set_local 0 (i32.mul (get_local 0) (i32.const 3)))
(set_local 0 (i32.sub (get_local 0) (i32.const 5)))
(set_local 0 (i32.mul (get_local 0) (i32.const 7)))
)
(get_local 0)
)
(export "empty" $empty)
(export "singular" $singular)
(export "multi" $multi)
(export "effects" $effects)
)
(invoke "empty")
(assert_return (invoke "singular") (i32.const 7))
(assert_return (invoke "multi") (i32.const 8))
(assert_return (invoke "effects") (i32.const -14))

15
js/src/jit-test/tests/wasm/spec/block_comments.wast Normal file
View File

@ -0,0 +1,15 @@
(;;)
(;(((((((((( ;)
(;)))))))))));)
(; (module $error) ;)
(; (module $error) ;)
(; (module $error)
;)
(;
(module $error);)
(; a (; b ;) c ;)
(; ;; bla ;)
(; ;; bla
;)
(module) ;; dummy

64
js/src/jit-test/tests/wasm/spec/break-drop.wast Normal file
View File

@ -0,0 +1,64 @@
(module
(func $br (block (br 0)))
(export "br" $br)
(func $br-nop (block (br 0 (nop))))
(export "br-nop" $br-nop)
(func $br-drop (block (br 0 (i32.const 1))))
(export "br-drop" $br-drop)
(func $br-block-nop (block (br 0 (block (i32.const 1) (nop)))))
(export "br-block-nop" $br-block-nop)
(func $br-block-drop (block (br 0 (block (nop) (i32.const 1)))))
(export "br-block-drop" $br-block-drop)
(func $br_if (block (br_if 0 (i32.const 1))))
(export "br_if" $br_if)
(func $br_if-nop (block (br_if 0 (nop) (i32.const 1))))
(export "br_if-nop" $br_if-nop)
(func $br_if-drop (block (br_if 0 (i32.const 1) (i32.const 1))))
(export "br_if-drop" $br_if-drop)
(func $br_if-block-nop (block (br_if 0 (block (i32.const 1) (nop)) (i32.const 1))))
(export "br_if-block-nop" $br_if-block-nop)
(func $br_if-block-drop (block (br_if 0 (block (nop) (i32.const 1)) (i32.const 1))))
(export "br_if-block-drop" $br_if-block-drop)
(func $br_table (block (br_table 0 (i32.const 0))))
(export "br_table" $br_table)
(func $br_table-nop (block (br_table 0 (nop) (i32.const 0))))
(export "br_table-nop" $br_table-nop)
(func $br_table-drop (block (br_table 0 (i32.const 1) (i32.const 0))))
(export "br_table-drop" $br_table-drop)
(func $br_table-block-nop (block (br_table 0 (block (i32.const 1) (nop)) (i32.const 0))))
(export "br_table-block-nop" $br_table-block-nop)
(func $br_table-block-drop (block (br_table 0 (block (nop) (i32.const 1)) (i32.const 0))))
(export "br_table-block-drop" $br_table-block-drop)
)
(assert_return (invoke "br"))
(assert_return (invoke "br-nop"))
(assert_return (invoke "br-drop"))
(assert_return (invoke "br-block-nop"))
(assert_return (invoke "br-block-drop"))
(assert_return (invoke "br_if"))
(assert_return (invoke "br_if-nop"))
(assert_return (invoke "br_if-drop"))
(assert_return (invoke "br_if-block-nop"))
(assert_return (invoke "br_if-block-drop"))
(assert_return (invoke "br_table"))
(assert_return (invoke "br_table-nop"))
(assert_return (invoke "br_table-drop"))
(assert_return (invoke "br_table-block-nop"))
(assert_return (invoke "br_table-block-drop"))

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

@ -0,0 +1,453 @@
(module
(func $i64.extend_s_i32 (param $x i32) (result i64) (i64.extend_s/i32 (get_local $x)))
(export "i64.extend_s_i32" $i64.extend_s_i32)
(func $i64.extend_u_i32 (param $x i32) (result i64) (i64.extend_u/i32 (get_local $x)))
(export "i64.extend_u_i32" $i64.extend_u_i32)
(func $i32.wrap_i64 (param $x i64) (result i32) (i32.wrap/i64 (get_local $x)))
(export "i32.wrap_i64" $i32.wrap_i64)
(func $i32.trunc_s_f32 (param $x f32) (result i32) (i32.trunc_s/f32 (get_local $x)))
(export "i32.trunc_s_f32" $i32.trunc_s_f32)
(func $i32.trunc_u_f32 (param $x f32) (result i32) (i32.trunc_u/f32 (get_local $x)))
(export "i32.trunc_u_f32" $i32.trunc_u_f32)
(func $i32.trunc_s_f64 (param $x f64) (result i32) (i32.trunc_s/f64 (get_local $x)))
(export "i32.trunc_s_f64" $i32.trunc_s_f64)
(func $i32.trunc_u_f64 (param $x f64) (result i32) (i32.trunc_u/f64 (get_local $x)))
(export "i32.trunc_u_f64" $i32.trunc_u_f64)
(func $i64.trunc_s_f32 (param $x f32) (result i64) (i64.trunc_s/f32 (get_local $x)))
(export "i64.trunc_s_f32" $i64.trunc_s_f32)
(func $i64.trunc_u_f32 (param $x f32) (result i64) (i64.trunc_u/f32 (get_local $x)))
(export "i64.trunc_u_f32" $i64.trunc_u_f32)
(func $i64.trunc_s_f64 (param $x f64) (result i64) (i64.trunc_s/f64 (get_local $x)))
(export "i64.trunc_s_f64" $i64.trunc_s_f64)
(func $i64.trunc_u_f64 (param $x f64) (result i64) (i64.trunc_u/f64 (get_local $x)))
(export "i64.trunc_u_f64" $i64.trunc_u_f64)
(func $f32.convert_s_i32 (param $x i32) (result f32) (f32.convert_s/i32 (get_local $x)))
(export "f32.convert_s_i32" $f32.convert_s_i32)
(func $f32.convert_s_i64 (param $x i64) (result f32) (f32.convert_s/i64 (get_local $x)))
(export "f32.convert_s_i64" $f32.convert_s_i64)
(func $f64.convert_s_i32 (param $x i32) (result f64) (f64.convert_s/i32 (get_local $x)))
(export "f64.convert_s_i32" $f64.convert_s_i32)
(func $f64.convert_s_i64 (param $x i64) (result f64) (f64.convert_s/i64 (get_local $x)))
(export "f64.convert_s_i64" $f64.convert_s_i64)
(func $f32.convert_u_i32 (param $x i32) (result f32) (f32.convert_u/i32 (get_local $x)))
(export "f32.convert_u_i32" $f32.convert_u_i32)
(func $f32.convert_u_i64 (param $x i64) (result f32) (f32.convert_u/i64 (get_local $x)))
(export "f32.convert_u_i64" $f32.convert_u_i64)
(func $f64.convert_u_i32 (param $x i32) (result f64) (f64.convert_u/i32 (get_local $x)))
(export "f64.convert_u_i32" $f64.convert_u_i32)
(func $f64.convert_u_i64 (param $x i64) (result f64) (f64.convert_u/i64 (get_local $x)))
(export "f64.convert_u_i64" $f64.convert_u_i64)
(func $f64.promote_f32 (param $x f32) (result f64) (f64.promote/f32 (get_local $x)))
(export "f64.promote_f32" $f64.promote_f32)
(func $f32.demote_f64 (param $x f64) (result f32) (f32.demote/f64 (get_local $x)))
(export "f32.demote_f64" $f32.demote_f64)
(func $f32.reinterpret_i32 (param $x i32) (result f32) (f32.reinterpret/i32 (get_local $x)))
(export "f32.reinterpret_i32" $f32.reinterpret_i32)
(func $f64.reinterpret_i64 (param $x i64) (result f64) (f64.reinterpret/i64 (get_local $x)))
(export "f64.reinterpret_i64" $f64.reinterpret_i64)
(func $i32.reinterpret_f32 (param $x f32) (result i32) (i32.reinterpret/f32 (get_local $x)))
(export "i32.reinterpret_f32" $i32.reinterpret_f32)
(func $i64.reinterpret_f64 (param $x f64) (result i64) (i64.reinterpret/f64 (get_local $x)))
(export "i64.reinterpret_f64" $i64.reinterpret_f64)
)
(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 infinity)) "integer overflow")
(assert_trap (invoke "i32.trunc_s_f32" (f32.const -infinity)) "integer overflow")
(assert_trap (invoke "i32.trunc_s_f32" (f32.const nan)) "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 infinity)) "integer overflow")
(assert_trap (invoke "i32.trunc_u_f32" (f32.const -infinity)) "integer overflow")
(assert_trap (invoke "i32.trunc_u_f32" (f32.const nan)) "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 infinity)) "integer overflow")
(assert_trap (invoke "i32.trunc_s_f64" (f64.const -infinity)) "integer overflow")
(assert_trap (invoke "i32.trunc_s_f64" (f64.const nan)) "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 infinity)) "integer overflow")
(assert_trap (invoke "i32.trunc_u_f64" (f64.const -infinity)) "integer overflow")
(assert_trap (invoke "i32.trunc_u_f64" (f64.const nan)) "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 infinity)) "integer overflow")
(assert_trap (invoke "i64.trunc_s_f32" (f32.const -infinity)) "integer overflow")
(assert_trap (invoke "i64.trunc_s_f32" (f32.const nan)) "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 infinity)) "integer overflow")
(assert_trap (invoke "i64.trunc_u_f32" (f32.const -infinity)) "integer overflow")
(assert_trap (invoke "i64.trunc_u_f32" (f32.const nan)) "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 infinity)) "integer overflow")
(assert_trap (invoke "i64.trunc_s_f64" (f64.const -infinity)) "integer overflow")
(assert_trap (invoke "i64.trunc_s_f64" (f64.const nan)) "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 infinity)) "integer overflow")
(assert_trap (invoke "i64.trunc_u_f64" (f64.const -infinity)) "integer overflow")
(assert_trap (invoke "i64.trunc_u_f64" (f64.const nan)) "invalid conversion to integer")
(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))
;; 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))
;; 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 infinity)) (f64.const infinity))
(assert_return (invoke "f64.promote_f32" (f32.const -infinity)) (f64.const -infinity))
(assert_return (invoke "f64.promote_f32" (f32.const nan)) (f64.const nan))
(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 -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.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.ffffffp+127)) (f32.const infinity))
(assert_return (invoke "f32.demote_f64" (f64.const -0x1.ffffffp+127)) (f32.const -infinity))
(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 infinity)) (f32.const infinity))
(assert_return (invoke "f32.demote_f64" (f64.const -infinity)) (f32.const -infinity))
(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.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.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 (invoke "f32.demote_f64" (f64.const nan)) (f32.const nan))
(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 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 0x0.8p-149)) (f32.const 0.0))
(assert_return (invoke "f32.demote_f64" (f64.const -0x0.8p-149)) (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 infinity))
(assert_return (invoke "f32.reinterpret_i32" (i32.const 0xff800000)) (f32.const -infinity))
(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 infinity))
(assert_return (invoke "f64.reinterpret_i64" (i64.const 0xfff0000000000000)) (f64.const -infinity))
(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 infinity)) (i32.const 0x7f800000))
(assert_return (invoke "i32.reinterpret_f32" (f32.const -infinity)) (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 infinity)) (i64.const 0x7ff0000000000000))
(assert_return (invoke "i64.reinterpret_f64" (f64.const -infinity)) (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))

241
js/src/jit-test/tests/wasm/spec/endianness.wast Normal file
View File

@ -0,0 +1,241 @@
(module
(memory 1)
;; Stores an i16 value in little-endian-format
(func $i16_store_little (param $address i32) (param $value i32)
(i32.store8 (get_local $address) (get_local $value))
(i32.store8 (i32.add (get_local $address) (i32.const 1)) (i32.shr_u (get_local $value) (i32.const 8)))
)
;; Stores an i32 value in little-endian format
(func $i32_store_little (param $address i32) (param $value i32)
(call $i16_store_little (get_local $address) (get_local $value))
(call $i16_store_little (i32.add (get_local $address) (i32.const 2)) (i32.shr_u (get_local $value) (i32.const 16)))
)
;; Stores an i64 value in little-endian format
(func $i64_store_little (param $address i32) (param $value i64)
(call $i32_store_little (get_local $address) (i32.wrap/i64 (get_local $value)))
(call $i32_store_little (i32.add (get_local $address) (i32.const 4)) (i32.wrap/i64 (i64.shr_u (get_local $value) (i64.const 32))))
)
;; Loads an i16 value in little-endian format
(func $i16_load_little (param $address i32) (result i32)
(i32.or
(i32.load8_u (get_local $address))
(i32.shl (i32.load8_u (i32.add (get_local $address) (i32.const 1))) (i32.const 8))
)
)
;; Loads an i32 value in little-endian format
(func $i32_load_little (param $address i32) (result i32)
(i32.or
(call $i16_load_little (get_local $address))
(i32.shl (call $i16_load_little (i32.add (get_local $address) (i32.const 2))) (i32.const 16))
)
)
;; Loads an i64 value in little-endian format
(func $i64_load_little (param $address i32) (result i64)
(i64.or
(i64.extend_u/i32 (call $i32_load_little (get_local $address)))
(i64.shl (i64.extend_u/i32 (call $i32_load_little (i32.add (get_local $address) (i32.const 4)))) (i64.const 32))
)
)
(func $i32_load16_s (param $value i32) (result i32)
(call $i16_store_little (i32.const 0) (get_local $value))
(i32.load16_s (i32.const 0))
)
(func $i32_load16_u (param $value i32) (result i32)
(call $i16_store_little (i32.const 0) (get_local $value))
(i32.load16_u (i32.const 0))
)
(func $i32_load (param $value i32) (result i32)
(call $i32_store_little (i32.const 0) (get_local $value))
(i32.load (i32.const 0))
)
(func $i64_load16_s (param $value i64) (result i64)
(call $i16_store_little (i32.const 0) (i32.wrap/i64 (get_local $value)))
(i64.load16_s (i32.const 0))
)
(func $i64_load16_u (param $value i64) (result i64)
(call $i16_store_little (i32.const 0) (i32.wrap/i64 (get_local $value)))
(i64.load16_u (i32.const 0))
)
(func $i64_load32_s (param $value i64) (result i64)
(call $i32_store_little (i32.const 0) (i32.wrap/i64 (get_local $value)))
(i64.load32_s (i32.const 0))
)
(func $i64_load32_u (param $value i64) (result i64)
(call $i32_store_little (i32.const 0) (i32.wrap/i64 (get_local $value)))
(i64.load32_u (i32.const 0))
)
(func $i64_load (param $value i64) (result i64)
(call $i64_store_little (i32.const 0) (get_local $value))
(i64.load (i32.const 0))
)
(func $f32_load (param $value f32) (result f32)
(call $i32_store_little (i32.const 0) (i32.reinterpret/f32 (get_local $value)))
(f32.load (i32.const 0))
)
(func $f64_load (param $value f64) (result f64)
(call $i64_store_little (i32.const 0) (i64.reinterpret/f64 (get_local $value)))
(f64.load (i32.const 0))
)
(func $i32_store16 (param $value i32) (result i32)
(i32.store16 (i32.const 0) (get_local $value))
(call $i16_load_little (i32.const 0))
)
(func $i32_store (param $value i32) (result i32)
(i32.store (i32.const 0) (get_local $value))
(call $i32_load_little (i32.const 0))
)
(func $i64_store16 (param $value i64) (result i64)
(i64.store16 (i32.const 0) (get_local $value))
(i64.extend_u/i32 (call $i16_load_little (i32.const 0)))
)
(func $i64_store32 (param $value i64) (result i64)
(i64.store32 (i32.const 0) (get_local $value))
(i64.extend_u/i32 (call $i32_load_little (i32.const 0)))
)
(func $i64_store (param $value i64) (result i64)
(i64.store (i32.const 0) (get_local $value))
(call $i64_load_little (i32.const 0))
)
(func $f32_store (param $value f32) (result f32)
(f32.store (i32.const 0) (get_local $value))
(f32.reinterpret/i32 (call $i32_load_little (i32.const 0)))
)
(func $f64_store (param $value f64) (result f64)
(f64.store (i32.const 0) (get_local $value))
(f64.reinterpret/i64 (call $i64_load_little (i32.const 0)))
)
(export "i32_load16_s" $i32_load16_s)
(export "i32_load16_u" $i32_load16_u)
(export "i32_load" $i32_load)
(export "i64_load16_s" $i64_load16_s)
(export "i64_load16_u" $i64_load16_u)
(export "i64_load32_s" $i64_load32_s)
(export "i64_load32_u" $i64_load32_u)
(export "i64_load" $i64_load)
(export "f32_load" $f32_load)
(export "f64_load" $f64_load)
(export "i32_store16" $i32_store16)
(export "i32_store" $i32_store)
(export "i64_store16" $i64_store16)
(export "i64_store32" $i64_store32)
(export "i64_store" $i64_store)
(export "f32_store" $f32_store)
(export "f64_store" $f64_store)
)
(assert_return (invoke "i32_load16_s" (i32.const -1)) (i32.const -1))
(assert_return (invoke "i32_load16_s" (i32.const -4242)) (i32.const -4242))
(assert_return (invoke "i32_load16_s" (i32.const 42)) (i32.const 42))
(assert_return (invoke "i32_load16_s" (i32.const 0x3210)) (i32.const 0x3210))
(assert_return (invoke "i32_load16_u" (i32.const -1)) (i32.const 0xFFFF))
(assert_return (invoke "i32_load16_u" (i32.const -4242)) (i32.const 61294))
(assert_return (invoke "i32_load16_u" (i32.const 42)) (i32.const 42))
(assert_return (invoke "i32_load16_u" (i32.const 0xCAFE)) (i32.const 0xCAFE))
(assert_return (invoke "i32_load" (i32.const -1)) (i32.const -1))
(assert_return (invoke "i32_load" (i32.const -42424242)) (i32.const -42424242))
(assert_return (invoke "i32_load" (i32.const 42424242)) (i32.const 42424242))
(assert_return (invoke "i32_load" (i32.const 0xABAD1DEA)) (i32.const 0xABAD1DEA))
(assert_return (invoke "i64_load16_s" (i64.const -1)) (i64.const -1))
(assert_return (invoke "i64_load16_s" (i64.const -4242)) (i64.const -4242))
(assert_return (invoke "i64_load16_s" (i64.const 42)) (i64.const 42))
(assert_return (invoke "i64_load16_s" (i64.const 0x3210)) (i64.const 0x3210))
(assert_return (invoke "i64_load16_u" (i64.const -1)) (i64.const 0xFFFF))
(assert_return (invoke "i64_load16_u" (i64.const -4242)) (i64.const 61294))
(assert_return (invoke "i64_load16_u" (i64.const 42)) (i64.const 42))
(assert_return (invoke "i64_load16_u" (i64.const 0xCAFE)) (i64.const 0xCAFE))
(assert_return (invoke "i64_load32_s" (i64.const -1)) (i64.const -1))
(assert_return (invoke "i64_load32_s" (i64.const -42424242)) (i64.const -42424242))
(assert_return (invoke "i64_load32_s" (i64.const 42424242)) (i64.const 42424242))
(assert_return (invoke "i64_load32_s" (i64.const 0x12345678)) (i64.const 0x12345678))
(assert_return (invoke "i64_load32_u" (i64.const -1)) (i64.const 0xFFFFFFFF))
(assert_return (invoke "i64_load32_u" (i64.const -42424242)) (i64.const 4252543054))
(assert_return (invoke "i64_load32_u" (i64.const 42424242)) (i64.const 42424242))
(assert_return (invoke "i64_load32_u" (i64.const 0xABAD1DEA)) (i64.const 0xABAD1DEA))
(assert_return (invoke "i64_load" (i64.const -1)) (i64.const -1))
(assert_return (invoke "i64_load" (i64.const -42424242)) (i64.const -42424242))
(assert_return (invoke "i64_load" (i64.const 0xABAD1DEA)) (i64.const 0xABAD1DEA))
(assert_return (invoke "i64_load" (i64.const 0xABADCAFEDEAD1DEA)) (i64.const 0xABADCAFEDEAD1DEA))
(assert_return (invoke "f32_load" (f32.const -1)) (f32.const -1))
(assert_return (invoke "f32_load" (f32.const 1234e-5)) (f32.const 1234e-5))
(assert_return (invoke "f32_load" (f32.const 4242.4242)) (f32.const 4242.4242))
(assert_return (invoke "f32_load" (f32.const 0x1.fffffep+127)) (f32.const 0x1.fffffep+127))
(assert_return (invoke "f64_load" (f64.const -1)) (f64.const -1))
(assert_return (invoke "f64_load" (f64.const 123456789e-5)) (f64.const 123456789e-5))
(assert_return (invoke "f64_load" (f64.const 424242.424242)) (f64.const 424242.424242))
(assert_return (invoke "f64_load" (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023))
(assert_return (invoke "i32_store16" (i32.const -1)) (i32.const 0xFFFF))
(assert_return (invoke "i32_store16" (i32.const -4242)) (i32.const 61294))
(assert_return (invoke "i32_store16" (i32.const 42)) (i32.const 42))
(assert_return (invoke "i32_store16" (i32.const 0xCAFE)) (i32.const 0xCAFE))
(assert_return (invoke "i32_store" (i32.const -1)) (i32.const -1))
(assert_return (invoke "i32_store" (i32.const -4242)) (i32.const -4242))
(assert_return (invoke "i32_store" (i32.const 42424242)) (i32.const 42424242))
(assert_return (invoke "i32_store" (i32.const 0xDEADCAFE)) (i32.const 0xDEADCAFE))
(assert_return (invoke "i64_store16" (i64.const -1)) (i64.const 0xFFFF))
(assert_return (invoke "i64_store16" (i64.const -4242)) (i64.const 61294))
(assert_return (invoke "i64_store16" (i64.const 42)) (i64.const 42))
(assert_return (invoke "i64_store16" (i64.const 0xCAFE)) (i64.const 0xCAFE))
(assert_return (invoke "i64_store32" (i64.const -1)) (i64.const 0xFFFFFFFF))
(assert_return (invoke "i64_store32" (i64.const -4242)) (i64.const 4294963054))
(assert_return (invoke "i64_store32" (i64.const 42424242)) (i64.const 42424242))
(assert_return (invoke "i64_store32" (i64.const 0xDEADCAFE)) (i64.const 0xDEADCAFE))
(assert_return (invoke "i64_store" (i64.const -1)) (i64.const -1))
(assert_return (invoke "i64_store" (i64.const -42424242)) (i64.const -42424242))
(assert_return (invoke "i64_store" (i64.const 0xABAD1DEA)) (i64.const 0xABAD1DEA))
(assert_return (invoke "i64_store" (i64.const 0xABADCAFEDEAD1DEA)) (i64.const 0xABADCAFEDEAD1DEA))
(assert_return (invoke "f32_store" (f32.const -1)) (f32.const -1))
(assert_return (invoke "f32_store" (f32.const 1234e-5)) (f32.const 1234e-5))
(assert_return (invoke "f32_store" (f32.const 4242.4242)) (f32.const 4242.4242))
(assert_return (invoke "f32_store" (f32.const 0x1.fffffep+127)) (f32.const 0x1.fffffep+127))
(assert_return (invoke "f64_store" (f64.const -1)) (f64.const -1))
(assert_return (invoke "f64_store" (f64.const 123456789e-5)) (f64.const 123456789e-5))
(assert_return (invoke "f64_store" (f64.const 424242.424242)) (f64.const 424242.424242))
(assert_return (invoke "f64_store" (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023))

26
js/src/jit-test/tests/wasm/spec/exports.wast Normal file
View File

@ -0,0 +1,26 @@
(module (func (i32.const 1)) (export "a" 0))
(module (func (i32.const 1)) (export "a" 0) (export "b" 0))
(module (func (i32.const 1)) (func (i32.const 2)) (export "a" 0) (export "b" 1))
(assert_invalid
(module (func (i32.const 1)) (export "a" 1))
"unknown function 1")
(assert_invalid
(module (func (i32.const 1)) (func (i32.const 2)) (export "a" 0) (export "a" 1))
"duplicate export name")
(assert_invalid
(module (func (i32.const 1)) (export "a" 0) (export "a" 0))
"duplicate export name")
(module
(func $f (param $n i32) (result i32)
(return (i32.add (get_local $n) (i32.const 1)))
)
(export "e" $f)
)
(assert_return (invoke "e" (i32.const 42)) (i32.const 43))
(module (memory 0 0) (export "a" memory))
(module (memory 0 0) (export "a" memory) (export "b" memory))
(assert_invalid (module (export "a" memory)) "no memory to export")

2429
js/src/jit-test/tests/wasm/spec/f32.wast Normal file
View File

File diff suppressed because it is too large Load Diff

1963
js/src/jit-test/tests/wasm/spec/f32_cmp.wast Normal file
View File

File diff suppressed because it is too large Load Diff

2429
js/src/jit-test/tests/wasm/spec/f64.wast Normal file
View File

File diff suppressed because it is too large Load Diff

1963
js/src/jit-test/tests/wasm/spec/f64_cmp.wast Normal file
View File

File diff suppressed because it is too large Load Diff

87
js/src/jit-test/tests/wasm/spec/fac.wast Normal file
View File

@ -0,0 +1,87 @@
(module
;; Recursive factorial
(func (param i64) (result i64)
(if (i64.eq (get_local 0) (i64.const 0))
(i64.const 1)
(i64.mul (get_local 0) (call 0 (i64.sub (get_local 0) (i64.const 1))))
)
)
;; Recursive factorial named
(func $fac-rec (param $n i64) (result i64)
(if (i64.eq (get_local $n) (i64.const 0))
(i64.const 1)
(i64.mul
(get_local $n)
(call $fac-rec (i64.sub (get_local $n) (i64.const 1)))
)
)
)
;; Iterative factorial
(func (param i64) (result i64)
(local i64 i64)
(set_local 1 (get_local 0))
(set_local 2 (i64.const 1))
(loop
(if
(i64.eq (get_local 1) (i64.const 0))
(br 2)
(block
(set_local 2 (i64.mul (get_local 1) (get_local 2)))
(set_local 1 (i64.sub (get_local 1) (i64.const 1)))
)
)
(br 0)
)
(get_local 2)
)
;; Iterative factorial named
(func $fac-iter (param $n i64) (result i64)
(local $i i64)
(local $res i64)
(set_local $i (get_local $n))
(set_local $res (i64.const 1))
(loop $done $loop
(if
(i64.eq (get_local $i) (i64.const 0))
(br $done)
(block
(set_local $res (i64.mul (get_local $i) (get_local $res)))
(set_local $i (i64.sub (get_local $i) (i64.const 1)))
)
)
(br $loop)
)
(get_local $res)
)
;; More-realistically optimized factorial.
(func $fac-opt (param i64) (result i64)
(local i64)
(set_local 1 (i64.const 1))
(block
(br_if 0 (i64.lt_s (get_local 0) (i64.const 2)))
(loop
(set_local 1 (i64.mul (get_local 1) (get_local 0)))
(set_local 0 (i64.add (get_local 0) (i64.const -1)))
(br_if 0 (i64.gt_s (get_local 0) (i64.const 1)))
)
)
(get_local 1)
)
(export "fac-rec" 0)
(export "fac-iter" 2)
(export "fac-rec-named" $fac-rec)
(export "fac-iter-named" $fac-iter)
(export "fac-opt" $fac-opt)
)
(assert_return (invoke "fac-rec" (i64.const 25)) (i64.const 7034535277573963776))
(assert_return (invoke "fac-iter" (i64.const 25)) (i64.const 7034535277573963776))
(assert_return (invoke "fac-rec-named" (i64.const 25)) (i64.const 7034535277573963776))
(assert_return (invoke "fac-iter-named" (i64.const 25)) (i64.const 7034535277573963776))
(assert_return (invoke "fac-opt" (i64.const 25)) (i64.const 7034535277573963776))
(assert_trap (invoke "fac-rec" (i64.const 1073741824)) "call stack exhausted")

1738
js/src/jit-test/tests/wasm/spec/float_exprs.wast Normal file
View File

File diff suppressed because one or more lines are too long

199
js/src/jit-test/tests/wasm/spec/float_literals.wast Normal file
View File

@ -0,0 +1,199 @@
;; Test floating-point literal parsing.
(module
;; f32 special values
(func $f32.nan (result i32) (i32.reinterpret/f32 (f32.const nan)))
(func $f32.positive_nan (result i32) (i32.reinterpret/f32 (f32.const +nan)))
(func $f32.negative_nan (result i32) (i32.reinterpret/f32 (f32.const -nan)))
(func $f32.plain_nan (result i32) (i32.reinterpret/f32 (f32.const nan:0x400000)))
(func $f32.informally_known_as_plain_snan (result i32) (i32.reinterpret/f32 (f32.const nan:0x200000)))
(func $f32.allones_nan (result i32) (i32.reinterpret/f32 (f32.const -nan:0x7fffff)))
(func $f32.misc_nan (result i32) (i32.reinterpret/f32 (f32.const nan:0x012345)))
(func $f32.misc_positive_nan (result i32) (i32.reinterpret/f32 (f32.const +nan:0x304050)))
(func $f32.misc_negative_nan (result i32) (i32.reinterpret/f32 (f32.const -nan:0x2abcde)))
(func $f32.infinity (result i32) (i32.reinterpret/f32 (f32.const infinity)))
(func $f32.positive_infinity (result i32) (i32.reinterpret/f32 (f32.const +infinity)))
(func $f32.negative_infinity (result i32) (i32.reinterpret/f32 (f32.const -infinity)))
;; f32 numbers
(func $f32.zero (result i32) (i32.reinterpret/f32 (f32.const 0x0.0p0)))
(func $f32.positive_zero (result i32) (i32.reinterpret/f32 (f32.const +0x0.0p0)))
(func $f32.negative_zero (result i32) (i32.reinterpret/f32 (f32.const -0x0.0p0)))
(func $f32.misc (result i32) (i32.reinterpret/f32 (f32.const 0x1.921fb6p+2)))
(func $f32.min_positive (result i32) (i32.reinterpret/f32 (f32.const 0x1p-149)))
(func $f32.min_normal (result i32) (i32.reinterpret/f32 (f32.const 0x1p-126)))
(func $f32.max_finite (result i32) (i32.reinterpret/f32 (f32.const 0x1.fffffep+127)))
(func $f32.max_subnormal (result i32) (i32.reinterpret/f32 (f32.const 0x1.fffffcp-127)))
(func $f32.trailing_dot (result i32) (i32.reinterpret/f32 (f32.const 0x1.p10)))
;; f32 in decimal format
(func $f32_dec.zero (result i32) (i32.reinterpret/f32 (f32.const 0.0e0)))
(func $f32_dec.positive_zero (result i32) (i32.reinterpret/f32 (f32.const +0.0e0)))
(func $f32_dec.negative_zero (result i32) (i32.reinterpret/f32 (f32.const -0.0e0)))
(func $f32_dec.misc (result i32) (i32.reinterpret/f32 (f32.const 6.28318548202514648)))
(func $f32_dec.min_positive (result i32) (i32.reinterpret/f32 (f32.const 1.4013e-45)))
(func $f32_dec.min_normal (result i32) (i32.reinterpret/f32 (f32.const 1.1754944e-38)))
(func $f32_dec.max_subnormal (result i32) (i32.reinterpret/f32 (f32.const 1.1754942e-38)))
(func $f32_dec.max_finite (result i32) (i32.reinterpret/f32 (f32.const 3.4028234e+38)))
(func $f32_dec.trailing_dot (result i32) (i32.reinterpret/f32 (f32.const 1.e10)))
;; f64 special values
(func $f64.nan (result i64) (i64.reinterpret/f64 (f64.const nan)))
(func $f64.positive_nan (result i64) (i64.reinterpret/f64 (f64.const +nan)))
(func $f64.negative_nan (result i64) (i64.reinterpret/f64 (f64.const -nan)))
(func $f64.plain_nan (result i64) (i64.reinterpret/f64 (f64.const nan:0x8000000000000)))
(func $f64.informally_known_as_plain_snan (result i64) (i64.reinterpret/f64 (f64.const nan:0x4000000000000)))
(func $f64.allones_nan (result i64) (i64.reinterpret/f64 (f64.const -nan:0xfffffffffffff)))
(func $f64.misc_nan (result i64) (i64.reinterpret/f64 (f64.const nan:0x0123456789abc)))
(func $f64.misc_positive_nan (result i64) (i64.reinterpret/f64 (f64.const +nan:0x3040506070809)))
(func $f64.misc_negative_nan (result i64) (i64.reinterpret/f64 (f64.const -nan:0x2abcdef012345)))
(func $f64.infinity (result i64) (i64.reinterpret/f64 (f64.const infinity)))
(func $f64.positive_infinity (result i64) (i64.reinterpret/f64 (f64.const +infinity)))
(func $f64.negative_infinity (result i64) (i64.reinterpret/f64 (f64.const -infinity)))
;; f64 numbers
(func $f64.zero (result i64) (i64.reinterpret/f64 (f64.const 0x0.0p0)))
(func $f64.positive_zero (result i64) (i64.reinterpret/f64 (f64.const +0x0.0p0)))
(func $f64.negative_zero (result i64) (i64.reinterpret/f64 (f64.const -0x0.0p0)))
(func $f64.misc (result i64) (i64.reinterpret/f64 (f64.const 0x1.921fb54442d18p+2)))
(func $f64.min_positive (result i64) (i64.reinterpret/f64 (f64.const 0x0.0000000000001p-1022)))
(func $f64.min_normal (result i64) (i64.reinterpret/f64 (f64.const 0x1p-1022)))
(func $f64.max_subnormal (result i64) (i64.reinterpret/f64 (f64.const 0x0.fffffffffffffp-1022)))
(func $f64.max_finite (result i64) (i64.reinterpret/f64 (f64.const 0x1.fffffffffffffp+1023)))
(func $f64.trailing_dot (result i64) (i64.reinterpret/f64 (f64.const 0x1.p100)))
;; f64 numbers in decimal format
(func $f64_dec.zero (result i64) (i64.reinterpret/f64 (f64.const 0.0e0)))
(func $f64_dec.positive_zero (result i64) (i64.reinterpret/f64 (f64.const +0.0e0)))
(func $f64_dec.negative_zero (result i64) (i64.reinterpret/f64 (f64.const -0.0e0)))
(func $f64_dec.misc (result i64) (i64.reinterpret/f64 (f64.const 6.28318530717958623)))
(func $f64_dec.min_positive (result i64) (i64.reinterpret/f64 (f64.const 4.94066e-324)))
(func $f64_dec.min_normal (result i64) (i64.reinterpret/f64 (f64.const 2.2250738585072012e-308)))
(func $f64_dec.max_subnormal (result i64) (i64.reinterpret/f64 (f64.const 2.2250738585072011e-308)))
(func $f64_dec.max_finite (result i64) (i64.reinterpret/f64 (f64.const 1.7976931348623157e+308)))
(func $f64_dec.trailing_dot (result i64) (i64.reinterpret/f64 (f64.const 1.e100)))
(export "f32.nan" $f32.nan)
(export "f32.positive_nan" $f32.positive_nan)
(export "f32.negative_nan" $f32.negative_nan)
(export "f32.plain_nan" $f32.plain_nan)
(export "f32.informally_known_as_plain_snan" $f32.informally_known_as_plain_snan)
(export "f32.allones_nan" $f32.allones_nan)
(export "f32.misc_nan" $f32.misc_nan)
(export "f32.misc_positive_nan" $f32.misc_positive_nan)
(export "f32.misc_negative_nan" $f32.misc_negative_nan)
(export "f32.infinity" $f32.infinity)
(export "f32.positive_infinity" $f32.positive_infinity)
(export "f32.negative_infinity" $f32.negative_infinity)
(export "f32.zero" $f32.zero)
(export "f32.positive_zero" $f32.positive_zero)
(export "f32.negative_zero" $f32.negative_zero)
(export "f32.misc" $f32.misc)
(export "f32.min_positive" $f32.min_positive)
(export "f32.min_normal" $f32.min_normal)
(export "f32.max_subnormal" $f32.max_subnormal)
(export "f32.max_finite" $f32.max_finite)
(export "f32.trailing_dot" $f32.trailing_dot)
(export "f32_dec.zero" $f32_dec.zero)
(export "f32_dec.positive_zero" $f32_dec.positive_zero)
(export "f32_dec.negative_zero" $f32_dec.negative_zero)
(export "f32_dec.misc" $f32_dec.misc)
(export "f32_dec.min_positive" $f32_dec.min_positive)
(export "f32_dec.min_normal" $f32_dec.min_normal)
(export "f32_dec.max_subnormal" $f32_dec.max_subnormal)
(export "f32_dec.max_finite" $f32_dec.max_finite)
(export "f32_dec.trailing_dot" $f32_dec.trailing_dot)
(export "f64.nan" $f64.nan)
(export "f64.positive_nan" $f64.positive_nan)
(export "f64.negative_nan" $f64.negative_nan)
(export "f64.plain_nan" $f64.plain_nan)
(export "f64.informally_known_as_plain_snan" $f64.informally_known_as_plain_snan)
(export "f64.allones_nan" $f64.allones_nan)
(export "f64.misc_nan" $f64.misc_nan)
(export "f64.misc_positive_nan" $f64.misc_positive_nan)
(export "f64.misc_negative_nan" $f64.misc_negative_nan)
(export "f64.infinity" $f64.infinity)
(export "f64.positive_infinity" $f64.positive_infinity)
(export "f64.negative_infinity" $f64.negative_infinity)
(export "f64.zero" $f64.zero)
(export "f64.positive_zero" $f64.positive_zero)
(export "f64.negative_zero" $f64.negative_zero)
(export "f64.misc" $f64.misc)
(export "f64.min_positive" $f64.min_positive)
(export "f64.min_normal" $f64.min_normal)
(export "f64.max_subnormal" $f64.max_subnormal)
(export "f64.max_finite" $f64.max_finite)
(export "f64.trailing_dot" $f64.trailing_dot)
(export "f64_dec.zero" $f64_dec.zero)
(export "f64_dec.positive_zero" $f64_dec.positive_zero)
(export "f64_dec.negative_zero" $f64_dec.negative_zero)
(export "f64_dec.misc" $f64_dec.misc)
(export "f64_dec.min_positive" $f64_dec.min_positive)
(export "f64_dec.min_normal" $f64_dec.min_normal)
(export "f64_dec.max_subnormal" $f64_dec.max_subnormal)
(export "f64_dec.max_finite" $f64_dec.max_finite)
(export "f64_dec.trailing_dot" $f64_dec.trailing_dot)
)
(assert_return (invoke "f32.nan") (i32.const 0x7fc00000))
(assert_return (invoke "f32.positive_nan") (i32.const 0x7fc00000))
(assert_return (invoke "f32.negative_nan") (i32.const 0xffc00000))
(assert_return (invoke "f32.plain_nan") (i32.const 0x7fc00000))
(assert_return (invoke "f32.informally_known_as_plain_snan") (i32.const 0x7fa00000))
(assert_return (invoke "f32.allones_nan") (i32.const 0xffffffff))
(assert_return (invoke "f32.misc_nan") (i32.const 0x7f812345))
(assert_return (invoke "f32.misc_positive_nan") (i32.const 0x7fb04050))
(assert_return (invoke "f32.misc_negative_nan") (i32.const 0xffaabcde))
(assert_return (invoke "f32.infinity") (i32.const 0x7f800000))
(assert_return (invoke "f32.positive_infinity") (i32.const 0x7f800000))
(assert_return (invoke "f32.negative_infinity") (i32.const 0xff800000))
(assert_return (invoke "f32.zero") (i32.const 0))
(assert_return (invoke "f32.positive_zero") (i32.const 0))
(assert_return (invoke "f32.negative_zero") (i32.const 0x80000000))
(assert_return (invoke "f32.misc") (i32.const 0x40c90fdb))
(assert_return (invoke "f32.min_positive") (i32.const 1))
(assert_return (invoke "f32.min_normal") (i32.const 0x800000))
(assert_return (invoke "f32.max_subnormal") (i32.const 0x7fffff))
(assert_return (invoke "f32.max_finite") (i32.const 0x7f7fffff))
(assert_return (invoke "f32.trailing_dot") (i32.const 0x44800000))
(assert_return (invoke "f32_dec.zero") (i32.const 0))
(assert_return (invoke "f32_dec.positive_zero") (i32.const 0))
(assert_return (invoke "f32_dec.negative_zero") (i32.const 0x80000000))
(assert_return (invoke "f32_dec.misc") (i32.const 0x40c90fdb))
(assert_return (invoke "f32_dec.min_positive") (i32.const 1))
(assert_return (invoke "f32_dec.min_normal") (i32.const 0x800000))
(assert_return (invoke "f32_dec.max_subnormal") (i32.const 0x7fffff))
(assert_return (invoke "f32_dec.max_finite") (i32.const 0x7f7fffff))
(assert_return (invoke "f32_dec.trailing_dot") (i32.const 0x501502f9))
(assert_return (invoke "f64.nan") (i64.const 0x7ff8000000000000))
(assert_return (invoke "f64.positive_nan") (i64.const 0x7ff8000000000000))
(assert_return (invoke "f64.negative_nan") (i64.const 0xfff8000000000000))
(assert_return (invoke "f64.plain_nan") (i64.const 0x7ff8000000000000))
(assert_return (invoke "f64.informally_known_as_plain_snan") (i64.const 0x7ff4000000000000))
(assert_return (invoke "f64.allones_nan") (i64.const 0xffffffffffffffff))
(assert_return (invoke "f64.misc_nan") (i64.const 0x7ff0123456789abc))
(assert_return (invoke "f64.misc_positive_nan") (i64.const 0x7ff3040506070809))
(assert_return (invoke "f64.misc_negative_nan") (i64.const 0xfff2abcdef012345))
(assert_return (invoke "f64.infinity") (i64.const 0x7ff0000000000000))
(assert_return (invoke "f64.positive_infinity") (i64.const 0x7ff0000000000000))
(assert_return (invoke "f64.negative_infinity") (i64.const 0xfff0000000000000))
(assert_return (invoke "f64.zero") (i64.const 0))
(assert_return (invoke "f64.positive_zero") (i64.const 0))
(assert_return (invoke "f64.negative_zero") (i64.const 0x8000000000000000))
(assert_return (invoke "f64.misc") (i64.const 0x401921fb54442d18))
(assert_return (invoke "f64.min_positive") (i64.const 1))
(assert_return (invoke "f64.min_normal") (i64.const 0x10000000000000))
(assert_return (invoke "f64.max_subnormal") (i64.const 0xfffffffffffff))
(assert_return (invoke "f64.max_finite") (i64.const 0x7fefffffffffffff))
(assert_return (invoke "f64.trailing_dot") (i64.const 0x4630000000000000))
(assert_return (invoke "f64_dec.zero") (i64.const 0))
(assert_return (invoke "f64_dec.positive_zero") (i64.const 0))
(assert_return (invoke "f64_dec.negative_zero") (i64.const 0x8000000000000000))
(assert_return (invoke "f64_dec.misc") (i64.const 0x401921fb54442d18))
(assert_return (invoke "f64_dec.min_positive") (i64.const 1))
(assert_return (invoke "f64_dec.min_normal") (i64.const 0x10000000000000))
(assert_return (invoke "f64_dec.max_subnormal") (i64.const 0xfffffffffffff))
(assert_return (invoke "f64_dec.max_finite") (i64.const 0x7fefffffffffffff))
(assert_return (invoke "f64_dec.trailing_dot") (i64.const 0x54b249ad2594c37d))

211
js/src/jit-test/tests/wasm/spec/float_memory.wast Normal file
View File

@ -0,0 +1,211 @@
;; Test that floating-point load and store are bit-preserving.
;; Test that load and store do not canonicalize NaNs as x87 does.
(module
(memory 1 1 (segment 0 "\00\00\a0\7f"))
(func $f32.load (result f32) (f32.load (i32.const 0)))
(export "f32.load" $f32.load)
(func $i32.load (result i32) (i32.load (i32.const 0)))
(export "i32.load" $i32.load)
(func $f32.store (f32.store (i32.const 0) (f32.const nan:0x200000)))
(export "f32.store" $f32.store)
(func $i32.store (i32.store (i32.const 0) (i32.const 0x7fa00000)))
(export "i32.store" $i32.store)
(func $reset (i32.store (i32.const 0) (i32.const 0)))
(export "reset" $reset)
)
(assert_return (invoke "i32.load") (i32.const 0x7fa00000))
(assert_return (invoke "f32.load") (f32.const nan:0x200000))
(invoke "reset")
(assert_return (invoke "i32.load") (i32.const 0x0))
(assert_return (invoke "f32.load") (f32.const 0.0))
(invoke "f32.store")
(assert_return (invoke "i32.load") (i32.const 0x7fa00000))
(assert_return (invoke "f32.load") (f32.const nan:0x200000))
(invoke "reset")
(assert_return (invoke "i32.load") (i32.const 0x0))
(assert_return (invoke "f32.load") (f32.const 0.0))
(invoke "i32.store")
(assert_return (invoke "i32.load") (i32.const 0x7fa00000))
(assert_return (invoke "f32.load") (f32.const nan:0x200000))
(module
(memory 1 1 (segment 0 "\00\00\00\00\00\00\f4\7f"))
(func $f64.load (result f64) (f64.load (i32.const 0)))
(export "f64.load" $f64.load)
(func $i64.load (result i64) (i64.load (i32.const 0)))
(export "i64.load" $i64.load)
(func $f64.store (f64.store (i32.const 0) (f64.const nan:0x4000000000000)))
(export "f64.store" $f64.store)
(func $i64.store (i64.store (i32.const 0) (i64.const 0x7ff4000000000000)))
(export "i64.store" $i64.store)
(func $reset (i64.store (i32.const 0) (i64.const 0)))
(export "reset" $reset)
)
(assert_return (invoke "i64.load") (i64.const 0x7ff4000000000000))
(assert_return (invoke "f64.load") (f64.const nan:0x4000000000000))
(invoke "reset")
(assert_return (invoke "i64.load") (i64.const 0x0))
(assert_return (invoke "f64.load") (f64.const 0.0))
(invoke "f64.store")
(assert_return (invoke "i64.load") (i64.const 0x7ff4000000000000))
(assert_return (invoke "f64.load") (f64.const nan:0x4000000000000))
(invoke "reset")
(assert_return (invoke "i64.load") (i64.const 0x0))
(assert_return (invoke "f64.load") (f64.const 0.0))
(invoke "i64.store")
(assert_return (invoke "i64.load") (i64.const 0x7ff4000000000000))
(assert_return (invoke "f64.load") (f64.const nan:0x4000000000000))
;; Test that unaligned load and store do not canonicalize NaNs.
(module
(memory 1 1 (segment 1 "\00\00\a0\7f"))
(func $f32.load (result f32) (f32.load (i32.const 1)))
(export "f32.load" $f32.load)
(func $i32.load (result i32) (i32.load (i32.const 1)))
(export "i32.load" $i32.load)
(func $f32.store (f32.store (i32.const 1) (f32.const nan:0x200000)))
(export "f32.store" $f32.store)
(func $i32.store (i32.store (i32.const 1) (i32.const 0x7fa00000)))
(export "i32.store" $i32.store)
(func $reset (i32.store (i32.const 1) (i32.const 0)))
(export "reset" $reset)
)
(assert_return (invoke "i32.load") (i32.const 0x7fa00000))
(assert_return (invoke "f32.load") (f32.const nan:0x200000))
(invoke "reset")
(assert_return (invoke "i32.load") (i32.const 0x0))
(assert_return (invoke "f32.load") (f32.const 0.0))
(invoke "f32.store")
(assert_return (invoke "i32.load") (i32.const 0x7fa00000))
(assert_return (invoke "f32.load") (f32.const nan:0x200000))
(invoke "reset")
(assert_return (invoke "i32.load") (i32.const 0x0))
(assert_return (invoke "f32.load") (f32.const 0.0))
(invoke "i32.store")
(assert_return (invoke "i32.load") (i32.const 0x7fa00000))
(assert_return (invoke "f32.load") (f32.const nan:0x200000))
(module
(memory 1 1 (segment 1 "\00\00\00\00\00\00\f4\7f"))
(func $f64.load (result f64) (f64.load (i32.const 1)))
(export "f64.load" $f64.load)
(func $i64.load (result i64) (i64.load (i32.const 1)))
(export "i64.load" $i64.load)
(func $f64.store (f64.store (i32.const 1) (f64.const nan:0x4000000000000)))
(export "f64.store" $f64.store)
(func $i64.store (i64.store (i32.const 1) (i64.const 0x7ff4000000000000)))
(export "i64.store" $i64.store)
(func $reset (i64.store (i32.const 1) (i64.const 0)))
(export "reset" $reset)
)
(assert_return (invoke "i64.load") (i64.const 0x7ff4000000000000))
(assert_return (invoke "f64.load") (f64.const nan:0x4000000000000))
(invoke "reset")
(assert_return (invoke "i64.load") (i64.const 0x0))
(assert_return (invoke "f64.load") (f64.const 0.0))
(invoke "f64.store")
(assert_return (invoke "i64.load") (i64.const 0x7ff4000000000000))
(assert_return (invoke "f64.load") (f64.const nan:0x4000000000000))
(invoke "reset")
(assert_return (invoke "i64.load") (i64.const 0x0))
(assert_return (invoke "f64.load") (f64.const 0.0))
(invoke "i64.store")
(assert_return (invoke "i64.load") (i64.const 0x7ff4000000000000))
(assert_return (invoke "f64.load") (f64.const nan:0x4000000000000))
;; Test that load and store do not canonicalize NaNs as some JS engines do.
(module
(memory 1 1 (segment 0 "\01\00\d0\7f"))
(func $f32.load (result f32) (f32.load (i32.const 0)))
(export "f32.load" $f32.load)
(func $i32.load (result i32) (i32.load (i32.const 0)))
(export "i32.load" $i32.load)
(func $f32.store (f32.store (i32.const 0) (f32.const nan:0x500001)))
(export "f32.store" $f32.store)
(func $i32.store (i32.store (i32.const 0) (i32.const 0x7fd00001)))
(export "i32.store" $i32.store)
(func $reset (i32.store (i32.const 0) (i32.const 0)))
(export "reset" $reset)
)
(assert_return (invoke "i32.load") (i32.const 0x7fd00001))
(assert_return (invoke "f32.load") (f32.const nan:0x500001))
(invoke "reset")
(assert_return (invoke "i32.load") (i32.const 0x0))
(assert_return (invoke "f32.load") (f32.const 0.0))
(invoke "f32.store")
(assert_return (invoke "i32.load") (i32.const 0x7fd00001))
(assert_return (invoke "f32.load") (f32.const nan:0x500001))
(invoke "reset")
(assert_return (invoke "i32.load") (i32.const 0x0))
(assert_return (invoke "f32.load") (f32.const 0.0))
(invoke "i32.store")
(assert_return (invoke "i32.load") (i32.const 0x7fd00001))
(assert_return (invoke "f32.load") (f32.const nan:0x500001))
(module
(memory 1 1 (segment 0 "\01\00\00\00\00\00\fc\7f"))
(func $f64.load (result f64) (f64.load (i32.const 0)))
(export "f64.load" $f64.load)
(func $i64.load (result i64) (i64.load (i32.const 0)))
(export "i64.load" $i64.load)
(func $f64.store (f64.store (i32.const 0) (f64.const nan:0xc000000000001)))
(export "f64.store" $f64.store)
(func $i64.store (i64.store (i32.const 0) (i64.const 0x7ffc000000000001)))
(export "i64.store" $i64.store)
(func $reset (i64.store (i32.const 0) (i64.const 0)))
(export "reset" $reset)
)
(assert_return (invoke "i64.load") (i64.const 0x7ffc000000000001))
(assert_return (invoke "f64.load") (f64.const nan:0xc000000000001))
(invoke "reset")
(assert_return (invoke "i64.load") (i64.const 0x0))
(assert_return (invoke "f64.load") (f64.const 0.0))
(invoke "f64.store")
(assert_return (invoke "i64.load") (i64.const 0x7ffc000000000001))
(assert_return (invoke "f64.load") (f64.const nan:0xc000000000001))
(invoke "reset")
(assert_return (invoke "i64.load") (i64.const 0x0))
(assert_return (invoke "f64.load") (f64.const 0.0))
(invoke "i64.store")
(assert_return (invoke "i64.load") (i64.const 0x7ffc000000000001))
(assert_return (invoke "f64.load") (f64.const nan:0xc000000000001))

585
js/src/jit-test/tests/wasm/spec/float_misc.wast Normal file
View File

@ -0,0 +1,585 @@
;; Platforms intended to run WebAssembly must support IEEE 754 arithmetic.
;; This testsuite is not currently sufficient for full IEEE 754 conformance
;; testing; platforms are currently expected to meet these requirements in
;; their own way (widely-used hardware platforms already do this).
;;
;; What this testsuite does test is that (a) the platform is basically IEEE 754
;; rather than something else entirely, (b) it's configured correctly for
;; WebAssembly (rounding direction, exception masks, precision level, subnormal
;; mode, etc.), and (c) the WebAssembly implementation doesn't perform any
;; common value-changing optimizations.
;;
;; This file supplements f32.wast, f64.wast, f32_cmp.wast, and f64_cmp.wast with
;; additional single-instruction tests covering additional miscellaneous
;; interesting cases.
(module
(func $f32.add (param $x f32) (param $y f32) (result f32) (f32.add (get_local $x) (get_local $y)))
(func $f32.sub (param $x f32) (param $y f32) (result f32) (f32.sub (get_local $x) (get_local $y)))
(func $f32.mul (param $x f32) (param $y f32) (result f32) (f32.mul (get_local $x) (get_local $y)))
(func $f32.div (param $x f32) (param $y f32) (result f32) (f32.div (get_local $x) (get_local $y)))
(func $f32.sqrt (param $x f32) (result f32) (f32.sqrt (get_local $x)))
(func $f32.abs (param $x f32) (result f32) (f32.abs (get_local $x)))
(func $f32.neg (param $x f32) (result f32) (f32.neg (get_local $x)))
(func $f32.copysign (param $x f32) (param $y f32) (result f32) (f32.copysign (get_local $x) (get_local $y)))
(func $f32.ceil (param $x f32) (result f32) (f32.ceil (get_local $x)))
(func $f32.floor (param $x f32) (result f32) (f32.floor (get_local $x)))
(func $f32.trunc (param $x f32) (result f32) (f32.trunc (get_local $x)))
(func $f32.nearest (param $x f32) (result f32) (f32.nearest (get_local $x)))
(func $f32.min (param $x f32) (param $y f32) (result f32) (f32.min (get_local $x) (get_local $y)))
(func $f32.max (param $x f32) (param $y f32) (result f32) (f32.max (get_local $x) (get_local $y)))
(func $f64.add (param $x f64) (param $y f64) (result f64) (f64.add (get_local $x) (get_local $y)))
(func $f64.sub (param $x f64) (param $y f64) (result f64) (f64.sub (get_local $x) (get_local $y)))
(func $f64.mul (param $x f64) (param $y f64) (result f64) (f64.mul (get_local $x) (get_local $y)))
(func $f64.div (param $x f64) (param $y f64) (result f64) (f64.div (get_local $x) (get_local $y)))
(func $f64.sqrt (param $x f64) (result f64) (f64.sqrt (get_local $x)))
(func $f64.abs (param $x f64) (result f64) (f64.abs (get_local $x)))
(func $f64.neg (param $x f64) (result f64) (f64.neg (get_local $x)))
(func $f64.copysign (param $x f64) (param $y f64) (result f64) (f64.copysign (get_local $x) (get_local $y)))
(func $f64.ceil (param $x f64) (result f64) (f64.ceil (get_local $x)))
(func $f64.floor (param $x f64) (result f64) (f64.floor (get_local $x)))
(func $f64.trunc (param $x f64) (result f64) (f64.trunc (get_local $x)))
(func $f64.nearest (param $x f64) (result f64) (f64.nearest (get_local $x)))
(func $f64.min (param $x f64) (param $y f64) (result f64) (f64.min (get_local $x) (get_local $y)))
(func $f64.max (param $x f64) (param $y f64) (result f64) (f64.max (get_local $x) (get_local $y)))
(export "f32.add" $f32.add)
(export "f32.sub" $f32.sub)
(export "f32.mul" $f32.mul)
(export "f32.div" $f32.div)
(export "f32.sqrt" $f32.sqrt)
(export "f32.abs" $f32.abs)
(export "f32.neg" $f32.neg)
(export "f32.copysign" $f32.copysign)
(export "f32.ceil" $f32.ceil)
(export "f32.floor" $f32.floor)
(export "f32.trunc" $f32.trunc)
(export "f32.nearest" $f32.nearest)
(export "f32.min" $f32.min)
(export "f32.max" $f32.max)
(export "f64.add" $f64.add)
(export "f64.sub" $f64.sub)
(export "f64.mul" $f64.mul)
(export "f64.div" $f64.div)
(export "f64.sqrt" $f64.sqrt)
(export "f64.abs" $f64.abs)
(export "f64.neg" $f64.neg)
(export "f64.copysign" $f64.copysign)
(export "f64.ceil" $f64.ceil)
(export "f64.floor" $f64.floor)
(export "f64.trunc" $f64.trunc)
(export "f64.nearest" $f64.nearest)
(export "f64.min" $f64.min)
(export "f64.max" $f64.max)
)
(assert_return (invoke "f32.add" (f32.const 1.1234567890) (f32.const 1.2345e-10)) (f32.const 1.123456789))
;; Test adding the greatest value to 1.0 that rounds back to 1.0, and the
;; least that rounds to something greater.
(assert_return (invoke "f32.add" (f32.const 1.0) (f32.const 0x1p-24)) (f32.const 0x1.0p+0))
(assert_return (invoke "f32.add" (f32.const 1.0) (f32.const 0x1.000002p-24)) (f32.const 0x1.000002p+0))
;; Computations that round differently in ties-to-odd mode.
(assert_return (invoke "f32.add" (f32.const 0x1p23) (f32.const 0x1p-1)) (f32.const 0x1p23))
(assert_return (invoke "f32.add" (f32.const 0x1.000002p+23) (f32.const 0x1p-1)) (f32.const 0x1.000004p+23))
;; Test that what some systems call signaling NaN behaves as a quiet NaN.
(assert_return (invoke "f32.add" (f32.const nan:0x200000) (f32.const 1.0)) (f32.const nan:0x600000))
(assert_return (invoke "f64.add" (f64.const 1.1234567890) (f64.const 1.2345e-10)) (f64.const 0x1.1f9add37c11f7p+0))
;; Test for a case of double rounding, example from:
;; http://perso.ens-lyon.fr/jean-michel.muller/Handbook.html
;; section 3.3.1: A typical problem: "double rounding"
(assert_return (invoke "f64.add" (f64.const 0x1p+63) (f64.const 1024.25)) (f64.const 0x1.0000000000001p+63))
;; Test a case that was "tricky" on MMIX.
;; http://mmix.cs.hm.edu/bugs/bug_rounding.html
(assert_return (invoke "f64.add" (f64.const -0x1p-1008) (f64.const 0x0.0000000001716p-1022)) (f64.const -0x1.fffffffffffffp-1009))
;; Test adding the greatest value to 1.0 that rounds back to 1.0, and the
;; least that rounds to something greater.
(assert_return (invoke "f64.add" (f64.const 1.0) (f64.const 0x1p-53)) (f64.const 0x1.0p+0))
(assert_return (invoke "f64.add" (f64.const 1.0) (f64.const 0x1.0000000000001p-53)) (f64.const 0x1.0000000000001p+0))
;; Computations that round differently in ties-to-odd mode.
(assert_return (invoke "f64.add" (f64.const 0x1p52) (f64.const 0x1p-1)) (f64.const 0x1p52))
(assert_return (invoke "f64.add" (f64.const 0x1.0000000000001p+52) (f64.const 0x1p-1)) (f64.const 0x1.0000000000002p+52))
;; Computations that round differently in round-upward mode.
(assert_return (invoke "f32.add" (f32.const -0x1.39675ap+102) (f32.const 0x1.76c94cp-99)) (f32.const -0x1.39675ap+102))
(assert_return (invoke "f32.add" (f32.const 0x1.6c0f24p+67) (f32.const -0x1.2b92dp+52)) (f32.const 0x1.6c0cccp+67))
(assert_return (invoke "f32.add" (f32.const 0x1.e62318p-83) (f32.const 0x1.f74abep-125)) (f32.const 0x1.e62318p-83))
(assert_return (invoke "f32.add" (f32.const 0x1.2a71d4p+39) (f32.const -0x1.c9f10cp+55)) (f32.const -0x1.c9efe2p+55))
(assert_return (invoke "f32.add" (f32.const 0x1.f8f736p-15) (f32.const 0x1.7bd45ep+106)) (f32.const 0x1.7bd45ep+106))
(assert_return (invoke "f64.add" (f64.const 0x1.f33e1fbca27aap-413) (f64.const -0x1.6b192891ed61p+249)) (f64.const -0x1.6b192891ed61p+249))
(assert_return (invoke "f64.add" (f64.const -0x1.46f75d130eeb1p+76) (f64.const 0x1.25275d6f7a4acp-184)) (f64.const -0x1.46f75d130eeb1p+76))
(assert_return (invoke "f64.add" (f64.const 0x1.04dec9265a731p-148) (f64.const -0x1.11eed4e8c127cp-12)) (f64.const -0x1.11eed4e8c127cp-12))
(assert_return (invoke "f64.add" (f64.const 0x1.05773b7166b0ap+497) (f64.const 0x1.134022f2da37bp+66)) (f64.const 0x1.05773b7166b0ap+497))
(assert_return (invoke "f64.add" (f64.const 0x1.ef4f794282a82p+321) (f64.const 0x1.14a82266badep+394)) (f64.const 0x1.14a82266badep+394))
;; Computations that round differently in round-downward mode.
(assert_return (invoke "f32.add" (f32.const 0x1.1bf976p+72) (f32.const -0x1.7f5868p+20)) (f32.const 0x1.1bf976p+72))
(assert_return (invoke "f32.add" (f32.const 0x1.7f9c6cp-45) (f32.const -0x1.b9bb0ep-78)) (f32.const 0x1.7f9c6cp-45))
(assert_return (invoke "f32.add" (f32.const -0x1.32d1bcp-42) (f32.const 0x1.f7d214p+125)) (f32.const 0x1.f7d214p+125))
(assert_return (invoke "f32.add" (f32.const -0x1.8e5c0ep-44) (f32.const -0x1.3afa4cp-106)) (f32.const -0x1.8e5c0ep-44))
(assert_return (invoke "f32.add" (f32.const 0x1.13cd78p-10) (f32.const -0x1.3af316p-107)) (f32.const 0x1.13cd78p-10))
(assert_return (invoke "f64.add" (f64.const 0x1.f8dd15ca97d4ap+179) (f64.const -0x1.367317d1fe8bfp-527)) (f64.const 0x1.f8dd15ca97d4ap+179))
(assert_return (invoke "f64.add" (f64.const 0x1.5db08d739228cp+155) (f64.const -0x1.fb316fa147dcbp-61)) (f64.const 0x1.5db08d739228cp+155))
(assert_return (invoke "f64.add" (f64.const 0x1.bbb403cb85c07p-404) (f64.const -0x1.7e44046b8bbf3p-979)) (f64.const 0x1.bbb403cb85c07p-404))
(assert_return (invoke "f64.add" (f64.const -0x1.34d38af291831p+147) (f64.const -0x1.9890b47439953p+139)) (f64.const -0x1.366c1ba705bcap+147))
(assert_return (invoke "f64.add" (f64.const -0x1.b61dedf4e0306p+3) (f64.const 0x1.09e2f31773c4ap+290)) (f64.const 0x1.09e2f31773c4ap+290))
;; Computations that round differently in round-toward-zero mode.
(assert_return (invoke "f32.add" (f32.const -0x1.129bd8p-117) (f32.const 0x1.c75012p-43)) (f32.const 0x1.c75012p-43))
(assert_return (invoke "f32.add" (f32.const -0x1.c204a2p-16) (f32.const 0x1.80b132p-27)) (f32.const -0x1.c1d48cp-16))
(assert_return (invoke "f32.add" (f32.const -0x1.decc1cp+36) (f32.const 0x1.c688dap-109)) (f32.const -0x1.decc1cp+36))
(assert_return (invoke "f32.add" (f32.const 0x1.61ce6ap-118) (f32.const -0x1.772892p+30)) (f32.const -0x1.772892p+30))
(assert_return (invoke "f32.add" (f32.const -0x1.3dc826p-120) (f32.const 0x1.fc3f66p+95)) (f32.const 0x1.fc3f66p+95))
(assert_return (invoke "f64.add" (f64.const 0x1.bf68acc263a0fp-777) (f64.const -0x1.5f9352965e5a6p+1004)) (f64.const -0x1.5f9352965e5a6p+1004))
(assert_return (invoke "f64.add" (f64.const -0x1.76eaa70911f51p+516) (f64.const -0x1.2d746324ce47ap+493)) (f64.const -0x1.76eaa963fabb6p+516))
(assert_return (invoke "f64.add" (f64.const -0x1.b637d82c15a7ap-967) (f64.const 0x1.cc654ccab4152p-283)) (f64.const 0x1.cc654ccab4152p-283))
(assert_return (invoke "f64.add" (f64.const -0x1.a5b1fb66e846ep-509) (f64.const 0x1.4bdd36f0bb5ccp-860)) (f64.const -0x1.a5b1fb66e846ep-509))
(assert_return (invoke "f64.add" (f64.const -0x1.14108da880f9ep+966) (f64.const 0x1.417f35701e89fp+800)) (f64.const -0x1.14108da880f9ep+966))
;; Computations that round differently on x87.
(assert_return (invoke "f64.add" (f64.const -0x1.fa0caf21ffebcp+804) (f64.const 0x1.4ca8fdcff89f9p+826)) (f64.const 0x1.4ca8f5e7c5e31p+826))
(assert_return (invoke "f64.add" (f64.const 0x1.016f1fcbdfd38p+784) (f64.const 0x1.375dffcbc9a2cp+746)) (f64.const 0x1.016f1fcbe4b0fp+784))
(assert_return (invoke "f64.add" (f64.const -0x1.dffda6d5bff3ap+624) (f64.const 0x1.f9e8cc2dff782p+674)) (f64.const 0x1.f9e8cc2dff77bp+674))
(assert_return (invoke "f64.add" (f64.const 0x1.fff4b43687dfbp+463) (f64.const 0x1.0fd5617c4a809p+517)) (f64.const 0x1.0fd5617c4a809p+517))
(assert_return (invoke "f64.add" (f64.const 0x1.535d380035da2p-995) (f64.const 0x1.cce37dddbb73bp-963)) (f64.const 0x1.cce37ddf0ed0fp-963))
;; Computations that round differently when computed via f32.
(assert_return (invoke "f64.add" (f64.const -0x1.d91cd3fc0c66fp+752) (f64.const -0x1.4e18c80229734p+952)) (f64.const -0x1.4e18c80229734p+952))
(assert_return (invoke "f64.add" (f64.const 0x1.afc70fd36e372p+193) (f64.const -0x1.bd10a9b377b46p+273)) (f64.const -0x1.bd10a9b377b46p+273))
(assert_return (invoke "f64.add" (f64.const -0x1.2abd570b078b2p+302) (f64.const 0x1.b3c1ad759cb5bp-423)) (f64.const -0x1.2abd570b078b2p+302))
(assert_return (invoke "f64.add" (f64.const -0x1.5b2ae84c0686cp-317) (f64.const -0x1.dba7a1c022823p+466)) (f64.const -0x1.dba7a1c022823p+466))
(assert_return (invoke "f64.add" (f64.const -0x1.ac627bd7cbf38p-198) (f64.const 0x1.2312e265b8d59p-990)) (f64.const -0x1.ac627bd7cbf38p-198))
;; Computations that utilize the maximum exponent value to avoid overflow.
(assert_return (invoke "f64.add" (f64.const -0x1.397be95d10fddp+719) (f64.const -0x1.e13909d198d32p+1023)) (f64.const -0x1.e13909d198d32p+1023))
(assert_return (invoke "f64.add" (f64.const -0x1.234a5a0412f41p+1023) (f64.const -0x1.53e9106c9367p+161)) (f64.const -0x1.234a5a0412f41p+1023))
(assert_return (invoke "f64.add" (f64.const -0x1.a86bdb66cbb32p+562) (f64.const 0x1.d10ff29e1d6e8p+1023)) (f64.const 0x1.d10ff29e1d6e8p+1023))
(assert_return (invoke "f64.add" (f64.const -0x1.dc295727a06e2p+1023) (f64.const 0x1.5e6979d7b24fp+485)) (f64.const -0x1.dc295727a06e2p+1023))
(assert_return (invoke "f64.add" (f64.const -0x1.3ff7dee2861c6p-557) (f64.const 0x1.84a2c18238b4cp+1023)) (f64.const 0x1.84a2c18238b4cp+1023))
;; Computations that utilize the minimum exponent value.
(assert_return (invoke "f64.add" (f64.const -0x0.2d2c9b631ae47p-1022) (f64.const -0x0.8e173a51d11a7p-1022)) (f64.const -0x0.bb43d5b4ebfeep-1022))
(assert_return (invoke "f64.add" (f64.const -0x0.ce7d534f2c7ep-1022) (f64.const -0x0.32f94dc4b7ee5p-1022)) (f64.const -0x1.0176a113e46c5p-1022))
(assert_return (invoke "f64.add" (f64.const -0x1.44d9fb78bf5d3p-1021) (f64.const -0x0.02766a20d263fp-1022)) (f64.const -0x1.46153089288f2p-1021))
(assert_return (invoke "f64.add" (f64.const 0x0.89e17f0fdc567p-1022) (f64.const -0x1.d9a93a01fd27dp-1021)) (f64.const -0x1.94b87a7a0efcap-1021))
(assert_return (invoke "f64.add" (f64.const -0x0.3f3d1a052fa2bp-1022) (f64.const -0x1.4b78292c7d2adp-1021)) (f64.const -0x1.6b16b62f14fc2p-1021))
;; Test that what some systems call signaling NaN behaves as a quiet NaN.
(assert_return (invoke "f64.add" (f64.const nan:0x4000000000000) (f64.const 1.0)) (f64.const nan:0xc000000000000))
;; Test for a historic spreadsheet bug.
;; https://blogs.office.com/2007/09/25/calculation-issue-update/
(assert_return (invoke "f32.sub" (f32.const 65536.0) (f32.const 0x1p-37)) (f32.const 65536.0))
;; Test for a historic spreadsheet bug.
;; https://blogs.office.com/2007/09/25/calculation-issue-update/
(assert_return (invoke "f64.sub" (f64.const 65536.0) (f64.const 0x1p-37)) (f64.const 0x1.fffffffffffffp+15))
;; Test subtracting the greatest value from 1.0 that rounds back to 1.0, and the
;; least that rounds to something less.
(assert_return (invoke "f32.sub" (f32.const 1.0) (f32.const 0x1p-25)) (f32.const 0x1.0p+0))
(assert_return (invoke "f32.sub" (f32.const 1.0) (f32.const 0x1.000002p-25)) (f32.const 0x1.fffffep-1))
;; Test subtracting the greatest value from 1.0 that rounds back to 1.0, and the
;; least that rounds to something less.
(assert_return (invoke "f64.sub" (f64.const 1.0) (f64.const 0x1p-54)) (f64.const 0x1.0p+0))
(assert_return (invoke "f64.sub" (f64.const 1.0) (f64.const 0x1.0000000000001p-54)) (f64.const 0x1.fffffffffffffp-1))
;; Computations that round differently in round-upward mode.
(assert_return (invoke "f32.sub" (f32.const 0x1.ee2466p-106) (f32.const -0x1.16277ep+119)) (f32.const 0x1.16277ep+119))
(assert_return (invoke "f32.sub" (f32.const -0x1.446f9ep+119) (f32.const -0x1.4396a4p+43)) (f32.const -0x1.446f9ep+119))
(assert_return (invoke "f32.sub" (f32.const 0x1.74773cp+0) (f32.const -0x1.a25512p-82)) (f32.const 0x1.74773cp+0))
(assert_return (invoke "f32.sub" (f32.const 0x1.9345c4p-117) (f32.const 0x1.6792c2p-76)) (f32.const -0x1.6792c2p-76))
(assert_return (invoke "f32.sub" (f32.const 0x1.9ecfa4p-18) (f32.const -0x1.864b44p-107)) (f32.const 0x1.9ecfa4p-18))
(assert_return (invoke "f64.sub" (f64.const -0x1.5b798875e7845p-333) (f64.const -0x1.b5147117452fep-903)) (f64.const -0x1.5b798875e7845p-333))
(assert_return (invoke "f64.sub" (f64.const -0x1.6c87baeb6d72dp+552) (f64.const -0x1.64fb35d4b5571p-158)) (f64.const -0x1.6c87baeb6d72dp+552))
(assert_return (invoke "f64.sub" (f64.const 0x1.b3d369fcf74bp-461) (f64.const -0x1.ea1668c0dec93p-837)) (f64.const 0x1.b3d369fcf74bp-461))
(assert_return (invoke "f64.sub" (f64.const 0x1.0abd449353eadp-1005) (f64.const -0x1.0422ea3e82ee9p+154)) (f64.const 0x1.0422ea3e82ee9p+154))
(assert_return (invoke "f64.sub" (f64.const -0x1.aadbc6b43cc3dp-143) (f64.const -0x1.e7f922ef1ee58p-539)) (f64.const -0x1.aadbc6b43cc3dp-143))
;; Computations that round differently in round-downward mode.
(assert_return (invoke "f32.sub" (f32.const -0x1.61e262p+108) (f32.const -0x1.baf3e4p+112)) (f32.const 0x1.a4d5bep+112))
(assert_return (invoke "f32.sub" (f32.const -0x1.62c2f6p+109) (f32.const 0x1.6e514ap+6)) (f32.const -0x1.62c2f6p+109))
(assert_return (invoke "f32.sub" (f32.const -0x1.287c94p-83) (f32.const 0x1.0f2f9cp-24)) (f32.const -0x1.0f2f9cp-24))
(assert_return (invoke "f32.sub" (f32.const -0x1.c8825cp-77) (f32.const -0x1.4aead6p-12)) (f32.const 0x1.4aead6p-12))
(assert_return (invoke "f32.sub" (f32.const -0x1.2976a4p+99) (f32.const 0x1.c6e3b8p-59)) (f32.const -0x1.2976a4p+99))
(assert_return (invoke "f64.sub" (f64.const -0x1.76cb28ae6c045p+202) (f64.const -0x1.0611f2af4e9b9p+901)) (f64.const 0x1.0611f2af4e9b9p+901))
(assert_return (invoke "f64.sub" (f64.const 0x1.baf35eff22e9ep-368) (f64.const 0x1.5c3e08ecf73ecp-451)) (f64.const 0x1.baf35eff22e9ep-368))
(assert_return (invoke "f64.sub" (f64.const -0x1.8fd354b376f1fp-200) (f64.const 0x1.513c860f386ffp-508)) (f64.const -0x1.8fd354b376f1fp-200))
(assert_return (invoke "f64.sub" (f64.const -0x1.760d447230ae6p-992) (f64.const -0x1.16f788438ae3ep-328)) (f64.const 0x1.16f788438ae3ep-328))
(assert_return (invoke "f64.sub" (f64.const -0x1.73aab4fcfc7ap+112) (f64.const 0x1.7c589f990b884p+171)) (f64.const -0x1.7c589f990b884p+171))
;; Computations that round differently in round-toward-zero mode.
(assert_return (invoke "f32.sub" (f32.const 0x1.ea264cp+95) (f32.const 0x1.852988p-15)) (f32.const 0x1.ea264cp+95))
(assert_return (invoke "f32.sub" (f32.const -0x1.14ec7cp+19) (f32.const -0x1.0ad3fep-35)) (f32.const -0x1.14ec7cp+19))
(assert_return (invoke "f32.sub" (f32.const -0x1.3251dap-36) (f32.const -0x1.49c97ep-56)) (f32.const -0x1.3251c6p-36))
(assert_return (invoke "f32.sub" (f32.const -0x1.13565ep-14) (f32.const 0x1.2f89a8p-13)) (f32.const -0x1.b934d8p-13))
(assert_return (invoke "f32.sub" (f32.const -0x1.6032b6p-33) (f32.const -0x1.bb5196p-104)) (f32.const -0x1.6032b6p-33))
(assert_return (invoke "f64.sub" (f64.const -0x1.b5b0797af491p-157) (f64.const -0x1.694b8348189e8p+722)) (f64.const 0x1.694b8348189e8p+722))
(assert_return (invoke "f64.sub" (f64.const -0x1.72b142826ed73p+759) (f64.const -0x1.010477bc9afbdp+903)) (f64.const 0x1.010477bc9afbdp+903))
(assert_return (invoke "f64.sub" (f64.const 0x1.83273b6bb94cfp-796) (f64.const 0x1.1a93f948a2abbp+181)) (f64.const -0x1.1a93f948a2abbp+181))
(assert_return (invoke "f64.sub" (f64.const -0x1.207e7156cbf2p-573) (f64.const 0x1.cf3f12fd3814dp-544)) (f64.const -0x1.cf3f13063c086p-544))
(assert_return (invoke "f64.sub" (f64.const -0x1.837e6844f1718p-559) (f64.const -0x1.1c29b757f98abp-14)) (f64.const 0x1.1c29b757f98abp-14))
;; Computations that round differently on x87.
(assert_return (invoke "f64.sub" (f64.const 0x1.c21151a709b6cp-78) (f64.const 0x1.0a12fff8910f6p-115)) (f64.const 0x1.c21151a701663p-78))
(assert_return (invoke "f64.sub" (f64.const 0x1.c57912aae2f64p-982) (f64.const 0x1.dbfbd4800b7cfp-1010)) (f64.const 0x1.c579128d2338fp-982))
(assert_return (invoke "f64.sub" (f64.const 0x1.ffef4399af9c6p-254) (f64.const 0x1.edb96dfaea8b1p-200)) (f64.const -0x1.edb96dfaea8b1p-200))
(assert_return (invoke "f64.sub" (f64.const -0x1.363eee391cde2p-39) (f64.const -0x1.a65462000265fp-69)) (f64.const -0x1.363eee32838c9p-39))
(assert_return (invoke "f64.sub" (f64.const 0x1.59016dba002a1p-25) (f64.const 0x1.5d4374f124cccp-3)) (f64.const -0x1.5d436f8d1f15dp-3))
;; Computations that round differently when computed via f32.
(assert_return (invoke "f64.sub" (f64.const -0x1.18196bca005cfp-814) (f64.const -0x1.db7b01ce3f52fp-766)) (f64.const 0x1.db7b01ce3f51dp-766))
(assert_return (invoke "f64.sub" (f64.const -0x1.d17b3528d219p+33) (f64.const 0x1.fd739d4ea220ap+367)) (f64.const -0x1.fd739d4ea220ap+367))
(assert_return (invoke "f64.sub" (f64.const 0x1.dea46994de319p+114) (f64.const 0x1.b5b19cd55c7d3p-590)) (f64.const 0x1.dea46994de319p+114))
(assert_return (invoke "f64.sub" (f64.const 0x1.b60f9b2fbd9ecp-489) (f64.const -0x1.6f81c59ec5b8ep-694)) (f64.const 0x1.b60f9b2fbd9ecp-489))
(assert_return (invoke "f64.sub" (f64.const 0x1.5e423fe8571f4p-57) (f64.const 0x1.9624ed7c162dfp-618)) (f64.const 0x1.5e423fe8571f4p-57))
(assert_return (invoke "f32.mul" (f32.const 1e15) (f32.const 1e15)) (f32.const 0x1.93e592p+99))
(assert_return (invoke "f32.mul" (f32.const 1e20) (f32.const 1e20)) (f32.const infinity))
(assert_return (invoke "f32.mul" (f32.const 1e25) (f32.const 1e25)) (f32.const infinity))
;; Test for a case of double rounding, example from:
;; http://perso.ens-lyon.fr/jean-michel.muller/Handbook.html
;; section 3.3.1: A typical problem: "double rounding"
(assert_return (invoke "f32.mul" (f32.const 1848874880.0) (f32.const 19954563072.0)) (f32.const 0x1.000002p+65))
;; Test for a historic spreadsheet bug.
;; http://www.joelonsoftware.com/items/2007/09/26b.html
(assert_return (invoke "f32.mul" (f32.const 77.1) (f32.const 850)) (f32.const 65535))
(assert_return (invoke "f64.mul" (f64.const 1e15) (f64.const 1e15)) (f64.const 0x1.93e5939a08ceap+99))
(assert_return (invoke "f64.mul" (f64.const 1e20) (f64.const 1e20)) (f64.const 0x1.d6329f1c35ca5p+132))
(assert_return (invoke "f64.mul" (f64.const 1e25) (f64.const 1e25)) (f64.const 0x1.11b0ec57e649bp+166))
;; Test for a case of double rounding, example from:
;; http://perso.ens-lyon.fr/jean-michel.muller/Handbook.html
;; section 3.3.1: A typical problem: "double rounding"
(assert_return (invoke "f64.mul" (f64.const 1848874847.0) (f64.const 19954562207.0)) (f64.const 3.6893488147419111424e+19))
;; Test for a historic spreadsheet bug.
;; http://www.joelonsoftware.com/items/2007/09/26b.html
(assert_return (invoke "f64.mul" (f64.const 77.1) (f64.const 850)) (f64.const 65534.99999999999272404))
;; Computations that round differently in round-upward mode.
(assert_return (invoke "f32.mul" (f32.const -0x1.14df2ep+61) (f32.const 0x1.748878p-36)) (f32.const -0x1.92e7e8p+25))
(assert_return (invoke "f32.mul" (f32.const -0x1.5629e2p+102) (f32.const -0x1.c33012p-102)) (f32.const 0x1.2d8604p+1))
(assert_return (invoke "f32.mul" (f32.const -0x1.b17694p+92) (f32.const -0x1.e4b56ap-97)) (f32.const 0x1.9a5baep-4))
(assert_return (invoke "f32.mul" (f32.const -0x1.1626a6p+79) (f32.const -0x1.c57d7p-75)) (f32.const 0x1.ecbaaep+4))
(assert_return (invoke "f32.mul" (f32.const 0x1.7acf72p+53) (f32.const 0x1.6c89acp+5)) (f32.const 0x1.0db556p+59))
(assert_return (invoke "f64.mul" (f64.const -0x1.25c293f6f37e4p+425) (f64.const 0x1.f5fd4fa41c6d8p+945)) (f64.const -infinity))
(assert_return (invoke "f64.mul" (f64.const -0x1.cc1ae79fffc5bp-986) (f64.const -0x1.c36ccc2861ca6p-219)) (f64.const 0x0p+0))
(assert_return (invoke "f64.mul" (f64.const 0x1.c0232b3e64b56p+606) (f64.const -0x1.f6939cf3affaap+106)) (f64.const -0x1.b7e3aedf190d3p+713))
(assert_return (invoke "f64.mul" (f64.const -0x1.60f289966b271p-313) (f64.const 0x1.28a5497f0c259p+583)) (f64.const -0x1.98fc50bcec259p+270))
(assert_return (invoke "f64.mul" (f64.const 0x1.37dab12d3afa2p+795) (f64.const 0x1.81e156bd393f1p-858)) (f64.const 0x1.d6126554b8298p-63))
;; Computations that round differently in round-downward mode.
(assert_return (invoke "f32.mul" (f32.const -0x1.3f57a2p-89) (f32.const -0x1.041d68p+92)) (f32.const 0x1.4479bp+3))
(assert_return (invoke "f32.mul" (f32.const 0x1.4d0582p+73) (f32.const 0x1.6e043ap+19)) (f32.const 0x1.dc236p+92))
(assert_return (invoke "f32.mul" (f32.const -0x1.2fdap-32) (f32.const -0x1.e1731cp+74)) (f32.const 0x1.1db89ep+43))
(assert_return (invoke "f32.mul" (f32.const 0x1.7bc8fep+67) (f32.const -0x1.3ad592p+15)) (f32.const -0x1.d3115ep+82))
(assert_return (invoke "f32.mul" (f32.const 0x1.936742p+30) (f32.const -0x1.a7a19p+66)) (f32.const -0x1.4dc71ap+97))
(assert_return (invoke "f64.mul" (f64.const -0x1.ba737b4ca3b13p-639) (f64.const 0x1.8923309857438p-314)) (f64.const -0x1.53bc0d07baa37p-952))
(assert_return (invoke "f64.mul" (f64.const 0x1.7c1932e610219p-276) (f64.const -0x1.2605db646489fp-635)) (f64.const -0x1.b48da2b0d2ae3p-911))
(assert_return (invoke "f64.mul" (f64.const -0x1.e43cdf3b2108p+329) (f64.const -0x1.99d96abbd61d1p+835)) (f64.const infinity))
(assert_return (invoke "f64.mul" (f64.const 0x1.4c19466551da3p+947) (f64.const 0x1.0bdcd6c7646e9p-439)) (f64.const 0x1.5b7cd8c3f638ap+508))
(assert_return (invoke "f64.mul" (f64.const 0x1.ff1da1726e3dfp+339) (f64.const -0x1.043c44f52b158p+169)) (f64.const -0x1.03c9364bb585cp+509))
;; Computations that round differently in round-toward-zero mode.
(assert_return (invoke "f32.mul" (f32.const -0x1.907e8ap+46) (f32.const -0x1.5d3668p+95)) (f32.const infinity))
(assert_return (invoke "f32.mul" (f32.const -0x1.8c9f74p-3) (f32.const 0x1.e2b452p-99)) (f32.const -0x1.75edccp-101))
(assert_return (invoke "f32.mul" (f32.const -0x1.cc605ap-19) (f32.const 0x1.ec321ap+105)) (f32.const -0x1.ba91a4p+87))
(assert_return (invoke "f32.mul" (f32.const -0x1.5fbb7ap+56) (f32.const 0x1.a8965ep-96)) (f32.const -0x1.23ae8ep-39))
(assert_return (invoke "f32.mul" (f32.const -0x1.fb7f12p+16) (f32.const 0x1.3a701ap-119)) (f32.const -0x1.37ac0cp-102))
(assert_return (invoke "f64.mul" (f64.const -0x1.5b0266454c26bp-496) (f64.const -0x1.af5787e3e0399p+433)) (f64.const 0x1.2457d81949e0bp-62))
(assert_return (invoke "f64.mul" (f64.const 0x1.0d54a82393d45p+478) (f64.const -0x1.425760807ceaep-764)) (f64.const -0x1.532068c8d0d5dp-286))
(assert_return (invoke "f64.mul" (f64.const -0x1.b532af981786p+172) (f64.const 0x1.ada95085ba36fp+359)) (f64.const -0x1.6ee38c1e01864p+532))
(assert_return (invoke "f64.mul" (f64.const 0x1.e132f4d49d1cep+768) (f64.const -0x1.a75afe9a7d864p+374)) (f64.const -infinity))
(assert_return (invoke "f64.mul" (f64.const 0x1.68bbf1cfff90ap+81) (f64.const 0x1.09cd17d652c5p+70)) (f64.const 0x1.768b8d67d794p+151))
;; Computations that round differently on x87.
(assert_return (invoke "f64.mul" (f64.const 0x1.f99fb602c89b7p-341) (f64.const 0x1.6caab46a31a2ep-575)) (f64.const 0x1.68201f986e9d7p-915))
(assert_return (invoke "f64.mul" (f64.const -0x1.86999c5eee379p-9) (f64.const 0x1.6e3b9e0d53e0dp+723)) (f64.const -0x1.17654a0ef35f5p+715))
(assert_return (invoke "f64.mul" (f64.const -0x1.069571b176f9p+367) (f64.const -0x1.e248b6ab0a0e3p-652)) (f64.const 0x1.eeaff575cae1dp-285))
(assert_return (invoke "f64.mul" (f64.const 0x1.c217645777dd2p+775) (f64.const 0x1.d93f5715dd646p+60)) (f64.const 0x1.a0064aa1d920dp+836))
(assert_return (invoke "f64.mul" (f64.const -0x1.848981b6e694ap-276) (f64.const 0x1.f5aacb64a0d19p+896)) (f64.const -0x1.7cb2296e6c2e5p+621))
;; Computations that round differently on x87 in double-precision mode.
(assert_return (invoke "f64.mul" (f64.const 0x1.db3bd2a286944p-599) (f64.const 0x1.ce910af1d55cap-425)) (f64.const 0x0.d6accdd538a39p-1022))
(assert_return (invoke "f64.mul" (f64.const -0x1.aca223916012p-57) (f64.const -0x1.2b2b4958dd228p-966)) (f64.const 0x0.fa74eccae5615p-1022))
(assert_return (invoke "f64.mul" (f64.const -0x1.bd062def16cffp-488) (f64.const -0x1.7ddd91a0c4c0ep-536)) (f64.const 0x0.a5f4d7769d90dp-1022))
(assert_return (invoke "f64.mul" (f64.const -0x1.c6a56169e9cep-772) (f64.const 0x1.517d55a474122p-255)) (f64.const -0x0.12baf260afb77p-1022))
(assert_return (invoke "f64.mul" (f64.const -0x1.08951b0b41705p-516) (f64.const -0x1.102dc27168d09p-507)) (f64.const 0x0.8ca6dbf3f592bp-1022))
;; Computations that round differently when computed via f32.
(assert_return (invoke "f64.mul" (f64.const 0x1.8d0dea50c8c9bp+852) (f64.const 0x1.21cac31d87a24p-881)) (f64.const 0x1.c177311f7cd73p-29))
(assert_return (invoke "f64.mul" (f64.const 0x1.98049118e3063p-7) (f64.const 0x1.6362525151b58p-149)) (f64.const 0x1.1b358514103f9p-155))
(assert_return (invoke "f64.mul" (f64.const -0x1.ea65cb0631323p+1) (f64.const 0x1.fce683201a19bp-41)) (f64.const -0x1.e76dc8c223667p-39))
(assert_return (invoke "f64.mul" (f64.const 0x1.e4d235961d543p-373) (f64.const 0x1.bc56f20ef9a48p-205)) (f64.const 0x1.a4c09efcb71d6p-577))
(assert_return (invoke "f64.mul" (f64.const -0x1.b9612e66faba8p+77) (f64.const 0x1.e2bc6aa782273p-348)) (f64.const -0x1.a026ea4f81db1p-270))
;; Test the least value with a positive square.
(assert_return (invoke "f32.mul" (f32.const 0x1p-75) (f32.const 0x1p-75)) (f32.const 0x0p+0))
(assert_return (invoke "f32.mul" (f32.const 0x1.000002p-75) (f32.const 0x1.000002p-75)) (f32.const 0x1p-149))
(assert_return (invoke "f64.mul" (f64.const 0x1.6a09e667f3bccp-538) (f64.const 0x1.6a09e667f3bccp-538)) (f64.const 0x0p+0))
(assert_return (invoke "f64.mul" (f64.const 0x1.6a09e667f3bcdp-538) (f64.const 0x1.6a09e667f3bcdp-538)) (f64.const 0x0.0000000000001p-1022))
(assert_return (invoke "f32.div" (f32.const 1.123456789) (f32.const 100)) (f32.const 0x1.702264p-7))
(assert_return (invoke "f32.div" (f32.const 8391667.0) (f32.const 12582905.0)) (f32.const 0x1.55754p-1))
(assert_return (invoke "f32.div" (f32.const 65536.0) (f32.const 0x1p-37)) (f32.const 0x1p+53))
(assert_return (invoke "f32.div" (f32.const 0x1.dcbf6ap+0) (f32.const 0x1.fffffep+127)) (f32.const 0x1.dcbf68p-128))
(assert_return (invoke "f32.div" (f32.const 4) (f32.const 3)) (f32.const 0x1.555556p+0))
;; Test for a historic hardware bug.
;; https://en.wikipedia.org/wiki/Pentium_FDIV_bug
(assert_return (invoke "f32.div" (f32.const 4195835) (f32.const 3145727)) (f32.const 0x1.557542p+0))
(assert_return (invoke "f64.div" (f64.const 1.123456789) (f64.const 100)) (f64.const 0.01123456789))
(assert_return (invoke "f64.div" (f64.const 8391667.0) (f64.const 12582905.0)) (f64.const 0x1.55753f1d9ba27p-1))
(assert_return (invoke "f64.div" (f64.const 65536.0) (f64.const 0x1p-37)) (f64.const 0x1p+53))
(assert_return (invoke "f64.div" (f64.const 4) (f64.const 3)) (f64.const 0x1.5555555555555p+0))
;; Test for a historic hardware bug.
;; https://en.wikipedia.org/wiki/Pentium_FDIV_bug
(assert_return (invoke "f64.div" (f64.const 4195835) (f64.const 3145727)) (f64.const 0x1.557541c7c6b43p+0))
;; Computations that round differently in round-upward mode.
(assert_return (invoke "f32.div" (f32.const 0x1.6a6c5ap-48) (f32.const 0x1.fa0b7p+127)) (f32.const 0x0p+0))
(assert_return (invoke "f32.div" (f32.const 0x1.616fb2p-87) (f32.const 0x1.332172p+68)) (f32.const 0x0p+0))
(assert_return (invoke "f32.div" (f32.const -0x1.96e778p+16) (f32.const 0x1.eb0c56p-80)) (f32.const -0x1.a8440ap+95))
(assert_return (invoke "f32.div" (f32.const -0x1.e2624p-76) (f32.const -0x1.ed236ep-122)) (f32.const 0x1.f4d584p+45))
(assert_return (invoke "f32.div" (f32.const -0x1.e2374ep+41) (f32.const 0x1.71fcdcp-80)) (f32.const -0x1.4da706p+121))
(assert_return (invoke "f64.div" (f64.const 0x1.163c09d0c38c1p+147) (f64.const 0x1.e04cc737348e6p+223)) (f64.const 0x1.289921caeed23p-77))
(assert_return (invoke "f64.div" (f64.const 0x1.d6867e741e0a9p-626) (f64.const 0x1.335eb19a9aae4p-972)) (f64.const 0x1.87e342d11f519p+346))
(assert_return (invoke "f64.div" (f64.const -0x1.d5edf648aeb98p+298) (f64.const 0x1.0dda15b079355p+640)) (f64.const -0x1.bdceaf9734b5cp-342))
(assert_return (invoke "f64.div" (f64.const -0x1.b683e3934aedap+691) (f64.const 0x1.c364e1df00dffp+246)) (f64.const -0x1.f16456e7afe3bp+444))
(assert_return (invoke "f64.div" (f64.const -0x1.44ca7539cc851p+540) (f64.const 0x1.58501bccc58fep+453)) (f64.const -0x1.e2f8657e0924ep+86))
;; Computations that round differently in round-downward mode.
(assert_return (invoke "f32.div" (f32.const -0x1.c2c54ap+69) (f32.const -0x1.00d142p-86)) (f32.const infinity))
(assert_return (invoke "f32.div" (f32.const 0x1.e35abep-46) (f32.const 0x1.c69dfp+44)) (f32.const 0x1.102eb4p-90))
(assert_return (invoke "f32.div" (f32.const 0x1.45ff2ap+0) (f32.const -0x1.1e8754p+89)) (f32.const -0x1.23434ep-89))
(assert_return (invoke "f32.div" (f32.const 0x1.8db18ap-51) (f32.const 0x1.47c678p-128)) (f32.const 0x1.369b96p+77))
(assert_return (invoke "f32.div" (f32.const 0x1.78599p+90) (f32.const 0x1.534144p+87)) (f32.const 0x1.1bfddcp+3))
(assert_return (invoke "f64.div" (f64.const 0x0.f331c4f47eb51p-1022) (f64.const -0x1.c7ff45bf6f03ap+362)) (f64.const -0x0p+0))
(assert_return (invoke "f64.div" (f64.const -0x1.0fc8707b9d19cp-987) (f64.const 0x1.77524d5f4a563p-536)) (f64.const -0x1.72c1a937d231p-452))
(assert_return (invoke "f64.div" (f64.const -0x1.edb3aa64bb338p-403) (f64.const -0x1.1c7c164320e4p+45)) (f64.const 0x1.bc44cc1c5ae63p-448))
(assert_return (invoke "f64.div" (f64.const -0x1.6534b34e8686bp+80) (f64.const 0x1.c34a7fc59e3c3p-791)) (f64.const -0x1.95421bf291b66p+870))
(assert_return (invoke "f64.div" (f64.const -0x1.91f58d7ed1237p+236) (f64.const -0x1.f190d808383c8p+55)) (f64.const 0x1.9d9eb0836f906p+180))
;; Computations that round differently in round-toward-zero mode.
(assert_return (invoke "f32.div" (f32.const 0x1.64b2a4p+26) (f32.const 0x1.e95752p-119)) (f32.const infinity))
(assert_return (invoke "f32.div" (f32.const -0x1.53c9b6p+77) (f32.const 0x1.d689ap+27)) (f32.const -0x1.71baa4p+49))
(assert_return (invoke "f32.div" (f32.const 0x1.664a8ap+38) (f32.const -0x1.59dba2p+96)) (f32.const -0x1.0933f4p-58))
(assert_return (invoke "f32.div" (f32.const -0x1.99e0fap+111) (f32.const -0x1.c2b5a8p+9)) (f32.const 0x1.d19de6p+101))
(assert_return (invoke "f32.div" (f32.const -0x1.5a815ap+92) (f32.const -0x1.b5820ap+13)) (f32.const 0x1.9580b8p+78))
(assert_return (invoke "f64.div" (f64.const -0x1.81fd1e2af7bebp-655) (f64.const 0x1.edefc4eae536cp-691)) (f64.const -0x1.901abdd91b661p+35))
(assert_return (invoke "f64.div" (f64.const -0x1.47cf932953c43p+782) (f64.const -0x1.bc40496b1f2a1p-553)) (f64.const infinity))
(assert_return (invoke "f64.div" (f64.const -0x1.2bd2e8fbdcad7p-746) (f64.const 0x1.b115674cc476ep-65)) (f64.const -0x1.62752bf19fa81p-682))
(assert_return (invoke "f64.div" (f64.const -0x1.f923e3fea9efep+317) (f64.const -0x1.8044c74d27a39p-588)) (f64.const 0x1.5086518cc7186p+905))
(assert_return (invoke "f64.div" (f64.const 0x1.516ed2051d6bbp+181) (f64.const -0x1.c9f455eb9c2eep+214)) (f64.const -0x1.79414d67f2889p-34))
;; Computations that round differently on x87.
(assert_return (invoke "f64.div" (f64.const -0x1.9c52726aed366p+585) (f64.const -0x1.7d0568c75660fp+195)) (f64.const 0x1.1507ca2a65f23p+390))
(assert_return (invoke "f64.div" (f64.const -0x1.522672f461667p+546) (f64.const -0x1.36d36572c9f71p+330)) (f64.const 0x1.1681369370619p+216))
(assert_return (invoke "f64.div" (f64.const 0x1.01051b4e8cd61p+185) (f64.const -0x1.2cbb5ca3d33ebp+965)) (f64.const -0x1.b59471598a2f3p-781))
(assert_return (invoke "f64.div" (f64.const 0x1.5f93bb80fc2cbp+217) (f64.const 0x1.7e051aae9f0edp+427)) (f64.const 0x1.d732fa926ba4fp-211))
(assert_return (invoke "f64.div" (f64.const -0x1.e251d762163ccp+825) (f64.const 0x1.3ee63581e1796p+349)) (f64.const -0x1.8330077d90a07p+476))
;; Computations that round differently on x87 in double-precision mode.
(assert_return (invoke "f64.div" (f64.const 0x1.dcbf69f10006dp+0) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x0.772fda7c4001bp-1022))
(assert_return (invoke "f64.div" (f64.const 0x1.e14169442fbcap-1011) (f64.const 0x1.505451d62ff7dp+12)) (f64.const 0x0.b727e85f38b39p-1022))
(assert_return (invoke "f64.div" (f64.const -0x1.d3ebe726ec964p-144) (f64.const -0x1.4a7bfc0b83608p+880)) (f64.const 0x0.5a9d8c50cbf87p-1022))
(assert_return (invoke "f64.div" (f64.const -0x1.6c3def770aee1p-393) (f64.const -0x1.8b84724347598p+631)) (f64.const 0x0.3af0707fcd0c7p-1022))
(assert_return (invoke "f64.div" (f64.const 0x1.16abda1bb3cb3p-856) (f64.const 0x1.6c9c7198eb1e6p+166)) (f64.const 0x0.c3a8fd6741649p-1022))
(assert_return (invoke "f64.div" (f64.const 0x1.7057d6ab553cap-1005) (f64.const -0x1.2abf1e98660ebp+23)) (f64.const -0x0.04ee8d8ec01cdp-1022))
;; Computations that round differently when div is mul by reciprocal.
(assert_return (invoke "f64.div" (f64.const 0x1.b2348a1c81899p+61) (f64.const -0x1.4a58aad903dd3p-861)) (f64.const -0x1.507c1e2a41b35p+922))
(assert_return (invoke "f64.div" (f64.const 0x1.23fa5137a918ap-130) (f64.const -0x1.7268db1951263p-521)) (f64.const -0x1.93965e0d896bep+390))
(assert_return (invoke "f64.div" (f64.const 0x1.dcb3915d82deep+669) (f64.const 0x1.50caaa1dc6b19p+638)) (f64.const 0x1.6a58ec814b09dp+31))
(assert_return (invoke "f64.div" (f64.const -0x1.046e378c0cc46p+182) (f64.const 0x1.ac925009a922bp+773)) (f64.const -0x1.3720aa94dab18p-592))
(assert_return (invoke "f64.div" (f64.const -0x1.8945fd69d8e11p-871) (f64.const -0x1.0a37870af809ap-646)) (f64.const 0x1.7a2e286c62382p-225))
;; Computations that round differently when computed via f32.
(assert_return (invoke "f64.div" (f64.const 0x1.82002af0ea1f3p-57) (f64.const 0x1.d0a9b0c2fa339p+0)) (f64.const 0x1.a952fbd1fc17cp-58))
(assert_return (invoke "f64.div" (f64.const 0x1.1e12b515db471p-102) (f64.const -0x1.41fc3c94fba5p-42)) (f64.const -0x1.c6e50cccb7cb6p-61))
(assert_return (invoke "f64.div" (f64.const 0x1.aba5adcd6f583p-41) (f64.const 0x1.17dfac639ce0fp-112)) (f64.const 0x1.872b0a008c326p+71))
(assert_return (invoke "f64.div" (f64.const 0x1.cf82510d0ae6bp+89) (f64.const 0x1.0207d86498053p+97)) (f64.const 0x1.cbdc804e2cf14p-8))
(assert_return (invoke "f64.div" (f64.const 0x1.4c82cbb508e21p-11) (f64.const -0x1.6b57208c2d5d5p+52)) (f64.const -0x1.d48e8b369129ap-64))
;; Division involving the maximum subnormal value and the minimum normal value.
(assert_return (invoke "f32.div" (f32.const 0x1p-126) (f32.const 0x1.fffffcp-127)) (f32.const 0x1.000002p+0))
(assert_return (invoke "f32.div" (f32.const 0x1.fffffcp-127) (f32.const 0x1p-126)) (f32.const 0x1.fffffcp-1))
(assert_return (invoke "f64.div" (f64.const 0x1p-1022) (f64.const 0x0.fffffffffffffp-1022)) (f64.const 0x1.0000000000001p+0))
(assert_return (invoke "f64.div" (f64.const 0x0.fffffffffffffp-1022) (f64.const 0x1p-1022)) (f64.const 0x1.ffffffffffffep-1))
;; Test the least value with a positive quotient with the maximum value.
(assert_return (invoke "f32.div" (f32.const 0x1.fffffep-23) (f32.const 0x1.fffffep+127)) (f32.const 0x0p+0))
(assert_return (invoke "f32.div" (f32.const 0x1p-22) (f32.const 0x1.fffffep+127)) (f32.const 0x1p-149))
(assert_return (invoke "f64.div" (f64.const 0x1.fffffffffffffp-52) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x0p+0))
(assert_return (invoke "f64.div" (f64.const 0x1p-51) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x0.0000000000001p-1022))
;; Test the least value with a finite reciprocal.
(assert_return (invoke "f32.div" (f32.const 1.0) (f32.const 0x1p-128)) (f32.const infinity))
(assert_return (invoke "f32.div" (f32.const 1.0) (f32.const 0x1.000008p-128)) (f32.const 0x1.fffffp+127))
(assert_return (invoke "f64.div" (f64.const 1.0) (f64.const 0x0.4p-1022)) (f64.const infinity))
(assert_return (invoke "f64.div" (f64.const 1.0) (f64.const 0x0.4000000000001p-1022)) (f64.const 0x1.ffffffffffff8p+1023))
;; Test for bugs found in an early RISC-V implementation.
;; https://github.com/riscv/riscv-tests/pull/8
(assert_return (invoke "f32.sqrt" (f32.const 0x1.56p+7)) (f32.const 0x1.a2744cp+3))
(assert_return (invoke "f32.sqrt" (f32.const 0x1.594dfcp-23)) (f32.const 0x1.a4789cp-12))
;; Computations that round differently on x87.
(assert_return (invoke "f64.sqrt" (f64.const 0x1.0263fcc94f259p-164)) (f64.const 0x1.0131485de579fp-82))
(assert_return (invoke "f64.sqrt" (f64.const 0x1.352dfa278c43dp+338)) (f64.const 0x1.195607dac5417p+169))
(assert_return (invoke "f64.sqrt" (f64.const 0x1.b15daa23924fap+402)) (f64.const 0x1.4d143db561493p+201))
(assert_return (invoke "f64.sqrt" (f64.const 0x1.518c8e68cb753p-37)) (f64.const 0x1.9fb8ef1ad5bfdp-19))
(assert_return (invoke "f64.sqrt" (f64.const 0x1.86d8b6518078ep-370)) (f64.const 0x1.3c5142a48fcadp-185))
;; Test another sqrt case on x87.
;; https://gcc.gnu.org/bugzilla/show_bug.cgi?id=52593
(assert_return (invoke "f64.sqrt" (f64.const 0x1.fffffffffffffp-1)) (f64.const 0x1.fffffffffffffp-1))
;; Test for bugs found in an early RISC-V implementation.
;; https://github.com/riscv/riscv-tests/pull/8
(assert_return (invoke "f64.sqrt" (f64.const 0x1.56p+7)) (f64.const 0x1.a2744ce9674f5p+3))
(assert_return (invoke "f64.sqrt" (f64.const 0x1.594dfc70aa105p-23)) (f64.const 0x1.a4789c0e37f99p-12))
;; Computations that round differently in round-upward mode.
(assert_return (invoke "f32.sqrt" (f32.const 0x1.098064p-3)) (f32.const 0x1.70b23p-2))
(assert_return (invoke "f32.sqrt" (f32.const 0x1.d9befp+100)) (f32.const 0x1.5c4052p+50))
(assert_return (invoke "f32.sqrt" (f32.const 0x1.42b5b6p-4)) (f32.const 0x1.1f6d0ep-2))
(assert_return (invoke "f32.sqrt" (f32.const 0x1.3684dp-71)) (f32.const 0x1.8ebae2p-36))
(assert_return (invoke "f32.sqrt" (f32.const 0x1.d8bc4ep-11)) (f32.const 0x1.ebf9eap-6))
(assert_return (invoke "f64.sqrt" (f64.const 0x1.5c39f220d5704p-924)) (f64.const 0x1.2a92bc24ceae9p-462))
(assert_return (invoke "f64.sqrt" (f64.const 0x1.53521a635745cp+727)) (f64.const 0x1.a0cfdc4ef8ff1p+363))
(assert_return (invoke "f64.sqrt" (f64.const 0x1.dfd5bbc9f4678p+385)) (f64.const 0x1.efa817117c94cp+192))
(assert_return (invoke "f64.sqrt" (f64.const 0x1.33f9640811cd4p+105)) (f64.const 0x1.8d17c9243baa3p+52))
(assert_return (invoke "f64.sqrt" (f64.const 0x1.6c0ef0267ff45p+999)) (f64.const 0x1.afbcfae3f2b4p+499))
;; Computations that round differently in round-downward mode.
(assert_return (invoke "f32.sqrt" (f32.const 0x1.26a62ep+27)) (f32.const 0x1.84685p+13))
(assert_return (invoke "f32.sqrt" (f32.const 0x1.166002p-113)) (f32.const 0x1.798762p-57))
(assert_return (invoke "f32.sqrt" (f32.const 0x1.3dfb5p-15)) (f32.const 0x1.937e38p-8))
(assert_return (invoke "f32.sqrt" (f32.const 0x1.30eb2cp-120)) (f32.const 0x1.176406p-60))
(assert_return (invoke "f32.sqrt" (f32.const 0x1.cb705cp-123)) (f32.const 0x1.e5020ap-62))
(assert_return (invoke "f64.sqrt" (f64.const 0x1.edae8aea0543p+695)) (f64.const 0x1.f6c1ea4fc8dd2p+347))
(assert_return (invoke "f64.sqrt" (f64.const 0x1.f7ee4bda5c9c3p-763)) (f64.const 0x1.fbf30bdaf11c5p-382))
(assert_return (invoke "f64.sqrt" (f64.const 0x1.a48f348266ad1p-30)) (f64.const 0x1.481ee7540baf7p-15))
(assert_return (invoke "f64.sqrt" (f64.const 0x1.feb5a1ce3ed9cp-242)) (f64.const 0x1.6995060c20d46p-121))
(assert_return (invoke "f64.sqrt" (f64.const 0x1.957d9796e3834p+930)) (f64.const 0x1.42305213157bap+465))
;; Computations that round differently in round-toward-zero mode.
(assert_return (invoke "f32.sqrt" (f32.const 0x1.65787cp+118)) (f32.const 0x1.2e82a4p+59))
(assert_return (invoke "f32.sqrt" (f32.const 0x1.736044p+15)) (f32.const 0x1.b40e4p+7))
(assert_return (invoke "f32.sqrt" (f32.const 0x1.a00edp-1)) (f32.const 0x1.cd8aecp-1))
(assert_return (invoke "f32.sqrt" (f32.const 0x1.7a4c8p-87)) (f32.const 0x1.b819e4p-44))
(assert_return (invoke "f32.sqrt" (f32.const 0x1.5d24d4p-94)) (f32.const 0x1.2af75ep-47))
(assert_return (invoke "f64.sqrt" (f64.const 0x1.a008948ead274p+738)) (f64.const 0x1.4659b37c39b19p+369))
(assert_return (invoke "f64.sqrt" (f64.const 0x1.70f6199ed21f5p-381)) (f64.const 0x1.b2a2bddf3300dp-191))
(assert_return (invoke "f64.sqrt" (f64.const 0x1.35c1d49f2a352p+965)) (f64.const 0x1.8e3d9f01a9716p+482))
(assert_return (invoke "f64.sqrt" (f64.const 0x1.3fbdcfb2b2a15p-45)) (f64.const 0x1.949ba4feca42ap-23))
(assert_return (invoke "f64.sqrt" (f64.const 0x1.c201b94757145p-492)) (f64.const 0x1.5369ee6bf2967p-246))
;; Computations that round differently when computed via f32.
(assert_return_nan (invoke "f64.sqrt" (f64.const -0x1.360e8d0032adp-963)))
(assert_return (invoke "f64.sqrt" (f64.const 0x1.d9a6f5eef0503p+103)) (f64.const 0x1.ec73f56c166f6p+51))
(assert_return (invoke "f64.sqrt" (f64.const 0x1.aa051a5c4ec27p-760)) (f64.const 0x1.4a3e771ff5149p-380))
(assert_return (invoke "f64.sqrt" (f64.const 0x1.e5522a741babep-276)) (f64.const 0x1.607ae2b6feb7dp-138))
(assert_return (invoke "f64.sqrt" (f64.const 0x1.4832badc0c061p+567)) (f64.const 0x1.99ec7934139b2p+283))
;; Test that the bitwise floating point operators are bitwise on NaN.
(assert_return (invoke "f32.abs" (f32.const nan)) (f32.const nan))
(assert_return (invoke "f32.abs" (f32.const -nan)) (f32.const nan))
(assert_return (invoke "f32.abs" (f32.const nan:0x0f1e2)) (f32.const nan:0x0f1e2))
(assert_return (invoke "f32.abs" (f32.const -nan:0x0f1e2)) (f32.const nan:0x0f1e2))
(assert_return (invoke "f64.abs" (f64.const nan)) (f64.const nan))
(assert_return (invoke "f64.abs" (f64.const -nan)) (f64.const nan))
(assert_return (invoke "f64.abs" (f64.const nan:0x0f1e27a6b)) (f64.const nan:0x0f1e27a6b))
(assert_return (invoke "f64.abs" (f64.const -nan:0x0f1e27a6b)) (f64.const nan:0x0f1e27a6b))
(assert_return (invoke "f32.neg" (f32.const nan)) (f32.const -nan))
(assert_return (invoke "f32.neg" (f32.const -nan)) (f32.const nan))
(assert_return (invoke "f32.neg" (f32.const nan:0x0f1e2)) (f32.const -nan:0x0f1e2))
(assert_return (invoke "f32.neg" (f32.const -nan:0x0f1e2)) (f32.const nan:0x0f1e2))
(assert_return (invoke "f64.neg" (f64.const nan)) (f64.const -nan))
(assert_return (invoke "f64.neg" (f64.const -nan)) (f64.const nan))
(assert_return (invoke "f64.neg" (f64.const nan:0x0f1e27a6b)) (f64.const -nan:0x0f1e27a6b))
(assert_return (invoke "f64.neg" (f64.const -nan:0x0f1e27a6b)) (f64.const nan:0x0f1e27a6b))
(assert_return (invoke "f32.copysign" (f32.const nan) (f32.const nan)) (f32.const nan))
(assert_return (invoke "f32.copysign" (f32.const nan) (f32.const -nan)) (f32.const -nan))
(assert_return (invoke "f32.copysign" (f32.const -nan) (f32.const nan)) (f32.const nan))
(assert_return (invoke "f32.copysign" (f32.const -nan) (f32.const -nan)) (f32.const -nan))
(assert_return (invoke "f32.copysign" (f32.const nan:0x0f1e2) (f32.const nan)) (f32.const nan:0x0f1e2))
(assert_return (invoke "f32.copysign" (f32.const nan:0x0f1e2) (f32.const -nan)) (f32.const -nan:0x0f1e2))
(assert_return (invoke "f32.copysign" (f32.const -nan:0x0f1e2) (f32.const nan)) (f32.const nan:0x0f1e2))
(assert_return (invoke "f32.copysign" (f32.const -nan:0x0f1e2) (f32.const -nan)) (f32.const -nan:0x0f1e2))
(assert_return (invoke "f64.copysign" (f64.const nan) (f64.const nan)) (f64.const nan))
(assert_return (invoke "f64.copysign" (f64.const nan) (f64.const -nan)) (f64.const -nan))
(assert_return (invoke "f64.copysign" (f64.const -nan) (f64.const nan)) (f64.const nan))
(assert_return (invoke "f64.copysign" (f64.const -nan) (f64.const -nan)) (f64.const -nan))
(assert_return (invoke "f64.copysign" (f64.const nan:0x0f1e27a6b) (f64.const nan)) (f64.const nan:0x0f1e27a6b))
(assert_return (invoke "f64.copysign" (f64.const nan:0x0f1e27a6b) (f64.const -nan)) (f64.const -nan:0x0f1e27a6b))
(assert_return (invoke "f64.copysign" (f64.const -nan:0x0f1e27a6b) (f64.const nan)) (f64.const nan:0x0f1e27a6b))
(assert_return (invoke "f64.copysign" (f64.const -nan:0x0f1e27a6b) (f64.const -nan)) (f64.const -nan:0x0f1e27a6b))
;; Test that ceil isn't implemented as adding 0.5 and rounding to nearest.
(assert_return (invoke "f32.ceil" (f32.const 0x1.fffffep-1)) (f32.const 1.0))
(assert_return (invoke "f32.ceil" (f32.const 0x1p-126)) (f32.const 1.0))
;; Test that ceil isn't implemented as adding 0.5 and rounding to nearest.
(assert_return (invoke "f64.ceil" (f64.const 0x1.fffffffffffffp-1)) (f64.const 1.0))
(assert_return (invoke "f64.ceil" (f64.const 0x1p-1022)) (f64.const 1.0))
;; Test that floor isn't implemented as subtracting 0.5 and rounding to nearest.
(assert_return (invoke "f32.floor" (f32.const -0x1.fffffep-1)) (f32.const -1.0))
(assert_return (invoke "f32.floor" (f32.const -0x1p-126)) (f32.const -1.0))
;; Test that floor isn't implemented as subtracting 0.5 and rounding to nearest.
(assert_return (invoke "f64.floor" (f64.const -0x1.fffffffffffffp-1)) (f64.const -1.0))
(assert_return (invoke "f64.floor" (f64.const -0x1p-1022)) (f64.const -1.0))
;; Test that nearest isn't implemented naively.
;; http://blog.frama-c.com/index.php?post/2013/05/02/nearbyintf1
;; http://blog.frama-c.com/index.php?post/2013/05/04/nearbyintf3
(assert_return (invoke "f32.nearest" (f32.const 0x1.000002p+23)) (f32.const 0x1.000002p+23))
(assert_return (invoke "f32.nearest" (f32.const 0x1.000004p+23)) (f32.const 0x1.000004p+23))
(assert_return (invoke "f32.nearest" (f32.const 0x1.fffffep-2)) (f32.const 0.0))
(assert_return (invoke "f64.nearest" (f64.const 0x1.0000000000001p+52)) (f64.const 0x1.0000000000001p+52))
(assert_return (invoke "f64.nearest" (f64.const 0x1.0000000000002p+52)) (f64.const 0x1.0000000000002p+52))
(assert_return (invoke "f64.nearest" (f64.const 0x1.fffffffffffffp-2)) (f64.const 0.0))
;; Nearest should not round halfway cases away from zero (as C's round(3) does)
;; or up (as JS's Math.round does).
(assert_return (invoke "f32.nearest" (f32.const 4.5)) (f32.const 4.0))
(assert_return (invoke "f32.nearest" (f32.const -4.5)) (f32.const -4.0))
(assert_return (invoke "f32.nearest" (f32.const -3.5)) (f32.const -4.0))
(assert_return (invoke "f64.nearest" (f64.const 4.5)) (f64.const 4.0))
(assert_return (invoke "f64.nearest" (f64.const -4.5)) (f64.const -4.0))
(assert_return (invoke "f64.nearest" (f64.const -3.5)) (f64.const -4.0))
;; Test that min and max behave properly with signaling NaNs.
(assert_return (invoke "f32.min" (f32.const 0.0) (f32.const nan:0x200000)) (f32.const nan:0x600000))
(assert_return (invoke "f32.min" (f32.const nan:0x200000) (f32.const 0.0)) (f32.const nan:0x600000))
(assert_return (invoke "f32.max" (f32.const 0.0) (f32.const nan:0x200000)) (f32.const nan:0x600000))
(assert_return (invoke "f32.max" (f32.const nan:0x200000) (f32.const 0.0)) (f32.const nan:0x600000))
(assert_return (invoke "f64.min" (f64.const 0.0) (f64.const nan:0x4000000000000)) (f64.const nan:0xc000000000000))
(assert_return (invoke "f64.min" (f64.const nan:0x4000000000000) (f64.const 0.0)) (f64.const nan:0xc000000000000))
(assert_return (invoke "f64.max" (f64.const 0.0) (f64.const nan:0x4000000000000)) (f64.const nan:0xc000000000000))
(assert_return (invoke "f64.max" (f64.const nan:0x4000000000000) (f64.const 0.0)) (f64.const nan:0xc000000000000))

23
js/src/jit-test/tests/wasm/spec/forward.wast Normal file
View File

@ -0,0 +1,23 @@
(module
(export "even" $even)
(export "odd" $odd)
(func $even (param $n i32) (result i32)
(if (i32.eq (get_local $n) (i32.const 0))
(i32.const 1)
(call $odd (i32.sub (get_local $n) (i32.const 1)))
)
)
(func $odd (param $n i32) (result i32)
(if (i32.eq (get_local $n) (i32.const 0))
(i32.const 0)
(call $even (i32.sub (get_local $n) (i32.const 1)))
)
)
)
(assert_return (invoke "even" (i32.const 13)) (i32.const 0))
(assert_return (invoke "even" (i32.const 20)) (i32.const 1))
(assert_return (invoke "odd" (i32.const 13)) (i32.const 1))
(assert_return (invoke "odd" (i32.const 20)) (i32.const 0))

94
js/src/jit-test/tests/wasm/spec/func_ptrs.wast Normal file
View File

@ -0,0 +1,94 @@
(module
(type (func)) ;; 0: void -> void
(type $S (func)) ;; 1: void -> void
(type (func (param))) ;; 2: void -> void
(type (func (result i32))) ;; 3: void -> i32
(type (func (param) (result i32))) ;; 4: void -> i32
(type $T (func (param i32) (result i32))) ;; 5: i32 -> i32
(type $U (func (param i32))) ;; 6: i32 -> void
(func (type 0))
(func (type $S))
(func $one (type 4) (i32.const 13))
(export "one" $one)
(func $two (type $T) (i32.add (get_local 0) (i32.const 1)))
(export "two" $two)
;; Both signature and parameters are allowed (and required to match)
;; since this allows the naming of parameters.
(func $three (type $T) (param $a i32) (result i32) (i32.sub (get_local 0) (i32.const 2)))
(export "three" $three)
(import $print "spectest" "print" (type 6))
(func $four (type $U) (call_import $print (get_local 0)))
(export "four" $four)
)
(assert_return (invoke "one") (i32.const 13))
(assert_return (invoke "two" (i32.const 13)) (i32.const 14))
(assert_return (invoke "three" (i32.const 13)) (i32.const 11))
(invoke "four" (i32.const 83))
(assert_invalid (module (func (type 42))) "unknown function type 42")
(assert_invalid (module (import "spectest" "print" (type 43))) "unknown function type 43")
(module
(type $T (func (param) (result i32)))
(type $U (func (param) (result i32)))
(table $t1 $t2 $t3 $u1 $u2 $t1 $t3)
(func $t1 (type $T) (i32.const 1))
(func $t2 (type $T) (i32.const 2))
(func $t3 (type $T) (i32.const 3))
(func $u1 (type $U) (i32.const 4))
(func $u2 (type $U) (i32.const 5))
(func $callt (param $i i32) (result i32)
(call_indirect $T (get_local $i))
)
(export "callt" $callt)
(func $callu (param $i i32) (result i32)
(call_indirect $U (get_local $i))
)
(export "callu" $callu)
)
(assert_return (invoke "callt" (i32.const 0)) (i32.const 1))
(assert_return (invoke "callt" (i32.const 1)) (i32.const 2))
(assert_return (invoke "callt" (i32.const 2)) (i32.const 3))
(assert_trap (invoke "callt" (i32.const 3)) "indirect call signature mismatch")
(assert_trap (invoke "callt" (i32.const 4)) "indirect call signature mismatch")
(assert_return (invoke "callt" (i32.const 5)) (i32.const 1))
(assert_return (invoke "callt" (i32.const 6)) (i32.const 3))
(assert_trap (invoke "callt" (i32.const 7)) "undefined table index 7")
(assert_trap (invoke "callt" (i32.const 100)) "undefined table index 100")
(assert_trap (invoke "callt" (i32.const -1)) "undefined table index -1")
(assert_trap (invoke "callu" (i32.const 0)) "indirect call signature mismatch")
(assert_trap (invoke "callu" (i32.const 1)) "indirect call signature mismatch")
(assert_trap (invoke "callu" (i32.const 2)) "indirect call signature mismatch")
(assert_return (invoke "callu" (i32.const 3)) (i32.const 4))
(assert_return (invoke "callu" (i32.const 4)) (i32.const 5))
(assert_trap (invoke "callu" (i32.const 5)) "indirect call signature mismatch")
(assert_trap (invoke "callu" (i32.const 6)) "indirect call signature mismatch")
(assert_trap (invoke "callu" (i32.const 7)) "undefined table index 7")
(assert_trap (invoke "callu" (i32.const -1)) "undefined table index -1")
(module
(type $T (func (result i32)))
(table 0 1)
(import $print_i32 "spectest" "print" (param i32))
(func $t1 (type $T) (i32.const 1))
(func $t2 (type $T) (i32.const 2))
(func $callt (param $i i32) (result i32)
(call_indirect $T (get_local $i)))
(export "callt" $callt)
)
(assert_return (invoke "callt" (i32.const 0)) (i32.const 1))
(assert_return (invoke "callt" (i32.const 1)) (i32.const 2))

44
js/src/jit-test/tests/wasm/spec/functions.wast Normal file
View File

@ -0,0 +1,44 @@
(module
(func $empty)
(export "empty" $empty)
(func $result-nop (nop))
(export "result-nop" $result-nop)
(func $result-drop (i32.const 1))
(export "result-drop" $result-drop)
(func $result-block-nop (block (i32.const 1) (nop)))
(export "result-block-nop" $result-block-nop)
(func $result-block-drop (block (nop) (i32.const 1)))
(export "result-block-drop" $result-block-drop)
(func $return (return))
(export "return" $return)
(func $return-nop (return (nop)))
(export "return-nop" $return-nop)
(func $return-drop (return (i32.const 1)))
(export "return-drop" $return-drop)
(func $return-block-nop (return (block (i32.const 1) (nop))))
(export "return-block-nop" $return-block-nop)
(func $return-block-drop (return (block (nop) (i32.const 1))))
(export "return-block-drop" $return-block-drop)
)
(assert_return (invoke "empty"))
(assert_return (invoke "result-nop"))
(assert_return (invoke "result-drop"))
(assert_return (invoke "result-block-nop"))
(assert_return (invoke "result-block-drop"))
(assert_return (invoke "return"))
(assert_return (invoke "return-nop"))
(assert_return (invoke "return-drop"))
(assert_return (invoke "return-block-nop"))
(assert_return (invoke "return-block-drop"))

418
js/src/jit-test/tests/wasm/spec/i32.wast Normal file
View File

@ -0,0 +1,418 @@
;; i32 operations
(module
(func $add (param $x i32) (param $y i32) (result i32) (i32.add (get_local $x) (get_local $y)))
(func $sub (param $x i32) (param $y i32) (result i32) (i32.sub (get_local $x) (get_local $y)))
(func $mul (param $x i32) (param $y i32) (result i32) (i32.mul (get_local $x) (get_local $y)))
(func $div_s (param $x i32) (param $y i32) (result i32) (i32.div_s (get_local $x) (get_local $y)))
(func $div_u (param $x i32) (param $y i32) (result i32) (i32.div_u (get_local $x) (get_local $y)))
(func $rem_s (param $x i32) (param $y i32) (result i32) (i32.rem_s (get_local $x) (get_local $y)))
(func $rem_u (param $x i32) (param $y i32) (result i32) (i32.rem_u (get_local $x) (get_local $y)))
(func $and (param $x i32) (param $y i32) (result i32) (i32.and (get_local $x) (get_local $y)))
(func $or (param $x i32) (param $y i32) (result i32) (i32.or (get_local $x) (get_local $y)))
(func $xor (param $x i32) (param $y i32) (result i32) (i32.xor (get_local $x) (get_local $y)))
(func $shl (param $x i32) (param $y i32) (result i32) (i32.shl (get_local $x) (get_local $y)))
(func $shr_s (param $x i32) (param $y i32) (result i32) (i32.shr_s (get_local $x) (get_local $y)))
(func $shr_u (param $x i32) (param $y i32) (result i32) (i32.shr_u (get_local $x) (get_local $y)))
(func $rotl (param $x i32) (param $y i32) (result i32) (i32.rotl (get_local $x) (get_local $y)))
(func $rotr (param $x i32) (param $y i32) (result i32) (i32.rotr (get_local $x) (get_local $y)))
(func $clz (param $x i32) (result i32) (i32.clz (get_local $x)))
(func $ctz (param $x i32) (result i32) (i32.ctz (get_local $x)))
(func $popcnt (param $x i32) (result i32) (i32.popcnt (get_local $x)))
(func $eqz (param $x i32) (result i32) (i32.eqz (get_local $x)))
(func $eq (param $x i32) (param $y i32) (result i32) (i32.eq (get_local $x) (get_local $y)))
(func $ne (param $x i32) (param $y i32) (result i32) (i32.ne (get_local $x) (get_local $y)))
(func $lt_s (param $x i32) (param $y i32) (result i32) (i32.lt_s (get_local $x) (get_local $y)))
(func $lt_u (param $x i32) (param $y i32) (result i32) (i32.lt_u (get_local $x) (get_local $y)))
(func $le_s (param $x i32) (param $y i32) (result i32) (i32.le_s (get_local $x) (get_local $y)))
(func $le_u (param $x i32) (param $y i32) (result i32) (i32.le_u (get_local $x) (get_local $y)))
(func $gt_s (param $x i32) (param $y i32) (result i32) (i32.gt_s (get_local $x) (get_local $y)))
(func $gt_u (param $x i32) (param $y i32) (result i32) (i32.gt_u (get_local $x) (get_local $y)))
(func $ge_s (param $x i32) (param $y i32) (result i32) (i32.ge_s (get_local $x) (get_local $y)))
(func $ge_u (param $x i32) (param $y i32) (result i32) (i32.ge_u (get_local $x) (get_local $y)))
(export "add" $add)
(export "sub" $sub)
(export "mul" $mul)
(export "div_s" $div_s)
(export "div_u" $div_u)
(export "rem_s" $rem_s)
(export "rem_u" $rem_u)
(export "and" $and)
(export "or" $or)
(export "xor" $xor)
(export "shl" $shl)
(export "shr_s" $shr_s)
(export "shr_u" $shr_u)
(export "rotl" $rotl)
(export "rotr" $rotr)
(export "clz" $clz)
(export "ctz" $ctz)
(export "popcnt" $popcnt)
(export "eqz" $eqz)
(export "eq" $eq)
(export "ne" $ne)
(export "lt_s" $lt_s)
(export "lt_u" $lt_u)
(export "le_s" $le_s)
(export "le_u" $le_u)
(export "gt_s" $gt_s)
(export "gt_u" $gt_u)
(export "ge_s" $ge_s)
(export "ge_u" $ge_u)
)
(assert_return (invoke "add" (i32.const 1) (i32.const 1)) (i32.const 2))
(assert_return (invoke "add" (i32.const 1) (i32.const 0)) (i32.const 1))
(assert_return (invoke "add" (i32.const -1) (i32.const -1)) (i32.const -2))
(assert_return (invoke "add" (i32.const -1) (i32.const 1)) (i32.const 0))
(assert_return (invoke "add" (i32.const 0x7fffffff) (i32.const 1)) (i32.const 0x80000000))
(assert_return (invoke "add" (i32.const 0x80000000) (i32.const -1)) (i32.const 0x7fffffff))
(assert_return (invoke "add" (i32.const 0x80000000) (i32.const 0x80000000)) (i32.const 0))
(assert_return (invoke "add" (i32.const 0x3fffffff) (i32.const 1)) (i32.const 0x40000000))
(assert_return (invoke "sub" (i32.const 1) (i32.const 1)) (i32.const 0))
(assert_return (invoke "sub" (i32.const 1) (i32.const 0)) (i32.const 1))
(assert_return (invoke "sub" (i32.const -1) (i32.const -1)) (i32.const 0))
(assert_return (invoke "sub" (i32.const 0x7fffffff) (i32.const -1)) (i32.const 0x80000000))
(assert_return (invoke "sub" (i32.const 0x80000000) (i32.const 1)) (i32.const 0x7fffffff))
(assert_return (invoke "sub" (i32.const 0x80000000) (i32.const 0x80000000)) (i32.const 0))
(assert_return (invoke "sub" (i32.const 0x3fffffff) (i32.const -1)) (i32.const 0x40000000))
(assert_return (invoke "mul" (i32.const 1) (i32.const 1)) (i32.const 1))
(assert_return (invoke "mul" (i32.const 1) (i32.const 0)) (i32.const 0))
(assert_return (invoke "mul" (i32.const -1) (i32.const -1)) (i32.const 1))
(assert_return (invoke "mul" (i32.const 0x10000000) (i32.const 4096)) (i32.const 0))
(assert_return (invoke "mul" (i32.const 0x80000000) (i32.const 0)) (i32.const 0))
(assert_return (invoke "mul" (i32.const 0x80000000) (i32.const -1)) (i32.const 0x80000000))
(assert_return (invoke "mul" (i32.const 0x7fffffff) (i32.const -1)) (i32.const 0x80000001))
(assert_return (invoke "mul" (i32.const 0x01234567) (i32.const 0x76543210)) (i32.const 0x358e7470))
(assert_trap (invoke "div_s" (i32.const 1) (i32.const 0)) "integer divide by zero")
(assert_trap (invoke "div_s" (i32.const 0) (i32.const 0)) "integer divide by zero")
(assert_trap (invoke "div_s" (i32.const 0x80000000) (i32.const -1)) "integer overflow")
(assert_return (invoke "div_s" (i32.const 1) (i32.const 1)) (i32.const 1))
(assert_return (invoke "div_s" (i32.const 0) (i32.const 1)) (i32.const 0))
(assert_return (invoke "div_s" (i32.const -1) (i32.const -1)) (i32.const 1))
(assert_return (invoke "div_s" (i32.const 0x80000000) (i32.const 2)) (i32.const 0xc0000000))
(assert_return (invoke "div_s" (i32.const 0x80000001) (i32.const 1000)) (i32.const 0xffdf3b65))
(assert_return (invoke "div_s" (i32.const 5) (i32.const 2)) (i32.const 2))
(assert_return (invoke "div_s" (i32.const -5) (i32.const 2)) (i32.const -2))
(assert_return (invoke "div_s" (i32.const 5) (i32.const -2)) (i32.const -2))
(assert_return (invoke "div_s" (i32.const -5) (i32.const -2)) (i32.const 2))
(assert_return (invoke "div_s" (i32.const 7) (i32.const 3)) (i32.const 2))
(assert_return (invoke "div_s" (i32.const -7) (i32.const 3)) (i32.const -2))
(assert_return (invoke "div_s" (i32.const 7) (i32.const -3)) (i32.const -2))
(assert_return (invoke "div_s" (i32.const -7) (i32.const -3)) (i32.const 2))
(assert_return (invoke "div_s" (i32.const 11) (i32.const 5)) (i32.const 2))
(assert_return (invoke "div_s" (i32.const 17) (i32.const 7)) (i32.const 2))
(assert_trap (invoke "div_u" (i32.const 1) (i32.const 0)) "integer divide by zero")
(assert_trap (invoke "div_u" (i32.const 0) (i32.const 0)) "integer divide by zero")
(assert_return (invoke "div_u" (i32.const 1) (i32.const 1)) (i32.const 1))
(assert_return (invoke "div_u" (i32.const 0) (i32.const 1)) (i32.const 0))
(assert_return (invoke "div_u" (i32.const -1) (i32.const -1)) (i32.const 1))
(assert_return (invoke "div_u" (i32.const 0x80000000) (i32.const -1)) (i32.const 0))
(assert_return (invoke "div_u" (i32.const 0x80000000) (i32.const 2)) (i32.const 0x40000000))
(assert_return (invoke "div_u" (i32.const 0x8ff00ff0) (i32.const 0x10001)) (i32.const 0x8fef))
(assert_return (invoke "div_u" (i32.const 0x80000001) (i32.const 1000)) (i32.const 0x20c49b))
(assert_return (invoke "div_u" (i32.const 5) (i32.const 2)) (i32.const 2))
(assert_return (invoke "div_u" (i32.const -5) (i32.const 2)) (i32.const 0x7ffffffd))
(assert_return (invoke "div_u" (i32.const 5) (i32.const -2)) (i32.const 0))
(assert_return (invoke "div_u" (i32.const -5) (i32.const -2)) (i32.const 0))
(assert_return (invoke "div_u" (i32.const 7) (i32.const 3)) (i32.const 2))
(assert_return (invoke "div_u" (i32.const 11) (i32.const 5)) (i32.const 2))
(assert_return (invoke "div_u" (i32.const 17) (i32.const 7)) (i32.const 2))
(assert_trap (invoke "rem_s" (i32.const 1) (i32.const 0)) "integer divide by zero")
(assert_trap (invoke "rem_s" (i32.const 0) (i32.const 0)) "integer divide by zero")
(assert_return (invoke "rem_s" (i32.const 0x7fffffff) (i32.const -1)) (i32.const 0))
(assert_return (invoke "rem_s" (i32.const 1) (i32.const 1)) (i32.const 0))
(assert_return (invoke "rem_s" (i32.const 0) (i32.const 1)) (i32.const 0))
(assert_return (invoke "rem_s" (i32.const -1) (i32.const -1)) (i32.const 0))
(assert_return (invoke "rem_s" (i32.const 0x80000000) (i32.const -1)) (i32.const 0))
(assert_return (invoke "rem_s" (i32.const 0x80000000) (i32.const 2)) (i32.const 0))
(assert_return (invoke "rem_s" (i32.const 0x80000001) (i32.const 1000)) (i32.const -647))
(assert_return (invoke "rem_s" (i32.const 5) (i32.const 2)) (i32.const 1))
(assert_return (invoke "rem_s" (i32.const -5) (i32.const 2)) (i32.const -1))
(assert_return (invoke "rem_s" (i32.const 5) (i32.const -2)) (i32.const 1))
(assert_return (invoke "rem_s" (i32.const -5) (i32.const -2)) (i32.const -1))
(assert_return (invoke "rem_s" (i32.const 7) (i32.const 3)) (i32.const 1))
(assert_return (invoke "rem_s" (i32.const -7) (i32.const 3)) (i32.const -1))
(assert_return (invoke "rem_s" (i32.const 7) (i32.const -3)) (i32.const 1))
(assert_return (invoke "rem_s" (i32.const -7) (i32.const -3)) (i32.const -1))
(assert_return (invoke "rem_s" (i32.const 11) (i32.const 5)) (i32.const 1))
(assert_return (invoke "rem_s" (i32.const 17) (i32.const 7)) (i32.const 3))
(assert_trap (invoke "rem_u" (i32.const 1) (i32.const 0)) "integer divide by zero")
(assert_trap (invoke "rem_u" (i32.const 0) (i32.const 0)) "integer divide by zero")
(assert_return (invoke "rem_u" (i32.const 1) (i32.const 1)) (i32.const 0))
(assert_return (invoke "rem_u" (i32.const 0) (i32.const 1)) (i32.const 0))
(assert_return (invoke "rem_u" (i32.const -1) (i32.const -1)) (i32.const 0))
(assert_return (invoke "rem_u" (i32.const 0x80000000) (i32.const -1)) (i32.const 0x80000000))
(assert_return (invoke "rem_u" (i32.const 0x80000000) (i32.const 2)) (i32.const 0))
(assert_return (invoke "rem_u" (i32.const 0x8ff00ff0) (i32.const 0x10001)) (i32.const 0x8001))
(assert_return (invoke "rem_u" (i32.const 0x80000001) (i32.const 1000)) (i32.const 649))
(assert_return (invoke "rem_u" (i32.const 5) (i32.const 2)) (i32.const 1))
(assert_return (invoke "rem_u" (i32.const -5) (i32.const 2)) (i32.const 1))
(assert_return (invoke "rem_u" (i32.const 5) (i32.const -2)) (i32.const 5))
(assert_return (invoke "rem_u" (i32.const -5) (i32.const -2)) (i32.const -5))
(assert_return (invoke "rem_u" (i32.const 7) (i32.const 3)) (i32.const 1))
(assert_return (invoke "rem_u" (i32.const 11) (i32.const 5)) (i32.const 1))
(assert_return (invoke "rem_u" (i32.const 17) (i32.const 7)) (i32.const 3))
(assert_return (invoke "and" (i32.const 1) (i32.const 0)) (i32.const 0))
(assert_return (invoke "and" (i32.const 0) (i32.const 1)) (i32.const 0))
(assert_return (invoke "and" (i32.const 1) (i32.const 1)) (i32.const 1))
(assert_return (invoke "and" (i32.const 0) (i32.const 0)) (i32.const 0))
(assert_return (invoke "and" (i32.const 0x7fffffff) (i32.const 0x80000000)) (i32.const 0))
(assert_return (invoke "and" (i32.const 0x7fffffff) (i32.const -1)) (i32.const 0x7fffffff))
(assert_return (invoke "and" (i32.const 0xf0f0ffff) (i32.const 0xfffff0f0)) (i32.const 0xf0f0f0f0))
(assert_return (invoke "and" (i32.const 0xffffffff) (i32.const 0xffffffff)) (i32.const 0xffffffff))
(assert_return (invoke "or" (i32.const 1) (i32.const 0)) (i32.const 1))
(assert_return (invoke "or" (i32.const 0) (i32.const 1)) (i32.const 1))
(assert_return (invoke "or" (i32.const 1) (i32.const 1)) (i32.const 1))
(assert_return (invoke "or" (i32.const 0) (i32.const 0)) (i32.const 0))
(assert_return (invoke "or" (i32.const 0x7fffffff) (i32.const 0x80000000)) (i32.const -1))
(assert_return (invoke "or" (i32.const 0x80000000) (i32.const 0)) (i32.const 0x80000000))
(assert_return (invoke "or" (i32.const 0xf0f0ffff) (i32.const 0xfffff0f0)) (i32.const 0xffffffff))
(assert_return (invoke "or" (i32.const 0xffffffff) (i32.const 0xffffffff)) (i32.const 0xffffffff))
(assert_return (invoke "xor" (i32.const 1) (i32.const 0)) (i32.const 1))
(assert_return (invoke "xor" (i32.const 0) (i32.const 1)) (i32.const 1))
(assert_return (invoke "xor" (i32.const 1) (i32.const 1)) (i32.const 0))
(assert_return (invoke "xor" (i32.const 0) (i32.const 0)) (i32.const 0))
(assert_return (invoke "xor" (i32.const 0x7fffffff) (i32.const 0x80000000)) (i32.const -1))
(assert_return (invoke "xor" (i32.const 0x80000000) (i32.const 0)) (i32.const 0x80000000))
(assert_return (invoke "xor" (i32.const -1) (i32.const 0x80000000)) (i32.const 0x7fffffff))
(assert_return (invoke "xor" (i32.const -1) (i32.const 0x7fffffff)) (i32.const 0x80000000))
(assert_return (invoke "xor" (i32.const 0xf0f0ffff) (i32.const 0xfffff0f0)) (i32.const 0x0f0f0f0f))
(assert_return (invoke "xor" (i32.const 0xffffffff) (i32.const 0xffffffff)) (i32.const 0))
(assert_return (invoke "shl" (i32.const 1) (i32.const 1)) (i32.const 2))
(assert_return (invoke "shl" (i32.const 1) (i32.const 0)) (i32.const 1))
(assert_return (invoke "shl" (i32.const 0x7fffffff) (i32.const 1)) (i32.const 0xfffffffe))
(assert_return (invoke "shl" (i32.const 0xffffffff) (i32.const 1)) (i32.const 0xfffffffe))
(assert_return (invoke "shl" (i32.const 0x80000000) (i32.const 1)) (i32.const 0))
(assert_return (invoke "shl" (i32.const 0x40000000) (i32.const 1)) (i32.const 0x80000000))
(assert_return (invoke "shl" (i32.const 1) (i32.const 31)) (i32.const 0x80000000))
(assert_return (invoke "shl" (i32.const 1) (i32.const 32)) (i32.const 1))
(assert_return (invoke "shl" (i32.const 1) (i32.const 33)) (i32.const 2))
(assert_return (invoke "shl" (i32.const 1) (i32.const -1)) (i32.const 0x80000000))
(assert_return (invoke "shl" (i32.const 1) (i32.const 0x7fffffff)) (i32.const 0x80000000))
(assert_return (invoke "shr_s" (i32.const 1) (i32.const 1)) (i32.const 0))
(assert_return (invoke "shr_s" (i32.const 1) (i32.const 0)) (i32.const 1))
(assert_return (invoke "shr_s" (i32.const -1) (i32.const 1)) (i32.const -1))
(assert_return (invoke "shr_s" (i32.const 0x7fffffff) (i32.const 1)) (i32.const 0x3fffffff))
(assert_return (invoke "shr_s" (i32.const 0x80000000) (i32.const 1)) (i32.const 0xc0000000))
(assert_return (invoke "shr_s" (i32.const 0x40000000) (i32.const 1)) (i32.const 0x20000000))
(assert_return (invoke "shr_s" (i32.const 1) (i32.const 32)) (i32.const 1))
(assert_return (invoke "shr_s" (i32.const 1) (i32.const 33)) (i32.const 0))
(assert_return (invoke "shr_s" (i32.const 1) (i32.const -1)) (i32.const 0))
(assert_return (invoke "shr_s" (i32.const 1) (i32.const 0x7fffffff)) (i32.const 0))
(assert_return (invoke "shr_s" (i32.const 1) (i32.const 0x80000000)) (i32.const 1))
(assert_return (invoke "shr_s" (i32.const 0x80000000) (i32.const 31)) (i32.const -1))
(assert_return (invoke "shr_s" (i32.const -1) (i32.const 32)) (i32.const -1))
(assert_return (invoke "shr_s" (i32.const -1) (i32.const 33)) (i32.const -1))
(assert_return (invoke "shr_s" (i32.const -1) (i32.const -1)) (i32.const -1))
(assert_return (invoke "shr_s" (i32.const -1) (i32.const 0x7fffffff)) (i32.const -1))
(assert_return (invoke "shr_s" (i32.const -1) (i32.const 0x80000000)) (i32.const -1))
(assert_return (invoke "shr_u" (i32.const 1) (i32.const 1)) (i32.const 0))
(assert_return (invoke "shr_u" (i32.const 1) (i32.const 0)) (i32.const 1))
(assert_return (invoke "shr_u" (i32.const -1) (i32.const 1)) (i32.const 0x7fffffff))
(assert_return (invoke "shr_u" (i32.const 0x7fffffff) (i32.const 1)) (i32.const 0x3fffffff))
(assert_return (invoke "shr_u" (i32.const 0x80000000) (i32.const 1)) (i32.const 0x40000000))
(assert_return (invoke "shr_u" (i32.const 0x40000000) (i32.const 1)) (i32.const 0x20000000))
(assert_return (invoke "shr_u" (i32.const 1) (i32.const 32)) (i32.const 1))
(assert_return (invoke "shr_u" (i32.const 1) (i32.const 33)) (i32.const 0))
(assert_return (invoke "shr_u" (i32.const 1) (i32.const -1)) (i32.const 0))
(assert_return (invoke "shr_u" (i32.const 1) (i32.const 0x7fffffff)) (i32.const 0))
(assert_return (invoke "shr_u" (i32.const 1) (i32.const 0x80000000)) (i32.const 1))
(assert_return (invoke "shr_u" (i32.const 0x80000000) (i32.const 31)) (i32.const 1))
(assert_return (invoke "shr_u" (i32.const -1) (i32.const 32)) (i32.const -1))
(assert_return (invoke "shr_u" (i32.const -1) (i32.const 33)) (i32.const 0x7fffffff))
(assert_return (invoke "shr_u" (i32.const -1) (i32.const -1)) (i32.const 1))
(assert_return (invoke "shr_u" (i32.const -1) (i32.const 0x7fffffff)) (i32.const 1))
(assert_return (invoke "shr_u" (i32.const -1) (i32.const 0x80000000)) (i32.const -1))
(assert_return (invoke "rotl" (i32.const 0xfe00dc00) (i32.const 4)) (i32.const 0xe00dc00f))
(assert_return (invoke "rotl" (i32.const 0xabcd9876) (i32.const 1)) (i32.const 0x579b30ed))
(assert_return (invoke "rotl" (i32.const 0x00008000) (i32.const 37)) (i32.const 0x00100000))
(assert_return (invoke "rotl" (i32.const 0x769abcdf) (i32.const 0x8000000d)) (i32.const 0x579beed3))
(assert_return (invoke "rotr" (i32.const 0xb0c1d2e3) (i32.const 0x0005)) (i32.const 0x1d860e97))
(assert_return (invoke "rotr" (i32.const 0xb0c1d2e3) (i32.const 0xff05)) (i32.const 0x1d860e97))
(assert_return (invoke "rotr" (i32.const 0xff00cc00) (i32.const 1)) (i32.const 0x7f806600))
(assert_return (invoke "rotr" (i32.const 0x00080000) (i32.const 4)) (i32.const 0x00008000))
(assert_return (invoke "rotr" (i32.const 0x769abcdf) (i32.const 0xffffffed)) (i32.const 0xe6fbb4d5))
(assert_return (invoke "clz" (i32.const 0xffffffff)) (i32.const 0))
(assert_return (invoke "clz" (i32.const 0)) (i32.const 32))
(assert_return (invoke "clz" (i32.const 0x00008000)) (i32.const 16))
(assert_return (invoke "clz" (i32.const 0xff)) (i32.const 24))
(assert_return (invoke "clz" (i32.const 0x80000000)) (i32.const 0))
(assert_return (invoke "clz" (i32.const 1)) (i32.const 31))
(assert_return (invoke "clz" (i32.const 2)) (i32.const 30))
(assert_return (invoke "ctz" (i32.const -1)) (i32.const 0))
(assert_return (invoke "ctz" (i32.const 0)) (i32.const 32))
(assert_return (invoke "ctz" (i32.const 0x00008000)) (i32.const 15))
(assert_return (invoke "ctz" (i32.const 0x00010000)) (i32.const 16))
(assert_return (invoke "ctz" (i32.const 0x80000000)) (i32.const 31))
(assert_return (invoke "popcnt" (i32.const -1)) (i32.const 32))
(assert_return (invoke "popcnt" (i32.const 0)) (i32.const 0))
(assert_return (invoke "popcnt" (i32.const 0x00008000)) (i32.const 1))
(assert_return (invoke "popcnt" (i32.const 0x80008000)) (i32.const 2))
(assert_return (invoke "popcnt" (i32.const 0xAAAAAAAA)) (i32.const 16))
(assert_return (invoke "popcnt" (i32.const 0x55555555)) (i32.const 16))
(assert_return (invoke "popcnt" (i32.const 0xDEADBEEF)) (i32.const 24))
(assert_return (invoke "eqz" (i32.const 0)) (i32.const 1))
(assert_return (invoke "eqz" (i32.const 1)) (i32.const 0))
(assert_return (invoke "eqz" (i32.const 0x80000000)) (i32.const 0))
(assert_return (invoke "eq" (i32.const 0) (i32.const 0)) (i32.const 1))
(assert_return (invoke "eq" (i32.const 1) (i32.const 1)) (i32.const 1))
(assert_return (invoke "eq" (i32.const -1) (i32.const 1)) (i32.const 0))
(assert_return (invoke "eq" (i32.const 0x80000000) (i32.const 0x80000000)) (i32.const 1))
(assert_return (invoke "eq" (i32.const 0x7fffffff) (i32.const 0x7fffffff)) (i32.const 1))
(assert_return (invoke "eq" (i32.const -1) (i32.const -1)) (i32.const 1))
(assert_return (invoke "eq" (i32.const 1) (i32.const 0)) (i32.const 0))
(assert_return (invoke "eq" (i32.const 0x80000000) (i32.const 0)) (i32.const 0))
(assert_return (invoke "eq" (i32.const 0x80000000) (i32.const -1)) (i32.const 0))
(assert_return (invoke "eq" (i32.const 0x80000000) (i32.const 0x7fffffff)) (i32.const 0))
(assert_return (invoke "ne" (i32.const 0) (i32.const 0)) (i32.const 0))
(assert_return (invoke "ne" (i32.const 1) (i32.const 1)) (i32.const 0))
(assert_return (invoke "ne" (i32.const -1) (i32.const 1)) (i32.const 1))
(assert_return (invoke "ne" (i32.const 0x80000000) (i32.const 0x80000000)) (i32.const 0))
(assert_return (invoke "ne" (i32.const 0x7fffffff) (i32.const 0x7fffffff)) (i32.const 0))
(assert_return (invoke "ne" (i32.const -1) (i32.const -1)) (i32.const 0))
(assert_return (invoke "ne" (i32.const 1) (i32.const 0)) (i32.const 1))
(assert_return (invoke "ne" (i32.const 0x80000000) (i32.const 0)) (i32.const 1))
(assert_return (invoke "ne" (i32.const 0x80000000) (i32.const -1)) (i32.const 1))
(assert_return (invoke "ne" (i32.const 0x80000000) (i32.const 0x7fffffff)) (i32.const 1))
(assert_return (invoke "lt_s" (i32.const 0) (i32.const 0)) (i32.const 0))
(assert_return (invoke "lt_s" (i32.const 1) (i32.const 1)) (i32.const 0))
(assert_return (invoke "lt_s" (i32.const -1) (i32.const 1)) (i32.const 1))
(assert_return (invoke "lt_s" (i32.const 0x80000000) (i32.const 0x80000000)) (i32.const 0))
(assert_return (invoke "lt_s" (i32.const 0x7fffffff) (i32.const 0x7fffffff)) (i32.const 0))
(assert_return (invoke "lt_s" (i32.const -1) (i32.const -1)) (i32.const 0))
(assert_return (invoke "lt_s" (i32.const 1) (i32.const 0)) (i32.const 0))
(assert_return (invoke "lt_s" (i32.const 0) (i32.const 1)) (i32.const 1))
(assert_return (invoke "lt_s" (i32.const 0x80000000) (i32.const 0)) (i32.const 1))
(assert_return (invoke "lt_s" (i32.const 0) (i32.const 0x80000000)) (i32.const 0))
(assert_return (invoke "lt_s" (i32.const 0x80000000) (i32.const -1)) (i32.const 1))
(assert_return (invoke "lt_s" (i32.const -1) (i32.const 0x80000000)) (i32.const 0))
(assert_return (invoke "lt_s" (i32.const 0x80000000) (i32.const 0x7fffffff)) (i32.const 1))
(assert_return (invoke "lt_s" (i32.const 0x7fffffff) (i32.const 0x80000000)) (i32.const 0))
(assert_return (invoke "lt_u" (i32.const 0) (i32.const 0)) (i32.const 0))
(assert_return (invoke "lt_u" (i32.const 1) (i32.const 1)) (i32.const 0))
(assert_return (invoke "lt_u" (i32.const -1) (i32.const 1)) (i32.const 0))
(assert_return (invoke "lt_u" (i32.const 0x80000000) (i32.const 0x80000000)) (i32.const 0))
(assert_return (invoke "lt_u" (i32.const 0x7fffffff) (i32.const 0x7fffffff)) (i32.const 0))
(assert_return (invoke "lt_u" (i32.const -1) (i32.const -1)) (i32.const 0))
(assert_return (invoke "lt_u" (i32.const 1) (i32.const 0)) (i32.const 0))
(assert_return (invoke "lt_u" (i32.const 0) (i32.const 1)) (i32.const 1))
(assert_return (invoke "lt_u" (i32.const 0x80000000) (i32.const 0)) (i32.const 0))
(assert_return (invoke "lt_u" (i32.const 0) (i32.const 0x80000000)) (i32.const 1))
(assert_return (invoke "lt_u" (i32.const 0x80000000) (i32.const -1)) (i32.const 1))
(assert_return (invoke "lt_u" (i32.const -1) (i32.const 0x80000000)) (i32.const 0))
(assert_return (invoke "lt_u" (i32.const 0x80000000) (i32.const 0x7fffffff)) (i32.const 0))
(assert_return (invoke "lt_u" (i32.const 0x7fffffff) (i32.const 0x80000000)) (i32.const 1))
(assert_return (invoke "le_s" (i32.const 0) (i32.const 0)) (i32.const 1))
(assert_return (invoke "le_s" (i32.const 1) (i32.const 1)) (i32.const 1))
(assert_return (invoke "le_s" (i32.const -1) (i32.const 1)) (i32.const 1))
(assert_return (invoke "le_s" (i32.const 0x80000000) (i32.const 0x80000000)) (i32.const 1))
(assert_return (invoke "le_s" (i32.const 0x7fffffff) (i32.const 0x7fffffff)) (i32.const 1))
(assert_return (invoke "le_s" (i32.const -1) (i32.const -1)) (i32.const 1))
(assert_return (invoke "le_s" (i32.const 1) (i32.const 0)) (i32.const 0))
(assert_return (invoke "le_s" (i32.const 0) (i32.const 1)) (i32.const 1))
(assert_return (invoke "le_s" (i32.const 0x80000000) (i32.const 0)) (i32.const 1))
(assert_return (invoke "le_s" (i32.const 0) (i32.const 0x80000000)) (i32.const 0))
(assert_return (invoke "le_s" (i32.const 0x80000000) (i32.const -1)) (i32.const 1))
(assert_return (invoke "le_s" (i32.const -1) (i32.const 0x80000000)) (i32.const 0))
(assert_return (invoke "le_s" (i32.const 0x80000000) (i32.const 0x7fffffff)) (i32.const 1))
(assert_return (invoke "le_s" (i32.const 0x7fffffff) (i32.const 0x80000000)) (i32.const 0))
(assert_return (invoke "le_u" (i32.const 0) (i32.const 0)) (i32.const 1))
(assert_return (invoke "le_u" (i32.const 1) (i32.const 1)) (i32.const 1))
(assert_return (invoke "le_u" (i32.const -1) (i32.const 1)) (i32.const 0))
(assert_return (invoke "le_u" (i32.const 0x80000000) (i32.const 0x80000000)) (i32.const 1))
(assert_return (invoke "le_u" (i32.const 0x7fffffff) (i32.const 0x7fffffff)) (i32.const 1))
(assert_return (invoke "le_u" (i32.const -1) (i32.const -1)) (i32.const 1))
(assert_return (invoke "le_u" (i32.const 1) (i32.const 0)) (i32.const 0))
(assert_return (invoke "le_u" (i32.const 0) (i32.const 1)) (i32.const 1))
(assert_return (invoke "le_u" (i32.const 0x80000000) (i32.const 0)) (i32.const 0))
(assert_return (invoke "le_u" (i32.const 0) (i32.const 0x80000000)) (i32.const 1))
(assert_return (invoke "le_u" (i32.const 0x80000000) (i32.const -1)) (i32.const 1))
(assert_return (invoke "le_u" (i32.const -1) (i32.const 0x80000000)) (i32.const 0))
(assert_return (invoke "le_u" (i32.const 0x80000000) (i32.const 0x7fffffff)) (i32.const 0))
(assert_return (invoke "le_u" (i32.const 0x7fffffff) (i32.const 0x80000000)) (i32.const 1))
(assert_return (invoke "gt_s" (i32.const 0) (i32.const 0)) (i32.const 0))
(assert_return (invoke "gt_s" (i32.const 1) (i32.const 1)) (i32.const 0))
(assert_return (invoke "gt_s" (i32.const -1) (i32.const 1)) (i32.const 0))
(assert_return (invoke "gt_s" (i32.const 0x80000000) (i32.const 0x80000000)) (i32.const 0))
(assert_return (invoke "gt_s" (i32.const 0x7fffffff) (i32.const 0x7fffffff)) (i32.const 0))
(assert_return (invoke "gt_s" (i32.const -1) (i32.const -1)) (i32.const 0))
(assert_return (invoke "gt_s" (i32.const 1) (i32.const 0)) (i32.const 1))
(assert_return (invoke "gt_s" (i32.const 0) (i32.const 1)) (i32.const 0))
(assert_return (invoke "gt_s" (i32.const 0x80000000) (i32.const 0)) (i32.const 0))
(assert_return (invoke "gt_s" (i32.const 0) (i32.const 0x80000000)) (i32.const 1))
(assert_return (invoke "gt_s" (i32.const 0x80000000) (i32.const -1)) (i32.const 0))
(assert_return (invoke "gt_s" (i32.const -1) (i32.const 0x80000000)) (i32.const 1))
(assert_return (invoke "gt_s" (i32.const 0x80000000) (i32.const 0x7fffffff)) (i32.const 0))
(assert_return (invoke "gt_s" (i32.const 0x7fffffff) (i32.const 0x80000000)) (i32.const 1))
(assert_return (invoke "gt_u" (i32.const 0) (i32.const 0)) (i32.const 0))
(assert_return (invoke "gt_u" (i32.const 1) (i32.const 1)) (i32.const 0))
(assert_return (invoke "gt_u" (i32.const -1) (i32.const 1)) (i32.const 1))
(assert_return (invoke "gt_u" (i32.const 0x80000000) (i32.const 0x80000000)) (i32.const 0))
(assert_return (invoke "gt_u" (i32.const 0x7fffffff) (i32.const 0x7fffffff)) (i32.const 0))
(assert_return (invoke "gt_u" (i32.const -1) (i32.const -1)) (i32.const 0))
(assert_return (invoke "gt_u" (i32.const 1) (i32.const 0)) (i32.const 1))
(assert_return (invoke "gt_u" (i32.const 0) (i32.const 1)) (i32.const 0))
(assert_return (invoke "gt_u" (i32.const 0x80000000) (i32.const 0)) (i32.const 1))
(assert_return (invoke "gt_u" (i32.const 0) (i32.const 0x80000000)) (i32.const 0))
(assert_return (invoke "gt_u" (i32.const 0x80000000) (i32.const -1)) (i32.const 0))
(assert_return (invoke "gt_u" (i32.const -1) (i32.const 0x80000000)) (i32.const 1))
(assert_return (invoke "gt_u" (i32.const 0x80000000) (i32.const 0x7fffffff)) (i32.const 1))
(assert_return (invoke "gt_u" (i32.const 0x7fffffff) (i32.const 0x80000000)) (i32.const 0))
(assert_return (invoke "ge_s" (i32.const 0) (i32.const 0)) (i32.const 1))
(assert_return (invoke "ge_s" (i32.const 1) (i32.const 1)) (i32.const 1))
(assert_return (invoke "ge_s" (i32.const -1) (i32.const 1)) (i32.const 0))
(assert_return (invoke "ge_s" (i32.const 0x80000000) (i32.const 0x80000000)) (i32.const 1))
(assert_return (invoke "ge_s" (i32.const 0x7fffffff) (i32.const 0x7fffffff)) (i32.const 1))
(assert_return (invoke "ge_s" (i32.const -1) (i32.const -1)) (i32.const 1))
(assert_return (invoke "ge_s" (i32.const 1) (i32.const 0)) (i32.const 1))
(assert_return (invoke "ge_s" (i32.const 0) (i32.const 1)) (i32.const 0))
(assert_return (invoke "ge_s" (i32.const 0x80000000) (i32.const 0)) (i32.const 0))
(assert_return (invoke "ge_s" (i32.const 0) (i32.const 0x80000000)) (i32.const 1))
(assert_return (invoke "ge_s" (i32.const 0x80000000) (i32.const -1)) (i32.const 0))
(assert_return (invoke "ge_s" (i32.const -1) (i32.const 0x80000000)) (i32.const 1))
(assert_return (invoke "ge_s" (i32.const 0x80000000) (i32.const 0x7fffffff)) (i32.const 0))
(assert_return (invoke "ge_s" (i32.const 0x7fffffff) (i32.const 0x80000000)) (i32.const 1))
(assert_return (invoke "ge_u" (i32.const 0) (i32.const 0)) (i32.const 1))
(assert_return (invoke "ge_u" (i32.const 1) (i32.const 1)) (i32.const 1))
(assert_return (invoke "ge_u" (i32.const -1) (i32.const 1)) (i32.const 1))
(assert_return (invoke "ge_u" (i32.const 0x80000000) (i32.const 0x80000000)) (i32.const 1))
(assert_return (invoke "ge_u" (i32.const 0x7fffffff) (i32.const 0x7fffffff)) (i32.const 1))
(assert_return (invoke "ge_u" (i32.const -1) (i32.const -1)) (i32.const 1))
(assert_return (invoke "ge_u" (i32.const 1) (i32.const 0)) (i32.const 1))
(assert_return (invoke "ge_u" (i32.const 0) (i32.const 1)) (i32.const 0))
(assert_return (invoke "ge_u" (i32.const 0x80000000) (i32.const 0)) (i32.const 1))
(assert_return (invoke "ge_u" (i32.const 0) (i32.const 0x80000000)) (i32.const 0))
(assert_return (invoke "ge_u" (i32.const 0x80000000) (i32.const -1)) (i32.const 0))
(assert_return (invoke "ge_u" (i32.const -1) (i32.const 0x80000000)) (i32.const 1))
(assert_return (invoke "ge_u" (i32.const 0x80000000) (i32.const 0x7fffffff)) (i32.const 1))
(assert_return (invoke "ge_u" (i32.const 0x7fffffff) (i32.const 0x80000000)) (i32.const 0))

420
js/src/jit-test/tests/wasm/spec/i64.wast Normal file
View File

@ -0,0 +1,420 @@
;; i64 operations
(module
(func $add (param $x i64) (param $y i64) (result i64) (i64.add (get_local $x) (get_local $y)))
(func $sub (param $x i64) (param $y i64) (result i64) (i64.sub (get_local $x) (get_local $y)))
(func $mul (param $x i64) (param $y i64) (result i64) (i64.mul (get_local $x) (get_local $y)))
(func $div_s (param $x i64) (param $y i64) (result i64) (i64.div_s (get_local $x) (get_local $y)))
(func $div_u (param $x i64) (param $y i64) (result i64) (i64.div_u (get_local $x) (get_local $y)))
(func $rem_s (param $x i64) (param $y i64) (result i64) (i64.rem_s (get_local $x) (get_local $y)))
(func $rem_u (param $x i64) (param $y i64) (result i64) (i64.rem_u (get_local $x) (get_local $y)))
(func $and (param $x i64) (param $y i64) (result i64) (i64.and (get_local $x) (get_local $y)))
(func $or (param $x i64) (param $y i64) (result i64) (i64.or (get_local $x) (get_local $y)))
(func $xor (param $x i64) (param $y i64) (result i64) (i64.xor (get_local $x) (get_local $y)))
(func $shl (param $x i64) (param $y i64) (result i64) (i64.shl (get_local $x) (get_local $y)))
(func $shr_s (param $x i64) (param $y i64) (result i64) (i64.shr_s (get_local $x) (get_local $y)))
(func $shr_u (param $x i64) (param $y i64) (result i64) (i64.shr_u (get_local $x) (get_local $y)))
(func $rotl (param $x i64) (param $y i64) (result i64) (i64.rotl (get_local $x) (get_local $y)))
(func $rotr (param $x i64) (param $y i64) (result i64) (i64.rotr (get_local $x) (get_local $y)))
(func $clz (param $x i64) (result i64) (i64.clz (get_local $x)))
(func $ctz (param $x i64) (result i64) (i64.ctz (get_local $x)))
(func $popcnt (param $x i64) (result i64) (i64.popcnt (get_local $x)))
(func $eqz (param $x i64) (result i32) (i64.eqz (get_local $x)))
(func $eq (param $x i64) (param $y i64) (result i32) (i64.eq (get_local $x) (get_local $y)))
(func $ne (param $x i64) (param $y i64) (result i32) (i64.ne (get_local $x) (get_local $y)))
(func $lt_s (param $x i64) (param $y i64) (result i32) (i64.lt_s (get_local $x) (get_local $y)))
(func $lt_u (param $x i64) (param $y i64) (result i32) (i64.lt_u (get_local $x) (get_local $y)))
(func $le_s (param $x i64) (param $y i64) (result i32) (i64.le_s (get_local $x) (get_local $y)))
(func $le_u (param $x i64) (param $y i64) (result i32) (i64.le_u (get_local $x) (get_local $y)))
(func $gt_s (param $x i64) (param $y i64) (result i32) (i64.gt_s (get_local $x) (get_local $y)))
(func $gt_u (param $x i64) (param $y i64) (result i32) (i64.gt_u (get_local $x) (get_local $y)))
(func $ge_s (param $x i64) (param $y i64) (result i32) (i64.ge_s (get_local $x) (get_local $y)))
(func $ge_u (param $x i64) (param $y i64) (result i32) (i64.ge_u (get_local $x) (get_local $y)))
(export "add" $add)
(export "sub" $sub)
(export "mul" $mul)
(export "div_s" $div_s)
(export "div_u" $div_u)
(export "rem_s" $rem_s)
(export "rem_u" $rem_u)
(export "and" $and)
(export "or" $or)
(export "xor" $xor)
(export "shl" $shl)
(export "shr_s" $shr_s)
(export "shr_u" $shr_u)
(export "rotl" $rotl)
(export "rotr" $rotr)
(export "clz" $clz)
(export "ctz" $ctz)
(export "popcnt" $popcnt)
(export "eqz" $eqz)
(export "eq" $eq)
(export "ne" $ne)
(export "lt_s" $lt_s)
(export "lt_u" $lt_u)
(export "le_s" $le_s)
(export "le_u" $le_u)
(export "gt_s" $gt_s)
(export "gt_u" $gt_u)
(export "ge_s" $ge_s)
(export "ge_u" $ge_u)
)
(assert_return (invoke "add" (i64.const 1) (i64.const 1)) (i64.const 2))
(assert_return (invoke "add" (i64.const 1) (i64.const 0)) (i64.const 1))
(assert_return (invoke "add" (i64.const -1) (i64.const -1)) (i64.const -2))
(assert_return (invoke "add" (i64.const -1) (i64.const 1)) (i64.const 0))
(assert_return (invoke "add" (i64.const 0x7fffffffffffffff) (i64.const 1)) (i64.const 0x8000000000000000))
(assert_return (invoke "add" (i64.const 0x8000000000000000) (i64.const -1)) (i64.const 0x7fffffffffffffff))
(assert_return (invoke "add" (i64.const 0x8000000000000000) (i64.const 0x8000000000000000)) (i64.const 0))
(assert_return (invoke "add" (i64.const 0x3fffffff) (i64.const 1)) (i64.const 0x40000000))
(assert_return (invoke "sub" (i64.const 1) (i64.const 1)) (i64.const 0))
(assert_return (invoke "sub" (i64.const 1) (i64.const 0)) (i64.const 1))
(assert_return (invoke "sub" (i64.const -1) (i64.const -1)) (i64.const 0))
(assert_return (invoke "sub" (i64.const 0x7fffffffffffffff) (i64.const -1)) (i64.const 0x8000000000000000))
(assert_return (invoke "sub" (i64.const 0x8000000000000000) (i64.const 1)) (i64.const 0x7fffffffffffffff))
(assert_return (invoke "sub" (i64.const 0x8000000000000000) (i64.const 0x8000000000000000)) (i64.const 0))
(assert_return (invoke "sub" (i64.const 0x3fffffff) (i64.const -1)) (i64.const 0x40000000))
(assert_return (invoke "mul" (i64.const 1) (i64.const 1)) (i64.const 1))
(assert_return (invoke "mul" (i64.const 1) (i64.const 0)) (i64.const 0))
(assert_return (invoke "mul" (i64.const -1) (i64.const -1)) (i64.const 1))
(assert_return (invoke "mul" (i64.const 0x1000000000000000) (i64.const 4096)) (i64.const 0))
(assert_return (invoke "mul" (i64.const 0x8000000000000000) (i64.const 0)) (i64.const 0))
(assert_return (invoke "mul" (i64.const 0x8000000000000000) (i64.const -1)) (i64.const 0x8000000000000000))
(assert_return (invoke "mul" (i64.const 0x7fffffffffffffff) (i64.const -1)) (i64.const 0x8000000000000001))
(assert_return (invoke "mul" (i64.const 0x0123456789abcdef) (i64.const 0xfedcba9876543210)) (i64.const 0x2236d88fe5618cf0))
(assert_trap (invoke "div_s" (i64.const 1) (i64.const 0)) "integer divide by zero")
(assert_trap (invoke "div_s" (i64.const 0) (i64.const 0)) "integer divide by zero")
(assert_trap (invoke "div_s" (i64.const 0x8000000000000000) (i64.const -1)) "integer overflow")
(assert_return (invoke "div_s" (i64.const 1) (i64.const 1)) (i64.const 1))
(assert_return (invoke "div_s" (i64.const 0) (i64.const 1)) (i64.const 0))
(assert_return (invoke "div_s" (i64.const -1) (i64.const -1)) (i64.const 1))
(assert_return (invoke "div_s" (i64.const 0x8000000000000000) (i64.const 2)) (i64.const 0xc000000000000000))
(assert_return (invoke "div_s" (i64.const 0x8000000000000001) (i64.const 1000)) (i64.const 0xffdf3b645a1cac09))
(assert_return (invoke "div_s" (i64.const 5) (i64.const 2)) (i64.const 2))
(assert_return (invoke "div_s" (i64.const -5) (i64.const 2)) (i64.const -2))
(assert_return (invoke "div_s" (i64.const 5) (i64.const -2)) (i64.const -2))
(assert_return (invoke "div_s" (i64.const -5) (i64.const -2)) (i64.const 2))
(assert_return (invoke "div_s" (i64.const 7) (i64.const 3)) (i64.const 2))
(assert_return (invoke "div_s" (i64.const -7) (i64.const 3)) (i64.const -2))
(assert_return (invoke "div_s" (i64.const 7) (i64.const -3)) (i64.const -2))
(assert_return (invoke "div_s" (i64.const -7) (i64.const -3)) (i64.const 2))
(assert_return (invoke "div_s" (i64.const 11) (i64.const 5)) (i64.const 2))
(assert_return (invoke "div_s" (i64.const 17) (i64.const 7)) (i64.const 2))
(assert_trap (invoke "div_u" (i64.const 1) (i64.const 0)) "integer divide by zero")
(assert_trap (invoke "div_u" (i64.const 0) (i64.const 0)) "integer divide by zero")
(assert_return (invoke "div_u" (i64.const 1) (i64.const 1)) (i64.const 1))
(assert_return (invoke "div_u" (i64.const 0) (i64.const 1)) (i64.const 0))
(assert_return (invoke "div_u" (i64.const -1) (i64.const -1)) (i64.const 1))
(assert_return (invoke "div_u" (i64.const 0x8000000000000000) (i64.const -1)) (i64.const 0))
(assert_return (invoke "div_u" (i64.const 0x8000000000000000) (i64.const 2)) (i64.const 0x4000000000000000))
(assert_return (invoke "div_u" (i64.const 0x8ff00ff00ff00ff0) (i64.const 0x100000001)) (i64.const 0x8ff00fef))
(assert_return (invoke "div_u" (i64.const 0x8000000000000001) (i64.const 1000)) (i64.const 0x20c49ba5e353f7))
(assert_return (invoke "div_u" (i64.const 5) (i64.const 2)) (i64.const 2))
(assert_return (invoke "div_u" (i64.const -5) (i64.const 2)) (i64.const 0x7ffffffffffffffd))
(assert_return (invoke "div_u" (i64.const 5) (i64.const -2)) (i64.const 0))
(assert_return (invoke "div_u" (i64.const -5) (i64.const -2)) (i64.const 0))
(assert_return (invoke "div_u" (i64.const 7) (i64.const 3)) (i64.const 2))
(assert_return (invoke "div_u" (i64.const 11) (i64.const 5)) (i64.const 2))
(assert_return (invoke "div_u" (i64.const 17) (i64.const 7)) (i64.const 2))
(assert_trap (invoke "rem_s" (i64.const 1) (i64.const 0)) "integer divide by zero")
(assert_trap (invoke "rem_s" (i64.const 0) (i64.const 0)) "integer divide by zero")
(assert_return (invoke "rem_s" (i64.const 0x7fffffffffffffff) (i64.const -1)) (i64.const 0))
(assert_return (invoke "rem_s" (i64.const 1) (i64.const 1)) (i64.const 0))
(assert_return (invoke "rem_s" (i64.const 0) (i64.const 1)) (i64.const 0))
(assert_return (invoke "rem_s" (i64.const -1) (i64.const -1)) (i64.const 0))
(assert_return (invoke "rem_s" (i64.const 0x8000000000000000) (i64.const -1)) (i64.const 0))
(assert_return (invoke "rem_s" (i64.const 0x8000000000000000) (i64.const 2)) (i64.const 0))
(assert_return (invoke "rem_s" (i64.const 0x8000000000000001) (i64.const 1000)) (i64.const -807))
(assert_return (invoke "rem_s" (i64.const 5) (i64.const 2)) (i64.const 1))
(assert_return (invoke "rem_s" (i64.const -5) (i64.const 2)) (i64.const -1))
(assert_return (invoke "rem_s" (i64.const 5) (i64.const -2)) (i64.const 1))
(assert_return (invoke "rem_s" (i64.const -5) (i64.const -2)) (i64.const -1))
(assert_return (invoke "rem_s" (i64.const 7) (i64.const 3)) (i64.const 1))
(assert_return (invoke "rem_s" (i64.const -7) (i64.const 3)) (i64.const -1))
(assert_return (invoke "rem_s" (i64.const 7) (i64.const -3)) (i64.const 1))
(assert_return (invoke "rem_s" (i64.const -7) (i64.const -3)) (i64.const -1))
(assert_return (invoke "rem_s" (i64.const 11) (i64.const 5)) (i64.const 1))
(assert_return (invoke "rem_s" (i64.const 17) (i64.const 7)) (i64.const 3))
(assert_trap (invoke "rem_u" (i64.const 1) (i64.const 0)) "integer divide by zero")
(assert_trap (invoke "rem_u" (i64.const 0) (i64.const 0)) "integer divide by zero")
(assert_return (invoke "rem_u" (i64.const 1) (i64.const 1)) (i64.const 0))
(assert_return (invoke "rem_u" (i64.const 0) (i64.const 1)) (i64.const 0))
(assert_return (invoke "rem_u" (i64.const -1) (i64.const -1)) (i64.const 0))
(assert_return (invoke "rem_u" (i64.const 0x8000000000000000) (i64.const -1)) (i64.const 0x8000000000000000))
(assert_return (invoke "rem_u" (i64.const 0x8000000000000000) (i64.const 2)) (i64.const 0))
(assert_return (invoke "rem_u" (i64.const 0x8ff00ff00ff00ff0) (i64.const 0x100000001)) (i64.const 0x80000001))
(assert_return (invoke "rem_u" (i64.const 0x8000000000000001) (i64.const 1000)) (i64.const 809))
(assert_return (invoke "rem_u" (i64.const 5) (i64.const 2)) (i64.const 1))
(assert_return (invoke "rem_u" (i64.const -5) (i64.const 2)) (i64.const 1))
(assert_return (invoke "rem_u" (i64.const 5) (i64.const -2)) (i64.const 5))
(assert_return (invoke "rem_u" (i64.const -5) (i64.const -2)) (i64.const -5))
(assert_return (invoke "rem_u" (i64.const 7) (i64.const 3)) (i64.const 1))
(assert_return (invoke "rem_u" (i64.const 11) (i64.const 5)) (i64.const 1))
(assert_return (invoke "rem_u" (i64.const 17) (i64.const 7)) (i64.const 3))
(assert_return (invoke "and" (i64.const 1) (i64.const 0)) (i64.const 0))
(assert_return (invoke "and" (i64.const 0) (i64.const 1)) (i64.const 0))
(assert_return (invoke "and" (i64.const 1) (i64.const 1)) (i64.const 1))
(assert_return (invoke "and" (i64.const 0) (i64.const 0)) (i64.const 0))
(assert_return (invoke "and" (i64.const 0x7fffffffffffffff) (i64.const 0x8000000000000000)) (i64.const 0))
(assert_return (invoke "and" (i64.const 0x7fffffffffffffff) (i64.const -1)) (i64.const 0x7fffffffffffffff))
(assert_return (invoke "and" (i64.const 0xf0f0ffff) (i64.const 0xfffff0f0)) (i64.const 0xf0f0f0f0))
(assert_return (invoke "and" (i64.const 0xffffffffffffffff) (i64.const 0xffffffffffffffff)) (i64.const 0xffffffffffffffff))
(assert_return (invoke "or" (i64.const 1) (i64.const 0)) (i64.const 1))
(assert_return (invoke "or" (i64.const 0) (i64.const 1)) (i64.const 1))
(assert_return (invoke "or" (i64.const 1) (i64.const 1)) (i64.const 1))
(assert_return (invoke "or" (i64.const 0) (i64.const 0)) (i64.const 0))
(assert_return (invoke "or" (i64.const 0x7fffffffffffffff) (i64.const 0x8000000000000000)) (i64.const -1))
(assert_return (invoke "or" (i64.const 0x8000000000000000) (i64.const 0)) (i64.const 0x8000000000000000))
(assert_return (invoke "or" (i64.const 0xf0f0ffff) (i64.const 0xfffff0f0)) (i64.const 0xffffffff))
(assert_return (invoke "or" (i64.const 0xffffffffffffffff) (i64.const 0xffffffffffffffff)) (i64.const 0xffffffffffffffff))
(assert_return (invoke "xor" (i64.const 1) (i64.const 0)) (i64.const 1))
(assert_return (invoke "xor" (i64.const 0) (i64.const 1)) (i64.const 1))
(assert_return (invoke "xor" (i64.const 1) (i64.const 1)) (i64.const 0))
(assert_return (invoke "xor" (i64.const 0) (i64.const 0)) (i64.const 0))
(assert_return (invoke "xor" (i64.const 0x7fffffffffffffff) (i64.const 0x8000000000000000)) (i64.const -1))
(assert_return (invoke "xor" (i64.const 0x8000000000000000) (i64.const 0)) (i64.const 0x8000000000000000))
(assert_return (invoke "xor" (i64.const -1) (i64.const 0x8000000000000000)) (i64.const 0x7fffffffffffffff))
(assert_return (invoke "xor" (i64.const -1) (i64.const 0x7fffffffffffffff)) (i64.const 0x8000000000000000))
(assert_return (invoke "xor" (i64.const 0xf0f0ffff) (i64.const 0xfffff0f0)) (i64.const 0x0f0f0f0f))
(assert_return (invoke "xor" (i64.const 0xffffffffffffffff) (i64.const 0xffffffffffffffff)) (i64.const 0))
(assert_return (invoke "shl" (i64.const 1) (i64.const 1)) (i64.const 2))
(assert_return (invoke "shl" (i64.const 1) (i64.const 0)) (i64.const 1))
(assert_return (invoke "shl" (i64.const 0x7fffffffffffffff) (i64.const 1)) (i64.const 0xfffffffffffffffe))
(assert_return (invoke "shl" (i64.const 0xffffffffffffffff) (i64.const 1)) (i64.const 0xfffffffffffffffe))
(assert_return (invoke "shl" (i64.const 0x8000000000000000) (i64.const 1)) (i64.const 0))
(assert_return (invoke "shl" (i64.const 0x4000000000000000) (i64.const 1)) (i64.const 0x8000000000000000))
(assert_return (invoke "shl" (i64.const 1) (i64.const 63)) (i64.const 0x8000000000000000))
(assert_return (invoke "shl" (i64.const 1) (i64.const 64)) (i64.const 1))
(assert_return (invoke "shl" (i64.const 1) (i64.const 65)) (i64.const 2))
(assert_return (invoke "shl" (i64.const 1) (i64.const -1)) (i64.const 0x8000000000000000))
(assert_return (invoke "shl" (i64.const 1) (i64.const 0x7fffffffffffffff)) (i64.const 0x8000000000000000))
(assert_return (invoke "shr_s" (i64.const 1) (i64.const 1)) (i64.const 0))
(assert_return (invoke "shr_s" (i64.const 1) (i64.const 0)) (i64.const 1))
(assert_return (invoke "shr_s" (i64.const -1) (i64.const 1)) (i64.const -1))
(assert_return (invoke "shr_s" (i64.const 0x7fffffffffffffff) (i64.const 1)) (i64.const 0x3fffffffffffffff))
(assert_return (invoke "shr_s" (i64.const 0x8000000000000000) (i64.const 1)) (i64.const 0xc000000000000000))
(assert_return (invoke "shr_s" (i64.const 0x4000000000000000) (i64.const 1)) (i64.const 0x2000000000000000))
(assert_return (invoke "shr_s" (i64.const 1) (i64.const 64)) (i64.const 1))
(assert_return (invoke "shr_s" (i64.const 1) (i64.const 65)) (i64.const 0))
(assert_return (invoke "shr_s" (i64.const 1) (i64.const -1)) (i64.const 0))
(assert_return (invoke "shr_s" (i64.const 1) (i64.const 0x7fffffffffffffff)) (i64.const 0))
(assert_return (invoke "shr_s" (i64.const 1) (i64.const 0x8000000000000000)) (i64.const 1))
(assert_return (invoke "shr_s" (i64.const 0x8000000000000000) (i64.const 63)) (i64.const -1))
(assert_return (invoke "shr_s" (i64.const -1) (i64.const 64)) (i64.const -1))
(assert_return (invoke "shr_s" (i64.const -1) (i64.const 65)) (i64.const -1))
(assert_return (invoke "shr_s" (i64.const -1) (i64.const -1)) (i64.const -1))
(assert_return (invoke "shr_s" (i64.const -1) (i64.const 0x7fffffffffffffff)) (i64.const -1))
(assert_return (invoke "shr_s" (i64.const -1) (i64.const 0x8000000000000000)) (i64.const -1))
(assert_return (invoke "shr_u" (i64.const 1) (i64.const 1)) (i64.const 0))
(assert_return (invoke "shr_u" (i64.const 1) (i64.const 0)) (i64.const 1))
(assert_return (invoke "shr_u" (i64.const -1) (i64.const 1)) (i64.const 0x7fffffffffffffff))
(assert_return (invoke "shr_u" (i64.const 0x7fffffffffffffff) (i64.const 1)) (i64.const 0x3fffffffffffffff))
(assert_return (invoke "shr_u" (i64.const 0x8000000000000000) (i64.const 1)) (i64.const 0x4000000000000000))
(assert_return (invoke "shr_u" (i64.const 0x4000000000000000) (i64.const 1)) (i64.const 0x2000000000000000))
(assert_return (invoke "shr_u" (i64.const 1) (i64.const 64)) (i64.const 1))
(assert_return (invoke "shr_u" (i64.const 1) (i64.const 65)) (i64.const 0))
(assert_return (invoke "shr_u" (i64.const 1) (i64.const -1)) (i64.const 0))
(assert_return (invoke "shr_u" (i64.const 1) (i64.const 0x7fffffffffffffff)) (i64.const 0))
(assert_return (invoke "shr_u" (i64.const 1) (i64.const 0x8000000000000000)) (i64.const 1))
(assert_return (invoke "shr_u" (i64.const 0x8000000000000000) (i64.const 63)) (i64.const 1))
(assert_return (invoke "shr_u" (i64.const -1) (i64.const 64)) (i64.const -1))
(assert_return (invoke "shr_u" (i64.const -1) (i64.const 65)) (i64.const 0x7fffffffffffffff))
(assert_return (invoke "shr_u" (i64.const -1) (i64.const -1)) (i64.const 1))
(assert_return (invoke "shr_u" (i64.const -1) (i64.const 0x7fffffffffffffff)) (i64.const 1))
(assert_return (invoke "shr_u" (i64.const -1) (i64.const 0x8000000000000000)) (i64.const -1))
(assert_return (invoke "rotl" (i64.const 1) (i64.const 1)) (i64.const 2))
(assert_return (invoke "rotl" (i64.const 1) (i64.const 0)) (i64.const 1))
(assert_return (invoke "rotl" (i64.const -1) (i64.const 1)) (i64.const -1))
(assert_return (invoke "rotl" (i64.const 0xabd1234ef567809c) (i64.const 63)) (i64.const 0x55e891a77ab3c04e))
(assert_return (invoke "rotl" (i64.const 0xabd1234ef567809c) (i64.const 0x800000000000003f)) (i64.const 0x55e891a77ab3c04e))
(assert_return (invoke "rotr" (i64.const 1) (i64.const 1)) (i64.const 0x8000000000000000))
(assert_return (invoke "rotr" (i64.const 1) (i64.const 0)) (i64.const 1))
(assert_return (invoke "rotr" (i64.const -1) (i64.const 1)) (i64.const -1))
(assert_return (invoke "rotr" (i64.const 0xabcd1234ef567809) (i64.const 53)) (i64.const 0x6891a77ab3c04d5e))
(assert_return (invoke "rotr" (i64.const 0xabcd1234ef567809) (i64.const 0x35)) (i64.const 0x6891a77ab3c04d5e))
(assert_return (invoke "rotr" (i64.const 0xabcd1234ef567809) (i64.const 0xf5)) (i64.const 0x6891a77ab3c04d5e))
(assert_return (invoke "clz" (i64.const 0xffffffffffffffff)) (i64.const 0))
(assert_return (invoke "clz" (i64.const 0)) (i64.const 64))
(assert_return (invoke "clz" (i64.const 0x00008000)) (i64.const 48))
(assert_return (invoke "clz" (i64.const 0xff)) (i64.const 56))
(assert_return (invoke "clz" (i64.const 0x8000000000000000)) (i64.const 0))
(assert_return (invoke "clz" (i64.const 1)) (i64.const 63))
(assert_return (invoke "clz" (i64.const 2)) (i64.const 62))
(assert_return (invoke "ctz" (i64.const -1)) (i64.const 0))
(assert_return (invoke "ctz" (i64.const 0)) (i64.const 64))
(assert_return (invoke "ctz" (i64.const 0x00008000)) (i64.const 15))
(assert_return (invoke "ctz" (i64.const 0x00010000)) (i64.const 16))
(assert_return (invoke "ctz" (i64.const 0x8000000000000000)) (i64.const 63))
(assert_return (invoke "popcnt" (i64.const -1)) (i64.const 64))
(assert_return (invoke "popcnt" (i64.const 0)) (i64.const 0))
(assert_return (invoke "popcnt" (i64.const 0x00008000)) (i64.const 1))
(assert_return (invoke "popcnt" (i64.const 0x8000800080008000)) (i64.const 4))
(assert_return (invoke "popcnt" (i64.const 0xAAAAAAAA55555555)) (i64.const 32))
(assert_return (invoke "popcnt" (i64.const 0x99999999AAAAAAAA)) (i64.const 32))
(assert_return (invoke "popcnt" (i64.const 0xDEADBEEFDEADBEEF)) (i64.const 48))
(assert_return (invoke "eqz" (i64.const 0)) (i32.const 1))
(assert_return (invoke "eqz" (i64.const 1)) (i32.const 0))
(assert_return (invoke "eqz" (i64.const 0x8000000000000000)) (i32.const 0))
(assert_return (invoke "eq" (i64.const 0) (i64.const 0)) (i32.const 1))
(assert_return (invoke "eq" (i64.const 1) (i64.const 1)) (i32.const 1))
(assert_return (invoke "eq" (i64.const -1) (i64.const 1)) (i32.const 0))
(assert_return (invoke "eq" (i64.const 0x8000000000000000) (i64.const 0x8000000000000000)) (i32.const 1))
(assert_return (invoke "eq" (i64.const 0x7fffffffffffffff) (i64.const 0x7fffffffffffffff)) (i32.const 1))
(assert_return (invoke "eq" (i64.const -1) (i64.const -1)) (i32.const 1))
(assert_return (invoke "eq" (i64.const 1) (i64.const 0)) (i32.const 0))
(assert_return (invoke "eq" (i64.const 0x8000000000000000) (i64.const 0)) (i32.const 0))
(assert_return (invoke "eq" (i64.const 0x8000000000000000) (i64.const -1)) (i32.const 0))
(assert_return (invoke "eq" (i64.const 0x8000000000000000) (i64.const 0x7fffffffffffffff)) (i32.const 0))
(assert_return (invoke "ne" (i64.const 0) (i64.const 0)) (i32.const 0))
(assert_return (invoke "ne" (i64.const 1) (i64.const 1)) (i32.const 0))
(assert_return (invoke "ne" (i64.const -1) (i64.const 1)) (i32.const 1))
(assert_return (invoke "ne" (i64.const 0x8000000000000000) (i64.const 0x8000000000000000)) (i32.const 0))
(assert_return (invoke "ne" (i64.const 0x7fffffffffffffff) (i64.const 0x7fffffffffffffff)) (i32.const 0))
(assert_return (invoke "ne" (i64.const -1) (i64.const -1)) (i32.const 0))
(assert_return (invoke "ne" (i64.const 1) (i64.const 0)) (i32.const 1))
(assert_return (invoke "ne" (i64.const 0x8000000000000000) (i64.const 0)) (i32.const 1))
(assert_return (invoke "ne" (i64.const 0x8000000000000000) (i64.const -1)) (i32.const 1))
(assert_return (invoke "ne" (i64.const 0x8000000000000000) (i64.const 0x7fffffffffffffff)) (i32.const 1))
(assert_return (invoke "lt_s" (i64.const 0) (i64.const 0)) (i32.const 0))
(assert_return (invoke "lt_s" (i64.const 1) (i64.const 1)) (i32.const 0))
(assert_return (invoke "lt_s" (i64.const -1) (i64.const 1)) (i32.const 1))
(assert_return (invoke "lt_s" (i64.const 0x8000000000000000) (i64.const 0x8000000000000000)) (i32.const 0))
(assert_return (invoke "lt_s" (i64.const 0x7fffffffffffffff) (i64.const 0x7fffffffffffffff)) (i32.const 0))
(assert_return (invoke "lt_s" (i64.const -1) (i64.const -1)) (i32.const 0))
(assert_return (invoke "lt_s" (i64.const 1) (i64.const 0)) (i32.const 0))
(assert_return (invoke "lt_s" (i64.const 0) (i64.const 1)) (i32.const 1))
(assert_return (invoke "lt_s" (i64.const 0x8000000000000000) (i64.const 0)) (i32.const 1))
(assert_return (invoke "lt_s" (i64.const 0) (i64.const 0x8000000000000000)) (i32.const 0))
(assert_return (invoke "lt_s" (i64.const 0x8000000000000000) (i64.const -1)) (i32.const 1))
(assert_return (invoke "lt_s" (i64.const -1) (i64.const 0x8000000000000000)) (i32.const 0))
(assert_return (invoke "lt_s" (i64.const 0x8000000000000000) (i64.const 0x7fffffffffffffff)) (i32.const 1))
(assert_return (invoke "lt_s" (i64.const 0x7fffffffffffffff) (i64.const 0x8000000000000000)) (i32.const 0))
(assert_return (invoke "lt_u" (i64.const 0) (i64.const 0)) (i32.const 0))
(assert_return (invoke "lt_u" (i64.const 1) (i64.const 1)) (i32.const 0))
(assert_return (invoke "lt_u" (i64.const -1) (i64.const 1)) (i32.const 0))
(assert_return (invoke "lt_u" (i64.const 0x8000000000000000) (i64.const 0x8000000000000000)) (i32.const 0))
(assert_return (invoke "lt_u" (i64.const 0x7fffffffffffffff) (i64.const 0x7fffffffffffffff)) (i32.const 0))
(assert_return (invoke "lt_u" (i64.const -1) (i64.const -1)) (i32.const 0))
(assert_return (invoke "lt_u" (i64.const 1) (i64.const 0)) (i32.const 0))
(assert_return (invoke "lt_u" (i64.const 0) (i64.const 1)) (i32.const 1))
(assert_return (invoke "lt_u" (i64.const 0x8000000000000000) (i64.const 0)) (i32.const 0))
(assert_return (invoke "lt_u" (i64.const 0) (i64.const 0x8000000000000000)) (i32.const 1))
(assert_return (invoke "lt_u" (i64.const 0x8000000000000000) (i64.const -1)) (i32.const 1))
(assert_return (invoke "lt_u" (i64.const -1) (i64.const 0x8000000000000000)) (i32.const 0))
(assert_return (invoke "lt_u" (i64.const 0x8000000000000000) (i64.const 0x7fffffffffffffff)) (i32.const 0))
(assert_return (invoke "lt_u" (i64.const 0x7fffffffffffffff) (i64.const 0x8000000000000000)) (i32.const 1))
(assert_return (invoke "le_s" (i64.const 0) (i64.const 0)) (i32.const 1))
(assert_return (invoke "le_s" (i64.const 1) (i64.const 1)) (i32.const 1))
(assert_return (invoke "le_s" (i64.const -1) (i64.const 1)) (i32.const 1))
(assert_return (invoke "le_s" (i64.const 0x8000000000000000) (i64.const 0x8000000000000000)) (i32.const 1))
(assert_return (invoke "le_s" (i64.const 0x7fffffffffffffff) (i64.const 0x7fffffffffffffff)) (i32.const 1))
(assert_return (invoke "le_s" (i64.const -1) (i64.const -1)) (i32.const 1))
(assert_return (invoke "le_s" (i64.const 1) (i64.const 0)) (i32.const 0))
(assert_return (invoke "le_s" (i64.const 0) (i64.const 1)) (i32.const 1))
(assert_return (invoke "le_s" (i64.const 0x8000000000000000) (i64.const 0)) (i32.const 1))
(assert_return (invoke "le_s" (i64.const 0) (i64.const 0x8000000000000000)) (i32.const 0))
(assert_return (invoke "le_s" (i64.const 0x8000000000000000) (i64.const -1)) (i32.const 1))
(assert_return (invoke "le_s" (i64.const -1) (i64.const 0x8000000000000000)) (i32.const 0))
(assert_return (invoke "le_s" (i64.const 0x8000000000000000) (i64.const 0x7fffffffffffffff)) (i32.const 1))
(assert_return (invoke "le_s" (i64.const 0x7fffffffffffffff) (i64.const 0x8000000000000000)) (i32.const 0))
(assert_return (invoke "le_u" (i64.const 0) (i64.const 0)) (i32.const 1))
(assert_return (invoke "le_u" (i64.const 1) (i64.const 1)) (i32.const 1))
(assert_return (invoke "le_u" (i64.const -1) (i64.const 1)) (i32.const 0))
(assert_return (invoke "le_u" (i64.const 0x8000000000000000) (i64.const 0x8000000000000000)) (i32.const 1))
(assert_return (invoke "le_u" (i64.const 0x7fffffffffffffff) (i64.const 0x7fffffffffffffff)) (i32.const 1))
(assert_return (invoke "le_u" (i64.const -1) (i64.const -1)) (i32.const 1))
(assert_return (invoke "le_u" (i64.const 1) (i64.const 0)) (i32.const 0))
(assert_return (invoke "le_u" (i64.const 0) (i64.const 1)) (i32.const 1))
(assert_return (invoke "le_u" (i64.const 0x8000000000000000) (i64.const 0)) (i32.const 0))
(assert_return (invoke "le_u" (i64.const 0) (i64.const 0x8000000000000000)) (i32.const 1))
(assert_return (invoke "le_u" (i64.const 0x8000000000000000) (i64.const -1)) (i32.const 1))
(assert_return (invoke "le_u" (i64.const -1) (i64.const 0x8000000000000000)) (i32.const 0))
(assert_return (invoke "le_u" (i64.const 0x8000000000000000) (i64.const 0x7fffffffffffffff)) (i32.const 0))
(assert_return (invoke "le_u" (i64.const 0x7fffffffffffffff) (i64.const 0x8000000000000000)) (i32.const 1))
(assert_return (invoke "gt_s" (i64.const 0) (i64.const 0)) (i32.const 0))
(assert_return (invoke "gt_s" (i64.const 1) (i64.const 1)) (i32.const 0))
(assert_return (invoke "gt_s" (i64.const -1) (i64.const 1)) (i32.const 0))
(assert_return (invoke "gt_s" (i64.const 0x8000000000000000) (i64.const 0x8000000000000000)) (i32.const 0))
(assert_return (invoke "gt_s" (i64.const 0x7fffffffffffffff) (i64.const 0x7fffffffffffffff)) (i32.const 0))
(assert_return (invoke "gt_s" (i64.const -1) (i64.const -1)) (i32.const 0))
(assert_return (invoke "gt_s" (i64.const 1) (i64.const 0)) (i32.const 1))
(assert_return (invoke "gt_s" (i64.const 0) (i64.const 1)) (i32.const 0))
(assert_return (invoke "gt_s" (i64.const 0x8000000000000000) (i64.const 0)) (i32.const 0))
(assert_return (invoke "gt_s" (i64.const 0) (i64.const 0x8000000000000000)) (i32.const 1))
(assert_return (invoke "gt_s" (i64.const 0x8000000000000000) (i64.const -1)) (i32.const 0))
(assert_return (invoke "gt_s" (i64.const -1) (i64.const 0x8000000000000000)) (i32.const 1))
(assert_return (invoke "gt_s" (i64.const 0x8000000000000000) (i64.const 0x7fffffffffffffff)) (i32.const 0))
(assert_return (invoke "gt_s" (i64.const 0x7fffffffffffffff) (i64.const 0x8000000000000000)) (i32.const 1))
(assert_return (invoke "gt_u" (i64.const 0) (i64.const 0)) (i32.const 0))
(assert_return (invoke "gt_u" (i64.const 1) (i64.const 1)) (i32.const 0))
(assert_return (invoke "gt_u" (i64.const -1) (i64.const 1)) (i32.const 1))
(assert_return (invoke "gt_u" (i64.const 0x8000000000000000) (i64.const 0x8000000000000000)) (i32.const 0))
(assert_return (invoke "gt_u" (i64.const 0x7fffffffffffffff) (i64.const 0x7fffffffffffffff)) (i32.const 0))
(assert_return (invoke "gt_u" (i64.const -1) (i64.const -1)) (i32.const 0))
(assert_return (invoke "gt_u" (i64.const 1) (i64.const 0)) (i32.const 1))
(assert_return (invoke "gt_u" (i64.const 0) (i64.const 1)) (i32.const 0))
(assert_return (invoke "gt_u" (i64.const 0x8000000000000000) (i64.const 0)) (i32.const 1))
(assert_return (invoke "gt_u" (i64.const 0) (i64.const 0x8000000000000000)) (i32.const 0))
(assert_return (invoke "gt_u" (i64.const 0x8000000000000000) (i64.const -1)) (i32.const 0))
(assert_return (invoke "gt_u" (i64.const -1) (i64.const 0x8000000000000000)) (i32.const 1))
(assert_return (invoke "gt_u" (i64.const 0x8000000000000000) (i64.const 0x7fffffffffffffff)) (i32.const 1))
(assert_return (invoke "gt_u" (i64.const 0x7fffffffffffffff) (i64.const 0x8000000000000000)) (i32.const 0))
(assert_return (invoke "ge_s" (i64.const 0) (i64.const 0)) (i32.const 1))
(assert_return (invoke "ge_s" (i64.const 1) (i64.const 1)) (i32.const 1))
(assert_return (invoke "ge_s" (i64.const -1) (i64.const 1)) (i32.const 0))
(assert_return (invoke "ge_s" (i64.const 0x8000000000000000) (i64.const 0x8000000000000000)) (i32.const 1))
(assert_return (invoke "ge_s" (i64.const 0x7fffffffffffffff) (i64.const 0x7fffffffffffffff)) (i32.const 1))
(assert_return (invoke "ge_s" (i64.const -1) (i64.const -1)) (i32.const 1))
(assert_return (invoke "ge_s" (i64.const 1) (i64.const 0)) (i32.const 1))
(assert_return (invoke "ge_s" (i64.const 0) (i64.const 1)) (i32.const 0))
(assert_return (invoke "ge_s" (i64.const 0x8000000000000000) (i64.const 0)) (i32.const 0))
(assert_return (invoke "ge_s" (i64.const 0) (i64.const 0x8000000000000000)) (i32.const 1))
(assert_return (invoke "ge_s" (i64.const 0x8000000000000000) (i64.const -1)) (i32.const 0))
(assert_return (invoke "ge_s" (i64.const -1) (i64.const 0x8000000000000000)) (i32.const 1))
(assert_return (invoke "ge_s" (i64.const 0x8000000000000000) (i64.const 0x7fffffffffffffff)) (i32.const 0))
(assert_return (invoke "ge_s" (i64.const 0x7fffffffffffffff) (i64.const 0x8000000000000000)) (i32.const 1))
(assert_return (invoke "ge_u" (i64.const 0) (i64.const 0)) (i32.const 1))
(assert_return (invoke "ge_u" (i64.const 1) (i64.const 1)) (i32.const 1))
(assert_return (invoke "ge_u" (i64.const -1) (i64.const 1)) (i32.const 1))
(assert_return (invoke "ge_u" (i64.const 0x8000000000000000) (i64.const 0x8000000000000000)) (i32.const 1))
(assert_return (invoke "ge_u" (i64.const 0x7fffffffffffffff) (i64.const 0x7fffffffffffffff)) (i32.const 1))
(assert_return (invoke "ge_u" (i64.const -1) (i64.const -1)) (i32.const 1))
(assert_return (invoke "ge_u" (i64.const 1) (i64.const 0)) (i32.const 1))
(assert_return (invoke "ge_u" (i64.const 0) (i64.const 1)) (i32.const 0))
(assert_return (invoke "ge_u" (i64.const 0x8000000000000000) (i64.const 0)) (i32.const 1))
(assert_return (invoke "ge_u" (i64.const 0) (i64.const 0x8000000000000000)) (i32.const 0))
(assert_return (invoke "ge_u" (i64.const 0x8000000000000000) (i64.const -1)) (i32.const 0))
(assert_return (invoke "ge_u" (i64.const -1) (i64.const 0x8000000000000000)) (i32.const 1))
(assert_return (invoke "ge_u" (i64.const 0x8000000000000000) (i64.const 0x7fffffffffffffff)) (i32.const 1))
(assert_return (invoke "ge_u" (i64.const 0x7fffffffffffffff) (i64.const 0x8000000000000000)) (i32.const 0))

14
js/src/jit-test/tests/wasm/spec/import_tests.sh Executable file
View File

@ -0,0 +1,14 @@
#!/bin/bash
rm -rf ./*.wast ./list.js
git clone https://github.com/WebAssembly/spec spec
mv spec/ml-proto/test/*.wast ./
rm -rf spec/
echo "// This is automatically generated by import_tests.sh. Do no modify by hand!" > list.js
echo "var specTests = [];" >> list.js
for i in $(ls *.wast);
do
echo "specTests.push(\"$i\");" >> list.js
done;

26
js/src/jit-test/tests/wasm/spec/imports.wast Normal file
View File

@ -0,0 +1,26 @@
(module
(import $print_i32 "spectest" "print" (param i32))
(import $print_i64 "spectest" "print" (param i64))
(import $print_i32_f32 "spectest" "print" (param i32 f32))
(import $print_i64_f64 "spectest" "print" (param i64 f64))
(func $print32 (param $i i32)
(call_import $print_i32_f32
(i32.add (get_local $i) (i32.const 1))
(f32.const 42)
)
(call_import $print_i32 (get_local $i))
)
(func $print64 (param $i i64)
(call_import $print_i64_f64
(i64.add (get_local $i) (i64.const 1))
(f64.const 53)
)
(call_import $print_i64 (get_local $i))
)
(export "print32" $print32)
(export "print64" $print64)
)
(assert_return (invoke "print32" (i32.const 13)))
(assert_return (invoke "print64" (i64.const 24)))

330
js/src/jit-test/tests/wasm/spec/int_exprs.wast Normal file
View File

@ -0,0 +1,330 @@
;; Test interesting integer "expressions". These tests contain code
;; patterns which tempt common value-changing optimizations.
;; Test that x+1<y+1 is not folded to x<y
(module
(func $i32.no_fold_cmp_s_offset (param $x i32) (param $y i32) (result i32)
(i32.lt_s (i32.add (get_local $x) (i32.const 1)) (i32.add (get_local $y) (i32.const 1))))
(export "i32.no_fold_cmp_s_offset" $i32.no_fold_cmp_s_offset)
(func $i32.no_fold_cmp_u_offset (param $x i32) (param $y i32) (result i32)
(i32.lt_u (i32.add (get_local $x) (i32.const 1)) (i32.add (get_local $y) (i32.const 1))))
(export "i32.no_fold_cmp_u_offset" $i32.no_fold_cmp_u_offset)
(func $i64.no_fold_cmp_s_offset (param $x i64) (param $y i64) (result i32)
(i64.lt_s (i64.add (get_local $x) (i64.const 1)) (i64.add (get_local $y) (i64.const 1))))
(export "i64.no_fold_cmp_s_offset" $i64.no_fold_cmp_s_offset)
(func $i64.no_fold_cmp_u_offset (param $x i64) (param $y i64) (result i32)
(i64.lt_u (i64.add (get_local $x) (i64.const 1)) (i64.add (get_local $y) (i64.const 1))))
(export "i64.no_fold_cmp_u_offset" $i64.no_fold_cmp_u_offset)
)
(assert_return (invoke "i32.no_fold_cmp_s_offset" (i32.const 0x7fffffff) (i32.const 0)) (i32.const 1))
(assert_return (invoke "i32.no_fold_cmp_u_offset" (i32.const 0xffffffff) (i32.const 0)) (i32.const 1))
(assert_return (invoke "i64.no_fold_cmp_s_offset" (i64.const 0x7fffffffffffffff) (i64.const 0)) (i32.const 1))
(assert_return (invoke "i64.no_fold_cmp_u_offset" (i64.const 0xffffffffffffffff) (i64.const 0)) (i32.const 1))
;; Test that wrap(extend_s(x)) is not folded to x
(module
(func $i64.no_fold_wrap_extend_s (param $x i64) (result i64)
(i64.extend_s/i32 (i32.wrap/i64 (get_local $x))))
(export "i64.no_fold_wrap_extend_s" $i64.no_fold_wrap_extend_s)
)
(assert_return (invoke "i64.no_fold_wrap_extend_s" (i64.const 0x0010203040506070)) (i64.const 0x0000000040506070))
(assert_return (invoke "i64.no_fold_wrap_extend_s" (i64.const 0x00a0b0c0d0e0f0a0)) (i64.const 0xffffffffd0e0f0a0))
;; Test that wrap(extend_u(x)) is not folded to x
(module
(func $i64.no_fold_wrap_extend_u (param $x i64) (result i64)
(i64.extend_u/i32 (i32.wrap/i64 (get_local $x))))
(export "i64.no_fold_wrap_extend_u" $i64.no_fold_wrap_extend_u)
)
(assert_return (invoke "i64.no_fold_wrap_extend_u" (i64.const 0x0010203040506070)) (i64.const 0x0000000040506070))
;; Test that x<<n>>n is not folded to x
(module
(func $i32.no_fold_shl_shr_s (param $x i32) (result i32)
(i32.shr_s (i32.shl (get_local $x) (i32.const 1)) (i32.const 1)))
(export "i32.no_fold_shl_shr_s" $i32.no_fold_shl_shr_s)
(func $i32.no_fold_shl_shr_u (param $x i32) (result i32)
(i32.shr_u (i32.shl (get_local $x) (i32.const 1)) (i32.const 1)))
(export "i32.no_fold_shl_shr_u" $i32.no_fold_shl_shr_u)
(func $i64.no_fold_shl_shr_s (param $x i64) (result i64)
(i64.shr_s (i64.shl (get_local $x) (i64.const 1)) (i64.const 1)))
(export "i64.no_fold_shl_shr_s" $i64.no_fold_shl_shr_s)
(func $i64.no_fold_shl_shr_u (param $x i64) (result i64)
(i64.shr_u (i64.shl (get_local $x) (i64.const 1)) (i64.const 1)))
(export "i64.no_fold_shl_shr_u" $i64.no_fold_shl_shr_u)
)
(assert_return (invoke "i32.no_fold_shl_shr_s" (i32.const 0x80000000)) (i32.const 0))
(assert_return (invoke "i32.no_fold_shl_shr_u" (i32.const 0x80000000)) (i32.const 0))
(assert_return (invoke "i64.no_fold_shl_shr_s" (i64.const 0x8000000000000000)) (i64.const 0))
(assert_return (invoke "i64.no_fold_shl_shr_u" (i64.const 0x8000000000000000)) (i64.const 0))
;; Test that x>>n<<n is not folded to x
(module
(func $i32.no_fold_shr_s_shl (param $x i32) (result i32)
(i32.shl (i32.shr_s (get_local $x) (i32.const 1)) (i32.const 1)))
(export "i32.no_fold_shr_s_shl" $i32.no_fold_shr_s_shl)
(func $i32.no_fold_shr_u_shl (param $x i32) (result i32)
(i32.shl (i32.shr_u (get_local $x) (i32.const 1)) (i32.const 1)))
(export "i32.no_fold_shr_u_shl" $i32.no_fold_shr_u_shl)
(func $i64.no_fold_shr_s_shl (param $x i64) (result i64)
(i64.shl (i64.shr_s (get_local $x) (i64.const 1)) (i64.const 1)))
(export "i64.no_fold_shr_s_shl" $i64.no_fold_shr_s_shl)
(func $i64.no_fold_shr_u_shl (param $x i64) (result i64)
(i64.shl (i64.shr_u (get_local $x) (i64.const 1)) (i64.const 1)))
(export "i64.no_fold_shr_u_shl" $i64.no_fold_shr_u_shl)
)
(assert_return (invoke "i32.no_fold_shr_s_shl" (i32.const 1)) (i32.const 0))
(assert_return (invoke "i32.no_fold_shr_u_shl" (i32.const 1)) (i32.const 0))
(assert_return (invoke "i64.no_fold_shr_s_shl" (i64.const 1)) (i64.const 0))
(assert_return (invoke "i64.no_fold_shr_u_shl" (i64.const 1)) (i64.const 0))
;; Test that x/n*n is not folded to x
(module
(func $i32.no_fold_div_s_mul (param $x i32) (result i32)
(i32.mul (i32.div_s (get_local $x) (i32.const 6)) (i32.const 6)))
(export "i32.no_fold_div_s_mul" $i32.no_fold_div_s_mul)
(func $i32.no_fold_div_u_mul (param $x i32) (result i32)
(i32.mul (i32.div_u (get_local $x) (i32.const 6)) (i32.const 6)))
(export "i32.no_fold_div_u_mul" $i32.no_fold_div_u_mul)
(func $i64.no_fold_div_s_mul (param $x i64) (result i64)
(i64.mul (i64.div_s (get_local $x) (i64.const 6)) (i64.const 6)))
(export "i64.no_fold_div_s_mul" $i64.no_fold_div_s_mul)
(func $i64.no_fold_div_u_mul (param $x i64) (result i64)
(i64.mul (i64.div_u (get_local $x) (i64.const 6)) (i64.const 6)))
(export "i64.no_fold_div_u_mul" $i64.no_fold_div_u_mul)
)
(assert_return (invoke "i32.no_fold_div_s_mul" (i32.const 1)) (i32.const 0))
(assert_return (invoke "i32.no_fold_div_u_mul" (i32.const 1)) (i32.const 0))
(assert_return (invoke "i64.no_fold_div_s_mul" (i64.const 1)) (i64.const 0))
(assert_return (invoke "i64.no_fold_div_u_mul" (i64.const 1)) (i64.const 0))
;; Test that x*n/n is not folded to x
(module
(func $i32.no_fold_mul_div_s (param $x i32) (result i32)
(i32.div_s (i32.mul (get_local $x) (i32.const 6)) (i32.const 6)))
(export "i32.no_fold_mul_div_s" $i32.no_fold_mul_div_s)
(func $i32.no_fold_mul_div_u (param $x i32) (result i32)
(i32.div_u (i32.mul (get_local $x) (i32.const 6)) (i32.const 6)))
(export "i32.no_fold_mul_div_u" $i32.no_fold_mul_div_u)
(func $i64.no_fold_mul_div_s (param $x i64) (result i64)
(i64.div_s (i64.mul (get_local $x) (i64.const 6)) (i64.const 6)))
(export "i64.no_fold_mul_div_s" $i64.no_fold_mul_div_s)
(func $i64.no_fold_mul_div_u (param $x i64) (result i64)
(i64.div_u (i64.mul (get_local $x) (i64.const 6)) (i64.const 6)))
(export "i64.no_fold_mul_div_u" $i64.no_fold_mul_div_u)
)
(assert_return (invoke "i32.no_fold_mul_div_s" (i32.const 0x80000000)) (i32.const 0))
(assert_return (invoke "i32.no_fold_mul_div_u" (i32.const 0x80000000)) (i32.const 0))
(assert_return (invoke "i64.no_fold_mul_div_s" (i64.const 0x8000000000000000)) (i64.const 0))
(assert_return (invoke "i64.no_fold_mul_div_u" (i64.const 0x8000000000000000)) (i64.const 0))
;; Test that x/n where n is a known power of 2 is not folded to shr_s
(module
(func $i32.no_fold_div_s_2 (param $x i32) (result i32)
(i32.div_s (get_local $x) (i32.const 2)))
(export "i32.no_fold_div_s_2" $i32.no_fold_div_s_2)
(func $i64.no_fold_div_s_2 (param $x i64) (result i64)
(i64.div_s (get_local $x) (i64.const 2)))
(export "i64.no_fold_div_s_2" $i64.no_fold_div_s_2)
)
(assert_return (invoke "i32.no_fold_div_s_2" (i32.const -11)) (i32.const -5))
(assert_return (invoke "i64.no_fold_div_s_2" (i64.const -11)) (i64.const -5))
;; Test that x%n where n is a known power of 2 is not folded to and
(module
(func $i32.no_fold_rem_s_2 (param $x i32) (result i32)
(i32.rem_s (get_local $x) (i32.const 2)))
(export "i32.no_fold_rem_s_2" $i32.no_fold_rem_s_2)
(func $i64.no_fold_rem_s_2 (param $x i64) (result i64)
(i64.rem_s (get_local $x) (i64.const 2)))
(export "i64.no_fold_rem_s_2" $i64.no_fold_rem_s_2)
)
(assert_return (invoke "i32.no_fold_rem_s_2" (i32.const -11)) (i32.const -1))
(assert_return (invoke "i64.no_fold_rem_s_2" (i64.const -11)) (i64.const -1))
;; Test that x/3 works
(module
(func $i32.div_s_3 (param $x i32) (result i32)
(i32.div_s (get_local $x) (i32.const 3)))
(export "i32.div_s_3" $i32.div_s_3)
(func $i32.div_u_3 (param $x i32) (result i32)
(i32.div_u (get_local $x) (i32.const 3)))
(export "i32.div_u_3" $i32.div_u_3)
(func $i64.div_s_3 (param $x i64) (result i64)
(i64.div_s (get_local $x) (i64.const 3)))
(export "i64.div_s_3" $i64.div_s_3)
(func $i64.div_u_3 (param $x i64) (result i64)
(i64.div_u (get_local $x) (i64.const 3)))
(export "i64.div_u_3" $i64.div_u_3)
)
(assert_return (invoke "i32.div_s_3" (i32.const 71)) (i32.const 23))
(assert_return (invoke "i32.div_s_3" (i32.const 0x60000000)) (i32.const 0x20000000))
(assert_return (invoke "i32.div_u_3" (i32.const 71)) (i32.const 23))
(assert_return (invoke "i32.div_u_3" (i32.const 0xc0000000)) (i32.const 0x40000000))
(assert_return (invoke "i64.div_s_3" (i64.const 71)) (i64.const 23))
(assert_return (invoke "i64.div_s_3" (i64.const 0x3000000000000000)) (i64.const 0x1000000000000000))
(assert_return (invoke "i64.div_u_3" (i64.const 71)) (i64.const 23))
(assert_return (invoke "i64.div_u_3" (i64.const 0xc000000000000000)) (i64.const 0x4000000000000000))
;; Test that x/5 works
(module
(func $i32.div_s_5 (param $x i32) (result i32)
(i32.div_s (get_local $x) (i32.const 5)))
(export "i32.div_s_5" $i32.div_s_5)
(func $i32.div_u_5 (param $x i32) (result i32)
(i32.div_u (get_local $x) (i32.const 5)))
(export "i32.div_u_5" $i32.div_u_5)
(func $i64.div_s_5 (param $x i64) (result i64)
(i64.div_s (get_local $x) (i64.const 5)))
(export "i64.div_s_5" $i64.div_s_5)
(func $i64.div_u_5 (param $x i64) (result i64)
(i64.div_u (get_local $x) (i64.const 5)))
(export "i64.div_u_5" $i64.div_u_5)
)
(assert_return (invoke "i32.div_s_5" (i32.const 71)) (i32.const 14))
(assert_return (invoke "i32.div_s_5" (i32.const 0x50000000)) (i32.const 0x10000000))
(assert_return (invoke "i32.div_u_5" (i32.const 71)) (i32.const 14))
(assert_return (invoke "i32.div_u_5" (i32.const 0xa0000000)) (i32.const 0x20000000))
(assert_return (invoke "i64.div_s_5" (i64.const 71)) (i64.const 14))
(assert_return (invoke "i64.div_s_5" (i64.const 0x5000000000000000)) (i64.const 0x1000000000000000))
(assert_return (invoke "i64.div_u_5" (i64.const 71)) (i64.const 14))
(assert_return (invoke "i64.div_u_5" (i64.const 0xa000000000000000)) (i64.const 0x2000000000000000))
;; Test that x/7 works
(module
(func $i32.div_s_7 (param $x i32) (result i32)
(i32.div_s (get_local $x) (i32.const 7)))
(export "i32.div_s_7" $i32.div_s_7)
(func $i32.div_u_7 (param $x i32) (result i32)
(i32.div_u (get_local $x) (i32.const 7)))
(export "i32.div_u_7" $i32.div_u_7)
(func $i64.div_s_7 (param $x i64) (result i64)
(i64.div_s (get_local $x) (i64.const 7)))
(export "i64.div_s_7" $i64.div_s_7)
(func $i64.div_u_7 (param $x i64) (result i64)
(i64.div_u (get_local $x) (i64.const 7)))
(export "i64.div_u_7" $i64.div_u_7)
)
(assert_return (invoke "i32.div_s_7" (i32.const 71)) (i32.const 10))
(assert_return (invoke "i32.div_s_7" (i32.const 0x70000000)) (i32.const 0x10000000))
(assert_return (invoke "i32.div_u_7" (i32.const 71)) (i32.const 10))
(assert_return (invoke "i32.div_u_7" (i32.const 0xe0000000)) (i32.const 0x20000000))
(assert_return (invoke "i64.div_s_7" (i64.const 71)) (i64.const 10))
(assert_return (invoke "i64.div_s_7" (i64.const 0x7000000000000000)) (i64.const 0x1000000000000000))
(assert_return (invoke "i64.div_u_7" (i64.const 71)) (i64.const 10))
(assert_return (invoke "i64.div_u_7" (i64.const 0xe000000000000000)) (i64.const 0x2000000000000000))
;; Test that x%3 works
(module
(func $i32.rem_s_3 (param $x i32) (result i32)
(i32.rem_s (get_local $x) (i32.const 3)))
(export "i32.rem_s_3" $i32.rem_s_3)
(func $i32.rem_u_3 (param $x i32) (result i32)
(i32.rem_u (get_local $x) (i32.const 3)))
(export "i32.rem_u_3" $i32.rem_u_3)
(func $i64.rem_s_3 (param $x i64) (result i64)
(i64.rem_s (get_local $x) (i64.const 3)))
(export "i64.rem_s_3" $i64.rem_s_3)
(func $i64.rem_u_3 (param $x i64) (result i64)
(i64.rem_u (get_local $x) (i64.const 3)))
(export "i64.rem_u_3" $i64.rem_u_3)
)
(assert_return (invoke "i32.rem_s_3" (i32.const 71)) (i32.const 2))
(assert_return (invoke "i32.rem_s_3" (i32.const 0x60000000)) (i32.const 0))
(assert_return (invoke "i32.rem_u_3" (i32.const 71)) (i32.const 2))
(assert_return (invoke "i32.rem_u_3" (i32.const 0xc0000000)) (i32.const 0))
(assert_return (invoke "i64.rem_s_3" (i64.const 71)) (i64.const 2))
(assert_return (invoke "i64.rem_s_3" (i64.const 0x3000000000000000)) (i64.const 0))
(assert_return (invoke "i64.rem_u_3" (i64.const 71)) (i64.const 2))
(assert_return (invoke "i64.rem_u_3" (i64.const 0xc000000000000000)) (i64.const 0))
;; Test that x%5 works
(module
(func $i32.rem_s_5 (param $x i32) (result i32)
(i32.rem_s (get_local $x) (i32.const 5)))
(export "i32.rem_s_5" $i32.rem_s_5)
(func $i32.rem_u_5 (param $x i32) (result i32)
(i32.rem_u (get_local $x) (i32.const 5)))
(export "i32.rem_u_5" $i32.rem_u_5)
(func $i64.rem_s_5 (param $x i64) (result i64)
(i64.rem_s (get_local $x) (i64.const 5)))
(export "i64.rem_s_5" $i64.rem_s_5)
(func $i64.rem_u_5 (param $x i64) (result i64)
(i64.rem_u (get_local $x) (i64.const 5)))
(export "i64.rem_u_5" $i64.rem_u_5)
)
(assert_return (invoke "i32.rem_s_5" (i32.const 71)) (i32.const 1))
(assert_return (invoke "i32.rem_s_5" (i32.const 0x50000000)) (i32.const 0))
(assert_return (invoke "i32.rem_u_5" (i32.const 71)) (i32.const 1))
(assert_return (invoke "i32.rem_u_5" (i32.const 0xa0000000)) (i32.const 0))
(assert_return (invoke "i64.rem_s_5" (i64.const 71)) (i64.const 1))
(assert_return (invoke "i64.rem_s_5" (i64.const 0x5000000000000000)) (i64.const 0))
(assert_return (invoke "i64.rem_u_5" (i64.const 71)) (i64.const 1))
(assert_return (invoke "i64.rem_u_5" (i64.const 0xa000000000000000)) (i64.const 0))
;; Test that x%7 works
(module
(func $i32.rem_s_7 (param $x i32) (result i32)
(i32.rem_s (get_local $x) (i32.const 7)))
(export "i32.rem_s_7" $i32.rem_s_7)
(func $i32.rem_u_7 (param $x i32) (result i32)
(i32.rem_u (get_local $x) (i32.const 7)))
(export "i32.rem_u_7" $i32.rem_u_7)
(func $i64.rem_s_7 (param $x i64) (result i64)
(i64.rem_s (get_local $x) (i64.const 7)))
(export "i64.rem_s_7" $i64.rem_s_7)
(func $i64.rem_u_7 (param $x i64) (result i64)
(i64.rem_u (get_local $x) (i64.const 7)))
(export "i64.rem_u_7" $i64.rem_u_7)
)
(assert_return (invoke "i32.rem_s_7" (i32.const 71)) (i32.const 1))
(assert_return (invoke "i32.rem_s_7" (i32.const 0x70000000)) (i32.const 0))
(assert_return (invoke "i32.rem_u_7" (i32.const 71)) (i32.const 1))
(assert_return (invoke "i32.rem_u_7" (i32.const 0xe0000000)) (i32.const 0))
(assert_return (invoke "i64.rem_s_7" (i64.const 71)) (i64.const 1))
(assert_return (invoke "i64.rem_s_7" (i64.const 0x7000000000000000)) (i64.const 0))
(assert_return (invoke "i64.rem_u_7" (i64.const 71)) (i64.const 1))
(assert_return (invoke "i64.rem_u_7" (i64.const 0xe000000000000000)) (i64.const 0))

61
js/src/jit-test/tests/wasm/spec/int_literals.wast Normal file
View File

@ -0,0 +1,61 @@
(module
(func $i32.test (result i32) (return (i32.const 0x0bAdD00D)))
(func $i32.umax (result i32) (return (i32.const 0xffffffff)))
(func $i32.smax (result i32) (return (i32.const 0x7fffffff)))
(func $i32.neg_smax (result i32) (return (i32.const -0x7fffffff)))
(func $i32.smin (result i32) (return (i32.const -0x80000000)))
(func $i32.alt_smin (result i32) (return (i32.const 0x80000000)))
(func $i32.inc_smin (result i32) (return (i32.add (i32.const -0x80000000) (i32.const 1))))
(func $i32.neg_zero (result i32) (return (i32.const -0x0)))
(func $i32.not_octal (result i32) (return (i32.const 010)))
(func $i64.test (result i64) (return (i64.const 0x0CABBA6E0ba66a6e)))
(func $i64.umax (result i64) (return (i64.const 0xffffffffffffffff)))
(func $i64.smax (result i64) (return (i64.const 0x7fffffffffffffff)))
(func $i64.neg_smax (result i64) (return (i64.const -0x7fffffffffffffff)))
(func $i64.smin (result i64) (return (i64.const -0x8000000000000000)))
(func $i64.alt_smin (result i64) (return (i64.const 0x8000000000000000)))
(func $i64.inc_smin (result i64) (return (i64.add (i64.const -0x8000000000000000) (i64.const 1))))
(func $i64.neg_zero (result i64) (return (i64.const -0x0)))
(func $i64.not_octal (result i64) (return (i64.const 010)))
(export "i32.test" $i32.test)
(export "i32.umax" $i32.umax)
(export "i32.smax" $i32.smax)
(export "i32.neg_smax" $i32.neg_smax)
(export "i32.smin" $i32.smin)
(export "i32.alt_smin" $i32.alt_smin)
(export "i32.inc_smin" $i32.inc_smin)
(export "i32.neg_zero" $i32.neg_zero)
(export "i32.not_octal" $i32.not_octal)
(export "i64.test" $i64.test)
(export "i64.umax" $i64.umax)
(export "i64.smax" $i64.smax)
(export "i64.neg_smax" $i64.neg_smax)
(export "i64.smin" $i64.smin)
(export "i64.alt_smin" $i64.alt_smin)
(export "i64.inc_smin" $i64.inc_smin)
(export "i64.neg_zero" $i64.neg_zero)
(export "i64.not_octal" $i64.not_octal)
)
(assert_return (invoke "i32.test") (i32.const 195940365))
(assert_return (invoke "i32.umax") (i32.const -1))
(assert_return (invoke "i32.smax") (i32.const 2147483647))
(assert_return (invoke "i32.neg_smax") (i32.const -2147483647))
(assert_return (invoke "i32.smin") (i32.const -2147483648))
(assert_return (invoke "i32.alt_smin") (i32.const -2147483648))
(assert_return (invoke "i32.inc_smin") (i32.const -2147483647))
(assert_return (invoke "i32.neg_zero") (i32.const 0))
(assert_return (invoke "i32.not_octal") (i32.const 10))
(assert_return (invoke "i64.test") (i64.const 913028331277281902))
(assert_return (invoke "i64.umax") (i64.const -1))
(assert_return (invoke "i64.smax") (i64.const 9223372036854775807))
(assert_return (invoke "i64.neg_smax") (i64.const -9223372036854775807))
(assert_return (invoke "i64.smin") (i64.const -9223372036854775808))
(assert_return (invoke "i64.alt_smin") (i64.const -9223372036854775808))
(assert_return (invoke "i64.inc_smin") (i64.const -9223372036854775807))
(assert_return (invoke "i64.neg_zero") (i64.const 0))
(assert_return (invoke "i64.not_octal") (i64.const 10))

298
js/src/jit-test/tests/wasm/spec/labels.wast Normal file
View File

@ -0,0 +1,298 @@
(module
(func $block (result i32)
(block $exit
(br $exit (i32.const 1))
(i32.const 0)
)
)
(func $loop1 (result i32)
(local $i i32)
(set_local $i (i32.const 0))
(loop $exit $cont
(set_local $i (i32.add (get_local $i) (i32.const 1)))
(if (i32.eq (get_local $i) (i32.const 5))
(br $exit (get_local $i))
)
(br $cont)
)
)
(func $loop2 (result i32)
(local $i i32)
(set_local $i (i32.const 0))
(loop $exit $cont
(set_local $i (i32.add (get_local $i) (i32.const 1)))
(if (i32.eq (get_local $i) (i32.const 5))
(br $cont)
)
(if (i32.eq (get_local $i) (i32.const 8))
(br $exit (get_local $i))
)
(set_local $i (i32.add (get_local $i) (i32.const 1)))
(br $cont)
)
)
(func $loop3 (result i32)
(local $i i32)
(set_local $i (i32.const 0))
(loop $exit $cont
(set_local $i (i32.add (get_local $i) (i32.const 1)))
(if (i32.eq (get_local $i) (i32.const 5))
(br $exit (get_local $i))
)
(get_local $i)
)
)
(func $loop4 (param $max i32) (result i32)
(local $i i32)
(set_local $i (i32.const 1))
(loop $exit $cont
(set_local $i (i32.add (get_local $i) (get_local $i)))
(if (i32.gt_u (get_local $i) (get_local $max))
(br $exit (get_local $i))
)
(br $cont)
)
)
(func $loop5 (result i32)
(i32.add (loop $l0 $l1
(i32.const 1)
)
(i32.const 1)
)
)
(func $if (result i32)
(local $i i32)
(set_local $i (i32.const 0))
(block
(if
(i32.const 1)
(then $l (br $l) (set_local $i (i32.const 666)))
)
(set_local $i (i32.add (get_local $i) (i32.const 1)))
(if
(i32.const 1)
(then $l (br $l) (set_local $i (i32.const 666)))
(else (set_local $i (i32.const 888)))
)
(set_local $i (i32.add (get_local $i) (i32.const 1)))
(if
(i32.const 1)
(then $l (br $l) (set_local $i (i32.const 666)))
(else $l (set_local $i (i32.const 888)))
)
(set_local $i (i32.add (get_local $i) (i32.const 1)))
(if
(i32.const 0)
(then (set_local $i (i32.const 888)))
(else $l (br $l) (set_local $i (i32.const 666)))
)
(set_local $i (i32.add (get_local $i) (i32.const 1)))
(if
(i32.const 0)
(then $l (set_local $i (i32.const 888)))
(else $l (br $l) (set_local $i (i32.const 666)))
)
(set_local $i (i32.add (get_local $i) (i32.const 1)))
)
(get_local $i)
)
(func $switch (param i32) (result i32)
(block $ret
(i32.mul (i32.const 10)
(block $exit
(block $0
(block $default
(block $3
(block $2
(block $1
(br_table $0 $1 $2 $3 $default (get_local 0))
) ;; 1
(i32.const 1)
) ;; 2
(br $exit (i32.const 2))
) ;; 3
(br $ret (i32.const 3))
) ;; default
(i32.const 4)
) ;; 0
(i32.const 5)
)
)
)
)
(func $return (param i32) (result i32)
(block $default
(block $1
(block $0
(br_table $0 $1 (get_local 0))
(br $default)
) ;; 0
(return (i32.const 0))
) ;; 1
(i32.const 1)
) ;; default
(i32.const 2)
)
(func $br_if0 (result i32)
(local $i i32)
(set_local $i (i32.const 0))
(block $outer
(block $inner
(br_if $inner (i32.const 0))
(set_local $i (i32.or (get_local $i) (i32.const 0x1)))
(br_if $inner (i32.const 1))
(set_local $i (i32.or (get_local $i) (i32.const 0x2)))
)
(br_if $outer
(set_local $i (i32.or (get_local $i) (i32.const 0x4))) (i32.const 0)
)
(set_local $i (i32.or (get_local $i) (i32.const 0x8)))
(br_if $outer
(set_local $i (i32.or (get_local $i) (i32.const 0x10))) (i32.const 1)
)
(set_local $i (i32.or (get_local $i) (i32.const 0x20)))
)
)
(func $br_if1 (result i32)
(block $l0
(br_if $l0 (block $l1 (br $l1 (i32.const 1))) (i32.const 1))
(i32.const 1)))
(func $br_if2 (result i32)
(block $l0
(if (i32.const 1)
(br $l0
(block $l1
(br $l1 (i32.const 1)))))
(i32.const 1)))
(func $br_if3 (result i32)
(local $i1 i32)
(i32.add
(block $l0
(br_if $l0 (set_local $i1 (i32.const 1)) (set_local $i1 (i32.const 2)))
(i32.const 0)
)
(i32.const 0)
)
(get_local $i1)
)
(func $br_if4
(block $l0 (br_if $l0 (nop) (i32.const 1)))
)
(func $br (result i32)
(block $l0
(if (i32.const 1)
(br $l0 (block $l1 (br $l1 (i32.const 1))))
(block (block $l1 (br $l1 (i32.const 1))) (nop))
)
(i32.const 1)
)
)
(func $misc1 (result i32)
(block $l1 (i32.xor (br $l1 (i32.const 1)) (i32.const 2)))
)
(func $misc2 (result i32)
(i32.xor (return (i32.const 1)) (i32.const 2))
)
(func $redefinition (result i32)
(block $l1
(i32.add (block $l1
(i32.const 2))
(block $l1
(br $l1 (i32.const 3)))))
)
(export "block" $block)
(export "loop1" $loop1)
(export "loop2" $loop2)
(export "loop3" $loop3)
(export "loop4" $loop4)
(export "loop5" $loop5)
(export "if" $if)
(export "switch" $switch)
(export "return" $return)
(export "br_if0" $br_if0)
(export "br_if1" $br_if1)
(export "br_if2" $br_if2)
(export "br_if3" $br_if3)
(export "br_if4" $br_if4)
(export "br" $br)
(export "misc1" $misc1)
(export "misc2" $misc2)
(export "redefinition" $redefinition)
)
(assert_return (invoke "block") (i32.const 1))
(assert_return (invoke "loop1") (i32.const 5))
(assert_return (invoke "loop2") (i32.const 8))
(assert_return (invoke "loop3") (i32.const 1))
(assert_return (invoke "loop4" (i32.const 8)) (i32.const 16))
(assert_return (invoke "loop5") (i32.const 2))
(assert_return (invoke "if") (i32.const 5))
(assert_return (invoke "switch" (i32.const 0)) (i32.const 50))
(assert_return (invoke "switch" (i32.const 1)) (i32.const 20))
(assert_return (invoke "switch" (i32.const 2)) (i32.const 20))
(assert_return (invoke "switch" (i32.const 3)) (i32.const 3))
(assert_return (invoke "switch" (i32.const 4)) (i32.const 50))
(assert_return (invoke "switch" (i32.const 5)) (i32.const 50))
(assert_return (invoke "return" (i32.const 0)) (i32.const 0))
(assert_return (invoke "return" (i32.const 1)) (i32.const 2))
(assert_return (invoke "return" (i32.const 2)) (i32.const 2))
(assert_return (invoke "br_if0") (i32.const 0x1d))
(assert_return (invoke "br_if1") (i32.const 1))
(assert_return (invoke "br_if2") (i32.const 1))
(assert_return (invoke "br_if3") (i32.const 2))
(assert_return (invoke "br_if4"))
(assert_return (invoke "br") (i32.const 1))
(assert_return (invoke "misc1") (i32.const 1))
(assert_return (invoke "misc2") (i32.const 1))
(assert_return (invoke "redefinition") (i32.const 5))
(assert_invalid
(module (func (block $l (f32.neg (br_if $l (i32.const 1))) (nop))))
"type mismatch"
)
(assert_invalid
(module (func (result f32) (block $l (br_if $l (f32.const 0) (i32.const 1)))))
"type mismatch"
)
(assert_invalid
(module (func (result i32) (block $l (br_if $l (f32.const 0) (i32.const 1)))))
"type mismatch"
)
(assert_invalid
(module (func (block $l (f32.neg (br_if $l (f32.const 0) (i32.const 1))))))
"type mismatch"
)
(assert_invalid
(module
(func (param i32) (result i32)
(block $l (f32.neg (br_if $l (f32.const 0) (get_local 0))))
)
)
"type mismatch"
)
(assert_invalid
(module
(func (param i32) (result f32)
(block $l (f32.neg (block $i (br_if $l (f32.const 3) (get_local 0)))))
)
)
"type mismatch"
)

281
js/src/jit-test/tests/wasm/spec/left-to-right.wast Normal file
View File

@ -0,0 +1,281 @@
(module
(memory 1)
(type $i32_T (func (param i32 i32) (result i32)))
(type $i64_T (func (param i64 i64) (result i32)))
(type $f32_T (func (param f32 f32) (result i32)))
(type $f64_T (func (param f64 f64) (result i32)))
(table $i32_t0 $i32_t1 $i64_t0 $i64_t1 $f32_t0 $f32_t1 $f64_t0 $f64_t1)
(func $i32_t0 (type $i32_T) (i32.const -1))
(func $i32_t1 (type $i32_T) (i32.const -2))
(func $i64_t0 (type $i64_T) (i32.const -1))
(func $i64_t1 (type $i64_T) (i32.const -2))
(func $f32_t0 (type $f32_T) (i32.const -1))
(func $f32_t1 (type $f32_T) (i32.const -2))
(func $f64_t0 (type $f64_T) (i32.const -1))
(func $f64_t1 (type $f64_T) (i32.const -2))
;; The idea is: We reset the memory, then the instruction call $*_left,
;; $*_right, $*_another, $*_callee (for indirect calls), and $*_bool (when a
;; boolean value is needed). These functions all call bump, which shifts the
;; memory starting at address 8 up a byte, and then store a unique value at
;; address 8. Then we read the 4-byte value at address 8. It should contain
;; the correct sequence of unique values if the calls were evaluated in the
;; correct order.
(func $reset (i32.store (i32.const 8) (i32.const 0)))
(func $bump
(i32.store8 (i32.const 11) (i32.load8_u (i32.const 10)))
(i32.store8 (i32.const 10) (i32.load8_u (i32.const 9)))
(i32.store8 (i32.const 9) (i32.load8_u (i32.const 8)))
(i32.store8 (i32.const 8) (i32.const -3)))
(func $get (result i32) (i32.load (i32.const 8)))
(func $i32_left (result i32) (call $bump) (i32.store8 (i32.const 8) (i32.const 1)) (i32.const 0))
(func $i32_right (result i32) (call $bump) (i32.store8 (i32.const 8) (i32.const 2)) (i32.const 1))
(func $i32_another (result i32) (call $bump) (i32.store8 (i32.const 8) (i32.const 3)) (i32.const 1))
(func $i32_callee (result i32) (call $bump) (i32.store8 (i32.const 8) (i32.const 4)) (i32.const 0))
(func $i32_bool (result i32) (call $bump) (i32.store8 (i32.const 8) (i32.const 5)) (i32.const 0))
(func $i64_left (result i64) (call $bump) (i32.store8 (i32.const 8) (i32.const 1)) (i64.const 0))
(func $i64_right (result i64) (call $bump) (i32.store8 (i32.const 8) (i32.const 2)) (i64.const 1))
(func $i64_another (result i64) (call $bump) (i32.store8 (i32.const 8) (i32.const 3)) (i64.const 1))
(func $i64_callee (result i32) (call $bump) (i32.store8 (i32.const 8) (i32.const 4)) (i32.const 2))
(func $i64_bool (result i32) (call $bump) (i32.store8 (i32.const 8) (i32.const 5)) (i32.const 0))
(func $f32_left (result f32) (call $bump) (i32.store8 (i32.const 8) (i32.const 1)) (f32.const 0))
(func $f32_right (result f32) (call $bump) (i32.store8 (i32.const 8) (i32.const 2)) (f32.const 1))
(func $f32_another (result f32) (call $bump) (i32.store8 (i32.const 8) (i32.const 3)) (f32.const 1))
(func $f32_callee (result i32) (call $bump) (i32.store8 (i32.const 8) (i32.const 4)) (i32.const 4))
(func $f32_bool (result i32) (call $bump) (i32.store8 (i32.const 8) (i32.const 5)) (i32.const 0))
(func $f64_left (result f64) (call $bump) (i32.store8 (i32.const 8) (i32.const 1)) (f64.const 0))
(func $f64_right (result f64) (call $bump) (i32.store8 (i32.const 8) (i32.const 2)) (f64.const 1))
(func $f64_another (result f64) (call $bump) (i32.store8 (i32.const 8) (i32.const 3)) (f64.const 1))
(func $f64_callee (result i32) (call $bump) (i32.store8 (i32.const 8) (i32.const 4)) (i32.const 6))
(func $f64_bool (result i32) (call $bump) (i32.store8 (i32.const 8) (i32.const 5)) (i32.const 0))
(func $i32_dummy (param i32 i32)) (func $i64_dummy (param i64 i64))
(func $f32_dummy (param f32 f32)) (func $f64_dummy (param f64 f64))
(func $i32_add (result i32) (call $reset) (i32.add (call $i32_left) (call $i32_right)) (call $get))
(func $i32_sub (result i32) (call $reset) (i32.sub (call $i32_left) (call $i32_right)) (call $get))
(func $i32_mul (result i32) (call $reset) (i32.mul (call $i32_left) (call $i32_right)) (call $get))
(func $i32_div_s (result i32) (call $reset) (i32.div_s (call $i32_left) (call $i32_right)) (call $get))
(func $i32_div_u (result i32) (call $reset) (i32.div_u (call $i32_left) (call $i32_right)) (call $get))
(func $i32_rem_s (result i32) (call $reset) (i32.rem_s (call $i32_left) (call $i32_right)) (call $get))
(func $i32_rem_u (result i32) (call $reset) (i32.rem_u (call $i32_left) (call $i32_right)) (call $get))
(func $i32_and (result i32) (call $reset) (i32.and (call $i32_left) (call $i32_right)) (call $get))
(func $i32_or (result i32) (call $reset) (i32.or (call $i32_left) (call $i32_right)) (call $get))
(func $i32_xor (result i32) (call $reset) (i32.xor (call $i32_left) (call $i32_right)) (call $get))
(func $i32_shl (result i32) (call $reset) (i32.shl (call $i32_left) (call $i32_right)) (call $get))
(func $i32_shr_u (result i32) (call $reset) (i32.shr_u (call $i32_left) (call $i32_right)) (call $get))
(func $i32_shr_s (result i32) (call $reset) (i32.shr_s (call $i32_left) (call $i32_right)) (call $get))
(func $i32_eq (result i32) (call $reset) (i32.eq (call $i32_left) (call $i32_right)) (call $get))
(func $i32_ne (result i32) (call $reset) (i32.ne (call $i32_left) (call $i32_right)) (call $get))
(func $i32_lt_s (result i32) (call $reset) (i32.lt_s (call $i32_left) (call $i32_right)) (call $get))
(func $i32_le_s (result i32) (call $reset) (i32.le_s (call $i32_left) (call $i32_right)) (call $get))
(func $i32_lt_u (result i32) (call $reset) (i32.lt_u (call $i32_left) (call $i32_right)) (call $get))
(func $i32_le_u (result i32) (call $reset) (i32.le_u (call $i32_left) (call $i32_right)) (call $get))
(func $i32_gt_s (result i32) (call $reset) (i32.gt_s (call $i32_left) (call $i32_right)) (call $get))
(func $i32_ge_s (result i32) (call $reset) (i32.ge_s (call $i32_left) (call $i32_right)) (call $get))
(func $i32_gt_u (result i32) (call $reset) (i32.gt_u (call $i32_left) (call $i32_right)) (call $get))
(func $i32_ge_u (result i32) (call $reset) (i32.ge_u (call $i32_left) (call $i32_right)) (call $get))
(func $i32_store (result i32) (call $reset) (i32.store (call $i32_left) (call $i32_right)) (call $get))
(func $i32_store8 (result i32) (call $reset) (i32.store8 (call $i32_left) (call $i32_right)) (call $get))
(func $i32_store16 (result i32) (call $reset) (i32.store16 (call $i32_left) (call $i32_right)) (call $get))
(func $i32_call (result i32) (call $reset) (call $i32_dummy (call $i32_left) (call $i32_right)) (call $get))
(func $i32_call_indirect (result i32) (call $reset) (call_indirect $i32_T (call $i32_callee) (call $i32_right) (call $i32_another)) (call $get))
(func $i32_select (result i32) (call $reset) (select (call $i32_left) (call $i32_right) (call $i32_bool)) (call $get))
(func $i64_add (result i32) (call $reset) (i64.add (call $i64_left) (call $i64_right)) (call $get))
(func $i64_sub (result i32) (call $reset) (i64.sub (call $i64_left) (call $i64_right)) (call $get))
(func $i64_mul (result i32) (call $reset) (i64.mul (call $i64_left) (call $i64_right)) (call $get))
(func $i64_div_s (result i32) (call $reset) (i64.div_s (call $i64_left) (call $i64_right)) (call $get))
(func $i64_div_u (result i32) (call $reset) (i64.div_u (call $i64_left) (call $i64_right)) (call $get))
(func $i64_rem_s (result i32) (call $reset) (i64.rem_s (call $i64_left) (call $i64_right)) (call $get))
(func $i64_rem_u (result i32) (call $reset) (i64.rem_u (call $i64_left) (call $i64_right)) (call $get))
(func $i64_and (result i32) (call $reset) (i64.and (call $i64_left) (call $i64_right)) (call $get))
(func $i64_or (result i32) (call $reset) (i64.or (call $i64_left) (call $i64_right)) (call $get))
(func $i64_xor (result i32) (call $reset) (i64.xor (call $i64_left) (call $i64_right)) (call $get))
(func $i64_shl (result i32) (call $reset) (i64.shl (call $i64_left) (call $i64_right)) (call $get))
(func $i64_shr_u (result i32) (call $reset) (i64.shr_u (call $i64_left) (call $i64_right)) (call $get))
(func $i64_shr_s (result i32) (call $reset) (i64.shr_s (call $i64_left) (call $i64_right)) (call $get))
(func $i64_eq (result i32) (call $reset) (i64.eq (call $i64_left) (call $i64_right)) (call $get))
(func $i64_ne (result i32) (call $reset) (i64.ne (call $i64_left) (call $i64_right)) (call $get))
(func $i64_lt_s (result i32) (call $reset) (i64.lt_s (call $i64_left) (call $i64_right)) (call $get))
(func $i64_le_s (result i32) (call $reset) (i64.le_s (call $i64_left) (call $i64_right)) (call $get))
(func $i64_lt_u (result i32) (call $reset) (i64.lt_u (call $i64_left) (call $i64_right)) (call $get))
(func $i64_le_u (result i32) (call $reset) (i64.le_u (call $i64_left) (call $i64_right)) (call $get))
(func $i64_gt_s (result i32) (call $reset) (i64.gt_s (call $i64_left) (call $i64_right)) (call $get))
(func $i64_ge_s (result i32) (call $reset) (i64.ge_s (call $i64_left) (call $i64_right)) (call $get))
(func $i64_gt_u (result i32) (call $reset) (i64.gt_u (call $i64_left) (call $i64_right)) (call $get))
(func $i64_ge_u (result i32) (call $reset) (i64.ge_u (call $i64_left) (call $i64_right)) (call $get))
(func $i64_store (result i32) (call $reset) (i64.store (call $i32_left) (call $i64_right)) (call $get))
(func $i64_store8 (result i32) (call $reset) (i64.store8 (call $i32_left) (call $i64_right)) (call $get))
(func $i64_store16 (result i32) (call $reset) (i64.store16 (call $i32_left) (call $i64_right)) (call $get))
(func $i64_store32 (result i32) (call $reset) (i64.store32 (call $i32_left) (call $i64_right)) (call $get))
(func $i64_call (result i32) (call $reset) (call $i64_dummy (call $i64_left) (call $i64_right)) (call $get))
(func $i64_call_indirect (result i32) (call $reset) (call_indirect $i64_T (call $i64_callee) (call $i64_right) (call $i64_another)) (call $get))
(func $i64_select (result i32) (call $reset) (select (call $i64_left) (call $i64_right) (call $i64_bool)) (call $get))
(func $f32_add (result i32) (call $reset) (f32.add (call $f32_left) (call $f32_right)) (call $get))
(func $f32_sub (result i32) (call $reset) (f32.sub (call $f32_left) (call $f32_right)) (call $get))
(func $f32_mul (result i32) (call $reset) (f32.mul (call $f32_left) (call $f32_right)) (call $get))
(func $f32_div (result i32) (call $reset) (f32.div (call $f32_left) (call $f32_right)) (call $get))
(func $f32_copysign (result i32) (call $reset) (f32.copysign (call $f32_left) (call $f32_right)) (call $get))
(func $f32_eq (result i32) (call $reset) (f32.eq (call $f32_left) (call $f32_right)) (call $get))
(func $f32_ne (result i32) (call $reset) (f32.ne (call $f32_left) (call $f32_right)) (call $get))
(func $f32_lt (result i32) (call $reset) (f32.lt (call $f32_left) (call $f32_right)) (call $get))
(func $f32_le (result i32) (call $reset) (f32.le (call $f32_left) (call $f32_right)) (call $get))
(func $f32_gt (result i32) (call $reset) (f32.gt (call $f32_left) (call $f32_right)) (call $get))
(func $f32_ge (result i32) (call $reset) (f32.ge (call $f32_left) (call $f32_right)) (call $get))
(func $f32_min (result i32) (call $reset) (f32.min (call $f32_left) (call $f32_right)) (call $get))
(func $f32_max (result i32) (call $reset) (f32.max (call $f32_left) (call $f32_right)) (call $get))
(func $f32_store (result i32) (call $reset) (f32.store (call $i32_left) (call $f32_right)) (call $get))
(func $f32_call (result i32) (call $reset) (call $f32_dummy (call $f32_left) (call $f32_right)) (call $get))
(func $f32_call_indirect (result i32) (call $reset) (call_indirect $f32_T (call $f32_callee) (call $f32_right) (call $f32_another)) (call $get))
(func $f32_select (result i32) (call $reset) (select (call $f32_left) (call $f32_right) (call $f32_bool)) (call $get))
(func $f64_add (result i32) (call $reset) (f64.add (call $f64_left) (call $f64_right)) (call $get))
(func $f64_sub (result i32) (call $reset) (f64.sub (call $f64_left) (call $f64_right)) (call $get))
(func $f64_mul (result i32) (call $reset) (f64.mul (call $f64_left) (call $f64_right)) (call $get))
(func $f64_div (result i32) (call $reset) (f64.div (call $f64_left) (call $f64_right)) (call $get))
(func $f64_copysign (result i32) (call $reset) (f64.copysign (call $f64_left) (call $f64_right)) (call $get))
(func $f64_eq (result i32) (call $reset) (f64.eq (call $f64_left) (call $f64_right)) (call $get))
(func $f64_ne (result i32) (call $reset) (f64.ne (call $f64_left) (call $f64_right)) (call $get))
(func $f64_lt (result i32) (call $reset) (f64.lt (call $f64_left) (call $f64_right)) (call $get))
(func $f64_le (result i32) (call $reset) (f64.le (call $f64_left) (call $f64_right)) (call $get))
(func $f64_gt (result i32) (call $reset) (f64.gt (call $f64_left) (call $f64_right)) (call $get))
(func $f64_ge (result i32) (call $reset) (f64.ge (call $f64_left) (call $f64_right)) (call $get))
(func $f64_min (result i32) (call $reset) (f64.min (call $f64_left) (call $f64_right)) (call $get))
(func $f64_max (result i32) (call $reset) (f64.max (call $f64_left) (call $f64_right)) (call $get))
(func $f64_store (result i32) (call $reset) (f64.store (call $i32_left) (call $f64_right)) (call $get))
(func $f64_call (result i32) (call $reset) (call $f64_dummy (call $f64_left) (call $f64_right)) (call $get))
(func $f64_call_indirect (result i32) (call $reset) (call_indirect $f64_T (call $f64_callee) (call $f64_right) (call $f64_another)) (call $get))
(func $f64_select (result i32) (call $reset) (select (call $f64_left) (call $f64_right) (call $f64_bool)) (call $get))
(func $br_if (result i32)
(block
(call $reset)
(br_if 0 (call $i32_left) (i32.and (call $i32_right) (i32.const 0)))
(call $get)
)
)
(func $br_table (result i32)
(block $a
(call $reset)
(block $b
(br_table $a $b (call $i32_left) (call $i32_right))
)
(call $get)
)
)
(export "i32_add" $i32_add) (export "i64_add" $i64_add)
(export "i32_sub" $i32_sub) (export "i64_sub" $i64_sub)
(export "i32_mul" $i32_mul) (export "i64_mul" $i64_mul)
(export "i32_div_s" $i32_div_s) (export "i64_div_s" $i64_div_s)
(export "i32_div_u" $i32_div_u) (export "i64_div_u" $i64_div_u)
(export "i32_rem_s" $i32_rem_s) (export "i64_rem_s" $i64_rem_s)
(export "i32_rem_u" $i32_rem_u) (export "i64_rem_u" $i64_rem_u)
(export "i32_and" $i32_and) (export "i64_and" $i64_and)
(export "i32_or" $i32_or) (export "i64_or" $i64_or)
(export "i32_xor" $i32_xor) (export "i64_xor" $i64_xor)
(export "i32_shl" $i32_shl) (export "i64_shl" $i64_shl)
(export "i32_shr_u" $i32_shr_u) (export "i64_shr_u" $i64_shr_u)
(export "i32_shr_s" $i32_shr_s) (export "i64_shr_s" $i64_shr_s)
(export "i32_eq" $i32_eq) (export "i64_eq" $i64_eq)
(export "i32_ne" $i32_ne) (export "i64_ne" $i64_ne)
(export "i32_lt_s" $i32_lt_s) (export "i64_lt_s" $i64_lt_s)
(export "i32_le_s" $i32_le_s) (export "i64_le_s" $i64_le_s)
(export "i32_lt_u" $i32_lt_u) (export "i64_lt_u" $i64_lt_u)
(export "i32_le_u" $i32_le_u) (export "i64_le_u" $i64_le_u)
(export "i32_gt_s" $i32_gt_s) (export "i64_gt_s" $i64_gt_s)
(export "i32_ge_s" $i32_ge_s) (export "i64_ge_s" $i64_ge_s)
(export "i32_gt_u" $i32_gt_u) (export "i64_gt_u" $i64_gt_u)
(export "i32_ge_u" $i32_ge_u) (export "i64_ge_u" $i64_ge_u)
(export "i32_store" $i32_store) (export "i64_store" $i64_store)
(export "i32_store8" $i32_store8) (export "i64_store8" $i64_store8)
(export "i32_store16" $i32_store16) (export "i64_store16" $i64_store16)
(export "i64_store32" $i64_store32)
(export "i32_call" $i32_call) (export "i64_call" $i64_call)
(export "i32_call_indirect" $i32_call_indirect) (export "i64_call_indirect" $i64_call_indirect)
(export "i32_select" $i32_select) (export "i64_select" $i64_select)
(export "f32_add" $f32_add) (export "f64_add" $f64_add)
(export "f32_sub" $f32_sub) (export "f64_sub" $f64_sub)
(export "f32_mul" $f32_mul) (export "f64_mul" $f64_mul)
(export "f32_div" $f32_div) (export "f64_div" $f64_div)
(export "f32_copysign" $f32_copysign) (export "f64_copysign" $f64_copysign)
(export "f32_eq" $f32_eq) (export "f64_eq" $f64_eq)
(export "f32_ne" $f32_ne) (export "f64_ne" $f64_ne)
(export "f32_lt" $f32_lt) (export "f64_lt" $f64_lt)
(export "f32_le" $f32_le) (export "f64_le" $f64_le)
(export "f32_gt" $f32_gt) (export "f64_gt" $f64_gt)
(export "f32_ge" $f32_ge) (export "f64_ge" $f64_ge)
(export "f32_min" $f32_min) (export "f64_min" $f64_min)
(export "f32_max" $f32_max) (export "f64_max" $f64_max)
(export "f32_store" $f32_store) (export "f64_store" $f64_store)
(export "f32_call" $f32_call) (export "f64_call" $f64_call)
(export "f32_call_indirect" $f32_call_indirect) (export "f64_call_indirect" $f64_call_indirect)
(export "f32_select" $f32_select) (export "f64_select" $f64_select)
(export "br_if" $br_if)
(export "br_table" $br_table)
)
(assert_return (invoke "i32_add") (i32.const 0x0102)) (assert_return (invoke "i64_add") (i32.const 0x0102))
(assert_return (invoke "i32_sub") (i32.const 0x0102)) (assert_return (invoke "i64_sub") (i32.const 0x0102))
(assert_return (invoke "i32_mul") (i32.const 0x0102)) (assert_return (invoke "i64_mul") (i32.const 0x0102))
(assert_return (invoke "i32_div_s") (i32.const 0x0102)) (assert_return (invoke "i64_div_s") (i32.const 0x0102))
(assert_return (invoke "i32_div_u") (i32.const 0x0102)) (assert_return (invoke "i64_div_u") (i32.const 0x0102))
(assert_return (invoke "i32_rem_s") (i32.const 0x0102)) (assert_return (invoke "i64_rem_s") (i32.const 0x0102))
(assert_return (invoke "i32_rem_u") (i32.const 0x0102)) (assert_return (invoke "i64_rem_u") (i32.const 0x0102))
(assert_return (invoke "i32_and") (i32.const 0x0102)) (assert_return (invoke "i64_and") (i32.const 0x0102))
(assert_return (invoke "i32_or") (i32.const 0x0102)) (assert_return (invoke "i64_or") (i32.const 0x0102))
(assert_return (invoke "i32_xor") (i32.const 0x0102)) (assert_return (invoke "i64_xor") (i32.const 0x0102))
(assert_return (invoke "i32_shl") (i32.const 0x0102)) (assert_return (invoke "i64_shl") (i32.const 0x0102))
(assert_return (invoke "i32_shr_u") (i32.const 0x0102)) (assert_return (invoke "i64_shr_u") (i32.const 0x0102))
(assert_return (invoke "i32_shr_s") (i32.const 0x0102)) (assert_return (invoke "i64_shr_s") (i32.const 0x0102))
(assert_return (invoke "i32_eq") (i32.const 0x0102)) (assert_return (invoke "i64_eq") (i32.const 0x0102))
(assert_return (invoke "i32_ne") (i32.const 0x0102)) (assert_return (invoke "i64_ne") (i32.const 0x0102))
(assert_return (invoke "i32_lt_s") (i32.const 0x0102)) (assert_return (invoke "i64_lt_s") (i32.const 0x0102))
(assert_return (invoke "i32_le_s") (i32.const 0x0102)) (assert_return (invoke "i64_le_s") (i32.const 0x0102))
(assert_return (invoke "i32_lt_u") (i32.const 0x0102)) (assert_return (invoke "i64_lt_u") (i32.const 0x0102))
(assert_return (invoke "i32_le_u") (i32.const 0x0102)) (assert_return (invoke "i64_le_u") (i32.const 0x0102))
(assert_return (invoke "i32_gt_s") (i32.const 0x0102)) (assert_return (invoke "i64_gt_s") (i32.const 0x0102))
(assert_return (invoke "i32_ge_s") (i32.const 0x0102)) (assert_return (invoke "i64_ge_s") (i32.const 0x0102))
(assert_return (invoke "i32_gt_u") (i32.const 0x0102)) (assert_return (invoke "i64_gt_u") (i32.const 0x0102))
(assert_return (invoke "i32_ge_u") (i32.const 0x0102)) (assert_return (invoke "i64_ge_u") (i32.const 0x0102))
(assert_return (invoke "i32_store") (i32.const 0x0102)) (assert_return (invoke "i64_store") (i32.const 0x0102))
(assert_return (invoke "i32_store8") (i32.const 0x0102)) (assert_return (invoke "i64_store8") (i32.const 0x0102))
(assert_return (invoke "i32_store16") (i32.const 0x0102)) (assert_return (invoke "i64_store16") (i32.const 0x0102))
(assert_return (invoke "i64_store32") (i32.const 0x0102))
(assert_return (invoke "i32_call") (i32.const 0x0102)) (assert_return (invoke "i64_call") (i32.const 0x0102))
(assert_return (invoke "i32_call_indirect") (i32.const 0x040203))
(assert_return (invoke "i64_call_indirect") (i32.const 0x040203))
(assert_return (invoke "i32_select") (i32.const 0x010205)) (assert_return (invoke "i64_select") (i32.const 0x010205))
(assert_return (invoke "f32_add") (i32.const 0x0102)) (assert_return (invoke "f64_add") (i32.const 0x0102))
(assert_return (invoke "f32_sub") (i32.const 0x0102)) (assert_return (invoke "f64_sub") (i32.const 0x0102))
(assert_return (invoke "f32_mul") (i32.const 0x0102)) (assert_return (invoke "f64_mul") (i32.const 0x0102))
(assert_return (invoke "f32_div") (i32.const 0x0102)) (assert_return (invoke "f64_div") (i32.const 0x0102))
(assert_return (invoke "f32_copysign") (i32.const 0x0102))(assert_return (invoke "f64_copysign") (i32.const 0x0102))
(assert_return (invoke "f32_eq") (i32.const 0x0102)) (assert_return (invoke "f64_eq") (i32.const 0x0102))
(assert_return (invoke "f32_ne") (i32.const 0x0102)) (assert_return (invoke "f64_ne") (i32.const 0x0102))
(assert_return (invoke "f32_lt") (i32.const 0x0102)) (assert_return (invoke "f64_lt") (i32.const 0x0102))
(assert_return (invoke "f32_le") (i32.const 0x0102)) (assert_return (invoke "f64_le") (i32.const 0x0102))
(assert_return (invoke "f32_gt") (i32.const 0x0102)) (assert_return (invoke "f64_gt") (i32.const 0x0102))
(assert_return (invoke "f32_ge") (i32.const 0x0102)) (assert_return (invoke "f64_ge") (i32.const 0x0102))
(assert_return (invoke "f32_min") (i32.const 0x0102)) (assert_return (invoke "f64_min") (i32.const 0x0102))
(assert_return (invoke "f32_max") (i32.const 0x0102)) (assert_return (invoke "f64_max") (i32.const 0x0102))
(assert_return (invoke "f32_store") (i32.const 0x0102)) (assert_return (invoke "f64_store") (i32.const 0x0102))
(assert_return (invoke "f32_call") (i32.const 0x0102)) (assert_return (invoke "f64_call") (i32.const 0x0102))
(assert_return (invoke "f32_call_indirect") (i32.const 0x040203))
(assert_return (invoke "f64_call_indirect") (i32.const 0x040203))
(assert_return (invoke "f32_select") (i32.const 0x010205)) (assert_return (invoke "f64_select") (i32.const 0x010205))
(assert_return (invoke "br_if") (i32.const 0x0102))
(assert_return (invoke "br_table") (i32.const 0x0102))

45
js/src/jit-test/tests/wasm/spec/list.js
View File

@ -1,7 +1,42 @@
// Included by ../spec.js.
// This is automatically generated by import_tests.sh. Do no modify by hand!
var specTests = [];
//specTests.push("address.wast"); // TODO wrapping offsets
//specTests.push("binary.wast"); // TODO binary text format
specTests.push("block_comments.wast");
specTests.push("block.wast");
specTests.push("break-drop.wast");
//specTests.push("conversions.wast"); // TODO custom NaN
//specTests.push("endianness.wast"); // TODO i64 ops
//specTests.push("exports.wast"); // TODO real memory exports
//specTests.push("f32_cmp.wast"); // TODO custom NaN
//specTests.push("f32.wast"); // TODO f32.trunc
//specTests.push("f64_cmp.wast"); // TODO custom NaN
//specTests.push("f64.wast"); // TODO f64.trunc
specTests.push("fac.wast");
//specTests.push("float_exprs.wast"); // TODO custom NaN
//specTests.push("float_literals.wast"); // TODO custom NaN
//specTests.push("float_memory.wast"); // TODO custom NaN
//specTests.push("float_misc.wast"); // TODO copysign
specTests.push("forward.wast");
//specTests.push("func_ptrs.wast"); // TODO pass table index in bad indirect error message
specTests.push("functions.wast");
specTests.push("i32.wast");
//specTests.push("i64.wast"); // TODO i64 ops
specTests.push("imports.wast");
specTests.push("int_exprs.wast");
specTests.push("int_literals.wast");
//specTests.push("labels.wast"); // TODO br_if value/cond
//specTests.push("left-to-right.wast"); // TODO i64 ops
specTests.push("memory_redundancy.wast");
//specTests.push("memory_trap.wast"); // TODO current_memory opcode
//specTests.push("memory.wast"); // TODO alignment
specTests.push("names.wast");
// Add more tests here.
//specTests.push("nan-propagation.wast"); // TODO f32 trunc
//specTests.push("resizing.wast"); // TODO grow_memory opcode
specTests.push("runaway-recursion.wast");
//specTests.push("select.wast"); // TODO custom NaN
//specTests.push("start.wast"); // TODO start opcode
//specTests.push("store_retval.wast"); // TODO i64 ops
//specTests.push("switch.wast"); // TODO value error!
//specTests.push("traps.wast"); // TODO trap on OOB
specTests.push("unreachable.wast");

235
js/src/jit-test/tests/wasm/spec/memory.wast Normal file
View File

@ -0,0 +1,235 @@
;; Test memory section structure
(module (memory 0 0))
(module (memory 0 1))
(module (memory 1 256))
(module (memory 0 0 (segment 0 "")))
(module (memory 1 1 (segment 0 "a")))
(module (memory 1 2 (segment 0 "a") (segment 65535 "b")))
(module (memory 1 2 (segment 0 "a") (segment 1 "b") (segment 2 "c")))
(assert_invalid
(module (memory 1 0))
"minimum memory pages must be less than or equal to the maximum"
)
(assert_invalid
(module (memory 0 0 (segment 0 "a")))
"data segment does not fit memory"
)
(assert_invalid
(module (memory 1 2 (segment 0 "a") (segment 98304 "b")))
"data segment does not fit memory"
)
(assert_invalid
(module (memory 1 2 (segment 0 "abc") (segment 0 "def")))
"data segment not disjoint and ordered"
)
(assert_invalid
(module (memory 1 2 (segment 3 "ab") (segment 0 "de")))
"data segment not disjoint and ordered"
)
(assert_invalid
(module (memory 1 2 (segment 0 "a") (segment 2 "b") (segment 1 "c")))
"data segment not disjoint and ordered"
)
;; Test alignment annotation rules
(module (memory 0) (func (i32.load8_u align=2 (i32.const 0))))
(module (memory 0) (func (i32.load16_u align=4 (i32.const 0))))
(module (memory 0) (func (i32.load align=8 (i32.const 0))))
(module (memory 0) (func (f32.load align=8 (i32.const 0))))
(assert_invalid
(module (memory 0) (func (i64.load align=0 (i32.const 0))))
"non-power-of-two alignment"
)
(assert_invalid
(module (memory 0) (func (i64.load align=3 (i32.const 0))))
"non-power-of-two alignment"
)
(assert_invalid
(module (memory 0) (func (i64.load align=5 (i32.const 0))))
"non-power-of-two alignment"
)
(assert_invalid
(module (memory 0) (func (i64.load align=6 (i32.const 0))))
"non-power-of-two alignment"
)
(assert_invalid
(module (memory 0) (func (i64.load align=7 (i32.const 0))))
"non-power-of-two alignment"
)
(module
(memory 1 (segment 0 "ABC\a7D") (segment 20 "WASM"))
;; Data section
(func $data (result i32)
(i32.and
(i32.and
(i32.and
(i32.eq (i32.load8_u (i32.const 0)) (i32.const 65))
(i32.eq (i32.load8_u (i32.const 3)) (i32.const 167))
)
(i32.and
(i32.eq (i32.load8_u (i32.const 6)) (i32.const 0))
(i32.eq (i32.load8_u (i32.const 19)) (i32.const 0))
)
)
(i32.and
(i32.and
(i32.eq (i32.load8_u (i32.const 20)) (i32.const 87))
(i32.eq (i32.load8_u (i32.const 23)) (i32.const 77))
)
(i32.and
(i32.eq (i32.load8_u (i32.const 24)) (i32.const 0))
(i32.eq (i32.load8_u (i32.const 1023)) (i32.const 0))
)
)
)
)
;; Aligned read/write
(func $aligned (result i32)
(local i32 i32 i32)
(set_local 0 (i32.const 10))
(loop
(if
(i32.eq (get_local 0) (i32.const 0))
(br 2)
)
(set_local 2 (i32.mul (get_local 0) (i32.const 4)))
(i32.store (get_local 2) (get_local 0))
(set_local 1 (i32.load (get_local 2)))
(if
(i32.ne (get_local 0) (get_local 1))
(return (i32.const 0))
)
(set_local 0 (i32.sub (get_local 0) (i32.const 1)))
(br 0)
)
(i32.const 1)
)
;; Unaligned read/write
(func $unaligned (result i32)
(local i32 f64 f64)
(set_local 0 (i32.const 10))
(loop
(if
(i32.eq (get_local 0) (i32.const 0))
(br 2)
)
(set_local 2 (f64.convert_s/i32 (get_local 0)))
(f64.store align=1 (get_local 0) (get_local 2))
(set_local 1 (f64.load align=1 (get_local 0)))
(if
(f64.ne (get_local 2) (get_local 1))
(return (i32.const 0))
)
(set_local 0 (i32.sub (get_local 0) (i32.const 1)))
(br 0)
)
(i32.const 1)
)
;; Memory cast
(func $cast (result f64)
(i64.store (i32.const 8) (i64.const -12345))
(if
(f64.eq
(f64.load (i32.const 8))
(f64.reinterpret/i64 (i64.const -12345))
)
(return (f64.const 0))
)
(i64.store align=1 (i32.const 9) (i64.const 0))
(i32.store16 align=1 (i32.const 15) (i32.const 16453))
(f64.load align=1 (i32.const 9))
)
;; Sign and zero extending memory loads
(func $i32_load8_s (param $i i32) (result i32)
(i32.store8 (i32.const 8) (get_local $i))
(i32.load8_s (i32.const 8))
)
(func $i32_load8_u (param $i i32) (result i32)
(i32.store8 (i32.const 8) (get_local $i))
(i32.load8_u (i32.const 8))
)
(func $i32_load16_s (param $i i32) (result i32)
(i32.store16 (i32.const 8) (get_local $i))
(i32.load16_s (i32.const 8))
)
(func $i32_load16_u (param $i i32) (result i32)
(i32.store16 (i32.const 8) (get_local $i))
(i32.load16_u (i32.const 8))
)
(func $i64_load8_s (param $i i64) (result i64)
(i64.store8 (i32.const 8) (get_local $i))
(i64.load8_s (i32.const 8))
)
(func $i64_load8_u (param $i i64) (result i64)
(i64.store8 (i32.const 8) (get_local $i))
(i64.load8_u (i32.const 8))
)
(func $i64_load16_s (param $i i64) (result i64)
(i64.store16 (i32.const 8) (get_local $i))
(i64.load16_s (i32.const 8))
)
(func $i64_load16_u (param $i i64) (result i64)
(i64.store16 (i32.const 8) (get_local $i))
(i64.load16_u (i32.const 8))
)
(func $i64_load32_s (param $i i64) (result i64)
(i64.store32 (i32.const 8) (get_local $i))
(i64.load32_s (i32.const 8))
)
(func $i64_load32_u (param $i i64) (result i64)
(i64.store32 (i32.const 8) (get_local $i))
(i64.load32_u (i32.const 8))
)
(export "data" $data)
(export "aligned" $aligned)
(export "unaligned" $unaligned)
(export "cast" $cast)
(export "i32_load8_s" $i32_load8_s)
(export "i32_load8_u" $i32_load8_u)
(export "i32_load16_s" $i32_load16_s)
(export "i32_load16_u" $i32_load16_u)
(export "i64_load8_s" $i64_load8_s)
(export "i64_load8_u" $i64_load8_u)
(export "i64_load16_s" $i64_load16_s)
(export "i64_load16_u" $i64_load16_u)
(export "i64_load32_s" $i64_load32_s)
(export "i64_load32_u" $i64_load32_u)
)
(assert_return (invoke "data") (i32.const 1))
(assert_return (invoke "aligned") (i32.const 1))
(assert_return (invoke "unaligned") (i32.const 1))
(assert_return (invoke "cast") (f64.const 42.0))
(assert_return (invoke "i32_load8_s" (i32.const -1)) (i32.const -1))
(assert_return (invoke "i32_load8_u" (i32.const -1)) (i32.const 255))
(assert_return (invoke "i32_load16_s" (i32.const -1)) (i32.const -1))
(assert_return (invoke "i32_load16_u" (i32.const -1)) (i32.const 65535))
(assert_return (invoke "i32_load8_s" (i32.const 100)) (i32.const 100))
(assert_return (invoke "i32_load8_u" (i32.const 200)) (i32.const 200))
(assert_return (invoke "i32_load16_s" (i32.const 20000)) (i32.const 20000))
(assert_return (invoke "i32_load16_u" (i32.const 40000)) (i32.const 40000))
(assert_return (invoke "i64_load8_s" (i64.const -1)) (i64.const -1))
(assert_return (invoke "i64_load8_u" (i64.const -1)) (i64.const 255))
(assert_return (invoke "i64_load16_s" (i64.const -1)) (i64.const -1))
(assert_return (invoke "i64_load16_u" (i64.const -1)) (i64.const 65535))
(assert_return (invoke "i64_load32_s" (i64.const -1)) (i64.const -1))
(assert_return (invoke "i64_load32_u" (i64.const -1)) (i64.const 4294967295))
(assert_return (invoke "i64_load8_s" (i64.const 100)) (i64.const 100))
(assert_return (invoke "i64_load8_u" (i64.const 200)) (i64.const 200))
(assert_return (invoke "i64_load16_s" (i64.const 20000)) (i64.const 20000))
(assert_return (invoke "i64_load16_u" (i64.const 40000)) (i64.const 40000))
(assert_return (invoke "i64_load32_s" (i64.const 20000)) (i64.const 20000))
(assert_return (invoke "i64_load32_u" (i64.const 40000)) (i64.const 40000))

44
js/src/jit-test/tests/wasm/spec/memory_redundancy.wast Normal file
View File

@ -0,0 +1,44 @@
;; Test that optimizers don't do redundant-load, store-to-load, or dead-store
;; optimizations when there are interfering stores, even of different types
;; and to non-identical addresses.
(module
(memory 1 1)
(export "zero_everything" $zero_everything)
(func $zero_everything
(i32.store (i32.const 0) (i32.const 0))
(i32.store (i32.const 4) (i32.const 0))
(i32.store (i32.const 8) (i32.const 0))
(i32.store (i32.const 12) (i32.const 0))
)
(export "test_store_to_load" $test_store_to_load)
(func $test_store_to_load (result i32)
(i32.store (i32.const 8) (i32.const 0))
(f32.store (i32.const 5) (f32.const -0.0))
(i32.load (i32.const 8))
)
(export "test_redundant_load" $test_redundant_load)
(func $test_redundant_load (result i32)
(i32.load (i32.const 8))
(f32.store (i32.const 5) (f32.const -0.0))
(i32.load (i32.const 8))
)
(export "test_dead_store" $test_dead_store)
(func $test_dead_store (result f32)
(local $t f32)
(i32.store (i32.const 8) (i32.const 0x23232323))
(set_local $t (f32.load (i32.const 11)))
(i32.store (i32.const 8) (i32.const 0))
(get_local $t)
)
)
(assert_return (invoke "test_store_to_load") (i32.const 0x00000080))
(invoke "zero_everything")
(assert_return (invoke "test_redundant_load") (i32.const 0x00000080))
(invoke "zero_everything")
(assert_return (invoke "test_dead_store") (f32.const 0x1.18p-144))

36
js/src/jit-test/tests/wasm/spec/memory_trap.wast Normal file
View File

@ -0,0 +1,36 @@
(module
(memory 1)
(func $addr_limit (result i32)
(i32.mul (current_memory) (i32.const 0x10000))
)
(export "store" $store)
(func $store (param $i i32) (param $v i32) (result i32)
(i32.store (i32.add (call $addr_limit) (get_local $i)) (get_local $v))
)
(export "load" $load)
(func $load (param $i i32) (result i32)
(i32.load (i32.add (call $addr_limit) (get_local $i)))
)
(export "grow_memory" $grow_memory)
(func $grow_memory (param i32)
(grow_memory (get_local 0))
)
)
(assert_return (invoke "store" (i32.const -4) (i32.const 42)) (i32.const 42))
(assert_return (invoke "load" (i32.const -4)) (i32.const 42))
(assert_trap (invoke "store" (i32.const -3) (i32.const 13)) "out of bounds memory access")
(assert_trap (invoke "load" (i32.const -3)) "out of bounds memory access")
(assert_trap (invoke "store" (i32.const -2) (i32.const 13)) "out of bounds memory access")
(assert_trap (invoke "load" (i32.const -2)) "out of bounds memory access")
(assert_trap (invoke "store" (i32.const -1) (i32.const 13)) "out of bounds memory access")
(assert_trap (invoke "load" (i32.const -1)) "out of bounds memory access")
(assert_trap (invoke "store" (i32.const 0) (i32.const 13)) "out of bounds memory access")
(assert_trap (invoke "load" (i32.const 0)) "out of bounds memory access")
(assert_trap (invoke "store" (i32.const 0x80000000) (i32.const 13)) "out of bounds memory access")
(assert_trap (invoke "load" (i32.const 0x80000000)) "out of bounds memory access")
(assert_trap (invoke "grow_memory" (i32.const 0x80000000)) "memory size exceeds implementation limit")

2
js/src/jit-test/tests/wasm/spec/names.wast
View File

@ -88,4 +88,4 @@
(export "print32" 0)
)
(invoke "print32" (i32.const 42) (i32.const 123))
(invoke "print32" (i32.const 42) (i32.const 123))

221
js/src/jit-test/tests/wasm/spec/nan-propagation.wast Normal file
View File

@ -0,0 +1,221 @@
;; Test that NaN values are propagated through arithmetic operators properly.
(module
(func $add (param $x f32) (param $y f32) (result f32) (f32.add (get_local $x) (get_local $y)))
(func $sub (param $x f32) (param $y f32) (result f32) (f32.sub (get_local $x) (get_local $y)))
(func $mul (param $x f32) (param $y f32) (result f32) (f32.mul (get_local $x) (get_local $y)))
(func $div (param $x f32) (param $y f32) (result f32) (f32.div (get_local $x) (get_local $y)))
(func $sqrt (param $x f32) (result f32) (f32.sqrt (get_local $x)))
(func $min (param $x f32) (param $y f32) (result f32) (f32.min (get_local $x) (get_local $y)))
(func $max (param $x f32) (param $y f32) (result f32) (f32.max (get_local $x) (get_local $y)))
(func $ceil (param $x f32) (result f32) (f32.ceil (get_local $x)))
(func $floor (param $x f32) (result f32) (f32.floor (get_local $x)))
(func $trunc (param $x f32) (result f32) (f32.trunc (get_local $x)))
(func $nearest (param $x f32) (result f32) (f32.nearest (get_local $x)))
(func $abs (param $x f32) (result f32) (f32.abs (get_local $x)))
(func $neg (param $x f32) (result f32) (f32.neg (get_local $x)))
(func $copysign (param $x f32) (param $y f32) (result f32) (f32.copysign (get_local $x) (get_local $y)))
(export "add" $add)
(export "sub" $sub)
(export "mul" $mul)
(export "div" $div)
(export "sqrt" $sqrt)
(export "min" $min)
(export "max" $max)
(export "ceil" $ceil)
(export "floor" $floor)
(export "trunc" $trunc)
(export "nearest" $nearest)
(export "abs" $abs)
(export "neg" $neg)
(export "copysign" $copysign)
)
(assert_return_nan (invoke "add" (f32.const infinity) (f32.const -infinity)))
(assert_return (invoke "add" (f32.const nan:0xf1e2) (f32.const 0x1p0)) (f32.const nan:0x40f1e2))
(assert_return (invoke "add" (f32.const 0x1p0) (f32.const nan:0xf1e2)) (f32.const nan:0x40f1e2))
(assert_return (invoke "add" (f32.const -nan:0xf1e2) (f32.const 0x1p0)) (f32.const -nan:0x40f1e2))
(assert_return (invoke "add" (f32.const 0x1p0) (f32.const -nan:0xf1e2)) (f32.const -nan:0x40f1e2))
(assert_return (invoke "add" (f32.const nan:0xf1e2) (f32.const nan:0xf1e2)) (f32.const nan:0x40f1e2))
(assert_return_nan (invoke "sub" (f32.const infinity) (f32.const infinity)))
(assert_return (invoke "sub" (f32.const nan:0xf1e2) (f32.const 0x1p0)) (f32.const nan:0x40f1e2))
(assert_return (invoke "sub" (f32.const 0x1p0) (f32.const nan:0xf1e2)) (f32.const nan:0x40f1e2))
(assert_return (invoke "sub" (f32.const -nan:0xf1e2) (f32.const 0x1p0)) (f32.const -nan:0x40f1e2))
(assert_return (invoke "sub" (f32.const 0x1p0) (f32.const -nan:0xf1e2)) (f32.const -nan:0x40f1e2))
(assert_return (invoke "sub" (f32.const nan:0xf1e2) (f32.const nan:0xf1e2)) (f32.const nan:0x40f1e2))
(assert_return_nan (invoke "mul" (f32.const infinity) (f32.const 0)))
(assert_return (invoke "mul" (f32.const nan:0xf1e2) (f32.const 0x1p0)) (f32.const nan:0x40f1e2))
(assert_return (invoke "mul" (f32.const 0x1p0) (f32.const nan:0xf1e2)) (f32.const nan:0x40f1e2))
(assert_return (invoke "mul" (f32.const -nan:0xf1e2) (f32.const 0x1p0)) (f32.const -nan:0x40f1e2))
(assert_return (invoke "mul" (f32.const 0x1p0) (f32.const -nan:0xf1e2)) (f32.const -nan:0x40f1e2))
(assert_return (invoke "mul" (f32.const nan:0xf1e2) (f32.const nan:0xf1e2)) (f32.const nan:0x40f1e2))
(assert_return_nan (invoke "div" (f32.const 0) (f32.const 0)))
(assert_return (invoke "div" (f32.const nan:0xf1e2) (f32.const 0x1p0)) (f32.const nan:0x40f1e2))
(assert_return (invoke "div" (f32.const 0x1p0) (f32.const nan:0xf1e2)) (f32.const nan:0x40f1e2))
(assert_return (invoke "div" (f32.const -nan:0xf1e2) (f32.const 0x1p0)) (f32.const -nan:0x40f1e2))
(assert_return (invoke "div" (f32.const 0x1p0) (f32.const -nan:0xf1e2)) (f32.const -nan:0x40f1e2))
(assert_return (invoke "div" (f32.const nan:0xf1e2) (f32.const nan:0xf1e2)) (f32.const nan:0x40f1e2))
(assert_return_nan (invoke "sqrt" (f32.const -0x1p0)))
(assert_return (invoke "sqrt" (f32.const nan:0xf1e2)) (f32.const nan:0x40f1e2))
(assert_return (invoke "sqrt" (f32.const -nan:0xf1e2)) (f32.const -nan:0x40f1e2))
(assert_return (invoke "min" (f32.const nan:0xf1e2) (f32.const 0x1p0)) (f32.const nan:0x40f1e2))
(assert_return (invoke "min" (f32.const 0x1p0) (f32.const nan:0xf1e2)) (f32.const nan:0x40f1e2))
(assert_return (invoke "min" (f32.const -nan:0xf1e2) (f32.const 0x1p0)) (f32.const -nan:0x40f1e2))
(assert_return (invoke "min" (f32.const 0x1p0) (f32.const -nan:0xf1e2)) (f32.const -nan:0x40f1e2))
(assert_return (invoke "min" (f32.const nan:0xf1e2) (f32.const nan:0xf1e2)) (f32.const nan:0x40f1e2))
(assert_return (invoke "max" (f32.const nan:0xf1e2) (f32.const 0x1p0)) (f32.const nan:0x40f1e2))
(assert_return (invoke "max" (f32.const 0x1p0) (f32.const nan:0xf1e2)) (f32.const nan:0x40f1e2))
(assert_return (invoke "max" (f32.const -nan:0xf1e2) (f32.const 0x1p0)) (f32.const -nan:0x40f1e2))
(assert_return (invoke "max" (f32.const 0x1p0) (f32.const -nan:0xf1e2)) (f32.const -nan:0x40f1e2))
(assert_return (invoke "max" (f32.const nan:0xf1e2) (f32.const nan:0xf1e2)) (f32.const nan:0x40f1e2))
(assert_return (invoke "ceil" (f32.const nan:0xf1e2)) (f32.const nan:0x40f1e2))
(assert_return (invoke "ceil" (f32.const -nan:0xf1e2)) (f32.const -nan:0x40f1e2))
(assert_return (invoke "floor" (f32.const nan:0xf1e2)) (f32.const nan:0x40f1e2))
(assert_return (invoke "floor" (f32.const -nan:0xf1e2)) (f32.const -nan:0x40f1e2))
(assert_return (invoke "trunc" (f32.const nan:0xf1e2)) (f32.const nan:0x40f1e2))
(assert_return (invoke "trunc" (f32.const -nan:0xf1e2)) (f32.const -nan:0x40f1e2))
(assert_return (invoke "nearest" (f32.const nan:0xf1e2)) (f32.const nan:0x40f1e2))
(assert_return (invoke "nearest" (f32.const -nan:0xf1e2)) (f32.const -nan:0x40f1e2))
(assert_return (invoke "abs" (f32.const nan:0xf1e2)) (f32.const nan:0xf1e2))
(assert_return (invoke "abs" (f32.const -nan:0xf1e2)) (f32.const nan:0xf1e2))
(assert_return (invoke "neg" (f32.const nan:0xf1e2)) (f32.const -nan:0xf1e2))
(assert_return (invoke "neg" (f32.const -nan:0xf1e2)) (f32.const nan:0xf1e2))
(assert_return (invoke "copysign" (f32.const nan:0xf1e2) (f32.const 0x1p0)) (f32.const nan:0xf1e2))
(assert_return (invoke "copysign" (f32.const nan:0xf1e2) (f32.const -0x1p0)) (f32.const -nan:0xf1e2))
(assert_return (invoke "copysign" (f32.const -nan:0xf1e2) (f32.const 0x1p0)) (f32.const nan:0xf1e2))
(assert_return (invoke "copysign" (f32.const -nan:0xf1e2) (f32.const -0x1p0)) (f32.const -nan:0xf1e2))
(module
(func $add (param $x f64) (param $y f64) (result f64) (f64.add (get_local $x) (get_local $y)))
(func $sub (param $x f64) (param $y f64) (result f64) (f64.sub (get_local $x) (get_local $y)))
(func $mul (param $x f64) (param $y f64) (result f64) (f64.mul (get_local $x) (get_local $y)))
(func $div (param $x f64) (param $y f64) (result f64) (f64.div (get_local $x) (get_local $y)))
(func $sqrt (param $x f64) (result f64) (f64.sqrt (get_local $x)))
(func $min (param $x f64) (param $y f64) (result f64) (f64.min (get_local $x) (get_local $y)))
(func $max (param $x f64) (param $y f64) (result f64) (f64.max (get_local $x) (get_local $y)))
(func $ceil (param $x f64) (result f64) (f64.ceil (get_local $x)))
(func $floor (param $x f64) (result f64) (f64.floor (get_local $x)))
(func $trunc (param $x f64) (result f64) (f64.trunc (get_local $x)))
(func $nearest (param $x f64) (result f64) (f64.nearest (get_local $x)))
(func $abs (param $x f64) (result f64) (f64.abs (get_local $x)))
(func $neg (param $x f64) (result f64) (f64.neg (get_local $x)))
(func $copysign (param $x f64) (param $y f64) (result f64) (f64.copysign (get_local $x) (get_local $y)))
(export "add" $add)
(export "sub" $sub)
(export "mul" $mul)
(export "div" $div)
(export "sqrt" $sqrt)
(export "min" $min)
(export "max" $max)
(export "ceil" $ceil)
(export "floor" $floor)
(export "trunc" $trunc)
(export "nearest" $nearest)
(export "abs" $abs)
(export "neg" $neg)
(export "copysign" $copysign)
)
(assert_return_nan (invoke "add" (f64.const infinity) (f64.const -infinity)))
(assert_return (invoke "add" (f64.const nan:0xf1e2) (f64.const 0x1p0)) (f64.const nan:0x800000000f1e2))
(assert_return (invoke "add" (f64.const 0x1p0) (f64.const nan:0xf1e2)) (f64.const nan:0x800000000f1e2))
(assert_return (invoke "add" (f64.const -nan:0xf1e2) (f64.const 0x1p0)) (f64.const -nan:0x800000000f1e2))
(assert_return (invoke "add" (f64.const 0x1p0) (f64.const -nan:0xf1e2)) (f64.const -nan:0x800000000f1e2))
(assert_return (invoke "add" (f64.const nan:0xf1e2) (f64.const nan:0xf1e2)) (f64.const nan:0x800000000f1e2))
(assert_return_nan (invoke "sub" (f64.const infinity) (f64.const infinity)))
(assert_return (invoke "sub" (f64.const nan:0xf1e2) (f64.const 0x1p0)) (f64.const nan:0x800000000f1e2))
(assert_return (invoke "sub" (f64.const 0x1p0) (f64.const nan:0xf1e2)) (f64.const nan:0x800000000f1e2))
(assert_return (invoke "sub" (f64.const -nan:0xf1e2) (f64.const 0x1p0)) (f64.const -nan:0x800000000f1e2))
(assert_return (invoke "sub" (f64.const 0x1p0) (f64.const -nan:0xf1e2)) (f64.const -nan:0x800000000f1e2))
(assert_return (invoke "sub" (f64.const nan:0xf1e2) (f64.const nan:0xf1e2)) (f64.const nan:0x800000000f1e2))
(assert_return_nan (invoke "mul" (f64.const infinity) (f64.const 0)))
(assert_return (invoke "mul" (f64.const nan:0xf1e2) (f64.const 0x1p0)) (f64.const nan:0x800000000f1e2))
(assert_return (invoke "mul" (f64.const 0x1p0) (f64.const nan:0xf1e2)) (f64.const nan:0x800000000f1e2))
(assert_return (invoke "mul" (f64.const -nan:0xf1e2) (f64.const 0x1p0)) (f64.const -nan:0x800000000f1e2))
(assert_return (invoke "mul" (f64.const 0x1p0) (f64.const -nan:0xf1e2)) (f64.const -nan:0x800000000f1e2))
(assert_return (invoke "mul" (f64.const nan:0xf1e2) (f64.const nan:0xf1e2)) (f64.const nan:0x800000000f1e2))
(assert_return_nan (invoke "div" (f64.const 0) (f64.const 0)))
(assert_return (invoke "div" (f64.const nan:0xf1e2) (f64.const 0x1p0)) (f64.const nan:0x800000000f1e2))
(assert_return (invoke "div" (f64.const 0x1p0) (f64.const nan:0xf1e2)) (f64.const nan:0x800000000f1e2))
(assert_return (invoke "div" (f64.const -nan:0xf1e2) (f64.const 0x1p0)) (f64.const -nan:0x800000000f1e2))
(assert_return (invoke "div" (f64.const 0x1p0) (f64.const -nan:0xf1e2)) (f64.const -nan:0x800000000f1e2))
(assert_return (invoke "div" (f64.const nan:0xf1e2) (f64.const nan:0xf1e2)) (f64.const nan:0x800000000f1e2))
(assert_return_nan (invoke "sqrt" (f64.const -0x1p0)))
(assert_return (invoke "sqrt" (f64.const nan:0xf1e2)) (f64.const nan:0x800000000f1e2))
(assert_return (invoke "sqrt" (f64.const -nan:0xf1e2)) (f64.const -nan:0x800000000f1e2))
(assert_return (invoke "min" (f64.const nan:0xf1e2) (f64.const 0x1p0)) (f64.const nan:0x800000000f1e2))
(assert_return (invoke "min" (f64.const 0x1p0) (f64.const nan:0xf1e2)) (f64.const nan:0x800000000f1e2))
(assert_return (invoke "min" (f64.const -nan:0xf1e2) (f64.const 0x1p0)) (f64.const -nan:0x800000000f1e2))
(assert_return (invoke "min" (f64.const 0x1p0) (f64.const -nan:0xf1e2)) (f64.const -nan:0x800000000f1e2))
(assert_return (invoke "min" (f64.const nan:0xf1e2) (f64.const nan:0xf1e2)) (f64.const nan:0x800000000f1e2))
(assert_return (invoke "max" (f64.const nan:0xf1e2) (f64.const 0x1p0)) (f64.const nan:0x800000000f1e2))
(assert_return (invoke "max" (f64.const 0x1p0) (f64.const nan:0xf1e2)) (f64.const nan:0x800000000f1e2))
(assert_return (invoke "max" (f64.const -nan:0xf1e2) (f64.const 0x1p0)) (f64.const -nan:0x800000000f1e2))
(assert_return (invoke "max" (f64.const 0x1p0) (f64.const -nan:0xf1e2)) (f64.const -nan:0x800000000f1e2))
(assert_return (invoke "max" (f64.const nan:0xf1e2) (f64.const nan:0xf1e2)) (f64.const nan:0x800000000f1e2))
(assert_return (invoke "ceil" (f64.const nan:0xf1e2)) (f64.const nan:0x800000000f1e2))
(assert_return (invoke "ceil" (f64.const -nan:0xf1e2)) (f64.const -nan:0x800000000f1e2))
(assert_return (invoke "floor" (f64.const nan:0xf1e2)) (f64.const nan:0x800000000f1e2))
(assert_return (invoke "floor" (f64.const -nan:0xf1e2)) (f64.const -nan:0x800000000f1e2))
(assert_return (invoke "trunc" (f64.const nan:0xf1e2)) (f64.const nan:0x800000000f1e2))
(assert_return (invoke "trunc" (f64.const -nan:0xf1e2)) (f64.const -nan:0x800000000f1e2))
(assert_return (invoke "nearest" (f64.const nan:0xf1e2)) (f64.const nan:0x800000000f1e2))
(assert_return (invoke "nearest" (f64.const -nan:0xf1e2)) (f64.const -nan:0x800000000f1e2))
(assert_return (invoke "abs" (f64.const nan:0xf1e2)) (f64.const nan:0xf1e2))
(assert_return (invoke "abs" (f64.const -nan:0xf1e2)) (f64.const nan:0xf1e2))
(assert_return (invoke "neg" (f64.const nan:0xf1e2)) (f64.const -nan:0xf1e2))
(assert_return (invoke "neg" (f64.const -nan:0xf1e2)) (f64.const nan:0xf1e2))
(assert_return (invoke "copysign" (f64.const nan:0xf1e2) (f64.const 0x1p0)) (f64.const nan:0xf1e2))
(assert_return (invoke "copysign" (f64.const nan:0xf1e2) (f64.const -0x1p0)) (f64.const -nan:0xf1e2))
(assert_return (invoke "copysign" (f64.const -nan:0xf1e2) (f64.const 0x1p0)) (f64.const nan:0xf1e2))
(assert_return (invoke "copysign" (f64.const -nan:0xf1e2) (f64.const -0x1p0)) (f64.const -nan:0xf1e2))
(module
(func $f64.promote_f32 (param $x f32) (result f64) (f64.promote/f32 (get_local $x)))
(export "f64.promote_f32" $f64.promote_f32)
(func $f32.demote_f64 (param $x f64) (result f32) (f32.demote/f64 (get_local $x)))
(export "f32.demote_f64" $f32.demote_f64)
(func $f32.reinterpret_i32 (param $x i32) (result f32) (f32.reinterpret/i32 (get_local $x)))
(export "f32.reinterpret_i32" $f32.reinterpret_i32)
(func $f64.reinterpret_i64 (param $x i64) (result f64) (f64.reinterpret/i64 (get_local $x)))
(export "f64.reinterpret_i64" $f64.reinterpret_i64)
)
(assert_return (invoke "f64.promote_f32" (f32.const nan:0xf1e2)) (f64.const nan:0x81e3c40000000))
(assert_return (invoke "f32.demote_f64" (f64.const nan:0xf1e2f1e2f1e2)) (f32.const nan:0x478f17))
(assert_return (invoke "f32.reinterpret_i32" (i32.const 0x7f876543)) (f32.const nan:0x76543))
(assert_return (invoke "f64.reinterpret_i64" (i64.const 0x7ff0123456789abc)) (f64.const nan:0x0123456789abc))

41
js/src/jit-test/tests/wasm/spec/resizing.wast Normal file
View File

@ -0,0 +1,41 @@
(module
(memory 0)
(export "load_at_zero" $load_at_zero)
(func $load_at_zero (result i32) (i32.load (i32.const 0)))
(export "store_at_zero" $store_at_zero)
(func $store_at_zero (result i32) (i32.store (i32.const 0) (i32.const 2)))
(export "load_at_page_size" $load_at_page_size)
(func $load_at_page_size (result i32) (i32.load (i32.const 0x10000)))
(export "store_at_page_size" $store_at_page_size)
(func $store_at_page_size (result i32) (i32.store (i32.const 0x10000) (i32.const 3)))
(export "grow" $grow)
(func $grow (param $sz i32) (result i32) (grow_memory (get_local $sz)))
(export "size" $size)
(func $size (result i32) (current_memory))
)
(assert_return (invoke "size") (i32.const 0))
(assert_trap (invoke "store_at_zero") "out of bounds memory access")
(assert_trap (invoke "load_at_zero") "out of bounds memory access")
(assert_trap (invoke "store_at_page_size") "out of bounds memory access")
(assert_trap (invoke "load_at_page_size") "out of bounds memory access")
(assert_return (invoke "grow" (i32.const 1)) (i32.const 0))
(assert_return (invoke "size") (i32.const 1))
(assert_return (invoke "load_at_zero") (i32.const 0))
(assert_return (invoke "store_at_zero") (i32.const 2))
(assert_return (invoke "load_at_zero") (i32.const 2))
(assert_trap (invoke "store_at_page_size") "out of bounds memory access")
(assert_trap (invoke "load_at_page_size") "out of bounds memory access")
(assert_return (invoke "grow" (i32.const 4)) (i32.const 1))
(assert_return (invoke "size") (i32.const 5))
(assert_return (invoke "load_at_zero") (i32.const 2))
(assert_return (invoke "store_at_zero") (i32.const 2))
(assert_return (invoke "load_at_page_size") (i32.const 0))
(assert_return (invoke "store_at_page_size") (i32.const 3))
(assert_return (invoke "load_at_page_size") (i32.const 3))

17
js/src/jit-test/tests/wasm/spec/runaway-recursion.wast Normal file
View File

@ -0,0 +1,17 @@
(module
;; Implementations are required to have every call consume some abstract
;; resource towards exhausting some abstract finite limit, such that
;; infinitely recursive testcases reliably trap in finite time. This is
;; because otherwise applications could come to depend on it on those
;; implementations and be incompatible with implementations that don't do
;; it (or don't do it under the same circumstances).
(func (call 0))
(export "runaway" 0)
(func $a (call $b))
(func $b (call $a))
(export "mutual_runaway" $a)
)
(assert_trap (invoke "runaway") "call stack exhausted")
(assert_trap (invoke "mutual_runaway") "call stack exhausted")

59
js/src/jit-test/tests/wasm/spec/select.wast Normal file
View File

@ -0,0 +1,59 @@
(module
(func $select_i32 (param $lhs i32) (param $rhs i32) (param $cond i32) (result i32)
(select (get_local $lhs) (get_local $rhs) (get_local $cond)))
(func $select_i64 (param $lhs i64) (param $rhs i64) (param $cond i32) (result i64)
(select (get_local $lhs) (get_local $rhs) (get_local $cond)))
(func $select_f32 (param $lhs f32) (param $rhs f32) (param $cond i32) (result f32)
(select (get_local $lhs) (get_local $rhs) (get_local $cond)))
(func $select_f64 (param $lhs f64) (param $rhs f64) (param $cond i32) (result f64)
(select (get_local $lhs) (get_local $rhs) (get_local $cond)))
;; Check that both sides of the select are evaluated
(func $select_trap_l (param $cond i32) (result i32)
(select (unreachable) (i32.const 0) (get_local $cond)))
(func $select_trap_r (param $cond i32) (result i32)
(select (i32.const 0) (unreachable) (get_local $cond)))
(export "select_i32" $select_i32)
(export "select_i64" $select_i64)
(export "select_f32" $select_f32)
(export "select_f64" $select_f64)
(export "select_trap_l" $select_trap_l)
(export "select_trap_r" $select_trap_r)
)
(assert_return (invoke "select_i32" (i32.const 1) (i32.const 2) (i32.const 1)) (i32.const 1))
(assert_return (invoke "select_i64" (i64.const 2) (i64.const 1) (i32.const 1)) (i64.const 2))
(assert_return (invoke "select_f32" (f32.const 1) (f32.const 2) (i32.const 1)) (f32.const 1))
(assert_return (invoke "select_f64" (f64.const 1) (f64.const 2) (i32.const 1)) (f64.const 1))
(assert_return (invoke "select_i32" (i32.const 1) (i32.const 2) (i32.const 0)) (i32.const 2))
(assert_return (invoke "select_i32" (i32.const 2) (i32.const 1) (i32.const 0)) (i32.const 1))
(assert_return (invoke "select_i64" (i64.const 2) (i64.const 1) (i32.const -1)) (i64.const 2))
(assert_return (invoke "select_i64" (i64.const 2) (i64.const 1) (i32.const 0xf0f0f0f0)) (i64.const 2))
(assert_return (invoke "select_f32" (f32.const nan) (f32.const 1) (i32.const 1)) (f32.const nan))
(assert_return (invoke "select_f32" (f32.const nan:0x20304) (f32.const 1) (i32.const 1)) (f32.const nan:0x20304))
(assert_return (invoke "select_f32" (f32.const nan) (f32.const 1) (i32.const 0)) (f32.const 1))
(assert_return (invoke "select_f32" (f32.const nan:0x20304) (f32.const 1) (i32.const 0)) (f32.const 1))
(assert_return (invoke "select_f32" (f32.const 2) (f32.const nan) (i32.const 1)) (f32.const 2))
(assert_return (invoke "select_f32" (f32.const 2) (f32.const nan:0x20304) (i32.const 1)) (f32.const 2))
(assert_return (invoke "select_f32" (f32.const 2) (f32.const nan) (i32.const 0)) (f32.const nan))
(assert_return (invoke "select_f32" (f32.const 2) (f32.const nan:0x20304) (i32.const 0)) (f32.const nan:0x20304))
(assert_return (invoke "select_f64" (f64.const nan) (f64.const 1) (i32.const 1)) (f64.const nan))
(assert_return (invoke "select_f64" (f64.const nan:0x20304) (f64.const 1) (i32.const 1)) (f64.const nan:0x20304))
(assert_return (invoke "select_f64" (f64.const nan) (f64.const 1) (i32.const 0)) (f64.const 1))
(assert_return (invoke "select_f64" (f64.const nan:0x20304) (f64.const 1) (i32.const 0)) (f64.const 1))
(assert_return (invoke "select_f64" (f64.const 2) (f64.const nan) (i32.const 1)) (f64.const 2))
(assert_return (invoke "select_f64" (f64.const 2) (f64.const nan:0x20304) (i32.const 1)) (f64.const 2))
(assert_return (invoke "select_f64" (f64.const 2) (f64.const nan) (i32.const 0)) (f64.const nan))
(assert_return (invoke "select_f64" (f64.const 2) (f64.const nan:0x20304) (i32.const 0)) (f64.const nan:0x20304))
(assert_trap (invoke "select_trap_l" (i32.const 1)) "unreachable executed")
(assert_trap (invoke "select_trap_l" (i32.const 0)) "unreachable executed")
(assert_trap (invoke "select_trap_r" (i32.const 1)) "unreachable executed")
(assert_trap (invoke "select_trap_r" (i32.const 0)) "unreachable executed")

89
js/src/jit-test/tests/wasm/spec/start.wast Normal file
View File

@ -0,0 +1,89 @@
(assert_invalid
(module (func (i32.const 1)) (start 1))
"unknown function 1"
)
(assert_invalid
(module
(func $main (result i32) (return (i32.const 0)))
(start $main)
)
"start function must not return anything"
)
(assert_invalid
(module
(func $main (param $a i32))
(start $main)
)
"start function must be nullary"
)
(module
(memory 1 (segment 0 "A"))
(func $inc
(i32.store8
(i32.const 0)
(i32.add
(i32.load8_u (i32.const 0))
(i32.const 1)
)
)
)
(func $get (result i32)
(return (i32.load8_u (i32.const 0)))
)
(func $main
(call $inc)
(call $inc)
(call $inc)
)
(start $main)
(export "inc" $inc)
(export "get" $get)
)
(assert_return (invoke "get") (i32.const 68))
(invoke "inc")
(assert_return (invoke "get") (i32.const 69))
(invoke "inc")
(assert_return (invoke "get") (i32.const 70))
(module
(memory 1 (segment 0 "A"))
(func $inc
(i32.store8
(i32.const 0)
(i32.add
(i32.load8_u (i32.const 0))
(i32.const 1)
)
)
)
(func $get (result i32)
(return (i32.load8_u (i32.const 0)))
)
(func $main
(call $inc)
(call $inc)
(call $inc)
)
(start 2)
(export "inc" $inc)
(export "get" $get)
)
(assert_return (invoke "get") (i32.const 68))
(invoke "inc")
(assert_return (invoke "get") (i32.const 69))
(invoke "inc")
(assert_return (invoke "get") (i32.const 70))
(module
(import $print_i32 "spectest" "print" (param i32))
(func $main
(call_import $print_i32 (i32.const 1)))
(start 0)
)
(module
(import $print_i32 "spectest" "print" (param i32))
(func $main
(call_import $print_i32 (i32.const 2)))
(start $main)
)

51
js/src/jit-test/tests/wasm/spec/store_retval.wast Normal file
View File

@ -0,0 +1,51 @@
(module
(memory 1)
(import $print_i32 "spectest" "print" (param i32))
(import $print_i64 "spectest" "print" (param i64))
(import $print_f32 "spectest" "print" (param f32))
(import $print_f64 "spectest" "print" (param f64))
(func $run
(local $i32 i32) (local $i64 i64) (local $f32 f32) (local $f64 f64)
(call_import $print_i32 (set_local $i32 (i32.const 1)))
(call_import $print_i64 (set_local $i64 (i64.const 2)))
(call_import $print_f32 (set_local $f32 (f32.const 3)))
(call_import $print_f64 (set_local $f64 (f64.const 4)))
(call_import $print_i32 (i32.store (i32.const 0) (i32.const 11)))
(call_import $print_i64 (i64.store (i32.const 0) (i64.const 12)))
(call_import $print_f32 (f32.store (i32.const 0) (f32.const 13)))
(call_import $print_f64 (f64.store (i32.const 0) (f64.const 14)))
(call_import $print_i32 (i32.store8 (i32.const 0) (i32.const 512)))
(call_import $print_i32 (i32.store16 (i32.const 0) (i32.const 65536)))
(call_import $print_i64 (i64.store8 (i32.const 0) (i64.const 512)))
(call_import $print_i64 (i64.store16 (i32.const 0) (i64.const 65536)))
(call_import $print_i64 (i64.store32 (i32.const 0) (i64.const 4294967296)))
)
(export "run" $run)
)
(invoke "run")
(assert_invalid
(module (func (local $i32 i32) (local $i64 i64)
(set_local $i64 (set_local $i32 (i32.const 1)))))
"type mismatch: expression has type i32 but the context requires i64"
)
(assert_invalid
(module (func (local $i32 i32) (local $i64 i64)
(set_local $i32 (set_local $i64 (i64.const 1)))))
"type mismatch: expression has type i64 but the context requires i32"
)
(assert_invalid
(module (func (local $f32 f32) (local $f64 f64)
(set_local $f64 (set_local $f32 (f32.const 1)))))
"type mismatch: expression has type f32 but the context requires f64"
)
(assert_invalid
(module (func (local $f32 f32) (local $f64 f64)
(set_local $f32 (set_local $f64 (f64.const 1)))))
"type mismatch: expression has type f64 but the context requires f32"
)

155
js/src/jit-test/tests/wasm/spec/switch.wast Normal file
View File

@ -0,0 +1,155 @@
(module
;; Statement switch
(func $stmt (param $i i32) (result i32)
(local $j i32)
(set_local $j (i32.const 100))
(block $switch
(block $7
(block $default
(block $6
(block $5
(block $4
(block $3
(block $2
(block $1
(block $0
(br_table $0 $1 $2 $3 $4 $5 $6 $7 $default
(get_local $i)
)
) ;; 0
(return (get_local $i))
) ;; 1
(nop)
;; fallthrough
) ;; 2
;; fallthrough
) ;; 3
(set_local $j (i32.sub (i32.const 0) (get_local $i)))
(br $switch)
) ;; 4
(br $switch)
) ;; 5
(set_local $j (i32.const 101))
(br $switch)
) ;; 6
(set_local $j (i32.const 101))
;; fallthrough
) ;; default
(set_local $j (i32.const 102))
) ;; 7
;; fallthrough
)
(return (get_local $j))
)
;; Expression switch
(func $expr (param $i i64) (result i64)
(local $j i64)
(set_local $j (i64.const 100))
(return
(block $switch
(block $7
(block $default
(block $4
(block $5
(block $6
(block $3
(block $2
(block $1
(block $0
(br_table $0 $1 $2 $3 $4 $5 $6 $7 $default
(i32.wrap/i64 (get_local $i))
)
) ;; 0
(return (get_local $i))
) ;; 1
(nop)
;; fallthrough
) ;; 2
;; fallthrough
) ;; 3
(br $switch (i64.sub (i64.const 0) (get_local $i)))
) ;; 6
(set_local $j (i64.const 101))
;; fallthrough
) ;; 4
;; fallthrough
) ;; 5
;; fallthrough
) ;; default
(br $switch (get_local $j))
) ;; 7
(i64.const -5)
)
)
)
;; Argument switch
(func $arg (param $i i32) (result i32)
(return
(block $2
(i32.add (i32.const 10)
(block $1
(i32.add (i32.const 100)
(block $0
(i32.add (i32.const 1000)
(block $default
(br_table $0 $1 $2 $default
(i32.mul (i32.const 2) (get_local $i))
(i32.and (i32.const 3) (get_local $i))
)
)
)
)
)
)
)
)
)
)
;; Corner cases
(func $corner (result i32)
(block
(br_table 0 (i32.const 0))
)
(i32.const 1)
)
(export "stmt" $stmt)
(export "expr" $expr)
(export "arg" $arg)
(export "corner" $corner)
)
(assert_return (invoke "stmt" (i32.const 0)) (i32.const 0))
(assert_return (invoke "stmt" (i32.const 1)) (i32.const -1))
(assert_return (invoke "stmt" (i32.const 2)) (i32.const -2))
(assert_return (invoke "stmt" (i32.const 3)) (i32.const -3))
(assert_return (invoke "stmt" (i32.const 4)) (i32.const 100))
(assert_return (invoke "stmt" (i32.const 5)) (i32.const 101))
(assert_return (invoke "stmt" (i32.const 6)) (i32.const 102))
(assert_return (invoke "stmt" (i32.const 7)) (i32.const 100))
(assert_return (invoke "stmt" (i32.const -10)) (i32.const 102))
(assert_return (invoke "expr" (i64.const 0)) (i64.const 0))
(assert_return (invoke "expr" (i64.const 1)) (i64.const -1))
(assert_return (invoke "expr" (i64.const 2)) (i64.const -2))
(assert_return (invoke "expr" (i64.const 3)) (i64.const -3))
(assert_return (invoke "expr" (i64.const 6)) (i64.const 101))
(assert_return (invoke "expr" (i64.const 7)) (i64.const -5))
(assert_return (invoke "expr" (i64.const -10)) (i64.const 100))
(assert_return (invoke "arg" (i32.const 0)) (i32.const 110))
(assert_return (invoke "arg" (i32.const 1)) (i32.const 12))
(assert_return (invoke "arg" (i32.const 2)) (i32.const 4))
(assert_return (invoke "arg" (i32.const 3)) (i32.const 1116))
(assert_return (invoke "arg" (i32.const 4)) (i32.const 118))
(assert_return (invoke "arg" (i32.const 5)) (i32.const 20))
(assert_return (invoke "arg" (i32.const 6)) (i32.const 12))
(assert_return (invoke "arg" (i32.const 7)) (i32.const 1124))
(assert_return (invoke "arg" (i32.const 8)) (i32.const 126))
(assert_return (invoke "corner") (i32.const 1))
(assert_invalid (module (func (br_table 3 (i32.const 0)))) "unknown label")

90
js/src/jit-test/tests/wasm/spec/traps.wast Normal file
View File

@ -0,0 +1,90 @@
;; Test that traps are preserved even in instructions which might otherwise
;; be dead-code-eliminated. These functions all perform an operation and
;; discard its return value.
(module
(func $no_dce.i32.div_s (param $x i32) (param $y i32)
(i32.div_s (get_local $x) (get_local $y)))
(func $no_dce.i32.div_u (param $x i32) (param $y i32)
(i32.div_u (get_local $x) (get_local $y)))
(func $no_dce.i64.div_s (param $x i64) (param $y i64)
(i64.div_s (get_local $x) (get_local $y)))
(func $no_dce.i64.div_u (param $x i64) (param $y i64)
(i64.div_u (get_local $x) (get_local $y)))
(export "no_dce.i32.div_s" $no_dce.i32.div_s)
(export "no_dce.i32.div_u" $no_dce.i32.div_u)
(export "no_dce.i64.div_s" $no_dce.i64.div_s)
(export "no_dce.i64.div_u" $no_dce.i64.div_u)
)
(assert_trap (invoke "no_dce.i32.div_s" (i32.const 1) (i32.const 0)) "integer divide by zero")
(assert_trap (invoke "no_dce.i32.div_u" (i32.const 1) (i32.const 0)) "integer divide by zero")
(assert_trap (invoke "no_dce.i64.div_s" (i64.const 1) (i64.const 0)) "integer divide by zero")
(assert_trap (invoke "no_dce.i64.div_u" (i64.const 1) (i64.const 0)) "integer divide by zero")
(module
(func $no_dce.i32.rem_s (param $x i32) (param $y i32)
(i32.rem_s (get_local $x) (get_local $y)))
(func $no_dce.i32.rem_u (param $x i32) (param $y i32)
(i32.rem_u (get_local $x) (get_local $y)))
(func $no_dce.i64.rem_s (param $x i64) (param $y i64)
(i64.rem_s (get_local $x) (get_local $y)))
(func $no_dce.i64.rem_u (param $x i64) (param $y i64)
(i64.rem_u (get_local $x) (get_local $y)))
(export "no_dce.i32.rem_s" $no_dce.i32.rem_s)
(export "no_dce.i32.rem_u" $no_dce.i32.rem_u)
(export "no_dce.i64.rem_s" $no_dce.i64.rem_s)
(export "no_dce.i64.rem_u" $no_dce.i64.rem_u)
)
(assert_trap (invoke "no_dce.i32.rem_s" (i32.const 1) (i32.const 0)) "integer divide by zero")
(assert_trap (invoke "no_dce.i32.rem_u" (i32.const 1) (i32.const 0)) "integer divide by zero")
(assert_trap (invoke "no_dce.i64.rem_s" (i64.const 1) (i64.const 0)) "integer divide by zero")
(assert_trap (invoke "no_dce.i64.rem_u" (i64.const 1) (i64.const 0)) "integer divide by zero")
(module
(func $no_dce.i32.trunc_s_f32 (param $x f32) (i32.trunc_s/f32 (get_local $x)))
(func $no_dce.i32.trunc_u_f32 (param $x f32) (i32.trunc_u/f32 (get_local $x)))
(func $no_dce.i32.trunc_s_f64 (param $x f64) (i32.trunc_s/f64 (get_local $x)))
(func $no_dce.i32.trunc_u_f64 (param $x f64) (i32.trunc_u/f64 (get_local $x)))
(func $no_dce.i64.trunc_s_f32 (param $x f32) (i64.trunc_s/f32 (get_local $x)))
(func $no_dce.i64.trunc_u_f32 (param $x f32) (i64.trunc_u/f32 (get_local $x)))
(func $no_dce.i64.trunc_s_f64 (param $x f64) (i64.trunc_s/f64 (get_local $x)))
(func $no_dce.i64.trunc_u_f64 (param $x f64) (i64.trunc_u/f64 (get_local $x)))
(export "no_dce.i32.trunc_s_f32" $no_dce.i32.trunc_s_f32)
(export "no_dce.i32.trunc_u_f32" $no_dce.i32.trunc_u_f32)
(export "no_dce.i32.trunc_s_f64" $no_dce.i32.trunc_s_f64)
(export "no_dce.i32.trunc_u_f64" $no_dce.i32.trunc_u_f64)
(export "no_dce.i64.trunc_s_f32" $no_dce.i64.trunc_s_f32)
(export "no_dce.i64.trunc_u_f32" $no_dce.i64.trunc_u_f32)
(export "no_dce.i64.trunc_s_f64" $no_dce.i64.trunc_s_f64)
(export "no_dce.i64.trunc_u_f64" $no_dce.i64.trunc_u_f64)
)
(assert_trap (invoke "no_dce.i32.trunc_s_f32" (f32.const nan)) "invalid conversion to integer")
(assert_trap (invoke "no_dce.i32.trunc_u_f32" (f32.const nan)) "invalid conversion to integer")
(assert_trap (invoke "no_dce.i32.trunc_s_f64" (f64.const nan)) "invalid conversion to integer")
(assert_trap (invoke "no_dce.i32.trunc_u_f64" (f64.const nan)) "invalid conversion to integer")
(assert_trap (invoke "no_dce.i64.trunc_s_f32" (f32.const nan)) "invalid conversion to integer")
(assert_trap (invoke "no_dce.i64.trunc_u_f32" (f32.const nan)) "invalid conversion to integer")
(assert_trap (invoke "no_dce.i64.trunc_s_f64" (f64.const nan)) "invalid conversion to integer")
(assert_trap (invoke "no_dce.i64.trunc_u_f64" (f64.const nan)) "invalid conversion to integer")
(module
(memory 1)
(export "no_dce.i32.load" $no_dce.i32.load)
(func $no_dce.i32.load (param $i i32) (i32.load (get_local $i)))
(export "no_dce.i64.load" $no_dce.i64.load)
(func $no_dce.i64.load (param $i i32) (i64.load (get_local $i)))
(export "no_dce.f32.load" $no_dce.f32.load)
(func $no_dce.f32.load (param $i i32) (f32.load (get_local $i)))
(export "no_dce.f64.load" $no_dce.f64.load)
(func $no_dce.f64.load (param $i i32) (f64.load (get_local $i)))
)
(assert_trap (invoke "no_dce.i32.load" (i32.const 65536)) "out of bounds memory access")
(assert_trap (invoke "no_dce.i64.load" (i32.const 65536)) "out of bounds memory access")
(assert_trap (invoke "no_dce.f32.load" (i32.const 65536)) "out of bounds memory access")
(assert_trap (invoke "no_dce.f64.load" (i32.const 65536)) "out of bounds memory access")

41
js/src/jit-test/tests/wasm/spec/unreachable.wast Normal file
View File

@ -0,0 +1,41 @@
(module
(func $return_i32 (result i32)
(unreachable))
(func $return_f64 (result f64)
(unreachable))
(func $if (param i32) (result f32)
(if (get_local 0) (unreachable) (f32.const 0)))
(func $block
(block (i32.const 1) (unreachable) (i32.const 2)))
(func $return_i64 (result i64)
(return (i64.const 1))
(unreachable))
(func $call (result f64)
(call $return_i32)
(unreachable))
(func $misc1 (result i32)
(i32.xor (unreachable) (i32.const 10))
)
(export "return_i32" $return_i32)
(export "return_f64" $return_f64)
(export "if" $if)
(export "block" $block)
(export "return_i64" $return_i64)
(export "call" $call)
(export "misc1" $misc1)
)
(assert_trap (invoke "return_i32") "unreachable executed")
(assert_trap (invoke "return_f64") "unreachable executed")
(assert_trap (invoke "if" (i32.const 1)) "unreachable executed")
(assert_return (invoke "if" (i32.const 0)) (f32.const 0))
(assert_trap (invoke "block") "unreachable executed")
(assert_return (invoke "return_i64") (i64.const 1))
(assert_trap (invoke "call") "unreachable executed")
(assert_trap (invoke "misc1") "unreachable executed")