[RISCV][NFC] Refactor RISC-V vector intrinsic utils.

[kito-cheng]

Summary

This patch is preparation for D111617, use class/struct/enum rather than char/StringRef to present internal information as possible, that provide more compact way to store those info and also easier to serialize/deserialize.

And also that improve readability of the code, e.g. "v" vs TypeProfile::Vector.

[kito-cheng]

Changes:

• Extract more utils functions to RISCVVIntrinsicUtils

[khchen]

Thanks for refactoring!

clang/include/clang/Support/RISCVVIntrinsicUtils.h

55

I think vector is not a primitive type in common sense, is it?
why Widening2XVector, Widening4XVector, Widening8XVector and MaskVector is not part of VectorTypeModifier?

Sorry, I'm confused and maybe forget something.

85

I think we need to update the comment in riscv_vector.td to sync the word "TypeProfile", I feel the new word TypeProfile is similar to modifier or prototype, is it?

The C/C++ prototype of the builtin is defined by the Prototype attribute.
Prototype is a non-empty sequence of type transformers, the first of which
is the return type of the builtin and the rest are the parameters of the
builtin, in order. For instance if Prototype is "wvv" and TypeRange is "si"
a first builtin will have type

we call it modifier or prototype is because those words are coming from clang intrinsic definition and other target.

https://github.com/llvm/llvm-project/blob/main/clang/include/clang/Basic/Builtins.def#L52
https://github.com/llvm/llvm-project/blob/main/clang/include/clang/Basic/arm_sve.td#L58

personally I think consistent naming maybe better than creating a new word, what do you think?

BTW, I think having this new class is really good idea for refactoring!

90

If we allow parameter could uint8_t, why other constructors not follow the same rule?

97

What's purpose of this function, translate TypeProfile to the Proto string?

256

additional space

clang/lib/Support/RISCVVIntrinsicUtils.cpp

874

In riscv_vector.td is said smaller or larger, I feel little confusing here when it call LagerThan. maybe have more comment like The result of modified type should be smaller than giving type ?

[kito-cheng]

Changes:

• Address @khchen's comment.
• Use new hash scheme for cache the result of computeType.

clang/include/clang/Support/RISCVVIntrinsicUtils.h

55

I think vector is not a primitive type in common sense, is it?

It's called primitive type transformer on the comment[1], so that's why I use PrimitiveType here, but I admit that's kind of confusing, maybe BaseTypeModifier?

Widening2XVector, Widening4XVector, Widening8XVector and MaskVector is not part of VectorTypeModifier?

Good point, Moved to VectorTypeModifier!

[1] https://github.com/llvm/llvm-project/blob/main/clang/lib/Support/RISCVVIntrinsicUtils.cpp#L366

85

Renamed to PrototypeDescriptor, that should be better I guess :)

90

Keep only two version of constructor, one for all uint8_t and one for all enum.

