riscv64: Add Zvbb (Vector Basic Bit-manipulation) extension support

cranelift/codegen/meta/src/isa/riscv64.rs

@@ -154,6 +154,13 @@ pub(crate) fn define() -> TargetIsa {
         false,
     );
 
+    let _has_zvbb = setting.add_bool(
+        "has_zvbb",
+        "has extension Zvbb?",
+        "Zvbb: Vector Basic Bit-manipulation",
+        false,
+    );
+
     let _has_zicsr = setting.add_bool(
         "has_zicsr",
         "has extension zicsr?",

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

@@ -1039,6 +1039,9 @@
 (decl pure has_zicond () bool)
 (extern constructor has_zicond has_zicond)
 
+(decl pure has_zvbb () bool)
+(extern constructor has_zvbb has_zvbb)
+
 
 ;;;; Type Helpers ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 

cranelift/codegen/src/isa/riscv64/inst/vector.rs

@@ -451,6 +451,10 @@ impl VecAluOpRRR {
             | VecAluOpRRR::VmnandMM => 0b011101,
             VecAluOpRRR::VmsgtuVX | VecAluOpRRR::VmnorMM => 0b011110,
             VecAluOpRRR::VmsgtVX | VecAluOpRRR::VmfgeVF => 0b011111,
+            // Zvbb
+            VecAluOpRRR::VandnVV | VecAluOpRRR::VandnVX => 0b000001,
+            VecAluOpRRR::VrorVV | VecAluOpRRR::VrorVX => 0b010100,
+            VecAluOpRRR::VrolVV | VecAluOpRRR::VrolVX => 0b010101,
         }
     }
 
@@ -480,7 +484,10 @@ impl VecAluOpRRR {
             | VecAluOpRRR::VmsltuVV
             | VecAluOpRRR::VmsltVV
             | VecAluOpRRR::VmsleuVV
-            | VecAluOpRRR::VmsleVV => VecOpCategory::OPIVV,
+            | VecAluOpRRR::VmsleVV
+            | VecAluOpRRR::VandnVV
+            | VecAluOpRRR::VrorVV
+            | VecAluOpRRR::VrolVV => VecOpCategory::OPIVV,
             VecAluOpRRR::VwaddVV
             | VecAluOpRRR::VwaddWV
             | VecAluOpRRR::VwadduVV
@@ -538,7 +545,10 @@ impl VecAluOpRRR {
             | VecAluOpRRR::VmsleuVX
             | VecAluOpRRR::VmsleVX
             | VecAluOpRRR::VmsgtuVX
-            | VecAluOpRRR::VmsgtVX => VecOpCategory::OPIVX,
+            | VecAluOpRRR::VmsgtVX
+            | VecAluOpRRR::VandnVX
+            | VecAluOpRRR::VrorVX
+            | VecAluOpRRR::VrolVX => VecOpCategory::OPIVX,
             VecAluOpRRR::VfaddVV
             | VecAluOpRRR::VfsubVV
             | VecAluOpRRR::VfmulVV
@@ -687,6 +697,8 @@ impl VecAluOpRRImm5 {
             VecAluOpRRImm5::VmsleVI => 0b011101,
             VecAluOpRRImm5::VmsgtuVI => 0b011110,
             VecAluOpRRImm5::VmsgtVI => 0b011111,
+            // Zvbb
+            VecAluOpRRImm5::VrorVI => 0b010100,
         }
     }
 
@@ -714,7 +726,8 @@ impl VecAluOpRRImm5 {
             | VecAluOpRRImm5::VmsleuVI
             | VecAluOpRRImm5::VmsleVI
             | VecAluOpRRImm5::VmsgtuVI
-            | VecAluOpRRImm5::VmsgtVI => VecOpCategory::OPIVI,
+            | VecAluOpRRImm5::VmsgtVI
+            | VecAluOpRRImm5::VrorVI => VecOpCategory::OPIVI,
         }
     }
 
@@ -728,7 +741,8 @@ impl VecAluOpRRImm5 {
             | VecAluOpRRImm5::VrgatherVI
             | VecAluOpRRImm5::VmvrV
             | VecAluOpRRImm5::VnclipWI
-            | VecAluOpRRImm5::VnclipuWI => true,
+            | VecAluOpRRImm5::VnclipuWI
+            | VecAluOpRRImm5::VrorVI => true,
             VecAluOpRRImm5::VaddVI
             | VecAluOpRRImm5::VrsubVI
             | VecAluOpRRImm5::VandVI
@@ -815,6 +829,13 @@ impl VecAluOpRR {
             | VecAluOpRR::VfcvtfxV
             | VecAluOpRR::VfwcvtffV
             | VecAluOpRR::VfncvtffW => 0b010010,
+            // Zvbb
+            VecAluOpRR::VbrevV
+            | VecAluOpRR::Vbrev8V
+            | VecAluOpRR::Vrev8V
+            | VecAluOpRR::VclzV
+            | VecAluOpRR::VctzV
+            | VecAluOpRR::VcpopV => 0b010010,
         }
     }
 
