SVFS implementation according to RFC: Interface user provided vector functions with the vectorizer.

[aranisumedh]

Summary

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

[jdoerfert]

Some high level coding comments.

Documentation needed in various places.

Why std::vector and not llvm::SmallVector for example?

llvm/include/llvm/Analysis/SearchVectorFunctionSystem.h

36

I'd like some "class comment" and also comments on the members. It is not clear to everyone (incl. me) what distinguishes for example LinearValPos and LinearUValPos and why we need that.

49

automatically private.

55

I don't think this is a good idea.

63

) : ParamPos(ParamPos), LinearStepOrPos(0)

Why take a string just to convert it? Shouldn't we expose the conversion as a static member and expect a enum here. That way users can use the conversion if they need to but if they know the enums they want there is no need to go through the string first.

113

One could generate them with a macro if one wanted to:

#declare LOOKUP_FN(NAME) \
   bool is ##NAME () { \
            return ParamKind == ParameterKind::OMP_ ## NAME; \
   }

LOOKUP_FN(Uniform)
...
#undef LOOKUP_FN(NAME)

138

The default case is missing. llvm_unreachable I assume.

151

Make it a struct or do not expose all members.

154

) : M(M) {}

158

No need for the typedef. Again, please add comments to the class and members.

164

(Honest question) Can't we use something like = default or is that a C++ feature we are not allowed to use yet?

llvm/lib/Analysis/SearchVectorFunctionSystem.cpp

21

MangledName.startswith("_ZGV") ?

37

You could add an "ISA_UNKNOWN" case as a default here and assert on that one. Would probably make it slightly easier to maintain. But this is fine as well.

[aranisumedh]

Added code to expose the functionality as an Analysis Pass. Integrated changes as suggested in prior code review.

[aranisumedh]

llvm/include/llvm/Analysis/SearchVectorFunctionSystem.h

55

I forgot to remove the comment. This is incorrect comment.

This constructor is not used for testing.

63

I preferred to use a string as demangling does String parsing. Hence, I thought it would be easier to call a class constructor with the StringRef as it's argument.

138

I don't think StringSwitch Default Case handles llvm_unreachable

164

It is a C++ 20 feature. Hence, I think I cannot use it for now. https://en.cppreference.com/w/cpp/keyword/default

[jdoerfert]

Second round, we make progress :)

Style:
We usually prefer C++-style comments // if possible. They are placed in front of variables (not for enums). And you should use doxygen style comments whenever it'll get picked up, so in front of any declaration (class, member, ...). (see also the style stuff here: https://llvm.org/docs/CodingStandards.html)

Test:
It looks like the tests are all positive, e.g., good input results in good return. Could you add some to make sure invalid input is detected _and_ reported as such?

llvm/include/llvm/Analysis/SearchVectorFunctionSystem.h

92

Why not LOOKUP_PARAMETER(Vector)?

I don't think you want ; at the end.

Cleanup:
#undef LOOKUP_PARAMETER

111

What is the default here? What happens for bad inputs?

121

Doxygen class comment.

122

I found a single use of this exposed member and that use can be replaced by something like:
Call->getModule()
If there is no reason to have this member, get rid of it and all the init stuff.

162

These doxygen documentations do not match the methods.

197

These methods lack doxygen documentation.

217

It seems the new pass manager interface is missing.

llvm/lib/Analysis/SearchVectorFunctionSystem.cpp

278

for (Instruction &I : instructions(F))

[aranisumedh]

llvm/include/llvm/Analysis/SearchVectorFunctionSystem.h

111

Should I add an assert before the StringSwitch?

Or add OMP_Unknown to handle such cases?

217

Could you share pointers to how to add a new pass using the new pass manager interface?

[jdoerfert]

llvm/include/llvm/Analysis/SearchVectorFunctionSystem.h

111

I would prefere the OMP_Unknown case but I am probably fine with any error checking solution. I mainly want to avoid silent errors.

217

Take a look at other patches that do it, e.g., D64185

[aranisumedh]

llvm/include/llvm/Analysis/SearchVectorFunctionSystem.h

92

Vector is a generic case and not just restricted to OMP. Hence, for the macro to work, there is a prefix OMP_ attached to the rest of the scenarios and not Vector.

122

I did make this change but however, as I'm building the CallInst programmatically in the test case, this leads to a segmentation fault.

However, in the patch that is to follow(hooking to the loopVectorizer), Call->getModule() works perfectly.

Do you have any suggestions as so as to get the getVectorizedFunction test working as specified in SearchVectorFunctionTest.cpp

Also, do I use AssertionSuccess() and AssertionFailure() for testing bad inputs?

[aranisumedh]

Thank you for valuable inputs. Sorry for the delay in getting back to you.

I have mostly used asserts() to capture bad inputs. I have not yet added tests to test for bad input. Google test had documentation using AssertionSuccess() and AssertionFailure(). [https://github.com/google/googletest/blob/master/googletest/docs/advanced.md]. Do I use that or you've something else in mind?

[jdoerfert]

I think someone else should start looking at this.

llvm/include/llvm/Analysis/SearchVectorFunctionSystem.h

122

You lost me here.

138

I guess you can do this: add a default case, if that value is chosen invoke llvm_unreachable.

llvm/unittests/Analysis/SearchVectorFunctionSystemTest.cpp

274

I doubt we want to output anything here.

[aranisumedh]

llvm/include/llvm/Analysis/SearchVectorFunctionSystem.h

122

I have added a new comment that points to the issue better.

138

Will update.

llvm/unittests/Analysis/SearchVectorFunctionSystemTest.cpp

228

I create the CallInst programmatically here. The stack trace tells me the bug is in getVectorizedFunction in SearchVectorFunctionSystem.cpp. When it calls Call->getModule(), a segmentation fault occurs. As I understand, the CallInst is probably not getting inserted in the module.

I was wondering how do I modify the test case so as to suit this functionality?

274

Yes. Forgot to remove the comments. It was for debugging purpose.

[aranisumedh]

Minor changes as suggested in the recent review.

[jdoerfert]

llvm/unittests/Analysis/SearchVectorFunctionSystemTest.cpp

228

CallInst should have a constructor/create method that takes a basic block or instruction. Alternatively, call Call->insertXXX later.

[a.elovikov]

Thanks for working on this! I'm really interested in using this functionality so here are some comments on the main interface header.

llvm/include/llvm/Analysis/SearchVectorFunctionSystem.h

45

How is this different from Vector?

56

That's great, I see how it can be used for non-OMP usage.

61

Is it original (scalar) call position or vector call position? Please make it clear in the comment.

I'm interested in this because my use case might have Mask argument in the vector function variant in the middle of other arguments. Is it possible to handle that with this patch?

66

My preference for this is to make the ctor private and provide public static functions to create different set of required arguments for different kinds. E.g. no LinearStepOrPos of varying/vector parameter. SOmething like this:

private:
  ParamType()

public
  static ParamType vector() { return ParamType{}; }
  static ParamType linear(int LinearStep) { ... }
  static ParamType linearWithNonConstStride(unsigned StepArgPosition) { ... }

Feel free to ignore though.

84

I'm not sure if more broad "isLinear" interface for all the Linear* would be useful. Kind of sad if we won't be able to have it because of this accessors.

94

I would split it into two methods with proper asserts for the correct kind of this param.

96

Do we really need the setter? Why once created param description could change?

121

This is marked as done but I don't see the doxygen comment...

131

Isn't it part of ISA somehow? Why do we need a separate flag that isn't applicable for all the ISAs? Or do I miss something here?

Also, I'm not familiar with is (I assume it's related to SVE) - how does it deal with VF. Do we still need VF here if IsScalable is true?

