x64: convert unpack and interleave instructions to new assembler

cranelift/assembler-x64/meta/src/instructions.rs

@@ -14,6 +14,7 @@ mod or;
 mod shift;
 mod sqrt;
 mod sub;
+mod unpack;
 mod xor;
 
 use crate::dsl::Inst;
@@ -36,5 +37,6 @@ pub fn list() -> Vec<Inst> {
     all.extend(sqrt::list());
     all.extend(sub::list());
     all.extend(xor::list());
+    all.extend(unpack::list());
     all
 }

cranelift/assembler-x64/meta/src/instructions/unpack.rs

@@ -0,0 +1,20 @@
+use crate::dsl::{Feature::*, Inst, Location::*};
+use crate::dsl::{fmt, inst, r, rex, rw};
+
+#[rustfmt::skip] // Keeps instructions on a single line.
+pub fn list() -> Vec<Inst> {
+    vec![
+        // Vector instructions.
+        inst("unpcklps", fmt("A", [rw(xmm1), r(xmm_m128)]), rex([0xF, 0x14]).r(), _64b | compat | sse),
+        inst("unpcklpd", fmt("A", [rw(xmm1), r(xmm_m128)]), rex([0x66, 0x0F, 0x14]).r(), _64b | compat | sse2),
+        inst("unpckhps", fmt("A", [rw(xmm1), r(xmm_m128)]), rex([0xF, 0x15]).r(), _64b | compat | sse),
+        inst("punpckhbw", fmt("A", [rw(xmm1), r(xmm_m128)]), rex([0x66, 0x0F, 0x68]).r(), _64b | compat | sse2),
+        inst("punpckhwd", fmt("A", [rw(xmm1), r(xmm_m128)]), rex([0x66, 0x0F, 0x69]).r(), _64b | compat | sse2),
+        inst("punpckhdq", fmt("A", [rw(xmm1), r(xmm_m128)]), rex([0x66, 0x0F, 0x6A]).r(), _64b | compat | sse2),
+        inst("punpcklwd", fmt("A", [rw(xmm1), r(xmm_m128)]), rex([0x66, 0x0F, 0x61]).r(), _64b | compat | sse2),
+        inst("punpcklqdq", fmt("A", [rw(xmm1), r(xmm_m128)]), rex([0x66, 0x0F, 0x6C]).r(), _64b | compat | sse2),
+        inst("punpcklbw", fmt("A", [rw(xmm1), r(xmm_m128)]), rex([0x66, 0x0F, 0x60]).r(), _64b | compat | sse2),
+        inst("punpckldq", fmt("A", [rw(xmm1), r(xmm_m128)]), rex([0x66, 0x0F, 0x62]).r(), _64b | compat | sse2),
+        inst("punpckhqdq", fmt("A", [rw(xmm1), r(xmm_m128)]), rex([0x66, 0x0F, 0x6D]).r(), _64b | compat | sse2),
+    ]
+}

cranelift/codegen/src/isa/x64/inst.isle

@@ -816,10 +816,6 @@
             Pshufb
             Pshufd
             Ptest
-            Punpckhbw
-            Punpckhwd
-            Punpcklbw
-            Punpcklwd
             Rcpss
             Roundps
             Roundpd
@@ -829,13 +825,6 @@
             Shufps
             Ucomiss
             Ucomisd
-            Unpcklps
-            Unpcklpd
-            Unpckhps
-            Punpckhdq
-            Punpckldq
-            Punpckhqdq
-            Punpcklqdq
             Pshuflw
             Pshufhw
             Pblendw