All enum one used for checking type safe as possilbe.
And uint8_t version used for low-level construct (used in https://reviews.llvm.org/D111617)

97

Used for caching the RVVType, but I realized we could use integer(uint64_t) as hash value, use new hash scheme in new version.

[khchen]

Thanks Kito. This all LGTM except some warnings need to fix.

clang/lib/Support/RISCVVIntrinsicUtils.cpp

376–377

so we also need to update this comment as base type transformer?

720

Don’t use default labels in fully covered switches over enumerations
please remove default in RISCVVIntrinsicUtils.cpp:624, RISCVVIntrinsicUtils.cpp:717 and RISCVVIntrinsicUtils.cpp:793.

960

clang/lib/Support/RISCVVIntrinsicUtils.cpp:962:10: warning: moving a local object in a return statement prevents copy elision [-Wpessimizing-move]
  return std::move(PrototypeDescriptors);
         ^
clang/lib/Support/RISCVVIntrinsicUtils.cpp:962:10: note: remove std::move call here
  return std::move(PrototypeDescriptors);

[kadircet]

clang/lib/Support/RISCVVIntrinsicUtils.cpp

35

these were previously owned by RVVEmitter, hence we would have one instance per invocation. After this move, and the follow up patch that introduced lazy lookup, now we actually have a race condition in tools that can perform concurrent AST builds (e.g. any tool, like clang-tidy, that might have multiple Semas alive because they're being executed with all-TUs executor, or clangd when the user opens multiple files).

Rather than having these caches as global singletons (or static local variables as things have evolved since this patch), can we:

• make them owned by RISCVIntrinsicManagerImpl (while getting rid of the cache for TableGen purposes completely, isn't it already generating the full header, why does it need a cache?)? that way we would get one instance per Sema and prevent above mentioned race conditions
• add some locks to synchronise access to these caches.

This has been triggering crashes in clangd for a long while now (tracking it back to this issue wasn't easy, sorry for the delay)

[kadircet]

Hi @kito-cheng, can you please let us know if you're working on a fix here (and whether it seems to be close)? otherwise i am planning to revert this and consequent changes, as it's clearly introducing data races.

[kadircet]

In D124730#3916786, @kadircet wrote:

Hi @kito-cheng, can you please let us know if you're working on a fix here (and whether it seems to be close)? otherwise i am planning to revert this and consequent changes, as it's clearly introducing data races.

FYI, dropping all the caching and pass-by-pointer logic in https://reviews.llvm.org/D138287

[kito-cheng]

@kadircet ooops, sorry for missing your comment, let me figure out how to fix that.

[kadircet]

thanks Kito! not sure if you've noticed D138287, but if landing a solution
is going to take a long while here, i'd like to move forward with that
approach to make sure this doesn't stay in a broken state. so it'd be great
if you can give some updates/estimates about fixing this soon.

[kito-cheng]

@kadircet Proposed fix: D138429

clang/include/clang/Support/RISCVVIntrinsicUtils.h

 //===--- RISCVVIntrinsicUtils.h - RISC-V Vector Intrinsic Utils -*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef CLANG_SUPPORT_RISCVVINTRINSICUTILS_H
 #define CLANG_SUPPORT_RISCVVINTRINSICUTILS_H
 
+#include "llvm/ADT/ArrayRef.h"
+#include "llvm/ADT/BitmaskEnum.h"
 #include "llvm/ADT/Optional.h"
+#include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringRef.h"
 #include <cstdint>
 #include <string>
 #include <vector>
 
 namespace clang {
 namespace RISCV {
 
-using BasicType = char;
 using VScaleVal = llvm::Optional<unsigned>;
 
-// Exponential LMUL
-struct LMULType {
-  int Log2LMUL;
-  LMULType(int Log2LMUL);
-  // Return the C/C++ string representation of LMUL
-  std::string str() const;
-  llvm::Optional<unsigned> getScale(unsigned ElementBitwidth) const;
-  void MulLog2LMUL(int Log2LMUL);
-  LMULType &operator*=(uint32_t RHS);
+// Modifier for vector type.
+enum class VectorTypeModifier : uint8_t {
+  NoModifier,
+  Widening2XVector,
+  Widening4XVector,
+  Widening8XVector,
+  MaskVector,
+  Log2EEW3,
+  Log2EEW4,
+  Log2EEW5,
+  Log2EEW6,
+  FixedSEW8,
+  FixedSEW16,
+  FixedSEW32,
+  FixedSEW64,
+  LFixedLog2LMULN3,
+  LFixedLog2LMULN2,
+  LFixedLog2LMULN1,
+  LFixedLog2LMUL0,
+  LFixedLog2LMUL1,
+  LFixedLog2LMUL2,
+  LFixedLog2LMUL3,
+  SFixedLog2LMULN3,
+  SFixedLog2LMULN2,
+  SFixedLog2LMULN1,
+  SFixedLog2LMUL0,
+  SFixedLog2LMUL1,
+  SFixedLog2LMUL2,
+  SFixedLog2LMUL3,
 };
 
-// This class is compact representation of a valid and invalid RVVType.
-class RVVType {
-  enum ScalarTypeKind : uint32_t {
-    Void,
-    Size_t,
-    Ptrdiff_t,
-    UnsignedLong,
-    SignedLong,
-    Boolean,
-    SignedInteger,
-    UnsignedInteger,
-    Float,
-    Invalid,
-  };
+// Similar to basic type but used to describe what's kind of type related to
+// basic vector type, used to compute type info of arguments.
+enum class BaseTypeModifier : uint8_t {
+  Invalid,
+  Scalar,
+  Vector,
+  Void,
+  SizeT,
+  Ptrdiff,
+  UnsignedLong,
+  SignedLong,
+};
+
+// Modifier for type, used for both scalar and vector types.
+enum class TypeModifier : uint8_t {
+  NoModifier = 0,
+  Pointer = 1 << 0,
+  Const = 1 << 1,
+  Immediate = 1 << 2,
+  UnsignedInteger = 1 << 3,
+  SignedInteger = 1 << 4,
+  Float = 1 << 5,
+  // LMUL1 should be kind of VectorTypeModifier, but that might come with
+  // Widening2XVector for widening reduction.
+  // However that might require VectorTypeModifier become bitmask rather than
+  // simple enum, so we decide keek LMUL1 in TypeModifier for code size
+  // optimization of clang binary size.
+  LMUL1 = 1 << 6,
+  MaxOffset = 6,
+  LLVM_MARK_AS_BITMASK_ENUM(LMUL1),
+};
+
+// PrototypeDescriptor is used to compute type info of arguments or return
+// value.
+struct PrototypeDescriptor {
+  constexpr PrototypeDescriptor() = default;
+  constexpr PrototypeDescriptor(
+      BaseTypeModifier PT,
+      VectorTypeModifier VTM = VectorTypeModifier::NoModifier,
+      TypeModifier TM = TypeModifier::NoModifier)
+      : PT(static_cast<uint8_t>(PT)), VTM(static_cast<uint8_t>(VTM)),
+        TM(static_cast<uint8_t>(TM)) {}
+  constexpr PrototypeDescriptor(uint8_t PT, uint8_t VTM, uint8_t TM)
+      : PT(PT), VTM(VTM), TM(TM) {}
+
+  uint8_t PT = static_cast<uint8_t>(BaseTypeModifier::Invalid);
+  uint8_t VTM = static_cast<uint8_t>(VectorTypeModifier::NoModifier);
+  uint8_t TM = static_cast<uint8_t>(TypeModifier::NoModifier);
+
+  bool operator!=(const PrototypeDescriptor &PD) const {
+    return PD.PT != PT || PD.VTM != VTM || PD.TM != TM;
+  }
+  bool operator>(const PrototypeDescriptor &PD) const {
+    return !(PD.PT <= PT && PD.VTM <= VTM && PD.TM <= TM);
+  }
+
+  static const PrototypeDescriptor Mask;
+  static const PrototypeDescriptor Vector;
+  static const PrototypeDescriptor VL;
+  static llvm::Optional<PrototypeDescriptor>
+  parsePrototypeDescriptor(llvm::StringRef PrototypeStr);
+};
+
+llvm::SmallVector<PrototypeDescriptor>
+parsePrototypes(llvm::StringRef Prototypes);
+
+// Basic type of vector type.
+enum class BasicType : uint8_t {
+  Unknown = 0,
+  Int8 = 1 << 0,
+  Int16 = 1 << 1,
+  Int32 = 1 << 2,
+  Int64 = 1 << 3,
+  Float16 = 1 << 4,
+  Float32 = 1 << 5,
+  Float64 = 1 << 6,
+  MaxOffset = 6,
+  LLVM_MARK_AS_BITMASK_ENUM(Float64),
+};
+
+// Type of vector type.
+enum ScalarTypeKind : uint8_t {
+
+// Exponential LMUL
+struct LMULType {
+  int Log2LMUL;
+  LMULType(int Log2LMUL);
+  // Return the C/C++ string representation of LMUL
+  std::string str() const;
+  llvm::Optional<unsigned> getScale(unsigned ElementBitwidth) const;
+  void MulLog2LMUL(int Log2LMUL);
+  LMULType &operator*=(uint32_t RHS);
+};
+
+class RVVType;
+using RVVTypePtr = RVVType *;
+using RVVTypes = std::vector<RVVTypePtr>;
+
+// This class is compact representation of a valid and invalid RVVType.
+class RVVType {
   BasicType BT;
   ScalarTypeKind ScalarType = Invalid;
   LMULType LMUL;
   bool IsPointer = false;
   // IsConstant indices are "int", but have the constant expression.
   bool IsImmediate = false;
   // Const qualifier for pointer to const object or object of const type.
   bool IsConstant = false;
   unsigned ElementBitwidth = 0;
   VScaleVal Scale = 0;
   bool Valid;
 
   std::string BuiltinStr;
   std::string ClangBuiltinStr;
   std::string Str;
   std::string ShortStr;
 
+  enum class FixedLMULType { LargerThan, SmallerThan };
+
 public:
-  RVVType() : RVVType(BasicType(), 0, llvm::StringRef()) {}
-  RVVType(BasicType BT, int Log2LMUL, llvm::StringRef prototype);
+  RVVType() : BT(BasicType::Unknown), LMUL(0), Valid(false) {}
+  RVVType(BasicType BT, int Log2LMUL, const PrototypeDescriptor &Profile);
 
   // Return the string representation of a type, which is an encoded string for
   // passing to the BUILTIN() macro in Builtins.def.
   const std::string &getBuiltinStr() const { return BuiltinStr; }
 
   // Return the clang builtin type for RVV vector type which are used in the
   // riscv_vector.h header file.
   const std::string &getClangBuiltinStr() const { return ClangBuiltinStr; }
private:
   // Verify RVV vector type and set Valid.
   bool verifyType() const;
 
   // Creates a type based on basic types of TypeRange
   void applyBasicType();
 
   // Applies a prototype modifier to the current type. The result maybe an
   // invalid type.
-  void applyModifier(llvm::StringRef prototype);
+  void applyModifier(const PrototypeDescriptor &prototype);
+
+  void applyLog2EEW(unsigned Log2EEW);
+  void applyFixedSEW(unsigned NewSEW);
+  void applyFixedLog2LMUL(int Log2LMUL, enum FixedLMULType Type);
 
   // Compute and record a string for legal type.
   void initBuiltinStr();
   // Compute and record a builtin RVV vector type string.
   void initClangBuiltinStr();
   // Compute and record a type string for used in the header.
   void initTypeStr();
   // Compute and record a short name of a type for C/C++ name suffix.
   void initShortStr();
+
+public:
+  /// Compute output and input types by applying different config (basic type
+  /// and LMUL with type transformers). It also record result of type in legal
+  /// or illegal set to avoid compute the same config again. The result maybe
+  /// have illegal RVVType.
+  static llvm::Optional<RVVTypes>
+  computeTypes(BasicType BT, int Log2LMUL, unsigned NF,
+               llvm::ArrayRef<PrototypeDescriptor> PrototypeSeq);
+  static llvm::Optional<RVVTypePtr> computeType(BasicType BT, int Log2LMUL,
+                                                PrototypeDescriptor Proto);
 };
 
-using RVVTypePtr = RVVType *;
-using RVVTypes = std::vector<RVVTypePtr>;
 using RISCVPredefinedMacroT = uint8_t;
 
 enum RISCVPredefinedMacro : RISCVPredefinedMacroT {
   Basic = 0,
   V = 1 << 1,
   Zvfh = 1 << 2,
   RV64 = 1 << 3,
   VectorMaxELen64 = 1 << 4,
public:
   }
   unsigned getNF() const { return NF; }
   const std::vector<int64_t> &getIntrinsicTypes() const {
     return IntrinsicTypes;
   }
 
   // Return the type string for a BUILTIN() macro in Builtins.def.
   std::string getBuiltinTypeStr() const;
+
+  static std::string getSuffixStr(
+      BasicType Type, int Log2LMUL,
+      const llvm::SmallVector<PrototypeDescriptor> &PrototypeDescriptors);
 };
 
 } // end namespace RISCV
 
 } // end namespace clang
 
 #endif // CLANG_SUPPORT_RISCVVINTRINSICUTILS_H

clang/lib/Support/RISCVVIntrinsicUtils.cpp

 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/SmallSet.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/ADT/StringMap.h"
 #include "llvm/ADT/StringSet.h"
 #include "llvm/ADT/Twine.h"
 #include "llvm/Support/raw_ostream.h"
 #include <numeric>
+#include <set>
+#include <unordered_map>
 
 using namespace llvm;
 
 namespace clang {
 namespace RISCV {
 
+const PrototypeDescriptor PrototypeDescriptor::Mask = PrototypeDescriptor(
+    BaseTypeModifier::Vector, VectorTypeModifier::MaskVector);
+const PrototypeDescriptor PrototypeDescriptor::VL =
+    PrototypeDescriptor(BaseTypeModifier::SizeT);
+const PrototypeDescriptor PrototypeDescriptor::Vector =
+    PrototypeDescriptor(BaseTypeModifier::Vector);
+
+// Concat BasicType, LMUL and Proto as key
+static std::unordered_map<uint64_t, RVVType> LegalTypes;
+static std::set<uint64_t> IllegalTypes;
+
 //===----------------------------------------------------------------------===//
 // Type implementation
 //===----------------------------------------------------------------------===//
 
 LMULType::LMULType(int NewLog2LMUL) {
   // Check Log2LMUL is -3, -2, -1, 0, 1, 2, 3
   assert(NewLog2LMUL <= 3 && NewLog2LMUL >= -3 && "Bad LMUL number!");
   Log2LMUL = NewLog2LMUL;

 void LMULType::MulLog2LMUL(int log2LMUL) { Log2LMUL += log2LMUL; }
 
 LMULType &LMULType::operator*=(uint32_t RHS) {
   assert(isPowerOf2_32(RHS));
   this->Log2LMUL = this->Log2LMUL + Log2_32(RHS);
   return *this;
 }
 
-RVVType::RVVType(BasicType BT, int Log2LMUL, StringRef prototype)
+RVVType::RVVType(BasicType BT, int Log2LMUL,
+                 const PrototypeDescriptor &prototype)
     : BT(BT), LMUL(LMULType(Log2LMUL)) {
   applyBasicType();
   applyModifier(prototype);
   Valid = verifyType();
   if (Valid) {
     initBuiltinStr();
     initTypeStr();
     if (isVector()) {
default:
     llvm_unreachable("Unhandled case!");
   }
   if (isVector())
     ShortStr += LMUL.str();
 }
 
 void RVVType::applyBasicType() {
   switch (BT) {
-  case 'c':
+  case BasicType::Int8:
     ElementBitwidth = 8;
     ScalarType = ScalarTypeKind::SignedInteger;
     break;
-  case 's':
+  case BasicType::Int16:
     ElementBitwidth = 16;
     ScalarType = ScalarTypeKind::SignedInteger;
     break;
-  case 'i':
+  case BasicType::Int32:
     ElementBitwidth = 32;
     ScalarType = ScalarTypeKind::SignedInteger;
     break;
-  case 'l':
+  case BasicType::Int64:
     ElementBitwidth = 64;
     ScalarType = ScalarTypeKind::SignedInteger;
     break;
-  case 'x':
+  case BasicType::Float16:
     ElementBitwidth = 16;
     ScalarType = ScalarTypeKind::Float;
     break;
-  case 'f':
+  case BasicType::Float32:
     ElementBitwidth = 32;
     ScalarType = ScalarTypeKind::Float;
     break;
-  case 'd':
+  case BasicType::Float64:
     ElementBitwidth = 64;
     ScalarType = ScalarTypeKind::Float;
     break;
   default:
     llvm_unreachable("Unhandled type code!");
   }
   assert(ElementBitwidth != 0 && "Bad element bitwidth!");
 }
 
-void RVVType::applyModifier(StringRef Transformer) {
-  if (Transformer.empty())
-    return;
-  // Handle primitive type transformer
-  auto PType = Transformer.back();
+Optional<PrototypeDescriptor> PrototypeDescriptor::parsePrototypeDescriptor(
+    llvm::StringRef PrototypeDescriptorStr) {
+  PrototypeDescriptor PD;
+  BaseTypeModifier PT = BaseTypeModifier::Invalid;
+  VectorTypeModifier VTM = VectorTypeModifier::NoModifier;
+
+  if (PrototypeDescriptorStr.empty())
+    return PD;
+
+  // Handle base type modifier
+  auto PType = PrototypeDescriptorStr.back();
   switch (PType) {
   case 'e':
-    Scale = 0;
+    PT = BaseTypeModifier::Scalar;
     break;
   case 'v':
-    Scale = LMUL.getScale(ElementBitwidth);
+    PT = BaseTypeModifier::Vector;
     break;
   case 'w':
-    ElementBitwidth *= 2;
-    LMUL *= 2;
-    Scale = LMUL.getScale(ElementBitwidth);
+    PT = BaseTypeModifier::Vector;
+    VTM = VectorTypeModifier::Widening2XVector;
     break;
   case 'q':
-    ElementBitwidth *= 4;
-    LMUL *= 4;
-    Scale = LMUL.getScale(ElementBitwidth);
+    PT = BaseTypeModifier::Vector;
+    VTM = VectorTypeModifier::Widening4XVector;
     break;
   case 'o':
-    ElementBitwidth *= 8;
-    LMUL *= 8;
-    Scale = LMUL.getScale(ElementBitwidth);
+    PT = BaseTypeModifier::Vector;
+    VTM = VectorTypeModifier::Widening8XVector;
     break;
   case 'm':
-    ScalarType = ScalarTypeKind::Boolean;
-    Scale = LMUL.getScale(ElementBitwidth);
-    ElementBitwidth = 1;
+    PT = BaseTypeModifier::Vector;
+    VTM = VectorTypeModifier::MaskVector;
     break;
   case '0':
-    ScalarType = ScalarTypeKind::Void;
+    PT = BaseTypeModifier::Void;
     break;
   case 'z':
-    ScalarType = ScalarTypeKind::Size_t;
+    PT = BaseTypeModifier::SizeT;
     break;
   case 't':
-    ScalarType = ScalarTypeKind::Ptrdiff_t;
+    PT = BaseTypeModifier::Ptrdiff;
     break;
   case 'u':
-    ScalarType = ScalarTypeKind::UnsignedLong;
+    PT = BaseTypeModifier::UnsignedLong;
     break;
   case 'l':
-    ScalarType = ScalarTypeKind::SignedLong;
+    PT = BaseTypeModifier::SignedLong;
     break;
   default:
     llvm_unreachable("Illegal primitive type transformers!");
   }
-  Transformer = Transformer.drop_back();
+  PD.PT = static_cast<uint8_t>(PT);
+  PrototypeDescriptorStr = PrototypeDescriptorStr.drop_back();
 
-  // Extract and compute complex type transformer. It can only appear one time.
-  if (Transformer.startswith("(")) {
-    size_t Idx = Transformer.find(')');
+  // Compute the vector type transformers, it can only appear one time.
+  if (PrototypeDescriptorStr.startswith("(")) {
+    assert(VTM == VectorTypeModifier::NoModifier &&
+           "VectorTypeModifier should only have one modifier");
+    size_t Idx = PrototypeDescriptorStr.find(')');
     assert(Idx != StringRef::npos);
-    StringRef ComplexType = Transformer.slice(1, Idx);
-    Transformer = Transformer.drop_front(Idx + 1);
-    assert(!Transformer.contains('(') &&
-           "Only allow one complex type transformer");
+    StringRef ComplexType = PrototypeDescriptorStr.slice(1, Idx);
+    PrototypeDescriptorStr = PrototypeDescriptorStr.drop_front(Idx + 1);
+    assert(!PrototypeDescriptorStr.contains('(') &&
+           "Only allow one vector type modifier");
 
-    auto UpdateAndCheckComplexProto = [&]() {
-      Scale = LMUL.getScale(ElementBitwidth);
-      const StringRef VectorPrototypes("vwqom");
-      if (!VectorPrototypes.contains(PType))
-        llvm_unreachable("Complex type transformer only supports vector type!");
-      if (Transformer.find_first_of("PCKWS") != StringRef::npos)
-        llvm_unreachable(
-            "Illegal type transformer for Complex type transformer");
-    };
-    auto ComputeFixedLog2LMUL =
-        [&](StringRef Value,
-            std::function<bool(const int32_t &, const int32_t &)> Compare) {
-          int32_t Log2LMUL;
-          Value.getAsInteger(10, Log2LMUL);
-          if (!Compare(Log2LMUL, LMUL.Log2LMUL)) {
-            ScalarType = Invalid;
-            return false;
-          }
-          // Update new LMUL
-          LMUL = LMULType(Log2LMUL);
-          UpdateAndCheckComplexProto();
-          return true;
-        };
     auto ComplexTT = ComplexType.split(":");
     if (ComplexTT.first == "Log2EEW") {
       uint32_t Log2EEW;
-      ComplexTT.second.getAsInteger(10, Log2EEW);
-      // update new elmul = (eew/sew) * lmul
-      LMUL.MulLog2LMUL(Log2EEW - Log2_32(ElementBitwidth));
-      // update new eew
-      ElementBitwidth = 1 << Log2EEW;
-      ScalarType = ScalarTypeKind::SignedInteger;
-      UpdateAndCheckComplexProto();
+      if (ComplexTT.second.getAsInteger(10, Log2EEW)) {
+        llvm_unreachable("Invalid Log2EEW value!");
+        return None;
+      }
+      switch (Log2EEW) {
+      case 3:
+        VTM = VectorTypeModifier::Log2EEW3;
+        break;
+      case 4:
+        VTM = VectorTypeModifier::Log2EEW4;
+        break;
+      case 5:
+        VTM = VectorTypeModifier::Log2EEW5;
+        break;
+      case 6:
+        VTM = VectorTypeModifier::Log2EEW6;
+        break;
+      default:
+        llvm_unreachable("Invalid Log2EEW value, should be [3-6]");
+        return None;
+      }
     } else if (ComplexTT.first == "FixedSEW") {
       uint32_t NewSEW;
-      ComplexTT.second.getAsInteger(10, NewSEW);
-      // Set invalid type if src and dst SEW are same.
-      if (ElementBitwidth == NewSEW) {
-        ScalarType = Invalid;
-        return;
+      if (ComplexTT.second.getAsInteger(10, NewSEW)) {
+        llvm_unreachable("Invalid FixedSEW value!");
+        return None;
+      }
+      switch (NewSEW) {
+      case 8:
+        VTM = VectorTypeModifier::FixedSEW8;
+        break;
+      case 16:
+        VTM = VectorTypeModifier::FixedSEW16;
+        break;
+      case 32:
+        VTM = VectorTypeModifier::FixedSEW32;
+        break;
+      case 64:
+        VTM = VectorTypeModifier::FixedSEW64;
+        break;
+      default:
+        llvm_unreachable("Invalid FixedSEW value, should be 8, 16, 32 or 64");
+        return None;
       }
-      // Update new SEW
-      ElementBitwidth = NewSEW;
-      UpdateAndCheckComplexProto();
     } else if (ComplexTT.first == "LFixedLog2LMUL") {
-      // New LMUL should be larger than old
-      if (!ComputeFixedLog2LMUL(ComplexTT.second, std::greater<int32_t>()))
-        return;
+      int32_t Log2LMUL;
+      if (ComplexTT.second.getAsInteger(10, Log2LMUL)) {
+        llvm_unreachable("Invalid LFixedLog2LMUL value!");
+        return None;
+      }
+      switch (Log2LMUL) {
+      case -3:
+        VTM = VectorTypeModifier::LFixedLog2LMULN3;
+        break;
+      case -2:
+        VTM = VectorTypeModifier::LFixedLog2LMULN2;
+        break;
+      case -1:
+        VTM = VectorTypeModifier::LFixedLog2LMULN1;
+        break;
+      case 0:
+        VTM = VectorTypeModifier::LFixedLog2LMUL0;
+        break;
+      case 1:
+        VTM = VectorTypeModifier::LFixedLog2LMUL1;
+        break;
+      case 2:
+        VTM = VectorTypeModifier::LFixedLog2LMUL2;
+        break;
+      case 3:
+        VTM = VectorTypeModifier::LFixedLog2LMUL3;
+        break;
+      default:
+        llvm_unreachable("Invalid LFixedLog2LMUL value, should be [-3, 3]");
+        return None;
+      }
     } else if (ComplexTT.first == "SFixedLog2LMUL") {
-      // New LMUL should be smaller than old
-      if (!ComputeFixedLog2LMUL(ComplexTT.second, std::less<int32_t>()))
-        return;
+      int32_t Log2LMUL;
+      if (ComplexTT.second.getAsInteger(10, Log2LMUL)) {
+        llvm_unreachable("Invalid SFixedLog2LMUL value!");
+        return None;
+      }
+      switch (Log2LMUL) {
+      case -3:
+        VTM = VectorTypeModifier::SFixedLog2LMULN3;
+        break;
+      case -2:
+        VTM = VectorTypeModifier::SFixedLog2LMULN2;
+        break;
+      case -1:
+        VTM = VectorTypeModifier::SFixedLog2LMULN1;
+        break;
+      case 0:
+        VTM = VectorTypeModifier::SFixedLog2LMUL0;
+        break;
+      case 1:
+        VTM = VectorTypeModifier::SFixedLog2LMUL1;
+        break;
+      case 2:
+        VTM = VectorTypeModifier::SFixedLog2LMUL2;
+        break;
+      case 3:
+        VTM = VectorTypeModifier::SFixedLog2LMUL3;
+        break;
+      default:
+        llvm_unreachable("Invalid LFixedLog2LMUL value, should be [-3, 3]");
+        return None;
+      }
+
     } else {
       llvm_unreachable("Illegal complex type transformers!");
     }
   }
+  PD.VTM = static_cast<uint8_t>(VTM);
 
   // Compute the remain type transformers
-  for (char I : Transformer) {
+  TypeModifier TM = TypeModifier::NoModifier;
+  for (char I : PrototypeDescriptorStr) {
     switch (I) {
     case 'P':
-      if (IsConstant)
+      if ((TM & TypeModifier::Const) == TypeModifier::Const)
         llvm_unreachable("'P' transformer cannot be used after 'C'");
-      if (IsPointer)
+      if ((TM & TypeModifier::Pointer) == TypeModifier::Pointer)
         llvm_unreachable("'P' transformer cannot be used twice");
-      IsPointer = true;
+      TM |= TypeModifier::Pointer;
       break;
     case 'C':
-      if (IsConstant)
-        llvm_unreachable("'C' transformer cannot be used twice");
-      IsConstant = true;
+      TM |= TypeModifier::Const;
       break;
     case 'K':
-      IsImmediate = true;
+      TM |= TypeModifier::Immediate;
       break;
     case 'U':
-      ScalarType = ScalarTypeKind::UnsignedInteger;
+      TM |= TypeModifier::UnsignedInteger;
       break;
     case 'I':
-      ScalarType = ScalarTypeKind::SignedInteger;
+      TM |= TypeModifier::SignedInteger;
       break;
     case 'F':
-      ScalarType = ScalarTypeKind::Float;
+      TM |= TypeModifier::Float;
       break;
     case 'S':
+      TM |= TypeModifier::LMUL1;
+      break;
+    default:
+      llvm_unreachable("Illegal non-primitive type transformer!");
+    }
+  }
+  PD.TM = static_cast<uint8_t>(TM);
+
+  return PD;
+}
+
+void RVVType::applyModifier(const PrototypeDescriptor &Transformer) {
+  // Handle primitive type transformer
+  switch (static_cast<BaseTypeModifier>(Transformer.PT)) {
+  case BaseTypeModifier::Scalar:
+    Scale = 0;
+    break;
+  case BaseTypeModifier::Vector:
+    Scale = LMUL.getScale(ElementBitwidth);
+    break;
+  case BaseTypeModifier::Void:
+    ScalarType = ScalarTypeKind::Void;
+    break;
+  case BaseTypeModifier::SizeT:
+    ScalarType = ScalarTypeKind::Size_t;
+    break;
+  case BaseTypeModifier::Ptrdiff:
+    ScalarType = ScalarTypeKind::Ptrdiff_t;
+    break;
+  case BaseTypeModifier::UnsignedLong:
+    ScalarType = ScalarTypeKind::UnsignedLong;
+    break;
+  case BaseTypeModifier::SignedLong:
+    ScalarType = ScalarTypeKind::SignedLong;
+    break;
+  case BaseTypeModifier::Invalid:
+    ScalarType = ScalarTypeKind::Invalid;
+    return;
+  }
+
+  switch (static_cast<VectorTypeModifier>(Transformer.VTM)) {
+  case VectorTypeModifier::Widening2XVector:
+    ElementBitwidth *= 2;
+    LMUL *= 2;
+    Scale = LMUL.getScale(ElementBitwidth);
+    break;
+  case VectorTypeModifier::Widening4XVector:
+    ElementBitwidth *= 4;
+    LMUL *= 4;
+    Scale = LMUL.getScale(ElementBitwidth);
+    break;
+  case VectorTypeModifier::Widening8XVector:
+    ElementBitwidth *= 8;
+    LMUL *= 8;
+    Scale = LMUL.getScale(ElementBitwidth);
+    break;
+  case VectorTypeModifier::MaskVector:
+    ScalarType = ScalarTypeKind::Boolean;
+    Scale = LMUL.getScale(ElementBitwidth);
+    ElementBitwidth = 1;
+    break;
+  case VectorTypeModifier::Log2EEW3:
+    applyLog2EEW(3);
+    break;
+  case VectorTypeModifier::Log2EEW4:
+    applyLog2EEW(4);
+    break;
+  case VectorTypeModifier::Log2EEW5:
+    applyLog2EEW(5);
+    break;
+  case VectorTypeModifier::Log2EEW6:
+    applyLog2EEW(6);
+    break;
+  case VectorTypeModifier::FixedSEW8:
+    applyFixedSEW(8);
+    break;
+  case VectorTypeModifier::FixedSEW16:
+    applyFixedSEW(16);
+    break;
+  case VectorTypeModifier::FixedSEW32:
+    applyFixedSEW(32);
+    break;
+  case VectorTypeModifier::FixedSEW64:
+    applyFixedSEW(64);
+    break;
+  case VectorTypeModifier::LFixedLog2LMULN3:
+    applyFixedLog2LMUL(-3, FixedLMULType::LargerThan);
+    break;
+  case VectorTypeModifier::LFixedLog2LMULN2:
+    applyFixedLog2LMUL(-2, FixedLMULType::LargerThan);
+    break;
+  case VectorTypeModifier::LFixedLog2LMULN1:
+    applyFixedLog2LMUL(-1, FixedLMULType::LargerThan);
+    break;
+  case VectorTypeModifier::LFixedLog2LMUL0:
+    applyFixedLog2LMUL(0, FixedLMULType::LargerThan);
+    break;
+  case VectorTypeModifier::LFixedLog2LMUL1:
+    applyFixedLog2LMUL(1, FixedLMULType::LargerThan);
+    break;
+  case VectorTypeModifier::LFixedLog2LMUL2:
+    applyFixedLog2LMUL(2, FixedLMULType::LargerThan);
+    break;
+  case VectorTypeModifier::LFixedLog2LMUL3:
+    applyFixedLog2LMUL(3, FixedLMULType::LargerThan);
+    break;
+  case VectorTypeModifier::SFixedLog2LMULN3:
+    applyFixedLog2LMUL(-3, FixedLMULType::SmallerThan);
+    break;
+  case VectorTypeModifier::SFixedLog2LMULN2:
+    applyFixedLog2LMUL(-2, FixedLMULType::SmallerThan);
+    break;
+  case VectorTypeModifier::SFixedLog2LMULN1:
+    applyFixedLog2LMUL(-1, FixedLMULType::SmallerThan);
+    break;
+  case VectorTypeModifier::SFixedLog2LMUL0:
+    applyFixedLog2LMUL(0, FixedLMULType::SmallerThan);
+    break;
+  case VectorTypeModifier::SFixedLog2LMUL1:
+    applyFixedLog2LMUL(1, FixedLMULType::SmallerThan);
+    break;
+  case VectorTypeModifier::SFixedLog2LMUL2:
+    applyFixedLog2LMUL(2, FixedLMULType::SmallerThan);
+    break;
+  case VectorTypeModifier::SFixedLog2LMUL3:
+    applyFixedLog2LMUL(3, FixedLMULType::SmallerThan);
+    break;
+  case VectorTypeModifier::NoModifier:
+    break;
+  }
+
+  for (unsigned TypeModifierMaskShift = 0;
+       TypeModifierMaskShift <= static_cast<unsigned>(TypeModifier::MaxOffset);
+       ++TypeModifierMaskShift) {
+    unsigned TypeModifierMask = 1 << TypeModifierMaskShift;
+    if ((static_cast<unsigned>(Transformer.TM) & TypeModifierMask) !=
+        TypeModifierMask)
+      continue;
+    switch (static_cast<TypeModifier>(TypeModifierMask)) {
+    case TypeModifier::Pointer:
+      IsPointer = true;
+      break;
+    case TypeModifier::Const:
+      IsConstant = true;
+      break;
+    case TypeModifier::Immediate:
+      IsImmediate = true;
+      IsConstant = true;
+      break;
+    case TypeModifier::UnsignedInteger:
+      ScalarType = ScalarTypeKind::UnsignedInteger;
+      break;
+    case TypeModifier::SignedInteger:
+      ScalarType = ScalarTypeKind::SignedInteger;
+      break;
+    case TypeModifier::Float:
+      ScalarType = ScalarTypeKind::Float;
+      break;
+    case TypeModifier::LMUL1:
       LMUL = LMULType(0);
       // Update ElementBitwidth need to update Scale too.
       Scale = LMUL.getScale(ElementBitwidth);
       break;
     default:
-      llvm_unreachable("Illegal non-primitive type transformer!");
-    }
+      llvm_unreachable("Unknown type modifier mask!");
+    }
+  }
+}
+
+void RVVType::applyLog2EEW(unsigned Log2EEW) {
+  // update new elmul = (eew/sew) * lmul
+  LMUL.MulLog2LMUL(Log2EEW - Log2_32(ElementBitwidth));
+  // update new eew
+  ElementBitwidth = 1 << Log2EEW;
+  ScalarType = ScalarTypeKind::SignedInteger;
+  Scale = LMUL.getScale(ElementBitwidth);
+
+void RVVType::applyFixedSEW(unsigned NewSEW) {
+  // Set invalid type if src and dst SEW are same.
+  if (ElementBitwidth == NewSEW) {
+    ScalarType = ScalarTypeKind::Invalid;
+    return;
   }
+  // Update new SEW
+  ElementBitwidth = NewSEW;
+  Scale = LMUL.getScale(ElementBitwidth);
+}
+
+void RVVType::applyFixedLog2LMUL(int Log2LMUL, enum FixedLMULType Type) {
+  switch (Type) {
+  case FixedLMULType::LargerThan:
+    if (Log2LMUL < LMUL.Log2LMUL) {
+      ScalarType = ScalarTypeKind::Invalid;
+      return;
+    }
+    break;
+  case FixedLMULType::SmallerThan:
+    if (Log2LMUL > LMUL.Log2LMUL) {
+      ScalarType = ScalarTypeKind::Invalid;
+      return;
+    }
+    break;
+  default:
+    llvm_unreachable("Unknown FixedLMULType??");
+  }
+
+  // Update new LMUL
+  LMUL = LMULType(Log2LMUL);
+  Scale = LMUL.getScale(ElementBitwidth);
+}
+
+Optional<RVVTypes>
+RVVType::computeTypes(BasicType BT, int Log2LMUL, unsigned NF,
+                      ArrayRef<PrototypeDescriptor> PrototypeSeq) {
+  // LMUL x NF must be less than or equal to 8.
+  if ((Log2LMUL >= 1) && (1 << Log2LMUL) * NF > 8)
+    return llvm::None;
+
+  RVVTypes Types;
+  for (const PrototypeDescriptor &Proto : PrototypeSeq) {
+    auto T = computeType(BT, Log2LMUL, Proto);
+    if (!T.hasValue())
+      return llvm::None;
+    // Record legal type index
+    Types.push_back(T.getValue());
+  }
+  return Types;
+}
+
+// Compute the hash value of RVVType, used for cache the result of computeType.
+static uint64_t computeRVVTypeHashValue(BasicType BT, int Log2LMUL,
+                                        PrototypeDescriptor Proto) {
+  // Layout of hash value:
+  // 0               8    16          24        32          40
+  // | Log2LMUL + 3  | BT  | Proto.PT | Proto.TM | Proto.VTM |
+  assert(Log2LMUL >= -3 && Log2LMUL <= 3);
+  return (Log2LMUL + 3) | (static_cast<uint64_t>(BT) & 0xff) << 8 |
+         ((uint64_t)(Proto.PT & 0xff) << 16) |
+         ((uint64_t)(Proto.TM & 0xff) << 24) |
+         ((uint64_t)(Proto.VTM & 0xff) << 32);
+}
+
+Optional<RVVTypePtr> RVVType::computeType(BasicType BT, int Log2LMUL,
+                                          PrototypeDescriptor Proto) {
+  uint64_t Idx = computeRVVTypeHashValue(BT, Log2LMUL, Proto);
+  // Search first
+  auto It = LegalTypes.find(Idx);
+  if (It != LegalTypes.end())
+    return &(It->second);
+
+  if (IllegalTypes.count(Idx))
+    return llvm::None;
+
+  // Compute type and record the result.
+  RVVType T(BT, Log2LMUL, Proto);
+  if (T.isValid()) {
+    // Record legal type index and value.
+    LegalTypes.insert({Idx, T});
+    return &(LegalTypes[Idx]);
+  }
+  // Record illegal type index.
+  IllegalTypes.insert(Idx);
+  return llvm::None;
 }
 
 //===----------------------------------------------------------------------===//
 // RVVIntrinsic implementation
 //===----------------------------------------------------------------------===//
 RVVIntrinsic::RVVIntrinsic(
     StringRef NewName, StringRef Suffix, StringRef NewMangledName,
     StringRef MangledSuffix, StringRef IRName, bool IsMasked,
     bool HasMaskedOffOperand, bool HasVL, PolicyScheme Scheme,
     bool HasUnMaskedOverloaded, bool HasBuiltinAlias, StringRef ManualCodegen,
     const RVVTypes &OutInTypes, const std::vector<int64_t> &NewIntrinsicTypes,
     const std::vector<StringRef> &RequiredFeatures, unsigned NF)
     : IRName(IRName), IsMasked(IsMasked), HasVL(HasVL), Scheme(Scheme),
       HasUnMaskedOverloaded(HasUnMaskedOverloaded),
       HasBuiltinAlias(HasBuiltinAlias), ManualCodegen(ManualCodegen.str()),
       NF(NF) {
 
   // Init BuiltinName, Name and MangledName
   BuiltinName = NewName.str();
   Name = BuiltinName;
   if (NewMangledName.empty())
     MangledName = NewName.split("_").first.str();
   else
     MangledName = NewMangledName.str();
   if (!Suffix.empty())
     Name += "_" + Suffix.str();
   if (!MangledSuffix.empty())
     MangledName += "_" + MangledSuffix.str();
   if (IsMasked) {
     BuiltinName += "_m";
     Name += "_m";
std::string RVVIntrinsic::getBuiltinTypeStr() const {
   std::string S;
   S += OutputType->getBuiltinStr();
   for (const auto &T : InputTypes) {
     S += T->getBuiltinStr();
   }
   return S;
 }
 
+std::string RVVIntrinsic::getSuffixStr(
+    BasicType Type, int Log2LMUL,
+    const llvm::SmallVector<PrototypeDescriptor> &PrototypeDescriptors) {
+  SmallVector<std::string> SuffixStrs;
+  for (auto PD : PrototypeDescriptors) {
+    auto T = RVVType::computeType(Type, Log2LMUL, PD);
+    SuffixStrs.push_back(T.getValue()->getShortStr());
+  }
+  return join(SuffixStrs, "_");
+}
+
+SmallVector<PrototypeDescriptor> parsePrototypes(StringRef Prototypes) {
+  SmallVector<PrototypeDescriptor> PrototypeDescriptors;
+  const StringRef Primaries("evwqom0ztul");
+  while (!Prototypes.empty()) {
+    size_t Idx = 0;
+    // Skip over complex prototype because it could contain primitive type
+    // character.
+    if (Prototypes[0] == '(')
+      Idx = Prototypes.find_first_of(')');
+    Idx = Prototypes.find_first_of(Primaries, Idx);
+    assert(Idx != StringRef::npos);
+    auto PD = PrototypeDescriptor::parsePrototypeDescriptor(
+        Prototypes.slice(0, Idx + 1));
+    if (!PD)
+      llvm_unreachable("Error during parsing prototype.");
+    PrototypeDescriptors.push_back(*PD);
+    Prototypes = Prototypes.drop_front(Idx + 1);
+  }
+  return PrototypeDescriptors;
+}
+
 } // end namespace RISCV
 } // end namespace clang

clang/utils/TableGen/RISCVVEmitter.cpp

 
 using namespace llvm;
 using namespace clang::RISCV;
 
 namespace {
 class RVVEmitter {
 private:
   RecordKeeper &Records;
-  // Concat BasicType, LMUL and Proto as key
-  StringMap<RVVType> LegalTypes;
-  StringSet<> IllegalTypes;
 
 public:
   RVVEmitter(RecordKeeper &R) : Records(R) {}
 
   /// Emit riscv_vector.h
   void createHeader(raw_ostream &o);
 
   /// Emit all the __builtin prototypes and code needed by Sema.
   void createBuiltins(raw_ostream &o);
 
   /// Emit all the information needed to map builtin -> LLVM IR intrinsic.
   void createCodeGen(raw_ostream &o);
 
-  std::string getSuffixStr(char Type, int Log2LMUL, StringRef Prototypes);
-
 private:
   /// Create all intrinsics and add them to \p Out
   void createRVVIntrinsics(std::vector<std::unique_ptr<RVVIntrinsic>> &Out);
   /// Print HeaderCode in RVVHeader Record to \p Out
   void printHeaderCode(raw_ostream &OS);
-  /// Compute output and input types by applying different config (basic type
-  /// and LMUL with type transformers). It also record result of type in legal
-  /// or illegal set to avoid compute the  same config again. The result maybe
-  /// have illegal RVVType.
-  Optional<RVVTypes> computeTypes(BasicType BT, int Log2LMUL, unsigned NF,
-                                  ArrayRef<std::string> PrototypeSeq);
-  Optional<RVVTypePtr> computeType(BasicType BT, int Log2LMUL, StringRef Proto);
 
   /// Emit Acrh predecessor definitions and body, assume the element of Defs are
   /// sorted by extension.
   void emitArchMacroAndBody(
       std::vector<std::unique_ptr<RVVIntrinsic>> &Defs, raw_ostream &o,
       std::function<void(raw_ostream &, const RVVIntrinsic &)>);
 
   // Emit the architecture preprocessor definitions. Return true when emits
   // non-empty string.
   bool emitMacroRestrictionStr(RISCVPredefinedMacroT PredefinedMacros,
                                raw_ostream &o);
-  // Slice Prototypes string into sub prototype string and process each sub
-  // prototype string individually in the Handler.
-  void parsePrototypes(StringRef Prototypes,
-                       std::function<void(StringRef)> Handler);
 };
 
 } // namespace
 
+static BasicType ParseBasicType(char c) {
+  switch (c) {
+  case 'c':
+    return BasicType::Int8;
+    break;
+  case 's':
+    return BasicType::Int16;
+    break;
+  case 'i':
+    return BasicType::Int32;
+    break;
+  case 'l':
+    return BasicType::Int64;
+    break;
+  case 'x':
+    return BasicType::Float16;
+    break;
+  case 'f':
+    return BasicType::Float32;
+    break;
+  case 'd':
+    return BasicType::Float64;
+    break;
+
+  default:
+    return BasicType::Unknown;
+  }
+}
+
 void emitCodeGenSwitchBody(const RVVIntrinsic *RVVI, raw_ostream &OS) {
   if (!RVVI->getIRName().empty())
     OS << "  ID = Intrinsic::riscv_" + RVVI->getIRName() + ";\n";
   if (RVVI->getNF() >= 2)
     OS << "  NF = " + utostr(RVVI->getNF()) + ";\n";
   if (RVVI->hasManualCodegen()) {
     OS << RVVI->getManualCodegen();
     OS << "break;\n";
void RVVEmitter::createHeader(raw_ostream &OS) {
   auto printType = [&](auto T) {
     OS << "typedef " << T->getClangBuiltinStr() << " " << T->getTypeStr()
        << ";\n";
   };
 
   constexpr int Log2LMULs[] = {-3, -2, -1, 0, 1, 2, 3};
   // Print RVV boolean types.
   for (int Log2LMUL : Log2LMULs) {
-    auto T = computeType('c', Log2LMUL, "m");
+    auto T = RVVType::computeType(BasicType::Int8, Log2LMUL,
+                                  PrototypeDescriptor::Mask);
     if (T.hasValue())
       printType(T.getValue());
   }
   // Print RVV int/float types.
   for (char I : StringRef("csil")) {
+    BasicType BT = ParseBasicType(I);
     for (int Log2LMUL : Log2LMULs) {
-      auto T = computeType(I, Log2LMUL, "v");
+      auto T = RVVType::computeType(BT, Log2LMUL, PrototypeDescriptor::Vector);
       if (T.hasValue()) {
         printType(T.getValue());
-        auto UT = computeType(I, Log2LMUL, "Uv");
+        auto UT = RVVType::computeType(
+            BT, Log2LMUL,
+            PrototypeDescriptor(BaseTypeModifier::Vector,
+                                VectorTypeModifier::NoModifier,
+                                TypeModifier::UnsignedInteger));
         printType(UT.getValue());
       }
     }
   }
   OS << "#if defined(__riscv_zvfh)\n";
   for (int Log2LMUL : Log2LMULs) {
-    auto T = computeType('x', Log2LMUL, "v");
+    auto T = RVVType::computeType(BasicType::Float16, Log2LMUL,
+                                  PrototypeDescriptor::Vector);
     if (T.hasValue())
       printType(T.getValue());
   }
   OS << "#endif\n";
 
   OS << "#if defined(__riscv_f)\n";
   for (int Log2LMUL : Log2LMULs) {
-    auto T = computeType('f', Log2LMUL, "v");
+    auto T = RVVType::computeType(BasicType::Float32, Log2LMUL,
+                                  PrototypeDescriptor::Vector);
     if (T.hasValue())
       printType(T.getValue());
   }
   OS << "#endif\n";
 
   OS << "#if defined(__riscv_d)\n";
   for (int Log2LMUL : Log2LMULs) {
-    auto T = computeType('d', Log2LMUL, "v");
+    auto T = RVVType::computeType(BasicType::Float64, Log2LMUL,
+                                  PrototypeDescriptor::Vector);
     if (T.hasValue())
       printType(T.getValue());
   }
   OS << "#endif\n\n";
 
   // The same extension include in the same arch guard marco.
   llvm::stable_sort(Defs, [](const std::unique_ptr<RVVIntrinsic> &A,
                              const std::unique_ptr<RVVIntrinsic> &B) {
else if (P.first->second->getPolicyScheme() != Def->getPolicyScheme())
       PrintFatalError("Builtin with same name has different getPolicyScheme");
     else if (P.first->second->getIntrinsicTypes() != Def->getIntrinsicTypes())
       PrintFatalError("Builtin with same name has different IntrinsicTypes");
   }
   emitCodeGenSwitchBody(Defs.back().get(), OS);
   OS << "\n";
 }
 
-void RVVEmitter::parsePrototypes(StringRef Prototypes,
-                                 std::function<void(StringRef)> Handler) {
-  const StringRef Primaries("evwqom0ztul");
-  while (!Prototypes.empty()) {
-    size_t Idx = 0;
-    // Skip over complex prototype because it could contain primitive type
-    // character.
-    if (Prototypes[0] == '(')
-      Idx = Prototypes.find_first_of(')');
-    Idx = Prototypes.find_first_of(Primaries, Idx);
-    assert(Idx != StringRef::npos);
-    Handler(Prototypes.slice(0, Idx + 1));
-    Prototypes = Prototypes.drop_front(Idx + 1);
-  }
-}
-
-std::string RVVEmitter::getSuffixStr(char Type, int Log2LMUL,
-                                     StringRef Prototypes) {
-  SmallVector<std::string> SuffixStrs;
-  parsePrototypes(Prototypes, [&](StringRef Proto) {
-    auto T = computeType(Type, Log2LMUL, Proto);
-    SuffixStrs.push_back(T.getValue()->getShortStr());
-  });
-  return join(SuffixStrs, "_");
-}
-
 void RVVEmitter::createRVVIntrinsics(
     std::vector<std::unique_ptr<RVVIntrinsic>> &Out) {
   std::vector<Record *> RV = Records.getAllDerivedDefinitions("RVVBuiltin");
   for (auto *R : RV) {
     StringRef Name = R->getValueAsString("Name");
     StringRef SuffixProto = R->getValueAsString("Suffix");
     StringRef MangledName = R->getValueAsString("MangledName");
     StringRef MangledSuffixProto = R->getValueAsString("MangledSuffix");
for (auto *R : RV) {
     std::vector<StringRef> RequiredFeatures =
         R->getValueAsListOfStrings("RequiredFeatures");
     StringRef IRName = R->getValueAsString("IRName");
     StringRef MaskedIRName = R->getValueAsString("MaskedIRName");
     unsigned NF = R->getValueAsInt("NF");
 
     // Parse prototype and create a list of primitive type with transformers
     // (operand) in ProtoSeq. ProtoSeq[0] is output operand.
-    SmallVector<std::string> ProtoSeq;
-    parsePrototypes(Prototypes, [&ProtoSeq](StringRef Proto) {
-      ProtoSeq.push_back(Proto.str());
-    });
+    SmallVector<PrototypeDescriptor> ProtoSeq = parsePrototypes(Prototypes);
+
+    SmallVector<PrototypeDescriptor> SuffixProtoSeq =
+        parsePrototypes(SuffixProto);
+    SmallVector<PrototypeDescriptor> MangledSuffixProtoSeq =
+        parsePrototypes(MangledSuffixProto);
 
     // Compute Builtin types
-    SmallVector<std::string> ProtoMaskSeq = ProtoSeq;
+    SmallVector<PrototypeDescriptor> ProtoMaskSeq = ProtoSeq;
     if (HasMasked) {
       // If HasMaskedOffOperand, insert result type as first input operand.
       if (HasMaskedOffOperand) {
         if (NF == 1) {
           ProtoMaskSeq.insert(ProtoMaskSeq.begin() + 1, ProtoSeq[0]);
         } else {
           // Convert
           // (void, op0 address, op1 address, ...)
           // to
           // (void, op0 address, op1 address, ..., maskedoff0, maskedoff1, ...)
+          PrototypeDescriptor MaskoffType = ProtoSeq[1];
+          MaskoffType.TM &= ~static_cast<uint8_t>(TypeModifier::Pointer);
           for (unsigned I = 0; I < NF; ++I)
-            ProtoMaskSeq.insert(
-                ProtoMaskSeq.begin() + NF + 1,
-                ProtoSeq[1].substr(1)); // Use substr(1) to skip '*'
+            ProtoMaskSeq.insert(ProtoMaskSeq.begin() + NF + 1, MaskoffType);
         }
       }
       if (HasMaskedOffOperand && NF > 1) {
         // Convert
         // (void, op0 address, op1 address, ..., maskedoff0, maskedoff1, ...)
         // to
         // (void, op0 address, op1 address, ..., mask, maskedoff0, maskedoff1,
         // ...)
-        ProtoMaskSeq.insert(ProtoMaskSeq.begin() + NF + 1, "m");
+        ProtoMaskSeq.insert(ProtoMaskSeq.begin() + NF + 1,
+                            PrototypeDescriptor::Mask);
       } else {
-        // If HasMasked, insert 'm' as first input operand.
-        ProtoMaskSeq.insert(ProtoMaskSeq.begin() + 1, "m");
+        // If HasMasked, insert PrototypeDescriptor:Mask as first input operand.
+        ProtoMaskSeq.insert(ProtoMaskSeq.begin() + 1,
+                            PrototypeDescriptor::Mask);
       }
     }
-    // If HasVL, append 'z' to last operand
+    // If HasVL, append PrototypeDescriptor:VL to last operand
     if (HasVL) {
-      ProtoSeq.push_back("z");
-      ProtoMaskSeq.push_back("z");
+      ProtoSeq.push_back(PrototypeDescriptor::VL);
+      ProtoMaskSeq.push_back(PrototypeDescriptor::VL);
     }
 
     // Create Intrinsics for each type and LMUL.
     for (char I : TypeRange) {
       for (int Log2LMUL : Log2LMULList) {
-        Optional<RVVTypes> Types = computeTypes(I, Log2LMUL, NF, ProtoSeq);
+        BasicType BT = ParseBasicType(I);
+        Optional<RVVTypes> Types =
+            RVVType::computeTypes(BT, Log2LMUL, NF, ProtoSeq);
         // Ignored to create new intrinsic if there are any illegal types.
         if (!Types.hasValue())
           continue;
 
-        auto SuffixStr = getSuffixStr(I, Log2LMUL, SuffixProto);
-        auto MangledSuffixStr = getSuffixStr(I, Log2LMUL, MangledSuffixProto);
+        auto SuffixStr =
+            RVVIntrinsic::getSuffixStr(BT, Log2LMUL, SuffixProtoSeq);
+        auto MangledSuffixStr =
+            RVVIntrinsic::getSuffixStr(BT, Log2LMUL, MangledSuffixProtoSeq);
         // Create a unmasked intrinsic
         Out.push_back(std::make_unique<RVVIntrinsic>(
             Name, SuffixStr, MangledName, MangledSuffixStr, IRName,
             /*IsMasked=*/false, /*HasMaskedOffOperand=*/false, HasVL,
             UnMaskedPolicy, HasUnMaskedOverloaded, HasBuiltinAlias,
             ManualCodegen, Types.getValue(), IntrinsicTypes, RequiredFeatures,
             NF));
         if (HasMasked) {
           // Create a masked intrinsic
           Optional<RVVTypes> MaskTypes =
-              computeTypes(I, Log2LMUL, NF, ProtoMaskSeq);
+              RVVType::computeTypes(BT, Log2LMUL, NF, ProtoMaskSeq);
           Out.push_back(std::make_unique<RVVIntrinsic>(
               Name, SuffixStr, MangledName, MangledSuffixStr, MaskedIRName,
               /*IsMasked=*/true, HasMaskedOffOperand, HasVL, MaskedPolicy,
               HasUnMaskedOverloaded, HasBuiltinAlias, MaskedManualCodegen,
               MaskTypes.getValue(), IntrinsicTypes, RequiredFeatures, NF));
         }
       } // end for Log2LMULList
     }   // end for TypeRange
   }
 }
 
 void RVVEmitter::printHeaderCode(raw_ostream &OS) {
   std::vector<Record *> RVVHeaders =
       Records.getAllDerivedDefinitions("RVVHeader");
   for (auto *R : RVVHeaders) {
     StringRef HeaderCodeStr = R->getValueAsString("HeaderCode");
     OS << HeaderCodeStr.str();
   }
 }
 
-Optional<RVVTypes>
-RVVEmitter::computeTypes(BasicType BT, int Log2LMUL, unsigned NF,
-                         ArrayRef<std::string> PrototypeSeq) {
-  // LMUL x NF must be less than or equal to 8.
-  if ((Log2LMUL >= 1) && (1 << Log2LMUL) * NF > 8)
-    return llvm::None;
-
-  RVVTypes Types;
-  for (const std::string &Proto : PrototypeSeq) {
-    auto T = computeType(BT, Log2LMUL, Proto);
-    if (!T.hasValue())
-      return llvm::None;
-    // Record legal type index
-    Types.push_back(T.getValue());
-  }
-  return Types;
-}
-
-Optional<RVVTypePtr> RVVEmitter::computeType(BasicType BT, int Log2LMUL,
-                                             StringRef Proto) {
-  std::string Idx = Twine(Twine(BT) + Twine(Log2LMUL) + Proto).str();
-  // Search first
-  auto It = LegalTypes.find(Idx);
-  if (It != LegalTypes.end())
-    return &(It->second);
-  if (IllegalTypes.count(Idx))
-    return llvm::None;
-  // Compute type and record the result.
-  RVVType T(BT, Log2LMUL, Proto);
-  if (T.isValid()) {
-    // Record legal type index and value.
-    LegalTypes.insert({Idx, T});
-    return &(LegalTypes[Idx]);
-  }
-  // Record illegal type index.
-  IllegalTypes.insert(Idx);
-  return llvm::None;
-}
-
 void RVVEmitter::emitArchMacroAndBody(
     std::vector<std::unique_ptr<RVVIntrinsic>> &Defs, raw_ostream &OS,
     std::function<void(raw_ostream &, const RVVIntrinsic &)> PrintBody) {
   RISCVPredefinedMacroT PrevMacros =
       (*Defs.begin())->getRISCVPredefinedMacros();
   bool NeedEndif = emitMacroRestrictionStr(PrevMacros, OS);
   for (auto &Def : Defs) {
     RISCVPredefinedMacroT CurMacros = Def->getRISCVPredefinedMacros();