[2/15][Clang][RISCV][NFC] Rename Policy::IsPolicyNone to IsUnspecifed

[eopXD]

Summary

The original naming is inaccurate. An RVV intrinsic always comes with
a corresponding policy behavior. When the policy is unspecified for an
intrinsic, its policy behavior should be it's default assumption.

This is the 2nd 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]

Bump CI

[eopXD]

Bump CI

[eopXD]

Rebase to latest main.

[kito-cheng]

LGTM, this made the code more expressive.

[craig.topper]

clang/include/clang/Support/RISCVVIntrinsicUtils.h

96

Maybe this should default to true, and the constructor that wants false should set it to false? Then you can use = default for the default constructor.

clang/lib/Support/RISCVVIntrinsicUtils.cpp

921

This can be folded into the previous if using &&.

[eopXD]

For the record here, IsUnspecified will be removed in D142016, so the un-addressed comment will be resolved by then.

clang/include/clang/Support/RISCVVIntrinsicUtils.h

enum class TypeModifier : uint8_t {
   // simple enum, so we decide keek LMUL1 in TypeModifier for code size
   // optimization of clang binary size.
   LMUL1 = 1 << 6,
   MaxOffset = 6,
   LLVM_MARK_AS_BITMASK_ENUM(LMUL1),
 };
 
 struct Policy {
-  bool PolicyNone = false;
+  bool IsUnspecified = false;
   enum PolicyType {
     Undisturbed,
     Agnostic,
     Omit, // No policy required.
   };
   PolicyType TailPolicy = Omit;
   PolicyType MaskPolicy = Omit;
   bool IntrinsicWithoutMU = false;
-  Policy() : PolicyNone(true) {}
+  Policy() : IsUnspecified(true) {}
   Policy(PolicyType _TailPolicy, PolicyType _MaskPolicy,
          bool _IntrinsicWithoutMU = false)
       : TailPolicy(_TailPolicy), MaskPolicy(_MaskPolicy),
         IntrinsicWithoutMU(_IntrinsicWithoutMU) {}
 
   bool isTAMAPolicy() const {
     return TailPolicy == Agnostic && MaskPolicy == Agnostic;
   }
struct Policy {
   bool isMAPolicy() const {
     return MaskPolicy == Agnostic && TailPolicy == Omit;
   }
 
   bool isMUPolicy() const {
     return MaskPolicy == Undisturbed && TailPolicy == Omit;
   }
 
-  bool isPolicyNonePolicy() const { return PolicyNone; }
+  bool isUnspecified() const { return IsUnspecified; }
 
   bool operator==(const Policy &Other) const {
-    return PolicyNone == Other.PolicyNone && TailPolicy == Other.TailPolicy &&
-           MaskPolicy == Other.MaskPolicy &&
+    return IsUnspecified == Other.IsUnspecified &&
+           TailPolicy == Other.TailPolicy && MaskPolicy == Other.MaskPolicy &&
            IntrinsicWithoutMU == Other.IntrinsicWithoutMU;
   }
 
   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)
public:
   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 getPolicyAttrs() const {
-    assert(PolicyAttrs.PolicyNone == false);
+    assert(PolicyAttrs.IsUnspecified == false);
     return PolicyAttrs;
   }
   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 PolicyAttrs = TAIL_UNDISTURBED;
-    assert(PolicyAttrs.PolicyNone == false);
+    assert(PolicyAttrs.IsUnspecified == false);
 
     if (PolicyAttrs.isTUMAPolicy())
       return 2;
     if (PolicyAttrs.isTAMAPolicy())
       return 3;
     if (PolicyAttrs.isTUMUPolicy())
       return 0;
     if (PolicyAttrs.isTAMUPolicy())

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
-  if (PolicyAttrs.isPolicyNonePolicy()) {
+  if (PolicyAttrs.isUnspecified()) {
     if (!IsMasked) {
-      PolicyAttrs.PolicyNone = false;
+      PolicyAttrs.IsUnspecified = false;
       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 && !PolicyAttrs.isTAMAPolicy()) {
void RVVIntrinsic::updateNamesAndPolicy(bool IsMasked, bool HasPolicy,
                                         Policy &PolicyAttrs) {
 
   auto appendPolicySuffix = [&](const std::string &suffix) {
     Name += suffix;
     BuiltinName += suffix;
     OverloadedName += suffix;
   };
 
-  if (PolicyAttrs.isPolicyNonePolicy()) {
-    PolicyAttrs.PolicyNone = false;
+  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";