[5/15][Clang][RISCV][NFC] Remove extra attribute Policy::IntrinsicWithoutMU by reusing HasTailPolicy and HasMaskPolicy

[eopXD]

Summary

Righteously there shouldn't be any special cases here because
HasTailPolicy and HasMaskPolicy is able to express necessary cases.
This commit is a part of the step-by-step effort to remove
Policy::Scheme::Omit, which completely does not make sense in RVV 1.0
because an RVV instruction always executes with vta and vma set
to a certain value.

This is the 5th commit of a patch-set that aims to change the default policy
for RVV intrinsics from TAMU to TAMA.

Please refer to the cover letter in the 1st commit (D141573) for an
overview.

[eopXD]

Rebase to latest main.

[kito-cheng]

clang/include/clang/Support/RISCVVIntrinsicUtils.h

398

Drop const for parameter, you don't need const qualifier for those primitive types on the parameter list.

480

Same here.

clang/lib/Sema/SemaRISCVVectorLookup.cpp

152

Ditto.

clang/lib/Support/RISCVVIntrinsicUtils.cpp

851

Ditto.

1015

Ditto.

[kito-cheng]

Wait, I fell HasTailPolicy and HasMaskPolicy should be part of Policy object, and then it's the Omit to present it's no policy.

[craig.topper]

LGTM

[craig.topper]

Oops I didn't mean to approve this with Kito's comments outstanding.

[eopXD]

Address comment from Kito.

[eopXD]

Update code.

[eopXD]

In D141754#4057829, @kito-cheng wrote:

Wait, I fell HasTailPolicy and HasMaskPolicy should be part of Policy object, and then it's the Omit to present it's no policy.

I think the simplification here https://reviews.llvm.org/D142016#inline-1372027 should resolve your concern.

[kito-cheng]

LGTM

[craig.topper]

LGTM

clang/include/clang/Support/RISCVVIntrinsicUtils.h

struct Policy {
   bool IsUnspecified = false;
   enum PolicyType {
     Undisturbed,
     Agnostic,
     Omit, // No policy required.
   };
   PolicyType TailPolicy = Omit;
   PolicyType MaskPolicy = Omit;
-  bool IntrinsicWithoutMU = false;
-  Policy() : IsUnspecified(true) {}
-  Policy(PolicyType _TailPolicy, PolicyType _MaskPolicy,
-         bool _IntrinsicWithoutMU = false)
-      : TailPolicy(_TailPolicy), MaskPolicy(_MaskPolicy),
-        IntrinsicWithoutMU(_IntrinsicWithoutMU) {}
+  bool HasTailPolicy, HasMaskPolicy;
+  Policy(bool HasTailPolicy, bool HasMaskPolicy)
+      : IsUnspecified(true), HasTailPolicy(HasTailPolicy),
+        HasMaskPolicy(HasMaskPolicy) {}
+  Policy(PolicyType TailPolicy, PolicyType MaskPolicy, bool HasTailPolicy,
+         bool HasMaskPolicy)
+      : TailPolicy(TailPolicy), MaskPolicy(MaskPolicy),
+        HasTailPolicy(HasTailPolicy), HasMaskPolicy(HasMaskPolicy) {}
 
   bool isTAMAPolicy() const {
     return TailPolicy == Agnostic && MaskPolicy == Agnostic;
   }
 
   bool isTAMUPolicy() const {
     return TailPolicy == Agnostic && MaskPolicy == Undisturbed;
   }
 
   bool isTUMAPolicy() const {
     return TailPolicy == Undisturbed && MaskPolicy == Agnostic;
   }
 
   bool isTUMUPolicy() const {
     return TailPolicy == Undisturbed && MaskPolicy == Undisturbed;
   }
 
-  bool isTUMPolicy() const {
-    return TailPolicy == Undisturbed && MaskPolicy == Agnostic &&
-           IntrinsicWithoutMU;
-  }
-
-  bool isTAMPolicy() const {
-    return TailPolicy == Agnostic && MaskPolicy == Agnostic &&
-           IntrinsicWithoutMU;
-  }
-
   bool isTAPolicy() const {
     return TailPolicy == Agnostic && MaskPolicy == Omit;
   }
 
