[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

391

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

473

Same here.

clang/lib/Sema/SemaRISCVVectorLookup.cpp

151

Ditto.

clang/lib/Support/RISCVVIntrinsicUtils.cpp

851

Ditto.

1014

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) {}
+  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;
   }
 
   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 isUnspecified() const { return IsUnspecified; }
 
   bool operator==(const Policy &Other) const {
     return IsUnspecified == Other.IsUnspecified &&
-           TailPolicy == Other.TailPolicy && MaskPolicy == Other.MaskPolicy &&
-           IntrinsicWithoutMU == Other.IntrinsicWithoutMU;
+           TailPolicy == Other.TailPolicy && MaskPolicy == Other.MaskPolicy;
   }
 
   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:
   std::string BuiltinName; // Builtin name
   std::string Name;        // C intrinsic name.
   std::string OverloadedName;
   std::string IRName;
   bool IsMasked;
   bool HasMaskedOffOperand;
   bool HasVL;
   PolicyScheme Scheme;
+  const bool HasTailPolicy, HasMaskPolicy;
   bool SupportOverloading;
   bool HasBuiltinAlias;
   std::string ManualCodegen;
   RVVTypePtr OutputType; // Builtin output type
   RVVTypes InputTypes;   // Builtin input types
   // The types we use to obtain the specific LLVM intrinsic. They are index of
   // InputTypes. -1 means the return type.
   std::vector<int64_t> IntrinsicTypes;
   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 HasVL, PolicyScheme Scheme, const bool HasTailPolicy,
