A lightweight WebAssembly runtime that is fast, secure, and standards-compliant
winch(aarch64): v128 splat and lane ops (#13940)
Daniel Macovei917ac37b86c5
diff --git a/crates/test-util/src/wast.rs b/crates/test-util/src/wast.rsindex 623177037e..ceaa45d550 100644--- a/crates/test-util/src/wast.rs+++ b/crates/test-util/src/wast.rs@@ -516,6 +516,8 @@ impl WastTest {let now_supported = ["misc_testsuite/winch/v128_load_lane_invalid_address.wast","misc_testsuite/simd/issue4807.wast",+ "misc_testsuite/simd/replace-lane-preserve.wast",+ "misc_testsuite/simd/spillslot-size-fuzzbug.wast",];if now_supported.iter().any(|part| self.path.ends_with(part)) {return false;diff --git a/tests/disas/winch/aarch64/v128_ops/f32x4_extract_lane.wat b/tests/disas/winch/aarch64/v128_ops/f32x4_extract_lane.watnew file mode 100644index 0000000000..8155d9542a--- /dev/null+++ b/tests/disas/winch/aarch64/v128_ops/f32x4_extract_lane.wat@@ -0,0 +1,39 @@+;;! target = "aarch64"+;;! test = "winch"++(module+ (func (export "run") (result f32)+ (f32x4.extract_lane 3 (v128.const i8x16 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25))))+;; 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 #0x60+;; 2c: mov x9, x0+;; sub x28, x28, #0x10+;; mov sp, x28+;; stur x0, [x28, #8]+;; stur x1, [x28]+;; ldr q0, #0x70+;; mov s0, v0.s[3]+;; add x28, x28, #0x10+;; mov sp, x28+;; mov sp, x28+;; ldr x28, [sp], #0x10+;; ldp x29, x30, [sp], #0x10+;; ret+;; 60: udf #0xc11f+;; 64: udf #0+;; 68: udf #0+;; 6c: udf #0+;; 70: .byte 0x0a, 0x0b, 0x0c, 0x0d+;; 74: add w14, w24, #0x403+;; 78: b #0x4504cc0+;; 7c: .byte 0x16, 0x17, 0x18, 0x19diff --git a/tests/disas/winch/aarch64/v128_ops/f32x4_replace_lane.wat b/tests/disas/winch/aarch64/v128_ops/f32x4_replace_lane.watnew file mode 100644index 0000000000..b7115a3b00--- /dev/null+++ b/tests/disas/winch/aarch64/v128_ops/f32x4_replace_lane.wat@@ -0,0 +1,45 @@+;;! target = "aarch64"+;;! test = "winch"++(module+ (memory 1)+ (func (export "run")+ (v128.store (i32.const 0)+ (f32x4.replace_lane 2 (v128.const i8x16 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25) (f32.const 1.5)))))+;; 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 #0x74+;; 2c: mov x9, x0+;; sub x28, x28, #0x10+;; mov sp, x28+;; stur x0, [x28, #8]+;; stur x1, [x28]+;; ldr q0, #0x80+;; fmov s31, #1.50000000+;; mov v0.s[2], v31.s[0]+;; mov x0, #0+;; ldur x1, [x9, #0x38]+;; add x1, x1, w0, uxtw+;; stur q0, [x1]+;; add x28, x28, #0x10+;; mov sp, x28+;; mov sp, x28+;; ldr x28, [sp], #0x10+;; ldp x29, x30, [sp], #0x10+;; ret+;; 74: udf #0xc11f+;; 78: udf #0+;; 7c: udf #0+;; 80: .byte 0x0a, 0x0b, 0x0c, 0x0d+;; 84: add w14, w24, #0x403+;; 88: b #0x4504cd0+;; 8c: .byte 0x16, 0x17, 0x18, 0x19diff --git a/tests/disas/winch/aarch64/v128_ops/f32x4_splat.wat b/tests/disas/winch/aarch64/v128_ops/f32x4_splat.watnew file mode 100644index 0000000000..79349a0932--- /dev/null+++ b/tests/disas/winch/aarch64/v128_ops/f32x4_splat.wat@@ -0,0 +1,38 @@+;;! target = "aarch64"+;;! test = "winch"++(module+ (memory 1)+ (func (export "run")+ (v128.store (i32.const 0)+ (f32x4.splat (f32.const 1.5)))))+;; 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]+;; fmov s0, #1.50000000+;; dup v1.4s, v0.s[0]+;; mov x0, #0+;; ldur x1, [x9, #0x38]+;; add x1, x1, w0, uxtw+;; stur q1, [x1]+;; add x28, x28, #0x10+;; mov sp, x28+;; mov sp, x28+;; ldr x28, [sp], #0x10+;; ldp x29, x30, [sp], #0x10+;; ret+;; 70: udf #0xc11fdiff --git a/tests/disas/winch/aarch64/v128_ops/f64x2_extract_lane.wat b/tests/disas/winch/aarch64/v128_ops/f64x2_extract_lane.watnew file mode 100644index 0000000000..e3583b0f83--- /dev/null+++ b/tests/disas/winch/aarch64/v128_ops/f64x2_extract_lane.wat@@ -0,0 +1,39 @@+;;! target = "aarch64"+;;! test = "winch"++(module+ (func (export "run") (result f64)+ (f64x2.extract_lane 1 (v128.const i8x16 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25))))+;; 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 #0x60+;; 2c: mov x9, x0+;; sub x28, x28, #0x10+;; mov sp, x28+;; stur x0, [x28, #8]+;; stur x1, [x28]+;; ldr q0, #0x70+;; mov d0, v0.d[1]+;; add x28, x28, #0x10+;; mov sp, x28+;; mov sp, x28+;; ldr x28, [sp], #0x10+;; ldp x29, x30, [sp], #0x10+;; ret+;; 60: udf #0xc11f+;; 64: udf #0+;; 68: udf #0+;; 6c: udf #0+;; 70: .byte 0x0a, 0x0b, 0x0c, 0x0d+;; 74: add w14, w24, #0x403+;; 78: b #0x4504cc0+;; 7c: .byte 0x16, 0x17, 0x18, 0x19diff --git a/tests/disas/winch/aarch64/v128_ops/f64x2_replace_lane.wat b/tests/disas/winch/aarch64/v128_ops/f64x2_replace_lane.watnew file mode 100644index 0000000000..a2a4b37c6f--- /dev/null+++ b/tests/disas/winch/aarch64/v128_ops/f64x2_replace_lane.wat@@ -0,0 +1,47 @@+;;! target = "aarch64"+;;! test = "winch"++(module+ (memory 1)+ (func (export "run")+ (v128.store (i32.const 0)+ (f64x2.replace_lane 1 (v128.const i8x16 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25) (f64.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 #0x74+;; 2c: mov x9, x0+;; sub x28, x28, #0x10+;; mov sp, x28+;; stur x0, [x28, #8]+;; stur x1, [x28]+;; ldr q0, #0x80+;; ldr d31, #0x90+;; mov v0.d[1], v31.d[0]+;; mov x0, #0+;; ldur x1, [x9, #0x38]+;; add x1, x1, w0, uxtw+;; stur q0, [x1]+;; add x28, x28, #0x10+;; mov sp, x28+;; mov sp, x28+;; ldr x28, [sp], #0x10+;; ldp x29, x30, [sp], #0x10+;; ret+;; 74: udf #0xc11f+;; 78: udf #0+;; 7c: udf #0+;; 80: .byte 0x0a, 0x0b, 0x0c, 0x0d+;; 84: add w14, w24, #0x403+;; 88: b #0x4504cd0+;; 8c: .byte 0x16, 0x17, 0x18, 0x19+;; 90: udf #0+;; 94: .byte 0x00, 0x00, 0x00, 0x80diff --git a/tests/disas/winch/aarch64/v128_ops/f64x2_splat.wat b/tests/disas/winch/aarch64/v128_ops/f64x2_splat.watnew file mode 100644index 0000000000..facabd1a53--- /dev/null+++ b/tests/disas/winch/aarch64/v128_ops/f64x2_splat.wat@@ -0,0 +1,41 @@+;;! target = "aarch64"+;;! test = "winch"++(module+ (memory 1)+ (func (export "run")+ (v128.store (i32.const 0)+ (f64x2.splat (f64.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 #0x70+;; 2c: mov x9, x0+;; sub x28, x28, #0x10+;; mov sp, x28+;; stur x0, [x28, #8]+;; stur x1, [x28]+;; ldr d0, #0x78+;; dup v1.2d, v0.d[0]+;; mov x0, #0+;; ldur x1, [x9, #0x38]+;; add x1, x1, w0, uxtw+;; stur q1, [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: .byte 0x00, 0x00, 0x00, 0x80diff --git a/tests/disas/winch/aarch64/v128_ops/i16x8_extract_lane_s.wat b/tests/disas/winch/aarch64/v128_ops/i16x8_extract_lane_s.watnew file mode 100644index 0000000000..2770462551--- /dev/null+++ b/tests/disas/winch/aarch64/v128_ops/i16x8_extract_lane_s.wat@@ -0,0 +1,39 @@+;;! target = "aarch64"+;;! test = "winch"++(module+ (func (export "run") (result i32)+ (i16x8.extract_lane_s 7 (v128.const i8x16 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25))))+;; 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 #0x60+;; 2c: mov x9, x0+;; sub x28, x28, #0x10+;; mov sp, x28+;; stur x0, [x28, #8]+;; stur x1, [x28]+;; ldr q0, #0x70+;; smov w0, v0.h[7]+;; add x28, x28, #0x10+;; mov sp, x28+;; mov sp, x28+;; ldr x28, [sp], #0x10+;; ldp x29, x30, [sp], #0x10+;; ret+;; 60: udf #0xc11f+;; 64: udf #0+;; 68: udf #0+;; 6c: udf #0+;; 70: .byte 0x0a, 0x0b, 0x0c, 0x0d+;; 74: add w14, w24, #0x403+;; 78: b #0x4504cc0+;; 7c: .byte 0x16, 0x17, 0x18, 0x19diff --git a/tests/disas/winch/aarch64/v128_ops/i16x8_extract_lane_u.wat b/tests/disas/winch/aarch64/v128_ops/i16x8_extract_lane_u.watnew file mode 100644index 0000000000..179e1a870d--- /dev/null+++ b/tests/disas/winch/aarch64/v128_ops/i16x8_extract_lane_u.wat@@ -0,0 +1,39 @@+;;! target = "aarch64"+;;! test = "winch"++(module+ (func (export "run") (result i32)+ (i16x8.extract_lane_u 3 (v128.const i8x16 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25))))+;; 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 #0x60+;; 2c: mov x9, x0+;; sub x28, x28, #0x10+;; mov sp, x28+;; stur x0, [x28, #8]+;; stur x1, [x28]+;; ldr q0, #0x70+;; umov w0, v0.h[3]+;; add x28, x28, #0x10+;; mov sp, x28+;; mov sp, x28+;; ldr x28, [sp], #0x10+;; ldp x29, x30, [sp], #0x10+;; ret+;; 60: udf #0xc11f+;; 64: udf #0+;; 68: udf #0+;; 6c: udf #0+;; 70: .byte 0x0a, 0x0b, 0x0c, 0x0d+;; 74: add w14, w24, #0x403+;; 78: b #0x4504cc0+;; 7c: .byte 0x16, 0x17, 0x18, 0x19diff --git a/tests/disas/winch/aarch64/v128_ops/i16x8_replace_lane.wat b/tests/disas/winch/aarch64/v128_ops/i16x8_replace_lane.watnew file mode 100644index 0000000000..b25927a8a5--- /dev/null+++ b/tests/disas/winch/aarch64/v128_ops/i16x8_replace_lane.wat@@ -0,0 +1,45 @@+;;! target = "aarch64"+;;! test = "winch"++(module+ (memory 1)+ (func (export "run")+ (v128.store (i32.const 0)+ (i16x8.replace_lane 0 (v128.const i8x16 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25) (i32.const 0x7FFF)))))+;; 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 #0x74+;; 2c: mov x9, x0+;; sub x28, x28, #0x10+;; mov sp, x28+;; stur x0, [x28, #8]+;; stur x1, [x28]+;; ldr q0, #0x80+;; mov x16, #0x7fff+;; mov v0.h[0], w16+;; mov x0, #0+;; ldur x1, [x9, #0x38]+;; add x1, x1, w0, uxtw+;; stur q0, [x1]+;; add x28, x28, #0x10+;; mov sp, x28+;; mov sp, x28+;; ldr x28, [sp], #0x10+;; ldp x29, x30, [sp], #0x10+;; ret+;; 74: udf #0xc11f+;; 78: udf #0+;; 7c: udf #0+;; 80: .byte 0x0a, 0x0b, 0x0c, 0x0d+;; 84: add w14, w24, #0x403+;; 88: b #0x4504cd0+;; 8c: .byte 0x16, 0x17, 0x18, 0x19diff --git a/tests/disas/winch/aarch64/v128_ops/i16x8_splat.wat b/tests/disas/winch/aarch64/v128_ops/i16x8_splat.watnew file mode 100644index 0000000000..e5da640eb4--- /dev/null+++ b/tests/disas/winch/aarch64/v128_ops/i16x8_splat.wat@@ -0,0 +1,38 @@+;;! target = "aarch64"+;;! test = "winch"++(module+ (memory 1)+ (func (export "run")+ (v128.store (i32.const 0)+ (i16x8.splat (i32.const 0x8001)))))+;; 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]+;; mov x0, #0x8001+;; dup v0.8h, w0+;; mov x0, #0+;; ldur x1, [x9, #0x38]+;; add x1, x1, w0, uxtw+;; stur q0, [x1]+;; add x28, x28, #0x10+;; mov sp, x28+;; mov sp, x28+;; ldr x28, [sp], #0x10+;; ldp x29, x30, [sp], #0x10+;; ret+;; 70: udf #0xc11fdiff --git a/tests/disas/winch/aarch64/v128_ops/i32x4_extract_lane.wat b/tests/disas/winch/aarch64/v128_ops/i32x4_extract_lane.watnew file mode 100644index 0000000000..9b15961673--- /dev/null+++ b/tests/disas/winch/aarch64/v128_ops/i32x4_extract_lane.wat@@ -0,0 +1,39 @@+;;! target = "aarch64"+;;! test = "winch"++(module+ (func (export "run") (result i32)+ (i32x4.extract_lane 2 (v128.const i8x16 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25))))+;; 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 #0x60+;; 2c: mov x9, x0+;; sub x28, x28, #0x10+;; mov sp, x28+;; stur x0, [x28, #8]+;; stur x1, [x28]+;; ldr q0, #0x70+;; mov w0, v0.s[2]+;; add x28, x28, #0x10+;; mov sp, x28+;; mov sp, x28+;; ldr x28, [sp], #0x10+;; ldp x29, x30, [sp], #0x10+;; ret+;; 60: udf #0xc11f+;; 64: udf #0+;; 68: udf #0+;; 6c: udf #0+;; 70: .byte 0x0a, 0x0b, 0x0c, 0x0d+;; 74: add w14, w24, #0x403+;; 78: b #0x4504cc0+;; 7c: .byte 0x16, 0x17, 0x18, 0x19diff --git a/tests/disas/winch/aarch64/v128_ops/i32x4_replace_lane.wat b/tests/disas/winch/aarch64/v128_ops/i32x4_replace_lane.watnew file mode 100644index 0000000000..88f7a493e2--- /dev/null+++ b/tests/disas/winch/aarch64/v128_ops/i32x4_replace_lane.wat@@ -0,0 +1,45 @@+;;! target = "aarch64"+;;! test = "winch"++(module+ (memory 1)+ (func (export "run")+ (v128.store (i32.const 0)+ (i32x4.replace_lane 3 (v128.const i8x16 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25) (i32.const -1)))))+;; 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 #0x74+;; 2c: mov x9, x0+;; sub x28, x28, #0x10+;; mov sp, x28+;; stur x0, [x28, #8]+;; stur x1, [x28]+;; ldr q0, #0x80+;; mov x16, #0xffffffff+;; mov v0.s[3], w16+;; mov x0, #0+;; ldur x1, [x9, #0x38]+;; add x1, x1, w0, uxtw+;; stur q0, [x1]+;; add x28, x28, #0x10+;; mov sp, x28+;; mov sp, x28+;; ldr x28, [sp], #0x10+;; ldp x29, x30, [sp], #0x10+;; ret+;; 74: udf #0xc11f+;; 78: udf #0+;; 7c: udf #0+;; 80: .byte 0x0a, 0x0b, 0x0c, 0x0d+;; 84: add w14, w24, #0x403+;; 88: b #0x4504cd0+;; 8c: .byte 0x16, 0x17, 0x18, 0x19diff --git a/tests/disas/winch/aarch64/v128_ops/i32x4_splat.wat b/tests/disas/winch/aarch64/v128_ops/i32x4_splat.watnew file mode 100644index 0000000000..36fd76a93e--- /dev/null+++ b/tests/disas/winch/aarch64/v128_ops/i32x4_splat.wat@@ -0,0 +1,38 @@+;;! target = "aarch64"+;;! test = "winch"++(module+ (memory 1)+ (func (export "run")+ (v128.store (i32.const 0)+ (i32x4.splat (i32.const 7)))))+;; 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]+;; mov x0, #7+;; dup v0.4s, w0+;; mov x0, #0+;; ldur x1, [x9, #0x38]+;; add x1, x1, w0, uxtw+;; stur q0, [x1]+;; add x28, x28, #0x10+;; mov sp, x28+;; mov sp, x28+;; ldr x28, [sp], #0x10+;; ldp x29, x30, [sp], #0x10+;; ret+;; 70: udf #0xc11fdiff --git a/tests/disas/winch/aarch64/v128_ops/i64x2_extract_lane.wat b/tests/disas/winch/aarch64/v128_ops/i64x2_extract_lane.watnew file mode 100644index 0000000000..b82dfdb80d--- /dev/null+++ b/tests/disas/winch/aarch64/v128_ops/i64x2_extract_lane.wat@@ -0,0 +1,39 @@+;;! target = "aarch64"+;;! test = "winch"++(module+ (func (export "run") (result i64)+ (i64x2.extract_lane 1 (v128.const i8x16 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25))))+;; 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 #0x60+;; 2c: mov x9, x0+;; sub x28, x28, #0x10+;; mov sp, x28+;; stur x0, [x28, #8]+;; stur x1, [x28]+;; ldr q0, #0x70+;; mov x0, v0.d[1]+;; add x28, x28, #0x10+;; mov sp, x28+;; mov sp, x28+;; ldr x28, [sp], #0x10+;; ldp x29, x30, [sp], #0x10+;; ret+;; 60: udf #0xc11f+;; 64: udf #0+;; 68: udf #0+;; 6c: udf #0+;; 70: .byte 0x0a, 0x0b, 0x0c, 0x0d+;; 74: add w14, w24, #0x403+;; 78: b #0x4504cc0+;; 7c: .byte 0x16, 0x17, 0x18, 0x19diff --git a/tests/disas/winch/aarch64/v128_ops/i64x2_replace_lane.wat b/tests/disas/winch/aarch64/v128_ops/i64x2_replace_lane.watnew file mode 100644index 0000000000..0bd50decc0--- /dev/null+++ b/tests/disas/winch/aarch64/v128_ops/i64x2_replace_lane.wat@@ -0,0 +1,45 @@+;;! target = "aarch64"+;;! test = "winch"++(module+ (memory 1)+ (func (export "run")+ (v128.store (i32.const 0)+ (i64x2.replace_lane 0 (v128.const i8x16 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25) (i64.const -2)))))+;; 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 #0x74+;; 2c: mov x9, x0+;; sub x28, x28, #0x10+;; mov sp, x28+;; stur x0, [x28, #8]+;; stur x1, [x28]+;; ldr q0, #0x80+;; mov x16, #-2+;; mov v0.d[0], x16+;; mov x0, #0+;; ldur x1, [x9, #0x38]+;; add x1, x1, w0, uxtw+;; stur q0, [x1]+;; add x28, x28, #0x10+;; mov sp, x28+;; mov sp, x28+;; ldr x28, [sp], #0x10+;; ldp x29, x30, [sp], #0x10+;; ret+;; 74: udf #0xc11f+;; 78: udf #0+;; 7c: udf #0+;; 80: .byte 0x0a, 0x0b, 0x0c, 0x0d+;; 84: add w14, w24, #0x403+;; 88: b #0x4504cd0+;; 8c: .byte 0x16, 0x17, 0x18, 0x19diff --git a/tests/disas/winch/aarch64/v128_ops/i64x2_splat.wat b/tests/disas/winch/aarch64/v128_ops/i64x2_splat.watnew file mode 100644index 0000000000..cf1ddfeaff--- /dev/null+++ b/tests/disas/winch/aarch64/v128_ops/i64x2_splat.wat@@ -0,0 +1,38 @@+;;! target = "aarch64"+;;! test = "winch"++(module+ (memory 1)+ (func (export "run")+ (v128.store (i32.const 0)+ (i64x2.splat (i64.const -2)))))+;; 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]+;; mov x0, #-2+;; dup v0.2d, x0+;; mov x0, #0+;; ldur x1, [x9, #0x38]+;; add x1, x1, w0, uxtw+;; stur q0, [x1]+;; add x28, x28, #0x10+;; mov sp, x28+;; mov sp, x28+;; ldr x28, [sp], #0x10+;; ldp x29, x30, [sp], #0x10+;; ret+;; 70: udf #0xc11fdiff --git a/tests/disas/winch/aarch64/v128_ops/i8x16_extract_lane_s.wat b/tests/disas/winch/aarch64/v128_ops/i8x16_extract_lane_s.watnew file mode 100644index 0000000000..7d1aab1cc7--- /dev/null+++ b/tests/disas/winch/aarch64/v128_ops/i8x16_extract_lane_s.wat@@ -0,0 +1,39 @@+;;! target = "aarch64"+;;! test = "winch"++(module+ (func (export "run") (result i32)+ (i8x16.extract_lane_s 15 (v128.const i8x16 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25))))+;; 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 #0x60+;; 2c: mov x9, x0+;; sub x28, x28, #0x10+;; mov sp, x28+;; stur x0, [x28, #8]+;; stur x1, [x28]+;; ldr q0, #0x70+;; smov w0, v0.b[0xf]+;; add x28, x28, #0x10+;; mov sp, x28+;; mov sp, x28+;; ldr x28, [sp], #0x10+;; ldp x29, x30, [sp], #0x10+;; ret+;; 60: udf #0xc11f+;; 64: udf #0+;; 68: udf #0+;; 6c: udf #0+;; 70: .byte 0x0a, 0x0b, 0x0c, 0x0d+;; 74: add w14, w24, #0x403+;; 78: b #0x4504cc0+;; 7c: .byte 0x16, 0x17, 0x18, 0x19diff --git a/tests/disas/winch/aarch64/v128_ops/i8x16_extract_lane_u.wat b/tests/disas/winch/aarch64/v128_ops/i8x16_extract_lane_u.watnew file mode 100644index 0000000000..6744041128--- /dev/null+++ b/tests/disas/winch/aarch64/v128_ops/i8x16_extract_lane_u.wat@@ -0,0 +1,39 @@+;;! target = "aarch64"+;;! test = "winch"++(module+ (func (export "run") (result i32)+ (i8x16.extract_lane_u 0 (v128.const i8x16 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25))))+;; 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 #0x60+;; 2c: mov x9, x0+;; sub x28, x28, #0x10+;; mov sp, x28+;; stur x0, [x28, #8]+;; stur x1, [x28]+;; ldr q0, #0x70+;; umov w0, v0.b[0]+;; add x28, x28, #0x10+;; mov sp, x28+;; mov sp, x28+;; ldr x28, [sp], #0x10+;; ldp x29, x30, [sp], #0x10+;; ret+;; 60: udf #0xc11f+;; 64: udf #0+;; 68: udf #0+;; 6c: udf #0+;; 70: .byte 0x0a, 0x0b, 0x0c, 0x0d+;; 74: add w14, w24, #0x403+;; 78: b #0x4504cc0+;; 7c: .byte 0x16, 0x17, 0x18, 0x19diff --git a/tests/disas/winch/aarch64/v128_ops/i8x16_replace_lane.wat b/tests/disas/winch/aarch64/v128_ops/i8x16_replace_lane.watnew file mode 100644index 0000000000..00cc3aecfb--- /dev/null+++ b/tests/disas/winch/aarch64/v128_ops/i8x16_replace_lane.wat@@ -0,0 +1,45 @@+;;! target = "aarch64"+;;! test = "winch"++(module+ (memory 1)+ (func (export "run")+ (v128.store (i32.const 0)+ (i8x16.replace_lane 15 (v128.const i8x16 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25) (i32.const 99)))))+;; 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 #0x74+;; 2c: mov x9, x0+;; sub x28, x28, #0x10+;; mov sp, x28+;; stur x0, [x28, #8]+;; stur x1, [x28]+;; ldr q0, #0x80+;; mov x16, #0x63+;; mov v0.b[0xf], w16+;; mov x0, #0+;; ldur x1, [x9, #0x38]+;; add x1, x1, w0, uxtw+;; stur q0, [x1]+;; add x28, x28, #0x10+;; mov sp, x28+;; mov sp, x28+;; ldr x28, [sp], #0x10+;; ldp x29, x30, [sp], #0x10+;; ret+;; 74: udf #0xc11f+;; 78: udf #0+;; 7c: udf #0+;; 80: .byte 0x0a, 0x0b, 0x0c, 0x0d+;; 84: add w14, w24, #0x403+;; 88: b #0x4504cd0+;; 8c: .byte 0x16, 0x17, 0x18, 0x19diff --git a/tests/disas/winch/aarch64/v128_ops/i8x16_splat.wat b/tests/disas/winch/aarch64/v128_ops/i8x16_splat.watnew file mode 100644index 0000000000..6e18422a14--- /dev/null+++ b/tests/disas/winch/aarch64/v128_ops/i8x16_splat.wat@@ -0,0 +1,38 @@+;;! target = "aarch64"+;;! test = "winch"++(module+ (memory 1)+ (func (export "run")+ (v128.store (i32.const 0)+ (i8x16.splat (i32.const 200)))))+;; 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]+;; mov x0, #0xc8+;; dup v0.16b, w0+;; mov x0, #0+;; ldur x1, [x9, #0x38]+;; add x1, x1, w0, uxtw+;; stur q0, [x1]+;; add x28, x28, #0x10+;; mov sp, x28+;; mov sp, x28+;; ldr x28, [sp], #0x10+;; ldp x29, x30, [sp], #0x10+;; ret+;; 70: udf #0xc11fdiff --git a/winch/codegen/src/isa/aarch64/asm.rs b/winch/codegen/src/isa/aarch64/asm.rsindex 431df7b15b..b652ed4778 100644--- a/winch/codegen/src/isa/aarch64/asm.rs+++ b/winch/codegen/src/isa/aarch64/asm.rs@@ -468,6 +468,86 @@ impl Assembler {});}}+ /// Duplicate a general-purpose register's value into every lane of a+ /// vector register.+ pub fn vec_dup(&mut self, rn: Reg, rd: WritableReg, size: VectorSize) {+ self.emit(Inst::VecDup {+ rd: rd.map(Into::into),+ rn: rn.into(),+ size,+ });+ }++ /// Signed move from a vector element to a GPR.+ pub fn mov_from_vec_signed(+ &mut self,+ rn: Reg,+ rd: WritableReg,+ idx: u8,+ size: VectorSize,+ scalar_size: OperandSize,+ ) {+ self.emit(Inst::MovFromVecSigned {+ rd: rd.map(Into::into),+ rn: rn.into(),+ idx,+ size,+ scalar_size: scalar_size.into(),+ });+ }++ /// Move from a vector element to a scalar float register.+ pub fn fpu_move_from_vec(&mut self, rn: Reg, rd: WritableReg, idx: u8, size: VectorSize) {+ self.emit(Inst::FpuMoveFromVec {+ rd: rd.map(Into::into),+ rn: rn.into(),+ idx,+ size,+ });+ }++ /// Move a GPR into a vector element, preserving the other lanes.+ pub fn mov_to_vec(&mut self, rn: Reg, rd: WritableReg, idx: u8, size: VectorSize) {+ self.emit(Inst::MovToVec {+ rd: rd.map(Into::into),+ ri: rd.to_reg().into(),+ rn: rn.into(),+ idx,+ size,+ });+ }++ /// Move a vector element into a vector element, preserving the other+ /// lanes.+ pub fn vec_mov_element(+ &mut self,+ rn: Reg,+ rd: WritableReg,+ dest_idx: u8,+ src_idx: u8,+ size: VectorSize,+ ) {+ self.emit(Inst::VecMovElement {+ rd: rd.map(Into::into),+ ri: rd.to_reg().into(),+ rn: rn.into(),+ dest_idx,+ src_idx,+ size,+ });+ }++ /// Duplicate one lane of a vector register into every lane of a vector+ /// register.+ pub fn vec_dup_elem(&mut self, rn: Reg, rd: WritableReg, size: VectorSize, lane: u8) {+ self.emit(Inst::VecDupFromFpu {+ rd: rd.map(Into::into),+ rn: rn.into(),+ size,+ lane,+ });+ }+/// Vector three-register ALU operation whose destination is also an inputpub fn vec_rrr_mod(&mut self,diff --git a/winch/codegen/src/isa/aarch64/masm.rs b/winch/codegen/src/isa/aarch64/masm.rsindex 1727bb87a0..eb05a7f2ac 100644--- a/winch/codegen/src/isa/aarch64/masm.rs+++ b/winch/codegen/src/isa/aarch64/masm.rs@@ -1319,8 +1319,33 @@ impl Masm for MacroAssembler {Ok(())}- fn splat(&mut self, _context: &mut CodeGenContext<Emission>, _size: SplatKind) -> Result<()> {- bail!(CodeGenError::unimplemented_masm_instruction())+ fn splat(&mut self, context: &mut CodeGenContext<Emission>, size: SplatKind) -> Result<()> {+ let src = context.pop_to_reg(self, None)?;+ let dst = writable!(context.any_fpr(self)?);++ match size {+ SplatKind::I8x16 => {+ self.asm.vec_dup(src.reg, dst, VectorSize::Size8x16);+ }+ SplatKind::I16x8 => {+ self.asm.vec_dup(src.reg, dst, VectorSize::Size16x8);+ }+ SplatKind::I32x4 => {+ self.asm.vec_dup(src.reg, dst, VectorSize::Size32x4);+ }+ SplatKind::I64x2 => {+ self.asm.vec_dup(src.reg, dst, VectorSize::Size64x2);+ }+ SplatKind::F32x4 => {+ self.asm.vec_dup_elem(src.reg, dst, VectorSize::Size32x4, 0);+ }+ SplatKind::F64x2 => {+ self.asm.vec_dup_elem(src.reg, dst, VectorSize::Size64x2, 0);+ }+ }+ context.free_reg(src);+ context.stack.push(TypedReg::v128(dst.to_reg()).into());+ Ok(())}fn shuffle(&mut self, _dst: WritableReg, _lhs: Reg, _rhs: Reg, _lanes: [u8; 16]) -> Result<()> {@@ -1345,22 +1370,76 @@ impl Masm for MacroAssembler {fn extract_lane(&mut self,- _src: Reg,- _dst: WritableReg,- _lane: u8,- _kind: ExtractLaneKind,+ src: Reg,+ dst: WritableReg,+ lane: u8,+ kind: ExtractLaneKind,) -> Result<()> {- bail!(CodeGenError::unimplemented_masm_instruction())+ match kind {+ ExtractLaneKind::I8x16S => {+ self.asm+ .mov_from_vec_signed(src, dst, lane, VectorSize::Size8x16, OperandSize::S32)+ }+ ExtractLaneKind::I16x8S => {+ self.asm+ .mov_from_vec_signed(src, dst, lane, VectorSize::Size16x8, OperandSize::S32)+ }+ ExtractLaneKind::I8x16U => self.asm.mov_from_vec(src, dst, lane, OperandSize::S8),+ ExtractLaneKind::I16x8U => self.asm.mov_from_vec(src, dst, lane, OperandSize::S16),+ ExtractLaneKind::I32x4 => self.asm.mov_from_vec(src, dst, lane, OperandSize::S32),+ ExtractLaneKind::I64x2 => self.asm.mov_from_vec(src, dst, lane, OperandSize::S64),+ ExtractLaneKind::F32x4 => {+ self.asm+ .fpu_move_from_vec(src, dst, lane, VectorSize::Size32x4)+ }+ ExtractLaneKind::F64x2 => {+ self.asm+ .fpu_move_from_vec(src, dst, lane, VectorSize::Size64x2)+ }+ }+ Ok(())}fn replace_lane(&mut self,- _src: RegImm,- _dst: WritableReg,- _lane: u8,- _kind: ReplaceLaneKind,+ src: RegImm,+ dst: WritableReg,+ lane: u8,+ kind: ReplaceLaneKind,) -> Result<()> {- bail!(CodeGenError::unimplemented_masm_instruction())+ let size = match kind {+ ReplaceLaneKind::I8x16 => VectorSize::Size8x16,+ ReplaceLaneKind::I16x8 => VectorSize::Size16x8,+ ReplaceLaneKind::I32x4 => VectorSize::Size32x4,+ ReplaceLaneKind::I64x2 => VectorSize::Size64x2,+ ReplaceLaneKind::F32x4 => VectorSize::Size32x4,+ ReplaceLaneKind::F64x2 => VectorSize::Size64x2,+ };+ match kind {+ ReplaceLaneKind::I8x16+ | ReplaceLaneKind::I16x8+ | ReplaceLaneKind::I32x4+ | ReplaceLaneKind::I64x2 => match src {+ RegImm::Reg(reg) => self.asm.mov_to_vec(reg, dst, lane, size),+ RegImm::Imm(imm) => {+ self.with_scratch::<IntScratch, _>(|masm, scratch| {+ masm.asm.mov_ir(scratch.writable(), imm, imm.size());+ masm.asm.mov_to_vec(scratch.inner(), dst, lane, size);+ });+ }+ },+ ReplaceLaneKind::F32x4 | ReplaceLaneKind::F64x2 => match src {+ RegImm::Reg(reg) => self.asm.vec_mov_element(reg, dst, lane, 0, size),+ RegImm::Imm(imm) => {+ self.with_scratch::<FloatScratch, _>(|masm, scratch| {+ masm.asm.mov_ir(scratch.writable(), imm, imm.size());+ masm.asm+ .vec_mov_element(scratch.inner(), dst, lane, 0, size);+ });+ }+ },+ }+ Ok(())}fn atomic_cas(