   bool isTUPolicy() const {
     return TailPolicy == Undisturbed && MaskPolicy == Omit;
   }
 
   bool isMAPolicy() const {
     return MaskPolicy == Agnostic && TailPolicy == Omit;
   }
 
   bool isMUPolicy() const {
     return MaskPolicy == Undisturbed && TailPolicy == Omit;
   }
 
+  bool hasTailPolicy() const { return HasTailPolicy; }
+
+  bool hasMaskPolicy() const { return HasMaskPolicy; }
+
   bool isUnspecified() const { return IsUnspecified; }
 
   bool operator==(const Policy &Other) const {
     return IsUnspecified == Other.IsUnspecified &&
            TailPolicy == Other.TailPolicy && MaskPolicy == Other.MaskPolicy &&
-           IntrinsicWithoutMU == Other.IntrinsicWithoutMU;
+           HasTailPolicy == Other.HasTailPolicy &&
+           HasMaskPolicy == Other.HasMaskPolicy;
   }
 
   bool operator!=(const Policy &Other) const { return !(*this == Other); }
 
   bool operator<(const Policy &Other) const {
     // Just for maintain the old order for quick test.
     if (MaskPolicy != Other.MaskPolicy)
       return Other.MaskPolicy < MaskPolicy;
private:
   unsigned NF = 1;
   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 PolicyAttrs);
   ~RVVIntrinsic() = default;
 
   RVVTypePtr getOutputType() const { return OutputType; }
   const RVVTypes &getInputTypes() const { return InputTypes; }
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, PolicyScheme DefaultScheme,
                       Policy PolicyAttrs);
 