@@ -827,7 +848,13 @@ impl VecAluOpRR {
             | VecAluOpRR::VzextVF8
             | VecAluOpRR::VsextVF2
             | VecAluOpRR::VsextVF4
-            | VecAluOpRR::VsextVF8 => VecOpCategory::OPMVV,
+            | VecAluOpRR::VsextVF8
+            | VecAluOpRR::VbrevV
+            | VecAluOpRR::Vbrev8V
+            | VecAluOpRR::Vrev8V
+            | VecAluOpRR::VclzV
+            | VecAluOpRR::VctzV
+            | VecAluOpRR::VcpopV => VecOpCategory::OPMVV,
             VecAluOpRR::VfmvSF | VecAluOpRR::VfmvVF => VecOpCategory::OPFVF,
             VecAluOpRR::VfmvFS
             | VecAluOpRR::VfsqrtV
@@ -879,6 +906,13 @@ impl VecAluOpRR {
             // These don't have a explicit encoding table, but Section 11.16 Vector Integer Move Instruction states:
             // > The first operand specifier (vs2) must contain v0, and any other vector register number in vs2 is reserved.
             VecAluOpRR::VmvVV | VecAluOpRR::VmvVX | VecAluOpRR::VfmvVF => 0,
+            // Zvbb VXUNARY0
+            VecAluOpRR::Vbrev8V => 0b01000,
+            VecAluOpRR::Vrev8V => 0b01001,
+            VecAluOpRR::VbrevV => 0b01010,
+            VecAluOpRR::VclzV => 0b01100,
+            VecAluOpRR::VctzV => 0b01101,
+            VecAluOpRR::VcpopV => 0b01110,
         }
     }
 
@@ -903,7 +937,13 @@ impl VecAluOpRR {
             | VecAluOpRR::VfcvtfxuV
             | VecAluOpRR::VfcvtfxV
             | VecAluOpRR::VfwcvtffV
-            | VecAluOpRR::VfncvtffW => true,
+            | VecAluOpRR::VfncvtffW
+            | VecAluOpRR::VbrevV
+            | VecAluOpRR::Vbrev8V
+            | VecAluOpRR::Vrev8V
+            | VecAluOpRR::VclzV
+            | VecAluOpRR::VctzV
+            | VecAluOpRR::VcpopV => true,
             VecAluOpRR::VmvSX
             | VecAluOpRR::VfmvSF
             | VecAluOpRR::VmvVV
@@ -933,7 +973,13 @@ impl VecAluOpRR {
             | VecAluOpRR::VfcvtfxuV
             | VecAluOpRR::VfcvtfxV
             | VecAluOpRR::VfwcvtffV
-            | VecAluOpRR::VfncvtffW => RegClass::Vector,
+            | VecAluOpRR::VfncvtffW
+            | VecAluOpRR::VbrevV
+            | VecAluOpRR::Vbrev8V
+            | VecAluOpRR::Vrev8V
+            | VecAluOpRR::VclzV
+            | VecAluOpRR::VctzV
+            | VecAluOpRR::VcpopV => RegClass::Vector,
             VecAluOpRR::VmvXS => RegClass::Int,
             VecAluOpRR::VfmvFS => RegClass::Float,
         }
@@ -958,7 +1004,13 @@ impl VecAluOpRR {
             | VecAluOpRR::VfcvtfxuV
             | VecAluOpRR::VfcvtfxV
             | VecAluOpRR::VfwcvtffV
-            | VecAluOpRR::VfncvtffW => RegClass::Vector,
+            | VecAluOpRR::VfncvtffW
+            | VecAluOpRR::VbrevV
+            | VecAluOpRR::Vbrev8V
+            | VecAluOpRR::Vrev8V
+            | VecAluOpRR::VclzV
+            | VecAluOpRR::VctzV
+            | VecAluOpRR::VcpopV => RegClass::Vector,
             VecAluOpRR::VfmvSF | VecAluOpRR::VfmvVF => RegClass::Float,
             VecAluOpRR::VmvSX | VecAluOpRR::VmvVX => RegClass::Int,
         }
@@ -1006,6 +1058,12 @@ impl fmt::Display for VecAluOpRR {
             VecAluOpRR::VfcvtfxV => "vfcvt.f.x.v",
             VecAluOpRR::VfwcvtffV => "vfwcvt.f.f.v",
             VecAluOpRR::VfncvtffW => "vfncvt.f.f.w",
+            VecAluOpRR::VbrevV => "vbrev.v",
+            VecAluOpRR::Vbrev8V => "vbrev8.v",
+            VecAluOpRR::Vrev8V => "vrev8.v",
+            VecAluOpRR::VclzV => "vclz.v",
+            VecAluOpRR::VctzV => "vctz.v",
+            VecAluOpRR::VcpopV => "vcpop.v",
         })
     }
 }

