[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

30

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

30

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

150

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

53

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

30

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

30

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

150

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

30

@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

30

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

30

I think that would be good-enough.

212

files should end with newlines

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

19 ↗

(On Diff #218144)

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

23–26 ↗

(On Diff #218144)

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

19 ↗

(On Diff #218144)

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

64–66 ↗

(On Diff #219420)

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

71 ↗

(On Diff #219420)

Documentation commends have 3x /

75–82 ↗

(On Diff #219420)

VectorVariant

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

104 ↗

(On Diff #219420)

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

164 ↗

(On Diff #219420)

same, and elsewhere.

[fpetrogalli]

llvm/include/llvm/Analysis/VectorUtils.h

75–82 ↗

(On Diff #219420)

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.

104 ↗

(On Diff #219420)

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

164 ↗

(On Diff #219420)

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 ↗

(On Diff #219773)

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 ↗

(On Diff #219773)

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

94 ↗

(On Diff #219773)

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 ↗

(On Diff #219773)

How about renaming to ISA_Unknown ?

llvm/lib/Analysis/VFABIDemangling.cpp

302 ↗

(On Diff #219773)

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 ↗

(On Diff #219773)

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

116 ↗

(On Diff #219940)

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

94 ↗

(On Diff #219773)

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

llvm/lib/Analysis/VFABIDemangling.cpp

30 ↗

(On Diff #219940)

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

314 ↗

(On Diff #219940)

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

356 ↗

(On Diff #219940)

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

[fpetrogalli]

llvm/include/llvm/Analysis/VectorUtils.h

116 ↗

(On Diff #219940)

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 ↗

(On Diff #220128)

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 ↗

(On Diff #220128)

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 ↗

(On Diff #220128)

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 ↗

(On Diff #220128)

I agree with you, thank you.

[sdesmalen]

llvm/include/llvm/Analysis/VectorUtils.h

92 ↗

(On Diff #220511)

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

136 ↗

(On Diff #220511)

nit: this code is still commented out.

[fpetrogalli]

Restore the function name to tryParseForVFABI.

[sdesmalen]

Thanks @fpetrogalli, LGTM!

llvm/include/llvm/Analysis/SearchVectorFunctionSystem.h

+//===- SearchVectorFunctionSystem.h - Search Vector Function System -------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+//
+/// \file
+/// This is the interface used for user provided vector functions with the
+/// vectorizer. It also contains demangling functionality as specified in the
+/// Vector Function ABI specifications.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_ANALYSIS_SVFS_H
+#define LLVM_ANALYSIS_SVFS_H
+
+#include "llvm/ADT/SmallVector.h"
+#include "llvm/ADT/StringRef.h"
+#include "llvm/ADT/StringSwitch.h"
+#include "llvm/IR/DerivedTypes.h"
+#include "llvm/IR/Instructions.h"
+#include "llvm/IR/Module.h"
+#include "llvm/Support/Compiler.h"
+#include "llvm/Support/raw_ostream.h"
+
+namespace llvm {
+
+// Vector Function ABI
+namespace VFABI {
+
+/// Describes the type of Parameters
+enum class ParameterKind {
+  Vector,            // declare simd
+  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)
+  Invalid
+};
+
+/// Describes the type of Instruction Set Architecture
+enum class ISAKind {
+  ISA_AdvancedSIMD,
+  ISA_SVE,
+  ISA_SSE,
+  ISA_AVX,
+  ISA_AVX2,
+  ISA_AVX512,
+  ISA_Invalid
+};
+
+/// Encapsulates information needed to describe a parameter
+class ParamType {
+  unsigned ParamPos;       // Parameter Position in Scalar Function
+  ParameterKind ParamKind; // Kind of Parameter
+  int LinearStepOrPos;     // Step or Position of the Parameter
+
+public:
+  ParamType(unsigned ParamPos, ParameterKind ParamKind, int LinearStepOrPos)
+      : ParamPos(ParamPos), ParamKind(ParamKind),
+        LinearStepOrPos(LinearStepOrPos) {}
+
+  // Constructor for ParameterKind with no step. Eg- ParameterKind::Vector
+  ParamType(unsigned ParamPos, ParameterKind ParamKind)
+      : ParamPos(ParamPos), ParamKind(ParamKind), LinearStepOrPos(0) {}
+
+  bool operator==(const ParamType &other) const {
+    return (ParamPos == other.ParamPos && ParamKind == other.ParamKind &&
+            LinearStepOrPos == other.LinearStepOrPos);
+  }
+
+  bool isVector() { return ParamKind == ParameterKind::Vector; }
+
+  bool isLinear() { return ParamKind == ParameterKind::OMP_Linear; }
+
+  bool isLinearVal() { return ParamKind == ParameterKind::OMP_LinearVal; }
+
+  bool isLinearRef() { return ParamKind == ParameterKind::OMP_LinearRef; }
+
+  bool isLinearUVal() { return ParamKind == ParameterKind::OMP_LinearUVal; }
+
+  bool isLinearPos() { return ParamKind == ParameterKind::OMP_LinearPos; }
+
+  bool isLinearValPos() { return ParamKind == ParameterKind::OMP_LinearValPos; }
+
+  bool isLinearRefPos() { return ParamKind == ParameterKind::OMP_LinearRefPos; }
+
+  bool isLinearUValPos() {
+    return ParamKind == ParameterKind::OMP_LinearUValPos;
+  }
+
+  bool isUniform() { return ParamKind == ParameterKind::OMP_Uniform; }
+
+  int getLinearStepOrPos() { return LinearStepOrPos; }
+
+  void setLinearStepOrPos(int s) { LinearStepOrPos = s; }
+
+  ParameterKind getParameterKind() { return ParamKind; }
+
+  static ParameterKind convertToParameterKind(StringRef kind) {
+    ParameterKind ParamKind = StringSwitch<ParameterKind>(kind)
+                                  .Case("v", ParameterKind::Vector)
+                                  .Case("l", ParameterKind::OMP_Linear)
+                                  .Case("R", ParameterKind::OMP_LinearRef)
+                                  .Case("L", ParameterKind::OMP_LinearVal)
+                                  .Case("U", ParameterKind::OMP_LinearUVal)
+                                  .Case("ls", ParameterKind::OMP_LinearPos)
+                                  .Case("Ls", ParameterKind::OMP_LinearValPos)
+                                  .Case("Rs", ParameterKind::OMP_LinearRefPos)
+                                  .Case("Us", ParameterKind::OMP_LinearUValPos)
+                                  .Case("u", ParameterKind::OMP_Uniform)
+                                  .Default(ParameterKind::Invalid);
+
+    if (ParamKind == ParameterKind::Invalid)
+      llvm_unreachable("Unexpected Parameter Kind");
+    return ParamKind;
+  }
+
+  unsigned getParamPos() { return ParamPos; }
+
+  void setParamPos(unsigned Position) { ParamPos = Position; }
+};
+
+/// Contains the information about the kind of vectoriazation available
+class VectorFunctionShape {
+
+public:
+  unsigned VF;                          // Vectorization factor
+  bool IsMasked;                        // True if Masked
+  bool IsScalable;                      // True if Scalable
+  ISAKind ISA;                          // Instruction Set Arch
+  SmallVector<ParamType, 8> Parameters; // List of Parameter Info
+  StringRef ScalarName;                 // Scalar Function Name
+  StringRef VectorName;                 // Vector ABI Mangled Name
+
+  // Equality checks
+  bool operator==(const VectorFunctionShape &other) const {
+    return (VF == other.VF && IsMasked == other.IsMasked &&
+            IsScalable == other.IsScalable && ISA == other.ISA &&
+            Parameters == other.Parameters && ScalarName == other.ScalarName &&
+            VectorName == other.VectorName);
+  }
+
+  VectorFunctionShape(StringRef MangledName) {
+    VectorName = MangledName;
+    assert(parseABISignature(MangledName) && "Incorrect VFABI Signature\n");
+    ISA = parseISA(MangledName);
+    IsMasked = parseIsMasked(MangledName);
+    VF = parseVF(MangledName);
+    IsScalable = getIsScalable();
+    parseParameters(MangledName);
+    ScalarName = parseScalarName(MangledName);
+  }
+
+  /// parses the name of the Vector variant of the function
+  /// \param MangledName - Mangled name to be parsed
+  /// \param Result Vector Function name
+  static StringRef getVectorName(StringRef MangledName);
+  /// parses the ABI mangled name without redirection specified
+  /// \param MangledName - Mangled name to be parsed
+  /// \param Result Vector Function name
+  static StringRef getPartMangledName(StringRef MangledName);
+
+private:
+  /// Checks ABI Signature
+  /// \param MangledName - Mangled name to be parsed
+  /// \param Result True if the MangledName follows the ABI signature
+  bool parseABISignature(StringRef &MangledName);
+  /// parses Instruction Set Architecture
+  /// \param MangledName - Mangled name to be parsed
+  /// \param Result The ISA specified in the mangled name
+  ISAKind parseISA(StringRef &MangledName);
+  /// Checks for Mask (inbranch, notinbranch)
+  /// \param MangledName - Mangled name to be parsed
+  /// \param Result True if Masked
+  bool parseIsMasked(StringRef &MangledName);
+  /// parses vectorization factor
+  /// \param MangledName - Mangled name to be parsed
+  /// \param Result Vectorization factor
+  unsigned parseVF(StringRef &MangledName);
+  /// parses the name of the Scalar variant of the function
+  /// \param MangledName - Mangled name to be parsed
+  /// \param Result Scalar Function name
+  StringRef parseScalarName(StringRef &MangledName);
+  /// Parses parameter Information
+  /// \param ParameterList - Substring of the Mangled Name which captures the
+  /// info about the parameters \param Parameters Populated SmallVector about
+  /// Parameter information
+  void parseParamList(StringRef ParameterList);
+  /// Checks if it supports scalability
+  /// \param MangledName - Mangled name to be parsed
+  /// \param Result True if scalable version exists
+  bool getIsScalable();
+  /// Parses the parameters information
+  /// \param MangledName - Mangled name to be parsed
+  /// \param NewRecord - Populate the Parameters in the new record
+  void parseParameters(StringRef &MangledName);
+};
+
+} // end namespace VFABI
+
+} // end namespace llvm
+
+#endif // LLVM_ANALYSIS_SVFS_H
 No newline at end of file

llvm/lib/Analysis/CMakeLists.txt

add_llvm_library(LLVMAnalysis
   PtrUseVisitor.cpp
   RegionInfo.cpp
   RegionPass.cpp
   RegionPrinter.cpp
   ScalarEvolution.cpp
   ScalarEvolutionAliasAnalysis.cpp
   ScalarEvolutionExpander.cpp
   ScalarEvolutionNormalization.cpp
+  SearchVectorFunctionSystem.cpp
   StackSafetyAnalysis.cpp
   SyncDependenceAnalysis.cpp
   SyntheticCountsUtils.cpp
   TargetLibraryInfo.cpp
   TargetTransformInfo.cpp
   Trace.cpp
   TypeBasedAliasAnalysis.cpp
   TypeMetadataUtils.cpp

llvm/lib/Analysis/SearchVectorFunctionSystem.cpp

+//===- SearchVectorFunctionSystem.cpp - Search Vector Function System -----===//
+//
+// 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/SearchVectorFunctionSystem.h"
+#include "llvm/ADT/SmallVector.h"
+#include "llvm/IR/Function.h"
+#include "llvm/IR/InstIterator.h"
+#include "llvm/IR/PassManager.h"
+#include "llvm/Pass.h"
+#include "llvm/Support/Compiler.h"
+#include "llvm/Support/raw_ostream.h"
+
+using namespace llvm;
+
+using namespace VFABI;
+
+bool VectorFunctionShape::parseABISignature(StringRef &MangledName) {
+  // Capture the ABI Signature value
+  if (MangledName.startswith("_ZGV")) {
+    MangledName = MangledName.drop_front(4);
+    return true;
+  }
+  return false;
+}
+
+ISAKind VectorFunctionShape::parseISA(StringRef &MangledName) {
+  // Capture the ISA value
+  StringRef ISAValue = MangledName.substr(0, 1);
+
+  ISAKind ISA = StringSwitch<ISAKind>(ISAValue)
+                    .Case("n", ISAKind::ISA_AdvancedSIMD)
+                    .Case("s", ISAKind::ISA_SVE)
+                    .Case("b", ISAKind::ISA_SSE)
+                    .Case("c", ISAKind::ISA_AVX)
+                    .Case("d", ISAKind::ISA_AVX2)
+                    .Case("e", ISAKind::ISA_AVX512)
+                    .Default(ISAKind::ISA_Invalid);
+
+  assert(ISA != ISAKind::ISA_Invalid && "Invalid ISA Specified");
+  MangledName = MangledName.drop_front(1);
+  return ISA;
+}
+
+bool VectorFunctionShape::parseIsMasked(StringRef &MangledName) {
+  // Capture the MASK value
+  StringRef Mask;
+  bool IsMasked;
+  Mask = MangledName.substr(0, 1);
+  MangledName = MangledName.drop_front(1);
+  if (this->ISA == ISAKind::ISA_SVE)
+    return true;
+  assert((Mask.equals("N") || Mask.equals("M")) && "Invalid masking option");
+  IsMasked = Mask.equals("N") ? false : true;
+  return IsMasked;
+}
+
+unsigned VectorFunctionShape::parseVF(StringRef &MangledName) {
+  // Capture the VF
+  // VectorLength can be any positive integer
+  unsigned VF;
+  std::size_t Pos;
+
+  Pos = MangledName.find_first_of("vlRLUu_", 0);
+  if (MangledName.substr(0, 1).equals("x")) {
+    assert(this->ISA == ISAKind::ISA_SVE && "Incompatible ISA");
+    MangledName = MangledName.drop_front(1);
+    return 0;
+  }
+  MangledName.substr(0, Pos).consumeInteger(10, VF);
+  MangledName = MangledName.drop_front(Pos);
+  return VF;
+}
+
+bool VectorFunctionShape::getIsScalable() {
+  // Capture if it is Scalable or Not
+  bool IsSVE = this->ISA == ISAKind::ISA_SVE;
+  bool IsVFZero = this->VF == 0;
+  return IsSVE && IsVFZero;
+}
+
+StringRef VectorFunctionShape::parseScalarName(StringRef &MangledName) {
+  // parse Scalar function name
+  StringRef ScalarFunctionName;
+  std::size_t NewPos;
+
+  MangledName = MangledName.drop_front(1);
+
+  NewPos = MangledName.find("(", 0);
+  // Handles Case: custom vector function name not provided
+  if (NewPos == StringRef::npos)
+    NewPos = MangledName.size();
+  ScalarFunctionName = MangledName.substr(0, NewPos);
+  return ScalarFunctionName;
+}
+
+StringRef VectorFunctionShape::getVectorName(StringRef MangledName) {
+  // parse vector Function Name
+  StringRef VectorFunctionName;
+  std::size_t Pos;
+  std::size_t NewPos;
+
+  Pos = MangledName.find("(");
+  if (Pos == StringRef::npos)
+    return MangledName;
+  Pos++;
+  NewPos = MangledName.find(")", Pos);
+  VectorFunctionName = MangledName.substr(Pos, NewPos - Pos);
+
+  return VectorFunctionName;
+}
+
+StringRef VectorFunctionShape::getPartMangledName(StringRef MangledName) {
+  // Part Mangled Name is Mangled Name without custom vector function
+  // redirection
+  StringRef PartMangledName;
+  std::size_t Pos;
+
+  Pos = MangledName.find("(");
+  if (Pos == StringRef::npos)
+    PartMangledName = MangledName;
+  else
+    PartMangledName = MangledName.substr(0, Pos);
+  return PartMangledName;
+}
+
+void VectorFunctionShape::parseParamList(StringRef ParamList) {
+  std::size_t Pos; // Pos to iterate ParamList
+  std::size_t NewPos;
+
+  unsigned ParamPos = 0; // parameter position
+  int LinearStepOrPos;
+
+  Pos = 0;
+  StringRef ParamKindStr;
+  ParameterKind ParamKind;
+
+  // Parse the param list and store it to VFS.Parameters
+  // NewPos - Pos = length of param string
+  // length of param string = ParamList.str().length()
+  // TODO: Handle negative numbers for LinearStepOrPos.
+  // Eg=linear(val(ParamPos):-3)=`Ln3`
+  while ((NewPos = ParamList.find_first_of("vlRLUu", Pos + 1)) <
+         (ParamList.str().length())) {
+    ParamKindStr = ParamList.substr(Pos, 1);
+    if (ParamList.substr(Pos + 1, 1).equals("s")) {
+      ParamKindStr = ParamList.substr(Pos, 2);
+      Pos++;
+    }
+    // +1 to read the LinearStepOrPos value after the param kind
+    Pos++;
+    if (NewPos > Pos) {
+      ParamList.substr(Pos, NewPos - (Pos)).consumeInteger(10, LinearStepOrPos);
+      ParamKind = ParamType::convertToParameterKind(ParamKindStr);
+      this->Parameters.push_back(
+          ParamType(ParamPos, ParamKind, LinearStepOrPos));
+    } else {
+      ParamKind = ParamType::convertToParameterKind(ParamKindStr);
+      ParamType Parameter(ParamPos, ParamKind);
+      assert((Parameter.isLinear() || Parameter.isLinearRef() ||
+              Parameter.isLinearVal() || Parameter.isVector() ||
+              Parameter.isUniform() || Parameter.isLinearUVal()) &&
+             "Step Not Specified for given ParameterKind");
+      // Default LinearStepOrPos value if not specified in ABI signature
+      if (Parameter.isLinear() || Parameter.isLinearRef() ||
+          Parameter.isLinearVal() || Parameter.isLinearUVal()) {
+        Parameter.setLinearStepOrPos(1);
+      }
+      this->Parameters.push_back(Parameter);
+    }
+    ParamPos++;
+    Pos = NewPos;
+  }
+
+  // Last param value OR if it is the only parameter
+  // NewPos is the end of StringRef ParamList
+  ParamKindStr = ParamList.substr(Pos, 1);
+  if (ParamList.substr(Pos + 1, 1).equals("s")) {
+    ParamKindStr = ParamList.substr(Pos, 2);
+    Pos++;
+  }
+  ParamKind = ParamType::convertToParameterKind(ParamKindStr);
+  // +1 to read the LinearStepOrPos value after the param kind
+  if ((ParamList.str().length()) > Pos + 1) {
+    StringRef StrLinearStepOrPos =
+        ParamList.substr(Pos + 1, (ParamList.str().length()) - (Pos + 1));
+    StrLinearStepOrPos.consumeInteger(10, LinearStepOrPos);
+    this->Parameters.push_back(ParamType(ParamPos, ParamKind, LinearStepOrPos));
+  } else {
+    ParamType Parameter(ParamPos, ParamKind);
+    assert((Parameter.isLinear() || Parameter.isLinearRef() ||
+            Parameter.isLinearVal() || Parameter.isVector() ||
+            Parameter.isUniform() || Parameter.isLinearUVal()) &&
+           "Step Not Specified for given ParameterKind");
+    // Default LinearStepOrPos value if not specified in ABI signature
+    if (Parameter.isLinear() || Parameter.isLinearRef() ||
+        Parameter.isLinearVal()) {
+      Parameter.setLinearStepOrPos(1);
+    }
+    this->Parameters.push_back(Parameter);
+  }
+}
+
+void VectorFunctionShape::parseParameters(StringRef &MangledName) {
+  // Capture the parameters
+  StringRef ParameterList;
+  std::size_t NewPos;
+
+  NewPos = MangledName.find("_", 0);
+  ParameterList = MangledName.substr(0, NewPos);
+  if (!ParameterList.empty())
+    VectorFunctionShape::parseParamList(ParameterList);
+  MangledName = MangledName.drop_front(ParameterList.size());
+}

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
   )

llvm/unittests/Analysis/VectorFunctionABITest.cpp

+//===------- SearchVectorFunctionSystemTest.cpp - SVFS 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/SearchVectorFunctionSystem.h"
+#include "llvm/Support/SourceMgr.h"
+#include "llvm/Support/raw_ostream.h"
+#include "gtest/gtest.h"
+
+using namespace llvm;
+using namespace VFABI;
+
+TEST(VectorFunctionABITests, ParamListParsing) {
+  // Testing "vl16Ls32R3l"
+  VectorFunctionShape VFS("_ZGVnN2vl16Ls32R3l_foo");
+
+  EXPECT_EQ(VFS.Parameters[0].getParamPos(), (unsigned)0);
+  EXPECT_TRUE(VFS.Parameters[0].isVector());
+
+  EXPECT_EQ(VFS.Parameters[1].getParamPos(), (unsigned)1);
+  EXPECT_TRUE(VFS.Parameters[1].isLinear());
+  EXPECT_EQ(VFS.Parameters[1].getLinearStepOrPos(), 16);
+
+  EXPECT_EQ(VFS.Parameters[2].getParamPos(), (unsigned)2);
+  EXPECT_TRUE(VFS.Parameters[2].isLinearValPos());
+  EXPECT_EQ(VFS.Parameters[2].getLinearStepOrPos(), 32);
+
+  EXPECT_EQ(VFS.Parameters[3].getParamPos(), (unsigned)3);
+  EXPECT_TRUE(VFS.Parameters[3].isLinearRef());
+  EXPECT_EQ(VFS.Parameters[3].getLinearStepOrPos(), 3);
+
+  EXPECT_EQ(VFS.Parameters[4].getParamPos(), (unsigned)4);
+  EXPECT_TRUE(VFS.Parameters[4].isLinear());
+  EXPECT_EQ(VFS.Parameters[4].getLinearStepOrPos(), 1);
+
+  EXPECT_DEATH(VectorFunctionShape("_ZGVnN2Ts_sin"),
+               "Unexpected Parameter Kind");
+  
+  EXPECT_DEATH(VectorFunctionShape("_ZGVnN2vLs_sin"),
+               "Step Not Specified for given ParameterKind"); 
+}
+
+TEST(VectorFunctionABITests, NameDemangling) {
+  VectorFunctionShape VFS("_ZGVnN2vl_sin");
+
+  EXPECT_EQ(VFS.VF, (unsigned)2);
+  EXPECT_FALSE(VFS.IsMasked);
+  EXPECT_EQ(VFS.ISA, ISAKind::ISA_AdvancedSIMD);
+
+  // Does call parseParamList()
+  EXPECT_TRUE(VFS.Parameters[0].isVector());
+  EXPECT_EQ(VFS.Parameters[0].getParamPos(), (unsigned)0);
+
+  EXPECT_EQ(VFS.Parameters[1].getLinearStepOrPos(), 1);
+  EXPECT_TRUE(VFS.Parameters[1].isLinear());
+  EXPECT_EQ(VFS.Parameters[1].getParamPos(), (unsigned)1);
+
+  EXPECT_EQ(VFS.ScalarName, "sin");
+  EXPECT_EQ(VFS.VectorName, "_ZGVnN2vl_sin");
+}
+
+TEST(VectorFunctionABITests, FunctionalityTests) {
+  // Parse ISA Kind
+  VectorFunctionShape VFS("_ZGVnN2vl_sin");
+  EXPECT_EQ(VectorFunctionShape("_ZGVnN2vl_sin").ISA,
+            ISAKind::ISA_AdvancedSIMD);
+  EXPECT_EQ(VectorFunctionShape("_ZGVsN2v_sin").ISA, ISAKind::ISA_SVE);
+  EXPECT_EQ(VectorFunctionShape("_ZGVbN2v_sin").ISA, ISAKind::ISA_SSE);
+  EXPECT_EQ(VectorFunctionShape("_ZGVcN2v_sin").ISA, ISAKind::ISA_AVX);
+  EXPECT_EQ(VectorFunctionShape("_ZGVdN2_sin").ISA, ISAKind::ISA_AVX2);
+  EXPECT_EQ(VectorFunctionShape("_ZGVeN2_sin").ISA, ISAKind::ISA_AVX512);
+  EXPECT_DEATH(VectorFunctionShape("_ZGVzN2vl_sin"), "Invalid ISA Specified");
+
+  // Parse Mask Value
+  EXPECT_TRUE(VectorFunctionShape("_ZGVnM2v_sin").IsMasked);
+  EXPECT_FALSE(VectorFunctionShape("_ZGVnN2v_sin").IsMasked);
+  EXPECT_TRUE(VectorFunctionShape("_ZGVsN2v_sin").IsMasked);
+  EXPECT_TRUE(VectorFunctionShape("_ZGVsM2v_sin").IsMasked);
+  EXPECT_DEATH(VectorFunctionShape("_ZGVnO2v_sin"), "Invalid masking option");
+
+  // Parse Scalable Value
+  EXPECT_TRUE(VectorFunctionShape("_ZGVsMxv_sin").IsScalable);
+  EXPECT_FALSE(VectorFunctionShape("_ZGVsM2v_sin").IsScalable);
+
+  // Parse VF
+  EXPECT_EQ(VectorFunctionShape("_ZGVnM2v_sin").VF, (unsigned)2);
+  EXPECT_EQ(VectorFunctionShape("_ZGVnM22v_sin").VF, (unsigned)22);
+  EXPECT_EQ(VectorFunctionShape("_ZGVsMxv_sin").VF, (unsigned)0);
+  EXPECT_DEATH(VectorFunctionShape("_ZGVnMxv_sin"), "Incompatible ISA");
+
+  // Parse Scalar Name
+  EXPECT_EQ(VectorFunctionShape("_ZGVnM2v_sin").ScalarName, "sin");
+  EXPECT_EQ(VectorFunctionShape("_ZGVnM2v_sin(UserFunc)").ScalarName, "sin");
+  EXPECT_EQ(VectorFunctionShape("_ZGVnM2v___sin_sin_sin").ScalarName,
+            "__sin_sin_sin");
+
+  // Get Vector Name
+  EXPECT_EQ(VectorFunctionShape::getVectorName("_ZGVnM2v_sin"), "_ZGVnM2v_sin");
+  EXPECT_EQ(VectorFunctionShape::getVectorName("_ZGVnM2v_sin(UserFunc)"),
+            "UserFunc");
+}