[RISCV][Clang] Refactor RISCVVEmitter. (NFC)

[khchen]

Summary

Remove MaskedPrototype and add several fields in RVVIntrinsicRecord,
compute Prototype in runtime.

[rogfer01]

LGTM. Thanks @khchen !

clang/include/clang/Support/RISCVVIntrinsicUtils.h

struct RVVIntrinsicRecord {
 
   // Overloaded intrinsic name, could be empty if it can be computed from Name.
   // e.g. vadd
   const char *OverloadedName;
 
   // Prototype for this intrinsic, index of RVVSignatureTable.
   uint16_t PrototypeIndex;
 
-  // Prototype for masked intrinsic, index of RVVSignatureTable.
-  uint16_t MaskedPrototypeIndex;
-
   // Suffix of intrinsic name, index of RVVSignatureTable.
   uint16_t SuffixIndex;
 
   // Suffix of overloaded intrinsic name, index of RVVSignatureTable.
   uint16_t OverloadedSuffixIndex;
 
   // Length of the prototype.
   uint8_t PrototypeLength;
 
-  // Length of prototype of masked intrinsic.
-  uint8_t MaskedPrototypeLength;
-
   // Length of intrinsic name suffix.
   uint8_t SuffixLength;
 
   // Length of overloaded intrinsic suffix.
   uint8_t OverloadedSuffixSize;
 
   // Required target features for this intrinsic.
   uint8_t RequiredExtensions;
 
   // Supported type, mask of BasicType.
   uint8_t TypeRangeMask;
 
   // Supported LMUL.
   uint8_t Log2LMULMask;
 
   // Number of fields, greater than 1 if it's segment load/store.
   uint8_t NF;
+
+  bool HasMasked : 1;
+  bool HasVL : 1;
+  bool HasMaskedOffOperand : 1;
 };
 
 llvm::raw_ostream &operator<<(llvm::raw_ostream &OS,
                               const RVVIntrinsicRecord &RVVInstrRecord);
 
 LLVM_ENABLE_BITMASK_ENUMS_IN_NAMESPACE();
 } // end namespace RISCV
 
 } // end namespace clang
 
 #endif // CLANG_SUPPORT_RISCVVINTRINSICUTILS_H

clang/lib/Sema/SemaRISCVVectorLookup.cpp