-  static llvm::SmallVector<Policy> getSupportedUnMaskedPolicies();
+  static llvm::SmallVector<Policy>
+  getSupportedUnMaskedPolicies(bool HasTailPolicy, bool HasMaskPolicy);
   static llvm::SmallVector<Policy>
       getSupportedMaskedPolicies(bool HasTailPolicy, bool HasMaskPolicy);
 
   static void updateNamesAndPolicy(bool IsMasked, bool HasPolicy,
                                    std::string &Name, std::string &BuiltinName,
                                    std::string &OverloadedName,
                                    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,

clang/lib/Sema/SemaRISCVVectorLookup.cpp

private:
 
   // Create IntrinsicList
   void InitIntrinsicList();
 
   // Create RVVIntrinsicDef.
   void InitRVVIntrinsic(const RVVIntrinsicRecord &Record, StringRef SuffixStr,
                         StringRef OverloadedSuffixStr, bool IsMask,
                         RVVTypes &Types, bool HasPolicy, Policy PolicyAttrs);
 
   // Create FunctionDecl for a vector intrinsic.
   void CreateRVVIntrinsicDecl(LookupResult &LR, IdentifierInfo *II,
                               Preprocessor &PP, unsigned Index,
                               bool IsOverload);
 
 public:
   RISCVIntrinsicManagerImpl(clang::Sema &S) : S(S), Context(S.Context) {
     InitIntrinsicList();
for (auto &Record : RVVIntrinsicRecords) {
     ArrayRef<PrototypeDescriptor> OverloadedSuffixProto = ProtoSeq2ArrayRef(
         Record.OverloadedSuffixIndex, Record.OverloadedSuffixSize);
 
     PolicyScheme UnMaskedPolicyScheme =
         static_cast<PolicyScheme>(Record.UnMaskedPolicyScheme);
     PolicyScheme MaskedPolicyScheme =
         static_cast<PolicyScheme>(Record.MaskedPolicyScheme);
 
+    const Policy DefaultPolicy(Record.HasTailPolicy, Record.HasMaskPolicy);
+
     llvm::SmallVector<PrototypeDescriptor> ProtoSeq =
         RVVIntrinsic::computeBuiltinTypes(BasicProtoSeq, /*IsMasked=*/false,
                                           /*HasMaskedOffOperand=*/false,
                                           Record.HasVL, Record.NF,
-                                          UnMaskedPolicyScheme, Policy());
+                                          UnMaskedPolicyScheme, DefaultPolicy);
 
     llvm::SmallVector<PrototypeDescriptor> ProtoMaskSeq =
         RVVIntrinsic::computeBuiltinTypes(
             BasicProtoSeq, /*IsMasked=*/true, Record.HasMaskedOffOperand,
-            Record.HasVL, Record.NF, MaskedPolicyScheme, Policy());
+            Record.HasVL, Record.NF, MaskedPolicyScheme, DefaultPolicy);
 
     bool UnMaskedHasPolicy = UnMaskedPolicyScheme != PolicyScheme::SchemeNone;
     bool MaskedHasPolicy = MaskedPolicyScheme != PolicyScheme::SchemeNone;
     SmallVector<Policy> SupportedUnMaskedPolicies =
-        RVVIntrinsic::getSupportedUnMaskedPolicies();
+        RVVIntrinsic::getSupportedUnMaskedPolicies(Record.HasTailPolicy,
+                                                   Record.HasMaskPolicy);
     SmallVector<Policy> SupportedMaskedPolicies =
         RVVIntrinsic::getSupportedMaskedPolicies(Record.HasTailPolicy,
                                                  Record.HasMaskPolicy);
 
     for (unsigned int TypeRangeMaskShift = 0;
          TypeRangeMaskShift <= static_cast<unsigned int>(BasicType::MaxOffset);
          ++TypeRangeMaskShift) {
       unsigned int BaseTypeI = 1 << TypeRangeMaskShift;
for (unsigned int TypeRangeMaskShift = 0;
 
         std::string SuffixStr = RVVIntrinsic::getSuffixStr(
             TypeCache, BaseType, Log2LMUL, SuffixProto);
         std::string OverloadedSuffixStr = RVVIntrinsic::getSuffixStr(
             TypeCache, BaseType, Log2LMUL, OverloadedSuffixProto);
 
         // Create non-masked intrinsic.
         InitRVVIntrinsic(Record, SuffixStr, OverloadedSuffixStr, false, *Types,
-                         UnMaskedHasPolicy, Policy());
+                         UnMaskedHasPolicy, DefaultPolicy);
 
         // Create non-masked policy intrinsic.
         if (Record.UnMaskedPolicyScheme != PolicyScheme::SchemeNone) {
           for (auto P : SupportedUnMaskedPolicies) {
             llvm::SmallVector<PrototypeDescriptor> PolicyPrototype =
                 RVVIntrinsic::computeBuiltinTypes(
                     BasicProtoSeq, /*IsMasked=*/false,
                     /*HasMaskedOffOperand=*/false, Record.HasVL, Record.NF,
                     UnMaskedPolicyScheme, P);
             std::optional<RVVTypes> PolicyTypes = TypeCache.computeTypes(
                 BaseType, Log2LMUL, Record.NF, PolicyPrototype);
             InitRVVIntrinsic(Record, SuffixStr, OverloadedSuffixStr,
                              /*IsMask=*/false, *PolicyTypes, UnMaskedHasPolicy,
                              P);
           }
         }
         if (!Record.HasMasked)
           continue;
         // Create masked intrinsic.
         std::optional<RVVTypes> MaskTypes =
             TypeCache.computeTypes(BaseType, Log2LMUL, Record.NF, ProtoMaskSeq);
         InitRVVIntrinsic(Record, SuffixStr, OverloadedSuffixStr, true,
-                         *MaskTypes, MaskedHasPolicy, Policy());
+                         *MaskTypes, MaskedHasPolicy, DefaultPolicy);
         if (Record.MaskedPolicyScheme == PolicyScheme::SchemeNone)
           continue;
         // Create masked policy intrinsic.
         for (auto P : SupportedMaskedPolicies) {
           llvm::SmallVector<PrototypeDescriptor> PolicyPrototype =
               RVVIntrinsic::computeBuiltinTypes(
                   BasicProtoSeq, /*IsMasked=*/true, Record.HasMaskedOffOperand,
                   Record.HasVL, Record.NF, MaskedPolicyScheme, P);

clang/lib/Support/RISCVVIntrinsicUtils.cpp

 //===----------------------------------------------------------------------===//
 // RVVIntrinsic implementation
 //===----------------------------------------------------------------------===//
 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 NewPolicyAttrs)
     : IRName(IRName), IsMasked(IsMasked),
       HasMaskedOffOperand(HasMaskedOffOperand), HasVL(HasVL), Scheme(Scheme),
       SupportOverloading(SupportOverloading), HasBuiltinAlias(HasBuiltinAlias),
       ManualCodegen(ManualCodegen.str()), NF(NF), PolicyAttrs(NewPolicyAttrs) {

  }
 
   // If HasVL, append PrototypeDescriptor:VL to last operand
   if (HasVL)
     NewPrototype.push_back(PrototypeDescriptor::VL);
   return NewPrototype;
 }
 
