| ;; Current Syntax: (type $i8_array) |
| ;; |
| ;; (func $test2 (export "test2") |
| ;; (i32.store (type $typeIdx) |
| ;; (global.get $arr_4) |
| ;; (i32.const 1) |
| ;; (i32.const 1337) |
| ;; ) |
| ;; ) |
| |
| ;; Alternative Syntax 1: type=array |
| ;; |
| ;; (func $test2 (export "test2") |
| ;; (i32.store type=array |
| ;; (global.get $arr_4) |
| ;; (i32.const 1) |
| ;; (i32.const 1337) |
| ;; ) |
| ;; ) |
| |
| ;; Alternative Syntax 2: array |
| ;; |
| ;; (func $test2 (export "test2") |
| ;; (i32.store array |
| ;; (global.get $arr_4) |
| ;; (i32.const 1) |
| ;; (i32.const 1337) |
| ;; ) |
| ;; ) |
| |
| ;; Alternative Syntax 3: new opcodes |
| ;; |
| ;; (func $test2 (export "test2") |
| ;; (i32.array.store |
| ;; (global.get $arr_4) |
| ;; (i32.const 1) |
| ;; (i32.const 1337) |
| ;; ) |
| ;; ) |
| |
| (module |
| (type $i8_array (array (mut i8))) |
| |
| (global $arr_4 (ref $i8_array) |
| (array.new_default $i8_array (i32.const 4)) |
| ) |
| |
| (global $arr_8 (ref $i8_array) |
| (array.new_default $i8_array (i32.const 8)) |
| ) |
| |
| (func $get_array_4_byte (export "get_array_4_byte") (param $idx i32) (result i32) |
| (array.get_u $i8_array (global.get $arr_4) (local.get $idx)) |
| ) |
| |
| (func $get_array_8_byte (export "get_array_8_byte") (param $idx i32) (result i32) |
| (array.get_u $i8_array (global.get $arr_8) (local.get $idx)) |
| ) |
| |
| (func $i32_set_i8 (export "i32_set_i8") (param $index i32) (param $value i32) |
| (i32.store8 (type $i8_array) |
| (global.get $arr_4) |
| (local.get $index) |
| (local.get $value) |
| ) |
| ) |
| |
| (func $i32_set_i16 (export "i32_set_i16") (param $index i32) (param $value i32) |
| (i32.store16 (type $i8_array) |
| (global.get $arr_4) |
| (local.get $index) |
| (local.get $value) |
| ) |
| ) |
| |
| (func $i32_set_i32 (export "i32_set_i32") (param $index i32) (param $value i32) |
| (i32.store (type $i8_array) |
| (global.get $arr_4) |
| (local.get $index) |
| (local.get $value) |
| ) |
| ) |
| |
| (func $f32_set (export "f32_set") (param $index i32) (param $value f32) |
| (f32.store (type $i8_array) |
| (global.get $arr_4) |
| (local.get $index) |
| (local.get $value) |
| ) |
| ) |
| |
| (func $i64_set_i8 (export "i64_set_i8") (param $index i32) (param $value i64) |
| (i64.store8 (type $i8_array) |
| (global.get $arr_8) |
| (local.get $index) |
| (local.get $value) |
| ) |
| ) |
| |
| (func $i64_set_i16 (export "i64_set_i16") (param $index i32) (param $value i64) |
| (i64.store16 (type $i8_array) |
| (global.get $arr_8) |
| (local.get $index) |
| (local.get $value) |
| ) |
| ) |
| |
| (func $i64_set_i32 (export "i64_set_i32") (param $index i32) (param $value i64) |
| (i64.store32 (type $i8_array) |
| (global.get $arr_8) |
| (local.get $index) |
| (local.get $value) |
| ) |
| ) |
| |
| (func $i64_set_i64 (export "i64_set_i64") (param $index i32) (param $value i64) |
| (i64.store (type $i8_array) |
| (global.get $arr_8) |
| (local.get $index) |
| (local.get $value) |
| ) |
| ) |
| |
| (func $f64_set (export "f64_set") (param $index i32) (param $value f64) |
| (f64.store (type $i8_array) |
| (global.get $arr_8) |
| (local.get $index) |
| (local.get $value) |
| ) |
| ) |
| |
| ;; TODO: Do we even want to spec out this instruction since array.set is the |
| ;; same thing? See |
| ;; https://github.com/WebAssembly/multibyte-array-access/issues/2 |
| (func $i32_set_and_get_i8 (export "i32_set_and_get_i8") (param $value i32) (result i32) |
| (i32.store8 (type $i8_array) |
| (global.get $arr_4) |
| (i32.const 0) |
| (local.get $value) |
| ) |
| (i32.load8_u (type $i8_array) (global.get $arr_4) (i32.const 0)) |
| ) |
| |
| (func $i32_set_and_get_i16 (export "i32_set_and_get_i16") (param $value i32) (result i32) |
| (i32.store16 (type $i8_array) |
| (global.get $arr_4) |
| (i32.const 0) |
| (local.get $value) |
| ) |
| (i32.load16_u (type $i8_array) (global.get $arr_4) (i32.const 0)) |
| ) |
| |
| (func $i32_set_and_get_i32 (export "i32_set_and_get_i32") (param $value i32) (result i32) |
| (i32.store (type $i8_array) |
| (global.get $arr_4) |
| (i32.const 0) |
| (local.get $value) |
| ) |
| (i32.load (type $i8_array) (global.get $arr_4) (i32.const 0)) |
| ) |
| |
| (func $set_and_get_f32 (export "set_and_get_f32") (param $value f32) (result f32) |
| (f32.store (type $i8_array) |
| (global.get $arr_4) |
| (i32.const 0) |
| (local.get $value) |
| ) |
| (i32.load (type $i8_array) (global.get $arr_4) (i32.const 0)) |
| (f32.reinterpret_i32) |
| ) |
| |
| (func $i64_set_and_get_i8 (export "i64_set_and_get_i8") (param $value i64) (result i64) |
| (i64.store8 (type $i8_array) |
| (global.get $arr_8) |
| (i32.const 0) |
| (local.get $value) |
| ) |
| (i64.load8_u (type $i8_array) (global.get $arr_8) (i32.const 0)) |
| ) |
| |
| (func $i64_set_and_get_i16 (export "i64_set_and_get_i16") (param $value i64) (result i64) |
| (i64.store16 (type $i8_array) |
| (global.get $arr_8) |
| (i32.const 0) |
| (local.get $value) |
| ) |
| (i64.load16_u (type $i8_array) (global.get $arr_8) (i32.const 0)) |
| ) |
| |
| (func $i64_set_and_get_i32 (export "i64_set_and_get_i32") (param $value i64) (result i64) |
| (i64.store32 (type $i8_array) |
| (global.get $arr_8) |
| (i32.const 0) |
| (local.get $value) |
| ) |
| (i64.load32_u (type $i8_array) (global.get $arr_8) (i32.const 0)) |
| ) |
| |
| (func $i64_set_and_get_i64 (export "i64_set_and_get_i64") (param $value i64) (result i64) |
| (i64.store (type $i8_array) |
| (global.get $arr_8) |
| (i32.const 0) |
| (local.get $value) |
| ) |
| (i64.load (type $i8_array) (global.get $arr_8) (i32.const 0)) |
| ) |
| |
| (func $set_and_get_f64 (export "set_and_get_f64") (param $value f64) (result f64) |
| (f64.store (type $i8_array) |
| (global.get $arr_8) |
| (i32.const 0) |
| (local.get $value) |
| ) |
| (i64.load (type $i8_array) (global.get $arr_8) (i32.const 0)) |
| (f64.reinterpret_i64) |
| ) |
| (func $load_i32_16_u (export "load_i32_16_u") (param $idx i32) (result i32) |
| (i32.load16_u (type $i8_array) (global.get $arr_4) (local.get $idx)) |
| ) |
| |
| (func $load_i32_16_s (export "load_i32_16_s") (param $idx i32) (result i32) |
| (i32.load16_s (type $i8_array) (global.get $arr_4) (local.get $idx)) |
| ) |
| |
| (func $load_i32 (export "load_i32") (param $idx i32) (result i32) |
| (i32.load (type $i8_array) (global.get $arr_4) (local.get $idx)) |
| ) |
| (func $load_i64 (export "load_i64") (param $idx i32) (result i64) |
| (i64.load (type $i8_array) (global.get $arr_8) (local.get $idx)) |
| ) |
| |
| (func $load_null (export "load_null") (result i32) |
| (local $null (ref null $i8_array)) |
| (i32.load (type $i8_array) (local.get $null) (i32.const 0)) |
| ) |
| ) |
| |
| ;; |
| ;; 32 bit round trip tests |
| ;; |
| |
| (assert_return (invoke "i32_set_and_get_i8" (i32.const 0)) (i32.const 0)) |
| (assert_return (invoke "i32_set_and_get_i8" (i32.const 0xFF)) (i32.const 0xFF)) |
| ;; ensure high bits are ignored |
| (assert_return (invoke "i32_set_and_get_i8" (i32.const 0xFFFFFF12)) (i32.const 0x12)) |
| |
| (assert_return (invoke "i32_set_and_get_i16" (i32.const 0)) (i32.const 0)) |
| (assert_return (invoke "i32_set_and_get_i16" (i32.const 0xFFFF)) (i32.const 0xFFFF)) |
| ;; ensure high bits are ignored |
| (assert_return (invoke "i32_set_and_get_i16" (i32.const 0xFFFF1234)) (i32.const 0x1234)) |
| |
| (assert_return (invoke "i32_set_and_get_i32" (i32.const 0)) (i32.const 0)) |
| (assert_return (invoke "i32_set_and_get_i32" (i32.const 1)) (i32.const 1)) |
| (assert_return (invoke "i32_set_and_get_i32" (i32.const 256)) (i32.const 256)) |
| (assert_return (invoke "i32_set_and_get_i32" (i32.const -1)) (i32.const -1)) |
| (assert_return (invoke "i32_set_and_get_i32" (i32.const 2147483647)) (i32.const 2147483647)) |
| (assert_return (invoke "i32_set_and_get_i32" (i32.const -2147483648)) (i32.const -2147483648)) |
| |
| (assert_return (invoke "set_and_get_f32" (f32.const 0)) (f32.const 0)) |
| (assert_return (invoke "set_and_get_f32" (f32.const -1)) (f32.const -1)) |
| (assert_return (invoke "set_and_get_f32" (f32.const 3.3)) (f32.const 3.3)) |
| (assert_return (invoke "set_and_get_f32" (f32.const -2.000000238418579)) (f32.const -2.000000238418579)) |
| (assert_return (invoke "set_and_get_f32" (f32.const nan)) (f32.const nan)) |
| (assert_return (invoke "set_and_get_f32" (f32.const nan:0x123456)) (f32.const nan:0x123456)) |
| (assert_return (invoke "set_and_get_f32" (f32.const -nan:0x654321)) (f32.const -nan:0x654321)) |
| |
| ;; |
| ;; 64 bit round trip tests |
| ;; |
| |
| (assert_return (invoke "i64_set_and_get_i8" (i64.const 0)) (i64.const 0)) |
| (assert_return (invoke "i64_set_and_get_i8" (i64.const 0xFF)) (i64.const 0xFF)) |
| ;; ensure high bits are ignored |
| (assert_return (invoke "i64_set_and_get_i8" (i64.const 0xFFFFFFFFFFFFFF12)) (i64.const 0x12)) |
| |
| (assert_return (invoke "i64_set_and_get_i16" (i64.const 0)) (i64.const 0)) |
| (assert_return (invoke "i64_set_and_get_i16" (i64.const 0xFFFF)) (i64.const 0xFFFF)) |
| ;; ensure high bits are ignored |
| (assert_return (invoke "i64_set_and_get_i16" (i64.const 0xFFFFFFFFFFFF1234)) (i64.const 0x1234)) |
| |
| (assert_return (invoke "i64_set_and_get_i32" (i64.const 0)) (i64.const 0)) |
| (assert_return (invoke "i64_set_and_get_i32" (i64.const 0x7FFFFFFF)) (i64.const 0x7FFFFFFF)) |
| ;; unsigned extend |
| (assert_return (invoke "i64_set_and_get_i32" (i64.const 0xFFFFFFFF80000000)) (i64.const 0x0000000080000000)) |
| ;; ensure high bits are ignored |
| (assert_return (invoke "i64_set_and_get_i32" (i64.const 0xFFFFFFFF12345678)) (i64.const 0x12345678)) |
| |
| (assert_return (invoke "i64_set_and_get_i64" (i64.const 0)) (i64.const 0)) |
| (assert_return (invoke "i64_set_and_get_i64" (i64.const 9223372036854775807)) (i64.const 9223372036854775807)) |
| (assert_return (invoke "i64_set_and_get_i64" (i64.const -9223372036854775808)) (i64.const -9223372036854775808)) |
| |
| (assert_return (invoke "set_and_get_f64" (f64.const 0)) (f64.const 0)) |
| (assert_return (invoke "set_and_get_f64" (f64.const -1)) (f64.const -1)) |
| (assert_return (invoke "set_and_get_f64" (f64.const 3.3)) (f64.const 3.3)) |
| (assert_return (invoke "set_and_get_f64" (f64.const -2.00000000000000044409)) (f64.const -2.00000000000000044409)) |
| (assert_return (invoke "set_and_get_f64" (f64.const nan)) (f64.const nan)) |
| (assert_return (invoke "set_and_get_f64" (f64.const nan:0x123456789abcd)) (f64.const nan:0x123456789abcd)) |
| (assert_return (invoke "set_and_get_f64" (f64.const -nan:0xedcba98765432)) (f64.const -nan:0xedcba98765432)) |
| |
| ;; |
| ;; Byte-wise store and unaligned store tests (32 bit) |
| ;; |
| |
| (invoke "i32_set_i32" (i32.const 0) (i32.const 0x00000000)) ;; clear |
| (invoke "i32_set_i16" (i32.const 0) (i32.const 0x1234)) |
| (assert_return (invoke "get_array_4_byte" (i32.const 0)) (i32.const 0x34)) |
| (assert_return (invoke "get_array_4_byte" (i32.const 1)) (i32.const 0x12)) |
| (assert_return (invoke "get_array_4_byte" (i32.const 2)) (i32.const 0x00)) |
| (assert_return (invoke "get_array_4_byte" (i32.const 3)) (i32.const 0x00)) |
| |
| (invoke "i32_set_i32" (i32.const 0) (i32.const 0x12345678)) |
| (assert_return (invoke "get_array_4_byte" (i32.const 0)) (i32.const 0x78)) |
| (assert_return (invoke "get_array_4_byte" (i32.const 1)) (i32.const 0x56)) |
| (assert_return (invoke "get_array_4_byte" (i32.const 2)) (i32.const 0x34)) |
| (assert_return (invoke "get_array_4_byte" (i32.const 3)) (i32.const 0x12)) |
| |
| (invoke "i32_set_i16" (i32.const 1) (i32.const 0xABCD)) |
| (assert_return (invoke "get_array_4_byte" (i32.const 0)) (i32.const 0x78)) |
| (assert_return (invoke "get_array_4_byte" (i32.const 1)) (i32.const 0xCD)) |
| (assert_return (invoke "get_array_4_byte" (i32.const 2)) (i32.const 0xAB)) |
| (assert_return (invoke "get_array_4_byte" (i32.const 3)) (i32.const 0x12)) |
| |
| ;; |
| ;; Byte-wise store and unaligned store tests (64 bit) |
| ;; |
| |
| (invoke "i64_set_i64" (i32.const 0) (i64.const 0x123456789ABCDEF0)) |
| (assert_return (invoke "get_array_8_byte" (i32.const 0)) (i32.const 0xF0)) |
| (assert_return (invoke "get_array_8_byte" (i32.const 1)) (i32.const 0xDE)) |
| (assert_return (invoke "get_array_8_byte" (i32.const 2)) (i32.const 0xBC)) |
| (assert_return (invoke "get_array_8_byte" (i32.const 3)) (i32.const 0x9A)) |
| (assert_return (invoke "get_array_8_byte" (i32.const 4)) (i32.const 0x78)) |
| (assert_return (invoke "get_array_8_byte" (i32.const 5)) (i32.const 0x56)) |
| (assert_return (invoke "get_array_8_byte" (i32.const 6)) (i32.const 0x34)) |
| (assert_return (invoke "get_array_8_byte" (i32.const 7)) (i32.const 0x12)) |
| |
| (invoke "i64_set_i32" (i32.const 3) (i64.const 0x11223344)) |
| (assert_return (invoke "get_array_8_byte" (i32.const 0)) (i32.const 0xF0)) |
| (assert_return (invoke "get_array_8_byte" (i32.const 1)) (i32.const 0xDE)) |
| (assert_return (invoke "get_array_8_byte" (i32.const 2)) (i32.const 0xBC)) |
| (assert_return (invoke "get_array_8_byte" (i32.const 3)) (i32.const 0x44)) |
| (assert_return (invoke "get_array_8_byte" (i32.const 4)) (i32.const 0x33)) |
| (assert_return (invoke "get_array_8_byte" (i32.const 5)) (i32.const 0x22)) |
| (assert_return (invoke "get_array_8_byte" (i32.const 6)) (i32.const 0x11)) |
| (assert_return (invoke "get_array_8_byte" (i32.const 7)) (i32.const 0x12)) |
| |
| ;; |
| ;; Byte-wise load tests |
| ;; |
| |
| (invoke "i32_set_i8" (i32.const 0) (i32.const 0x12)) |
| (invoke "i32_set_i8" (i32.const 1) (i32.const 0x34)) |
| (invoke "i32_set_i8" (i32.const 2) (i32.const 0x56)) |
| (invoke "i32_set_i8" (i32.const 3) (i32.const 0x78)) |
| |
| (assert_return (invoke "load_i32_16_u" (i32.const 0)) (i32.const 0x3412)) |
| (assert_return (invoke "load_i32_16_s" (i32.const 0)) (i32.const 0x3412)) |
| |
| ;; Test sign extension |
| (invoke "i32_set_i8" (i32.const 0) (i32.const 0xFF)) |
| (invoke "i32_set_i8" (i32.const 1) (i32.const 0x7F)) |
| (assert_return (invoke "load_i32_16_u" (i32.const 0)) (i32.const 0x7FFF)) |
| (assert_return (invoke "load_i32_16_s" (i32.const 0)) (i32.const 0x7FFF)) |
| |
| (invoke "i32_set_i8" (i32.const 0) (i32.const 0xFF)) |
| (invoke "i32_set_i8" (i32.const 1) (i32.const 0xFF)) |
| (invoke "i32_set_i8" (i32.const 2) (i32.const 0x56)) |
| (invoke "i32_set_i8" (i32.const 3) (i32.const 0x78)) |
| (assert_return (invoke "load_i32_16_u" (i32.const 0)) (i32.const 0x0000FFFF)) |
| (assert_return (invoke "load_i32_16_s" (i32.const 0)) (i32.const 0xFFFFFFFF)) |
| |
| (assert_return (invoke "load_i32" (i32.const 0)) (i32.const 0x7856FFFF)) |
| |
| ;; |
| ;; Bounds checks (32 bit with a 4-byte array) |
| ;; |
| |
| (invoke "i32_set_i32" (i32.const 0) (i32.const 0)) |
| |
| ;; i32_set_i8: Writes 1 byte |
| ;; Valid range: [0, 3] |
| (assert_trap (invoke "i32_set_i8" (i32.const -1) (i32.const 0)) "out of bounds") |
| (assert_return (invoke "i32_set_i8" (i32.const 0) (i32.const 0))) |
| (assert_return (invoke "i32_set_i8" (i32.const 1) (i32.const 0))) |
| (assert_return (invoke "i32_set_i8" (i32.const 2) (i32.const 0))) |
| (assert_return (invoke "i32_set_i8" (i32.const 3) (i32.const 0))) |
| (assert_trap (invoke "i32_set_i8" (i32.const 4) (i32.const 0xFFFF)) "out of bounds") |
| |
| ;; i32_set_i16: Writes 2 bytes |
| ;; Valid range: offset + 2 <= 4 -> Max offset 2 |
| (invoke "i32_set_i32" (i32.const 0) (i32.const 0)) |
| (assert_trap (invoke "i32_set_i16" (i32.const -1) (i32.const 0)) "out of bounds") |
| (assert_return (invoke "i32_set_i16" (i32.const 0) (i32.const 0))) |
| (assert_return (invoke "i32_set_i16" (i32.const 1) (i32.const 0))) |
| (assert_return (invoke "i32_set_i16" (i32.const 2) (i32.const 0))) |
| (assert_trap (invoke "i32_set_i16" (i32.const 3) (i32.const 0xFFFF)) "out of bounds") |
| (assert_return (invoke "get_array_4_byte" (i32.const 3)) (i32.const 0)) |
| |
| ;; i32_set_i32: Writes 4 bytes |
| ;; Valid range: offset + 4 <= 4 -> Max offset 0 |
| (invoke "i32_set_i32" (i32.const 0) (i32.const 0)) |
| (assert_trap (invoke "i32_set_i32" (i32.const -1) (i32.const 0)) "out of bounds") |
| (assert_return (invoke "i32_set_i32" (i32.const 0) (i32.const 0))) |
| (assert_trap (invoke "i32_set_i32" (i32.const 1) (i32.const 0xFFFFFFFF)) "out of bounds") |
| (assert_return (invoke "get_array_4_byte" (i32.const 1)) (i32.const 0)) |
| |
| ;; f32_set: Writes 4 bytes |
| ;; Valid range: offset + 4 <= 4 -> Max offset 0 |
| (invoke "i32_set_i32" (i32.const 0) (i32.const 0)) |
| (assert_trap (invoke "f32_set" (i32.const -1) (f32.const 0)) "out of bounds") |
| (assert_return (invoke "f32_set" (i32.const 0) (f32.const 0))) |
| (assert_trap (invoke "f32_set" (i32.const 1) (f32.const 1.0)) "out of bounds") |
| (assert_return (invoke "get_array_4_byte" (i32.const 1)) (i32.const 0)) |
| |
| ;; |
| ;; Bounds checks (64 bit with an 8-byte array) |
| ;; |
| |
| (invoke "i64_set_i64" (i32.const 0) (i64.const 0)) |
| |
| ;; i64_set_i8: Writes 1 byte |
| ;; Valid range: [0, 7] |
| (assert_trap (invoke "i64_set_i8" (i32.const -1) (i64.const 0)) "out of bounds") |
| (assert_return (invoke "i64_set_i8" (i32.const 0) (i64.const 0))) |
| (assert_return (invoke "i64_set_i8" (i32.const 1) (i64.const 0))) |
| (assert_return (invoke "i64_set_i8" (i32.const 6) (i64.const 0))) |
| (assert_return (invoke "i64_set_i8" (i32.const 7) (i64.const 0))) |
| (assert_trap (invoke "i64_set_i8" (i32.const 8) (i64.const 0xFFFF)) "out of bounds") |
| |
| ;; i64_set_i16: Writes 2 bytes |
| ;; Valid range: offset + 2 <= 8 -> Max offset 6 |
| (invoke "i64_set_i64" (i32.const 0) (i64.const 0)) |
| (assert_trap (invoke "i64_set_i16" (i32.const -1) (i64.const 0)) "out of bounds") |
| (assert_return (invoke "i64_set_i16" (i32.const 0) (i64.const 0))) |
| (assert_return (invoke "i64_set_i16" (i32.const 1) (i64.const 0))) |
| (assert_return (invoke "i64_set_i16" (i32.const 5) (i64.const 0))) |
| (assert_return (invoke "i64_set_i16" (i32.const 6) (i64.const 0))) |
| (assert_trap (invoke "i64_set_i16" (i32.const 7) (i64.const 0xFFFF)) "out of bounds") |
| (assert_return (invoke "get_array_8_byte" (i32.const 7)) (i32.const 0)) |
| |
| ;; i64_set_i32: Writes 4 bytes |
| ;; Valid range: offset + 4 <= 8 -> Max offset 4 |
| (invoke "i64_set_i64" (i32.const 0) (i64.const 0)) |
| (assert_trap (invoke "i64_set_i32" (i32.const -1) (i64.const 0)) "out of bounds") |
| (assert_return (invoke "i64_set_i32" (i32.const 0) (i64.const 0))) |
| (assert_return (invoke "i64_set_i32" (i32.const 1) (i64.const 0))) |
| (assert_return (invoke "i64_set_i32" (i32.const 3) (i64.const 0))) |
| (assert_return (invoke "i64_set_i32" (i32.const 4) (i64.const 0))) |
| (assert_trap (invoke "i64_set_i32" (i32.const 5) (i64.const 0xFFFFFFFF)) "out of bounds") |
| (assert_return (invoke "get_array_8_byte" (i32.const 5)) (i32.const 0)) |
| |
| ;; i64_set_i64: Writes 8 bytes |
| ;; Valid range: offset + 8 <= 8 -> Max offset 0 |
| (invoke "i64_set_i64" (i32.const 0) (i64.const 0)) |
| (assert_trap (invoke "i64_set_i64" (i32.const -1) (i64.const 0)) "out of bounds") |
| (assert_return (invoke "i64_set_i64" (i32.const 0) (i64.const 0))) |
| (assert_trap (invoke "i64_set_i64" (i32.const 1) (i64.const 0xFFFFFFFFFFFFFFFF)) "out of bounds") |
| (assert_return (invoke "get_array_8_byte" (i32.const 1)) (i32.const 0)) |
| |
| ;; f64_set: Writes 8 bytes |
| ;; Valid range: offset + 8 <= 8 -> Max offset 0 |
| (invoke "i64_set_i64" (i32.const 0) (i64.const 0)) |
| (assert_trap (invoke "f64_set" (i32.const -1) (f64.const 0)) "out of bounds") |
| (assert_return (invoke "f64_set" (i32.const 0) (f64.const 0))) |
| (assert_trap (invoke "f64_set" (i32.const 1) (f64.const 1.0)) "out of bounds") |
| (assert_return (invoke "get_array_8_byte" (i32.const 1)) (i32.const 0)) |
| |
| |
| (assert_invalid |
| (module |
| (type $a (array i8)) |
| (func (export "i32_set_immutable") (param $a (ref $a)) |
| (i32.store (type $a) (local.get $a) (i32.const 0) (i32.const 1)) |
| ) |
| ) |
| "array is immutable" |
| ) |
| |
| (assert_invalid |
| (module |
| (type $a (array (mut anyref))) |
| (func (export "i32_set_non_numeric") (param $a (ref $a)) |
| (i32.store (type $a) (local.get $a) (i32.const 0) (i32.const 1)) |
| ) |
| ) |
| "array element type must be numeric" |
| ) |
| |
| ;; New OOB Load Tests |
| (assert_trap (invoke "load_i32_16_u" (i32.const 3)) "out of bounds") |
| (assert_trap (invoke "load_i32" (i32.const 1)) "out of bounds") |
| (assert_trap (invoke "load_i64" (i32.const 1)) "out of bounds") |
| |
| ;; Null reference for load |
| (assert_trap (invoke "load_null") "null array") |
| |
| ;; Unaligned reads |
| (invoke "i32_set_i8" (i32.const 0) (i32.const 0x12)) |
| (invoke "i32_set_i8" (i32.const 1) (i32.const 0x34)) |
| (invoke "i32_set_i8" (i32.const 2) (i32.const 0x56)) |
| (invoke "i32_set_i8" (i32.const 3) (i32.const 0x78)) |
| |
| (assert_return (invoke "load_i32_16_u" (i32.const 1)) (i32.const 0x5634)) |
| (assert_return (invoke "load_i32_16_u" (i32.const 2)) (i32.const 0x7856)) |
| |
| ;; Null dereference |
| |
| (module |
| (type $t (array (mut i8))) |
| ;; (func (export "array.get-null") |
| ;; (local (ref null $t)) (drop (array.get $t (local.get 0) (i32.const 0))) |
| ;; ) |
| (func (export "i32.store_array_null") |
| (local (ref null $t)) (i32.store (type $t) (local.get 0) (i32.const 0) (i32.const 0)) |
| ) |
| ) |
| |
| ;; (assert_trap (invoke "array.get-null") "null array") |
| (assert_trap (invoke "i32.store_array_null") "null array") |
| |
| ;; ============================================================================ |
| ;; Multibyte accesses on arrays of every numeric element type. |
| ;; |
| ;; The accesses operate on the array's payload bytes, so the element type of |
| ;; the array is independent of the type and the size of the access. Each of the |
| ;; arrays below has a 16-byte payload, so the same accesses and the same bounds |
| ;; apply to all of them. |
| ;; ============================================================================ |
| |
| (module |
| (type $i8_array (array (mut i8))) |
| (type $i16_array (array (mut i16))) |
| (type $i32_array (array (mut i32))) |
| (type $i64_array (array (mut i64))) |
| (type $f32_array (array (mut f32))) |
| (type $f64_array (array (mut f64))) |
| (type $v128_array (array (mut v128))) |
| (type $imm_i32_array (array i32)) |
| |
| (global $i8 (ref $i8_array) (array.new_default $i8_array (i32.const 16))) |
| (global $i16 (ref $i16_array) (array.new_default $i16_array (i32.const 8))) |
| (global $i32 (ref $i32_array) (array.new_default $i32_array (i32.const 4))) |
| (global $i64 (ref $i64_array) (array.new_default $i64_array (i32.const 2))) |
| (global $f32 (ref $f32_array) (array.new_default $f32_array (i32.const 4))) |
| (global $f64 (ref $f64_array) (array.new_default $f64_array (i32.const 2))) |
| (global $v128 (ref $v128_array) (array.new_default $v128_array (i32.const 1))) |
| (global $v128_2 (ref $v128_array) (array.new_default $v128_array (i32.const 2))) |
| (global $imm_i32 (ref $imm_i32_array) |
| (array.new_fixed $imm_i32_array 2 (i32.const 0x11223344) (i32.const 0x55667788)) |
| ) |
| (global $empty (ref $i32_array) (array.new_default $i32_array (i32.const 0))) |
| |
| (func (export "clear") |
| (v128.store (type $i8_array) (global.get $i8) (i32.const 0) (v128.const i32x4 0 0 0 0)) |
| (v128.store (type $i16_array) (global.get $i16) (i32.const 0) (v128.const i32x4 0 0 0 0)) |
| (v128.store (type $i32_array) (global.get $i32) (i32.const 0) (v128.const i32x4 0 0 0 0)) |
| (v128.store (type $i64_array) (global.get $i64) (i32.const 0) (v128.const i32x4 0 0 0 0)) |
| (v128.store (type $f32_array) (global.get $f32) (i32.const 0) (v128.const i32x4 0 0 0 0)) |
| (v128.store (type $f64_array) (global.get $f64) (i32.const 0) (v128.const i32x4 0 0 0 0)) |
| (v128.store (type $v128_array) (global.get $v128) (i32.const 0) (v128.const i32x4 0 0 0 0)) |
| ) |
| |
| ;; Store an i32 and read it back, for an array of each element type. |
| |
| (func (export "i8_arr_i32") (param $i i32) (param $v i32) (result i32) |
| (i32.store (type $i8_array) (global.get $i8) (local.get $i) (local.get $v)) |
| (i32.load (type $i8_array) (global.get $i8) (local.get $i)) |
| ) |
| (func (export "i16_arr_i32") (param $i i32) (param $v i32) (result i32) |
| (i32.store (type $i16_array) (global.get $i16) (local.get $i) (local.get $v)) |
| (i32.load (type $i16_array) (global.get $i16) (local.get $i)) |
| ) |
| (func (export "i32_arr_i32") (param $i i32) (param $v i32) (result i32) |
| (i32.store (type $i32_array) (global.get $i32) (local.get $i) (local.get $v)) |
| (i32.load (type $i32_array) (global.get $i32) (local.get $i)) |
| ) |
| (func (export "i64_arr_i32") (param $i i32) (param $v i32) (result i32) |
| (i32.store (type $i64_array) (global.get $i64) (local.get $i) (local.get $v)) |
| (i32.load (type $i64_array) (global.get $i64) (local.get $i)) |
| ) |
| (func (export "f32_arr_i32") (param $i i32) (param $v i32) (result i32) |
| (i32.store (type $f32_array) (global.get $f32) (local.get $i) (local.get $v)) |
| (i32.load (type $f32_array) (global.get $f32) (local.get $i)) |
| ) |
| (func (export "f64_arr_i32") (param $i i32) (param $v i32) (result i32) |
| (i32.store (type $f64_array) (global.get $f64) (local.get $i) (local.get $v)) |
| (i32.load (type $f64_array) (global.get $f64) (local.get $i)) |
| ) |
| (func (export "v128_arr_i32") (param $i i32) (param $v i32) (result i32) |
| (i32.store (type $v128_array) (global.get $v128) (local.get $i) (local.get $v)) |
| (i32.load (type $v128_array) (global.get $v128) (local.get $i)) |
| ) |
| |
| ;; Store an i64 and read it back, for an array of each element type. |
| |
| (func (export "i8_arr_i64") (param $i i32) (param $v i64) (result i64) |
| (i64.store (type $i8_array) (global.get $i8) (local.get $i) (local.get $v)) |
| (i64.load (type $i8_array) (global.get $i8) (local.get $i)) |
| ) |
| (func (export "i16_arr_i64") (param $i i32) (param $v i64) (result i64) |
| (i64.store (type $i16_array) (global.get $i16) (local.get $i) (local.get $v)) |
| (i64.load (type $i16_array) (global.get $i16) (local.get $i)) |
| ) |
| (func (export "i32_arr_i64") (param $i i32) (param $v i64) (result i64) |
| (i64.store (type $i32_array) (global.get $i32) (local.get $i) (local.get $v)) |
| (i64.load (type $i32_array) (global.get $i32) (local.get $i)) |
| ) |
| (func (export "i64_arr_i64") (param $i i32) (param $v i64) (result i64) |
| (i64.store (type $i64_array) (global.get $i64) (local.get $i) (local.get $v)) |
| (i64.load (type $i64_array) (global.get $i64) (local.get $i)) |
| ) |
| (func (export "f32_arr_i64") (param $i i32) (param $v i64) (result i64) |
| (i64.store (type $f32_array) (global.get $f32) (local.get $i) (local.get $v)) |
| (i64.load (type $f32_array) (global.get $f32) (local.get $i)) |
| ) |
| (func (export "f64_arr_i64") (param $i i32) (param $v i64) (result i64) |
| (i64.store (type $f64_array) (global.get $f64) (local.get $i) (local.get $v)) |
| (i64.load (type $f64_array) (global.get $f64) (local.get $i)) |
| ) |
| (func (export "v128_arr_i64") (param $i i32) (param $v i64) (result i64) |
| (i64.store (type $v128_array) (global.get $v128) (local.get $i) (local.get $v)) |
| (i64.load (type $v128_array) (global.get $v128) (local.get $i)) |
| ) |
| |
| ;; Float accesses on arrays of integer, float, and vector elements. |
| |
| (func (export "i32_arr_f32") (param $i i32) (param $v f32) (result f32) |
| (f32.store (type $i32_array) (global.get $i32) (local.get $i) (local.get $v)) |
| (f32.load (type $i32_array) (global.get $i32) (local.get $i)) |
| ) |
| (func (export "i16_arr_f64") (param $i i32) (param $v f64) (result f64) |
| (f64.store (type $i16_array) (global.get $i16) (local.get $i) (local.get $v)) |
| (f64.load (type $i16_array) (global.get $i16) (local.get $i)) |
| ) |
| (func (export "f64_arr_f32") (param $i i32) (param $v f32) (result f32) |
| (f32.store (type $f64_array) (global.get $f64) (local.get $i) (local.get $v)) |
| (f32.load (type $f64_array) (global.get $f64) (local.get $i)) |
| ) |
| (func (export "v128_arr_f64") (param $i i32) (param $v f64) (result f64) |
| (f64.store (type $v128_array) (global.get $v128) (local.get $i) (local.get $v)) |
| (f64.load (type $v128_array) (global.get $v128) (local.get $i)) |
| ) |
| |
| ;; v128 accesses, including on an array of v128 elements. |
| |
| (func (export "i32_arr_v128") (param $i i32) (param $v v128) (result v128) |
| (v128.store (type $i32_array) (global.get $i32) (local.get $i) (local.get $v)) |
| (v128.load (type $i32_array) (global.get $i32) (local.get $i)) |
| ) |
| (func (export "i8_arr_v128_lane0") (param $i i32) (param $v v128) (result i64) |
| (v128.store (type $i8_array) (global.get $i8) (local.get $i) (local.get $v)) |
| (i64.load (type $i8_array) (global.get $i8) (local.get $i)) |
| ) |
| (func (export "v128_arr_v128_lane1") (param $i i32) (param $v v128) (result i64) |
| (v128.store (type $v128_array) (global.get $v128) (local.get $i) (local.get $v)) |
| (i64.load (type $v128_array) (global.get $v128) (i32.add (local.get $i) (i32.const 8))) |
| ) |
| (func (export "v128_arr_unaligned") (param $v0 v128) (param $v1 v128) (result v128) |
| (v128.store (type $v128_array) (global.get $v128_2) (i32.const 0) (local.get $v0)) |
| (v128.store (type $v128_array) (global.get $v128_2) (i32.const 16) (local.get $v1)) |
| (v128.load (type $v128_array) align=1 (global.get $v128_2) (i32.const 8)) |
| ) |
| |
| ;; Sign and zero extension when loading from an array of wider elements. |
| |
| (func (export "i64_arr_load8_s") (param $i i32) (param $v i32) (result i32) |
| (i32.store8 (type $i64_array) (global.get $i64) (local.get $i) (local.get $v)) |
| (i32.load8_s (type $i64_array) (global.get $i64) (local.get $i)) |
| ) |
| (func (export "i64_arr_load8_u") (param $i i32) (param $v i32) (result i32) |
| (i32.store8 (type $i64_array) (global.get $i64) (local.get $i) (local.get $v)) |
| (i32.load8_u (type $i64_array) (global.get $i64) (local.get $i)) |
| ) |
| (func (export "i64_arr_load16_s") (param $i i32) (param $v i32) (result i32) |
| (i32.store16 (type $i64_array) (global.get $i64) (local.get $i) (local.get $v)) |
| (i32.load16_s (type $i64_array) (global.get $i64) (local.get $i)) |
| ) |
| (func (export "i64_arr_load16_u") (param $i i32) (param $v i32) (result i32) |
| (i32.store16 (type $i64_array) (global.get $i64) (local.get $i) (local.get $v)) |
| (i32.load16_u (type $i64_array) (global.get $i64) (local.get $i)) |
| ) |
| (func (export "f64_arr_load8_s") (param $i i32) (param $v i64) (result i64) |
| (i64.store8 (type $f64_array) (global.get $f64) (local.get $i) (local.get $v)) |
| (i64.load8_s (type $f64_array) (global.get $f64) (local.get $i)) |
| ) |
| (func (export "f64_arr_load8_u") (param $i i32) (param $v i64) (result i64) |
| (i64.store8 (type $f64_array) (global.get $f64) (local.get $i) (local.get $v)) |
| (i64.load8_u (type $f64_array) (global.get $f64) (local.get $i)) |
| ) |
| (func (export "f64_arr_load16_s") (param $i i32) (param $v i64) (result i64) |
| (i64.store16 (type $f64_array) (global.get $f64) (local.get $i) (local.get $v)) |
| (i64.load16_s (type $f64_array) (global.get $f64) (local.get $i)) |
| ) |
| (func (export "f64_arr_load16_u") (param $i i32) (param $v i64) (result i64) |
| (i64.store16 (type $f64_array) (global.get $f64) (local.get $i) (local.get $v)) |
| (i64.load16_u (type $f64_array) (global.get $f64) (local.get $i)) |
| ) |
| (func (export "f64_arr_load32_s") (param $i i32) (param $v i64) (result i64) |
| (i64.store32 (type $f64_array) (global.get $f64) (local.get $i) (local.get $v)) |
| (i64.load32_s (type $f64_array) (global.get $f64) (local.get $i)) |
| ) |
| (func (export "f64_arr_load32_u") (param $i i32) (param $v i64) (result i64) |
| (i64.store32 (type $f64_array) (global.get $f64) (local.get $i) (local.get $v)) |
| (i64.load32_u (type $f64_array) (global.get $f64) (local.get $i)) |
| ) |
| |
| ;; Narrow stores wrap the value and leave surrounding bytes of wider elements |
| ;; untouched. |
| |
| (func (export "i32_arr_store_widths") (param $init i32) (param $b0 i32) (param $h1 i32) (result i32) |
| (i32.store (type $i32_array) (global.get $i32) (i32.const 0) (local.get $init)) |
| (i32.store8 (type $i32_array) (global.get $i32) (i32.const 0) (local.get $b0)) |
| (i32.store16 (type $i32_array) (global.get $i32) (i32.const 2) (local.get $h1)) |
| (i32.load (type $i32_array) (global.get $i32) (i32.const 0)) |
| ) |
| (func (export "i64_arr_store_widths") (param $init i64) (param $b0 i64) (param $h1 i64) (param $w1 i64) (result i64) |
| (i64.store (type $i64_array) (global.get $i64) (i32.const 0) (local.get $init)) |
| (i64.store8 (type $i64_array) (global.get $i64) (i32.const 0) (local.get $b0)) |
| (i64.store16 (type $i64_array) (global.get $i64) (i32.const 2) (local.get $h1)) |
| (i64.store32 (type $i64_array) (global.get $i64) (i32.const 4) (local.get $w1)) |
| (i64.load (type $i64_array) (global.get $i64) (i32.const 0)) |
| ) |
| |
| ;; Multibyte accesses and element accesses see the same payload bytes. |
| |
| (func (export "i32_arr_store_then_get") (param $v i32) (result i32) |
| (i32.store (type $i32_array) (global.get $i32) (i32.const 8) (local.get $v)) |
| (array.get $i32_array (global.get $i32) (i32.const 2)) |
| ) |
| (func (export "i32_arr_set_then_load") (param $v i32) (result i32) |
| (array.set $i32_array (global.get $i32) (i32.const 2) (local.get $v)) |
| (i32.load (type $i32_array) (global.get $i32) (i32.const 8)) |
| ) |
| (func (export "i16_arr_store_then_get_u") (param $v i32) (param $elem i32) (result i32) |
| (i32.store (type $i16_array) (global.get $i16) (i32.const 4) (local.get $v)) |
| (array.get_u $i16_array (global.get $i16) (local.get $elem)) |
| ) |
| (func (export "i16_arr_store_then_get_s") (param $v i32) (param $elem i32) (result i32) |
| (i32.store (type $i16_array) (global.get $i16) (i32.const 4) (local.get $v)) |
| (array.get_s $i16_array (global.get $i16) (local.get $elem)) |
| ) |
| (func (export "i16_arr_set_then_load") (param $v0 i32) (param $v1 i32) (result i32) |
| (array.set $i16_array (global.get $i16) (i32.const 2) (local.get $v0)) |
| (array.set $i16_array (global.get $i16) (i32.const 3) (local.get $v1)) |
| (i32.load (type $i16_array) (global.get $i16) (i32.const 4)) |
| ) |
| (func (export "f64_arr_store_then_get") (param $v f64) (result f64) |
| (f64.store (type $f64_array) (global.get $f64) (i32.const 8) (local.get $v)) |
| (array.get $f64_array (global.get $f64) (i32.const 1)) |
| ) |
| (func (export "i32_arr_v128_store_then_get") (param $v v128) (param $elem i32) (result i32) |
| (v128.store (type $i32_array) (global.get $i32) (i32.const 0) (local.get $v)) |
| (array.get $i32_array (global.get $i32) (local.get $elem)) |
| ) |
| |
| ;; Loads from an immutable array are allowed. |
| |
| (func (export "immutable_load") (param $i i32) (result i32) |
| (i32.load (type $imm_i32_array) (global.get $imm_i32) (local.get $i)) |
| ) |
| |
| ;; Any access on an empty array is out of bounds. |
| |
| (func (export "empty_load") |
| (drop (i32.load8_u (type $i32_array) (global.get $empty) (i32.const 0))) |
| ) |
| |
| ;; Null references trap, before the bounds check. |
| |
| (func (export "null_load") (result i32) |
| (i32.load (type $v128_array) (ref.null $v128_array) (i32.const 999)) |
| ) |
| (func (export "null_store") |
| (f64.store (type $f64_array) (ref.null $f64_array) (i32.const 999) (f64.const 0)) |
| ) |
| ) |
| |
| ;; i32 accesses work the same on all element types. |
| (invoke "clear") |
| (assert_return (invoke "i8_arr_i32" (i32.const 3) (i32.const 0x12345678)) (i32.const 0x12345678)) |
| (assert_return (invoke "i16_arr_i32" (i32.const 3) (i32.const 0x12345678)) (i32.const 0x12345678)) |
| (assert_return (invoke "i32_arr_i32" (i32.const 3) (i32.const 0x12345678)) (i32.const 0x12345678)) |
| (assert_return (invoke "i64_arr_i32" (i32.const 3) (i32.const 0x12345678)) (i32.const 0x12345678)) |
| (assert_return (invoke "f32_arr_i32" (i32.const 3) (i32.const 0x12345678)) (i32.const 0x12345678)) |
| (assert_return (invoke "f64_arr_i32" (i32.const 3) (i32.const 0x12345678)) (i32.const 0x12345678)) |
| (assert_return (invoke "v128_arr_i32" (i32.const 3) (i32.const 0x12345678)) (i32.const 0x12345678)) |
| |
| ;; The last in-bounds i32 access of a 16-byte payload is at index 12. |
| (invoke "clear") |
| (assert_return (invoke "i8_arr_i32" (i32.const 12) (i32.const -1)) (i32.const -1)) |
| (assert_return (invoke "i16_arr_i32" (i32.const 12) (i32.const -1)) (i32.const -1)) |
| (assert_return (invoke "i32_arr_i32" (i32.const 12) (i32.const -1)) (i32.const -1)) |
| (assert_return (invoke "i64_arr_i32" (i32.const 12) (i32.const -1)) (i32.const -1)) |
| (assert_return (invoke "f32_arr_i32" (i32.const 12) (i32.const -1)) (i32.const -1)) |
| (assert_return (invoke "f64_arr_i32" (i32.const 12) (i32.const -1)) (i32.const -1)) |
| (assert_return (invoke "v128_arr_i32" (i32.const 12) (i32.const -1)) (i32.const -1)) |
| |
| (assert_trap (invoke "i8_arr_i32" (i32.const 13) (i32.const 0)) "out of bounds") |
| (assert_trap (invoke "i16_arr_i32" (i32.const 13) (i32.const 0)) "out of bounds") |
| (assert_trap (invoke "i32_arr_i32" (i32.const 13) (i32.const 0)) "out of bounds") |
| (assert_trap (invoke "i64_arr_i32" (i32.const 13) (i32.const 0)) "out of bounds") |
| (assert_trap (invoke "f32_arr_i32" (i32.const 13) (i32.const 0)) "out of bounds") |
| (assert_trap (invoke "f64_arr_i32" (i32.const 13) (i32.const 0)) "out of bounds") |
| (assert_trap (invoke "v128_arr_i32" (i32.const 13) (i32.const 0)) "out of bounds") |
| |
| ;; The index is unsigned, so a negative index is far out of bounds. |
| (assert_trap (invoke "i8_arr_i32" (i32.const -1) (i32.const 0)) "out of bounds") |
| (assert_trap (invoke "i32_arr_i32" (i32.const -4) (i32.const 0)) "out of bounds") |
| (assert_trap (invoke "v128_arr_i32" (i32.const -16) (i32.const 0)) "out of bounds") |
| |
| ;; i64 accesses work the same on all element types. |
| (invoke "clear") |
| (assert_return (invoke "i8_arr_i64" (i32.const 5) (i64.const 0x1122334455667788)) (i64.const 0x1122334455667788)) |
| (assert_return (invoke "i16_arr_i64" (i32.const 5) (i64.const 0x1122334455667788)) (i64.const 0x1122334455667788)) |
| (assert_return (invoke "i32_arr_i64" (i32.const 5) (i64.const 0x1122334455667788)) (i64.const 0x1122334455667788)) |
| (assert_return (invoke "i64_arr_i64" (i32.const 5) (i64.const 0x1122334455667788)) (i64.const 0x1122334455667788)) |
| (assert_return (invoke "f32_arr_i64" (i32.const 5) (i64.const 0x1122334455667788)) (i64.const 0x1122334455667788)) |
| (assert_return (invoke "f64_arr_i64" (i32.const 5) (i64.const 0x1122334455667788)) (i64.const 0x1122334455667788)) |
| (assert_return (invoke "v128_arr_i64" (i32.const 5) (i64.const 0x1122334455667788)) (i64.const 0x1122334455667788)) |
| |
| ;; The last in-bounds i64 access of a 16-byte payload is at index 8. |
| (invoke "clear") |
| (assert_return (invoke "i8_arr_i64" (i32.const 8) (i64.const -1)) (i64.const -1)) |
| (assert_return (invoke "i16_arr_i64" (i32.const 8) (i64.const -1)) (i64.const -1)) |
| (assert_return (invoke "i32_arr_i64" (i32.const 8) (i64.const -1)) (i64.const -1)) |
| (assert_return (invoke "i64_arr_i64" (i32.const 8) (i64.const -1)) (i64.const -1)) |
| (assert_return (invoke "f32_arr_i64" (i32.const 8) (i64.const -1)) (i64.const -1)) |
| (assert_return (invoke "f64_arr_i64" (i32.const 8) (i64.const -1)) (i64.const -1)) |
| (assert_return (invoke "v128_arr_i64" (i32.const 8) (i64.const -1)) (i64.const -1)) |
| (assert_trap (invoke "i8_arr_i64" (i32.const 9) (i64.const 0)) "out of bounds") |
| (assert_trap (invoke "i16_arr_i64" (i32.const 9) (i64.const 0)) "out of bounds") |
| (assert_trap (invoke "i32_arr_i64" (i32.const 9) (i64.const 0)) "out of bounds") |
| (assert_trap (invoke "i64_arr_i64" (i32.const 9) (i64.const 0)) "out of bounds") |
| (assert_trap (invoke "f32_arr_i64" (i32.const 9) (i64.const 0)) "out of bounds") |
| (assert_trap (invoke "f64_arr_i64" (i32.const 9) (i64.const 0)) "out of bounds") |
| (assert_trap (invoke "v128_arr_i64" (i32.const 9) (i64.const 0)) "out of bounds") |
| |
| ;; Floats keep their bits, even when the element type is an integer type, and |
| ;; even for NaNs with a payload. |
| (invoke "clear") |
| (assert_return (invoke "i32_arr_f32" (i32.const 2) (f32.const 3.3)) (f32.const 3.3)) |
| (assert_return (invoke "i32_arr_f32" (i32.const 2) (f32.const -nan:0x654321)) (f32.const -nan:0x654321)) |
| (assert_return (invoke "i16_arr_f64" (i32.const 3) (f64.const 3.3)) (f64.const 3.3)) |
| (assert_return (invoke "i16_arr_f64" (i32.const 3) (f64.const nan:0x123456789ABCD)) (f64.const nan:0x123456789ABCD)) |
| (assert_return (invoke "f64_arr_f32" (i32.const 6) (f32.const -1)) (f32.const -1)) |
| (assert_return (invoke "v128_arr_f64" (i32.const 4) (f64.const 1.5)) (f64.const 1.5)) |
| |
| ;; v128 accesses read and write 16 bytes. |
| (invoke "clear") |
| (assert_return (invoke "i32_arr_v128" (i32.const 0) (v128.const i32x4 1 2 3 4)) (v128.const i32x4 1 2 3 4)) |
| (assert_return (invoke "i8_arr_v128_lane0" (i32.const 0) (v128.const i64x2 1 2)) (i64.const 1)) |
| (assert_return (invoke "v128_arr_v128_lane1" (i32.const 0) (v128.const i64x2 1 2)) (i64.const 2)) |
| (assert_return (invoke "v128_arr_unaligned" (v128.const i64x2 1 2) (v128.const i64x2 3 4)) (v128.const i64x2 2 3)) |
| (assert_trap (invoke "i8_arr_v128_lane0" (i32.const 1) (v128.const i64x2 0 0)) "out of bounds") |
| |
| ;; Sign and zero extension. |
| (invoke "clear") |
| (assert_return (invoke "i64_arr_load8_s" (i32.const 1) (i32.const 0x80)) (i32.const 0xFFFFFF80)) |
| (assert_return (invoke "i64_arr_load8_u" (i32.const 1) (i32.const 0x80)) (i32.const 0x00000080)) |
| (assert_return (invoke "i64_arr_load8_s" (i32.const 1) (i32.const 0x7F)) (i32.const 0x0000007F)) |
| (assert_return (invoke "i64_arr_load16_s" (i32.const 2) (i32.const 0x8000)) (i32.const 0xFFFF8000)) |
| (assert_return (invoke "i64_arr_load16_u" (i32.const 2) (i32.const 0x8000)) (i32.const 0x00008000)) |
| (assert_return (invoke "i64_arr_load16_s" (i32.const 2) (i32.const 0x7FFF)) (i32.const 0x00007FFF)) |
| (assert_return (invoke "i64_arr_load16_u" (i32.const 2) (i32.const 0x7FFF)) (i32.const 0x00007FFF)) |
| (assert_return (invoke "f64_arr_load8_s" (i32.const 1) (i64.const 0x80)) (i64.const 0xFFFFFFFFFFFFFF80)) |
| (assert_return (invoke "f64_arr_load8_u" (i32.const 1) (i64.const 0x80)) (i64.const 0x0000000000000080)) |
| (assert_return (invoke "f64_arr_load16_s" (i32.const 2) (i64.const 0x8000)) (i64.const 0xFFFFFFFFFFFF8000)) |
| (assert_return (invoke "f64_arr_load16_u" (i32.const 2) (i64.const 0x8000)) (i64.const 0x0000000000008000)) |
| (assert_return (invoke "f64_arr_load32_s" (i32.const 4) (i64.const 0x80000000)) (i64.const 0xFFFFFFFF80000000)) |
| (assert_return (invoke "f64_arr_load32_u" (i32.const 4) (i64.const 0x80000000)) (i64.const 0x0000000080000000)) |
| |
| ;; Narrow stores wrap the value and preserve surrounding bytes. |
| (invoke "clear") |
| (assert_return |
| (invoke "i32_arr_store_widths" (i32.const 0xFFFFFFFF) (i32.const 0xDEAD12) (i32.const 0xDEAD3456)) |
| (i32.const 0x3456FF12) |
| ) |
| (assert_return |
| (invoke "i64_arr_store_widths" (i64.const 0xFFFFFFFFFFFFFFFF) (i64.const 0xDEAD12) (i64.const 0xDEAD3456) (i64.const 0xDEAD789ABCDE)) |
| (i64.const 0x789ABCDE3456FF12) |
| ) |
| |
| ;; Multibyte accesses and element accesses agree. |
| (invoke "clear") |
| (assert_return (invoke "i32_arr_store_then_get" (i32.const 1337)) (i32.const 1337)) |
| (assert_return (invoke "i32_arr_set_then_load" (i32.const 1337)) (i32.const 1337)) |
| (assert_return (invoke "i16_arr_store_then_get_u" (i32.const 0x80001234) (i32.const 2)) (i32.const 0x00001234)) |
| (assert_return (invoke "i16_arr_store_then_get_u" (i32.const 0x80001234) (i32.const 3)) (i32.const 0x00008000)) |
| (assert_return (invoke "i16_arr_store_then_get_s" (i32.const 0x80001234) (i32.const 3)) (i32.const 0xFFFF8000)) |
| (assert_return (invoke "i16_arr_set_then_load" (i32.const 0x1234) (i32.const 0x5678)) (i32.const 0x56781234)) |
| (assert_return (invoke "f64_arr_store_then_get" (f64.const 3.3)) (f64.const 3.3)) |
| (assert_return (invoke "i32_arr_v128_store_then_get" (v128.const i32x4 10 20 30 40) (i32.const 1)) (i32.const 20)) |
| (assert_return (invoke "i32_arr_v128_store_then_get" (v128.const i32x4 10 20 30 40) (i32.const 3)) (i32.const 40)) |
| |
| ;; Loads from immutable arrays. |
| (assert_return (invoke "immutable_load" (i32.const 0)) (i32.const 0x11223344)) |
| (assert_return (invoke "immutable_load" (i32.const 4)) (i32.const 0x55667788)) |
| (assert_return (invoke "immutable_load" (i32.const 2)) (i32.const 0x77881122)) |
| (assert_trap (invoke "immutable_load" (i32.const 5)) "out of bounds") |
| |
| ;; Empty arrays and null references. |
| (assert_trap (invoke "empty_load") "out of bounds") |
| (assert_trap (invoke "null_load") "null array") |
| (assert_trap (invoke "null_store") "null array") |
| |
| ;; ============================================================================ |
| ;; Static offset and alignment immediates. |
| ;; ============================================================================ |
| |
| (module |
| (type $i8_array (array (mut i8))) |
| (type $i32_array (array (mut i32))) |
| |
| (global $i8 (ref $i8_array) (array.new_default $i8_array (i32.const 16))) |
| (global $i32 (ref $i32_array) (array.new_default $i32_array (i32.const 4))) |
| |
| ;; The effective address is the sum of the dynamic index and the static |
| ;; offset, so these two functions access the same bytes. |
| (func (export "store_offset") (param $i i32) (param $v i32) |
| (i32.store (type $i8_array) offset=4 (global.get $i8) (local.get $i) (local.get $v)) |
| ) |
| (func (export "load_index") (param $i i32) (result i32) |
| (i32.load (type $i8_array) (global.get $i8) (local.get $i)) |
| ) |
| (func (export "load_offset") (param $i i32) (result i32) |
| (i32.load (type $i8_array) offset=4 (global.get $i8) (local.get $i)) |
| ) |
| |
| ;; The offset alone can address the array. |
| (func (export "load_offset_only") (result i32) |
| (i32.load (type $i8_array) offset=12 (global.get $i8) (i32.const 0)) |
| ) |
| |
| ;; The offset is included in the bounds check, and the sum of the index and |
| ;; the offset does not wrap around. |
| (func (export "load_offset_oob") (result i32) |
| (i32.load (type $i8_array) offset=13 (global.get $i8) (i32.const 0)) |
| ) |
| (func (export "load_offset_no_wrap") (result i32) |
| (i32.load8_u (type $i8_array) offset=1 (global.get $i8) (i32.const -1)) |
| ) |
| (func (export "load_offset_max") (result i32) |
| (i32.load8_u (type $i8_array) offset=4294967295 (global.get $i8) (i32.const 1)) |
| ) |
| |
| ;; Alignment is only a hint: it does not affect the result, and it does not |
| ;; need to match the alignment of the array's elements. |
| (func (export "unaligned_store") (param $i i32) (param $v i32) |
| (i32.store (type $i32_array) align=1 (global.get $i32) (local.get $i) (local.get $v)) |
| ) |
| (func (export "aligned_store") (param $i i32) (param $v i32) |
| (i32.store (type $i32_array) align=4 (global.get $i32) (local.get $i) (local.get $v)) |
| ) |
| (func (export "unaligned_load") (param $i i32) (result i32) |
| (i32.load (type $i32_array) align=1 (global.get $i32) (local.get $i)) |
| ) |
| (func (export "aligned_load") (param $i i32) (result i32) |
| (i32.load (type $i32_array) align=4 (global.get $i32) (local.get $i)) |
| ) |
| ) |
| |
| (invoke "store_offset" (i32.const 2) (i32.const 0x12345678)) |
| (assert_return (invoke "load_index" (i32.const 6)) (i32.const 0x12345678)) |
| (assert_return (invoke "load_offset" (i32.const 2)) (i32.const 0x12345678)) |
| (invoke "store_offset" (i32.const 0) (i32.const 0x11223344)) |
| (assert_return (invoke "load_index" (i32.const 4)) (i32.const 0x11223344)) |
| ;; The second store overwrote the first two bytes of the first one. |
| (assert_return (invoke "load_index" (i32.const 6)) (i32.const 0x12341122)) |
| |
| (invoke "store_offset" (i32.const 8) (i32.const 0x55667788)) |
| (assert_return (invoke "load_offset_only") (i32.const 0x55667788)) |
| |
| (assert_trap (invoke "load_offset_oob") "out of bounds") |
| (assert_trap (invoke "load_offset_no_wrap") "out of bounds") |
| (assert_trap (invoke "load_offset_max") "out of bounds") |
| |
| ;; An unaligned store of an i32 array crosses two elements. |
| (invoke "aligned_store" (i32.const 0) (i32.const 0)) |
| (invoke "aligned_store" (i32.const 4) (i32.const 0)) |
| (invoke "unaligned_store" (i32.const 2) (i32.const 0x12345678)) |
| (assert_return (invoke "unaligned_load" (i32.const 2)) (i32.const 0x12345678)) |
| (assert_return (invoke "aligned_load" (i32.const 0)) (i32.const 0x56780000)) |
| (assert_return (invoke "aligned_load" (i32.const 4)) (i32.const 0x00001234)) |
| |
| ;; ============================================================================ |
| ;; Binary format: memarg ::= flags:u32 typeidx:u32 offset:u32 |
| ;; ============================================================================ |
| |
| (module binary |
| "\00asm\01\00\00\00" |
| |
| "\01\0a\03" ;; Type section: 3 types |
| "\5f\00" ;; Type 0: (struct) |
| "\5e\78\01" ;; Type 1: (array (mut i8)) |
| "\60\00\01\7f" ;; Type 2: (func (result i32)) |
| |
| "\03\02\01\02" ;; Function section: 1 function of type 2 |
| |
| "\07\08\01" ;; Export section: 1 export |
| "\04test\00\00" ;; (export "test" (func 0)) |
| |
| "\0a\1e\01" ;; Code section: 1 function |
| "\1c\01" ;; Body size 28, 1 local entry |
| "\01\63\01" ;; (local (ref null 1)) |
| "\41\08" ;; i32.const 8 |
| "\fb\07\01" ;; array.new_default 1 |
| "\22\00" ;; local.tee 0 |
| "\41\00" ;; i32.const 0 |
| "\41\2a" ;; i32.const 42 |
| "\36\22\01\04" ;; i32.store flags=0x22 (array, align=4) typeidx=1 offset=4 |
| "\20\00" ;; local.get 0 |
| "\41\00" ;; i32.const 0 |
| "\28\22\01\04" ;; i32.load flags=0x22 (array, align=4) typeidx=1 offset=4 |
| "\0b" ;; end |
| ) |
| |
| (assert_return (invoke "test") (i32.const 42)) |