cranelift/codegen/src/isa/riscv64/inst_vector.isle

@@ -203,6 +203,14 @@
   (VmfleVF)
   (VmfgtVF)
   (VmfgeVF)
+
+  ;; Zvbb: Vector Basic Bit-manipulation
+  (VandnVV)
+  (VandnVX)
+  (VrolVV)
+  (VrolVX)
+  (VrorVV)
+  (VrorVX)
 ))
 
 
@@ -260,6 +268,9 @@
   (VmsleVI)
   (VmsgtuVI)
   (VmsgtVI)
+
+  ;; Zvbb: Vector Basic Bit-manipulation
+  (VrorVI)
 ))
 
 ;; Imm only ALU Ops
@@ -294,6 +305,14 @@
   (VfcvtfxV)
   (VfwcvtffV)
   (VfncvtffW)
+
+  ;; Zvbb: Vector Basic Bit-manipulation
+  (VbrevV)
+  (Vbrev8V)
+  (Vrev8V)
+  (VclzV)
+  (VctzV)
+  (VcpopV)
 ))
 
 ;; Returns the canonical destination type for a VecAluOpRRImm5.
@@ -803,6 +822,60 @@
 (rule (rv_vxor_vi vs2 imm mask vstate)
   (vec_alu_rr_imm5 (VecAluOpRRImm5.VxorVI) vs2 imm mask vstate))
 
+;;;; Zvbb: Vector Basic Bit-manipulation ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(decl rv_vandn_vv (VReg VReg VecOpMasking VState) VReg)
+(rule (rv_vandn_vv vs2 vs1 mask vstate)
+  (vec_alu_rrr (VecAluOpRRR.VandnVV) vs2 vs1 mask vstate))
+
+(decl rv_vandn_vx (VReg XReg VecOpMasking VState) VReg)
+(rule (rv_vandn_vx vs2 vs1 mask vstate)
+  (vec_alu_rrr (VecAluOpRRR.VandnVX) vs2 vs1 mask vstate))
+
+(decl rv_vrol_vv (VReg VReg VecOpMasking VState) VReg)
+(rule (rv_vrol_vv vs2 vs1 mask vstate)
+  (vec_alu_rrr (VecAluOpRRR.VrolVV) vs2 vs1 mask vstate))
+
+(decl rv_vrol_vx (VReg XReg VecOpMasking VState) VReg)
+(rule (rv_vrol_vx vs2 vs1 mask vstate)
+  (vec_alu_rrr (VecAluOpRRR.VrolVX) vs2 vs1 mask vstate))
+
+(decl rv_vror_vv (VReg VReg VecOpMasking VState) VReg)
+(rule (rv_vror_vv vs2 vs1 mask vstate)
+  (vec_alu_rrr (VecAluOpRRR.VrorVV) vs2 vs1 mask vstate))
+
+(decl rv_vror_vx (VReg XReg VecOpMasking VState) VReg)
+(rule (rv_vror_vx vs2 vs1 mask vstate)
+  (vec_alu_rrr (VecAluOpRRR.VrorVX) vs2 vs1 mask vstate))
+
+(decl rv_vror_vi (VReg Imm5 VecOpMasking VState) VReg)
+(rule (rv_vror_vi vs2 imm mask vstate)
+  (vec_alu_rr_imm5 (VecAluOpRRImm5.VrorVI) vs2 imm mask vstate))
+
+(decl rv_vbrev_v (VReg VecOpMasking VState) VReg)
+(rule (rv_vbrev_v vs mask vstate)
+  (vec_alu_rr (VecAluOpRR.VbrevV) vs mask vstate))
+
+(decl rv_vbrev8_v (VReg VecOpMasking VState) VReg)
+(rule (rv_vbrev8_v vs mask vstate)
+  (vec_alu_rr (VecAluOpRR.Vbrev8V) vs mask vstate))
+
+(decl rv_vrev8_v (VReg VecOpMasking VState) VReg)
+(rule (rv_vrev8_v vs mask vstate)
+  (vec_alu_rr (VecAluOpRR.Vrev8V) vs mask vstate))
+
+(decl rv_vclz_v (VReg VecOpMasking VState) VReg)
+(rule (rv_vclz_v vs mask vstate)
+  (vec_alu_rr (VecAluOpRR.VclzV) vs mask vstate))
+
+(decl rv_vctz_v (VReg VecOpMasking VState) VReg)
+(rule (rv_vctz_v vs mask vstate)
+  (vec_alu_rr (VecAluOpRR.VctzV) vs mask vstate))
+
+(decl rv_vcpop_v (VReg VecOpMasking VState) VReg)
+(rule (rv_vcpop_v vs mask vstate)
+  (vec_alu_rr (VecAluOpRR.VcpopV) vs mask vstate))
+
 ;; Helper for emitting the `vssrl.vi` instruction.
 ;;
 ;; vd[i] = (unsigned(vs2[i]) >> imm) + r