134

Is it possible to add the information about the return value? Like varying vector/uniform scalar/uniform vector.

171

I'd rather have an interface not referencing the CallInst (e.g. mangled name instead). Why doesn't it have a "bool Masked" parameter?

178

Same as above, I think. E.g. interface without CallInst, bool Mask.

195

I'm not sure why is in VFABI namespace. Mask/NoMask isn't ABI-specific. Same for functions below.

[aranisumedh]

llvm/include/llvm/Analysis/SearchVectorFunctionSystem.h

45

You mean Unknown? It's for error handling.

61

It is the original call position.

84

It just checks if the parameter type is OMP_Linear. It doesn't check for Linear* case

94

According to the VFABI, it'll be either step or pos associated. If we split this into two, we would need more variables.

As per the ABI, if it's ls, Rs, Ls, Us, u, only then would we pos associated with the parameter else it's a step.

96

No. I don't think the parameters can change. I can change the implementation so as to avoid using the setter function.

131

If the VF is set to 'x' and and the ISA is SVE, it is then the IsScalable flag is set to true.

134

Could you elaborate, so as to make sure I get you right?

171

We are trying to search for all the vector function mappings available for a given scalar function by querying the SVFS table. Hence, I think that it is better to pass the CallInst, where we check for records in our table with matching scalar names. It also follows the description in the RFC.

178

You can specify the bool Mask within the VectorFunctionShape that is the second parameter. In the separate patch that is to follow, I'll demonstrate how the loop vectorizer will call and query SVFS to vectorize a CallInst.

195

The parsing of the mangled names is as described in the Vector Function ABI. All these functions take in mangled name and parse the information. Hence, I decided to keep these function within the VFABI namespace.

[sdesmalen]

Thanks @aranisumedh for working on this!

The patch is quite big and I think it would be easier to review if it is split up. My main concern is that this patch conflates the SVFS pass/mechanism and the (demangling for the) AArch64 Vector ABI, which I think need to be split up into separate patches.

If you add a print method to the SVFS pass, you can print the available vector mappings as described in LLVM IR function attributes by running opt -analyze -svfs, which would make it easier to test using FileCheck. If you add that first, you could use the -analyze functionality to test the demangling of the AArch64 Vector ABI with .ll tests.

Not sure if this was already discussed anywhere else, but is there a reason this doesn't live in TargetLibraryInfo? There is already a getVectorizedFunction in that class, so it makes sense to make that method more powerful by having it take a VectorFunctionShape as well as unsigned VF.

llvm/include/llvm/Analysis/SearchVectorFunctionSystem.h

45

It is more explicit to rename it to Invalid in that case.

81

Can you just expand these functions instead of using a pragma? Given the simplicity of the definition there is little benefit to using a macro here, and having them expanded would make it easier to search for in the codebase.

100

is this not specific to the AArch64 Vector ABI?

128

VectorFunctionShape could benefit from having a constructor, if only to ensure that a VectorFunctionShape is valid and can be used as operand in operator==.

153

Do we want to expose RecordTable?

179

This method asks for a vectorized function that *exactly*matches the specifications in VectorFunctionShape info. You may want to think about a mechanism in VectorFunctionShape where you can distinguish "required" and "optional" features. For example, if this function is asked for to return an unpredicated vector function, but it only has a predicated vector function, we'd still prefer to get the predicated vector function and construct an "all true" predicate, rather than having to fall back on scalar instructions.

llvm/lib/Analysis/SearchVectorFunctionSystem.cpp

266

I think you should either support 1 mapping, or support multiple mappings with a clear mechanism to prioritise which mapping takes priority. This function seems to prioritise based on whether or not a function-name is mangled which makes little sense to me.

[aranisumedh]

As suggested earlier by Sander, I'll be splitting this patch into two patches for easier review.

[aranisumedh]

llvm/include/llvm/Analysis/SearchVectorFunctionSystem.h

96

The current implementation allows me to handle corner cases better. This setter function is used to set the LinearStepOrPos for the first time.

100

No. IIRC, this is in agreement with other vendors too.

121

That is because it was a part of the last diff. Hence, the lines get moved. The getter and setters are pretty straightforward. Do I still add a doxygen comment for the same?

153

Making it private.

[aranisumedh]

llvm/lib/Analysis/SearchVectorFunctionSystem.cpp

266

The priority is given on the basis that there exists a redirection to a custom user-defined function. This scenario arises from the different uses of declare simd and declare variant.

