Allow empty parameter list demangling

llvm/include/llvm/Analysis/VectorUtils.h

 //===- llvm/Analysis/VectorUtils.h - Vector utilities -----------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //

 ///
 /// \param MangledName -> input string in the format
 /// _ZGV<isa><mask><vlen><parameters>_<scalarname>[(<redirection>)].
 /// \param M -> Module used to retrieve informations about the vector
 /// function that are not possible to retrieve from the mangled
 /// name. At the moment, this parameter is needed only to retrieve the
 /// Vectorization Factor of scalable vector functions from their
 /// respective IR declarations.
-/// \param AllowEmptyParameter -> If true, this function will try to demangle
-/// even when the <parameters> list is empty. The x86 VFABI doc explicitly
-/// allows an empty parameter list.
 std::optional<VFInfo> tryDemangleForVFABI(StringRef MangledName,
-                                          const Module &M,
-                                          bool AllowEmptyParameter = false);
+                                          const Module &M);
 /// \param M -> The pointer to module used to retrieve informations about the
 /// vector function. If nullptr is passed, we don't check the existence of
 /// the demangled vector function.
 std::optional<VFInfo> tryDemangleForVFABI(StringRef MangledName,
-                                          const Module *M = nullptr,
-                                          bool AllowEmptyParameter = false);
-VFInfo demangleForVFABI(StringRef MangledName,
-                        bool AllowEmptyParameter = false);
+                                          const Module *M = nullptr);
+VFInfo demangleForVFABI(StringRef MangledName);
 
 /// This routine mangles the given VectorName according to the LangRef
 /// specification for vector-function-abi-variant attribute and is specific to
 /// the TLI mappings. It is the responsibility of the caller to make sure that
 /// this is only used if all parameters in the vector function are vector type.
 /// This returned string holds scalar-to-vector mapping:
 ///    _ZGV<isa><mask><vlen><vparams>_<scalarname>(<vectorname>)
 ///

llvm/lib/Analysis/VFABIDemangling.cpp

 //===- VFABIDemangling.cpp - Vector Function ABI demangling utilities. ---===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
ElementCount getECFromSignature(FunctionType *Signature) {
   for (auto *Ty : Signature->params())
     if (auto *VTy = dyn_cast<VectorType>(Ty))
       return VTy->getElementCount();
 
   return ElementCount::getFixed(/*Min=*/1);
 }
 } // namespace
 