@@ -3445,71 +3434,71 @@
 ;; Helper for creating `punpckhwd` instructions.
 (decl x64_punpckhwd (Xmm XmmMem) Xmm)
 (rule 0 (x64_punpckhwd src1 src2)
-      (xmm_rm_r (SseOpcode.Punpckhwd) src1 src2))
+      (x64_punpckhwd_a src1 src2))
 (rule 1 (x64_punpckhwd src1 src2)
       (if-let true (use_avx))
       (xmm_rmir_vex (AvxOpcode.Vpunpckhwd) src1 src2))
 
 ;; Helper for creating `punpcklwd` instructions.
 (decl x64_punpcklwd (Xmm XmmMem) Xmm)
 (rule 0 (x64_punpcklwd src1 src2)
-      (xmm_rm_r (SseOpcode.Punpcklwd) src1 src2))
+      (x64_punpcklwd_a src1 src2))
 (rule 1 (x64_punpcklwd src1 src2)
       (if-let true (use_avx))
       (xmm_rmir_vex (AvxOpcode.Vpunpcklwd) src1 src2))
 
 ;; Helper for creating `punpckldq` instructions.
 (decl x64_punpckldq (Xmm XmmMem) Xmm)
 (rule 0 (x64_punpckldq src1 src2)
-      (xmm_rm_r (SseOpcode.Punpckldq) src1 src2))
+      (x64_punpckldq_a src1 src2))
 (rule 1 (x64_punpckldq src1 src2)
       (if-let true (use_avx))
       (xmm_rmir_vex (AvxOpcode.Vpunpckldq) src1 src2))
 
 ;; Helper for creating `punpckhdq` instructions.
 (decl x64_punpckhdq (Xmm XmmMem) Xmm)
 (rule 0 (x64_punpckhdq src1 src2)
-      (xmm_rm_r (SseOpcode.Punpckhdq) src1 src2))
+      (x64_punpckhdq_a src1 src2))
 (rule 1 (x64_punpckhdq src1 src2)
       (if-let true (use_avx))
       (xmm_rmir_vex (AvxOpcode.Vpunpckhdq) src1 src2))
 
 ;; Helper for creating `punpcklqdq` instructions.
 (decl x64_punpcklqdq (Xmm XmmMem) Xmm)
 (rule 0 (x64_punpcklqdq src1 src2)
-      (xmm_rm_r (SseOpcode.Punpcklqdq) src1 src2))
+      (x64_punpcklqdq_a src1 src2))
 (rule 1 (x64_punpcklqdq src1 src2)
       (if-let true (use_avx))
       (xmm_rmir_vex (AvxOpcode.Vpunpcklqdq) src1 src2))
 
 ;; Helper for creating `punpckhqdq` instructions.
 (decl x64_punpckhqdq (Xmm XmmMem) Xmm)
 (rule 0 (x64_punpckhqdq src1 src2)
-      (xmm_rm_r (SseOpcode.Punpckhqdq) src1 src2))
+      (x64_punpckhqdq_a src1 src2))
 (rule 1 (x64_punpckhqdq src1 src2)
       (if-let true (use_avx))
       (xmm_rmir_vex (AvxOpcode.Vpunpckhqdq) src1 src2))
 
 ;; Helper for creating `unpcklps` instructions.
 (decl x64_unpcklps (Xmm XmmMem) Xmm)
 (rule 0 (x64_unpcklps src1 src2)
-      (xmm_rm_r (SseOpcode.Unpcklps) src1 src2))
+      (x64_unpcklps_a src1 src2))
 (rule 1 (x64_unpcklps src1 src2)
       (if-let true (use_avx))
       (xmm_rmir_vex (AvxOpcode.Vunpcklps) src1 src2))
 
 ;; Helper for creating `unpcklpd` instructions.
 (decl x64_unpcklpd (Xmm XmmMem) Xmm)
 (rule 0 (x64_unpcklpd src1 src2)
-      (xmm_rm_r (SseOpcode.Unpcklpd) src1 src2))
+      (x64_unpcklpd_a src1 src2))
 (rule 1 (x64_unpcklpd src1 src2)
       (if-let true (use_avx))
       (xmm_rmir_vex (AvxOpcode.Vunpcklpd) src1 src2))
 
 ;; Helper for creating `unpckhps` instructions.
 (decl x64_unpckhps (Xmm XmmMem) Xmm)
 (rule 0 (x64_unpckhps src1 src2)
-      (xmm_rm_r (SseOpcode.Unpckhps) src1 src2))
+      (x64_unpckhps_a src1 src2))
 (rule 1 (x64_unpckhps src1 src2)
       (if-let true (use_avx))
       (xmm_rmir_vex (AvxOpcode.Vunpckhps) src1 src2))
@@ -3804,15 +3793,15 @@
 ;; Helper for creating `punpcklbw` instructions.
 (decl x64_punpcklbw (Xmm XmmMem) Xmm)
 (rule 0 (x64_punpcklbw src1 src2)
-      (xmm_rm_r (SseOpcode.Punpcklbw) src1 src2))
+      (x64_punpcklbw_a src1 src2))
 (rule 1 (x64_punpcklbw src1 src2)
         (if-let true (use_avx))
         (xmm_rmir_vex (AvxOpcode.Vpunpcklbw) src1 src2))
 
 ;; Helper for creating `punpckhbw` instructions.
 (decl x64_punpckhbw (Xmm XmmMem) Xmm)
 (rule 0 (x64_punpckhbw src1 src2)
-      (xmm_rm_r (SseOpcode.Punpckhbw) src1 src2))
+      (x64_punpckhbw_a src1 src2))
 (rule 1 (x64_punpckhbw src1 src2)
         (if-let true (use_avx))
         (xmm_rmir_vex (AvxOpcode.Vpunpckhbw) src1 src2))