+               const bool HasMaskPolicy, 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; }
computeBuiltinTypes(llvm::ArrayRef<PrototypeDescriptor> Prototype,
                       unsigned NF, PolicyScheme DefaultScheme,
                       Policy PolicyAttrs);
 
   static llvm::SmallVector<Policy> getSupportedUnMaskedPolicies();
   static llvm::SmallVector<Policy>
       getSupportedMaskedPolicies(bool HasTailPolicy, bool HasMaskPolicy);
 
   static void updateNamesAndPolicy(bool IsMasked, bool HasPolicy,
-                                   std::string &Name, std::string &BuiltinName,
+                                   const bool HasTailPolicy,
+                                   const bool HasMaskPolicy, 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,

clang/lib/Sema/SemaRISCVVectorLookup.cpp

private:
   StringMap<RVVOverloadIntrinsicDef> OverloadIntrinsics;
 
   // Create IntrinsicList
   void InitIntrinsicList();
 
   // Create RVVIntrinsicDef.
   void InitRVVIntrinsic(const RVVIntrinsicRecord &Record, StringRef SuffixStr,
                         StringRef OverloadedSuffixStr, bool IsMask,
-                        RVVTypes &Types, bool HasPolicy, Policy PolicyAttrs);
+                        RVVTypes &Types, bool HasPolicy, Policy PolicyAttrs,
+                        const bool HasTailPolicy, const bool HasMaskPolicy);
 
   // 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) {
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, Policy(), Record.HasTailPolicy,
+                         Record.HasMaskPolicy);
 
         // 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);
             Optional<RVVTypes> PolicyTypes = TypeCache.computeTypes(
                 BaseType, Log2LMUL, Record.NF, PolicyPrototype);
             InitRVVIntrinsic(Record, SuffixStr, OverloadedSuffixStr,
                              /*IsMask=*/false, *PolicyTypes, UnMaskedHasPolicy,
-                             P);
+                             P, Record.HasTailPolicy, Record.HasMaskPolicy);
           }
         }
         if (!Record.HasMasked)
           continue;
         // Create masked intrinsic.
         Optional<RVVTypes> MaskTypes =
             TypeCache.computeTypes(BaseType, Log2LMUL, Record.NF, ProtoMaskSeq);
         InitRVVIntrinsic(Record, SuffixStr, OverloadedSuffixStr, true,
-                         *MaskTypes, MaskedHasPolicy, Policy());
+                         *MaskTypes, MaskedHasPolicy, Policy(),
+                         Record.HasTailPolicy, Record.HasMaskPolicy);
         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);
           Optional<RVVTypes> PolicyTypes = TypeCache.computeTypes(
               BaseType, Log2LMUL, Record.NF, PolicyPrototype);
           InitRVVIntrinsic(Record, SuffixStr, OverloadedSuffixStr,
-                           /*IsMask=*/true, *PolicyTypes, MaskedHasPolicy, P);
+                           /*IsMask=*/true, *PolicyTypes, MaskedHasPolicy, P,
+                           Record.HasTailPolicy, Record.HasMaskPolicy);
         }
       } // End for different LMUL
     } // End for different TypeRange
   }
 }
 
 // Compute name and signatures for intrinsic with practical types.
 void RISCVIntrinsicManagerImpl::InitRVVIntrinsic(
     const RVVIntrinsicRecord &Record, StringRef SuffixStr,
     StringRef OverloadedSuffixStr, bool IsMasked, RVVTypes &Signature,
-    bool HasPolicy, Policy PolicyAttrs) {
+    bool HasPolicy, Policy PolicyAttrs, const bool HasTailPolicy,
+    const bool HasMaskPolicy) {
   // Function name, e.g. vadd_vv_i32m1.
   std::string Name = Record.Name;
   if (!SuffixStr.empty())
     Name += "_" + SuffixStr.str();
 
   // Overloaded function name, e.g. vadd.
   std::string OverloadedName;
   if (!Record.OverloadedName)
     OverloadedName = StringRef(Record.Name).split("_").first.str();
   else
     OverloadedName = Record.OverloadedName;
   if (!OverloadedSuffixStr.empty())
     OverloadedName += "_" + OverloadedSuffixStr.str();
 
   // clang built-in function name, e.g. __builtin_rvv_vadd.
   std::string BuiltinName = "__builtin_rvv_" + std::string(Record.Name);
 
-  RVVIntrinsic::updateNamesAndPolicy(IsMasked, HasPolicy, Name, BuiltinName,
+  RVVIntrinsic::updateNamesAndPolicy(IsMasked, HasPolicy, HasTailPolicy,
+                                     HasMaskPolicy, Name, BuiltinName,
                                      OverloadedName, PolicyAttrs);
 
   // Put into IntrinsicList.
   size_t Index = IntrinsicList.size();
   IntrinsicList.push_back({Name, OverloadedName, BuiltinName, Signature});
 
   // Creating mapping to Intrinsics.
   Intrinsics.insert({Name, Index});

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,
+                           PolicyScheme Scheme, const bool HasTailPolicy,
+                           const bool HasMaskPolicy, 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),
+      HasTailPolicy(HasTailPolicy), HasMaskPolicy(HasMaskPolicy),
       SupportOverloading(SupportOverloading), HasBuiltinAlias(HasBuiltinAlias),
       ManualCodegen(ManualCodegen.str()), NF(NF), PolicyAttrs(NewPolicyAttrs) {
 
   // Init BuiltinName, Name and OverloadedName
   BuiltinName = NewName.str();
   Name = BuiltinName;
   if (NewOverloadedName.empty())
     OverloadedName = NewName.split("_").first.str();
   else
     OverloadedName = NewOverloadedName.str();
   if (!Suffix.empty())
     Name += "_" + Suffix.str();
   if (!OverloadedSuffix.empty())
     OverloadedName += "_" + OverloadedSuffix.str();
 
-  updateNamesAndPolicy(IsMasked, hasPolicy(), Name, BuiltinName, OverloadedName,
-                       PolicyAttrs);
+  updateNamesAndPolicy(IsMasked, hasPolicy(), HasTailPolicy, HasMaskPolicy,
+                       Name, BuiltinName, OverloadedName, PolicyAttrs);
 
   // Init OutputType and InputTypes
   OutputType = OutInTypes[0];
   InputTypes.assign(OutInTypes.begin() + 1, OutInTypes.end());
 
   // IntrinsicTypes is unmasked TA version index. Need to update it
   // if there is merge operand (It is always in first operand).
   IntrinsicTypes = NewIntrinsicTypes;
return {Policy(Policy::PolicyType::Undisturbed,
             Policy(Policy::PolicyType::Agnostic,
                    Policy::PolicyType::Agnostic), // TAMA
             Policy(Policy::PolicyType::Undisturbed,
                    Policy::PolicyType::Undisturbed), // TUMU
             Policy(Policy::PolicyType::Agnostic,
                    Policy::PolicyType::Undisturbed)}; // TAMU
   if (HasTailPolicy && !HasMaskPolicy)
     return {Policy(Policy::PolicyType::Undisturbed,
-                   Policy::PolicyType::Agnostic, true), // TUM
-            Policy(Policy::PolicyType::Agnostic, Policy::PolicyType::Agnostic,
-                   true)}; // TAM
+                   Policy::PolicyType::Agnostic), // TUM
+            Policy(Policy::PolicyType::Agnostic,
+                   Policy::PolicyType::Agnostic)}; // TAM
   if (!HasTailPolicy && HasMaskPolicy)
     return {
         Policy(Policy::PolicyType::Omit, Policy::PolicyType::Agnostic), // MA
         Policy(Policy::PolicyType::Omit,
                Policy::PolicyType::Undisturbed)}; // 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) {
+void RVVIntrinsic::updateNamesAndPolicy(
+    bool IsMasked, bool HasPolicy, const bool HasTailPolicy,
+    const bool HasMaskPolicy, 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()) {
if (IsMasked) {
       else
         BuiltinName += "_m";
     } else {
       PolicyAttrs.TailPolicy = Policy::PolicyType::Agnostic;
       if (HasPolicy)
         BuiltinName += "_ta";
     }
   } else {
-    if (PolicyAttrs.isTUMPolicy())
+    if (PolicyAttrs.isTUMAPolicy() && !HasMaskPolicy)
       appendPolicySuffix("_tum");
-    else if (PolicyAttrs.isTAMPolicy())
+    else if (PolicyAttrs.isTAMAPolicy() && !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() && !HasTailPolicy) {
       appendPolicySuffix("_mu");
       PolicyAttrs.TailPolicy = Policy::PolicyType::Agnostic;
-    } else if (PolicyAttrs.isMAPolicy()) {
+    } else if (PolicyAttrs.isMAPolicy() && !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 (char I : TypeRange) {
         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()));
+            UnMaskedPolicyScheme, HasTailPolicy, HasMaskPolicy,
+            SupportOverloading, HasBuiltinAlias, ManualCodegen, *Types,
+            IntrinsicTypes, RequiredFeatures, NF, Policy()));
         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 =
                 TypeCache.computeTypes(BT, Log2LMUL, NF, PolicyPrototype);
             Out.push_back(std::make_unique<RVVIntrinsic>(
                 Name, SuffixStr, OverloadedName, OverloadedSuffixStr, IRName,
                 /*IsMask=*/false, /*HasMaskedOffOperand=*/false, HasVL,
-                UnMaskedPolicyScheme, SupportOverloading, HasBuiltinAlias,
-                ManualCodegen, *PolicyTypes, IntrinsicTypes, RequiredFeatures,
-                NF, P));
+                UnMaskedPolicyScheme, HasTailPolicy, HasMaskPolicy,
+                SupportOverloading, HasBuiltinAlias, ManualCodegen,
+                *PolicyTypes, IntrinsicTypes, RequiredFeatures, NF, P));
           }
         if (!HasMasked)
           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()));