And the implementation follows that we save the VectorName as the mangledName if there is no redirection. Hence we prioritize declare variant over declare simd

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.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_ANALYSIS_SVFS_H
+#define LLVM_ANALYSIS_SVFS_H
+
+#include "llvm/ADT/APFloat.h"
+#include "llvm/ADT/SmallVector.h"
+#include "llvm/ADT/Statistic.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/IR/PassManager.h"
+#include "llvm/Pass.h"
+#include "llvm/Support/Compiler.h"
+#include "llvm/Support/raw_ostream.h"
+
+namespace llvm {
+
+/// 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)
+  Unknown
+};
+
+/// Describes the type of Instruction Set Architecture
+enum class ISAKind {
+  ISA_AdvancedSIMD,
+  ISA_SVE,
+  ISA_SSE,
+  ISA_AVX,
+  ISA_AVX2,
+  ISA_AVX512,
+  ISA_Unknown
+};
+
+/// Encapsulates information needed to describe a parameter
+class ParamType {
+  unsigned ParamPos;       // Parameter Position
+  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; }
+
+#define LOOKUP_PARAMETER(PARAM)                                                \
+  bool is##PARAM() { return ParamKind == ParameterKind::OMP_##PARAM; }
+
+  LOOKUP_PARAMETER(Linear)
+  LOOKUP_PARAMETER(LinearVal)
+  LOOKUP_PARAMETER(LinearRef)
+  LOOKUP_PARAMETER(LinearUVal)
+  LOOKUP_PARAMETER(LinearPos)
+  LOOKUP_PARAMETER(LinearValPos)
+  LOOKUP_PARAMETER(LinearRefPos)
+  LOOKUP_PARAMETER(LinearUValPos)
+  LOOKUP_PARAMETER(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::Unknown);
+
+    if(ParamKind == ParameterKind::Unknown)
+      llvm_unreachable("Unexpected Parameter Kind");
+    return ParamKind;
+  }
+
+  unsigned getParamPos() { return ParamPos; }
+
+  void setParamPos(unsigned Position) { ParamPos = Position; }
+};
+
+/// Search Vector Function System Functionality
+struct SVFS {
+  // Contains the information about the kind of vectoriazation available
+  // for a llvm::CallInst
+  struct VectorFunctionShape {
+    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
+
+    // Equality checks
+    bool operator==(const VectorFunctionShape &other) const {
+      return (VF == other.VF && IsMasked == other.IsMasked &&
+              IsScalable == other.IsScalable && ISA == other.ISA &&
+              Parameters == other.Parameters);
+    }
+  };
+
+  // Encapuslates the other required information from the available
+  // user-defined vector function
+  struct VectorRecord {
+    VectorFunctionShape VFS; // Vector Function Shape
+    StringRef ScalarName;    // Scalar Name of the Function
+    StringRef VectorName;    // Vector Name of the function
+  };
+
+  // RecordTable stores all the information for querying
+  // Uses a vector as this table will not have a large entries
+  SmallVector<VectorRecord, 8> RecordTable;
+
+  /// Creates a table for quick lookup of available vector functions.
+  ///
+  /// \param Call - Extract information to populate the table
+  /// the vector function signature
+  void createTableLookupRecord(CallInst *Call);
+
+  /// Does name demangling
+  /// \param MangledName - Mangled name for demangling
+  /// \param Result filled with a populated vector record after name
+  /// demangling
+  void demangleName(StringRef MangledName, SVFS::VectorRecord &Record);
+
+  /// Checks for available vectorizable function
+  /// \param Call - Extract information to query the table
+  /// \param Result Available vector function shapes for vectorization
+  SmallVector<VectorFunctionShape, 8>
+  isFunctionVectorizable(CallInst *Call) const;
+
+  /// Returns the user-defined vector function
+  /// \param Call - Extract information to query the table
+  /// \param Info - Return user-defined vector function which matches the
+  /// VectorFunctionShape passed as argument
+  /// \param Result Available vector function shapes for vectorization
+  Function *getVectorizedFunction(llvm::CallInst *Call,
+                                  VectorFunctionShape Info) const;
+};
+
+// Vector Function ABI
+namespace VFABI {
+/// Checks ABI Signature
+/// \param MangledName - Mangled name to be parsed
+/// \param Result True if the MangledName follows the ABI signature
+bool getABISignature(StringRef MangledName);
+/// Gets Instruction Set Architecture
+/// \param MangledName - Mangled name to be parsed
+/// \param Result The ISA specified in the mangled name
+ISAKind getISA(StringRef MangledName);
+/// Checks for Mask (inbranch, notinbranch)
+/// \param MangledName - Mangled name to be parsed
+/// \param Result True if Masked
+bool getIsMasked(StringRef MangledName);
+/// Gets vectorization factor
+/// \param MangledName - Mangled name to be parsed
+/// \param Result Vectorization factor
+unsigned getVF(StringRef MangledName);
+/// Parses the parameters information
+/// \param MangledName - Mangled name to be parsed
+/// \param NewRecord - Populate the Parameters in the new record
+void getParameters(StringRef MangledName, SVFS::VectorRecord &NewRecord);
+/// Gets the name of the Scalar variant of the function
+/// \param MangledName - Mangled name to be parsed
+/// \param Result Scalar Function name
+StringRef getScalarName(StringRef MangledName);
+/// Gets the name of the Vector variant of the function
+/// \param MangledName - Mangled name to be parsed
+/// \param Result Vector Function name
+StringRef getVectorName(StringRef MangledName);
+/// Gets the ABI mangled name without redirection specified
+/// \param MangledName - Mangled name to be parsed
+/// \param Result Vector Function name
+StringRef getPartMangledName(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,
+                    SmallVector<ParamType, 8> &Parameters);
+/// Checks if it supports scalability
+/// \param MangledName - Mangled name to be parsed
+/// \param Result True if scalable version exists
+bool getIsScalable(StringRef MangledName);
+} // end namespace VFABI
+
+/// Analysis pass which captures all the user-defined vector functions
+struct SearchVectorFunctionSystem : public ModulePass {
+  static char ID; // Pass identification, replacement for typeid
+
+  std::unique_ptr<SVFS> QSVFS;
+
+  SearchVectorFunctionSystem() : ModulePass(ID) {
+    initializeSearchVectorFunctionSystemPass(*PassRegistry::getPassRegistry());
+  }
+
+  SVFS &getSVFS() { return *QSVFS; }
+  const SVFS &getSVFS() const { return *QSVFS; }
+
+  bool runOnModule(Module &M) override;
+
+  void getAnalysisUsage(AnalysisUsage &AU) const override {
+    AU.setPreservesAll();
+  }
+};
+
+ModulePass *createSearchVectorFunctionSystemPass();
+
+/// An analysis pass based on the new PM to deliver SVFS.
+class SVFSAnalysis : public AnalysisInfoMixin<SVFSAnalysis> {
+public:
+  typedef SVFS Result;
+
+  Result run(Module &M, ModuleAnalysisManager &);
+
+private:
+  friend AnalysisInfoMixin<SVFSAnalysis>;
+  static AnalysisKey Key;
+};
+
+/// Printer pass that uses \c SVFSAnalysis.
+class SVFSPrinterPass : public PassInfoMixin<SVFSPrinterPass> {
+  raw_ostream &OS;
+
+public:
+  explicit SVFSPrinterPass(raw_ostream &OS) : OS(OS) {}
+  PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM);
+};
+
+} // end namespace llvm
+
+#endif // LLVM_ANALYSIS_SVFS_H
 No newline at end of file

llvm/include/llvm/InitializePasses.h

 void initializeVirtRegRewriterPass(PassRegistry&);
 void initializeWarnMissedTransformationsLegacyPass(PassRegistry &);
 void initializeWasmEHPreparePass(PassRegistry&);
 void initializeWholeProgramDevirtPass(PassRegistry&);
 void initializeWinEHPreparePass(PassRegistry&);
 void initializeWriteBitcodePassPass(PassRegistry&);
 void initializeWriteThinLTOBitcodePass(PassRegistry&);
 void initializeXRayInstrumentationPass(PassRegistry&);
+void initializeSearchVectorFunctionSystemPass(PassRegistry &);
 
 } // end namespace llvm
 
 #endif // LLVM_INITIALIZEPASSES_H

llvm/include/llvm/LinkAllPasses.h

 #include "llvm/Analysis/Lint.h"
 #include "llvm/Analysis/Passes.h"
 #include "llvm/Analysis/PostDominators.h"
 #include "llvm/Analysis/RegionPass.h"
 #include "llvm/Analysis/RegionPrinter.h"
 #include "llvm/Analysis/ScalarEvolution.h"
 #include "llvm/Analysis/ScalarEvolutionAliasAnalysis.h"
 #include "llvm/Analysis/ScopedNoAliasAA.h"