cranelift/codegen/src/isa/x64/inst/args.rs

@@ -886,10 +886,6 @@ pub enum SseOpcode {
     Pshufb,
     Pshufd,
     Ptest,
-    Punpckhbw,
-    Punpckhwd,
-    Punpcklbw,
-    Punpcklwd,
     Rcpss,
     Roundps,
     Roundpd,
@@ -899,13 +895,6 @@ pub enum SseOpcode {
     Shufps,
     Ucomiss,
     Ucomisd,
-    Unpcklps,
-    Unpcklpd,
-    Unpckhps,
-    Punpckhdq,
-    Punpckldq,
-    Punpckhqdq,
-    Punpcklqdq,
     Pshuflw,
     Pshufhw,
     Pblendw,
@@ -929,9 +918,7 @@ impl SseOpcode {
             | SseOpcode::Rcpss
             | SseOpcode::Rsqrtss
             | SseOpcode::Shufps
-            | SseOpcode::Ucomiss
-            | SseOpcode::Unpcklps
-            | SseOpcode::Unpckhps => SSE,
+            | SseOpcode::Ucomiss => SSE,
 
             SseOpcode::Cmppd
             | SseOpcode::Cmpsd
@@ -960,18 +947,9 @@ impl SseOpcode {
             | SseOpcode::Pmullw
             | SseOpcode::Pmuludq
             | SseOpcode::Pshufd
-            | SseOpcode::Punpckhbw
-            | SseOpcode::Punpckhwd
-            | SseOpcode::Punpcklbw
-            | SseOpcode::Punpcklwd
             | SseOpcode::Ucomisd
-            | SseOpcode::Punpckldq
-            | SseOpcode::Punpckhdq
-            | SseOpcode::Punpcklqdq
-            | SseOpcode::Punpckhqdq
             | SseOpcode::Pshuflw
-            | SseOpcode::Pshufhw
-            | SseOpcode::Unpcklpd => SSE2,
+            | SseOpcode::Pshufhw => SSE2,
 
             SseOpcode::Pabsb
             | SseOpcode::Pabsw
@@ -1109,10 +1087,6 @@ impl fmt::Debug for SseOpcode {
             SseOpcode::Pshufb => "pshufb",
             SseOpcode::Pshufd => "pshufd",
             SseOpcode::Ptest => "ptest",
-            SseOpcode::Punpckhbw => "punpckhbw",
-            SseOpcode::Punpckhwd => "punpckhwd",
-            SseOpcode::Punpcklbw => "punpcklbw",
-            SseOpcode::Punpcklwd => "punpcklwd",
             SseOpcode::Rcpss => "rcpss",
             SseOpcode::Roundps => "roundps",
             SseOpcode::Roundpd => "roundpd",
@@ -1122,17 +1096,10 @@ impl fmt::Debug for SseOpcode {
             SseOpcode::Shufps => "shufps",
             SseOpcode::Ucomiss => "ucomiss",
             SseOpcode::Ucomisd => "ucomisd",
-            SseOpcode::Unpcklps => "unpcklps",
-            SseOpcode::Unpckhps => "unpckhps",
-            SseOpcode::Punpckldq => "punpckldq",
-            SseOpcode::Punpckhdq => "punpckhdq",
-            SseOpcode::Punpcklqdq => "punpcklqdq",
-            SseOpcode::Punpckhqdq => "punpckhqdq",
             SseOpcode::Pshuflw => "pshuflw",
             SseOpcode::Pshufhw => "pshufhw",
             SseOpcode::Pblendw => "pblendw",
             SseOpcode::Movddup => "movddup",
-            SseOpcode::Unpcklpd => "unpcklpd",
         };
         write!(fmt, "{name}")
     }

cranelift/codegen/src/isa/x64/inst/emit.rs

@@ -1779,18 +1779,7 @@ pub(crate) fn emit(
                 SseOpcode::Pmullw => (LegacyPrefixes::_66, 0x0FD5, 2),
                 SseOpcode::Pmuludq => (LegacyPrefixes::_66, 0x0FF4, 2),
                 SseOpcode::Pshufb => (LegacyPrefixes::_66, 0x0F3800, 3),
-                SseOpcode::Punpckhbw => (LegacyPrefixes::_66, 0x0F68, 2),
-                SseOpcode::Punpckhwd => (LegacyPrefixes::_66, 0x0F69, 2),
-                SseOpcode::Punpcklbw => (LegacyPrefixes::_66, 0x0F60, 2),
-                SseOpcode::Punpcklwd => (LegacyPrefixes::_66, 0x0F61, 2),
-                SseOpcode::Punpckldq => (LegacyPrefixes::_66, 0x0F62, 2),
-                SseOpcode::Punpcklqdq => (LegacyPrefixes::_66, 0x0F6C, 2),
-                SseOpcode::Punpckhdq => (LegacyPrefixes::_66, 0x0F6A, 2),
-                SseOpcode::Punpckhqdq => (LegacyPrefixes::_66, 0x0F6D, 2),
-                SseOpcode::Unpcklps => (LegacyPrefixes::None, 0x0F14, 2),
-                SseOpcode::Unpckhps => (LegacyPrefixes::None, 0x0F15, 2),
                 SseOpcode::Movss => (LegacyPrefixes::_F3, 0x0F10, 2),
-                SseOpcode::Unpcklpd => (LegacyPrefixes::_66, 0x0F14, 2),
                 _ => unimplemented!("Opcode {:?} not implemented", op),
             };
 

cranelift/codegen/src/isa/x64/inst/emit_tests.rs

@@ -2791,36 +2791,6 @@ fn test_x64_emit() {
         "packuswb %xmm4, %xmm9, %xmm4",
     ));
 
-    insns.push((
-        Inst::xmm_rm_r(SseOpcode::Punpckhbw, RegMem::reg(xmm3), w_xmm2),
-        "660F68D3",
-        "punpckhbw %xmm2, %xmm3, %xmm2",
-    ));
-
-    insns.push((
-        Inst::xmm_rm_r(SseOpcode::Punpckhwd, RegMem::reg(xmm13), w_xmm2),
-        "66410F69D5",
-        "punpckhwd %xmm2, %xmm13, %xmm2",
-    ));
-
-    insns.push((
-        Inst::xmm_rm_r(SseOpcode::Punpcklbw, RegMem::reg(xmm1), w_xmm8),
-        "66440F60C1",
-        "punpcklbw %xmm8, %xmm1, %xmm8",
-    ));
-
-    insns.push((
-        Inst::xmm_rm_r(SseOpcode::Punpcklwd, RegMem::reg(xmm11), w_xmm8),
-        "66450F61C3",
-        "punpcklwd %xmm8, %xmm11, %xmm8",
-    ));
-
-    insns.push((
-        Inst::xmm_rm_r(SseOpcode::Unpcklps, RegMem::reg(xmm11), w_xmm2),
-        "410F14D3",
-        "unpcklps %xmm2, %xmm11, %xmm2",
-    ));
-
     // ========================================================
     // XMM_RM_R: Integer Conversion
 

cranelift/filetests/filetests/isa/x64/bitcast.clif

@@ -194,7 +194,7 @@ block0(v0: i128):
 ; block0:
 ;   movq %rdi, %xmm0
 ;   movq %rsi, %xmm5
-;   punpcklqdq %xmm0, %xmm5, %xmm0
+;   punpcklqdq %xmm5, %xmm0
 ;   movq    %rbp, %rsp
 ;   popq    %rbp
 ;   ret
@@ -252,7 +252,7 @@ block0(v0: i128):
 ; block0:
 ;   movq %rdi, %xmm0
 ;   movq %rsi, %xmm5
-;   punpcklqdq %xmm0, %xmm5, %xmm0
+;   punpcklqdq %xmm5, %xmm0
 ;   movq    %rbp, %rsp
 ;   popq    %rbp
 ;   ret

cranelift/filetests/filetests/isa/x64/fcvt.clif

@@ -338,7 +338,7 @@ block0(v0: i32x4):
 ;   pushq   %rbp
 ;   movq    %rsp, %rbp
 ; block0:
-;   unpcklps %xmm0, const(0), %xmm0
+;   unpcklps (%rip), %xmm0
 ;   subpd (%rip), %xmm0
 ;   movq    %rbp, %rsp
 ;   popq    %rbp
@@ -1215,7 +1215,7 @@ block0(v0: i64x2):
 ;   pshufd  $238, %xmm6, %xmm2
 ;   movq %xmm2, %rcx
 ;   cvtsi2sdq %rcx, %xmm1
-;   unpcklpd %xmm0, %xmm1, %xmm0
+;   unpcklpd %xmm1, %xmm0
 ;   movq    %rbp, %rsp
 ;   popq    %rbp
 ;   ret