+            HasTailPolicy, HasMaskPolicy, SupportOverloading, HasBuiltinAlias,
+            ManualCodegen, *MaskTypes, IntrinsicTypes, RequiredFeatures, NF,
+            Policy()));
         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 =
               TypeCache.computeTypes(BT, Log2LMUL, NF, PolicyPrototype);
           Out.push_back(std::make_unique<RVVIntrinsic>(
               Name, SuffixStr, OverloadedName, OverloadedSuffixStr,
               MaskedIRName, /*IsMasked=*/true, HasMaskedOffOperand, HasVL,
-              MaskedPolicyScheme, SupportOverloading, HasBuiltinAlias,
-              ManualCodegen, *PolicyTypes, IntrinsicTypes, RequiredFeatures, NF,
-              P));
+              MaskedPolicyScheme, HasTailPolicy, HasMaskPolicy,
+              SupportOverloading, HasBuiltinAlias, ManualCodegen, *PolicyTypes,
+              IntrinsicTypes, RequiredFeatures, NF, P));
         }
       } // End for Log2LMULList
     }   // End for TypeRange
 
     // We don't emit vsetvli and vsetvlimax for SemaRecord.
     // They are written in riscv_vector.td and will emit those marco define in
     // riscv_vector.h
     if (Name == "vsetvli" || Name == "vsetvlimax")