+#include "llvm/Analysis/SearchVectorFunctionSystem.h"
 #include "llvm/Analysis/TargetLibraryInfo.h"
 #include "llvm/Analysis/TypeBasedAliasAnalysis.h"
 #include "llvm/CodeGen/Passes.h"
 #include "llvm/IR/Function.h"
 #include "llvm/IR/IRPrintingPasses.h"
 #include "llvm/Support/Valgrind.h"
 #include "llvm/Transforms/AggressiveInstCombine/AggressiveInstCombine.h"
 #include "llvm/Transforms/IPO.h"
ForcePassLinking() {
       (void) llvm::createRewriteSymbolsPass();
       (void) llvm::createStraightLineStrengthReducePass();
       (void) llvm::createMemDerefPrinter();
       (void) llvm::createMustExecutePrinter();
       (void) llvm::createFloat2IntPass();
       (void) llvm::createEliminateAvailableExternallyPass();
       (void) llvm::createScalarizeMaskedMemIntrinPass();
       (void) llvm::createWarnMissedTransformationsPass();
+      (void)llvm::createSearchVectorFunctionSystemPass();
 
       (void)new llvm::IntervalPartition();
       (void)new llvm::ScalarEvolutionWrapperPass();
       llvm::Function::Create(nullptr, llvm::GlobalValue::ExternalLinkage)->viewCFGOnly();
       llvm::RGPassManager RGM;
       llvm::TargetLibraryInfoImpl TLII;
       llvm::TargetLibraryInfo TLI(TLII);
       llvm::AliasAnalysis AA(TLI);

llvm/lib/Analysis/Analysis.cpp

void llvm::initializeAnalysis(PassRegistry &Registry) {
   initializeStackSafetyGlobalInfoWrapperPassPass(Registry);
   initializeStackSafetyInfoWrapperPassPass(Registry);
   initializeTargetTransformInfoWrapperPassPass(Registry);
   initializeTypeBasedAAWrapperPassPass(Registry);
   initializeScopedNoAliasAAWrapperPassPass(Registry);
   initializeLCSSAVerificationPassPass(Registry);
   initializeMemorySSAWrapperPassPass(Registry);
   initializeMemorySSAPrinterLegacyPassPass(Registry);
+  initializeSearchVectorFunctionSystemPass(Registry);
 }
 
 void LLVMInitializeAnalysis(LLVMPassRegistryRef R) {
   initializeAnalysis(*unwrap(R));
 }
 
 void LLVMInitializeIPA(LLVMPassRegistryRef R) {
   initializeAnalysis(*unwrap(R));

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;
+
+bool VFABI::getABISignature(StringRef MangledName) {
+  // Capture the ABI Signature value
+  return MangledName.startswith("_ZGV");
+}
+
+ISAKind VFABI::getISA(StringRef MangledName) {
+  // Capture the ISA value
+  StringRef ISAValue = MangledName.substr(4, 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_Unknown);
+
+  assert(ISA != ISAKind::ISA_Unknown && "Unknown ISA Specified");
+  return ISA;
+}
+
+bool VFABI::getIsMasked(StringRef MangledName) {
+  // Capture the MASK value
+  StringRef Mask;
+  Mask = MangledName.substr(5, 1);
+  if (VFABI::getISA(MangledName) == ISAKind::ISA_SVE)
+    return true;
+  assert((Mask.equals("N") || Mask.equals("M")) && "Invalid masking option");
+  return Mask.equals("N") ? false : true;
+}
+
+unsigned VFABI::getVF(StringRef MangledName) {
+  // Capture the VF
+  // VectorLength can be any positive integer
+  unsigned VF;
+  std::size_t Pos;
+
+  Pos = MangledName.find_first_of("vlRLUu", 6);
+  if (!MangledName.substr(6, Pos - 6).compare("x")) {
+    assert(VFABI::getISA(MangledName) == ISAKind::ISA_SVE &&
+           "Incompatible ISA");
+    return 0;
+  }
+  MangledName.substr(6, Pos - 6).consumeInteger(10, VF);
+  return VF;
+}
+
+bool VFABI::getIsScalable(StringRef MangledName) {
+  // Capture if it is Scalable or Not
+  bool IsSVE = VFABI::getISA(MangledName) == ISAKind::ISA_SVE;
+  bool IsVFZero = VFABI::getVF(MangledName) == 0;
+  return IsSVE && IsVFZero;
+}
+
+void VFABI::getParameters(StringRef MangledName,
+                          SVFS::VectorRecord &NewRecord) {
+  // Capture the parameters
+  StringRef ParamList;
+  std::size_t Pos;
+  std::size_t NewPos;
+
+  Pos = MangledName.find_first_of("vlRLUu", 6);
+  NewPos = MangledName.find("_", Pos);
+  ParamList = MangledName.substr(Pos, NewPos - Pos);
+  VFABI::parseParamList(ParamList, NewRecord.VFS.Parameters);
+}
+
+StringRef VFABI::getScalarName(StringRef MangledName) {
+  // Get Scalar function name
+  StringRef ScalarFunctionName;
+  std::size_t Pos;
+  std::size_t NewPos;
+
+  Pos = MangledName.find("_", 6) + 1;
+  NewPos = MangledName.find("(", Pos);
+  // Handles Case: custom vector function name not provided
+  if (NewPos == StringRef::npos)
+    NewPos = MangledName.str().length();
+  ScalarFunctionName = MangledName.substr(Pos, NewPos - Pos);
+
+  return ScalarFunctionName;
+}
+
+StringRef VFABI::getVectorName(StringRef MangledName) {
+  // Get 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 VFABI::getPartMangledName(StringRef MangledName) {
+  StringRef PartMangledName;
+  std::size_t Pos;
+
+  Pos = MangledName.find("(");
+  if (Pos == StringRef::npos)
+    PartMangledName = MangledName;
+  else
+    PartMangledName = MangledName.substr(0, Pos);
+  return PartMangledName;
+}
+
+void VFABI::parseParamList(StringRef ParamList,
+                           SmallVector<ParamType, 8> &Params) {
+  std::size_t Pos; // Pos to iterate ParamList
+  std::size_t NewPos;
+
+  unsigned ParamPos = 0; // parameter Pos
+  int LinearStepOrPos;
+
+  Pos = 0;
+  StringRef ParamKindStr;
+  ParameterKind ParamKind;
+
+  // Parse the param list and store it to newRecord.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);
+      assert(ParamKind != ParameterKind::Unknown && "Unknown type specified\n");
+      Params.push_back(ParamType(ParamPos, ParamKind, LinearStepOrPos));
+    } else {
+      ParamKind = ParamType::convertToParameterKind(ParamKindStr);
+      assert(ParamKind != ParameterKind::Unknown && "Unknown type specified\n");
+      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);
+      }
+      Params.push_back(Parameter);
+    }
+    ParamPos++;
+    Pos = NewPos;
+  }
+
+  // Last param value || only param
+  // NewPos is the end of StringRef ParamList
+  ParamKindStr = ParamList.substr(Pos, 1);
+  ParamKind = ParamType::convertToParameterKind(ParamKindStr);
+  assert(ParamKind != ParameterKind::Unknown && "Unknown type specified\n");
+  // +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);
+    Params.push_back(ParamType(ParamPos, ParamKind, LinearStepOrPos));
+  } else {
+    ParamType Parameter(ParamPos, ParamKind);
+    // Default LinearStepOrPos value if not specified in ABI signature
+    if (Parameter.isLinear() || Parameter.isLinearRef() ||
+        Parameter.isLinearVal()) {
+      Parameter.setLinearStepOrPos(1);
+    }
+    Params.push_back(Parameter);
+  }
+}
+
+void SVFS::demangleName(StringRef MangledName, SVFS::VectorRecord &NewRecord) {
+  // String Parsing - Populate newRecord
+  // Vector Function ABI for AArch64 (Sec 3.5)
+
+  if (!VFABI::getABISignature(MangledName))
+    return;
+  NewRecord.VFS.ISA = VFABI::getISA(MangledName);
+  NewRecord.VFS.IsMasked = VFABI::getIsMasked(MangledName);
+  NewRecord.VFS.VF = VFABI::getVF(MangledName);
+  NewRecord.VFS.IsScalable = VFABI::getIsScalable(MangledName);
+  VFABI::getParameters(MangledName, NewRecord);
+  NewRecord.ScalarName = VFABI::getScalarName(MangledName);
+  NewRecord.VectorName = MangledName;
+}
+
+void SVFS::createTableLookupRecord(CallInst *Call) {
+  Function *ScalarFunc = Call->getCalledFunction();
+  StringRef MangledName =
+      ScalarFunc->getFnAttribute("vector-function-abi-variant")
+          .getValueAsString();
+
+  SmallVector<StringRef, 8> VectorStrings;
+
+  MangledName.split(VectorStrings, ",");
+
+  for (auto VectorString : VectorStrings) {
+    // Populate a new entry to be recorded
+    SVFS::VectorRecord NewRecord;
+    SVFS::demangleName(VectorString.trim(), NewRecord);
+    // Populate the table
+    SVFS::RecordTable.push_back(NewRecord);
+  }
+}
+
+SmallVector<SVFS::VectorFunctionShape, 8>
+SVFS::isFunctionVectorizable(CallInst *Call) const {
+  SmallVector<SVFS::VectorFunctionShape, 8> AvailableVFS;
+  // Iterate through all records.
+  for (auto Record : SVFS::RecordTable) {
+    if (Record.ScalarName == Call->getCalledFunction()->getName()) {
+      AvailableVFS.push_back(Record.VFS);
+    }
+  }
+  return AvailableVFS;
+}
+
+Function *SVFS::getVectorizedFunction(CallInst *Call,
+                                      SVFS::VectorFunctionShape Info) const {
+  SmallVector<VectorRecord, 8> Records;
+  // Iterate through all records
+  for (auto Record : SVFS::RecordTable) {
+    if (Record.ScalarName == Call->getCalledFunction()->getName() &&
+        Record.VFS == Info) {
+      Records.push_back(Record);
+    }
+  }
+
+  StringRef FnName = VFABI::getVectorName(Records[0].VectorName);
+
+  Module *M = Call->getModule();
+  // Atmost 2 functions that have the same VectorFunctionShape.
+  assert(Records.size() <= 2 && "Invalid Table Entries");
+  if (Records.size() == 2) {
+    StringRef VecName0 = VFABI::getVectorName(Records[0].VectorName);
+    StringRef VecName1 = VFABI::getVectorName(Records[1].VectorName);
+    bool IsMangled = VFABI::getABISignature(VecName0);
+    // Checks to ensure only one entry has a custom name redirection
+    if (IsMangled)
+      assert(VFABI::getABISignature(VecName1) == false &&
+             "Invalid Table Entries");
+    else
+      assert(VFABI::getABISignature(VecName1) == true &&
+             "Invalid Table Entries");
+    FnName = IsMangled ? VecName1 : VecName0;
+  }
+
+  StringRef FnMangledName;
+  FnMangledName = VFABI::getPartMangledName(Records[0].VectorName);
+  // Extract the existing function signature added by front-end
+  FunctionType *FnTy = M->getFunction(FnMangledName)->getFunctionType();
+
+  return cast<Function>(M->getOrInsertFunction(FnName, FnTy).getCallee());
+}
+
+char SearchVectorFunctionSystem::ID = 0;
+
+INITIALIZE_PASS(SearchVectorFunctionSystem, "svfs",
+                "Query System for the Vectorizer", false, true)
+
+ModulePass *llvm::createSearchVectorFunctionSystemPass() {
+  return new SearchVectorFunctionSystem();
+}
+
+// SearchVectorFunctionSystem::run - This is the main Analysis entry point.
+bool SearchVectorFunctionSystem::runOnModule(Module &M) {
+  QSVFS.reset(new SVFS());
+  for (auto &F : M)
+    for (auto &I : instructions(F))
+      if (auto *Call = dyn_cast<CallInst>(&I))
+        QSVFS->createTableLookupRecord(Call);
+  return false;
+}
+
+AnalysisKey SVFSAnalysis::Key;
+
+SVFS SVFSAnalysis::run(Module &M, ModuleAnalysisManager &) {
+  SVFS QSVFS;
+  for (auto &F : M)
+    for (auto &I : instructions(F))
+      if (auto *Call = dyn_cast<CallInst>(&I))
+        QSVFS.createTableLookupRecord(Call);
+  return QSVFS;
+}
+
+PreservedAnalyses SVFSPrinterPass::run(Module &M, ModuleAnalysisManager &AM) {
+  SVFS &QSVFS = AM.getResult<SVFSAnalysis>(M);
+
+  OS << "Functions in "
+     << "\n";
+  for (auto &Record : QSVFS.RecordTable)
+    OS << Record.VectorName;
+  return PreservedAnalyses::all();
+}
 No newline at end of file

