[SVFS] Vector Function ABI name demangler.

[fpetrogalli]

Summary

This patch implements the demangling functionality as described in the
Vector Function ABI. This patch will be used to implement the
SearchVectorFunctionSystem(SVFS) as described in the RFC:

http://lists.llvm.org/pipermail/llvm-dev/2019-June/133484.html

A fuzzer is added to test the demangling utility.

[lebedev.ri]

2 comments:

• It will be a good idea to add a fuzzer target for VFABI::getVectorName() specifically from the get go.
• This is likely a dubious question, but is this mangling compatible with other implementations, e.g. GCC?

[aranisumedh]

@lebedev.ri

1. Could you elaborate about the fuzzer target? The VFABI::getVectorName() extracts the custom redirection to a user-specified function that can be described using #pragma declare variant
2. If I understood you correctly, yes, this name mangling format is as specified in the ABI. It is also supported by other implementations such as GCC. The following link is a demonstration of the same which uses GCC compiler. [https://godbolt.org/z/PrGLn0]

[lebedev.ri]

In D66024#1623639, @aranisumedh wrote:

@lebedev.ri

1. Could you elaborate about the fuzzer target?

All the parsing code is always extremely prone to subtle bugs.
At least it should not crash on them.
That would be easy to ensure via a fuzz target.

The VFABI::getVectorName() extracts the custom redirection to a user-specified function that can be described using #pragma declare variant

2. If I understood you correctly, yes, this name mangling format is as specified in the ABI. It is also supported by other implementations such as GCC. The following link is a demonstration of the same which uses GCC compiler. [https://godbolt.org/z/PrGLn0]

Great, just checking.

[aranisumedh]

All the parsing code is always extremely prone to subtle bugs.
At least it should not crash on them.
That would be easy to ensure via a fuzz target.

Sorry for being naive here, but what is a fuzz target? I have also added several test cases to test for known corner cases.

[lebedev.ri]

In D66024#1623711, @aranisumedh wrote:

All the parsing code is always extremely prone to subtle bugs.
At least it should not crash on them.
That would be easy to ensure via a fuzz target.

Sorry for being naive here, but what is a fuzz target?

Oh, i should have clarified.
See e.g. llvm/tools/llvm-dwarfdump/fuzzer/llvm-dwarfdump-fuzzer.cpp, llvm/tools/*-fuzzer.

I have also added several test cases to test for known corner cases.

llvm/include/llvm/Analysis/SearchVectorFunctionSystem.h

29 ↗

(On Diff #214419)

All these are currently in llvm namespace, would it be better to narrow it and put them into VFABI?

[aranisumedh]

llvm/include/llvm/Analysis/SearchVectorFunctionSystem.h

29 ↗

(On Diff #214419)

Someone correct me if I am wrong.

This module is intended to be extensible to other vectorization as well (as stated in the RFC). I am assuming that it can be extended to other ParameterKind as well.

Whereas the name demangling for now is as stated in the vector function ABI and hence a part of the VFABI namespace.

[sdesmalen]

Thanks for splitting this functionality off into a separate patch!
I added some comments inline, but my main points are:

• that it would be better to parse the mangled string incrementally, rather than extracting each feature from the string individually.
• if you change this patch to parse incrementally, interfaces such as getIsMasked or getISA should probably be private methods to VectorFunctionShape, and be renamed to parseIsMasked and parseISA.

llvm/include/llvm/Analysis/SearchVectorFunctionSystem.h

149 ↗

(On Diff #214419)

I don't think we want to expose any of these interfaces directly, as they are only relevant to the parsing of the mangled name vis-a-vis the construction of the VectorFunctionShape object. After it has been parsed, the VectorFunctionShape object can be queried directly for these properties.

If you make them private methods to VectorFunctionShape, then a constructor of VectorFunctionShape can take StringRef MangledName and parse the string to fill out the object, calling all these interfaces under the hood. For this reason, I think you'll want to move demangleName and getParameters from D66025 to this patch as well.

I'd also recommend renaming these functions to use 'parse' instead of 'get', and instead of returning the value that they have parsed directly, you can wrap it in a Optional<>, so you can check whether an issue occurred while parsing the mangled name.

llvm/lib/Analysis/SearchVectorFunctionSystem.cpp

52 ↗

(On Diff #214419)

If you implement these methods as 'parse' methods, you can simplify the code by just updating the StringRef for MangledName. e.g.

// note that MangledName is now a reference, so when the value
// is parsed it is sliced off from the name.
Optional<bool> parseMask(StringRef &MangledName) { 
  bool Mask;
  switch (MangledName[0]) {
  case 'N':
    Mask = false;
    break;
  case 'M' :
    Mask = true;
    break;
  default:
    // parse failure, return nothing (caller can choose to
    // error or recover). MangledName is not updated.
    return {};
  }
  MangledName = MangledName.drop_front(1);
  return {Mask};
}

for parseVF, you can do something along the lines of:

Optional<unsigned> parseVF(StringRef &MangledName) {
  // Get the string containing the VF
  StringRef VFString = MangledName.take_until([](char c) { return ::isdigit(c); });

  unsigned VF;
  if (VFString.consumeInteger(10, VF))
    return {}; // Could not parse as integer

  // Successfully parsed, so update MangledName.
  MangledName.drop_front(VFString.size());
  return {VF};
}

llvm/unittests/Analysis/SearchVectorFunctionSystemTest.cpp

1 ↗

(On Diff #214419)

Do you want to rename this test to something like VectorFunctionABITest.cpp ?

[jdoerfert]

llvm/include/llvm/Analysis/SearchVectorFunctionSystem.h

29 ↗

(On Diff #214419)

I'm with @lebedev.ri, ParameterKind and ParamType are such generic names that one can easily see errors in the future of someone "seeing" that definition but not the intended one. What is the problem with wrapping this in the VFABI namespace even if we use it in other contexts?

[aranisumedh]

llvm/include/llvm/Analysis/SearchVectorFunctionSystem.h

29 ↗

(On Diff #214419)

I see the point you're trying to make. I'll wrap the ParameterKind and ParamType in the same namespace as the rest.

149 ↗

(On Diff #214419)

I'd also recommend renaming these functions to use 'parse' instead of 'get',

Will do.

and instead of returning the value that they have parsed directly, you can wrap it in a Optional<>, so you can check whether an issue occurred while parsing the mangled name.

I have used asserts for error handling. Also, vector function ABI doesn't allow any fields to be optional. Any mismatch is a failure.

[aranisumedh]

Thank you all for valuable comments. I have made the changes as requested so far.

Still trying to figure out the *-fuzzer part. Will add support for same soon.

[aranisumedh]

Had a minor bug in the previous patch. Updated it.

[aranisumedh]

Minor Update. Cosmetic changes.

[fpetrogalli]

Hi all,

thank you for the reviews so far.

I am picking up this change-set to continue working on it. Thank you @aranisumedh for your work!

Question: what is the fuzzer supposed to do? Generate random strings to be parsed by VABI::getVectorName?

Francesco

[fpetrogalli]

llvm/include/llvm/Analysis/SearchVectorFunctionSystem.h

29 ↗

(On Diff #214419)

@lebedev.ri, @jdoerfert I agree that the names ParameterKind and ParamType are too generic to be exposed in the llvm namespace, but I think that moving them in the VABI namespace might not be the right thing to do. These enum and structure are supposed to support other types of parameters of vector function that might not be OpenMP specific or directly related to a vector function ABI specification. This is one of the goals of the RFC submitted for the SVFS.

Therefore I suggest to move them back to the llvm namespace, with names that will make it clar that we are talking about function vectorization.

How about the following?

ParameterKind -> VectorFunctionParameterKind or VFParameterKind
ParamType -> VectorFunctionParameter or VFParameter (we might want get rid of the Type token too)

Does that make sense to you?

[fpetrogalli]

I have uploaded a new version with the fuzzer requested by @lebedev.ri .

[fpetrogalli]

Cosmetic changes to a comment.

[jdoerfert]

llvm/include/llvm/Analysis/SearchVectorFunctionSystem.h

29 ↗

(On Diff #214419)

How about the following?

ParameterKind -> VectorFunctionParameterKind or VFParameterKind
ParamType -> VectorFunctionParameter or VFParameter (we might want get rid of the Type > token too)

Does that make sense to you?

That is fine with me (both the VectorFunction or the VF version). It would be nice and consistent to put VF (or VectorFunction) in front of all these names (ParameterKind, ISAKind, ParamType) as done for VectorFunctionShape.

[lebedev.ri]

Sorry, meant to reply, but lost track.

llvm/include/llvm/Analysis/SearchVectorFunctionSystem.h

29 ↗

(On Diff #214419)

I think that would be good-enough.

211 ↗

(On Diff #218144)

files should end with newlines

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

20

Question: does getVectorName() run *all* of the parsing code in SearchVectorFunctionSystem.cpp?

24–27

Yes, this should be ok i suppose.

[fpetrogalli]

I have updated the code according to the last round of reviews. I have removed pieces of code that were not needed anymore for testing.

The parser now is split from the VFParameter class (the old ParamType class).

[fpetrogalli]

Hi @sdesmalen:

it would be better to parse the mangled string incrementally, rather than extracting each feature from the string individually.

I think the parser now does what you ask for the "variable length" part of the mangled string, which is the one that holds the <vlen> and the <parameters>.

Francesco

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

20

Good catch. Now it does.

[fpetrogalli]

I have done the following updates:

1. Added demangling and tests for uniform parameters ("u").
2. Added more docs, with references to the Vector Function ABI specs for x86 and AArch64.
3. Use default constructors for the structs introduced in the patch.
4. Added a test that checks that the demangling functions for the parameters is the same for the vector extensions of both AArch64 and x86.

[lebedev.ri]

Not a review, but some thoughts nonetheless.

llvm/include/llvm/Analysis/VectorUtils.h

63–65

have you considered std::tie() ? Not sure if it would work/help here.

70

Documentation commends have 3x /

74–81

VectorVariant

But, i think this function should return llvm::Optional<Some Struct>, or error_or maybe

103

This is unreachable, right? Else i think this might need better error propagation strategy.

163

same, and elsewhere.

[fpetrogalli]

llvm/include/llvm/Analysis/VectorUtils.h

74–81

I have changed the signature to use a single input parameter. The method is still returning a bool.

I have used optional in the static method that creates the VFShape instance.

103

I have replace the output type with Optional<VFParamKind> and moved the llvm_unreachable at the end of the function.

163

Done. The static method now returns an optional value.

[fpetrogalli]

In this new patch I have:

1. Fixed a build failure of the fuzzer (I forgot to apply the interface changes of the last diff).
2. Add ASSERT_DEATH testing for invalid names.
3. Add testing to make sure <scalarname> is always present in the string.
4. Add testing to make sure that <vectorname> is present when the opening ( is parsed.
5. Add testing to make sure that the string terminates with ) when <vectorname> is present.

[fpetrogalli]

I have deferred the handling of the mask token "M" to the VFParameter struct, introducing a new VFPAramKind that handles global function predication. This should be more in line with the aim of this implementation, which is to make VFShape independent from the Vector Function ABI. In particular, there are use cases that @simoll cares about where predication can be attached to single parameters, and not to the whole function.

Tests to make sure the Global Predicate is added correct;ly has been added for all the targets supported in this patch (x86 and aarch64).

[jdoerfert]

I'm fine with this (one small nit below).

@simoll, @lebedev.ri, any more comments or can this go in?

llvm/lib/Analysis/VFABIDemangling.cpp

413

Why is this an Optional? It seems to always return a proper VFParamKind if it returns at all.

[lebedev.ri]

Looks ok.
(Note that i'm only looking at code, not correctness of demangling here.)

llvm/include/llvm/Analysis/VectorUtils.h

63

There's ongoing effort to migrate to llvm::Alignment (i don't recall the name)

94

I'm not sure why this should not also return Optional<ParsedData>.

[simoll]

One minor thing: VFABI parsing should succeed for any well-formed AVFBI vector function name (beyond what's listed in the VFISAKind enum). This would open up the functionality for external users.

llvm/include/llvm/Analysis/VectorUtils.h

50

How about renaming to ISA_Unknown ?

llvm/lib/Analysis/VFABIDemangling.cpp

302

Why not carry on with parsing a well-formed AFABI String if the ABI is unknown?
This would enable support for VFABIs not listed here.

[fpetrogalli]

I have address all comments. Thank you for your feedback @jdoerfert @simoll @lebedev.ri !

Additionally, I have renames the enums values of VFISAKind from VFISAKind::ISA_* to VFISAKind::*.

llvm/lib/Analysis/VFABIDemangling.cpp

413

yeah, sorry,Optional is an unnecessary complication here.

[simoll]

LGTM. Thanks!

[sdesmalen]

Thanks for all the changes @fpetrogalli, this patch is really taking shape! Just added a few more drive-by comments.

llvm/include/llvm/Analysis/VectorUtils.h

94

nit: Can we rename this main function to something like tryDemangleForVFABI ?

116

Given that ScalarName and VectorName are not part of the equality-comparison, does that imply they should not be part of VFShape ?

llvm/lib/Analysis/VFABIDemangling.cpp

31

Why is it named getISA which starts parsing at position4 rather than tryParseISA which starts parsing at position 0?

315

Can we make the dropping of these substrings part of getMask and getISA (on success) ?

357

nit: this comment seems unnecessary (the code says it all)

[fpetrogalli]

llvm/include/llvm/Analysis/VectorUtils.h

116

I see. How about I refactor this as follow?

struct VFShape {
  unsigned VF;     // Vectorization factor.
  bool IsScalable; // True if the function is a scalable function.
  VFISAKind ISA;   // Instruction Set Architecture.
  SmallVector<VFParameter, 8> Parameters; // List of parameter informations.
};

struct VFInfo {
  VFShape Shape;
  StringRef ScalarName;                   // Scalar Function Name.
  StringRef VectorName; // Vector Function Name associated to this VFShape.
;

I think this makes more sense, I just want to double check with you before applying the changes.

[fpetrogalli]

HI @sdesmalen ,

I have updated the patch according to your feedback. In particular, I have modified all the parsing method to use the ParseRet enum instead of booleans. It looks better now, thanks.

Once outstanding work is the comparison operator of VFShape. I have proposed a solution in a comment, let me know what you think, I will apply it if you agree on the approach. BTW: good catch. The VFShape should carry information only about the shape, not about the names of the functions.

One more nit: while working on the SVFS, I have noticed that the llvm_unreachable I have added at the end of the static method to create FShape out of the parsed data was quite annoying: it got fired every time the CI I was trying to vectorize didn't have the name with the mangled attribute. hence, I have removed the assertion, and converted the ASSERT_DEATH tests into EXPECT_FALSE tests in TEST(VectorFunctionABITests, OnlyValidNames). This should not be controversial (I am happy to be told I am wrong if that's the case).

Thank you,

Francesco

[sdesmalen]

In D66024#1668515, @fpetrogalli wrote:

I have updated the patch according to your feedback. In particular, I have modified all the parsing method to use the ParseRet enum instead of booleans. It looks better now, thanks.

Agreed, this looks good now, thanks!

Once outstanding work is the comparison operator of VFShape. I have proposed a solution in a comment, let me know what you think, I will apply it if you agree on the approach. BTW: good catch. The VFShape should carry information only about the shape, not about the names of the functions.

Yes, that seems like a good suggestion.

One more nit: while working on the SVFS, I have noticed that the llvm_unreachable I have added at the end of the static method to create FShape out of the parsed data was quite annoying: it got fired every time the CI I was trying to vectorize didn't have the name with the mangled attribute. hence, I have removed the assertion, and converted the ASSERT_DEATH tests into EXPECT_FALSE tests in TEST(VectorFunctionABITests, OnlyValidNames). This should not be controversial (I am happy to be told I am wrong if that's the case).

That seems like the better choice given how you've shaped the interface that returns a Optional<VFShape>, but I don't really understand why this would break CI.

[fpetrogalli]

In D66024#1669011, @sdesmalen wrote:

One more nit: while working on the SVFS, I have noticed that the llvm_unreachable I have added at the end of the static method to create FShape out of the parsed data was quite annoying: it got fired every time the CI I was trying to vectorize didn't have the name with the mangled attribute. hence, I have removed the assertion, and converted the ASSERT_DEATH tests into EXPECT_FALSE tests in TEST(VectorFunctionABITests, OnlyValidNames). This should not be controversial (I am happy to be told I am wrong if that's the case).

That seems like the better choice given how you've shaped the interface that returns a Optional<VFShape>, but I don't really understand why this would break CI.

The way I am building the VFShape is as follows:

const StringRef AttrString =
        CI->getCalledFunction()->getFnAttribute("vector-function-abi-variant").getValueAsString();
      SmallVector<StringRef, 8> ListOfStrings;
      AttrString.split(ListOfStrings, ",");
SmallVector<VFShape, 8> Ret;
      for (auto MangledName : ListOfStrings) {
	auto Shape = VFShape::getFromVFABI(MangledName);
        if (Shape.hasValue() && Shape.getValue().ScalarName == ScalarName)
          Ret.push_back(Shape.getValue());
      }

Most of the functions don't have the attribute, which result in list of string consisting of a single element, which is an empty string, therefore the parser fails and the exception is raised.

Maybe there is a better way to do it, but given the Optional<VFShape> return, it doesn't make sense to raise the exception on failure.

[fpetrogalli]

I have split the implementation of VFShape into VFShape and VFInfo, as agreed.

I have also found a couple of bugs thanks to the fuzzer (that was a great suggestion @lebedev.ri !). I have added the correspondent unit tests to prevent regressions. The bugs were around invalid mangled name strings and the parsing of the align token.

Regards,

Francesco

[fpetrogalli]

I added the Unknown ISA handling in the test ISAIndependentMangling, and updated the comments in the fuzzer.

[sdesmalen]

llvm/include/llvm/Analysis/VectorUtils.h

153

Can't tryDemangleForVFABI return a Optional<VFInfo> directly? (rather than construct it here from the ParsedData)
This also makes me question the need for ParsedData.

[fpetrogalli]

llvm/include/llvm/Analysis/VectorUtils.h

153

I could, but I think it is not the right thing to do. I expect the the`VFInfo` struct to grow beyond handling Vector Function ABI and OpenMP information (it is one of the requirements). When this happens, all we need to do is just to to change this line adding a proper ParsedData -> VFInfo constructor instead of having to adapt the parser to the new VFInfo class.

[sdesmalen]

llvm/include/llvm/Analysis/VectorUtils.h

153

If VFInfo turns into a class that supports a superset of the VFABI, the parser could construct a VFInfo object that populates less fields through having multiple constructors for VFInfo, or through a constructor with default arguments for the fields that are not applicable.
In the end there needs to be code somewhere that fills in the VFInfo object. Having a layer in the middle that just passes the information around offers little value, unless that layer adds some new functionality. Without such functionality, I think it makes more sense to return VFInfo directly.

[fpetrogalli]

I have removed the ParsedData struct as requested by @sdesmalen , my reasoning for keeping it was wrong.

I have updated the tests and the fuzzer accordingly.

[fpetrogalli]

llvm/include/llvm/Analysis/VectorUtils.h

153

I agree with you, thank you.

[sdesmalen]

llvm/include/llvm/Analysis/VectorUtils.h

92

Sorry, just spotting this now. Instead of having struct VFInfo; here, can you just move the definition of VFInfo here?

136

nit: this code is still commented out.

[fpetrogalli]

Restore the function name to tryParseForVFABI.

[sdesmalen]

Thanks @fpetrogalli, LGTM!

llvm/include/llvm/Analysis/VectorUtils.h

 
 #include "llvm/ADT/MapVector.h"
 #include "llvm/Analysis/LoopAccessAnalysis.h"
 #include "llvm/IR/IRBuilder.h"
 #include "llvm/Support/CheckedArithmetic.h"
 
 namespace llvm {
 
+/// Describes the type of Parameters
+enum class VFParamKind {
+  Vector,            // No semantic information.
+  OMP_Linear,        // declare simd linear(i)
+  OMP_LinearRef,     // declare simd linear(ref(i))
+  OMP_LinearVal,     // declare simd linear(val(i))
+  OMP_LinearUVal,    // declare simd linear(uval(i))
+  OMP_LinearPos,     // declare simd linear(i:c) uniform(c)
+  OMP_LinearValPos,  // declare simd linear(val(i:c)) uniform(c)
+  OMP_LinearRefPos,  // declare simd linear(ref(i:c)) uniform(c)
+  OMP_LinearUValPos, // declare simd linear(uval(i:c)) uniform(c
+  OMP_Uniform,       // declare simd uniform(i)
+  GlobalPredicate,   // Global logical predicate that acts on all lanes
+                     // of the input and output mask concurrently. For
+                     // example, it is implied by the `M` token in the
+                     // Vector Function ABI mangled name.
+  Invalid
+};
+
+/// Describes the type of Instruction Set Architecture
+enum class VFISAKind {
+  ISA_AdvancedSIMD, // AArch64 Advanced SIMD (NEON)
+  ISA_SVE,          // AArch64 Scalable Vector Extension
+  ISA_SSE,          // x86 SSE
+  ISA_AVX,          // x86 AVX
+  ISA_AVX2,         // x86 AVX2
+  ISA_AVX512,       // x86 AVX512
+  ISA_Invalid       // Unsupported ISA
+};
+
+/// Encapsulates information needed to describe a parameter.
+///
+/// The description of the parameter is not linked directly to
+/// OpenMP or any other vector function description. This structure
+/// is extendible to handle other paradigms that describe vector
+/// functions and their parameters.
+struct VFParameter {
+  unsigned ParamPos;       // Parameter Position in Scalar Function.
+  VFParamKind ParamKind;   // Kind of Parameter.
+  int LinearStepOrPos = 0; // Step or Position of the Parameter.
+  unsigned Alignment = 1;  // Optional aligment, in bytes, defaulted to 1.
+
+  // Comparison operator.
+  bool operator==(const VFParameter &Other) const {
+    return std::tie(ParamPos, ParamKind, LinearStepOrPos, Alignment) ==
+           std::tie(Other.ParamPos, Other.ParamKind, Other.LinearStepOrPos,
+                    Other.Alignment);
+  }
+};
+
+namespace VFABI {
+/// Convenience container for the data produced by the parser when
+/// parsing
+/// _ZGV<isa><mask><vlen><parameters>_<scalarname>[(<redirection>)].
+struct ParsedData {
+  unsigned VF;     // Holds <vlen> if <vlen> is a number.
+  bool IsMasked;   //  true if <mask> == "M", false if <mask> == "N".
+  bool IsScalable; //  true if <vlen> == "x".
+  VFISAKind ISA;   // Holds <isa> with the internal enum.
+  SmallVector<VFParameter, 8> Parameters; // Holds the <parameters>.
+  StringRef ScalarName;                   // Holds the <scalarname>.
+  StringRef VectorName; // Holds the optional <redirection> if present,
+                        // otherwise holds
+                        // _ZGV<isa><mask><vlen><parameters>_<scalarname>.
+};
+
+/// Parse a string in the format
+/// _ZGV<isa><mask><vlen><parameters>_<scalarname>[(<redirection>)].
+///
+/// \param MangledName -> input string.
+/// \param PD -> ParsedData instance to store the results produced by the parse.
+bool tryParserVFABIName(const StringRef mangledName, ParsedData &PD);
+
+/// Retrieve the `VFParamKind` from a string token.
+Optional<VFParamKind> getVFParamKindFromString(const StringRef Token);
+} // end namespace VFABI
+
+/// Contains the information about the kind of vectorization
+/// available.
+///
+/// This object in independent on the paradigm used to
+/// represent vector functions. in particular, it is not attached to
+/// any target-specific ABI.
+struct VFShape {
+  unsigned VF;     // Vectorization factor.
+  bool IsScalable; // True if the function is a scalable function.
+  VFISAKind ISA;   // Instruction Set Architecture.
+  SmallVector<VFParameter, 8> Parameters; // List of parameter informations.
+  StringRef ScalarName;                   // Scalar Function Name.
+  StringRef VectorName; // Vector Function Name associated to this VFShape.
+
+  // Comparison operator.
+  bool operator==(const VFShape &Other) const {
+    return std::tie(VF, ISA, Parameters, ScalarName, VectorName) ==
+           std::tie(Other.VF, Other.ISA, Other.Parameters, Other.ScalarName,
+                    Other.VectorName);
+  }
+
+  /// Static method to contruct a VFShape out of a mangled names in the
+  /// following format:
+  ///
+  /// <VFABI_name>{(<redirection>)}
+  ///
+  /// where <VFABI_name> is the name of the vector function, mangled according
+  /// to the rules described in the Vector Function ABI of the target vector
+  /// extentsion (or <isa> from now on). The <VFABI_name> is in the following
+  /// format:
+  ///
+  /// _ZGV<isa><mask><vlen><parameters>_<scalarname>[(<redirection>)]
+  ///
+  /// This methods support demangling rules for the following <isa>:
+  ///
+  /// * 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
+  static Optional<VFShape> getFromVFABI(StringRef MangledName) {
+    VFABI::ParsedData PD;
+    if (VFABI::tryParserVFABIName(MangledName, PD))
+      return VFShape({PD.VF, PD.IsScalable, PD.ISA, PD.Parameters,
+                      PD.ScalarName, PD.VectorName});
+
+    // The values of MangledNames are supposed to be valid once they
+    // are present in the backend. We throw a debug error if it is not
+    // the case.
+    llvm_unreachable("Invalid Vector Function ABI name.");
+  }
+};
+
 template <typename T> class ArrayRef;
 class DemandedBits;
 class GetElementPtrInst;
 template <typename InstTy> class InterleaveGroup;
 class Loop;
 class ScalarEvolution;
 class TargetLibraryInfo;
 class TargetTransformInfo;
 class Type;
 class Value;
 
 namespace Intrinsic {
 enum ID : unsigned;
 }
 
 /// Identify if the intrinsic is trivially vectorizable.
 /// This method returns true if the intrinsic's argument types are all scalars
 /// for the scalar form of the intrinsic and all vectors (or scalars handled by
 /// hasVectorInstrinsicScalarOpd) for the vector form of the intrinsic.
 bool isTriviallyVectorizable(Intrinsic::ID ID);

llvm/lib/Analysis/CMakeLists.txt

add_llvm_library(LLVMAnalysis
   Trace.cpp
   TypeBasedAliasAnalysis.cpp
   TypeMetadataUtils.cpp
   ScopedNoAliasAA.cpp
   ValueLattice.cpp
   ValueLatticeUtils.cpp
   ValueTracking.cpp
   VectorUtils.cpp
+  VFABIDemangling.cpp
 
   ADDITIONAL_HEADER_DIRS
   ${LLVM_MAIN_INCLUDE_DIR}/llvm/Analysis
 
   DEPENDS
   intrinsics_gen
   )

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
+//
+//===----------------------------------------------------------------------===//
+
+#include "llvm/Analysis/VectorUtils.h"
+
+using namespace llvm;
+
+namespace {
+/// Utilities for the Vector Function ABI name parser.
+///
+/// `get*` methods: extract values from fixed parts of the string,
+/// without modifying it.
+///
+/// `consume*` methods: find variable size tokens that are
+/// mandatory. The string to be parsed is advanced.
+///
+/// `tryParse` methods: find optional tokens and advance the string
+/// to be parsed.
+
+/// Extracts the `<isa>` information from the mangled string, and
+/// sets the `ISA` accordingly. The input string `MangledName` is left
+/// unmodified. Return false in case of failure, true otherwise.
+bool getISA(const StringRef MangledName, VFISAKind &ISA) {
+  // Capture the ISA value (one char): `_ZGV<isa>...`.
+  StringRef ISAValue = MangledName.substr(4, 1);
+
+  ISA = StringSwitch<VFISAKind>(ISAValue)
+            .Case("n", VFISAKind::ISA_AdvancedSIMD)
+            .Case("s", VFISAKind::ISA_SVE)
+            .Case("b", VFISAKind::ISA_SSE)
+            .Case("c", VFISAKind::ISA_AVX)
+            .Case("d", VFISAKind::ISA_AVX2)
+            .Case("e", VFISAKind::ISA_AVX512)
+            .Default(VFISAKind::ISA_Invalid);
+
+  return ISA != VFISAKind::ISA_Invalid;
+}
+
+/// Extracts the `<mask>` information from the mangled string, and
+/// sets `IsMasked` accordingly. The input string `MangledName` is
+/// left unmodified. Return false in case of failure, true
+/// otherwise.
+bool getMask(const StringRef MangledName, bool &IsMasked) {
+  // Capture the MASK value (one char): `_ZGV<isa><mask>...`.
+  StringRef Mask = MangledName.substr(5, 1);
+
+  if (Mask == "M") {
+    IsMasked = true;
+    return true;
+  }
+
+  if (Mask == "N") {
+    IsMasked = false;
+    return true;
+  }
+
+  return false;
+}
+
+/// Extract the `<vlen>` information from the mangled string, and
+/// sets `VF` accordingly. Returns false in case of failure, true
+/// otherwise. A `<vlen> == "x"` token is interpreted as a scalable
+/// vector length. On success, the `<vlen>` token is removed from
+/// the input string `ParseString`.
+///
+bool consumeVLEN(StringRef &ParseString, unsigned &VF, bool &IsScalable) {
+  if (ParseString.consume_front("x")) {
+    VF = 0;
+    IsScalable = true;
+    return true;
+  }
+
+  if (ParseString.consumeInteger(10, VF))
+    return false;
+
+  IsScalable = false;
+  return true;
+}
+
+// Return types for the parser functions.
+enum class ParseRet {
+  OK,   // Found.
+  None, // Not found.
+  Error // Syntax error.
+};
+
+/// The function looks for the following strings at the beginning of
+/// the input string `ParseString`:
+///
+///  <token> <number>
+///
+/// On success, it removes the parsed parameter from `ParseString`,
+/// sets `PKind` to the correspondent enum value, sets `Pos` to
+/// <number>, and return success.  On a syntax error, it return a
+/// parsing error. If nothing is parsed, it returns None.
+///
+/// The function expects <token> to be one of "ls", "Rs", "Us" or
+/// "Ls".
+ParseRet tryParseLinearTokenWithRuntimeStep(StringRef &ParseString,
+                                            VFParamKind &PKind, int &Pos,
+                                            const StringRef Token) {
+  assert((Token == "ls" || Token == "Rs" || Token == "Us" || Token == "Ls") &&
+         "Not a valid token.");
+  if (ParseString.consume_front(Token)) {
+    PKind = VFABI::getVFParamKindFromString(Token).getValue();
+    if (ParseString.consumeInteger(10, Pos))
+      return ParseRet::Error;
+    return ParseRet::OK;
+  }
+  return ParseRet::None;
+}
+
+/// The function looks for the following stringt at the beginning of
+/// the input string `ParseString`:
+///
+///  <token> <number>
+///
+/// <token> is one of "ls", "Rs", "Us" or "Ls".
+///
+/// On success, it removes the parsed parameter from `ParseString`,
+/// sets `PKind` to the correspondent enum value, sets `StepOrPos` to
+/// <number>, and return success.  On a syntax error, it return a
+/// parsing error. If nothing is parsed, it returns None.
+ParseRet tryParseLinearWithRuntimeStep(StringRef &ParseString,
+                                       VFParamKind &PKind, int &StepOrPos) {
+  ParseRet Ret;
+
+  // "ls" <RuntimeStepPos>
+  Ret = tryParseLinearTokenWithRuntimeStep(ParseString, PKind, StepOrPos, "ls");
+  if (Ret != ParseRet::None)
+    return Ret;
+
+  // "Rs" <RuntimeStepPos>
+  Ret = tryParseLinearTokenWithRuntimeStep(ParseString, PKind, StepOrPos, "Rs");
+  if (Ret != ParseRet::None)
+    return Ret;
+
+  // "Ls" <RuntimeStepPos>
+  Ret = tryParseLinearTokenWithRuntimeStep(ParseString, PKind, StepOrPos, "Ls");
+  if (Ret != ParseRet::None)
+    return Ret;
+
+  // "Us" <RuntimeStepPos>
+  Ret = tryParseLinearTokenWithRuntimeStep(ParseString, PKind, StepOrPos, "Us");
+  if (Ret != ParseRet::None)
+    return Ret;
+
+  return ParseRet::None;
+}
+
+/// The function looks for the following strings at the beginning of
+/// the input string `ParseString`:
+///
+///  <token> {"n"} <number>
+///
+/// On success, it removes the parsed parameter from `ParseString`,
+/// sets `PKind` to the correspondent enum value, sets `LinearStep` to
+/// <number>, and return success.  On a syntax error, it return a
+/// parsing error. If nothing is parsed, it returns None.
+///
+/// The function expects <token> to be one of "l", "R", "U" or
+/// "L".
+bool consumeCompileTimeLinearToken(StringRef &ParseString, VFParamKind &PKind,
+                                   int &LinearStep, const StringRef Token) {
+  assert((Token == "l" || Token == "R" || Token == "U" || Token == "L") &&
+         "Not a valid token.");
+  if (ParseString.consume_front(Token)) {
+    PKind = VFABI::getVFParamKindFromString(Token).getValue();
+    const bool Negate = ParseString.consume_front("n");
+    if (ParseString.consumeInteger(10, LinearStep))
+      LinearStep = 1;
+    if (Negate)
+      LinearStep *= -1;
+    return true;
+  }
+
+  return false;
+}
+
+/// The function looks for the following strings at the beginning of
+/// the input string `ParseString`:
+///
+/// ["l" | "R" | "U" | "L"] {"n"} <number>
+///
+/// On success, it removes the parsed parameter from `ParseString`,
+/// sets `PKind` to the correspondent enum value, sets `LinearStep` to
+/// <number>, and return success.  On a syntax error, it return a
+/// parsing error. If nothing is parsed, it returns None.
+ParseRet tryParseLinearWithCompileTimeStep(StringRef &ParseString,
+                                           VFParamKind &PKind, int &StepOrPos) {
+  // "l" {"n"} <CompileTimeStep>
+  if (consumeCompileTimeLinearToken(ParseString, PKind, StepOrPos, "l"))
+    return ParseRet::OK;
+
+  // "R" {"n"} <CompileTimeStep>
+  if (consumeCompileTimeLinearToken(ParseString, PKind, StepOrPos, "R"))
+    return ParseRet::OK;
+
+  // "L" {"n"} <CompileTimeStep>
+  if (consumeCompileTimeLinearToken(ParseString, PKind, StepOrPos, "L"))
+    return ParseRet::OK;
+
+  // "U" {"n"} <CompileTimeStep>
+  if (consumeCompileTimeLinearToken(ParseString, PKind, StepOrPos, "U"))
+    return ParseRet::OK;
+
+  return ParseRet::None;
+}
+
+/// The function looks for the following strings at the beginning of
+/// the input string `ParseString`:
+///
+/// "u" <number>
+///
+/// On success, it removes the parsed parameter from `ParseString`,
+/// sets `PKind` to the correspondent enum value, sets `Pos` to
+/// <number>, and return success.  On a syntax error, it return a
+/// parsing error. If nothing is parsed, it returns None.
+ParseRet tryParseUniform(StringRef &ParseString, VFParamKind &PKind, int &Pos) {
+  // "u" <Pos>
+  const char *UniformToken = "u";
+  if (ParseString.consume_front(UniformToken)) {
+    PKind = VFABI::getVFParamKindFromString(UniformToken).getValue();
+    if (ParseString.consumeInteger(10, Pos))
+      return ParseRet::Error;
+
+    return ParseRet::OK;
+  }
+  return ParseRet::None;
+}
+
+/// Looks into the <parameters> part of the mangled name in search
+/// for valid paramaters at the beginning of the string
+/// `ParseString`.
+///
+/// On success, it removes the parsed parameter from `ParseString`,
+/// sets `PKind` to the correspondent enum value, sets `StepOrPos`
+/// accordingly, and return success.  On a syntax error, it return a
+/// parsing error. If nothing is parsed, it returns None.
+ParseRet tryParseParameter(StringRef &ParseString, VFParamKind &PKind,
+                           int &StepOrPos) {
+  if (ParseString.consume_front("v")) {
+    PKind = VFParamKind::Vector;
+    StepOrPos = 0;
+    return ParseRet::OK;
+  }
+
+  const ParseRet HasLinearRuntime =
+      tryParseLinearWithRuntimeStep(ParseString, PKind, StepOrPos);
+  if (HasLinearRuntime != ParseRet::None)
+    return HasLinearRuntime;
+
+  const ParseRet HasLinearCompileTime =
+      tryParseLinearWithCompileTimeStep(ParseString, PKind, StepOrPos);
+  if (HasLinearCompileTime != ParseRet::None)
+    return HasLinearCompileTime;
+
+  const ParseRet HasUniform = tryParseUniform(ParseString, PKind, StepOrPos);
+  if (HasUniform != ParseRet::None)
+    return HasUniform;
+
+  return ParseRet::None;
+}
+
+/// Looks into the <parameters> part of the mangled name in search
+/// of a valid 'aligned' clause. The function should be invoked
+/// after parsing a parameter via `tryParseParameter`.
+///
+/// On success, it removes the parsed parameter from `ParseString`,
+/// sets `PKind` to the correspondent enum value, sets `StepOrPos`
+/// accordingly, and return success.  On a syntax error, it return a
+/// parsing error. If nothing is parsed, it returns None.
+ParseRet tryParseAlign(StringRef &ParseString, unsigned &Align) {
+  //    "a" <number>
+  if (ParseString.consume_front("a")) {
+    if (ParseString.consumeInteger(10, Align))
+      return ParseRet::Error;
+    return ParseRet::OK;
+  }
+
+  return ParseRet::None;
+}
+} // namespace
+
+// Format of the ABI name:
+// _ZGV<isa><mask><vlen><parameters>_<scalarname>[(<redirection>)]
+bool VFABI::tryParserVFABIName(const StringRef MangledName, ParsedData &PD) {
+  // Assume there is no custom name <redirection>, and therefore the
+  // vector name consists of
+  // _ZGV<isa><mask><vlen><parameters>_<scalarname>.
+  PD.VectorName = MangledName;
+
+  // Parse the fixed size part of the manled name
+  if (!MangledName.startswith("_ZGV"))
+    return false;
+
+  if (!getISA(MangledName, PD.ISA))
+    return false;
+
+  if (!getMask(MangledName, PD.IsMasked))
+    return false;
+
+  // First, drop the first 6 chars of the mangled name: _ZGV<isa><mask>
+  StringRef ParseString = MangledName.drop_front(6);
+
+  // Parse the variable size, starting from <vlen>.
+  if (!consumeVLEN(ParseString, PD.VF, PD.IsScalable))
+    return false;
+
+  // Parse the <parameters>.
+  ParseRet ParamFound;
+  do {
+    const unsigned ParameterPos = PD.Parameters.size();
+    VFParamKind PKind;
+    int StepOrPos;
+    ParamFound = tryParseParameter(ParseString, PKind, StepOrPos);
+
+    // Bail off if there is a parsing error in the parsing of the parameter.
+    if (ParamFound == ParseRet::Error)
+      return false;
+
+    if (ParamFound == ParseRet::OK) {
+      VFParameter Parameter = {ParameterPos, PKind, StepOrPos};
+
+      // Look for the alignment token "a <number>".
+      ParseRet AlignFound = tryParseAlign(ParseString, Parameter.Alignment);
+      // Bail off if there is a syntax error in the align token.
+      if (AlignFound == ParseRet::Error)
+        return false;
+
+      // Add the parameter.
+      PD.Parameters.push_back(Parameter);
+    }
+  } while (ParamFound == ParseRet::OK);
+
+  // Check for the <scalarname> and the optional <redirection>, which
+  // are separated from the prefix with "_"
+  if (!ParseString.consume_front("_"))
+    return false;
+
+  // The rest of the string must be in the format:
+  // <scalarname>[(<redirection>)]
+  PD.ScalarName =
+      ParseString.take_while([](char In) -> bool { return In != '('; });
+
+  // If the scalar name is missing, bail out.
+  if (PD.ScalarName.empty())
+    return false;
+
+  // Reduce ParseString to [(<redirection>)].
+  ParseString = ParseString.ltrim(PD.ScalarName);
+  // Find the optional custom name redirection.
+  if (ParseString.consume_front("(")) {
+    if (!ParseString.consume_back(")"))
+      return false;
+    // Update the vector variant with the one specified by the user.
+    PD.VectorName = ParseString;
+    // If the vector name is missing, bail out.
+    if (PD.VectorName.empty())
+      return false;
+  }
+
+  // When <mask> is "M", we need to add a parameter that is used as
+  // global predicate for the function.
+  if (PD.IsMasked) {
+    unsigned Pos = PD.Parameters.size();
+    PD.Parameters.push_back({Pos, VFParamKind::GlobalPredicate});
+  }
+
+  // Asserts for parameters of type `VFParamKind::GlobalPredicate`, as
+  // prescribed by the Vector Function ABI specifications supported by
+  // this parser:
+  // 1. Uniqueness.
+  // 2. Must be the last in the parameter list.
+  const auto NGlobalPreds = std::count_if(
+      PD.Parameters.begin(), PD.Parameters.end(), [](const VFParameter PK) {
+        return PK.ParamKind == VFParamKind::GlobalPredicate;
+      });
+  assert(NGlobalPreds < 2 && "Cannot have more than one global predicate.");
+  if (NGlobalPreds)
+    assert(PD.Parameters.back().ParamKind == VFParamKind::GlobalPredicate &&
+           "The global predicate must be the last parameter");
+
+  return true;
+}
+
+Optional<VFParamKind> VFABI::getVFParamKindFromString(const StringRef Token) {
+  VFParamKind ParamKind = StringSwitch<VFParamKind>(Token)
+                              .Case("v", VFParamKind::Vector)
+                              .Case("l", VFParamKind::OMP_Linear)
+                              .Case("R", VFParamKind::OMP_LinearRef)
+                              .Case("L", VFParamKind::OMP_LinearVal)
+                              .Case("U", VFParamKind::OMP_LinearUVal)
+                              .Case("ls", VFParamKind::OMP_LinearPos)
+                              .Case("Ls", VFParamKind::OMP_LinearValPos)
+                              .Case("Rs", VFParamKind::OMP_LinearRefPos)
+                              .Case("Us", VFParamKind::OMP_LinearUValPos)
+                              .Case("u", VFParamKind::OMP_Uniform)
+                              .Default(VFParamKind::Invalid);
+
+  if (ParamKind != VFParamKind::Invalid)
+    return ParamKind;
+
+  // This function should never be invoked with an invalid input.
+  llvm_unreachable("This fuction should be invoken only on parameters"
+                   " that have a textual representation in the mangled name"
+                   " of the Vector Function ABI");
+}

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

+set(LLVM_LINK_COMPONENTS
+  Analysis
+  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"
+
+using namespace llvm;
+
+extern "C" int LLVMFuzzerTestOneInput(const uint8_t *Data, size_t Size) {
+  const StringRef MangledName((const char *)Data, Size);
+  VFABI::ParsedData PD;
+  bool Ret = VFABI::tryParserVFABIName(MangledName, PD);
+
+  // Do not optimize away Ret. Inspired by
+  // https://github.com/google/benchmark/blob/master/include/benchmark/benchmark.h#L307-L345
+  asm volatile("" : : "r,m"(Ret) : "memory");
+
+  return 0;
+}

llvm/unittests/Analysis/CMakeLists.txt

add_llvm_unittest(AnalysisTests
   LoopInfoTest.cpp
   MemoryBuiltinsTest.cpp
   MemorySSATest.cpp
   OrderedBasicBlockTest.cpp
   OrderedInstructionsTest.cpp
   PhiValuesTest.cpp
   ProfileSummaryInfoTest.cpp
   ScalarEvolutionTest.cpp
+  VectorFunctionABITest.cpp
   SparsePropagation.cpp
   TargetLibraryInfoTest.cpp
   TBAATest.cpp
   UnrollAnalyzerTest.cpp
   ValueLatticeTest.cpp
   ValueTrackingTest.cpp
   VectorUtilsTest.cpp
   )

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 "gtest/gtest.h"
+
+using namespace llvm;
+
+// This test makes sure that the getFromVFABI method succeeds only on
+// valid values of the string.
+TEST(VectorFunctionABITests, DieOnInvalidName) {
+  const char *Msg = "Invalid Vector Function ABI name.";
+  // Missing _ZGV prefix.
+  ASSERT_DEATH(VFShape::getFromVFABI("_ZVnN2v_foo"), Msg);
+  // Missing <isa>.
+  ASSERT_DEATH(VFShape::getFromVFABI("_ZGVN2v_foo"), Msg);
+  // Missing <mask>.
+  ASSERT_DEATH(VFShape::getFromVFABI("_ZGVn2v_foo"), Msg);
+  // Missing <vlen>.
+  ASSERT_DEATH(VFShape::getFromVFABI("_ZGVnNv_foo"), Msg);
+  // Missing <scalarname>.
+  ASSERT_DEATH(VFShape::getFromVFABI("_ZGVnN2v_"), Msg);
+  // Missing _ separator.
+  ASSERT_DEATH(VFShape::getFromVFABI("_ZGVnN2vfoo"), Msg);
+  // Missing <vectorname>.
+  ASSERT_DEATH(VFShape::getFromVFABI("_ZGVnN2v_foo()"), Msg);
+  // Unterminated name.
+  ASSERT_DEATH(VFShape::getFromVFABI("_ZGVnN2v_foo(bar"), Msg);
+}
+
+TEST(VectorFunctionABITests, ParamListParsing) {
+  // Testing "vl16Ls32R3l"
+  const auto OptVFS = VFShape::getFromVFABI("_ZGVnN2vl16Ls32R3l_foo");
+  EXPECT_TRUE(OptVFS.hasValue());
+  const VFShape VFS = OptVFS.getValue();
+  EXPECT_EQ(VFS.Parameters.size(), (unsigned)5);
+  EXPECT_EQ(VFS.Parameters[0], VFParameter({0, VFParamKind::Vector, 0}));
+  EXPECT_EQ(VFS.Parameters[1], VFParameter({1, VFParamKind::OMP_Linear, 16}));
+  EXPECT_EQ(VFS.Parameters[2],
+            VFParameter({2, VFParamKind::OMP_LinearValPos, 32}));
+  EXPECT_EQ(VFS.Parameters[3], VFParameter({3, VFParamKind::OMP_LinearRef, 3}));
+  EXPECT_EQ(VFS.Parameters[4], VFParameter({4, VFParamKind::OMP_Linear, 1}));
+}
+
+TEST(VectorFunctionABITests, ScalarNameAndVectorName) {
+  // Parse Scalar Name
+  const auto A = VFShape::getFromVFABI("_ZGVnM2v_sin");
+  const auto B = VFShape::getFromVFABI("_ZGVnM2v_sin(UserFunc)");
+  const auto C = VFShape::getFromVFABI("_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:
+  // Field holding the parser output.
+  VFABI::ParsedData PD;
+  // Reset the parser output references.
+  void reset() {
+    VF = 0;
+    IsMasked = false;
+    ISA = VFISAKind::ISA_Invalid;
+    Parameters.clear();
+    ScalarName = "";
+    VectorName = "";
+    IsScalable = false;
+  }
+
+protected:
+  // Referencies to the parser output field.
+  unsigned &VF = PD.VF;
+  bool &IsMasked = PD.IsMasked;
+  VFISAKind &ISA = PD.ISA;
+  SmallVector<VFParameter, 8> &Parameters = PD.Parameters;
+  StringRef &ScalarName = PD.ScalarName;
+  StringRef &VectorName = PD.VectorName;
+  bool &IsScalable = PD.IsScalable;
+  // Invoke the parser.
+  bool invokeParser(const StringRef MangledName) {
+    reset();
+    const bool Ret = VFABI::tryParserVFABIName(MangledName, PD);
+    return Ret;
+  }
+};
+} // unnamed namespace
+
+TEST_F(VFABIParserTest, Parse) {
+  EXPECT_TRUE(invokeParser("_ZGVnN2vls2Ls27Us4Rs5l1L10U100R1000_sin"));
+  EXPECT_EQ(VF, (unsigned)2);
+  EXPECT_FALSE(IsMasked);
+  EXPECT_EQ(ISA, VFISAKind::ISA_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_EQ(VF, (unsigned)2);
+  EXPECT_FALSE(IsMasked);
+  EXPECT_FALSE(IsScalable);
+  EXPECT_EQ(ISA, VFISAKind::ISA_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_TRUE(invokeParser("_ZGVnN2ln1Ln10Un100Rn1000_sin"));
+  EXPECT_EQ(VF, (unsigned)2);
+  EXPECT_FALSE(IsMasked);
+  EXPECT_EQ(ISA, VFISAKind::ISA_AdvancedSIMD);
+  EXPECT_FALSE(IsScalable);
+  EXPECT_EQ(Parameters.size(), (unsigned)4);
+  EXPECT_EQ(Parameters[0], VFParameter({0, VFParamKind::OMP_Linear, -1}));
+  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(IsMasked);
+  EXPECT_TRUE(IsScalable);
+  EXPECT_EQ(ISA, VFISAKind::ISA_SVE);
+  EXPECT_EQ(ScalarName, "sin");
+  EXPECT_EQ(VectorName, "_ZGVsMxv_sin");
+}
+
+TEST_F(VFABIParserTest, ParseFixedWidthSVE) {
+  EXPECT_TRUE(invokeParser("_ZGVsM2v_sin"));
+  EXPECT_EQ(VF, (unsigned)2);
+  EXPECT_TRUE(IsMasked);
+  EXPECT_FALSE(IsScalable);
+  EXPECT_EQ(ISA, VFISAKind::ISA_SVE);
+  EXPECT_EQ(ScalarName, "sin");
+  EXPECT_EQ(VectorName, "_ZGVsM2v_sin");
+}
+
+TEST_F(VFABIParserTest, NotAVectorFunctionABIName) {
+  // Vector names should start with `_ZGV`.
+  EXPECT_FALSE(invokeParser("ZGVnN2v_sin"));
+}
+
+TEST_F(VFABIParserTest, LinearWithRuntimeStep) {
+  EXPECT_FALSE(invokeParser("_ZGVnN2ls_sin"))
+      << "A number should be present after \"ls\".";
+  EXPECT_TRUE(invokeParser("_ZGVnN2ls2_sin"));
+  EXPECT_FALSE(invokeParser("_ZGVnN2Rs_sin"))
+      << "A number should be present after \"Rs\".";
+  EXPECT_TRUE(invokeParser("_ZGVnN2Rs4_sin"));
+  EXPECT_FALSE(invokeParser("_ZGVnN2Ls_sin"))
+      << "A number should be present after \"Ls\".";
+  EXPECT_TRUE(invokeParser("_ZGVnN2Ls6_sin"));
+  EXPECT_FALSE(invokeParser("_ZGVnN2Us_sin"))
+      << "A number should be present after \"Us\".";
+  EXPECT_TRUE(invokeParser("_ZGVnN2Us8_sin"));
+}
+
+TEST_F(VFABIParserTest, LinearWithoutCompileTime) {
+  EXPECT_TRUE(invokeParser("_ZGVnN3lLRUlnLnRnUn_sin"));
+  EXPECT_EQ(Parameters.size(), (unsigned)8);
+  EXPECT_EQ(Parameters[0], VFParameter({0, VFParamKind::OMP_Linear, 1}));
+  EXPECT_EQ(Parameters[1], VFParameter({1, VFParamKind::OMP_LinearVal, 1}));
+  EXPECT_EQ(Parameters[2], VFParameter({2, VFParamKind::OMP_LinearRef, 1}));
+  EXPECT_EQ(Parameters[3], VFParameter({3, VFParamKind::OMP_LinearUVal, 1}));
+  EXPECT_EQ(Parameters[4], VFParameter({4, VFParamKind::OMP_Linear, -1}));
+  EXPECT_EQ(Parameters[5], VFParameter({5, VFParamKind::OMP_LinearVal, -1}));
+  EXPECT_EQ(Parameters[6], VFParameter({6, VFParamKind::OMP_LinearRef, -1}));
+  EXPECT_EQ(Parameters[7], VFParameter({7, VFParamKind::OMP_LinearUVal, -1}));
+}
+
+TEST_F(VFABIParserTest, ValidAndInvalidISA) {
+  EXPECT_FALSE(invokeParser("_ZGVqN2v_sin"));
+
+  EXPECT_TRUE(invokeParser("_ZGVnN2v_sin"));
+  EXPECT_EQ(ISA, VFISAKind::ISA_AdvancedSIMD);
+
+  EXPECT_TRUE(invokeParser("_ZGVsN2v_sin"));
+  EXPECT_EQ(ISA, VFISAKind::ISA_SVE);
+
+  EXPECT_TRUE(invokeParser("_ZGVbN2v_sin"));
+  EXPECT_EQ(ISA, VFISAKind::ISA_SSE);
+
+  EXPECT_TRUE(invokeParser("_ZGVcN2v_sin"));
+  EXPECT_EQ(ISA, VFISAKind::ISA_AVX);
+
+  EXPECT_TRUE(invokeParser("_ZGVdN2v_sin"));
+  EXPECT_EQ(ISA, VFISAKind::ISA_AVX2);
+
+  EXPECT_TRUE(invokeParser("_ZGVeN2v_sin"));
+  EXPECT_EQ(ISA, VFISAKind::ISA_AVX512);
+}
+
+TEST_F(VFABIParserTest, InvalidMask) {
+  EXPECT_FALSE(invokeParser("_ZGVsK2v_sin"));
+}
+
+TEST_F(VFABIParserTest, InvalidParameter) {
+  EXPECT_FALSE(invokeParser("_ZGVsM2vX_sin"));
+}
+
+TEST_F(VFABIParserTest, Align) {
+  EXPECT_TRUE(invokeParser("_ZGVsN2l2a2_sin"));
+  EXPECT_EQ(Parameters.size(), (unsigned)1);
+  EXPECT_EQ(Parameters[0].Alignment, (unsigned)2);
+
+  // Missing alignement value.
+  EXPECT_FALSE(invokeParser("_ZGVsM2l2a_sin"));
+  // Invalid alignment token "x".
+  EXPECT_FALSE(invokeParser("_ZGVsM2l2ax_sin"));
+  // Alignment MUST be associated to a paramater.
+  EXPECT_FALSE(invokeParser("_ZGVsM2a2_sin"));
+}
+
+TEST_F(VFABIParserTest, ParseUniform) {
+  EXPECT_TRUE(invokeParser("_ZGVnN2u0_sin"));
+  EXPECT_EQ(VF, (unsigned)2);
+  EXPECT_FALSE(IsMasked);
+  EXPECT_EQ(ISA, VFISAKind::ISA_AdvancedSIMD);
+  EXPECT_FALSE(IsScalable);
+  EXPECT_EQ(Parameters.size(), (unsigned)1);
+  EXPECT_EQ(Parameters[0], VFParameter({0, VFParamKind::OMP_Uniform, 0}));
+  EXPECT_EQ(ScalarName, "sin");
+  EXPECT_EQ(VectorName, "_ZGVnN2u0_sin");
+
+  EXPECT_FALSE(invokeParser("_ZGVnN2u_sin"));
+  EXPECT_FALSE(invokeParser("_ZGVnN2ul_sin"));
+}
+
+TEST_F(VFABIParserTest, ISAIndependentMangling) {
+  // This test makes sure that the mangling of the parameters in
+  // independent on the <isa> token.
+  const SmallVector<VFParameter, 8> ExpectedParams = {
+      VFParameter({0, VFParamKind::Vector, 0}),
+      VFParameter({1, VFParamKind::OMP_LinearPos, 2}),
+      VFParameter({2, VFParamKind::OMP_LinearValPos, 27}),
+      VFParameter({3, VFParamKind::OMP_LinearUValPos, 4}),
+      VFParameter({4, VFParamKind::OMP_LinearRefPos, 5}),
+      VFParameter({5, VFParamKind::OMP_Linear, 1}),
+      VFParameter({6, VFParamKind::OMP_LinearVal, 10}),
+      VFParameter({7, VFParamKind::OMP_LinearUVal, 100}),
+      VFParameter({8, VFParamKind::OMP_LinearRef, 1000}),
+      VFParameter({9, VFParamKind::OMP_Uniform, 2}),
+  };
+
+#define __COMMON_CHECKS                                                        \
+  do {                                                                         \
+    EXPECT_EQ(VF, (unsigned)2);                                                \
+    EXPECT_FALSE(IsMasked);                                                    \
+    EXPECT_FALSE(IsScalable);                                                  \
+    EXPECT_EQ(Parameters.size(), (unsigned)10);                                \
+    EXPECT_EQ(Parameters, ExpectedParams);                                     \
+    EXPECT_EQ(ScalarName, "sin");                                              \
+  } while (0)
+
+  // Advanced SIMD: <isa> = "n"
+  EXPECT_TRUE(invokeParser("_ZGVnN2vls2Ls27Us4Rs5l1L10U100R1000u2_sin"));
+  EXPECT_EQ(ISA, VFISAKind::ISA_AdvancedSIMD);
+  __COMMON_CHECKS;
+  EXPECT_EQ(VectorName, "_ZGVnN2vls2Ls27Us4Rs5l1L10U100R1000u2_sin");
+
+  // SVE: <isa> = "s"
+  EXPECT_TRUE(invokeParser("_ZGVsN2vls2Ls27Us4Rs5l1L10U100R1000u2_sin"));
+  EXPECT_EQ(ISA, VFISAKind::ISA_SVE);
+  __COMMON_CHECKS;
+  EXPECT_EQ(VectorName, "_ZGVsN2vls2Ls27Us4Rs5l1L10U100R1000u2_sin");
+
+  // SSE: <isa> = "b"
+  EXPECT_TRUE(invokeParser("_ZGVbN2vls2Ls27Us4Rs5l1L10U100R1000u2_sin"));
+  EXPECT_EQ(ISA, VFISAKind::ISA_SSE);
+  __COMMON_CHECKS;
+  EXPECT_EQ(VectorName, "_ZGVbN2vls2Ls27Us4Rs5l1L10U100R1000u2_sin");
+
+  // AVX: <isa> = "c"
+  EXPECT_TRUE(invokeParser("_ZGVcN2vls2Ls27Us4Rs5l1L10U100R1000u2_sin"));
+  EXPECT_EQ(ISA, VFISAKind::ISA_AVX);
+  __COMMON_CHECKS;
+  EXPECT_EQ(VectorName, "_ZGVcN2vls2Ls27Us4Rs5l1L10U100R1000u2_sin");
+
+  // AVX2: <isa> = "d"
+  EXPECT_TRUE(invokeParser("_ZGVdN2vls2Ls27Us4Rs5l1L10U100R1000u2_sin"));
+  EXPECT_EQ(ISA, VFISAKind::ISA_AVX2);
+  __COMMON_CHECKS;
+  EXPECT_EQ(VectorName, "_ZGVdN2vls2Ls27Us4Rs5l1L10U100R1000u2_sin");
+
+  // AVX512: <isa> = "e"
+  EXPECT_TRUE(invokeParser("_ZGVeN2vls2Ls27Us4Rs5l1L10U100R1000u2_sin"));
+  EXPECT_EQ(ISA, VFISAKind::ISA_AVX512);
+  __COMMON_CHECKS;
+  EXPECT_EQ(VectorName, "_ZGVeN2vls2Ls27Us4Rs5l1L10U100R1000u2_sin");
+
+#undef __COMMON_CHECKS
+}
+
+TEST_F(VFABIParserTest, MissingScalarName) {
+  EXPECT_FALSE(invokeParser("_ZGVnN2v_"));
+}
+
+TEST_F(VFABIParserTest, MissingVectorName) {
+  EXPECT_FALSE(invokeParser("_ZGVnN2v_foo()"));
+}
+
+TEST_F(VFABIParserTest, MissingVectorNameTermination) {
+  EXPECT_FALSE(invokeParser("_ZGVnN2v_foo(bar"));
+}
+
+TEST_F(VFABIParserTest, ParseMaskingNEON) {
+  EXPECT_TRUE(invokeParser("_ZGVnM2v_sin"));
+  EXPECT_EQ(VF, (unsigned)2);
+  EXPECT_TRUE(IsMasked);
+  EXPECT_FALSE(IsScalable);
+  EXPECT_EQ(ISA, VFISAKind::ISA_AdvancedSIMD);
+  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, ParseMaskingSVE) {
+  EXPECT_TRUE(invokeParser("_ZGVsM2v_sin"));
+  EXPECT_EQ(VF, (unsigned)2);
+  EXPECT_TRUE(IsMasked);
+  EXPECT_FALSE(IsScalable);
+  EXPECT_EQ(ISA, VFISAKind::ISA_SVE);
+  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, ParseMaskingSSE) {
+  EXPECT_TRUE(invokeParser("_ZGVbM2v_sin"));
+  EXPECT_EQ(VF, (unsigned)2);
+  EXPECT_TRUE(IsMasked);
+  EXPECT_FALSE(IsScalable);
+  EXPECT_EQ(ISA, VFISAKind::ISA_SSE);
+  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, ParseMaskingAVX) {
+  EXPECT_TRUE(invokeParser("_ZGVcM2v_sin"));
+  EXPECT_EQ(VF, (unsigned)2);
+  EXPECT_TRUE(IsMasked);
+  EXPECT_FALSE(IsScalable);
+  EXPECT_EQ(ISA, VFISAKind::ISA_AVX);
+  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, ParseMaskingAVX2) {
+  EXPECT_TRUE(invokeParser("_ZGVdM2v_sin"));
+  EXPECT_EQ(VF, (unsigned)2);
+  EXPECT_TRUE(IsMasked);
+  EXPECT_FALSE(IsScalable);
+  EXPECT_EQ(ISA, VFISAKind::ISA_AVX2);
+  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, ParseMaskingAVX512) {
+  EXPECT_TRUE(invokeParser("_ZGVeM2v_sin"));
+  EXPECT_EQ(VF, (unsigned)2);
+  EXPECT_TRUE(IsMasked);
+  EXPECT_FALSE(IsScalable);
+  EXPECT_EQ(ISA, VFISAKind::ISA_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");
+}