-llvm::SmallVector<Policy> RVVIntrinsic::getSupportedUnMaskedPolicies() {
-  return {
-      Policy(Policy::PolicyType::Undisturbed, Policy::PolicyType::Omit), // TU
-      Policy(Policy::PolicyType::Agnostic, Policy::PolicyType::Omit)};   // TA
+llvm::SmallVector<Policy>
+RVVIntrinsic::getSupportedUnMaskedPolicies(bool HasTailPolicy,
+                                           bool HasMaskPolicy) {
+  return {Policy(Policy::PolicyType::Undisturbed, Policy::PolicyType::Omit,
+                 HasTailPolicy, HasMaskPolicy), // TU
+          Policy(Policy::PolicyType::Agnostic, Policy::PolicyType::Omit,
+                 HasTailPolicy, HasMaskPolicy)}; // TA
 }
 
 llvm::SmallVector<Policy>
 RVVIntrinsic::getSupportedMaskedPolicies(bool HasTailPolicy,
                                          bool HasMaskPolicy) {
   if (HasTailPolicy && HasMaskPolicy)
-    return {Policy(Policy::PolicyType::Undisturbed,
-                   Policy::PolicyType::Agnostic), // TUMA
-            Policy(Policy::PolicyType::Agnostic,
-                   Policy::PolicyType::Agnostic), // TAMA
-            Policy(Policy::PolicyType::Undisturbed,
-                   Policy::PolicyType::Undisturbed), // TUMU
-            Policy(Policy::PolicyType::Agnostic,
-                   Policy::PolicyType::Undisturbed)}; // TAMU
+    return {
+        Policy(Policy::PolicyType::Undisturbed, Policy::PolicyType::Agnostic,
+               HasTailPolicy, HasMaskPolicy), // TUMA
+        Policy(Policy::PolicyType::Agnostic, Policy::PolicyType::Agnostic,
+               HasTailPolicy, HasMaskPolicy), // TAMA
+        Policy(Policy::PolicyType::Undisturbed, Policy::PolicyType::Undisturbed,
+               HasTailPolicy, HasMaskPolicy), // TUMU
+        Policy(Policy::PolicyType::Agnostic, Policy::PolicyType::Undisturbed,
+               HasTailPolicy, HasMaskPolicy)}; // TAMU
   if (HasTailPolicy && !HasMaskPolicy)
     return {Policy(Policy::PolicyType::Undisturbed,
-                   Policy::PolicyType::Agnostic, true), // TUM
+                   Policy::PolicyType::Agnostic, HasTailPolicy,
+                   HasMaskPolicy), // TUM
             Policy(Policy::PolicyType::Agnostic, Policy::PolicyType::Agnostic,
-                   true)}; // TAM
+                   HasTailPolicy, HasMaskPolicy)}; // TAM
   if (!HasTailPolicy && HasMaskPolicy)
