[llvm][VectorUtils] Tweak VFShape for scalable vector functions.

[fpetrogalli]

Summary

This patch makes sure that the field VFShape.VF is greater than zero
when demangling the vector function name of scalable vector functions
encoded in the "vector-function-abi-variant" attribute.

This change is required to be able to provide instances of VFShape
that can be used to query the VFDatabase for the vectorization passes,
as such passes always require a positive value for the Vectorization Factor (VF)
needed by the vectorization process.

It is not possible to extract the value of VFShape.VF from the mangled
name of scalable vector functions, because it is encoded as
x. Therefore, the VFABI demangling function has been modified to
extract such information from the IR declaration of the vector
function, under the assumption that _all_ vectors in the signature of
the vector function have the same number of lanes. Such assumption is
valid because it is also assumed by the Vector Function ABI
specifications supported by the demangling function (x86, AArch64, and
LLVM internal one).

The unit tests that demangle scalable names have been modified by
adding the IR module that carries the declaration of the vector
function name being demangled.

In particular, the demangling function fails in the following cases:

1. When the declaration of the scalable vector function is not present in the module.

2. When the value of VFSHape.VF is not greater than 0.

[fpetrogalli]

Putting this on hold - I just found a problem with the fuzzer. I'll ping you when ready to review.

[fpetrogalli]

Fix the failure in the fuzzer.

[fpetrogalli]

Another fix in the fuzzer: make sure that the parser doesn't crash if
the input llvm::Module *M is set to nullptr.

[fpetrogalli]

OK, I have been running the fuzzer for ~1h, no failures: ready to review!

  PID USER      PR  NI    VIRT    RES    SHR S  %CPU %MEM     TIME+ COMMAND
34158 frapet01  38  18 20.000t 549332  51564 R  99.7  0.4  57:56.06 vfabi-demangler

[andwar]

A few nits. Also, in the commit msg:

• patche -> patch
• which always set a positive value -> which is always set to a positive value?
• mame ?

Maybe it would be good to add negative tests too? E.g. for when the module is missing.

llvm/lib/Analysis/VFABIDemangling.cpp

303

Why not if (auto RetTy = dyn_cast<VectorType>(Signature->getReturnType()))

332