llvm/lib/Passes/PassBuilder.cpp

 #include "llvm/Analysis/OptimizationRemarkEmitter.h"
 #include "llvm/Analysis/PhiValues.h"
 #include "llvm/Analysis/PostDominators.h"
 #include "llvm/Analysis/ProfileSummaryInfo.h"
 #include "llvm/Analysis/RegionInfo.h"
 #include "llvm/Analysis/ScalarEvolution.h"
 #include "llvm/Analysis/ScalarEvolutionAliasAnalysis.h"
 #include "llvm/Analysis/ScopedNoAliasAA.h"
+#include "llvm/Analysis/SearchVectorFunctionSystem.h"
 #include "llvm/Analysis/StackSafetyAnalysis.h"
 #include "llvm/Analysis/TargetLibraryInfo.h"
 #include "llvm/Analysis/TargetTransformInfo.h"
 #include "llvm/Analysis/TypeBasedAliasAnalysis.h"
 #include "llvm/CodeGen/PreISelIntrinsicLowering.h"
 #include "llvm/CodeGen/UnreachableBlockElim.h"
 #include "llvm/IR/Dominators.h"
 #include "llvm/IR/IRPrintingPasses.h"

 #include "llvm/Transforms/Scalar/LoopUnrollAndJamPass.h"
 #include "llvm/Transforms/Scalar/LoopUnrollPass.h"
 #include "llvm/Transforms/Scalar/LowerAtomic.h"
 #include "llvm/Transforms/Scalar/LowerExpectIntrinsic.h"
 #include "llvm/Transforms/Scalar/LowerGuardIntrinsic.h"
 #include "llvm/Transforms/Scalar/LowerWidenableCondition.h"
 #include "llvm/Transforms/Scalar/MakeGuardsExplicit.h"
 #include "llvm/Transforms/Scalar/MemCpyOptimizer.h"