-    return {
-        Policy(Policy::PolicyType::Omit, Policy::PolicyType::Agnostic), // MA
-        Policy(Policy::PolicyType::Omit,
-               Policy::PolicyType::Undisturbed)}; // MU
+    return {Policy(Policy::PolicyType::Omit, Policy::PolicyType::Agnostic,
+                   HasTailPolicy, HasMaskPolicy), // MA
+            Policy(Policy::PolicyType::Omit, Policy::PolicyType::Undisturbed,
+                   HasTailPolicy, HasMaskPolicy)}; // MU
   llvm_unreachable("An RVV instruction should not be without both tail policy "
                    "and mask policy");
 }
 
 void RVVIntrinsic::updateNamesAndPolicy(bool IsMasked, bool HasPolicy,
                                         std::string &Name,
                                         std::string &BuiltinName,
                                         std::string &OverloadedName,
                                         Policy &PolicyAttrs) {
 
   auto appendPolicySuffix = [&](const std::string &suffix) {
     Name += suffix;
     BuiltinName += suffix;
     OverloadedName += suffix;
   };
 
   if (PolicyAttrs.isUnspecified()) {
     PolicyAttrs.IsUnspecified = false;
     if (IsMasked) {
       Name += "_m";
       // FIXME: Currently _m default policy implementation is different with
       // RVV intrinsic spec (TUMA)
       PolicyAttrs.TailPolicy = Policy::PolicyType::Undisturbed;
       PolicyAttrs.MaskPolicy = Policy::PolicyType::Undisturbed;
       if (HasPolicy)
         BuiltinName += "_tumu";
       else
         BuiltinName += "_m";
     } else {
       PolicyAttrs.TailPolicy = Policy::PolicyType::Agnostic;
       if (HasPolicy)
         BuiltinName += "_ta";
     }
   } else {
-    if (PolicyAttrs.isTUMPolicy())
+    if (PolicyAttrs.isTUMAPolicy() && !PolicyAttrs.hasMaskPolicy())
       appendPolicySuffix("_tum");
-    else if (PolicyAttrs.isTAMPolicy())
+    else if (PolicyAttrs.isTAMAPolicy() && !PolicyAttrs.hasMaskPolicy())
       appendPolicySuffix("_tam");
     else if (PolicyAttrs.isTUMUPolicy())
       appendPolicySuffix("_tumu");
     else if (PolicyAttrs.isTAMUPolicy())
       appendPolicySuffix("_tamu");
     else if (PolicyAttrs.isTUMAPolicy())
       appendPolicySuffix("_tuma");
     else if (PolicyAttrs.isTAMAPolicy())
       appendPolicySuffix("_tama");
-    else if (PolicyAttrs.isTUPolicy())
+    else if (PolicyAttrs.isTUPolicy() && !IsMasked)
       appendPolicySuffix("_tu");
-    else if (PolicyAttrs.isTAPolicy())
+    else if (PolicyAttrs.isTAPolicy() && !IsMasked)
       appendPolicySuffix("_ta");
-    else if (PolicyAttrs.isMUPolicy()) {
+    else if (PolicyAttrs.isMUPolicy() && !PolicyAttrs.hasTailPolicy()) {
       appendPolicySuffix("_mu");
       PolicyAttrs.TailPolicy = Policy::PolicyType::Agnostic;
-    } else if (PolicyAttrs.isMAPolicy()) {
+    } else if (PolicyAttrs.isMAPolicy() && !PolicyAttrs.hasTailPolicy()) {
       appendPolicySuffix("_ma");
       PolicyAttrs.TailPolicy = Policy::PolicyType::Agnostic;
-    }
+    } else
+      llvm_unreachable("Unhandled policy condition");
   }
 }
 
 SmallVector<PrototypeDescriptor> parsePrototypes(StringRef Prototypes) {
   SmallVector<PrototypeDescriptor> PrototypeDescriptors;
   const StringRef Primaries("evwqom0ztul");
   while (!Prototypes.empty()) {
     size_t Idx = 0;

clang/utils/TableGen/RISCVVEmitter.cpp

for (auto *R : RV) {
     std::vector<int64_t> IntrinsicTypes =
         R->getValueAsListOfInts("IntrinsicTypes");
     std::vector<StringRef> RequiredFeatures =
         R->getValueAsListOfStrings("RequiredFeatures");
     StringRef IRName = R->getValueAsString("IRName");
     StringRef MaskedIRName = R->getValueAsString("MaskedIRName");
     unsigned NF = R->getValueAsInt("NF");
 
+    const Policy DefaultPolicy(HasTailPolicy, HasMaskPolicy);
     SmallVector<Policy> SupportedUnMaskedPolicies =
-        RVVIntrinsic::getSupportedUnMaskedPolicies();
+        RVVIntrinsic::getSupportedUnMaskedPolicies(HasTailPolicy,
+                                                   HasMaskPolicy);
     SmallVector<Policy> SupportedMaskedPolicies =
         RVVIntrinsic::getSupportedMaskedPolicies(HasTailPolicy, HasMaskPolicy);
 
     // Parse prototype and create a list of primitive type with transformers
     // (operand) in Prototype. Prototype[0] is output operand.
     SmallVector<PrototypeDescriptor> BasicPrototype =
         parsePrototypes(Prototypes);
 
     SmallVector<PrototypeDescriptor> SuffixDesc = parsePrototypes(SuffixProto);
     SmallVector<PrototypeDescriptor> OverloadedSuffixDesc =
         parsePrototypes(OverloadedSuffixProto);
 
     // Compute Builtin types
-    auto Prototype =
-        RVVIntrinsic::computeBuiltinTypes(BasicPrototype, /*IsMasked=*/false,
-                                          /*HasMaskedOffOperand=*/false, HasVL,
-                                          NF, UnMaskedPolicyScheme, Policy());
+    auto Prototype = RVVIntrinsic::computeBuiltinTypes(
+        BasicPrototype, /*IsMasked=*/false,
+        /*HasMaskedOffOperand=*/false, HasVL, NF, UnMaskedPolicyScheme,
+        DefaultPolicy);
     auto MaskedPrototype = RVVIntrinsic::computeBuiltinTypes(
         BasicPrototype, /*IsMasked=*/true, HasMaskedOffOperand, HasVL, NF,
-        MaskedPolicyScheme, Policy());
+        MaskedPolicyScheme, DefaultPolicy);
 
     // Create Intrinsics for each type and LMUL.
     for (char I : TypeRange) {
       for (int Log2LMUL : Log2LMULList) {
         BasicType BT = ParseBasicType(I);
         std::optional<RVVTypes> Types =
             TypeCache.computeTypes(BT, Log2LMUL, NF, Prototype);
         // Ignored to create new intrinsic if there are any illegal types.
         if (!Types)
           continue;
 
         auto SuffixStr =
             RVVIntrinsic::getSuffixStr(TypeCache, BT, Log2LMUL, SuffixDesc);
         auto OverloadedSuffixStr = RVVIntrinsic::getSuffixStr(
             TypeCache, BT, Log2LMUL, OverloadedSuffixDesc);
         // Create a unmasked intrinsic
         Out.push_back(std::make_unique<RVVIntrinsic>(
             Name, SuffixStr, OverloadedName, OverloadedSuffixStr, IRName,
             /*IsMasked=*/false, /*HasMaskedOffOperand=*/false, HasVL,
             UnMaskedPolicyScheme, SupportOverloading, HasBuiltinAlias,
             ManualCodegen, *Types, IntrinsicTypes, RequiredFeatures, NF,
-            Policy()));
+            DefaultPolicy));
         if (UnMaskedPolicyScheme != PolicyScheme::SchemeNone)
           for (auto P : SupportedUnMaskedPolicies) {
             SmallVector<PrototypeDescriptor> PolicyPrototype =
                 RVVIntrinsic::computeBuiltinTypes(
                     BasicPrototype, /*IsMasked=*/false,
                     /*HasMaskedOffOperand=*/false, HasVL, NF,
                     UnMaskedPolicyScheme, P);
             std::optional<RVVTypes> PolicyTypes =
for (char I : TypeRange) {
           continue;
         // Create a masked intrinsic
         std::optional<RVVTypes> MaskTypes =
             TypeCache.computeTypes(BT, Log2LMUL, NF, Prototype);
         Out.push_back(std::make_unique<RVVIntrinsic>(
             Name, SuffixStr, OverloadedName, OverloadedSuffixStr, MaskedIRName,
             /*IsMasked=*/true, HasMaskedOffOperand, HasVL, MaskedPolicyScheme,
             SupportOverloading, HasBuiltinAlias, ManualCodegen, *MaskTypes,
-            IntrinsicTypes, RequiredFeatures, NF, Policy()));
+            IntrinsicTypes, RequiredFeatures, NF, DefaultPolicy));
         if (MaskedPolicyScheme == PolicyScheme::SchemeNone)
           continue;
         for (auto P : SupportedMaskedPolicies) {
           SmallVector<PrototypeDescriptor> PolicyPrototype =
               RVVIntrinsic::computeBuiltinTypes(
                   BasicPrototype, /*IsMasked=*/true, HasMaskedOffOperand, HasVL,
                   NF, MaskedPolicyScheme, P);
           std::optional<RVVTypes> PolicyTypes =