void RISCVIntrinsicManagerImpl::InitIntrinsicList() {
   bool HasRV64 = TI.hasFeature("64bit");
   bool HasFullMultiply = TI.hasFeature("v");
 
   // Construction of RVVIntrinsicRecords need to sync with createRVVIntrinsics
   // in RISCVVEmitter.cpp.
   for (auto &Record : RVVIntrinsicRecords) {
     // Create Intrinsics for each type and LMUL.
     BasicType BaseType = BasicType::Unknown;
-    ArrayRef<PrototypeDescriptor> ProtoSeq =
+    ArrayRef<PrototypeDescriptor> BasicProtoSeq =
         ProtoSeq2ArrayRef(Record.PrototypeIndex, Record.PrototypeLength);
-    ArrayRef<PrototypeDescriptor> ProtoMaskSeq = ProtoSeq2ArrayRef(
-        Record.MaskedPrototypeIndex, Record.MaskedPrototypeLength);
     ArrayRef<PrototypeDescriptor> SuffixProto =
         ProtoSeq2ArrayRef(Record.SuffixIndex, Record.SuffixLength);
     ArrayRef<PrototypeDescriptor> OverloadedSuffixProto = ProtoSeq2ArrayRef(
         Record.OverloadedSuffixIndex, Record.OverloadedSuffixSize);
+
+    llvm::SmallVector<PrototypeDescriptor> ProtoSeq =
+        RVVIntrinsic::computeBuiltinTypes(BasicProtoSeq, /*IsMasked=*/false,
+                                          /*HasMaskedOffOperand=*/false,
+                                          Record.HasVL, Record.NF);
+
+    llvm::SmallVector<PrototypeDescriptor> ProtoMaskSeq =
+        RVVIntrinsic::computeBuiltinTypes(BasicProtoSeq, /*IsMasked=*/true,
+                                          Record.HasMaskedOffOperand,
+                                          Record.HasVL, Record.NF);
+
     for (unsigned int TypeRangeMaskShift = 0;
          TypeRangeMaskShift <= static_cast<unsigned int>(BasicType::MaxOffset);
          ++TypeRangeMaskShift) {
       unsigned int BaseTypeI = 1 << TypeRangeMaskShift;
       BaseType = static_cast<BasicType>(BaseTypeI);
 
       if ((BaseTypeI & Record.TypeRangeMask) != BaseTypeI)
         continue;
for (unsigned int TypeRangeMaskShift = 0;
         std::string SuffixStr =
             RVVIntrinsic::getSuffixStr(BaseType, Log2LMUL, SuffixProto);
         std::string OverloadedSuffixStr = RVVIntrinsic::getSuffixStr(
             BaseType, Log2LMUL, OverloadedSuffixProto);
 
         // Create non-masked intrinsic.
         InitRVVIntrinsic(Record, SuffixStr, OverloadedSuffixStr, false, *Types);
 
-        if (Record.MaskedPrototypeLength != 0) {
+        if (Record.HasMasked) {
           // Create masked intrinsic.
           Optional<RVVTypes> MaskTypes = RVVType::computeTypes(
               BaseType, Log2LMUL, Record.NF, ProtoMaskSeq);
 
           InitRVVIntrinsic(Record, SuffixStr, OverloadedSuffixStr, true,
                            *MaskTypes);
         }
       }

clang/lib/Support/RISCVVIntrinsicUtils.cpp

raw_ostream &operator<<(raw_ostream &OS, const RVVIntrinsicRecord &Record) {
   OS << "{";
   OS << "\"" << Record.Name << "\",";
   if (Record.OverloadedName == nullptr ||
       StringRef(Record.OverloadedName).empty())
     OS << "nullptr,";
   else
     OS << "\"" << Record.OverloadedName << "\",";
   OS << Record.PrototypeIndex << ",";
-  OS << Record.MaskedPrototypeIndex << ",";
   OS << Record.SuffixIndex << ",";
   OS << Record.OverloadedSuffixIndex << ",";
   OS << (int)Record.PrototypeLength << ",";
-  OS << (int)Record.MaskedPrototypeLength << ",";
   OS << (int)Record.SuffixLength << ",";
   OS << (int)Record.OverloadedSuffixSize << ",";
   OS << (int)Record.RequiredExtensions << ",";
   OS << (int)Record.TypeRangeMask << ",";
   OS << (int)Record.Log2LMULMask << ",";
   OS << (int)Record.NF << ",";
+  OS << (int)Record.HasMasked << ",";
+  OS << (int)Record.HasVL << ",";
+  OS << (int)Record.HasMaskedOffOperand << ",";
   OS << "},\n";
   return OS;
 }
 
 } // end namespace RISCV
 } // end namespace clang

clang/utils/TableGen/RISCVVEmitter.cpp

struct SemaRecord {
   unsigned Log2LMULMask;
 
   // Required extensions for this intrinsic.
   unsigned RequiredExtensions;
 
   // Prototype for this intrinsic.
   SmallVector<PrototypeDescriptor> Prototype;
 
-  // Prototype for masked intrinsic.
-  SmallVector<PrototypeDescriptor> MaskedPrototype;
-
   // Suffix of intrinsic name.
   SmallVector<PrototypeDescriptor> Suffix;
 
   // Suffix of overloaded intrinsic name.
   SmallVector<PrototypeDescriptor> OverloadedSuffix;
 
   // Number of field, large than 1 if it's segment load/store.
   unsigned NF;
+
+  bool HasMasked :1;
+  bool HasVL :1;
+  bool HasMaskedOffOperand :1;
 };
 
 // Compressed function signature table.
 class SemaSignatureTable {
 private:
   std::vector<PrototypeDescriptor> SignatureTable;
 
   void insert(ArrayRef<PrototypeDescriptor> Signature);
auto InsertToSignatureSet =
 
         Signatures.insert(Signature);
       };
 
   assert(!SemaRecords.empty());
 
   llvm::for_each(SemaRecords, [&](const SemaRecord &SR) {
     InsertToSignatureSet(SR.Prototype);
-    InsertToSignatureSet(SR.MaskedPrototype);
     InsertToSignatureSet(SR.Suffix);
     InsertToSignatureSet(SR.OverloadedSuffix);
   });
 
   llvm::for_each(Signatures, [this](auto &Sig) { insert(Sig); });
 }
 
 void SemaSignatureTable::insert(ArrayRef<PrototypeDescriptor> Signature) {
for (auto RequiredFeature : RequiredFeatures) {
                                   .Case("RV64", RVV_REQ_RV64)
                                   .Case("FullMultiply", RVV_REQ_FullMultiply)
                                   .Default(RVV_REQ_None);
       assert(RequireExt != RVV_REQ_None && "Unrecognized required feature?");
       SR.RequiredExtensions |= RequireExt;
     }
 
     SR.NF = NF;
-
-    SR.Prototype = std::move(Prototype);
-
-    if (HasMasked)
-      SR.MaskedPrototype = std::move(MaskedPrototype);
-
+    SR.HasMasked = HasMasked;
+    SR.HasVL = HasVL;
+    SR.HasMaskedOffOperand = HasMaskedOffOperand;
+    SR.Prototype = std::move(BasicPrototype);
     SR.Suffix = parsePrototypes(SuffixProto);
     SR.OverloadedSuffix = parsePrototypes(OverloadedSuffixProto);
 
     SemaRecords->push_back(SR);
   }
 }
 
 void RVVEmitter::printHeaderCode(raw_ostream &OS) {
void RVVEmitter::createRVVIntrinsicRecords(std::vector<RVVIntrinsicRecord> &Out,
   SST.init(SemaRecords);
 
   for (const auto &SR : SemaRecords) {
     Out.emplace_back(RVVIntrinsicRecord());
     RVVIntrinsicRecord &R = Out.back();
     R.Name = SR.Name.c_str();
     R.OverloadedName = SR.OverloadedName.c_str();
     R.PrototypeIndex = SST.getIndex(SR.Prototype);
-    R.MaskedPrototypeIndex = SST.getIndex(SR.MaskedPrototype);
     R.SuffixIndex = SST.getIndex(SR.Suffix);
     R.OverloadedSuffixIndex = SST.getIndex(SR.OverloadedSuffix);
     R.PrototypeLength = SR.Prototype.size();
-    R.MaskedPrototypeLength = SR.MaskedPrototype.size();
     R.SuffixLength = SR.Suffix.size();
     R.OverloadedSuffixSize = SR.OverloadedSuffix.size();
     R.RequiredExtensions = SR.RequiredExtensions;
     R.TypeRangeMask = SR.TypeRangeMask;
     R.Log2LMULMask = SR.Log2LMULMask;
     R.NF = SR.NF;
+    R.HasMasked = SR.HasMasked;
+    R.HasVL = SR.HasVL;
+    R.HasMaskedOffOperand = SR.HasMaskedOffOperand;
 
     assert(R.PrototypeIndex !=
            static_cast<uint16_t>(SemaSignatureTable::INVALID_INDEX));
-    assert(R.MaskedPrototypeIndex !=
-           static_cast<uint16_t>(SemaSignatureTable::INVALID_INDEX));
     assert(R.SuffixIndex !=
            static_cast<uint16_t>(SemaSignatureTable::INVALID_INDEX));
     assert(R.OverloadedSuffixIndex !=
            static_cast<uint16_t>(SemaSignatureTable::INVALID_INDEX));
   }
 }
 
 void RVVEmitter::createSema(raw_ostream &OS) {