-#include "llvm/Transforms/Scalar/MergedLoadStoreMotion.h"
 #include "llvm/Transforms/Scalar/MergeICmps.h"
+#include "llvm/Transforms/Scalar/MergedLoadStoreMotion.h"
 #include "llvm/Transforms/Scalar/NaryReassociate.h"
 #include "llvm/Transforms/Scalar/NewGVN.h"
 #include "llvm/Transforms/Scalar/PartiallyInlineLibCalls.h"
 #include "llvm/Transforms/Scalar/Reassociate.h"
 #include "llvm/Transforms/Scalar/RewriteStatepointsForGC.h"
 #include "llvm/Transforms/Scalar/SCCP.h"
 #include "llvm/Transforms/Scalar/SROA.h"
 #include "llvm/Transforms/Scalar/Scalarizer.h"

llvm/lib/Passes/PassRegistry.def

 MODULE_ANALYSIS("module-summary", ModuleSummaryIndexAnalysis())
 MODULE_ANALYSIS("no-op-module", NoOpModuleAnalysis())
 MODULE_ANALYSIS("profile-summary", ProfileSummaryAnalysis())
 MODULE_ANALYSIS("stack-safety", StackSafetyGlobalAnalysis())
 MODULE_ANALYSIS("targetlibinfo", TargetLibraryAnalysis())
 MODULE_ANALYSIS("verify", VerifierAnalysis())
 MODULE_ANALYSIS("pass-instrumentation", PassInstrumentationAnalysis(PIC))
 MODULE_ANALYSIS("asan-globals-md", ASanGlobalsMetadataAnalysis())
+MODULE_ANALYSIS("svfs", SVFSAnalysis())
 
 #ifndef MODULE_ALIAS_ANALYSIS
 #define MODULE_ALIAS_ANALYSIS(NAME, CREATE_PASS)                               \
   MODULE_ANALYSIS(NAME, CREATE_PASS)
 #endif
 MODULE_ALIAS_ANALYSIS("globals-aa", GlobalsAA())
 #undef MODULE_ALIAS_ANALYSIS
 #undef MODULE_ANALYSIS

 MODULE_PASS("print-lcg", LazyCallGraphPrinterPass(dbgs()))
 MODULE_PASS("print-lcg-dot", LazyCallGraphDOTPrinterPass(dbgs()))
 MODULE_PASS("print-stack-safety", StackSafetyGlobalPrinterPass(dbgs()))
 MODULE_PASS("rewrite-statepoints-for-gc", RewriteStatepointsForGC())
 MODULE_PASS("rewrite-symbols", RewriteSymbolPass())
 MODULE_PASS("rpo-functionattrs", ReversePostOrderFunctionAttrsPass())
 MODULE_PASS("sample-profile", SampleProfileLoaderPass())
 MODULE_PASS("strip-dead-prototypes", StripDeadPrototypesPass())
+MODULE_PASS("print-svfs", SVFSPrinterPass(dbgs()))
 MODULE_PASS("synthetic-counts-propagation", SyntheticCountsPropagation())
 MODULE_PASS("wholeprogramdevirt", WholeProgramDevirtPass(nullptr, nullptr))
 MODULE_PASS("verify", VerifierPass())
 MODULE_PASS("asan-module", ModuleAddressSanitizerPass(/*CompileKernel=*/false, false, true, false))
 MODULE_PASS("kasan-module", ModuleAddressSanitizerPass(/*CompileKernel=*/true, false, true, false))
 #undef MODULE_PASS
 
 #ifndef CGSCC_ANALYSIS

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
+  SearchVectorFunctionSystemTest.cpp
   SparsePropagation.cpp
   TargetLibraryInfoTest.cpp
   TBAATest.cpp
   UnrollAnalyzerTest.cpp
   ValueLatticeTest.cpp
   ValueTrackingTest.cpp
   )

