[clang] [Clang][RISCV] Record the LMUL and mask ratio in RVV fixed-length vector kinds (PR #237845)

Kito Cheng via cfe-commits cfe-commits at lists.llvm.org
Wed Nov 4 22:34:34 PST 2026


================
@@ -4255,16 +4255,141 @@ enum class VectorKind {
   SveFixedLengthPredicate,
 
   /// is RISC-V RVV fixed-length data vector
-  RVVFixedLengthData,
-
-  /// is RISC-V RVV fixed-length mask vector
-  RVVFixedLengthMask,
-
-  RVVFixedLengthMask_1,
-  RVVFixedLengthMask_2,
-  RVVFixedLengthMask_4
+  RVVFixedLengthData_MF8,
+  RVVFixedLengthData_MF4,
+  RVVFixedLengthData_MF2,
+  RVVFixedLengthData_M1,
+  RVVFixedLengthData_M2,
+  RVVFixedLengthData_M4,
+  RVVFixedLengthData_M8,
+
+  /// is RISC-V RVV fixed-length mask vector of vbool<R>_t; the _<L> kinds
+  /// have only L lanes in a single byte
+  RVVFixedLengthMaskRatio1,
+  RVVFixedLengthMaskRatio1_1,
+  RVVFixedLengthMaskRatio1_2,
+  RVVFixedLengthMaskRatio1_4,
+  RVVFixedLengthMaskRatio2,
+  RVVFixedLengthMaskRatio2_1,
+  RVVFixedLengthMaskRatio2_2,
+  RVVFixedLengthMaskRatio2_4,
+  RVVFixedLengthMaskRatio4,
+  RVVFixedLengthMaskRatio4_1,
+  RVVFixedLengthMaskRatio4_2,
+  RVVFixedLengthMaskRatio4_4,
+  RVVFixedLengthMaskRatio8,
+  RVVFixedLengthMaskRatio8_1,
+  RVVFixedLengthMaskRatio8_2,
+  RVVFixedLengthMaskRatio8_4,
+  RVVFixedLengthMaskRatio16,
+  RVVFixedLengthMaskRatio16_1,
+  RVVFixedLengthMaskRatio16_2,
+  RVVFixedLengthMaskRatio16_4,
+  RVVFixedLengthMaskRatio32,
+  RVVFixedLengthMaskRatio32_1,
+  RVVFixedLengthMaskRatio32_2,
+  RVVFixedLengthMaskRatio32_4,
+  RVVFixedLengthMaskRatio64,
+  RVVFixedLengthMaskRatio64_1,
+  RVVFixedLengthMaskRatio64_2,
+  RVVFixedLengthMaskRatio64_4
 };
 
+// The helpers below rely on the order of the RVV fixed-length kinds:
+// RVVFixedLengthData_MF8 .. _M8 by LMUL, then RVVFixedLengthMaskRatio<R>,
+// <R>_1, <R>_2 and <R>_4 for R = 1 .. 64.
+static_assert(unsigned(VectorKind::RVVFixedLengthData_M1) ==
+                      unsigned(VectorKind::RVVFixedLengthData_MF8) + 3 &&
+                  unsigned(VectorKind::RVVFixedLengthData_M8) ==
+                      unsigned(VectorKind::RVVFixedLengthData_MF8) + 6,
+              "unexpected order of the RVV fixed-length data vector kinds");
+static_assert(unsigned(VectorKind::RVVFixedLengthMaskRatio1_4) ==
+                      unsigned(VectorKind::RVVFixedLengthMaskRatio1) + 3 &&
+                  unsigned(VectorKind::RVVFixedLengthMaskRatio2) ==
+                      unsigned(VectorKind::RVVFixedLengthMaskRatio1) + 4 &&
+                  unsigned(VectorKind::RVVFixedLengthMaskRatio64_4) ==
+                      unsigned(VectorKind::RVVFixedLengthMaskRatio1) + 27,
+              "unexpected order of the RVV fixed-length mask vector kinds");
+
+/// True if \p VK is one of the RVV fixed-length data vector kinds, i.e. a
+/// riscv_rvv_vector_bits typedef of a data (non-mask) RVV type.
+inline bool isRVVFixedLengthDataVectorKind(VectorKind VK) {
+  return VK >= VectorKind::RVVFixedLengthData_MF8 &&
+         VK <= VectorKind::RVVFixedLengthData_M8;
+}
+
+/// Return log2 of the LMUL recorded in an RVV fixed-length data vector kind:
+/// MF8 -> -3, ..., M1 -> 0, ..., M8 -> 3.
+inline int getRVVFixedLengthDataLMulLog2(VectorKind VK) {
+  assert(isRVVFixedLengthDataVectorKind(VK) &&
+         "not an RVV fixed-length data vector kind");
+  return int(VK) - int(VectorKind::RVVFixedLengthData_M1);
+}
+
+/// Inverse of getRVVFixedLengthDataLMulLog2().
+inline VectorKind getRVVFixedLengthDataVectorKind(int LMulLog2) {
+  assert(LMulLog2 >= -3 && LMulLog2 <= 3 &&
+         "LMUL out of range for an RVV type");
+  return VectorKind(int(VectorKind::RVVFixedLengthData_M1) + LMulLog2);
+}
+
+/// True if \p VK is one of the RVV fixed-length mask vector kinds, i.e. a
+/// riscv_rvv_vector_bits typedef of a vbool<R>_t type.
+inline bool isRVVFixedLengthMaskVectorKind(VectorKind VK) {
+  return VK >= VectorKind::RVVFixedLengthMaskRatio1 &&
+         VK <= VectorKind::RVVFixedLengthMaskRatio64_4;
+}
+
+/// Return log2 of the R of the vbool<R>_t type recorded in an RVV fixed-length
+/// mask vector kind: Ratio1 -> 0, Ratio2 -> 1, ..., Ratio64 -> 6.
+inline unsigned getRVVFixedLengthMaskRatioLog2(VectorKind VK) {
+  assert(isRVVFixedLengthMaskVectorKind(VK) &&
+         "not an RVV fixed-length mask vector kind");
+  return (unsigned(VK) - unsigned(VectorKind::RVVFixedLengthMaskRatio1)) / 4;
+}
+
+/// True if \p VK is one of the RVV fixed-length data or mask vector kinds.
+inline bool isRVVFixedLengthVectorKind(VectorKind VK) {
+  return isRVVFixedLengthDataVectorKind(VK) ||
+         isRVVFixedLengthMaskVectorKind(VK);
+}
+
+/// Return the LMUL of an RVV fixed-length data vector kind, "mf8" .. "m8", or
+/// the ratio of a mask vector kind, "1" .. "64".
+inline StringRef getRVVFixedLengthString(VectorKind VK) {
+  if (isRVVFixedLengthDataVectorKind(VK)) {
+    static constexpr const char *LMuls[] = {"mf8", "mf4", "mf2", "m1",
+                                            "m2",  "m4",  "m8"};
+    return LMuls[getRVVFixedLengthDataLMulLog2(VK) + 3];
+  }
+  static constexpr const char *Ratios[] = {"1",  "2",  "4", "8",
+                                           "16", "32", "64"};
+  return Ratios[getRVVFixedLengthMaskRatioLog2(VK)];
+}
+
+/// Return the number of lanes (1, 2 or 4) of an RVV fixed-length mask vector
+/// kind that fits in less than one byte, or 0 if its lanes fill whole bytes.
+inline unsigned getRVVFixedLengthMaskSubByteLanes(VectorKind VK) {
+  assert(isRVVFixedLengthMaskVectorKind(VK) &&
+         "not an RVV fixed-length mask vector kind");
+  unsigned Col =
+      (unsigned(VK) - unsigned(VectorKind::RVVFixedLengthMaskRatio1)) % 4;
+  return Col ? 1u << (Col - 1) : 0;
+}
+
+/// Inverse of getRVVFixedLengthMaskRatioLog2() and
+/// getRVVFixedLengthMaskSubByteLanes().
+inline VectorKind getRVVFixedLengthMaskVectorKind(unsigned RatioLog2,
+                                                  unsigned SubByteLanes) {
+  assert(RatioLog2 < 7 && "ratio out of range for an RVV mask type");
+  assert((SubByteLanes == 0 || SubByteLanes == 1 || SubByteLanes == 2 ||
+          SubByteLanes == 4) &&
+         "unexpected sub-byte lane count");
+  unsigned Col = SubByteLanes == 4 ? 3 : SubByteLanes;
----------------
kito-cheng wrote:

Applied, thanks :)

https://github.com/llvm/llvm-project/pull/237845


More information about the cfe-commits mailing list