-VFInfo VFABI::demangleForVFABI(StringRef MangledName,
-                               bool AllowEmptyParameter) {
-  auto VI = VFABI::tryDemangleForVFABI(MangledName, /*M = */ nullptr,
-                                       AllowEmptyParameter);
+VFInfo VFABI::demangleForVFABI(StringRef MangledName) {
+  auto VI = VFABI::tryDemangleForVFABI(MangledName, /*M = */ nullptr);
   assert(VI && "Invalid name for a VFABI variant.");
   return VI.value();
 }
 
 std::optional<VFInfo> VFABI::tryDemangleForVFABI(StringRef MangledName,
-                                                 const Module &M,
-                                                 bool AllowEmptyParameter) {
-  return VFABI::tryDemangleForVFABI(MangledName, &M, AllowEmptyParameter);
+                                                 const Module &M) {
+  return VFABI::tryDemangleForVFABI(MangledName, &M);
 }
 
 // Format of the ABI name:
 // _ZGV<isa><mask><vlen><parameters>_<scalarname>[(<redirection>)]
 std::optional<VFInfo> VFABI::tryDemangleForVFABI(StringRef MangledName,
-                                                 const Module *M,
-                                                 bool AllowEmptyParameter) {
+                                                 const Module *M) {
   const StringRef OriginalName = MangledName;
   // Assume there is no custom name <redirection>, and therefore the
   // vector name consists of
   // _ZGV<isa><mask><vlen><parameters>_<scalarname>.
   StringRef VectorName = MangledName;
 
   // Parse the fixed size part of the manled name
   if (!MangledName.consume_front("_ZGV"))
if (ParamFound == ParseRet::OK) {
       if (AlignFound == ParseRet::Error)
         return std::nullopt;
 
       // Add the parameter.
       Parameters.push_back({ParameterPos, PKind, StepOrPos, Alignment});
     }
   } while (ParamFound == ParseRet::OK);
 
-  if (!AllowEmptyParameter && Parameters.empty())
-    return std::nullopt;
-
   // Check for the <scalarname> and the optional <redirection>, which
   // are separated from the prefix with "_"
   if (!MangledName.consume_front("_"))
     return std::nullopt;
 
   // The rest of the string must be in the format:
   // <scalarname>[(<redirection>)]
   const StringRef ScalarName =

llvm/unittests/Analysis/VectorFunctionABITest.cpp

 //===------- VectorFunctionABITest.cpp - VFABI Unittests  ---------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
protected:
   // \p IRType -> FunctionType string to be used for the signature of
   // the vector function.  The correct signature is needed by the
   // parser only for scalable functions. For the sake of testing, the
   // generic fixed-length case can use as signature `void()`.
   //
   bool invokeParser(const StringRef MangledName,
                     const StringRef VectorName = "",
                     const StringRef IRType = "void()",
-                    bool CheckVectorNameExistence = true,
-                    bool AllowEmptyParameter = false) {
+                    bool CheckVectorNameExistence = true) {
     StringRef Name = MangledName;
     if (!VectorName.empty())
       Name = VectorName;
     // Reset the VFInfo and the Module to be able to invoke
     // `invokeParser` multiple times in the same test.
     reset(Name, IRType);
 
-    const auto OptInfo = CheckVectorNameExistence
-                             ? VFABI::tryDemangleForVFABI(
-                                   MangledName, *(M.get()), AllowEmptyParameter)
-                             : VFABI::tryDemangleForVFABI(MangledName, nullptr,
-                                                          AllowEmptyParameter);
+    const auto OptInfo = VFABI::tryDemangleForVFABI(
+        MangledName, CheckVectorNameExistence ? M.get() : nullptr);
     if (OptInfo) {
       Info = *OptInfo;
       return true;
     }
 
     return false;
   }
 
TEST_F(VFABIParserTest, OnlyValidNames) {
   // Incomplete string.
   EXPECT_FALSE(invokeParser(""));
   EXPECT_FALSE(invokeParser("_ZGV"));
   EXPECT_FALSE(invokeParser("_ZGVn"));
   EXPECT_FALSE(invokeParser("_ZGVnN"));
   EXPECT_FALSE(invokeParser("_ZGVnN2"));
   EXPECT_FALSE(invokeParser("_ZGVnN2v"));
   EXPECT_FALSE(invokeParser("_ZGVnN2v_"));
-  // Missing parameters.
-  EXPECT_FALSE(invokeParser("_ZGVnN2_foo"));
   // Missing _ZGV prefix.
   EXPECT_FALSE(invokeParser("_ZVnN2v_foo"));
   // Missing <isa>.
   EXPECT_FALSE(invokeParser("_ZGVN2v_foo"));
   // Missing <mask>.
   EXPECT_FALSE(invokeParser("_ZGVn2v_foo"));
   // Missing <vlen>.
   EXPECT_FALSE(invokeParser("_ZGVnNv_foo"));
   // Missing <scalarname>.
   EXPECT_FALSE(invokeParser("_ZGVnN2v_"));
   // Missing _ separator.
   EXPECT_FALSE(invokeParser("_ZGVnN2vfoo"));
   // Missing <vectorname>. Using `fakename` because the string being
   // parsed is not a valid function name that `invokeParser` can add.
   EXPECT_FALSE(invokeParser("_ZGVnN2v_foo()", "fakename"));
   // Unterminated name. Using `fakename` because the string being
   // parsed is not a valid function name that `invokeParser` can add.
   EXPECT_FALSE(invokeParser("_ZGVnN2v_foo(bar", "fakename"));
 }
 
 TEST_F(VFABIParserTest, EmptyParamList) {
-  EXPECT_TRUE(invokeParser(
-      "_ZGVnN2_foo", /*VectorName = */ "", /*IRType = */ "void()",
-      /*CheckVectorNameExistence = */ true, /*AllowEmptyParameter = */ true));
+  EXPECT_TRUE(invokeParser("_ZGVnN2_foo", /*VectorName = */ "",
+                           /*IRType = */ "void()"));
 }
 
 TEST_F(VFABIParserTest, DontCheckVectorNameExistence) {
   // Demangling succeeds even if `UserFunc` doesn't exist in the module.
   EXPECT_TRUE(invokeParser("_ZGVnM2v_sin(UserFunc)", /*VectorName = */ "",
                            /*IRType = */ "void()",
                            /*CheckVectorNameExistence = */ false));
   EXPECT_EQ(ScalarName, "sin");