[Clang][RISCV] Simplify RVV intrinsic policy suffix

This patch works towards the simplification proposal [0] of Nick
Knight. After this patch, we have reduced the hierarchy of intrinsics
from two sets (non-policy and policy) into a single set, with a general
assumption that policy behavior is agnostic unless specified.

[0] https://gist.github.com/nick-knight/6cb0b74b351a25323dfb1821d3a269b9

Pull Request: riscv-non-isa/rvv-intrinsic-doc#186.

Depends on D141796.

Reviewed By: craig.topper, kito-cheng

Differential Revision: https://reviews.llvm.org/D142016

Author: eopXD

clang/include/clang/Support/RISCVVIntrinsicUtils.h

@@ -98,26 +98,18 @@ class Policy {
     Undisturbed,
     Agnostic,
   };
-  bool IsUnspecified = false;
 
 private:
   // The default assumption for an RVV instruction is TAMA, as an undisturbed
   // policy generally will affect the performance of an out-of-order core.
   const PolicyType TailPolicy = Agnostic;
   const PolicyType MaskPolicy = Agnostic;
-  bool HasTailPolicy, HasMaskPolicy;
 
 public:
-  Policy(bool HasTailPolicy, bool HasMaskPolicy)
-      : IsUnspecified(true), HasTailPolicy(HasTailPolicy),
-        HasMaskPolicy(HasMaskPolicy) {}
-  Policy(PolicyType TailPolicy, bool HasTailPolicy, bool HasMaskPolicy)
-      : TailPolicy(TailPolicy), HasTailPolicy(HasTailPolicy),
-        HasMaskPolicy(HasMaskPolicy) {}
-  Policy(PolicyType TailPolicy, PolicyType MaskPolicy, bool HasTailPolicy,
-         bool HasMaskPolicy)
-      : TailPolicy(TailPolicy), MaskPolicy(MaskPolicy),
-        HasTailPolicy(HasTailPolicy), HasMaskPolicy(HasMaskPolicy) {}
+  Policy() = default;
+  Policy(PolicyType TailPolicy) : TailPolicy(TailPolicy) {}
+  Policy(PolicyType TailPolicy, PolicyType MaskPolicy)
+      : TailPolicy(TailPolicy), MaskPolicy(MaskPolicy) {}
 
   bool isTAMAPolicy() const {
     return TailPolicy == Agnostic && MaskPolicy == Agnostic;
@@ -143,17 +135,8 @@ class Policy {
 
   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 {
-    return IsUnspecified == Other.IsUnspecified &&
-           TailPolicy == Other.TailPolicy && MaskPolicy == Other.MaskPolicy &&
-           HasTailPolicy == Other.HasTailPolicy &&
-           HasMaskPolicy == Other.HasMaskPolicy;
+    return TailPolicy == Other.TailPolicy && MaskPolicy == Other.MaskPolicy;
   }
 
   bool operator!=(const Policy &Other) const { return !(*this == Other); }
@@ -429,7 +412,6 @@ class RVVIntrinsic {
     return IntrinsicTypes;
   }
   Policy getPolicyAttrs() const {
-    assert(PolicyAttrs.IsUnspecified == false);
     return PolicyAttrs;
   }
   unsigned getPolicyAttrsBits() const {
@@ -438,8 +420,6 @@ class RVVIntrinsic {
     // The 1st bit simulates the `vma` of RVV
     // int PolicyAttrs = 0;
 
-    assert(PolicyAttrs.IsUnspecified == false);
-
     if (PolicyAttrs.isTUMAPolicy())
       return 2;
     if (PolicyAttrs.isTAMAPolicy())
@@ -466,8 +446,7 @@ class RVVIntrinsic {
                       unsigned NF, PolicyScheme DefaultScheme,
                       Policy PolicyAttrs);
 
-  static llvm::SmallVector<Policy>
-  getSupportedUnMaskedPolicies(bool HasTailPolicy, bool HasMaskPolicy);
+  static llvm::SmallVector<Policy> getSupportedUnMaskedPolicies();
   static llvm::SmallVector<Policy>
       getSupportedMaskedPolicies(bool HasTailPolicy, bool HasMaskPolicy);
 

clang/lib/Sema/SemaRISCVVectorLookup.cpp

@@ -192,7 +192,7 @@ void RISCVIntrinsicManagerImpl::InitIntrinsicList() {
     PolicyScheme MaskedPolicyScheme =
         static_cast<PolicyScheme>(Record.MaskedPolicyScheme);
 
-    const Policy DefaultPolicy(Record.HasTailPolicy, Record.HasMaskPolicy);
+    const Policy DefaultPolicy;
 
     llvm::SmallVector<PrototypeDescriptor> ProtoSeq =
         RVVIntrinsic::computeBuiltinTypes(BasicProtoSeq, /*IsMasked=*/false,
@@ -208,8 +208,7 @@ void RISCVIntrinsicManagerImpl::InitIntrinsicList() {
     bool UnMaskedHasPolicy = UnMaskedPolicyScheme != PolicyScheme::SchemeNone;
     bool MaskedHasPolicy = MaskedPolicyScheme != PolicyScheme::SchemeNone;
     SmallVector<Policy> SupportedUnMaskedPolicies =
-        RVVIntrinsic::getSupportedUnMaskedPolicies(Record.HasTailPolicy,
-                                                   Record.HasMaskPolicy);
+        RVVIntrinsic::getSupportedUnMaskedPolicies();
     SmallVector<Policy> SupportedMaskedPolicies =
         RVVIntrinsic::getSupportedMaskedPolicies(Record.HasTailPolicy,
                                                  Record.HasMaskPolicy);

clang/lib/Support/RISCVVIntrinsicUtils.cpp

@@ -966,40 +966,26 @@ llvm::SmallVector<PrototypeDescriptor> RVVIntrinsic::computeBuiltinTypes(
   return NewPrototype;
 }
 
-llvm::SmallVector<Policy>
-RVVIntrinsic::getSupportedUnMaskedPolicies(bool HasTailPolicy,
-                                           bool HasMaskPolicy) {
-  return {
-      Policy(Policy::PolicyType::Undisturbed, HasTailPolicy,
-             HasMaskPolicy),                                               // TU
-      Policy(Policy::PolicyType::Agnostic, HasTailPolicy, HasMaskPolicy)}; // TA
+llvm::SmallVector<Policy> RVVIntrinsic::getSupportedUnMaskedPolicies() {
+  return {Policy(Policy::PolicyType::Undisturbed)}; // TU
 }
 
 llvm::SmallVector<Policy>
 RVVIntrinsic::getSupportedMaskedPolicies(bool HasTailPolicy,
                                          bool HasMaskPolicy) {
   if (HasTailPolicy && HasMaskPolicy)
-    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
+    return {Policy(Policy::PolicyType::Undisturbed,
+                   Policy::PolicyType::Agnostic), // TUM
+            Policy(Policy::PolicyType::Undisturbed,
+                   Policy::PolicyType::Undisturbed), // TUMU
+            Policy(Policy::PolicyType::Agnostic,
+                   Policy::PolicyType::Undisturbed)}; // MU
   if (HasTailPolicy && !HasMaskPolicy)
     return {Policy(Policy::PolicyType::Undisturbed,
-                   Policy::PolicyType::Agnostic, HasTailPolicy,
-                   HasMaskPolicy), // TUM
-            Policy(Policy::PolicyType::Agnostic, Policy::PolicyType::Agnostic,
-                   HasTailPolicy, HasMaskPolicy)}; // TAM
+                   Policy::PolicyType::Agnostic)}; // TU
   if (!HasTailPolicy && HasMaskPolicy)
-    return {Policy(Policy::PolicyType::Agnostic, Policy::PolicyType::Agnostic,
-                   HasTailPolicy, HasMaskPolicy), // MA
-            Policy(Policy::PolicyType::Agnostic,
-                   Policy::PolicyType::Undisturbed, HasTailPolicy,
-                   HasMaskPolicy)}; // MU
+    return {Policy(Policy::PolicyType::Agnostic,
+                   Policy::PolicyType::Undisturbed)}; // MU
   llvm_unreachable("An RVV instruction should not be without both tail policy "
                    "and mask policy");
 }
@@ -1016,46 +1002,29 @@ void RVVIntrinsic::updateNamesAndPolicy(bool IsMasked, bool HasPolicy,
     OverloadedName += suffix;
   };
 
-  if (PolicyAttrs.isUnspecified()) {
-    PolicyAttrs.IsUnspecified = false;
-    if (IsMasked) {
+  if (IsMasked) {
+    if (PolicyAttrs.isTUMUPolicy())
+      appendPolicySuffix("_tumu");
+    else if (PolicyAttrs.isTUMAPolicy())
+      appendPolicySuffix("_tum");
+    else if (PolicyAttrs.isTAMUPolicy())
+      appendPolicySuffix("_mu");
+    else if (PolicyAttrs.isTAMAPolicy()) {
       Name += "_m";
       if (HasPolicy)
         BuiltinName += "_tama";
       else
         BuiltinName += "_m";
-    } else {
+    } else
+      llvm_unreachable("Unhandled policy condition");
+  } else {
+    if (PolicyAttrs.isTUPolicy())
+      appendPolicySuffix("_tu");
+    else if (PolicyAttrs.isTAPolicy()) {
       if (HasPolicy)
         BuiltinName += "_ta";
-    }
-  } else {
-    if (IsMasked) {
-      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
-        llvm_unreachable("Unhandled policy condition");
-    } else {
-      if (PolicyAttrs.isTUPolicy())
-        appendPolicySuffix("_tu");
-      else if (PolicyAttrs.isTAPolicy())
-        appendPolicySuffix("_ta");
-      else
-        llvm_unreachable("Unhandled policy condition");
-    }
+    } else
+      llvm_unreachable("Unhandled policy condition");
   }
 }