[6/15][Clang][RISCV][NFC] Instructions with a mask destination register is always tail agnostic

[eopXD]

Summary

The logic under computeBuiltinTypes is an amendment to setting Policy as
Omit. The tail policy should be set to agnostic for those intrinsics that
has HasTailPolicy = false, which are the intrinsics with a mask destination
register.

This is the 6th 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 upon latest main.

Also [10/N] was mistakenly fused into this patch. Removed it.

[eopXD]

I was mistaken. Nothing was mistakenly fused. Recover the patch.

[kito-cheng]

LGTM, the condition of those predictor function more reasonable now

[craig.topper]

LGTM

clang/include/clang/Support/RISCVVIntrinsicUtils.h

struct Policy {
   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 isMAPolicy() const { return MaskPolicy == Agnostic; }
 
-  bool isMUPolicy() const {
-    return MaskPolicy == Undisturbed && TailPolicy == Omit;
-  }
+  bool isMUPolicy() const { return MaskPolicy == Undisturbed; }
 
   bool hasTailPolicy() const { return HasTailPolicy; }
 
   bool hasMaskPolicy() const { return HasMaskPolicy; }
 
   bool isUnspecified() const { return IsUnspecified; }
 
   bool operator==(const Policy &Other) const {

clang/lib/Support/RISCVVIntrinsicUtils.cpp

 }
 
 llvm::SmallVector<PrototypeDescriptor> RVVIntrinsic::computeBuiltinTypes(
     llvm::ArrayRef<PrototypeDescriptor> Prototype, bool IsMasked,
     bool HasMaskedOffOperand, bool HasVL, unsigned NF,
     PolicyScheme DefaultScheme, Policy PolicyAttrs) {
   SmallVector<PrototypeDescriptor> NewPrototype(Prototype.begin(),
                                                 Prototype.end());
-  // Update PolicyAttrs if need (TA or TAMA) for compute builtin types.
-  if (PolicyAttrs.isMAPolicy())
-    PolicyAttrs.TailPolicy = Policy::PolicyType::Agnostic; // TAMA
   bool HasPassthruOp = DefaultScheme == PolicyScheme::HasPassthruOperand;
   if (IsMasked) {
     // If HasMaskedOffOperand, insert result type as first input operand if
     // need.
     if (HasMaskedOffOperand && !PolicyAttrs.isTAMAPolicy()) {
       if (NF == 1) {
         NewPrototype.insert(NewPrototype.begin() + 1, NewPrototype[0]);
       } else if (NF > 1) {
return {
                HasTailPolicy, HasMaskPolicy)}; // TAMU
   if (HasTailPolicy && !HasMaskPolicy)
     return {Policy(Policy::PolicyType::Undisturbed,
                    Policy::PolicyType::Agnostic, HasTailPolicy,
                    HasMaskPolicy), // TUM
             Policy(Policy::PolicyType::Agnostic, Policy::PolicyType::Agnostic,
                    HasTailPolicy, HasMaskPolicy)}; // TAM
   if (!HasTailPolicy && HasMaskPolicy)
-    return {Policy(Policy::PolicyType::Omit, Policy::PolicyType::Agnostic,
+    return {Policy(Policy::PolicyType::Agnostic, Policy::PolicyType::Agnostic,
                    HasTailPolicy, HasMaskPolicy), // MA
-            Policy(Policy::PolicyType::Omit, Policy::PolicyType::Undisturbed,
-                   HasTailPolicy, HasMaskPolicy)}; // MU
+            Policy(Policy::PolicyType::Agnostic,
+                   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,
if (IsMasked) {
       if (HasPolicy)
         BuiltinName += "_ta";
     }
   } else {
     if (PolicyAttrs.isTUMAPolicy() && !PolicyAttrs.hasMaskPolicy())
       appendPolicySuffix("_tum");
     else if (PolicyAttrs.isTAMAPolicy() && !PolicyAttrs.hasMaskPolicy())
       appendPolicySuffix("_tam");
+    else if (PolicyAttrs.isMUPolicy() && !PolicyAttrs.hasTailPolicy())
+      appendPolicySuffix("_mu");
+    else if (PolicyAttrs.isMAPolicy() && !PolicyAttrs.hasTailPolicy())
+      appendPolicySuffix("_ma");
     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() && !IsMasked)
       appendPolicySuffix("_tu");
     else if (PolicyAttrs.isTAPolicy() && !IsMasked)
       appendPolicySuffix("_ta");
-    else if (PolicyAttrs.isMUPolicy() && !PolicyAttrs.hasTailPolicy()) {
-      appendPolicySuffix("_mu");
-      PolicyAttrs.TailPolicy = Policy::PolicyType::Agnostic;
-    } else if (PolicyAttrs.isMAPolicy() && !PolicyAttrs.hasTailPolicy()) {
-      appendPolicySuffix("_ma");
-      PolicyAttrs.TailPolicy = Policy::PolicyType::Agnostic;
-    } else
+    else
       llvm_unreachable("Unhandled policy condition");
   }
 }
 
 SmallVector<PrototypeDescriptor> parsePrototypes(StringRef Prototypes) {
   SmallVector<PrototypeDescriptor> PrototypeDescriptors;
   const StringRef Primaries("evwqom0ztul");
   while (!Prototypes.empty()) {