[11/15][Clang][RISCV][NFC] Remove Policy::PolicyType::Omit

[eopXD]

Summary

The attribute can be removed now as preceding patches have removed its
users.

This is the 11th 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 latset main.

[eopXD]

Bump CI.

[kito-cheng]

LGTM

[craig.topper]

clang/lib/Support/RISCVVIntrinsicUtils.cpp

1038

If you hadn't just removed Omit, it somewhat feels like Omit should be part of Policy and this code to pick the policy suffix string should be inside the Policy class. But I'll defer to your judgement.

[craig.topper]

LGTM

[eopXD]

clang/lib/Support/RISCVVIntrinsicUtils.cpp

1038

Good idea, I will encapsulate logics into Policy. Considering the next patch-set, to simplify the policy suffixes, IsUnspecified can be further removed. Eventually we can have something like:

void RVVIntrinsic::updateNamesAndPolicy(bool IsMasked, bool HasPolicy,
                                        std::string &Name,
                                        std::string &BuiltinName,
                                        std::string &OverloadedName,
                                        Policy &PolicyAttrs) {
  std::string PolicySuffix =
    PolicyAttrs.getPolicySuffix(IsMasked, HasPolicy);
  Name += PolicySuffix;
  BuiltinName += PolicySuffix;
  OverloadedName += PolicySuffix;
}

I will create a separate revision so we won't be distracted towards the goal of this patch-set.

---

On the other hand, here is my thought process when considering the removal of Omit as a legit refactoring.

Logics to deal with Omit occurs under here (updateNamesAndPolicy), computeBuiltinTypes, and getPolicyAttrs. The Omit state specified to a Policy implies it has to be corrected to something specific (either Agnostic or Undisturbed) before calling getPolicyAttrs, which will set the values in riscv_vector_cg (called under RISCVVEmitter.cpp. This blocks the possibility of setting TailPolicy, MaskPolicy as constant members.

I picked HasTailPolicy and HasMaskPolicy for the predicates because it was exactly how riscv_vector.td defined the intrinsics. They are necessary as conditions now with the current policy suffix naming rules. With the next patch-set, HasTailPolicy and HasMaskPolicy will only be called by getSupportedUnMaskedPolicies and getSupportedMaskedPolicies. This is because the policy suffix logics here can be simplified to something like: (this does not contradict with the encapsulating topic above)

if (PolicyAttrs.isUnspecified()) {
  if (IsMasked) {
    Name += "_m";
    if (HasPolicy)
      BuiltinName += "_tama";
    else
      BuiltinName += "_m";
  } else {
    if (HasPolicy)
      BuiltinName += "_ta";
  }
} else {
  if (IsMasked) {
    if (PolicyAttrs.isTAMUPolicy())
      appendPolicySuffix("_mu")
    else if (PolicyAttrs.isTUMAPolicy())
      appendPolicySuffix("_tum")
    else if (PolicyAttrs.isTUMUPolicy())
      appendPolicySuffix("_tumu")
    else
      llvm_unreachable("Unhandled policy condition");
  } else {
    if (PolicyAttrs.isTUPolicy())
      appendPolicySuffix("_tu");
    else
      llvm_unreachable("Unhandled policy condition");
  }
}

[eopXD]

Rebase to latest main.

clang/include/clang/Support/RISCVVIntrinsicUtils.h

enum class TypeModifier : uint8_t {
   LLVM_MARK_AS_BITMASK_ENUM(LMUL1),
 };
 
 struct Policy {
   bool IsUnspecified = false;
   enum PolicyType {
     Undisturbed,
     Agnostic,
-    Omit, // No policy required.
   };
   PolicyType TailPolicy = Agnostic;
   PolicyType MaskPolicy = Undisturbed;
   Policy() : IsUnspecified(true) {}
-  Policy(PolicyType _TailPolicy, PolicyType _MaskPolicy)
-      : TailPolicy(_TailPolicy), MaskPolicy(_MaskPolicy) {}
+  Policy(PolicyType TailPolicy) : TailPolicy(TailPolicy) {}
+  Policy(PolicyType TailPolicy, PolicyType MaskPolicy)
+      : TailPolicy(TailPolicy), MaskPolicy(MaskPolicy) {}
 
   bool isTAMAPolicy() const {
     return TailPolicy == Agnostic && MaskPolicy == Agnostic;
   }
 
   bool isTAMUPolicy() const {
     return TailPolicy == Agnostic && MaskPolicy == Undisturbed;
   }

clang/lib/Support/RISCVVIntrinsicUtils.cpp

llvm::SmallVector<PrototypeDescriptor> RVVIntrinsic::computeBuiltinTypes(
 
   // 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
+  return {Policy(Policy::PolicyType::Undisturbed), // TU
+          Policy(Policy::PolicyType::Agnostic)};   // TA
 }
 
 llvm::SmallVector<Policy>
 RVVIntrinsic::getSupportedMaskedPolicies(bool HasTailPolicy,
                                          bool HasMaskPolicy) {
   if (HasTailPolicy && HasMaskPolicy)
     return {Policy(Policy::PolicyType::Undisturbed,
                    Policy::PolicyType::Agnostic), // TUMA
if (IsMasked) {
       else
         BuiltinName += "_m";
     } else {
       PolicyAttrs.TailPolicy = Policy::PolicyType::Agnostic;
       if (HasPolicy)
         BuiltinName += "_ta";
     }
   } else {
+    if (IsMasked) {
       if (PolicyAttrs.isTUMAPolicy() && !HasMaskPolicy)
         appendPolicySuffix("_tum");
       else if (PolicyAttrs.isTAMAPolicy() && !HasMaskPolicy)
         appendPolicySuffix("_tam");
       else if (PolicyAttrs.isMUPolicy() && !HasTailPolicy)
         appendPolicySuffix("_mu");
       else if (PolicyAttrs.isMAPolicy() && !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)
+      else
+        llvm_unreachable("Unhandled policy condition");
+    } else {
+      if (PolicyAttrs.isTUPolicy())
         appendPolicySuffix("_tu");
-    else if (PolicyAttrs.isTAPolicy() && !IsMasked)
+      else if (PolicyAttrs.isTAPolicy())
         appendPolicySuffix("_ta");
       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;
     // Skip over complex prototype because it could contain primitive type
     // character.