;; 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))