Why not if (auto RetTy = dyn_cast<VectorType>(Signature->getReturnType())?

340

As per https://llvm.org/docs/CodingStandards.html#comment-formatting:

return {1 /*Min*/, false /*Scalable*/}; --> return {/*Min=*/1, /*Scalable=*/false};

llvm/tools/vfabi-demangle-fuzzer/vfabi-demangler-fuzzer.cpp

24–34

As per https://llvm.org/docs/CodingStandards.html#comment-formatting:

nullptr /*M*/ --> /*M=*/nullptr

[fpetrogalli]

Address code review from @andwar (thank you!).

I have added 2 tests:

1. Check that demangling of scalable names fails when the function

declaration is not present.

2. Check that VLEN=0 is invalid for fixed-length vector names.

[andwar]

One [nit] (non-blocking), otherwise LGTM.

llvm/lib/Analysis/VFABIDemangling.cpp

471

This should never be hit because for VF = 0 tryParseVLEN returns an error and getECFromSignature returns at least 1.

I'm just wondering, maybe less would be more here?

[fpetrogalli]

llvm/lib/Analysis/VFABIDemangling.cpp

471

This should never be hit because for VF = 0 tryParseVLEN returns an error and getECFromSignature returns at least 1.

yes, but...

I'm just wondering, maybe less would be more here?

... I'd rather leave the assert to make sure that if someone adds code after the invocation of tryParseVLEN that sets VF to zero, they get a failure to make them aware of the problem.

Alternatively, we could make VF in VFShape a class that can only be a strictly positive number... but that seems to be over-killing...

[jdoerfert]

Sorry for my delay. Some comments below.

llvm/include/llvm/Analysis/VectorUtils.h

170

Any reason one would not pass M here? If not, I would remove the default and maybe even make it required (via reference).

llvm/lib/Analysis/VFABIDemangling.cpp

302

Nit: using is not needed.

314

llvm::all_of

317

Nit: auto * and auto & wherever possible.

334

Let's be even more verbose here: ElementCount{...}

[fpetrogalli]

llvm/include/llvm/Analysis/VectorUtils.h

170

Could do - that will require changing all unit tests to provide a module though... are you happy for me to do that?

[jdoerfert]

llvm/include/llvm/Analysis/VectorUtils.h

170

I guess we can script it* so it should not be too bad work-wise. The question is, what do we want to achieve. If there is a use case that we want to support going forward which does not need the module, I'm fine with the pointer. If we are actually not anticipating such a use case we will just burden and confuse our future selves as we open up the possibility for all kinds of subtle bugs as someone forgot somewhere to pass a module, we should at least remove the default value.

• Something like

for file in $(ag --files-with-matches "tryDemangleForVFABI")
do
  sed -i -e 's:tryDemangleForVFABI(\([^)]*\)):tryDemangleForVFABI(\1, nullptr):' ${file}
done

(UNTESTED)

[fpetrogalli]

llvm/include/llvm/Analysis/VectorUtils.h

170

On the long term I have a plan to require the Module, because I think to make sense to store the FunctionType of the variant instead of the pair VF and Scalable in VFShape. This is to support cases in which the vectorization factor is not uniform across the signature of the vector function - for example, where one parameter has two lanes and the other one four. Admittedly, such cases are not supported by the current vectorizer and cannot be represented via the VFABI rules, but we want to make VFShape generic enough so that it does not prevent adding such support if needed.

I'd rather not do this change now, because I think this will go beyond the scope of this patch, where all what I am trying to do is to make sure that VF is never zero when demangling the vector function.

So I have opted for passing const Module & to the demagler, and for adding an assertion right after having discovered the vector name to be used that makes sure that the name is present in the module itself. I'll finish up this soon and upload it.

[jdoerfert]

LGTM, please address the nits mentioned here https://reviews.llvm.org/D73286#1845416

llvm/include/llvm/Analysis/VectorUtils.h

170

OK. Let's keep it for now this way.

[fpetrogalli]

I have addressed the feedback from @jdoerfert.

In particular, the parser method now requires a Module instance. The
parser fails if the function declaration is not present in the
module. For this reason, I tweaked the test fixture in the unittest so
that the module and the function definition is present.

Notice that (as explained inthe comments in the code), for the sake of
testing, the signature of the vector function in the module is
relevant only for vector names that represent scalable functions.

[jdoerfert]

thx.

llvm/include/llvm/Analysis/VectorUtils.h

 ///
 /// * AArch64: https://developer.arm.com/docs/101129/latest
 ///
 /// * x86 (libmvec): https://sourceware.org/glibc/wiki/libmvec and
 ///  https://sourceware.org/glibc/wiki/libmvec?action=AttachFile&do=view&target=VectorABI.txt
 ///
 /// \param MangledName -> input string in the format
 /// _ZGV<isa><mask><vlen><parameters>_<scalarname>[(<redirection>)].
-Optional<VFInfo> tryDemangleForVFABI(StringRef MangledName);
+/// \param M -> Module used to retrive informations about the vector
+/// function that are not possible to retrieve from the mangled
+/// name. At the moment, this parameter is needed only to retrive the
+/// Vectorization Factor of scalable vector functions from their
+/// respective IR declarations.
+Optional<VFInfo> tryDemangleForVFABI(StringRef MangledName, const Module &M);
 
 /// Retrieve the `VFParamKind` from a string token.
 VFParamKind getVFParamKindFromString(const StringRef Token);
 
 // Name of the attribute where the variant mappings are stored.
 static constexpr char const *MappingsAttrName = "vector-function-abi-variant";
 
 /// Populates a set of strings representing the Vector Function ABI variants
 /// associated to the CallInst CI.
const StringRef S =
         CI.getAttribute(AttributeList::FunctionIndex, VFABI::MappingsAttrName)
             .getValueAsString();
     if (S.empty())
       return;
 
     SmallVector<std::string, 8> ListOfStrings;
     VFABI::getVectorVariantNames(CI, ListOfStrings);
     for (const auto &MangledName : ListOfStrings) {
-      const Optional<VFInfo> Shape = VFABI::tryDemangleForVFABI(MangledName);
+      const Optional<VFInfo> Shape =
+          VFABI::tryDemangleForVFABI(MangledName, *(CI.getModule()));
       // A match is found via scalar and vector names, and also by
       // ensuring that the variant described in the attribute has a
       // corresponding definition or declaration of the vector
       // function in the Module M.
       if (Shape.hasValue() && (Shape.getValue().ScalarName == ScalarName)) {
         assert(CI.getModule()->getFunction(Shape.getValue().VectorName) &&
                "Vector function is missing.");
         Mappings.push_back(Shape.getValue());

llvm/lib/Analysis/VFABIDemangling.cpp

 
 /// Extract the `<vlen>` information from the mangled string, and
 /// sets `VF` accordingly. A `<vlen> == "x"` token is interpreted as a scalable
 /// vector length. On success, the `<vlen>` token is removed from
 /// the input string `ParseString`.
 ///
 ParseRet tryParseVLEN(StringRef &ParseString, unsigned &VF, bool &IsScalable) {
   if (ParseString.consume_front("x")) {
+    // Set VF to 0, to be later adjusted to a value grater than zero
+    // by looking at the signature of the vector function with
+    // `getECFromSignature`.
     VF = 0;
     IsScalable = true;
     return ParseRet::OK;
   }
 
   if (ParseString.consumeInteger(10, VF))
     return ParseRet::Error;
 
+  // The token `0` is invalid for VLEN.
+  if (VF == 0)
+    return ParseRet::Error;
+
   IsScalable = false;
   return ParseRet::OK;
 }
 
 /// The function looks for the following strings at the beginning of
 /// the input string `ParseString`:
 ///
 ///  <token> <number>
if (ParseString.consume_front("a")) {
 
     Alignment = Align(Val);
 
     return ParseRet::OK;
   }
 
   return ParseRet::None;
 }
+#ifndef NDEBUG
+// Verify the assumtion that all vectors in the signature of a vector
+// function have the same number of elements.
+bool verifyAllVectorsHaveSameWidth(FunctionType *Signature) {
+  SmallVector<VectorType *, 2> VecTys;
+  if (auto *RetTy = dyn_cast<VectorType>(Signature->getReturnType()))
+    VecTys.push_back(RetTy);
+  for (auto *Ty : Signature->params())
+    if (auto *VTy = dyn_cast<VectorType>(Ty))
+      VecTys.push_back(VTy);
+
+  if (VecTys.size() <= 1)
+    return true;
+
+  assert(VecTys.size() > 1 && "Invalid number of elements.");
+  const ElementCount EC = VecTys[0]->getElementCount();
+  return llvm::all_of(
+      llvm::make_range(VecTys.begin() + 1, VecTys.end()),
+      [&EC](VectorType *VTy) { return (EC == VTy->getElementCount()); });
+}
+
+#endif // NDEBUG
+
+// Extract the VectorizationFactor from a given function signature,
+// under the assumtion that all vectors have the same number of
+// elements, i.e. same ElementCount.Min.
+ElementCount getECFromSignature(FunctionType *Signature) {
+  assert(verifyAllVectorsHaveSameWidth(Signature) &&
+         "Invalid vector signature.");
+
+  if (auto *RetTy = dyn_cast<VectorType>(Signature->getReturnType()))
+    return RetTy->getElementCount();
+  for (auto *Ty : Signature->params())
+    if (auto *VTy = dyn_cast<VectorType>(Ty))
+      return VTy->getElementCount();
+
+  return ElementCount(/*Min=*/1, /*Scalable=*/false);
+}
 } // namespace
 
 // Format of the ABI name:
 // _ZGV<isa><mask><vlen><parameters>_<scalarname>[(<redirection>)]
-Optional<VFInfo> VFABI::tryDemangleForVFABI(StringRef MangledName) {
+Optional<VFInfo> VFABI::tryDemangleForVFABI(StringRef MangledName,
+                                            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"))
const auto NGlobalPreds = std::count_if(
       Parameters.begin(), Parameters.end(), [](const VFParameter PK) {
         return PK.ParamKind == VFParamKind::GlobalPredicate;
       });
   assert(NGlobalPreds < 2 && "Cannot have more than one global predicate.");
   if (NGlobalPreds)
     assert(Parameters.back().ParamKind == VFParamKind::GlobalPredicate &&
            "The global predicate must be the last parameter");
 
+  // Adjust the VF for scalable signatures. The EC.Min is not encoded
+  // in the name of the function, but it is encoded in the IR
+  // signature of the function. We need to extract this information
+  // because it is needed by the loop vectorizer, which reasons in
+  // terms of VectorizationFactor or ElementCount. In particular, we
+  // need to make sure that the VF field of the VFShape class is never
+  // set to 0.
+  if (IsScalable) {
+    const Function *F = M.getFunction(VectorName);
+    // The declaration of the function must be present in the module
+    // to be able to retrieve its signature.
+    if (!F)
+      return None;
+    const ElementCount EC = getECFromSignature(F->getFunctionType());
+    VF = EC.Min;
+  }
+
+  // Sanity checks.
+  // 1. We don't accept a zero lanes vectorization factor.
+  // 2. We don't accept the demangling if the vector function is not
+  // present in the module.
+  if (VF == 0)
+    return None;
+  if (!M.getFunction(VectorName))
+    return None;
+
   const VFShape Shape({VF, IsScalable, Parameters});
   return VFInfo({Shape, std::string(ScalarName), std::string(VectorName), ISA});
 }
 
 VFParamKind VFABI::getVFParamKindFromString(const StringRef Token) {
   const VFParamKind ParamKind = StringSwitch<VFParamKind>(Token)
                                     .Case("v", VFParamKind::Vector)
                                     .Case("l", VFParamKind::OMP_Linear)

llvm/lib/Analysis/VectorUtils.cpp

if (S.empty())
     return;
 
   SmallVector<StringRef, 8> ListAttr;
   S.split(ListAttr, ",");
 
   for (auto &S : SetVector<StringRef>(ListAttr.begin(), ListAttr.end())) {
 #ifndef NDEBUG
     LLVM_DEBUG(dbgs() << "VFABI: adding mapping '" << S << "'\n");
-    Optional<VFInfo> Info = VFABI::tryDemangleForVFABI(S);
+    Optional<VFInfo> Info = VFABI::tryDemangleForVFABI(S, *(CI.getModule()));
     assert(Info.hasValue() && "Invalid name for a VFABI variant.");
     assert(CI.getModule()->getFunction(Info.getValue().VectorName) &&
            "Vector function is missing.");
 #endif
     VariantMappings.push_back(std::string(S));
   }
 }
 

llvm/lib/Transforms/Utils/ModuleUtils.cpp

void VFABI::setVectorVariantNames(
   // Get rid of the trailing ','.
   assert(!Buffer.str().empty() && "Must have at least one char.");
   Buffer.pop_back();
 
   Module *M = CI->getModule();
 #ifndef NDEBUG
   for (const std::string &VariantMapping : VariantMappings) {
     LLVM_DEBUG(dbgs() << "VFABI: adding mapping '" << VariantMapping << "'\n");
-    Optional<VFInfo> VI = VFABI::tryDemangleForVFABI(VariantMapping);
+    Optional<VFInfo> VI = VFABI::tryDemangleForVFABI(VariantMapping, *M);
     assert(VI.hasValue() && "Cannot add an invalid VFABI name.");
     assert(M->getNamedValue(VI.getValue().VectorName) &&
            "Cannot add variant to attribute: "
            "vector function declaration is missing.");
   }
 #endif
   CI->addAttribute(
       AttributeList::FunctionIndex,
       Attribute::get(M->getContext(), MappingsAttrName, Buffer.str()));
 }

llvm/tools/vfabi-demangle-fuzzer/CMakeLists.txt

 set(LLVM_LINK_COMPONENTS
   Analysis
+  AsmParser
+  Core
   Support
 )
 add_llvm_fuzzer(vfabi-demangler-fuzzer
   vfabi-demangler-fuzzer.cpp
 )

llvm/tools/vfabi-demangle-fuzzer/vfabi-demangler-fuzzer.cpp

 //===-- vfabi-demangler-fuzzer.cpp - Fuzzer VFABI using lib/Fuzzer   ------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // Build tool to fuzz the demangler for the vector function ABI names.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/Analysis/VectorUtils.h"
+#include "llvm/AsmParser/Parser.h"
 
 using namespace llvm;
 
 extern "C" int LLVMFuzzerTestOneInput(const uint8_t *Data, size_t Size) {
+  LLVMContext Ctx;
+  SMDiagnostic Err;
+  const std::unique_ptr<Module> M =
+      parseAssemblyString("declare i32 @foo(i32 )\n", Err, Ctx);
   const StringRef MangledName((const char *)Data, Size);
-  const auto Info = VFABI::tryDemangleForVFABI(MangledName);
+  // Make sure that whatever symbol the demangler is operating on is
+  // present in the module (the signature is not important). This is
+  // because `tryDemangleForVFABI` fails if the function is not
+  // present. We need to make sure we can even invoke
+  // `getOrInsertFunction` because such method asserts on strings with
+  // zeroes.
+  if (!MangledName.empty() && MangledName.find_first_of(0) == StringRef::npos)
+    M->getOrInsertFunction(
+        MangledName,
+        FunctionType::get(Type::getVoidTy(M->getContext()), false));
+  const auto Info = VFABI::tryDemangleForVFABI(MangledName, *M);
 
   // Do not optimize away the return value. Inspired by
   // https://github.com/google/benchmark/blob/master/include/benchmark/benchmark.h#L307-L345
   asm volatile("" : : "r,m"(Info) : "memory");
 
   return 0;
 }

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
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/Analysis/VectorUtils.h"
 #include "llvm/AsmParser/Parser.h"
 #include "llvm/IR/InstIterator.h"
 #include "gtest/gtest.h"
 
 using namespace llvm;
 
-// This test makes sure that the demangling method succeeds only on
-// valid values of the string.
-TEST(VectorFunctionABITests, OnlyValidNames) {
-  // Incomplete string.
-  EXPECT_FALSE(VFABI::tryDemangleForVFABI("").hasValue());
-  EXPECT_FALSE(VFABI::tryDemangleForVFABI("_ZGV").hasValue());
-  EXPECT_FALSE(VFABI::tryDemangleForVFABI("_ZGVn").hasValue());
-  EXPECT_FALSE(VFABI::tryDemangleForVFABI("_ZGVnN").hasValue());
-  EXPECT_FALSE(VFABI::tryDemangleForVFABI("_ZGVnN2").hasValue());
-  EXPECT_FALSE(VFABI::tryDemangleForVFABI("_ZGVnN2v").hasValue());
-  EXPECT_FALSE(VFABI::tryDemangleForVFABI("_ZGVnN2v_").hasValue());
-  // Missing parameters.
-  EXPECT_FALSE(VFABI::tryDemangleForVFABI("_ZGVnN2_foo").hasValue());
-  // Missing _ZGV prefix.
-  EXPECT_FALSE(VFABI::tryDemangleForVFABI("_ZVnN2v_foo").hasValue());
-  // Missing <isa>.
-  EXPECT_FALSE(VFABI::tryDemangleForVFABI("_ZGVN2v_foo").hasValue());
-  // Missing <mask>.
-  EXPECT_FALSE(VFABI::tryDemangleForVFABI("_ZGVn2v_foo").hasValue());
-  // Missing <vlen>.
-  EXPECT_FALSE(VFABI::tryDemangleForVFABI("_ZGVnNv_foo").hasValue());
-  // Missing <scalarname>.
-  EXPECT_FALSE(VFABI::tryDemangleForVFABI("_ZGVnN2v_").hasValue());
-  // Missing _ separator.
-  EXPECT_FALSE(VFABI::tryDemangleForVFABI("_ZGVnN2vfoo").hasValue());
-  // Missing <vectorname>.
-  EXPECT_FALSE(VFABI::tryDemangleForVFABI("_ZGVnN2v_foo()").hasValue());
-  // Unterminated name.
-  EXPECT_FALSE(VFABI::tryDemangleForVFABI("_ZGVnN2v_foo(bar").hasValue());
-}
-
-TEST(VectorFunctionABITests, ParamListParsing) {
-  // Testing "vl16Ls32R3l"
-  const auto OptVFS = VFABI::tryDemangleForVFABI("_ZGVnN2vl16Ls32R3l_foo");
-  EXPECT_TRUE(OptVFS.hasValue());
-  const VFInfo VFS = OptVFS.getValue();
-  EXPECT_EQ(VFS.Shape.Parameters.size(), (unsigned)5);
-  EXPECT_EQ(VFS.Shape.Parameters[0], VFParameter({0, VFParamKind::Vector, 0}));
-  EXPECT_EQ(VFS.Shape.Parameters[1],
-            VFParameter({1, VFParamKind::OMP_Linear, 16}));
-  EXPECT_EQ(VFS.Shape.Parameters[2],
-            VFParameter({2, VFParamKind::OMP_LinearValPos, 32}));
-  EXPECT_EQ(VFS.Shape.Parameters[3],
-            VFParameter({3, VFParamKind::OMP_LinearRef, 3}));
-  EXPECT_EQ(VFS.Shape.Parameters[4],
-            VFParameter({4, VFParamKind::OMP_Linear, 1}));
-}
-
-TEST(VectorFunctionABITests, ScalarNameAndVectorName) {
-  // Parse Scalar Name
-  const auto A = VFABI::tryDemangleForVFABI("_ZGVnM2v_sin");
-  const auto B = VFABI::tryDemangleForVFABI("_ZGVnM2v_sin(UserFunc)");
-  const auto C = VFABI::tryDemangleForVFABI("_ZGVnM2v___sin_sin_sin");
-  EXPECT_TRUE(A.hasValue());
-  EXPECT_TRUE(B.hasValue());
-  EXPECT_TRUE(C.hasValue());
-  EXPECT_EQ(A.getValue().ScalarName, "sin");
-  EXPECT_EQ(B.getValue().ScalarName, "sin");
-  EXPECT_EQ(C.getValue().ScalarName, "__sin_sin_sin");
-  EXPECT_EQ(A.getValue().VectorName, "_ZGVnM2v_sin");
-  EXPECT_EQ(B.getValue().VectorName, "UserFunc");
-  EXPECT_EQ(C.getValue().VectorName, "_ZGVnM2v___sin_sin_sin");
-}
-
 namespace {
 // Test fixture needed that holds the veariables needed by the parser.
 class VFABIParserTest : public ::testing::Test {
 private:
   // Parser output.
   VFInfo Info;
-  // Reset the parser output references.
-  void reset() { Info = VFInfo(); }
+  // Reset the data needed for the test.
+  void reset(const StringRef Name, const StringRef IRType) {
+    M = parseAssemblyString("declare void @dummy()", Err, Ctx);
+    EXPECT_NE(M.get(), nullptr) << "Loading an invalid module.\n "
+                                << Err.getMessage() << "\n";
+    Type *Ty = parseType(IRType, Err, *(M.get()));
+    FunctionType *FTy = dyn_cast<FunctionType>(Ty);
+    EXPECT_NE(FTy, nullptr) << "Invalid function type string: " << IRType
+                            << "\n"
+                            << Err.getMessage() << "\n";
+    FunctionCallee F = M->getOrInsertFunction(Name, FTy);
+    EXPECT_NE(F.getCallee(), nullptr)
+        << "The function must be present in the module\n";
+    // Reset the VFInfo
+    Info = VFInfo();
+  }
 
+  // Data needed to load the optional IR passed to invokeParser
+  LLVMContext Ctx;
+  SMDiagnostic Err;
+  std::unique_ptr<Module> M;
+  //  CallInst *CI;
 protected:
   // Referencies to the parser output field.
   unsigned &VF = Info.Shape.VF;
   VFISAKind &ISA = Info.ISA;
   SmallVector<VFParameter, 8> &Parameters = Info.Shape.Parameters;
   std::string &ScalarName = Info.ScalarName;
   std::string &VectorName = Info.VectorName;
   bool &IsScalable = Info.Shape.IsScalable;
-  // Invoke the parser.
-  bool invokeParser(const StringRef MangledName) {
-    reset();
-    const auto OptInfo = VFABI::tryDemangleForVFABI(MangledName);
+  // Invoke the parser. We need to make sure that a function exist in
+  // the module because the parser fails if such function don't
+  // exists. Every time this method is invoked the state of the test
+  // is reset.
+  //
+  // \p MangledName -> the string the parser has to demangle.
+  //
+  // \p VectorName -> optional vector name that the method needs to
+  // use to create the function in the module if it differs from the
+  // standard mangled name.
+  //
+  // \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()") {
+    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 = VFABI::tryDemangleForVFABI(MangledName, *(M.get()));
     if (OptInfo.hasValue()) {
       Info = OptInfo.getValue();
       return true;
     }
 
     return false;
   }
   // Checks that 1. the last Parameter in the Shape is of type
   // VFParamKind::GlobalPredicate and 2. it is the only one of such
   // type.
   bool IsMasked() const {
     const auto NGlobalPreds =
         std::count_if(Info.Shape.Parameters.begin(),
                       Info.Shape.Parameters.end(), [](const VFParameter PK) {
                         return PK.ParamKind == VFParamKind::GlobalPredicate;
                       });
     return NGlobalPreds == 1 && Info.Shape.Parameters.back().ParamKind ==
                                     VFParamKind::GlobalPredicate;
   }
 };
 } // unnamed namespace
 
+// This test makes sure that the demangling method succeeds only on
+// valid values of the string.
+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, ParamListParsing) {
+  EXPECT_TRUE(invokeParser("_ZGVnN2vl16Ls32R3l_foo"));
+  EXPECT_EQ(Parameters.size(), (unsigned)5);
+  EXPECT_EQ(Parameters[0], VFParameter({0, VFParamKind::Vector, 0}));
+  EXPECT_EQ(Parameters[1], VFParameter({1, VFParamKind::OMP_Linear, 16}));
+  EXPECT_EQ(Parameters[2], VFParameter({2, VFParamKind::OMP_LinearValPos, 32}));
+  EXPECT_EQ(Parameters[3], VFParameter({3, VFParamKind::OMP_LinearRef, 3}));
+  EXPECT_EQ(Parameters[4], VFParameter({4, VFParamKind::OMP_Linear, 1}));
+}
+
+TEST_F(VFABIParserTest, ScalarNameAndVectorName_01) {
+  EXPECT_TRUE(invokeParser("_ZGVnM2v_sin"));
+  EXPECT_EQ(ScalarName, "sin");
+  EXPECT_EQ(VectorName, "_ZGVnM2v_sin");
+}
+
+TEST_F(VFABIParserTest, ScalarNameAndVectorName_02) {
+  EXPECT_TRUE(invokeParser("_ZGVnM2v_sin(UserFunc)", "UserFunc"));
+  EXPECT_EQ(ScalarName, "sin");
+  EXPECT_EQ(VectorName, "UserFunc");
+}
+
+TEST_F(VFABIParserTest, ScalarNameAndVectorName_03) {
+  EXPECT_TRUE(invokeParser("_ZGVnM2v___sin_sin_sin"));
+  EXPECT_EQ(ScalarName, "__sin_sin_sin");
+  EXPECT_EQ(VectorName, "_ZGVnM2v___sin_sin_sin");
+}
+
 TEST_F(VFABIParserTest, Parse) {
   EXPECT_TRUE(invokeParser("_ZGVnN2vls2Ls27Us4Rs5l1L10U100R1000_sin"));
   EXPECT_EQ(VF, (unsigned)2);
   EXPECT_FALSE(IsMasked());
   EXPECT_EQ(ISA, VFISAKind::AdvancedSIMD);
   EXPECT_FALSE(IsScalable);
   EXPECT_EQ(Parameters.size(), (unsigned)9);
   EXPECT_EQ(Parameters[0], VFParameter({0, VFParamKind::Vector, 0}));
   EXPECT_EQ(Parameters[1], VFParameter({1, VFParamKind::OMP_LinearPos, 2}));
   EXPECT_EQ(Parameters[2], VFParameter({2, VFParamKind::OMP_LinearValPos, 27}));
   EXPECT_EQ(Parameters[3], VFParameter({3, VFParamKind::OMP_LinearUValPos, 4}));
   EXPECT_EQ(Parameters[4], VFParameter({4, VFParamKind::OMP_LinearRefPos, 5}));
   EXPECT_EQ(Parameters[5], VFParameter({5, VFParamKind::OMP_Linear, 1}));
   EXPECT_EQ(Parameters[6], VFParameter({6, VFParamKind::OMP_LinearVal, 10}));
   EXPECT_EQ(Parameters[7], VFParameter({7, VFParamKind::OMP_LinearUVal, 100}));
   EXPECT_EQ(Parameters[8], VFParameter({8, VFParamKind::OMP_LinearRef, 1000}));
   EXPECT_EQ(ScalarName, "sin");
   EXPECT_EQ(VectorName, "_ZGVnN2vls2Ls27Us4Rs5l1L10U100R1000_sin");
 }
 
 TEST_F(VFABIParserTest, ParseVectorName) {
-  EXPECT_TRUE(invokeParser("_ZGVnN2v_sin(my_v_sin)"));
+  EXPECT_TRUE(invokeParser("_ZGVnN2v_sin(my_v_sin)", "my_v_sin"));
   EXPECT_EQ(VF, (unsigned)2);
   EXPECT_FALSE(IsMasked());
   EXPECT_FALSE(IsScalable);
   EXPECT_EQ(ISA, VFISAKind::AdvancedSIMD);
   EXPECT_EQ(Parameters.size(), (unsigned)1);
   EXPECT_EQ(Parameters[0], VFParameter({0, VFParamKind::Vector, 0}));
   EXPECT_EQ(ScalarName, "sin");
   EXPECT_EQ(VectorName, "my_v_sin");
TEST_F(VFABIParserTest, LinearWithCompileTimeNegativeStep) {
   EXPECT_EQ(Parameters[1], VFParameter({1, VFParamKind::OMP_LinearVal, -10}));
   EXPECT_EQ(Parameters[2], VFParameter({2, VFParamKind::OMP_LinearUVal, -100}));
   EXPECT_EQ(Parameters[3], VFParameter({3, VFParamKind::OMP_LinearRef, -1000}));
   EXPECT_EQ(ScalarName, "sin");
   EXPECT_EQ(VectorName, "_ZGVnN2ln1Ln10Un100Rn1000_sin");
 }
 
 TEST_F(VFABIParserTest, ParseScalableSVE) {
-  EXPECT_TRUE(invokeParser("_ZGVsMxv_sin"));
-  EXPECT_EQ(VF, (unsigned)0);
+  EXPECT_TRUE(invokeParser(
+      "_ZGVsMxv_sin(custom_vg)", "custom_vg",
+      "<vscale x 2 x i32>(<vscale x 2 x i32>, <vscale x 2 x i1>)"));
+  EXPECT_EQ(VF, (unsigned)2);
   EXPECT_TRUE(IsMasked());
   EXPECT_TRUE(IsScalable);
   EXPECT_EQ(ISA, VFISAKind::SVE);
   EXPECT_EQ(ScalarName, "sin");
-  EXPECT_EQ(VectorName, "_ZGVsMxv_sin");
+  EXPECT_EQ(VectorName, "custom_vg");
 }
 
 TEST_F(VFABIParserTest, ParseFixedWidthSVE) {
   EXPECT_TRUE(invokeParser("_ZGVsM2v_sin"));
   EXPECT_EQ(VF, (unsigned)2);
   EXPECT_TRUE(IsMasked());
   EXPECT_FALSE(IsScalable);
   EXPECT_EQ(ISA, VFISAKind::SVE);
TEST_F(VFABIParserTest, ISA) {
   EXPECT_EQ(ISA, VFISAKind::AVX2);
 
   EXPECT_TRUE(invokeParser("_ZGVeN2v_sin"));
   EXPECT_EQ(ISA, VFISAKind::AVX512);
 }
 
 TEST_F(VFABIParserTest, LLVM_ISA) {
   EXPECT_FALSE(invokeParser("_ZGV_LLVM_N2v_sin"));
-  EXPECT_TRUE(invokeParser("_ZGV_LLVM_N2v_sin_(vector_name)"));
+  EXPECT_TRUE(invokeParser("_ZGV_LLVM_N2v_sin_(vector_name)", "vector_name"));
   EXPECT_EQ(ISA, VFISAKind::LLVM);
 }
 
 TEST_F(VFABIParserTest, InvalidMask) {
   EXPECT_FALSE(invokeParser("_ZGVsK2v_sin"));
 }
 
 TEST_F(VFABIParserTest, InvalidParameter) {
#define __COMMON_CHECKS                                                        \
 
   // AVX512: <isa> = "e"
   EXPECT_TRUE(invokeParser("_ZGVeN2vls2Ls27Us4Rs5l1L10U100R1000u2_sin"));
   EXPECT_EQ(ISA, VFISAKind::AVX512);
   __COMMON_CHECKS;
   EXPECT_EQ(VectorName, "_ZGVeN2vls2Ls27Us4Rs5l1L10U100R1000u2_sin");
 
   // LLVM: <isa> = "_LLVM_" internal vector function.
-  EXPECT_TRUE(
-      invokeParser("_ZGV_LLVM_N2vls2Ls27Us4Rs5l1L10U100R1000u2_sin(vectorf)"));
+  EXPECT_TRUE(invokeParser(
+      "_ZGV_LLVM_N2vls2Ls27Us4Rs5l1L10U100R1000u2_sin(vectorf)", "vectorf"));
   EXPECT_EQ(ISA, VFISAKind::LLVM);
   __COMMON_CHECKS;
   EXPECT_EQ(VectorName, "vectorf");
 
   // Unknown ISA (randomly using "q"). This test will need update if
   // some targets decide to use "q" as their ISA token.
   EXPECT_TRUE(invokeParser("_ZGVqN2vls2Ls27Us4Rs5l1L10U100R1000u2_sin"));
   EXPECT_EQ(ISA, VFISAKind::Unknown);
TEST_F(VFABIParserTest, ParseMaskingAVX512) {
   EXPECT_EQ(ISA, VFISAKind::AVX512);
   EXPECT_EQ(Parameters.size(), (unsigned)2);
   EXPECT_EQ(Parameters[0], VFParameter({0, VFParamKind::Vector}));
   EXPECT_EQ(Parameters[1], VFParameter({1, VFParamKind::GlobalPredicate}));
   EXPECT_EQ(ScalarName, "sin");
 }
 
 TEST_F(VFABIParserTest, ParseMaskingLLVM) {
-  EXPECT_TRUE(invokeParser("_ZGV_LLVM_M2v_sin(custom_vector_sin)"));
+  EXPECT_TRUE(invokeParser("_ZGV_LLVM_M2v_sin(custom_vector_sin)",
+                           "custom_vector_sin"));
   EXPECT_EQ(VF, (unsigned)2);
   EXPECT_TRUE(IsMasked());
   EXPECT_FALSE(IsScalable);
   EXPECT_EQ(ISA, VFISAKind::LLVM);
   EXPECT_EQ(Parameters.size(), (unsigned)2);
   EXPECT_EQ(Parameters[0], VFParameter({0, VFParamKind::Vector}));
   EXPECT_EQ(Parameters[1], VFParameter({1, VFParamKind::GlobalPredicate}));
   EXPECT_EQ(ScalarName, "sin");
   EXPECT_EQ(VectorName, "custom_vector_sin");
 }
 
 TEST_F(VFABIParserTest, ParseScalableMaskingLLVM) {
-  EXPECT_TRUE(invokeParser("_ZGV_LLVM_Mxv_sin(custom_vector_sin)"));
+  EXPECT_TRUE(invokeParser(
+      "_ZGV_LLVM_Mxv_sin(custom_vector_sin)", "custom_vector_sin",
+      "<vscale x 2 x i32> (<vscale x 2 x i32>, <vscale x 2 x i1>)"));
   EXPECT_TRUE(IsMasked());
+  EXPECT_EQ(VF, (unsigned)2);
   EXPECT_TRUE(IsScalable);
   EXPECT_EQ(ISA, VFISAKind::LLVM);
   EXPECT_EQ(Parameters.size(), (unsigned)2);
   EXPECT_EQ(Parameters[0], VFParameter({0, VFParamKind::Vector}));
   EXPECT_EQ(Parameters[1], VFParameter({1, VFParamKind::GlobalPredicate}));
   EXPECT_EQ(ScalarName, "sin");
   EXPECT_EQ(VectorName, "custom_vector_sin");
 }
 
 TEST_F(VFABIParserTest, ParseScalableMaskingLLVMSincos) {
-  EXPECT_TRUE(invokeParser("_ZGV_LLVM_Mxvl8l8_sincos(custom_vector_sincos)"));
+  EXPECT_TRUE(invokeParser("_ZGV_LLVM_Mxvl8l8_sincos(custom_vector_sincos)",
+                           "custom_vector_sincos",
+                           "void(<vscale x 2 x double>, double *, double *)"));
+  EXPECT_EQ(VF, (unsigned)2);
   EXPECT_TRUE(IsMasked());
   EXPECT_TRUE(IsScalable);
   EXPECT_EQ(ISA, VFISAKind::LLVM);
   EXPECT_EQ(Parameters.size(), (unsigned)4);
   EXPECT_EQ(Parameters[0], VFParameter({0, VFParamKind::Vector}));
   EXPECT_EQ(Parameters[1], VFParameter({1, VFParamKind::OMP_Linear, 8}));
   EXPECT_EQ(Parameters[2], VFParameter({2, VFParamKind::OMP_Linear, 8}));
   EXPECT_EQ(Parameters[3], VFParameter({3, VFParamKind::GlobalPredicate}));
TEST_F(VFABIAttrTest, Read) {
   SmallVector<std::string, 8> Exp;
   Exp.push_back("_ZGVnN2v_g(custom_vg)");
   Exp.push_back("_ZGVnN4v_g");
   EXPECT_EQ(Mappings, Exp);
 }
 
 TEST_F(VFABIParserTest, LLVM_InternalISA) {
   EXPECT_FALSE(invokeParser("_ZGV_LLVM_N2v_sin"));
-  EXPECT_TRUE(invokeParser("_ZGV_LLVM_N2v_sin_(vector_name)"));
+  EXPECT_TRUE(invokeParser("_ZGV_LLVM_N2v_sin_(vector_name)", "vector_name"));
   EXPECT_EQ(ISA, VFISAKind::LLVM);
 }
 
 TEST_F(VFABIParserTest, IntrinsicsInLLVMIsa) {
-  EXPECT_TRUE(invokeParser("_ZGV_LLVM_N4vv_llvm.pow.f32(__svml_powf4)"));
+  EXPECT_TRUE(invokeParser("_ZGV_LLVM_N4vv_llvm.pow.f32(__svml_powf4)",
+                           "__svml_powf4"));
   EXPECT_EQ(VF, (unsigned)4);
   EXPECT_FALSE(IsMasked());
   EXPECT_FALSE(IsScalable);
   EXPECT_EQ(ISA, VFISAKind::LLVM);
   EXPECT_EQ(Parameters.size(), (unsigned)2);
   EXPECT_EQ(Parameters[0], VFParameter({0, VFParamKind::Vector}));
   EXPECT_EQ(Parameters[1], VFParameter({1, VFParamKind::Vector}));
   EXPECT_EQ(ScalarName, "llvm.pow.f32");
 }
+
+TEST_F(VFABIParserTest, ParseScalableRequiresDeclaration) {
+  const char *MangledName = "_ZGVsMxv_sin(custom_vg)";
+  // The parser succeds only when the correct function definition of
+  // `custom_vg` is added to the module.
+  EXPECT_FALSE(invokeParser(MangledName));
+  EXPECT_TRUE(invokeParser(
+      MangledName, "custom_vg",
+      "<vscale x 4 x double>(<vscale x 4 x double>, <vscale x 4 x i1>)"));
+}
+
+TEST_F(VFABIParserTest, ZeroIsInvalidVLEN) {
+  EXPECT_FALSE(invokeParser("_ZGVeM0v_sin"));
+  EXPECT_FALSE(invokeParser("_ZGVeN0v_sin"));
+  EXPECT_FALSE(invokeParser("_ZGVsM0v_sin"));
+  EXPECT_FALSE(invokeParser("_ZGVsN0v_sin"));
+}