llvm/unittests/Analysis/SearchVectorFunctionSystemTest.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/AsmParser/Parser.h"
+#include "llvm/IR/Dominators.h"
+#include "llvm/IR/InstIterator.h"
+#include "llvm/Support/SourceMgr.h"
+#include "llvm/Support/raw_ostream.h"
+#include "gtest/gtest.h"
+
+using namespace llvm;
+
+class SearchVectorFunctionSystemTest : public testing::Test {
+protected:
+  SearchVectorFunctionSystemTest() : M(new Module("MyModule", Ctx)) {
+    FArgTypes.push_back(Type::getInt32Ty(Ctx));
+    FArgTypes.push_back(Type::getInt32Ty(Ctx));
+    FunctionType *FTy =
+        FunctionType::get(Type::getInt32Ty(Ctx), FArgTypes, false);
+    F = Function::Create(FTy, Function::ExternalLinkage, "sin", M.get());
+  }
+
+  LLVMContext Ctx;
+  std::unique_ptr<Module> M;
+  SmallVector<Type *, 2> FArgTypes;
+  Function *F;
+};
+
+TEST_F(SearchVectorFunctionSystemTest, TableCreation) {
+  SVFS S;
+
+  // Tests the complete functionality of table creation
+  Value *Args[] = {ConstantInt::get(Type::getInt32Ty(Ctx), 20),
+                   ConstantInt::get(Type::getInt32Ty(Ctx), 20)};
+  std::unique_ptr<CallInst> Caller(CallInst::Create(F, Args));
+  CallInst *Call = Caller.get();
+  F->addFnAttr("vector-function-abi-variant",
+               "_ZGVnN2vv_sin(another_vector),"
+               "_ZGVnN8l8v_sin(sinVector),_ZGVnN4vl_sin");
+
+  S.createTableLookupRecord(Call);
+
+  // Checks for "_ZGVnN2vv_sin(another_vector)"
+  EXPECT_EQ(S.RecordTable[0].VFS.VF, (unsigned)2);
+  EXPECT_FALSE(S.RecordTable[0].VFS.IsMasked);
+  EXPECT_EQ(S.RecordTable[0].VFS.ISA, ISAKind::ISA_AdvancedSIMD);
+
+  EXPECT_TRUE(S.RecordTable[0].VFS.Parameters[0].isVector());
+  EXPECT_EQ(S.RecordTable[0].VFS.Parameters[0].getParamPos(), (unsigned)0);
+
+  EXPECT_TRUE(S.RecordTable[0].VFS.Parameters[1].isVector());
+  EXPECT_EQ(S.RecordTable[0].VFS.Parameters[1].getParamPos(), (unsigned)1);
+
+  EXPECT_EQ(S.RecordTable[0].ScalarName, "sin");
+  EXPECT_EQ(S.RecordTable[0].VectorName, "_ZGVnN2vv_sin(another_vector)");
+
+  // Checks for "_ZGVnN8l8v_sin(sinVector)"
+  EXPECT_EQ(S.RecordTable[1].VFS.VF, (unsigned)8);
+  EXPECT_FALSE(S.RecordTable[1].VFS.IsMasked);
+  EXPECT_EQ(S.RecordTable[1].VFS.ISA, ISAKind::ISA_AdvancedSIMD);
+
+  EXPECT_TRUE(S.RecordTable[1].VFS.Parameters[0].isLinear());
+  EXPECT_EQ(S.RecordTable[1].VFS.Parameters[0].getParamPos(), (unsigned)0);
+  EXPECT_EQ(S.RecordTable[1].VFS.Parameters[0].getLinearStepOrPos(), 8);
+
+  EXPECT_TRUE(S.RecordTable[1].VFS.Parameters[1].isVector());
+  EXPECT_EQ(S.RecordTable[1].VFS.Parameters[1].getParamPos(), (unsigned)1);
+
+  EXPECT_EQ(S.RecordTable[1].ScalarName, "sin");
+  EXPECT_EQ(S.RecordTable[1].VectorName, "_ZGVnN8l8v_sin(sinVector)");
+
+  // Checks for "_ZGVnN4vl_sin"
+  EXPECT_EQ(S.RecordTable[2].VFS.VF, (unsigned)4);
+  EXPECT_FALSE(S.RecordTable[2].VFS.IsMasked);
+  EXPECT_EQ(S.RecordTable[2].VFS.ISA, ISAKind::ISA_AdvancedSIMD);
+
+  EXPECT_TRUE(S.RecordTable[2].VFS.Parameters[0].isVector());
+  EXPECT_EQ(S.RecordTable[2].VFS.Parameters[0].getParamPos(), (unsigned)0);
+
+  EXPECT_TRUE(S.RecordTable[2].VFS.Parameters[1].isLinear());
+  EXPECT_EQ(S.RecordTable[2].VFS.Parameters[1].getParamPos(), (unsigned)1);
+  EXPECT_EQ(S.RecordTable[2].VFS.Parameters[1].getLinearStepOrPos(), 1);
+
+  EXPECT_EQ(S.RecordTable[2].ScalarName, "sin");
+  EXPECT_EQ(S.RecordTable[2].VectorName, "_ZGVnN4vl_sin");
+}
+
+TEST_F(SearchVectorFunctionSystemTest, NameDemangling) {
+  SVFS S;
+
+  SVFS::VectorRecord Output;
+
+  S.demangleName("_ZGVnN2vl_sin", Output);
+
+  EXPECT_EQ(Output.VFS.VF, (unsigned)2);
+  EXPECT_FALSE(Output.VFS.IsMasked);
+  EXPECT_EQ(Output.VFS.ISA, ISAKind::ISA_AdvancedSIMD);
+
+  // Does call parseParamList()
+  EXPECT_TRUE(Output.VFS.Parameters[0].isVector());
+  EXPECT_EQ(Output.VFS.Parameters[0].getParamPos(), (unsigned)0);
+
+  EXPECT_EQ(Output.VFS.Parameters[1].getLinearStepOrPos(), 1);
+  EXPECT_TRUE(Output.VFS.Parameters[1].isLinear());
+  EXPECT_EQ(Output.VFS.Parameters[1].getParamPos(), (unsigned)1);
+
+  EXPECT_EQ(Output.ScalarName, "sin");
+  EXPECT_EQ(Output.VectorName, "_ZGVnN2vl_sin");
+}
+
+TEST_F(SearchVectorFunctionSystemTest, ParamListParsing) {
+  SVFS S;
+
+  SmallVector<ParamType, 8> Output;
+
+  VFABI::parseParamList("vl16Ls32R3l", Output);
+
+  EXPECT_EQ(Output[0].getParamPos(), (unsigned)0);
+  EXPECT_TRUE(Output[0].isVector());
+
+  EXPECT_EQ(Output[1].getParamPos(), (unsigned)1);
+  EXPECT_TRUE(Output[1].isLinear());
+  EXPECT_EQ(Output[1].getLinearStepOrPos(), 16);
+
+  EXPECT_EQ(Output[2].getParamPos(), (unsigned)2);
+  EXPECT_TRUE(Output[2].isLinearValPos());
+  EXPECT_EQ(Output[2].getLinearStepOrPos(), 32);
+
+  EXPECT_EQ(Output[3].getParamPos(), (unsigned)3);
+  EXPECT_TRUE(Output[3].isLinearRef());
+  EXPECT_EQ(Output[3].getLinearStepOrPos(), 3);
+
+  EXPECT_EQ(Output[4].getParamPos(), (unsigned)4);
+  EXPECT_TRUE(Output[4].isLinear());
+  EXPECT_EQ(Output[4].getLinearStepOrPos(), 1);
+}
+
+TEST_F(SearchVectorFunctionSystemTest, VFABITest) {
+  SVFS S;
+
+  // Getting ISA Kind
+  EXPECT_EQ(VFABI::getISA("_ZGVnN2_sin"), ISAKind::ISA_AdvancedSIMD);
+  EXPECT_EQ(VFABI::getISA("_ZGVsN2_sin"), ISAKind::ISA_SVE);
+  EXPECT_EQ(VFABI::getISA("_ZGVbN2_sin"), ISAKind::ISA_SSE);
+  EXPECT_EQ(VFABI::getISA("_ZGVcN2_sin"), ISAKind::ISA_AVX);
+  EXPECT_EQ(VFABI::getISA("_ZGVdN2_sin"), ISAKind::ISA_AVX2);
+  EXPECT_EQ(VFABI::getISA("_ZGVeN2_sin"), ISAKind::ISA_AVX512);
+
+  // Getting Mask Value
+  EXPECT_TRUE(VFABI::getIsMasked("_ZGVnM2v_sin"));
+  EXPECT_FALSE(VFABI::getIsMasked("_ZGVnN2v_sin"));
+  EXPECT_TRUE(VFABI::getIsMasked("_ZGVsN2v_sin"));
+  EXPECT_TRUE(VFABI::getIsMasked("_ZGVsM2v_sin"));
+
+  // Getting Scalable Value
+  EXPECT_TRUE(VFABI::getIsScalable("_ZGVsMxv_sin"));
+  EXPECT_FALSE(VFABI::getIsScalable("_ZGVsM2v_sin"));
+
+  // Getting VF
+  EXPECT_EQ(VFABI::getVF("_ZGVnM2v_sin"), (unsigned)2);
+  EXPECT_EQ(VFABI::getVF("_ZGVnM22v_sin"), (unsigned)22);
+  EXPECT_EQ(VFABI::getVF("_ZGVsMxv_sin"), (unsigned)0);
+
+  // Getting Scalar Name
+  EXPECT_EQ(VFABI::getScalarName("_ZGVnM2v_sin"), "sin");
+  EXPECT_EQ(VFABI::getScalarName("_ZGVnM2v_sin(UserFunc)"), "sin");
+  EXPECT_EQ(VFABI::getScalarName("_ZGVnM2v___sin_sin_sin"), "__sin_sin_sin");
+
+  // Getting Vector Name
+  EXPECT_EQ(VFABI::getVectorName("_ZGVnM2v_sin"), "_ZGVnM2v_sin");
+  EXPECT_EQ(VFABI::getVectorName("_ZGVnM2v_sin(UserFunc)"), "UserFunc");
+}
+
+TEST_F(SearchVectorFunctionSystemTest, isFunctionVectorizable) {
+  SVFS S;
+
+  Value *Args[] = {ConstantInt::get(Type::getInt32Ty(Ctx), 20),
+                   ConstantInt::get(Type::getInt32Ty(Ctx), 20)};
+  std::unique_ptr<CallInst> Caller(CallInst::Create(F, Args));
+  CallInst *Call = Caller.get();
+
+  F->addFnAttr("vector-function-abi-variant",
+               "_ZGVnN2vv_cos(another_vector), _ZGVnN2vv_sin,"
+               " _ZGVnN4vl_sin(sinVector),_ZGVnN4vl_sin");
+
+  S.createTableLookupRecord(Call);
+  SmallVector<SVFS::VectorFunctionShape, 8> AvailableVFS;
+  AvailableVFS = S.isFunctionVectorizable(Call);
+
+  EXPECT_EQ(AvailableVFS.size(), (unsigned)3);
+  EXPECT_EQ(AvailableVFS[0], S.RecordTable[1].VFS);
+  EXPECT_EQ(AvailableVFS[1], S.RecordTable[2].VFS);
+  EXPECT_EQ(AvailableVFS[2], S.RecordTable[3].VFS);
+
+  const ParamType Param1((unsigned)0, ParameterKind::Vector);
+  const ParamType Param2((unsigned)1, ParameterKind::Vector);
+  const ParamType Param3((unsigned)1, ParameterKind::OMP_Linear, 1);
+
+  // Corresponding VFS for _ZGVnN2vv
+  SmallVector<ParamType, 8> ParamList1{{Param1, Param2}};
+  SVFS::VectorFunctionShape ExpectedVFS1{
+      (unsigned)2 /* VF */, false /* IsMasked */, false /* IsScalable */,
+      ISAKind::ISA_AdvancedSIMD, ParamList1};
+
+  // Corresponding VFS for _ZGVnN4vl_sin
+  SmallVector<ParamType, 8> ParamList2{{Param1, Param3}};
+  SVFS::VectorFunctionShape ExpectedVFS2{
+      (unsigned)4 /* VF */, false /* IsMasked */, false /* IsScalable */,
+      ISAKind::ISA_AdvancedSIMD, ParamList2};
+
+  EXPECT_EQ(AvailableVFS[0], ExpectedVFS1);
+  EXPECT_EQ(AvailableVFS[1], ExpectedVFS2);
+  EXPECT_EQ(AvailableVFS[2], ExpectedVFS2);
+}
+
+TEST_F(SearchVectorFunctionSystemTest, getVectorizedFunction) {
+  SVFS S;
+
+  Value *Args[] = {ConstantInt::get(Type::getInt32Ty(Ctx), 20),
+                   ConstantInt::get(Type::getInt32Ty(Ctx), 20)};
+  std::unique_ptr<CallInst> Caller(CallInst::Create(F, Args));
+  CallInst *Call = Caller.get();
+
+  F->addFnAttr("vector-function-abi-variant",
+               "_ZGVnN2vv_cos(another_vector),_ZGVnN2vv_sin,"
+               "_ZGVnN4vl_sin(sinVector), _ZGVnN4vl_sin,"
+               " _ZGVnN16ll_sin");
+
+  const ParamType Param1((unsigned)0, ParameterKind::Vector);
+  const ParamType Param2((unsigned)0, ParameterKind::OMP_Linear, 1);
+  const ParamType Param3((unsigned)1, ParameterKind::OMP_Linear, 1);
+
+  // Corresponding VFS for _ZGVnN4vl_sin
+  SmallVector<ParamType, 8> ParamList1{{Param1, Param3}};
+  SVFS::VectorFunctionShape VFS1{(unsigned)4 /* VF */, false /* IsMasked */,
+                                 false /* IsScalable */,
+                                 ISAKind::ISA_AdvancedSIMD, ParamList1};
+
+  Type *Tys0[] = {VectorType::get(FArgTypes[0], 4), FArgTypes[1]};
+  FunctionType *VectorFTy0 =
+      FunctionType::get(VectorType::get(Type::getInt32Ty(Ctx), 4), Tys0, false);
+  Function *VectorFunc0 = Function::Create(
+      VectorFTy0, Function::ExternalLinkage, "sinVector", M.get());
+
+  S.createTableLookupRecord(Call);
+
+  // Checking for "_ZGVnN4vl_sin"
+  Function *ResFunc0 = S.getVectorizedFunction(Call, VFS1);
+  // As the given VFS has two possible options,
+  // we return the one with custom name
+  EXPECT_EQ(ResFunc0, VectorFunc0);
+
+  // Corresponding VFS for _ZGVnN16ll_sin
+  SmallVector<ParamType, 8> ParamList2{{Param2, Param3}};
+  SVFS::VectorFunctionShape VFS2{(unsigned)16 /* VF */, false /* IsMasked */,
+                                 false /* IsScalable */,
+                                 ISAKind::ISA_AdvancedSIMD, ParamList2};
+
+  FunctionType *VectorFTy1 = FunctionType::get(
+      VectorType::get(Type::getInt32Ty(Ctx), 16), FArgTypes, false);
+  Function *VectorFunc1 = Function::Create(
+      VectorFTy1, Function::ExternalLinkage, "_ZGVnN16ll_sin", M.get());
+
+  // Checking for "_ZGVnN16ll_sin"
+  Function *ResFunc1 = S.getVectorizedFunction(Call, VFS2);
+  // Only one record exists for the given VFS
+  EXPECT_EQ(ResFunc1, VectorFunc1);
+}
 No newline at end of file