[NFC][Clang][RISCV] Rename data member 'DefaultPolicy' to 'PolicyAttrs'

[eopXD]

Summary

The naming here is strange since the value may still be updated.

[eopXD]

Just throwing out the question here, I would be happy to rename it to anything else that makes sense rather than the current.

[kito-cheng]

Could you rebase with D140361?

[eopXD]

Rebase upon latest main.

[khchen]

LGTM, thanks!

[eopXD]

Rebae to latest main.

[eopXD]

Change: Recover mis-deleted lines.

[eopXD]

Recover mis-deleted lines.

clang/include/clang/Basic/riscv_vector.td

let Name = NAME # "_v",
       MaskedIRName = "vleff_mask",
       SupportOverloading = false,
       UnMaskedPolicyScheme = HasPassthruOperand,
       ManualCodegen = [{
       {
         if (IsMasked) {
           // Move mask to right before vl.
           std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
-          if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC)
+          if (PolicyAttrs == TAIL_AGNOSTIC_MASK_AGNOSTIC)
             Ops.insert(Ops.begin(), llvm::PoisonValue::get(ResultType));
-          Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
+          Ops.push_back(ConstantInt::get(Ops.back()->getType(), PolicyAttrs));
           IntrinsicTypes = {ResultType, Ops[4]->getType()};
         } else {
-          if (DefaultPolicy == TAIL_AGNOSTIC)
+          if (PolicyAttrs == TAIL_AGNOSTIC)
             Ops.insert(Ops.begin(), llvm::PoisonValue::get(ResultType));
           IntrinsicTypes = {ResultType, Ops[3]->getType()};
         }
         Ops[1] = Builder.CreateBitCast(Ops[1], ResultType->getPointerTo());
         Value *NewVL = Ops[2];
         Ops.erase(Ops.begin() + 2);
         llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
         llvm::Value *LoadValue = Builder.CreateCall(F, Ops, "");
foreach type = TypeList in {
     {
       ResultType = ConvertType(E->getArg(0)->getType()->getPointeeType());
       IntrinsicTypes = {ResultType, Ops.back()->getType()};
       SmallVector<llvm::Value*, 10> Operands;
       if (IsMasked) {
         // TAMA builtin: (val0 address, ..., mask, ptr, vl)
         // builtin: (val0 address, ..., mask, maskedoff0, ..., ptr, vl)
         // intrinsic: (maskedoff0, ..., ptr, mask, vl)
-        if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC) {
+        if (PolicyAttrs == TAIL_AGNOSTIC_MASK_AGNOSTIC) {
           Operands.append(NF, llvm::PoisonValue::get(ResultType));
           Operands.push_back(Ops[NF + 1]);
           Operands.push_back(Ops[NF]);
           Operands.push_back(Ops[NF + 2]);
         } else {
           for (unsigned I = 0; I < NF; ++I)
             Operands.push_back(Ops[NF + I + 1]);
           Operands.push_back(Ops[2 * NF + 1]);
           Operands.push_back(Ops[NF]);
           Operands.push_back(Ops[2 * NF + 2]);
         }
-        Operands.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
+        Operands.push_back(ConstantInt::get(Ops.back()->getType(), PolicyAttrs));
         assert(Operands.size() == NF + 4);
       } else {
         // TA builtin: (val0 address, val1 address, ..., ptr, vl)
         // TU builtin: (val0 address, ..., passthru0, ..., ptr, vl)
         // intrinsic: (passthru0, passthru1, ..., ptr, vl)
-        if (DefaultPolicy == TAIL_AGNOSTIC) {
+        if (PolicyAttrs == TAIL_AGNOSTIC) {
           Operands.append(NF, llvm::PoisonValue::get(ResultType));
           Operands.push_back(Ops[NF]);
           Operands.push_back(Ops[NF + 1]);
         } else {
           for (unsigned I = 0; I < NF; ++I)
             Operands.push_back(Ops[NF + I]);
           Operands.push_back(Ops[2 * NF]);
           Operands.push_back(Ops[2 * NF + 1]);
defvar eew = !cond(!eq(type, "c") : "8",
       IntrinsicTypes = {ResultType, Ops.back()->getType()};
       SmallVector<llvm::Value*, 12> Operands;
       Value *NewVL;
 
       if (IsMasked) {
         // TAMA builtin: (val0 address, ..., mask, ptr, new_vl, vl)
         // builtin: (val0 address, ..., mask, maskedoff0, ..., ptr, new_vl, vl)
         // intrinsic: (maskedoff0, ..., ptr, mask, vl)
-        if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC) {
+        if (PolicyAttrs == TAIL_AGNOSTIC_MASK_AGNOSTIC) {
           Operands.append(NF, llvm::PoisonValue::get(ResultType));
           Operands.push_back(Ops[NF + 1]);
           Operands.push_back(Ops[NF]);
           Operands.push_back(Ops[NF + 3]);
           NewVL = Ops[NF + 2];
         } else {
           for (unsigned I = 0; I < NF; ++I)
             Operands.push_back(Ops[NF + I + 1]);
           Operands.push_back(Ops[2 * NF + 1]);
           Operands.push_back(Ops[NF]);
           Operands.push_back(Ops[2 * NF + 3]);
           NewVL = Ops[2 * NF + 2];
         }
-        Operands.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
+        Operands.push_back(ConstantInt::get(Ops.back()->getType(), PolicyAttrs));
         assert(Operands.size() == NF + 4);
       } else {
         // TA builtin: (val0 address, val1 address, ..., ptr, new_vl, vl)
         // TU builtin: (val0 address, ..., passthru0, ..., ptr, new_vl, vl)
         // intrinsic: (passthru0, passthru1, ..., ptr, vl)
-        if (DefaultPolicy == TAIL_AGNOSTIC) {
+        if (PolicyAttrs == TAIL_AGNOSTIC) {
           Operands.append(NF, llvm::PoisonValue::get(ResultType));
           Operands.push_back(Ops[NF]);
           Operands.push_back(Ops[NF + 2]);
           NewVL = Ops[NF + 1];
         } else {
           for (unsigned I = 0; I < NF; ++I)
             Operands.push_back(Ops[NF + I]);
           Operands.push_back(Ops[2 * NF]);
defvar eew = !cond(!eq(type, "c") : "8",
       ResultType = ConvertType(E->getArg(0)->getType()->getPointeeType());
       IntrinsicTypes = {ResultType, Ops.back()->getType()};
       SmallVector<llvm::Value*, 12> Operands;
 
       if (IsMasked) {
         // TAMA builtin: (val0 address, ..., mask, ptr, stride, vl)
         // builtin: (val0 address, ..., mask, maskedoff0, ..., ptr, stride, vl)
         // intrinsic: (maskedoff0, ..., ptr, stride, mask, vl)
-        if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC) {
+        if (PolicyAttrs == TAIL_AGNOSTIC_MASK_AGNOSTIC) {
           Operands.append(NF, llvm::PoisonValue::get(ResultType));
           Operands.push_back(Ops[NF + 1]);
           Operands.push_back(Ops[NF + 2]);
           Operands.push_back(Ops[NF]);
           Operands.push_back(Ops[NF + 3]);
         } else {
           for (unsigned I = 0; I < NF; ++I)
             Operands.push_back(Ops[NF + I + 1]);
           Operands.push_back(Ops[2 * NF + 1]);
           Operands.push_back(Ops[2 * NF + 2]);
           Operands.push_back(Ops[NF]);
           Operands.push_back(Ops[2 * NF + 3]);
         }
-        Operands.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
+        Operands.push_back(ConstantInt::get(Ops.back()->getType(), PolicyAttrs));
         assert(Operands.size() == NF + 5);
       } else {
         // TA builtin: (val0 address, val1 address, ..., ptr, stride, vl)
         // TU builtin: (val0 address, ..., passthru0, ..., ptr, stride, vl)
         // intrinsic: (passthru0, passthru1, ..., ptr, stride, vl)
-        if (DefaultPolicy == TAIL_AGNOSTIC) {
+        if (PolicyAttrs == TAIL_AGNOSTIC) {
           Operands.append(NF, llvm::PoisonValue::get(ResultType));
           Operands.push_back(Ops[NF]);
           Operands.push_back(Ops[NF + 1]);
           Operands.push_back(Ops[NF + 2]);
         } else {
           for (unsigned I = 0; I < NF; ++I)
             Operands.push_back(Ops[NF + I]);
           Operands.push_back(Ops[2 * NF]);
foreach eew_info = EEWList in {
             ManualCodegen = [{
     {
       ResultType = ConvertType(E->getArg(0)->getType()->getPointeeType());
       SmallVector<llvm::Value*, 12> Operands;
       if (IsMasked) {
         // TAMA builtin: (val0 address, ..., mask, ptr, index, vl)
         // builtin: (val0 address, ..., mask, maskedoff0, ..., ptr, index, vl)
         // intrinsic: (maskedoff0, ..., ptr, index, mask, vl)
-        if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC) {
+        if (PolicyAttrs == TAIL_AGNOSTIC_MASK_AGNOSTIC) {
           Operands.append(NF, llvm::PoisonValue::get(ResultType));
           Operands.push_back(Ops[NF + 1]);
           Operands.push_back(Ops[NF + 2]);
           Operands.push_back(Ops[NF]);
           Operands.push_back(Ops[NF + 3]);
           IntrinsicTypes = {ResultType, Ops[NF + 2]->getType(), Ops.back()->getType()};
         } else {
           for (unsigned I = 0; I < NF; ++I)
             Operands.push_back(Ops[NF + I + 1]);
           Operands.push_back(Ops[2 * NF + 1]);
           Operands.push_back(Ops[2 * NF + 2]);
           Operands.push_back(Ops[NF]);
           Operands.push_back(Ops[2 * NF + 3]);
           IntrinsicTypes = {ResultType, Ops[2 * NF + 2]->getType(), Ops.back()->getType()};
         }
-        Operands.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
+        Operands.push_back(ConstantInt::get(Ops.back()->getType(), PolicyAttrs));
         assert(Operands.size() == NF + 5);
       } else {
         // TA builtin: (val0 address, val1 address, ..., ptr, index, vl)
         // TU builtin: (val0 address, ..., passthru0, ..., ptr, index, vl)
         // intrinsic: (passthru0, passthru1, ..., ptr, index, vl)
-        if (DefaultPolicy == TAIL_AGNOSTIC) {
+        if (PolicyAttrs == TAIL_AGNOSTIC) {
           Operands.append(NF, llvm::PoisonValue::get(ResultType));
           Operands.push_back(Ops[NF]);
           Operands.push_back(Ops[NF + 1]);
           Operands.push_back(Ops[NF + 2]);
           IntrinsicTypes = {ResultType, Ops[NF + 1]->getType(), Ops.back()->getType()};
         } else {
           for (unsigned I = 0; I < NF; ++I)
             Operands.push_back(Ops[NF + I]);
multiclass RVVPseudoUnaryBuiltin<string IR, string type_range> {
   let Name = NAME,
       IRName = IR,
       MaskedIRName = IR # "_mask",
       UnMaskedPolicyScheme = HasPassthruOperand,
       ManualCodegen = [{
       {
         if (IsMasked) {
           std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
-          if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC)
+          if (PolicyAttrs == TAIL_AGNOSTIC_MASK_AGNOSTIC)
             Ops.insert(Ops.begin(), llvm::PoisonValue::get(ResultType));
         } else {
-          if (DefaultPolicy == TAIL_AGNOSTIC)
+          if (PolicyAttrs == TAIL_AGNOSTIC)
             Ops.insert(Ops.begin(), llvm::PoisonValue::get(ResultType));
         }
         auto ElemTy = cast<llvm::VectorType>(ResultType)->getElementType();
         Ops.insert(Ops.begin() + 2, llvm::Constant::getNullValue(ElemTy));
 
         if (IsMasked) {
-          Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
+          Ops.push_back(ConstantInt::get(Ops.back()->getType(), PolicyAttrs));
           // maskedoff, op1, op2, mask, vl, policy
           IntrinsicTypes = {ResultType, ElemTy, Ops[4]->getType()};
         } else {
           // passthru, op1, op2, vl
           IntrinsicTypes = {ResultType, ElemTy, Ops[3]->getType()};
         }
         break;
       }
       }] in {
         def : RVVBuiltin<"v", "vv", type_range>;
   }
 }
 
 multiclass RVVPseudoVNotBuiltin<string IR, string type_range> {
   let Name = NAME,
       IRName = IR,
       MaskedIRName = IR # "_mask",
       UnMaskedPolicyScheme = HasPassthruOperand,
       ManualCodegen = [{
       {
         if (IsMasked) {
           std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
-          if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC)
+          if (PolicyAttrs == TAIL_AGNOSTIC_MASK_AGNOSTIC)
             Ops.insert(Ops.begin(), llvm::PoisonValue::get(ResultType));
         } else {
-          if (DefaultPolicy == TAIL_AGNOSTIC)
+          if (PolicyAttrs == TAIL_AGNOSTIC)
             Ops.insert(Ops.begin(), llvm::PoisonValue::get(ResultType));
         }
         auto ElemTy = cast<llvm::VectorType>(ResultType)->getElementType();
         Ops.insert(Ops.begin() + 2,
                    llvm::Constant::getAllOnesValue(ElemTy));
         if (IsMasked) {
-          Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
+          Ops.push_back(ConstantInt::get(Ops.back()->getType(), PolicyAttrs));
           // maskedoff, op1, po2, mask, vl, policy
           IntrinsicTypes = {ResultType,
                             ElemTy,
                             Ops[4]->getType()};
         } else {
           // passthru, op1, op2, vl
           IntrinsicTypes = {ResultType,
                             ElemTy,
multiclass RVVPseudoVFUnaryBuiltin<string IR, string type_range> {
   let Name = NAME,
       IRName = IR,
       MaskedIRName = IR # "_mask",
       UnMaskedPolicyScheme = HasPassthruOperand,
       ManualCodegen = [{
       {
         if (IsMasked) {
           std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
-          if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC)
+          if (PolicyAttrs == TAIL_AGNOSTIC_MASK_AGNOSTIC)
             Ops.insert(Ops.begin(), llvm::PoisonValue::get(ResultType));
           Ops.insert(Ops.begin() + 2, Ops[1]);
-          Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
+          Ops.push_back(ConstantInt::get(Ops.back()->getType(), PolicyAttrs));
           // maskedoff, op1, op2, mask, vl
           IntrinsicTypes = {ResultType,
                             Ops[2]->getType(),
                             Ops.back()->getType()};
         } else {
-          if (DefaultPolicy == TAIL_AGNOSTIC)
+          if (PolicyAttrs == TAIL_AGNOSTIC)
             Ops.insert(Ops.begin(), llvm::PoisonValue::get(ResultType));
           // op1, po2, vl
           IntrinsicTypes = {ResultType,
                             Ops[1]->getType(), Ops[2]->getType()};
           Ops.insert(Ops.begin() + 2, Ops[1]);
           break;
         }
         break;
let Name = NAME,
       OverloadedName = MName,
       IRName = IR,
       MaskedIRName = IR # "_mask",
       UnMaskedPolicyScheme = HasPassthruOperand,
       ManualCodegen = [{
       {
         if (IsMasked) {
           std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
-          if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC)
+          if (PolicyAttrs == TAIL_AGNOSTIC_MASK_AGNOSTIC)
             Ops.insert(Ops.begin(), llvm::PoisonValue::get(ResultType));
         } else {
-          if (DefaultPolicy == TAIL_AGNOSTIC)
+          if (PolicyAttrs == TAIL_AGNOSTIC)
             Ops.insert(Ops.begin(), llvm::PoisonValue::get(ResultType));
         }
         auto ElemTy = cast<llvm::VectorType>(ResultType)->getElementType();
         Ops.insert(Ops.begin() + 2, llvm::Constant::getNullValue(ElemTy));
         if (IsMasked) {
-          Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
+          Ops.push_back(ConstantInt::get(Ops.back()->getType(), PolicyAttrs));
           // maskedoff, op1, op2, mask, vl, policy
           IntrinsicTypes = {ResultType,
                             Ops[1]->getType(),
                             ElemTy,
                             Ops[4]->getType()};
         } else {
           // passtru, op1, op2, vl
           IntrinsicTypes = {ResultType,
let Name = NAME,
       OverloadedName = MName,
       IRName = IR,
       MaskedIRName = IR # "_mask",
       UnMaskedPolicyScheme = HasPassthruOperand,
       ManualCodegen = [{
       {
         if (IsMasked) {
           std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
-          if (DefaultPolicy == TAIL_AGNOSTIC_MASK_AGNOSTIC)
+          if (PolicyAttrs == TAIL_AGNOSTIC_MASK_AGNOSTIC)
             Ops.insert(Ops.begin(), llvm::PoisonValue::get(ResultType));
         } else {
-          if (DefaultPolicy == TAIL_AGNOSTIC)
+          if (PolicyAttrs == TAIL_AGNOSTIC)
             Ops.insert(Ops.begin(), llvm::PoisonValue::get(ResultType));
         }
         Ops.insert(Ops.begin() + 2, llvm::Constant::getNullValue(Ops.back()->getType())); 
         if (IsMasked) {
-          Ops.push_back(ConstantInt::get(Ops.back()->getType(), DefaultPolicy));
+          Ops.push_back(ConstantInt::get(Ops.back()->getType(), PolicyAttrs));
           // maskedoff, op1, xlen, mask, vl
           IntrinsicTypes = {ResultType,
                             Ops[1]->getType(),
                             Ops[4]->getType(),
                             Ops[4]->getType()};
         } else {
           // passthru, op1, xlen, vl
           IntrinsicTypes = {ResultType,

 // 12.15. Vector Integer Merge Instructions
 // C/C++ Operand: (mask, op1, op2, vl), Intrinsic: (passthru, op1, op2, mask, vl)
 let HasMasked = false,
     UnMaskedPolicyScheme = HasPassthruOperandAtIdx1,
     MaskedPolicyScheme = NonePolicy,
     ManualCodegen = [{
       std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
       // insert poison passthru
-      if (DefaultPolicy == TAIL_AGNOSTIC)
+      if (PolicyAttrs == TAIL_AGNOSTIC)
         Ops.insert(Ops.begin(), llvm::PoisonValue::get(ResultType));
       IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
     }] in {
   defm vmerge : RVVOutOp1BuiltinSet<"vmerge", "csil",
                                     [["vvm", "v", "vmvv"],
                                      ["vxm", "v", "vmve"],
                                      ["vvm", "Uv", "UvmUvUv"],
                                      ["vxm", "Uv", "UvmUvUe"]]>;

 // 14.15. Vector Floating-Point Merge Instructio
 // C/C++ Operand: (mask, op1, op2, vl), Builtin: (op1, op2, mask, vl)
 let HasMasked = false,
     UnMaskedPolicyScheme = HasPassthruOperandAtIdx1,
     MaskedPolicyScheme = NonePolicy,
     ManualCodegen = [{
       std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
       // insert poison passthru
-      if (DefaultPolicy == TAIL_AGNOSTIC)
+      if (PolicyAttrs == TAIL_AGNOSTIC)
         Ops.insert(Ops.begin(), llvm::PoisonValue::get(ResultType));
       IntrinsicTypes = {ResultType, Ops[2]->getType(), Ops.back()->getType()};
     }] in {
   defm vmerge : RVVOutOp1BuiltinSet<"vmerge", "xfd",
                                     [["vvm", "v", "vmvv"]]>;
   defm vfmerge : RVVOutOp1BuiltinSet<"vfmerge", "xfd",
                                     [["vfm", "v", "vmve"]]>;
 }

 // 17.5. Vector Compress Instruction
 let IsPrototypeDefaultTU = true,
     HasMasked = false,
     UnMaskedPolicyScheme = HasPassthruOperandAtIdx1,
     MaskedPolicyScheme = NonePolicy,
     ManualCodegen = [{
       std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);
       // insert poison passthru
-      if (DefaultPolicy == TAIL_AGNOSTIC)
+      if (PolicyAttrs == TAIL_AGNOSTIC)
         Ops.insert(Ops.begin(), llvm::PoisonValue::get(ResultType));
       IntrinsicTypes = {ResultType, Ops.back()->getType()};
     }] in {
   // signed and floating type
   defm vcompress : RVVOutBuiltinSet<"vcompress", "csilxfd",
                                     [["vm", "v", "vmvv"]]>;
   // unsigned type
   defm vcompress : RVVOutBuiltinSet<"vcompress", "csil",

clang/include/clang/Support/RISCVVIntrinsicUtils.h

private:
   bool HasBuiltinAlias;
   std::string ManualCodegen;
   RVVTypePtr OutputType; // Builtin output type
   RVVTypes InputTypes;   // Builtin input types
   // The types we use to obtain the specific LLVM intrinsic. They are index of
   // InputTypes. -1 means the return type.
   std::vector<int64_t> IntrinsicTypes;
   unsigned NF = 1;
-  Policy DefaultPolicy;
+  Policy PolicyAttrs;
 
 public:
   RVVIntrinsic(llvm::StringRef Name, llvm::StringRef Suffix,
                llvm::StringRef OverloadedName, llvm::StringRef OverloadedSuffix,
                llvm::StringRef IRName, bool IsMasked, bool HasMaskedOffOperand,
                bool HasVL, PolicyScheme Scheme, bool SupportOverloading,
                bool HasBuiltinAlias, llvm::StringRef ManualCodegen,
                const RVVTypes &Types,
                const std::vector<int64_t> &IntrinsicTypes,
                const std::vector<llvm::StringRef> &RequiredFeatures,
-               unsigned NF, Policy DefaultPolicy, bool IsPrototypeDefaultTU);
+               unsigned NF, Policy PolicyAttrs, bool IsPrototypeDefaultTU);
   ~RVVIntrinsic() = default;
 
   RVVTypePtr getOutputType() const { return OutputType; }
   const RVVTypes &getInputTypes() const { return InputTypes; }
   llvm::StringRef getBuiltinName() const { return BuiltinName; }
   llvm::StringRef getName() const { return Name; }
   llvm::StringRef getOverloadedName() const { return OverloadedName; }
   bool hasMaskedOffOperand() const { return HasMaskedOffOperand; }
public:
   bool isMasked() const { return IsMasked; }
   llvm::StringRef getIRName() const { return IRName; }
   llvm::StringRef getManualCodegen() const { return ManualCodegen; }
   PolicyScheme getPolicyScheme() const { return Scheme; }
   unsigned getNF() const { return NF; }
   const std::vector<int64_t> &getIntrinsicTypes() const {
     return IntrinsicTypes;
   }
-  Policy getDefaultPolicy() const {
-    assert(DefaultPolicy.PolicyNone == false);
-    return DefaultPolicy;
+  Policy getPolicyAttrs() const {
+    assert(PolicyAttrs.PolicyNone == false);
+    return PolicyAttrs;
   }
-  unsigned getDefaultPolicyBits() const {
+  unsigned getPolicyAttrsBits() const {
     // Return following value.
     // constexpr unsigned TAIL_UNDISTURBED = 0;
     // constexpr unsigned TAIL_AGNOSTIC = 1;
     // constexpr unsigned TAIL_AGNOSTIC_MASK_AGNOSTIC = 3;
     // FIXME: how about value 2
-    // int DefaultPolicy = TAIL_UNDISTURBED;
-    assert(DefaultPolicy.PolicyNone == false);
+    // int PolicyAttrs = TAIL_UNDISTURBED;
+    assert(PolicyAttrs.PolicyNone == false);
 
-    if (DefaultPolicy.isTUMAPolicy())
+    if (PolicyAttrs.isTUMAPolicy())
       return 2;
-    if (DefaultPolicy.isTAMAPolicy())
+    if (PolicyAttrs.isTAMAPolicy())
       return 3;
-    if (DefaultPolicy.isTUMUPolicy())
+    if (PolicyAttrs.isTUMUPolicy())
       return 0;
-    if (DefaultPolicy.isTAMUPolicy())
+    if (PolicyAttrs.isTAMUPolicy())
       return 1;
-    if (DefaultPolicy.isTUPolicy())
+    if (PolicyAttrs.isTUPolicy())
       return 0;
-    if (DefaultPolicy.isTAPolicy())
+    if (PolicyAttrs.isTAPolicy())
       return 1;
 
     llvm_unreachable("unsupport policy");
     return 0;
   }
 
   // Return the type string for a BUILTIN() macro in Builtins.def.
   std::string getBuiltinTypeStr() const;
 
   static std::string
   getSuffixStr(RVVTypeCache &TypeCache, BasicType Type, int Log2LMUL,
                llvm::ArrayRef<PrototypeDescriptor> PrototypeDescriptors);
 
   static llvm::SmallVector<PrototypeDescriptor>
-      computeBuiltinTypes(llvm::ArrayRef<PrototypeDescriptor> Prototype,
-                          bool IsMasked, bool HasMaskedOffOperand, bool HasVL,
-                          unsigned NF, bool IsPrototypeDefaultTU,
-                          PolicyScheme DefaultScheme,
-                          Policy DefaultPolicy);
+                      PolicyScheme DefaultScheme, Policy PolicyAttrs);
   static llvm::SmallVector<Policy>
       getSupportedMaskedPolicies(bool HasTailPolicy, bool HasMaskPolicy);
 
   static void updateNamesAndPolicy(bool IsMasked, bool HasPolicy,
                                    bool IsPrototypeDefaultTU, std::string &Name,
                                    std::string &BuiltinName,
                                    std::string &OverloadedName,
-                                   Policy &DefaultPolicy);
+                                   Policy &PolicyAttrs);
 };
 
 // RVVRequire should be sync'ed with target features, but only
 // required features used in riscv_vector.td.
 enum RVVRequire : uint8_t {
   RVV_REQ_None = 0,
   RVV_REQ_RV64 = 1 << 0,
   RVV_REQ_FullMultiply = 1 << 1,

clang/lib/CodeGen/CGBuiltin.cpp

Ops.push_back(llvm::ConstantInt::get(
         getLLVMContext(), *E->getArg(i)->getIntegerConstantExpr(getContext())));
   }
 
   Intrinsic::ID ID = Intrinsic::not_intrinsic;
   unsigned NF = 1;
   constexpr unsigned TAIL_UNDISTURBED = 0;
   constexpr unsigned TAIL_AGNOSTIC = 1;
   constexpr unsigned TAIL_AGNOSTIC_MASK_AGNOSTIC = 3;
-  int DefaultPolicy = TAIL_UNDISTURBED;
+  int PolicyAttrs = TAIL_UNDISTURBED;
   bool IsMasked = false;
 
   // Required for overloaded intrinsics.
   llvm::SmallVector<llvm::Type *, 2> IntrinsicTypes;
   switch (BuiltinID) {
   default: llvm_unreachable("unexpected builtin ID");
   case RISCV::BI__builtin_riscv_orc_b_32:
   case RISCV::BI__builtin_riscv_orc_b_64:

clang/lib/Sema/SemaRISCVVectorLookup.cpp

private:
   StringMap<RVVOverloadIntrinsicDef> OverloadIntrinsics;
 
   // Create IntrinsicList
   void InitIntrinsicList();
 
   // Create RVVIntrinsicDef.
   void InitRVVIntrinsic(const RVVIntrinsicRecord &Record, StringRef SuffixStr,
                         StringRef OverloadedSuffixStr, bool IsMask,
-                        RVVTypes &Types, bool HasPolicy, Policy DefaultPolicy,
+                        RVVTypes &Types, bool HasPolicy, Policy PolicyAttrs,
                         bool IsPrototypeDefaultTU);
 
   // Create FunctionDecl for a vector intrinsic.
   void CreateRVVIntrinsicDecl(LookupResult &LR, IdentifierInfo *II,
                               Preprocessor &PP, unsigned Index,
                               bool IsOverload);
 
 public:
for (auto &Record : RVVIntrinsicRecords) {
     } // End for different TypeRange
   }
 }
 
 // Compute name and signatures for intrinsic with practical types.
 void RISCVIntrinsicManagerImpl::InitRVVIntrinsic(
     const RVVIntrinsicRecord &Record, StringRef SuffixStr,
     StringRef OverloadedSuffixStr, bool IsMasked, RVVTypes &Signature,
-    bool HasPolicy, Policy DefaultPolicy, bool IsPrototypeDefaultTU) {
+    bool HasPolicy, Policy PolicyAttrs, bool IsPrototypeDefaultTU) {
   // Function name, e.g. vadd_vv_i32m1.
   std::string Name = Record.Name;
   if (!SuffixStr.empty())
     Name += "_" + SuffixStr.str();
 
   // Overloaded function name, e.g. vadd.
   std::string OverloadedName;
   if (!Record.OverloadedName)
     OverloadedName = StringRef(Record.Name).split("_").first.str();
   else
     OverloadedName = Record.OverloadedName;
   if (!OverloadedSuffixStr.empty())
     OverloadedName += "_" + OverloadedSuffixStr.str();
 
   // clang built-in function name, e.g. __builtin_rvv_vadd.
   std::string BuiltinName = "__builtin_rvv_" + std::string(Record.Name);
 
   RVVIntrinsic::updateNamesAndPolicy(IsMasked, HasPolicy, IsPrototypeDefaultTU,
                                      Name, BuiltinName, OverloadedName,
-                                     DefaultPolicy);
+                                     PolicyAttrs);
 
   // Put into IntrinsicList.
   size_t Index = IntrinsicList.size();
   IntrinsicList.push_back({Name, OverloadedName, BuiltinName, Signature});
 
   // Creating mapping to Intrinsics.
   Intrinsics.insert({Name, Index});
 

clang/lib/Support/RISCVVIntrinsicUtils.cpp

 //===----------------------------------------------------------------------===//
 RVVIntrinsic::RVVIntrinsic(
     StringRef NewName, StringRef Suffix, StringRef NewOverloadedName,
     StringRef OverloadedSuffix, StringRef IRName, bool IsMasked,
     bool HasMaskedOffOperand, bool HasVL, PolicyScheme Scheme,
     bool SupportOverloading, bool HasBuiltinAlias, StringRef ManualCodegen,
     const RVVTypes &OutInTypes, const std::vector<int64_t> &NewIntrinsicTypes,
     const std::vector<StringRef> &RequiredFeatures, unsigned NF,
-    Policy NewDefaultPolicy, bool IsPrototypeDefaultTU)
+    Policy NewPolicyAttrs, bool IsPrototypeDefaultTU)
     : IRName(IRName), IsMasked(IsMasked),
       HasMaskedOffOperand(HasMaskedOffOperand), HasVL(HasVL), Scheme(Scheme),
       SupportOverloading(SupportOverloading), HasBuiltinAlias(HasBuiltinAlias),
-      ManualCodegen(ManualCodegen.str()), NF(NF),
-      DefaultPolicy(NewDefaultPolicy) {
+      ManualCodegen(ManualCodegen.str()), NF(NF), PolicyAttrs(NewPolicyAttrs) {
 
   // Init BuiltinName, Name and OverloadedName
   BuiltinName = NewName.str();
   Name = BuiltinName;
   if (NewOverloadedName.empty())
     OverloadedName = NewName.split("_").first.str();
   else
     OverloadedName = NewOverloadedName.str();
   if (!Suffix.empty())
     Name += "_" + Suffix.str();
   if (!OverloadedSuffix.empty())
     OverloadedName += "_" + OverloadedSuffix.str();
 
   updateNamesAndPolicy(IsMasked, hasPolicy(), IsPrototypeDefaultTU, Name,
-                       BuiltinName, OverloadedName, DefaultPolicy);
+                       BuiltinName, OverloadedName, PolicyAttrs);
 
   // Init OutputType and InputTypes
   OutputType = OutInTypes[0];
   InputTypes.assign(OutInTypes.begin() + 1, OutInTypes.end());
 
   // IntrinsicTypes is unmasked TA version index. Need to update it
   // if there is merge operand (It is always in first operand).
   IntrinsicTypes = NewIntrinsicTypes;
for (auto PD : PrototypeDescriptors) {
     SuffixStrs.push_back((*T)->getShortStr());
   }
   return join(SuffixStrs, "_");
 }
 
 llvm::SmallVector<PrototypeDescriptor> RVVIntrinsic::computeBuiltinTypes(
     llvm::ArrayRef<PrototypeDescriptor> Prototype, bool IsMasked,
     bool HasMaskedOffOperand, bool HasVL, unsigned NF,
-    bool IsPrototypeDefaultTU, PolicyScheme DefaultScheme,
-    Policy DefaultPolicy) {
+    bool IsPrototypeDefaultTU, PolicyScheme DefaultScheme, Policy PolicyAttrs) {
   SmallVector<PrototypeDescriptor> NewPrototype(Prototype.begin(),
                                                 Prototype.end());
-  // Update DefaultPolicy if need (TA or TAMA) for compute builtin types.
-  if (DefaultPolicy.isMAPolicy())
-    DefaultPolicy.TailPolicy = Policy::PolicyType::Agnostic; // TAMA
-  if (DefaultPolicy.isPolicyNonePolicy()) {
+  // Update PolicyAttrs if need (TA or TAMA) for compute builtin types.
+  if (PolicyAttrs.isMAPolicy())
+    PolicyAttrs.TailPolicy = Policy::PolicyType::Agnostic; // TAMA
+  if (PolicyAttrs.isPolicyNonePolicy()) {
     if (!IsMasked) {
-      DefaultPolicy.PolicyNone = false;
+      PolicyAttrs.PolicyNone = false;
       if (IsPrototypeDefaultTU)
-        DefaultPolicy.TailPolicy = Policy::PolicyType::Undisturbed; // TU
+        PolicyAttrs.TailPolicy = Policy::PolicyType::Undisturbed; // TU
       else
-        DefaultPolicy.TailPolicy = Policy::PolicyType::Agnostic; // TA
+        PolicyAttrs.TailPolicy = Policy::PolicyType::Agnostic; // TA
     }
   }
   bool HasPassthruOp = DefaultScheme == PolicyScheme::HasPassthruOperand;
   if (IsMasked) {
     // If HasMaskedOffOperand, insert result type as first input operand if
     // need.
-    if (HasMaskedOffOperand && !DefaultPolicy.isTAMAPolicy()) {
+    if (HasMaskedOffOperand && !PolicyAttrs.isTAMAPolicy()) {
       if (NF == 1) {
         NewPrototype.insert(NewPrototype.begin() + 1, NewPrototype[0]);
       } else if (NF > 1) {
         // Convert
         // (void, op0 address, op1 address, ...)
         // to
         // (void, op0 address, op1 address, ..., maskedoff0, maskedoff1, ...)
         PrototypeDescriptor MaskoffType = NewPrototype[1];
         MaskoffType.TM &= ~static_cast<uint8_t>(TypeModifier::Pointer);
         NewPrototype.insert(NewPrototype.begin() + NF + 1, NF, MaskoffType);
       }
     }
     // Erase passthru operand for TAM
-    if (NF == 1 && IsPrototypeDefaultTU && DefaultPolicy.isTAMAPolicy() &&
+    if (NF == 1 && IsPrototypeDefaultTU && PolicyAttrs.isTAMAPolicy() &&
         HasPassthruOp && !HasMaskedOffOperand)
       NewPrototype.erase(NewPrototype.begin() + 1);
     if (HasMaskedOffOperand && NF > 1) {
       // Convert
       // (void, op0 address, op1 address, ..., maskedoff0, maskedoff1, ...)
       // to
       // (void, op0 address, op1 address, ..., mask, maskedoff0, maskedoff1,
       // ...)
       NewPrototype.insert(NewPrototype.begin() + NF + 1,
                           PrototypeDescriptor::Mask);
     } else {
       // If IsMasked, insert PrototypeDescriptor:Mask as first input operand.
       NewPrototype.insert(NewPrototype.begin() + 1, PrototypeDescriptor::Mask);
     }
   } else {
     if (NF == 1) {
-      if (DefaultPolicy.isTUPolicy() && HasPassthruOp && !IsPrototypeDefaultTU)
+      if (PolicyAttrs.isTUPolicy() && HasPassthruOp && !IsPrototypeDefaultTU)
         NewPrototype.insert(NewPrototype.begin(), NewPrototype[0]);
-      else if (DefaultPolicy.isTAPolicy() && HasPassthruOp &&
+      else if (PolicyAttrs.isTAPolicy() && HasPassthruOp &&
                IsPrototypeDefaultTU)
         NewPrototype.erase(NewPrototype.begin() + 1);
       if (DefaultScheme == PolicyScheme::HasPassthruOperandAtIdx1) {
-        if (DefaultPolicy.isTUPolicy() && !IsPrototypeDefaultTU) {
+        if (PolicyAttrs.isTUPolicy() && !IsPrototypeDefaultTU) {
           // Insert undisturbed output to index 1
           NewPrototype.insert(NewPrototype.begin() + 2, NewPrototype[0]);
-        } else if (DefaultPolicy.isTAPolicy() && IsPrototypeDefaultTU) {
+        } else if (PolicyAttrs.isTAPolicy() && IsPrototypeDefaultTU) {
           // Erase passthru for TA policy
           NewPrototype.erase(NewPrototype.begin() + 2);
         }
       }
-    } else if (DefaultPolicy.isTUPolicy() && HasPassthruOp) {
+    } else if (PolicyAttrs.isTUPolicy() && HasPassthruOp) {
       // NF > 1 cases for segment load operations.
       // Convert
       // (void, op0 address, op1 address, ...)
       // to
       // (void, op0 address, op1 address, maskedoff0, maskedoff1, ...)
       PrototypeDescriptor MaskoffType = Prototype[1];
       MaskoffType.TM &= ~static_cast<uint8_t>(TypeModifier::Pointer);
       NewPrototype.insert(NewPrototype.begin() + NF + 1, NF, MaskoffType);
return {
       Policy(Policy::PolicyType::Omit, Policy::PolicyType::Undisturbed)}; // MU
 }
 
 void RVVIntrinsic::updateNamesAndPolicy(bool IsMasked, bool HasPolicy,
                                         bool IsPrototypeDefaultTU,
                                         std::string &Name,
                                         std::string &BuiltinName,
                                         std::string &OverloadedName,
-                                        Policy &DefaultPolicy) {
+                                        Policy &PolicyAttrs) {
 
   auto appendPolicySuffix = [&](const std::string &suffix) {
     Name += suffix;
     BuiltinName += suffix;
     OverloadedName += suffix;
   };
 
-  if (DefaultPolicy.isPolicyNonePolicy()) {
-    DefaultPolicy.PolicyNone = false;
+  if (PolicyAttrs.isPolicyNonePolicy()) {
+    PolicyAttrs.PolicyNone = false;
     if (IsMasked) {
       Name += "_m";
       // FIXME: Currently _m default policy implementation is different with
       // RVV intrinsic spec (TUMA)
-      DefaultPolicy.TailPolicy = Policy::PolicyType::Undisturbed;
-      DefaultPolicy.MaskPolicy = Policy::PolicyType::Undisturbed;
+      PolicyAttrs.TailPolicy = Policy::PolicyType::Undisturbed;
+      PolicyAttrs.MaskPolicy = Policy::PolicyType::Undisturbed;
       if (HasPolicy)
         BuiltinName += "_tumu";
       else
         BuiltinName += "_m";
     } else if (IsPrototypeDefaultTU) {
-      DefaultPolicy.TailPolicy = Policy::PolicyType::Undisturbed;
+      PolicyAttrs.TailPolicy = Policy::PolicyType::Undisturbed;
       if (HasPolicy)
         BuiltinName += "_tu";
     } else {
-      DefaultPolicy.TailPolicy = Policy::PolicyType::Agnostic;
+      PolicyAttrs.TailPolicy = Policy::PolicyType::Agnostic;
       if (HasPolicy)
         BuiltinName += "_ta";
     }
   } else {
-    if (DefaultPolicy.isTUMPolicy())
+    if (PolicyAttrs.isTUMPolicy())
       appendPolicySuffix("_tum");
-    else if (DefaultPolicy.isTAMPolicy())
+    else if (PolicyAttrs.isTAMPolicy())
       appendPolicySuffix("_tam");
-    else if (DefaultPolicy.isTUMUPolicy())
+    else if (PolicyAttrs.isTUMUPolicy())
       appendPolicySuffix("_tumu");
-    else if (DefaultPolicy.isTAMUPolicy())
+    else if (PolicyAttrs.isTAMUPolicy())
       appendPolicySuffix("_tamu");
-    else if (DefaultPolicy.isTUMAPolicy())
+    else if (PolicyAttrs.isTUMAPolicy())
       appendPolicySuffix("_tuma");
-    else if (DefaultPolicy.isTAMAPolicy())
+    else if (PolicyAttrs.isTAMAPolicy())
       appendPolicySuffix("_tama");
-    else if (DefaultPolicy.isTUPolicy())
+    else if (PolicyAttrs.isTUPolicy())
       appendPolicySuffix("_tu");
-    else if (DefaultPolicy.isTAPolicy())
+    else if (PolicyAttrs.isTAPolicy())
       appendPolicySuffix("_ta");
-    else if (DefaultPolicy.isMUPolicy()) {
+    else if (PolicyAttrs.isMUPolicy()) {
       appendPolicySuffix("_mu");
-      DefaultPolicy.TailPolicy = Policy::PolicyType::Agnostic;
-    } else if (DefaultPolicy.isMAPolicy()) {
+      PolicyAttrs.TailPolicy = Policy::PolicyType::Agnostic;
+    } else if (PolicyAttrs.isMAPolicy()) {
       appendPolicySuffix("_ma");
-      DefaultPolicy.TailPolicy = Policy::PolicyType::Agnostic;
+      PolicyAttrs.TailPolicy = Policy::PolicyType::Agnostic;
     }
   }
 }
 
 SmallVector<PrototypeDescriptor> parsePrototypes(StringRef Prototypes) {
   SmallVector<PrototypeDescriptor> PrototypeDescriptors;
   const StringRef Primaries("evwqom0ztul");
   while (!Prototypes.empty()) {

clang/utils/TableGen/RISCVVEmitter.cpp

static BasicType ParseBasicType(char c) {
   }
 }
 
 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";
-  // We had initialized DefaultPolicy as TU/TUMU in CodeGen function.
-  if (!RVVI->getDefaultPolicy().isTUPolicy() &&
-      !RVVI->getDefaultPolicy().isTUMUPolicy() && !RVVI->hasPassthruOperand() &&
+  // We had initialized PolicyAttrs as TU/TUMU in CodeGen function.
+  if (!RVVI->getPolicyAttrs().isTUPolicy() &&
+      !RVVI->getPolicyAttrs().isTUMUPolicy() && !RVVI->hasPassthruOperand() &&
       !RVVI->hasManualCodegen() && RVVI->hasVL())
-    OS << "  DefaultPolicy = " << RVVI->getDefaultPolicyBits() << ";\n";
+    OS << "  PolicyAttrs = " << RVVI->getPolicyAttrsBits() << ";\n";
 
   if (RVVI->hasManualCodegen()) {
-    OS << "  DefaultPolicy = " << RVVI->getDefaultPolicyBits() << ";\n";
+    OS << "  PolicyAttrs = " << RVVI->getPolicyAttrsBits() << ";\n";
     if (RVVI->isMasked())
       OS << "IsMasked = true;\n";
     else
       OS << "IsMasked = false;\n";
     OS << RVVI->getManualCodegen();
     OS << "break;\n";
     return;
   }
 
   // Cast pointer operand of vector load intrinsic.
   for (const auto &I : enumerate(RVVI->getInputTypes())) {
     if (I.value()->isPointer()) {
       assert(RVVI->getIntrinsicTypes().front() == -1 &&
              "RVVI should be vector load intrinsic.");
       OS << "  Ops[" << I.index() << "] = Builder.CreateBitCast(Ops[";
       OS << I.index() << "], ResultType->getPointerTo());\n";
     }
   }
 
   if (RVVI->isMasked()) {
     if (RVVI->hasVL()) {
       OS << "  std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end() - 1);\n";
       if (RVVI->hasPolicyOperand())
         OS << "  Ops.push_back(ConstantInt::get(Ops.back()->getType(),"
-              " DefaultPolicy));\n";
-      if (RVVI->hasMaskedOffOperand() &&
-          RVVI->getDefaultPolicy().isTAMAPolicy())
+              " PolicyAttrs));\n";
+      if (RVVI->hasMaskedOffOperand() && RVVI->getPolicyAttrs().isTAMAPolicy())
         OS << "  Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));\n";
       // Masked reduction cases.
       if (!RVVI->hasMaskedOffOperand() && RVVI->hasPassthruOperand() &&
-          RVVI->getDefaultPolicy().isTAMAPolicy())
+          RVVI->getPolicyAttrs().isTAMAPolicy())
         OS << "  Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));\n";
     } else {
       OS << "  std::rotate(Ops.begin(), Ops.begin() + 1, Ops.end());\n";
     }
   } else {
     if (RVVI->hasPolicyOperand())
       OS << "  Ops.push_back(ConstantInt::get(Ops.back()->getType(), "
-            "DefaultPolicy));\n";
-    else if (RVVI->hasPassthruOperand() &&
-             RVVI->getDefaultPolicy().isTAPolicy())
+            "PolicyAttrs));\n";
+    else if (RVVI->hasPassthruOperand() && RVVI->getPolicyAttrs().isTAPolicy())
       OS << "  Ops.insert(Ops.begin(), llvm::UndefValue::get(ResultType));\n";
   }
 
   OS << "  IntrinsicTypes = {";
   ListSeparator LS;
   for (const auto &Idx : RVVI->getIntrinsicTypes()) {
     if (Idx == -1)
       OS << LS << "ResultType";

 
 void RVVEmitter::createCodeGen(raw_ostream &OS) {
   std::vector<std::unique_ptr<RVVIntrinsic>> Defs;
   createRVVIntrinsics(Defs);
   // IR name could be empty, use the stable sort preserves the relative order.
   llvm::stable_sort(Defs, [](const std::unique_ptr<RVVIntrinsic> &A,
                              const std::unique_ptr<RVVIntrinsic> &B) {
     if (A->getIRName() == B->getIRName())
-      return (A->getDefaultPolicy() < B->getDefaultPolicy());
+      return (A->getPolicyAttrs() < B->getPolicyAttrs());
     return (A->getIRName() < B->getIRName());
   });
 
   // Map to keep track of which builtin names have already been emitted.
   StringMap<RVVIntrinsic *> BuiltinMap;
 
   // Print switch body when the ir name, ManualCodegen or policy changes from
   // previous iteration.
   RVVIntrinsic *PrevDef = Defs.begin()->get();
   for (auto &Def : Defs) {
     StringRef CurIRName = Def->getIRName();
     if (CurIRName != PrevDef->getIRName() ||
         (Def->getManualCodegen() != PrevDef->getManualCodegen()) ||
-        (Def->getDefaultPolicy() != PrevDef->getDefaultPolicy())) {
+        (Def->getPolicyAttrs() != PrevDef->getPolicyAttrs())) {
       emitCodeGenSwitchBody(PrevDef, OS);
     }
     PrevDef = Def.get();
 
     auto P =
         BuiltinMap.insert(std::make_pair(Def->getBuiltinName(), Def.get()));
     if (P.second) {
       OS << "case RISCVVector::BI__builtin_rvv_" << Def->getBuiltinName()