A lightweight WebAssembly runtime that is fast, secure, and standards-compliant
winch(aarch64): v128 load and store ops (#13957)
Daniel Macovei5d7caa3e0b3c
diff --git a/crates/test-util/src/wast.rs b/crates/test-util/src/wast.rsindex c8ee3aa315..bfd1ba3959 100644--- a/crates/test-util/src/wast.rs+++ b/crates/test-util/src/wast.rs@@ -526,6 +526,10 @@ impl WastTest {"misc_testsuite/winch/issue-10331.wast","misc_testsuite/int-to-float-splat.wast","misc_testsuite/simd/cvt-from-uint.wast",+ "misc_testsuite/memory64/simd.wast",+ "misc_testsuite/simd/load_splat_out_of_bounds.wast",+ "misc_testsuite/simd/edge-of-memory.wast",+ "misc_testsuite/issue6562.wast",];if now_supported.iter().any(|part| self.path.ends_with(part)) {return false;diff --git a/tests/disas/winch/aarch64/load/v128_load16_lane.wat b/tests/disas/winch/aarch64/load/v128_load16_lane.watnew file mode 100644index 0000000000..51bab335b5--- /dev/null+++ b/tests/disas/winch/aarch64/load/v128_load16_lane.wat@@ -0,0 +1,46 @@+;;! target = "aarch64"+;;! test = "winch"++(module+ (memory 1 1)+ (func (export "_start") (result v128)+ (v128.load16_lane+ 1 (i32.const 0) (v128.const i64x2 0xFFFFFFFFFFFFFFFF 0xFFFFFFFFFFFFFFFF)+ )))+;; wasm[0]::function[0]:+;; stp x29, x30, [sp, #-0x10]!+;; mov x29, sp+;; str x28, [sp, #-0x10]!+;; mov x28, sp+;; ldur x16, [x0, #8]+;; ldur x16, [x16, #0x18]+;; mov x17, #0+;; movk x17, #0x10+;; add x16, x16, x17+;; cmp sp, x16+;; b.lo #0x70+;; 2c: mov x9, x0+;; sub x28, x28, #0x10+;; mov sp, x28+;; stur x0, [x28, #8]+;; stur x1, [x28]+;; ldr q0, #0x80+;; mov x0, #0+;; ldur x1, [x9, #0x38]+;; add x1, x1, w0, uxtw+;; ldurh w16, [x1]+;; mov v0.h[1], w16+;; add x28, x28, #0x10+;; mov sp, x28+;; mov sp, x28+;; ldr x28, [sp], #0x10+;; ldp x29, x30, [sp], #0x10+;; ret+;; 70: udf #0xc11f+;; 74: udf #0+;; 78: udf #0+;; 7c: udf #0+;; 80: .byte 0xff, 0xff, 0xff, 0xff+;; 84: .byte 0xff, 0xff, 0xff, 0xff+;; 88: .byte 0xff, 0xff, 0xff, 0xff+;; 8c: .byte 0xff, 0xff, 0xff, 0xffdiff --git a/tests/disas/winch/aarch64/load/v128_load16_splat.wat b/tests/disas/winch/aarch64/load/v128_load16_splat.watnew file mode 100644index 0000000000..ad415b5fd0--- /dev/null+++ b/tests/disas/winch/aarch64/load/v128_load16_splat.wat@@ -0,0 +1,36 @@+;;! target = "aarch64"+;;! test = "winch"++(module+ (memory (data "\80\ff\01\ff\00\02\fe\c0\aa\55\00\00\00\00\00\00"))++ (func (export "v128.load16_splat") (result v128) (v128.load16_splat (i32.const 0)))+)+;; wasm[0]::function[0]:+;; stp x29, x30, [sp, #-0x10]!+;; mov x29, sp+;; str x28, [sp, #-0x10]!+;; mov x28, sp+;; ldur x16, [x0, #8]+;; ldur x16, [x16, #0x18]+;; mov x17, #0+;; movk x17, #0x10+;; add x16, x16, x17+;; cmp sp, x16+;; b.lo #0x68+;; 2c: mov x9, x0+;; sub x28, x28, #0x10+;; mov sp, x28+;; stur x0, [x28, #8]+;; stur x1, [x28]+;; mov x0, #0+;; ldur x1, [x9, #0x38]+;; add x1, x1, w0, uxtw+;; ld1r {v0.8h}, [x1]+;; add x28, x28, #0x10+;; mov sp, x28+;; mov sp, x28+;; ldr x28, [sp], #0x10+;; ldp x29, x30, [sp], #0x10+;; ret+;; 68: udf #0xc11fdiff --git a/tests/disas/winch/aarch64/load/v128_load16x4_s.wat b/tests/disas/winch/aarch64/load/v128_load16x4_s.watnew file mode 100644index 0000000000..4b339f4059--- /dev/null+++ b/tests/disas/winch/aarch64/load/v128_load16x4_s.wat@@ -0,0 +1,37 @@+;;! target = "aarch64"+;;! test = "winch"++(module+ (memory (data "\00\00\00\00\00\00\00\00\00\00\00\00\00\00\a0\7f"))++ (func (export "v128.load16x4_s") (result v128) (v128.load16x4_s (i32.const 0)))+)+;; wasm[0]::function[0]:+;; stp x29, x30, [sp, #-0x10]!+;; mov x29, sp+;; str x28, [sp, #-0x10]!+;; mov x28, sp+;; ldur x16, [x0, #8]+;; ldur x16, [x16, #0x18]+;; mov x17, #0+;; movk x17, #0x10+;; add x16, x16, x17+;; cmp sp, x16+;; b.lo #0x6c+;; 2c: mov x9, x0+;; sub x28, x28, #0x10+;; mov sp, x28+;; stur x0, [x28, #8]+;; stur x1, [x28]+;; mov x0, #0+;; ldur x1, [x9, #0x38]+;; add x1, x1, w0, uxtw+;; ldur d0, [x1]+;; sshll v0.4s, v0.4h, #0+;; add x28, x28, #0x10+;; mov sp, x28+;; mov sp, x28+;; ldr x28, [sp], #0x10+;; ldp x29, x30, [sp], #0x10+;; ret+;; 6c: udf #0xc11fdiff --git a/tests/disas/winch/aarch64/load/v128_load16x4_u.wat b/tests/disas/winch/aarch64/load/v128_load16x4_u.watnew file mode 100644index 0000000000..572b88cfd8--- /dev/null+++ b/tests/disas/winch/aarch64/load/v128_load16x4_u.wat@@ -0,0 +1,37 @@+;;! target = "aarch64"+;;! test = "winch"++(module+ (memory (data "\00\00\00\00\00\00\00\00\00\00\00\00\00\00\a0\7f"))++ (func (export "v128.load16x4_u") (result v128) (v128.load16x4_u (i32.const 0)))+)+;; wasm[0]::function[0]:+;; stp x29, x30, [sp, #-0x10]!+;; mov x29, sp+;; str x28, [sp, #-0x10]!+;; mov x28, sp+;; ldur x16, [x0, #8]+;; ldur x16, [x16, #0x18]+;; mov x17, #0+;; movk x17, #0x10+;; add x16, x16, x17+;; cmp sp, x16+;; b.lo #0x6c+;; 2c: mov x9, x0+;; sub x28, x28, #0x10+;; mov sp, x28+;; stur x0, [x28, #8]+;; stur x1, [x28]+;; mov x0, #0+;; ldur x1, [x9, #0x38]+;; add x1, x1, w0, uxtw+;; ldur d0, [x1]+;; ushll v0.4s, v0.4h, #0+;; add x28, x28, #0x10+;; mov sp, x28+;; mov sp, x28+;; ldr x28, [sp], #0x10+;; ldp x29, x30, [sp], #0x10+;; ret+;; 6c: udf #0xc11fdiff --git a/tests/disas/winch/aarch64/load/v128_load32_lane.wat b/tests/disas/winch/aarch64/load/v128_load32_lane.watnew file mode 100644index 0000000000..fead0aa880--- /dev/null+++ b/tests/disas/winch/aarch64/load/v128_load32_lane.wat@@ -0,0 +1,46 @@+;;! target = "aarch64"+;;! test = "winch"++(module+ (memory 1 1)+ (func (export "_start") (result v128)+ (v128.load32_lane+ 1 (i32.const 0) (v128.const i64x2 0xFFFFFFFFFFFFFFFF 0xFFFFFFFFFFFFFFFF)+ )))+;; wasm[0]::function[0]:+;; stp x29, x30, [sp, #-0x10]!+;; mov x29, sp+;; str x28, [sp, #-0x10]!+;; mov x28, sp+;; ldur x16, [x0, #8]+;; ldur x16, [x16, #0x18]+;; mov x17, #0+;; movk x17, #0x10+;; add x16, x16, x17+;; cmp sp, x16+;; b.lo #0x70+;; 2c: mov x9, x0+;; sub x28, x28, #0x10+;; mov sp, x28+;; stur x0, [x28, #8]+;; stur x1, [x28]+;; ldr q0, #0x80+;; mov x0, #0+;; ldur x1, [x9, #0x38]+;; add x1, x1, w0, uxtw+;; ldur w16, [x1]+;; mov v0.s[1], w16+;; add x28, x28, #0x10+;; mov sp, x28+;; mov sp, x28+;; ldr x28, [sp], #0x10+;; ldp x29, x30, [sp], #0x10+;; ret+;; 70: udf #0xc11f+;; 74: udf #0+;; 78: udf #0+;; 7c: udf #0+;; 80: .byte 0xff, 0xff, 0xff, 0xff+;; 84: .byte 0xff, 0xff, 0xff, 0xff+;; 88: .byte 0xff, 0xff, 0xff, 0xff+;; 8c: .byte 0xff, 0xff, 0xff, 0xffdiff --git a/tests/disas/winch/aarch64/load/v128_load32_splat.wat b/tests/disas/winch/aarch64/load/v128_load32_splat.watnew file mode 100644index 0000000000..025e75f2e2--- /dev/null+++ b/tests/disas/winch/aarch64/load/v128_load32_splat.wat@@ -0,0 +1,36 @@+;;! target = "aarch64"+;;! test = "winch"++(module+ (memory (data "\80\ff\01\ff\00\02\fe\c0\aa\55\00\00\00\00\00\00"))++ (func (export "v128.load32_splat") (result v128) (v128.load32_splat (i32.const 0)))+)+;; wasm[0]::function[0]:+;; stp x29, x30, [sp, #-0x10]!+;; mov x29, sp+;; str x28, [sp, #-0x10]!+;; mov x28, sp+;; ldur x16, [x0, #8]+;; ldur x16, [x16, #0x18]+;; mov x17, #0+;; movk x17, #0x10+;; add x16, x16, x17+;; cmp sp, x16+;; b.lo #0x68+;; 2c: mov x9, x0+;; sub x28, x28, #0x10+;; mov sp, x28+;; stur x0, [x28, #8]+;; stur x1, [x28]+;; mov x0, #0+;; ldur x1, [x9, #0x38]+;; add x1, x1, w0, uxtw+;; ld1r {v0.4s}, [x1]+;; add x28, x28, #0x10+;; mov sp, x28+;; mov sp, x28+;; ldr x28, [sp], #0x10+;; ldp x29, x30, [sp], #0x10+;; ret+;; 68: udf #0xc11fdiff --git a/tests/disas/winch/aarch64/load/v128_load32_zero.wat b/tests/disas/winch/aarch64/load/v128_load32_zero.watnew file mode 100644index 0000000000..f577f26b26--- /dev/null+++ b/tests/disas/winch/aarch64/load/v128_load32_zero.wat@@ -0,0 +1,36 @@+;;! target = "aarch64"+;;! test = "winch"++(module+ (memory (data "\80\ff\01\ff\00\02\fe\c0\aa\55\00\00\00\00\00\00"))++ (func (export "v128.load32_zero") (result v128) (v128.load32_zero (i32.const 0)))+)+;; wasm[0]::function[0]:+;; stp x29, x30, [sp, #-0x10]!+;; mov x29, sp+;; str x28, [sp, #-0x10]!+;; mov x28, sp+;; ldur x16, [x0, #8]+;; ldur x16, [x16, #0x18]+;; mov x17, #0+;; movk x17, #0x10+;; add x16, x16, x17+;; cmp sp, x16+;; b.lo #0x68+;; 2c: mov x9, x0+;; sub x28, x28, #0x10+;; mov sp, x28+;; stur x0, [x28, #8]+;; stur x1, [x28]+;; mov x0, #0+;; ldur x1, [x9, #0x38]+;; add x1, x1, w0, uxtw+;; ldur s0, [x1]+;; add x28, x28, #0x10+;; mov sp, x28+;; mov sp, x28+;; ldr x28, [sp], #0x10+;; ldp x29, x30, [sp], #0x10+;; ret+;; 68: udf #0xc11fdiff --git a/tests/disas/winch/aarch64/load/v128_load32x2_s.wat b/tests/disas/winch/aarch64/load/v128_load32x2_s.watnew file mode 100644index 0000000000..492c2cbc41--- /dev/null+++ b/tests/disas/winch/aarch64/load/v128_load32x2_s.wat@@ -0,0 +1,37 @@+;;! target = "aarch64"+;;! test = "winch"++(module+ (memory (data "\00\00\00\00\00\00\00\00\00\00\00\00\00\00\a0\7f"))++ (func (export "v128.load32x2_s") (result v128) (v128.load32x2_s (i32.const 0)))+)+;; wasm[0]::function[0]:+;; stp x29, x30, [sp, #-0x10]!+;; mov x29, sp+;; str x28, [sp, #-0x10]!+;; mov x28, sp+;; ldur x16, [x0, #8]+;; ldur x16, [x16, #0x18]+;; mov x17, #0+;; movk x17, #0x10+;; add x16, x16, x17+;; cmp sp, x16+;; b.lo #0x6c+;; 2c: mov x9, x0+;; sub x28, x28, #0x10+;; mov sp, x28+;; stur x0, [x28, #8]+;; stur x1, [x28]+;; mov x0, #0+;; ldur x1, [x9, #0x38]+;; add x1, x1, w0, uxtw+;; ldur d0, [x1]+;; sshll v0.2d, v0.2s, #0+;; add x28, x28, #0x10+;; mov sp, x28+;; mov sp, x28+;; ldr x28, [sp], #0x10+;; ldp x29, x30, [sp], #0x10+;; ret+;; 6c: udf #0xc11fdiff --git a/tests/disas/winch/aarch64/load/v128_load32x2_u.wat b/tests/disas/winch/aarch64/load/v128_load32x2_u.watnew file mode 100644index 0000000000..8fcb6c3a86--- /dev/null+++ b/tests/disas/winch/aarch64/load/v128_load32x2_u.wat@@ -0,0 +1,37 @@+;;! target = "aarch64"+;;! test = "winch"++(module+ (memory (data "\00\00\00\00\00\00\00\00\00\00\00\00\00\00\a0\7f"))++ (func (export "v128.load32x2_u") (result v128) (v128.load32x2_u (i32.const 0)))+)+;; wasm[0]::function[0]:+;; stp x29, x30, [sp, #-0x10]!+;; mov x29, sp+;; str x28, [sp, #-0x10]!+;; mov x28, sp+;; ldur x16, [x0, #8]+;; ldur x16, [x16, #0x18]+;; mov x17, #0+;; movk x17, #0x10+;; add x16, x16, x17+;; cmp sp, x16+;; b.lo #0x6c+;; 2c: mov x9, x0+;; sub x28, x28, #0x10+;; mov sp, x28+;; stur x0, [x28, #8]+;; stur x1, [x28]+;; mov x0, #0+;; ldur x1, [x9, #0x38]+;; add x1, x1, w0, uxtw+;; ldur d0, [x1]+;; ushll v0.2d, v0.2s, #0+;; add x28, x28, #0x10+;; mov sp, x28+;; mov sp, x28+;; ldr x28, [sp], #0x10+;; ldp x29, x30, [sp], #0x10+;; ret+;; 6c: udf #0xc11fdiff --git a/tests/disas/winch/aarch64/load/v128_load64_lane.wat b/tests/disas/winch/aarch64/load/v128_load64_lane.watnew file mode 100644index 0000000000..bb9b3a465d--- /dev/null+++ b/tests/disas/winch/aarch64/load/v128_load64_lane.wat@@ -0,0 +1,46 @@+;;! target = "aarch64"+;;! test = "winch"++(module+ (memory 1 1)+ (func (export "_start") (result v128)+ (v128.load64_lane+ 1 (i32.const 0) (v128.const i64x2 0xFFFFFFFFFFFFFFFF 0xFFFFFFFFFFFFFFFF)+ )))+;; wasm[0]::function[0]:+;; stp x29, x30, [sp, #-0x10]!+;; mov x29, sp+;; str x28, [sp, #-0x10]!+;; mov x28, sp+;; ldur x16, [x0, #8]+;; ldur x16, [x16, #0x18]+;; mov x17, #0+;; movk x17, #0x10+;; add x16, x16, x17+;; cmp sp, x16+;; b.lo #0x70+;; 2c: mov x9, x0+;; sub x28, x28, #0x10+;; mov sp, x28+;; stur x0, [x28, #8]+;; stur x1, [x28]+;; ldr q0, #0x80+;; mov x0, #0+;; ldur x1, [x9, #0x38]+;; add x1, x1, w0, uxtw+;; ldur x16, [x1]+;; mov v0.d[1], x16+;; add x28, x28, #0x10+;; mov sp, x28+;; mov sp, x28+;; ldr x28, [sp], #0x10+;; ldp x29, x30, [sp], #0x10+;; ret+;; 70: udf #0xc11f+;; 74: udf #0+;; 78: udf #0+;; 7c: udf #0+;; 80: .byte 0xff, 0xff, 0xff, 0xff+;; 84: .byte 0xff, 0xff, 0xff, 0xff+;; 88: .byte 0xff, 0xff, 0xff, 0xff+;; 8c: .byte 0xff, 0xff, 0xff, 0xffdiff --git a/tests/disas/winch/aarch64/load/v128_load64_splat.wat b/tests/disas/winch/aarch64/load/v128_load64_splat.watnew file mode 100644index 0000000000..2d37e8be6e--- /dev/null+++ b/tests/disas/winch/aarch64/load/v128_load64_splat.wat@@ -0,0 +1,36 @@+;;! target = "aarch64"+;;! test = "winch"++(module+ (memory (data "\80\ff\01\ff\00\02\fe\c0\aa\55\00\00\00\00\00\00"))++ (func (export "v128.load64_splat") (result v128) (v128.load64_splat (i32.const 0)))+)+;; wasm[0]::function[0]:+;; stp x29, x30, [sp, #-0x10]!+;; mov x29, sp+;; str x28, [sp, #-0x10]!+;; mov x28, sp+;; ldur x16, [x0, #8]+;; ldur x16, [x16, #0x18]+;; mov x17, #0+;; movk x17, #0x10+;; add x16, x16, x17+;; cmp sp, x16+;; b.lo #0x68+;; 2c: mov x9, x0+;; sub x28, x28, #0x10+;; mov sp, x28+;; stur x0, [x28, #8]+;; stur x1, [x28]+;; mov x0, #0+;; ldur x1, [x9, #0x38]+;; add x1, x1, w0, uxtw+;; ld1r {v0.2d}, [x1]+;; add x28, x28, #0x10+;; mov sp, x28+;; mov sp, x28+;; ldr x28, [sp], #0x10+;; ldp x29, x30, [sp], #0x10+;; ret+;; 68: udf #0xc11fdiff --git a/tests/disas/winch/aarch64/load/v128_load64_zero.wat b/tests/disas/winch/aarch64/load/v128_load64_zero.watnew file mode 100644index 0000000000..0aa097da7c--- /dev/null+++ b/tests/disas/winch/aarch64/load/v128_load64_zero.wat@@ -0,0 +1,36 @@+;;! target = "aarch64"+;;! test = "winch"++(module+ (memory (data "\80\ff\01\ff\00\02\fe\c0\aa\55\00\00\00\00\00\00"))++ (func (export "v128.load64_zero") (result v128) (v128.load64_zero (i32.const 0)))+)+;; wasm[0]::function[0]:+;; stp x29, x30, [sp, #-0x10]!+;; mov x29, sp+;; str x28, [sp, #-0x10]!+;; mov x28, sp+;; ldur x16, [x0, #8]+;; ldur x16, [x16, #0x18]+;; mov x17, #0+;; movk x17, #0x10+;; add x16, x16, x17+;; cmp sp, x16+;; b.lo #0x68+;; 2c: mov x9, x0+;; sub x28, x28, #0x10+;; mov sp, x28+;; stur x0, [x28, #8]+;; stur x1, [x28]+;; mov x0, #0+;; ldur x1, [x9, #0x38]+;; add x1, x1, w0, uxtw+;; ldur d0, [x1]+;; add x28, x28, #0x10+;; mov sp, x28+;; mov sp, x28+;; ldr x28, [sp], #0x10+;; ldp x29, x30, [sp], #0x10+;; ret+;; 68: udf #0xc11fdiff --git a/tests/disas/winch/aarch64/load/v128_load8_lane.wat b/tests/disas/winch/aarch64/load/v128_load8_lane.watnew file mode 100644index 0000000000..2284a5407b--- /dev/null+++ b/tests/disas/winch/aarch64/load/v128_load8_lane.wat@@ -0,0 +1,46 @@+;;! target = "aarch64"+;;! test = "winch"++(module+ (memory 1 1)+ (func (export "_start") (result v128)+ (v128.load8_lane+ 1 (i32.const 0) (v128.const i64x2 0xFFFFFFFFFFFFFFFF 0xFFFFFFFFFFFFFFFF)+ )))+;; wasm[0]::function[0]:+;; stp x29, x30, [sp, #-0x10]!+;; mov x29, sp+;; str x28, [sp, #-0x10]!+;; mov x28, sp+;; ldur x16, [x0, #8]+;; ldur x16, [x16, #0x18]+;; mov x17, #0+;; movk x17, #0x10+;; add x16, x16, x17+;; cmp sp, x16+;; b.lo #0x70+;; 2c: mov x9, x0+;; sub x28, x28, #0x10+;; mov sp, x28+;; stur x0, [x28, #8]+;; stur x1, [x28]+;; ldr q0, #0x80+;; mov x0, #0+;; ldur x1, [x9, #0x38]+;; add x1, x1, w0, uxtw+;; ldurb w16, [x1]+;; mov v0.b[1], w16+;; add x28, x28, #0x10+;; mov sp, x28+;; mov sp, x28+;; ldr x28, [sp], #0x10+;; ldp x29, x30, [sp], #0x10+;; ret+;; 70: udf #0xc11f+;; 74: udf #0+;; 78: udf #0+;; 7c: udf #0+;; 80: .byte 0xff, 0xff, 0xff, 0xff+;; 84: .byte 0xff, 0xff, 0xff, 0xff+;; 88: .byte 0xff, 0xff, 0xff, 0xff+;; 8c: .byte 0xff, 0xff, 0xff, 0xffdiff --git a/tests/disas/winch/aarch64/load/v128_load8_splat.wat b/tests/disas/winch/aarch64/load/v128_load8_splat.watnew file mode 100644index 0000000000..496a852582--- /dev/null+++ b/tests/disas/winch/aarch64/load/v128_load8_splat.wat@@ -0,0 +1,36 @@+;;! target = "aarch64"+;;! test = "winch"++(module+ (memory (data "\80\ff\01\ff\00\02\fe\c0\aa\55\00\00\00\00\00\00"))++ (func (export "v128.load8_splat") (result v128) (v128.load8_splat (i32.const 0)))+)+;; wasm[0]::function[0]:+;; stp x29, x30, [sp, #-0x10]!+;; mov x29, sp+;; str x28, [sp, #-0x10]!+;; mov x28, sp+;; ldur x16, [x0, #8]+;; ldur x16, [x16, #0x18]+;; mov x17, #0+;; movk x17, #0x10+;; add x16, x16, x17+;; cmp sp, x16+;; b.lo #0x68+;; 2c: mov x9, x0+;; sub x28, x28, #0x10+;; mov sp, x28+;; stur x0, [x28, #8]+;; stur x1, [x28]+;; mov x0, #0+;; ldur x1, [x9, #0x38]+;; add x1, x1, w0, uxtw+;; ld1r {v0.16b}, [x1]+;; add x28, x28, #0x10+;; mov sp, x28+;; mov sp, x28+;; ldr x28, [sp], #0x10+;; ldp x29, x30, [sp], #0x10+;; ret+;; 68: udf #0xc11fdiff --git a/tests/disas/winch/aarch64/load/v128_load8x8_s.wat b/tests/disas/winch/aarch64/load/v128_load8x8_s.watnew file mode 100644index 0000000000..81770932a1--- /dev/null+++ b/tests/disas/winch/aarch64/load/v128_load8x8_s.wat@@ -0,0 +1,37 @@+;;! target = "aarch64"+;;! test = "winch"++(module+ (memory (data "\00\00\00\00\00\00\00\00\00\00\00\00\00\00\a0\7f"))++ (func (export "v128.load8x8_s") (result v128) (v128.load8x8_s (i32.const 0)))+)+;; wasm[0]::function[0]:+;; stp x29, x30, [sp, #-0x10]!+;; mov x29, sp+;; str x28, [sp, #-0x10]!+;; mov x28, sp+;; ldur x16, [x0, #8]+;; ldur x16, [x16, #0x18]+;; mov x17, #0+;; movk x17, #0x10+;; add x16, x16, x17+;; cmp sp, x16+;; b.lo #0x6c+;; 2c: mov x9, x0+;; sub x28, x28, #0x10+;; mov sp, x28+;; stur x0, [x28, #8]+;; stur x1, [x28]+;; mov x0, #0+;; ldur x1, [x9, #0x38]+;; add x1, x1, w0, uxtw+;; ldur d0, [x1]+;; sshll v0.8h, v0.8b, #0+;; add x28, x28, #0x10+;; mov sp, x28+;; mov sp, x28+;; ldr x28, [sp], #0x10+;; ldp x29, x30, [sp], #0x10+;; ret+;; 6c: udf #0xc11fdiff --git a/tests/disas/winch/aarch64/load/v128_load8x8_u.wat b/tests/disas/winch/aarch64/load/v128_load8x8_u.watnew file mode 100644index 0000000000..edf6b28ede--- /dev/null+++ b/tests/disas/winch/aarch64/load/v128_load8x8_u.wat@@ -0,0 +1,37 @@+;;! target = "aarch64"+;;! test = "winch"++(module+ (memory (data "\00\00\00\00\00\00\00\00\00\00\00\00\00\00\a0\7f"))++ (func (export "v128.load8x8_u") (result v128) (v128.load8x8_u (i32.const 0)))+)+;; wasm[0]::function[0]:+;; stp x29, x30, [sp, #-0x10]!+;; mov x29, sp+;; str x28, [sp, #-0x10]!+;; mov x28, sp+;; ldur x16, [x0, #8]+;; ldur x16, [x16, #0x18]+;; mov x17, #0+;; movk x17, #0x10+;; add x16, x16, x17+;; cmp sp, x16+;; b.lo #0x6c+;; 2c: mov x9, x0+;; sub x28, x28, #0x10+;; mov sp, x28+;; stur x0, [x28, #8]+;; stur x1, [x28]+;; mov x0, #0+;; ldur x1, [x9, #0x38]+;; add x1, x1, w0, uxtw+;; ldur d0, [x1]+;; ushll v0.8h, v0.8b, #0+;; add x28, x28, #0x10+;; mov sp, x28+;; mov sp, x28+;; ldr x28, [sp], #0x10+;; ldp x29, x30, [sp], #0x10+;; ret+;; 6c: udf #0xc11fdiff --git a/tests/disas/winch/aarch64/store/v128_store16_lane.wat b/tests/disas/winch/aarch64/store/v128_store16_lane.watnew file mode 100644index 0000000000..11d98d3e79--- /dev/null+++ b/tests/disas/winch/aarch64/store/v128_store16_lane.wat@@ -0,0 +1,46 @@+;;! target = "aarch64"+;;! test = "winch"++(module+ (memory 1 1)+ (func (export "_start")+ (v128.store16_lane+ 1 (i32.const 0) (v128.const i64x2 0xFFFFFFFFFFFFFFFF 0xFFFFFFFFFFFFFFFF)+ )))+;; wasm[0]::function[0]:+;; stp x29, x30, [sp, #-0x10]!+;; mov x29, sp+;; str x28, [sp, #-0x10]!+;; mov x28, sp+;; ldur x16, [x0, #8]+;; ldur x16, [x16, #0x18]+;; mov x17, #0+;; movk x17, #0x10+;; add x16, x16, x17+;; cmp sp, x16+;; b.lo #0x70+;; 2c: mov x9, x0+;; sub x28, x28, #0x10+;; mov sp, x28+;; stur x0, [x28, #8]+;; stur x1, [x28]+;; ldr q0, #0x80+;; mov x0, #0+;; ldur x1, [x9, #0x38]+;; add x1, x1, w0, uxtw+;; umov w16, v0.h[1]+;; sturh w16, [x1]+;; add x28, x28, #0x10+;; mov sp, x28+;; mov sp, x28+;; ldr x28, [sp], #0x10+;; ldp x29, x30, [sp], #0x10+;; ret+;; 70: udf #0xc11f+;; 74: udf #0+;; 78: udf #0+;; 7c: udf #0+;; 80: .byte 0xff, 0xff, 0xff, 0xff+;; 84: .byte 0xff, 0xff, 0xff, 0xff+;; 88: .byte 0xff, 0xff, 0xff, 0xff+;; 8c: .byte 0xff, 0xff, 0xff, 0xffdiff --git a/tests/disas/winch/aarch64/store/v128_store32_lane.wat b/tests/disas/winch/aarch64/store/v128_store32_lane.watnew file mode 100644index 0000000000..87358c4a9f--- /dev/null+++ b/tests/disas/winch/aarch64/store/v128_store32_lane.wat@@ -0,0 +1,46 @@+;;! target = "aarch64"+;;! test = "winch"++(module+ (memory 1 1)+ (func (export "_start")+ (v128.store32_lane+ 1 (i32.const 0) (v128.const i64x2 0xFFFFFFFFFFFFFFFF 0xFFFFFFFFFFFFFFFF)+ )))+;; wasm[0]::function[0]:+;; stp x29, x30, [sp, #-0x10]!+;; mov x29, sp+;; str x28, [sp, #-0x10]!+;; mov x28, sp+;; ldur x16, [x0, #8]+;; ldur x16, [x16, #0x18]+;; mov x17, #0+;; movk x17, #0x10+;; add x16, x16, x17+;; cmp sp, x16+;; b.lo #0x70+;; 2c: mov x9, x0+;; sub x28, x28, #0x10+;; mov sp, x28+;; stur x0, [x28, #8]+;; stur x1, [x28]+;; ldr q0, #0x80+;; mov x0, #0+;; ldur x1, [x9, #0x38]+;; add x1, x1, w0, uxtw+;; mov w16, v0.s[1]+;; stur w16, [x1]+;; add x28, x28, #0x10+;; mov sp, x28+;; mov sp, x28+;; ldr x28, [sp], #0x10+;; ldp x29, x30, [sp], #0x10+;; ret+;; 70: udf #0xc11f+;; 74: udf #0+;; 78: udf #0+;; 7c: udf #0+;; 80: .byte 0xff, 0xff, 0xff, 0xff+;; 84: .byte 0xff, 0xff, 0xff, 0xff+;; 88: .byte 0xff, 0xff, 0xff, 0xff+;; 8c: .byte 0xff, 0xff, 0xff, 0xffdiff --git a/tests/disas/winch/aarch64/store/v128_store64_lane.wat b/tests/disas/winch/aarch64/store/v128_store64_lane.watnew file mode 100644index 0000000000..2023f8fd9b--- /dev/null+++ b/tests/disas/winch/aarch64/store/v128_store64_lane.wat@@ -0,0 +1,46 @@+;;! target = "aarch64"+;;! test = "winch"++(module+ (memory 1 1)+ (func (export "_start")+ (v128.store64_lane+ 1 (i32.const 0) (v128.const i64x2 0xFFFFFFFFFFFFFFFF 0xFFFFFFFFFFFFFFFF)+ )))+;; wasm[0]::function[0]:+;; stp x29, x30, [sp, #-0x10]!+;; mov x29, sp+;; str x28, [sp, #-0x10]!+;; mov x28, sp+;; ldur x16, [x0, #8]+;; ldur x16, [x16, #0x18]+;; mov x17, #0+;; movk x17, #0x10+;; add x16, x16, x17+;; cmp sp, x16+;; b.lo #0x70+;; 2c: mov x9, x0+;; sub x28, x28, #0x10+;; mov sp, x28+;; stur x0, [x28, #8]+;; stur x1, [x28]+;; ldr q0, #0x80+;; mov x0, #0+;; ldur x1, [x9, #0x38]+;; add x1, x1, w0, uxtw+;; mov x16, v0.d[1]+;; stur x16, [x1]+;; add x28, x28, #0x10+;; mov sp, x28+;; mov sp, x28+;; ldr x28, [sp], #0x10+;; ldp x29, x30, [sp], #0x10+;; ret+;; 70: udf #0xc11f+;; 74: udf #0+;; 78: udf #0+;; 7c: udf #0+;; 80: .byte 0xff, 0xff, 0xff, 0xff+;; 84: .byte 0xff, 0xff, 0xff, 0xff+;; 88: .byte 0xff, 0xff, 0xff, 0xff+;; 8c: .byte 0xff, 0xff, 0xff, 0xffdiff --git a/tests/disas/winch/aarch64/store/v128_store8_lane.wat b/tests/disas/winch/aarch64/store/v128_store8_lane.watnew file mode 100644index 0000000000..80e5959fa7--- /dev/null+++ b/tests/disas/winch/aarch64/store/v128_store8_lane.wat@@ -0,0 +1,46 @@+;;! target = "aarch64"+;;! test = "winch"++(module+ (memory 1 1)+ (func (export "_start")+ (v128.store8_lane+ 1 (i32.const 0) (v128.const i64x2 0xFFFFFFFFFFFFFFFF 0xFFFFFFFFFFFFFFFF)+ )))+;; wasm[0]::function[0]:+;; stp x29, x30, [sp, #-0x10]!+;; mov x29, sp+;; str x28, [sp, #-0x10]!+;; mov x28, sp+;; ldur x16, [x0, #8]+;; ldur x16, [x16, #0x18]+;; mov x17, #0+;; movk x17, #0x10+;; add x16, x16, x17+;; cmp sp, x16+;; b.lo #0x70+;; 2c: mov x9, x0+;; sub x28, x28, #0x10+;; mov sp, x28+;; stur x0, [x28, #8]+;; stur x1, [x28]+;; ldr q0, #0x80+;; mov x0, #0+;; ldur x1, [x9, #0x38]+;; add x1, x1, w0, uxtw+;; umov w16, v0.b[1]+;; sturb w16, [x1]+;; add x28, x28, #0x10+;; mov sp, x28+;; mov sp, x28+;; ldr x28, [sp], #0x10+;; ldp x29, x30, [sp], #0x10+;; ret+;; 70: udf #0xc11f+;; 74: udf #0+;; 78: udf #0+;; 7c: udf #0+;; 80: .byte 0xff, 0xff, 0xff, 0xff+;; 84: .byte 0xff, 0xff, 0xff, 0xff+;; 88: .byte 0xff, 0xff, 0xff, 0xff+;; 8c: .byte 0xff, 0xff, 0xff, 0xffdiff --git a/winch/codegen/src/codegen/error.rs b/winch/codegen/src/codegen/error.rsindex edeb3c20f0..6d2db6cff0 100644--- a/winch/codegen/src/codegen/error.rs+++ b/winch/codegen/src/codegen/error.rs@@ -17,9 +17,6 @@ pub(crate) enum CodeGenError {/// Unimplemented MacroAssembler instruction.#[error("Unimplemented Masm instruction")]UnimplementedMasmInstruction,- /// Unimplemented Wasm load kind.- #[error("Unimplemented Wasm load kind")]- UnimplementedWasmLoadKind,/// Unimplemented due to requiring AVX.#[error("Instruction not implemented for CPUs without AVX support")]UnimplementedForNoAvx,diff --git a/winch/codegen/src/isa/aarch64/asm.rs b/winch/codegen/src/isa/aarch64/asm.rsindex fb1cba0997..b364eb9f1a 100644--- a/winch/codegen/src/isa/aarch64/asm.rs+++ b/winch/codegen/src/isa/aarch64/asm.rs@@ -627,6 +627,22 @@ impl Assembler {});}+ /// Load a scalar and replicate it into all vector lanes.+ pub fn vec_load_replicate(+ &mut self,+ rn: Reg,+ rd: WritableReg,+ size: VectorSize,+ flags: MemFlagsData,+ ) {+ self.emit(Inst::VecLoadReplicate {+ rd: rd.map(Into::into),+ rn: rn.into(),+ size,+ flags,+ });+ }+/// Vector ALU oppub fn vec_rrr(&mut self,diff --git a/winch/codegen/src/isa/aarch64/masm.rs b/winch/codegen/src/isa/aarch64/masm.rsindex a7673705de..663830b241 100644--- a/winch/codegen/src/isa/aarch64/masm.rs+++ b/winch/codegen/src/isa/aarch64/masm.rs@@ -18,12 +18,13 @@ use crate::{},masm::{CalleeKind, DivKind, Extend, ExtendKind, ExtractLaneKind, FloatCmpKind, FloatScratch,- Imm as I, IntCmpKind, IntScratch, LoadKind, MacroAssembler as Masm, MulWideKind,- OperandSize, RegImm, RemKind, ReplaceLaneKind, RmwOp, RoundingMode, SPOffset, Scratch,- ScratchType, ShiftKind, SplatKind, StackSlot, StoreKind, TRUSTED_FLAGS, TrapCode,- TruncKind, UNTRUSTED_FLAGS, V128AbsKind, V128AddKind, V128ConvertKind, V128ExtAddKind,- V128ExtMulKind, V128ExtendKind, V128MaxKind, V128MinKind, V128MulKind, V128NarrowKind,- V128NegKind, V128SubKind, V128TruncKind, VectorCompareKind, VectorEqualityKind, Zero,+ Imm as I, IntCmpKind, IntScratch, LaneSelector, LoadKind, MacroAssembler as Masm,+ MulWideKind, OperandSize, RegImm, RemKind, ReplaceLaneKind, RmwOp, RoundingMode, SPOffset,+ Scratch, ScratchType, ShiftKind, SplatKind, SplatLoadKind, StackSlot, StoreKind,+ TRUSTED_FLAGS, TrapCode, TruncKind, UNTRUSTED_FLAGS, V128AbsKind, V128AddKind,+ V128ConvertKind, V128ExtAddKind, V128ExtMulKind, V128ExtendKind, V128LoadExtendKind,+ V128MaxKind, V128MinKind, V128MulKind, V128NarrowKind, V128NegKind, V128SubKind,+ V128TruncKind, VectorCompareKind, VectorEqualityKind, Zero,},stack::{TypedReg, Val},};@@ -392,9 +393,14 @@ impl Masm for MacroAssembler {StoreKind::Atomic(_size) => {Err(format_err!(CodeGenError::unimplemented_masm_instruction()))}- StoreKind::VectorLane(_selector) => {- Err(format_err!(CodeGenError::unimplemented_masm_instruction()))- }+ StoreKind::VectorLane(LaneSelector { lane, size }) => masm+ .with_scratch::<IntScratch, _>(|masm, scratch| {+ masm.asm.mov_from_vec(src, scratch.writable(), lane, size);+ dst.to_addressing_mode(masm, size, |masm, mem| {+ masm.asm.str(scratch.inner(), mem, size, UNTRUSTED_FLAGS);+ Ok(())+ })+ }),})}@@ -443,10 +449,25 @@ impl Masm for MacroAssembler {fn wasm_load(&mut self, src: Self::Address, dst: WritableReg, kind: LoadKind) -> Result<()> {let size = kind.derive_operand_size();self.with_aligned_sp(|masm| match &kind {- LoadKind::Operand(_) => src.to_addressing_mode(masm, size, |masm, mem| {- Ok(masm.asm.uload(mem, dst, size, UNTRUSTED_FLAGS))- }),- LoadKind::Splat(_) => bail!(CodeGenError::UnimplementedWasmLoadKind),+ // Scalar loads into a vector register zero the unused upper bits,+ // which is exactly the semantics `VectorZero` requires.+ LoadKind::Operand(_) | LoadKind::VectorZero(_) => {+ src.to_addressing_mode(masm, size, |masm, mem| {+ Ok(masm.asm.uload(mem, dst, size, UNTRUSTED_FLAGS))+ })+ }+ LoadKind::Splat(splat_load_kind) => {+ let vector_size = match splat_load_kind {+ SplatLoadKind::S8 => VectorSize::Size8x16,+ SplatLoadKind::S16 => VectorSize::Size16x8,+ SplatLoadKind::S32 => VectorSize::Size32x4,+ SplatLoadKind::S64 => VectorSize::Size64x2,+ };+ let (base, _) = src.unwrap_offset();+ masm.asm+ .vec_load_replicate(base, dst, vector_size, UNTRUSTED_FLAGS);+ Ok(())+ }LoadKind::ScalarExtend(extend_kind) => {if extend_kind.signed() {src.to_addressing_mode(masm, size, |masm, mem| {@@ -461,16 +482,41 @@ impl Masm for MacroAssembler {})}}- LoadKind::VectorExtend(_vector_extend_kind) => {- bail!(CodeGenError::UnimplementedWasmLoadKind)+ LoadKind::VectorExtend(extend_kind) => {+ let (op, lane_size) = match extend_kind {+ V128LoadExtendKind::E8x8S => (VecExtendOp::Sxtl, ScalarSize::Size16),+ V128LoadExtendKind::E8x8U => (VecExtendOp::Uxtl, ScalarSize::Size16),+ V128LoadExtendKind::E16x4S => (VecExtendOp::Sxtl, ScalarSize::Size32),+ V128LoadExtendKind::E16x4U => (VecExtendOp::Uxtl, ScalarSize::Size32),+ V128LoadExtendKind::E32x2S => (VecExtendOp::Sxtl, ScalarSize::Size64),+ V128LoadExtendKind::E32x2U => (VecExtendOp::Uxtl, ScalarSize::Size64),+ };+ src.to_addressing_mode(masm, size, |masm, mem| {+ masm.asm.uload(mem, dst, size, UNTRUSTED_FLAGS);+ masm.asm.vec_extend(op, dst.to_reg(), dst, false, lane_size);+ Ok(())+ })}- LoadKind::VectorLane(_selector) => {- bail!(CodeGenError::unimplemented_masm_instruction())+ LoadKind::VectorLane(LaneSelector { lane, size }) => {+ let vector_size = match size {+ OperandSize::S8 => VectorSize::Size8x16,+ OperandSize::S16 => VectorSize::Size16x8,+ OperandSize::S32 => VectorSize::Size32x4,+ OperandSize::S64 => VectorSize::Size64x2,+ _ => bail!(CodeGenError::unexpected_operand_size()),+ };+ masm.with_scratch::<IntScratch, _>(|masm, scratch| {+ src.to_addressing_mode(masm, *size, |masm, mem| {+ masm.asm+ .uload(mem, scratch.writable(), *size, UNTRUSTED_FLAGS);+ Ok(())+ })?;+ masm.asm+ .mov_to_vec(scratch.inner(), dst, *lane, vector_size);+ Ok(())+ })}LoadKind::Atomic(_, _) => bail!(CodeGenError::unimplemented_masm_instruction()),- LoadKind::VectorZero(_size) => {- bail!(CodeGenError::UnimplementedWasmLoadKind)- }})}