mirror of
https://github.com/mozilla/gecko-dev.git
synced 2024-10-25 11:15:34 +00:00
Bug 1265461: Import wast files; r=mbx
MozReview-Commit-ID: 6ad3QkZMYkS --HG-- extra : rebase_source : a9e6048bffa86dd17c41eb8c421244219bf30983 extra : histedit_source : ed1625830738716b40bdc1db882edf42da9240b1
This commit is contained in:
parent
50e90e1537
commit
b687699fa6
34
js/src/jit-test/tests/wasm/spec/address.wast
Normal file
34
js/src/jit-test/tests/wasm/spec/address.wast
Normal 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
14
js/src/jit-test/tests/wasm/spec/binary.wast
Normal 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
35
js/src/jit-test/tests/wasm/spec/block.wast
Normal 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
15
js/src/jit-test/tests/wasm/spec/block_comments.wast
Normal 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
64
js/src/jit-test/tests/wasm/spec/break-drop.wast
Normal 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
453
js/src/jit-test/tests/wasm/spec/conversions.wast
Normal 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
241
js/src/jit-test/tests/wasm/spec/endianness.wast
Normal 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
26
js/src/jit-test/tests/wasm/spec/exports.wast
Normal 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
2429
js/src/jit-test/tests/wasm/spec/f32.wast
Normal file
File diff suppressed because it is too large
Load Diff
1963
js/src/jit-test/tests/wasm/spec/f32_cmp.wast
Normal file
1963
js/src/jit-test/tests/wasm/spec/f32_cmp.wast
Normal file
File diff suppressed because it is too large
Load Diff
2429
js/src/jit-test/tests/wasm/spec/f64.wast
Normal file
2429
js/src/jit-test/tests/wasm/spec/f64.wast
Normal file
File diff suppressed because it is too large
Load Diff
1963
js/src/jit-test/tests/wasm/spec/f64_cmp.wast
Normal file
1963
js/src/jit-test/tests/wasm/spec/f64_cmp.wast
Normal file
File diff suppressed because it is too large
Load Diff
87
js/src/jit-test/tests/wasm/spec/fac.wast
Normal file
87
js/src/jit-test/tests/wasm/spec/fac.wast
Normal 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
1738
js/src/jit-test/tests/wasm/spec/float_exprs.wast
Normal 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
199
js/src/jit-test/tests/wasm/spec/float_literals.wast
Normal 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
211
js/src/jit-test/tests/wasm/spec/float_memory.wast
Normal 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
585
js/src/jit-test/tests/wasm/spec/float_misc.wast
Normal 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
23
js/src/jit-test/tests/wasm/spec/forward.wast
Normal 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
94
js/src/jit-test/tests/wasm/spec/func_ptrs.wast
Normal 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
44
js/src/jit-test/tests/wasm/spec/functions.wast
Normal 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
418
js/src/jit-test/tests/wasm/spec/i32.wast
Normal 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
420
js/src/jit-test/tests/wasm/spec/i64.wast
Normal 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
14
js/src/jit-test/tests/wasm/spec/import_tests.sh
Executable 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
26
js/src/jit-test/tests/wasm/spec/imports.wast
Normal 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
330
js/src/jit-test/tests/wasm/spec/int_exprs.wast
Normal 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
61
js/src/jit-test/tests/wasm/spec/int_literals.wast
Normal 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
298
js/src/jit-test/tests/wasm/spec/labels.wast
Normal 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
281
js/src/jit-test/tests/wasm/spec/left-to-right.wast
Normal 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))
|
@ -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
235
js/src/jit-test/tests/wasm/spec/memory.wast
Normal 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
44
js/src/jit-test/tests/wasm/spec/memory_redundancy.wast
Normal 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
36
js/src/jit-test/tests/wasm/spec/memory_trap.wast
Normal 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")
|
@ -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
221
js/src/jit-test/tests/wasm/spec/nan-propagation.wast
Normal 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
41
js/src/jit-test/tests/wasm/spec/resizing.wast
Normal 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
17
js/src/jit-test/tests/wasm/spec/runaway-recursion.wast
Normal 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
59
js/src/jit-test/tests/wasm/spec/select.wast
Normal 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
89
js/src/jit-test/tests/wasm/spec/start.wast
Normal 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
51
js/src/jit-test/tests/wasm/spec/store_retval.wast
Normal 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
155
js/src/jit-test/tests/wasm/spec/switch.wast
Normal 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
90
js/src/jit-test/tests/wasm/spec/traps.wast
Normal 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
41
js/src/jit-test/tests/wasm/spec/unreachable.wast
Normal 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")
|
Loading…
Reference in New Issue
Block a user