cranelift/codegen/src/isa/riscv64/lower.isle

@@ -765,6 +765,25 @@
         (high XReg (rv_andn (value_regs_get x 1) (value_regs_get y 1))))
     (value_regs low high)))
 
+;; Zvbb: band(x, bnot(y)) -> vandn.vv
+(rule 18 (lower (band (ty_supported_vec ty) x (bnot _ y)))
+  (if-let true (has_zvbb))
+  (rv_vandn_vv x y (unmasked) ty))
+
+(rule 19 (lower (band (ty_supported_vec ty) (bnot _ y) x))
+  (if-let true (has_zvbb))
+  (rv_vandn_vv x y (unmasked) ty))
+
+(rule 20 (lower (band (ty_supported_vec ty) x (bnot _ (splat _ y))))
+  (if-let true (has_zvbb))
+  (if (ty_vector_not_float ty))
+  (rv_vandn_vx x y (unmasked) ty))
+
+(rule 21 (lower (band (ty_supported_vec ty) (bnot _ (splat _ y)) x))
+  (if-let true (has_zvbb))
+  (if (ty_vector_not_float ty))
+  (rv_vandn_vx x y (unmasked) ty))
+
 (rule 9 (lower (band (ty_supported_vec ty) x y))
   (rv_vand_vv x y (unmasked) ty))
 
@@ -1107,6 +1126,7 @@
   (rv_rev8 x))
 
 ;;;; Rules for `ctz` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
 (rule (lower (ctz (fits_in_64 ty) x))
   (lower_ctz ty x))
 
@@ -1122,6 +1142,7 @@
     (value_regs result (imm $I64 0))))
 
 ;;;; Rules for `clz` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
 (rule 0 (lower (clz (fits_in_64 ty) x))
   (gen_cltz true x ty))
 
@@ -1249,6 +1270,11 @@
      (result XReg (rv_add low high)))
     (value_regs result (imm $I64 0))))
 
+;; Zvbb: vcpop.v
+(rule 5 (lower (popcnt (ty_supported_vec ty) x))
+  (if-let true (has_zvbb))
+  (rv_vcpop_v x (unmasked) ty))
+
 ;; Popcount using multiply.
 ;; This is popcount64c() from
 ;; http://en.wikipedia.org/wiki/Hamming_weight
@@ -1470,6 +1496,12 @@
 
 ;;;; Rules for `rotl` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
+;; Zvbb: vrol.vx (rotl on vector with scalar amount)
+(rule 5 (lower (rotl (ty_supported_vec ty) x y))
+  (if-let true (has_zvbb))
+  (if (ty_vector_not_float ty))
+  (rv_vrol_vx x y (unmasked) ty))
+
 (rule 0 (lower (rotl (fits_in_64 ty) rs amount))
   (let
     ((rs XReg (zext rs))
@@ -1526,6 +1558,12 @@
 
 ;;;; Rules for `rotr` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
+;; Zvbb: vror.vx (rotr on vector with scalar amount)
+(rule 5 (lower (rotr (ty_supported_vec ty) x y))
+  (if-let true (has_zvbb))
+  (if (ty_vector_not_float ty))
+  (rv_vror_vx x y (unmasked) ty))
+
 (rule (lower (rotr (fits_in_64 ty) rs amount))
   (let
     ((rs XReg (zext rs))

cranelift/codegen/src/isa/riscv64/lower/isle.rs

@@ -525,6 +525,10 @@ impl generated_code::Context for RV64IsleContext<'_, '_, MInst, Riscv64Backend>
         self.backend.isa_flags.has_zicond()
     }
 
+    fn has_zvbb(&mut self) -> bool {
+        self.backend.isa_flags.has_zvbb()
+    }
+
     fn gen_reg_offset_amode(&mut self, base: Reg, offset: i64) -> AMode {
         AMode::RegOffset(base, offset)
     }