[VFABI] Add LLVM internal mangling for vector functions.

[fpetrogalli]

Summary

This patch adds a custom ISA for vector functions for internal use
in LLVM. The <isa> token is set to "_LLVM_VF_", and it is not attached
to any specific instruction Vector ISA, or Vector Function ABI.

The ISA is used as a token for handling Vector Function ABI-style
vectorization for those vector functions that are not directly
associated to any existing Vector Function ABI (for example, some of
the vector functions exposed by TargetLibraryInfo). The demangling
function for this ISA in a Vector Function ABI context is set to be
the same as the common one shared between X86 and AArch64.

[sdesmalen]

Nice and simple patch, LGTM!

llvm/include/llvm/Analysis/VectorUtils.h

51–53

nit: maybe drop the _VF and use LLVM directly? (also for other uses in this file)

[fpetrogalli]

llvm/include/llvm/Analysis/VectorUtils.h

51–53

I'd prefer llvm::LLVM_VF. The alternative llvm::LLVM is less appealing to me, because it doesn't say anything about it's meaning. In the former, at least VF stands for Vector Function.

Once could argue that we could move the variable into the VFABI namespace, so that llvm::VFABI::LLVM would be slightly more specific, but I'd rather not do this too because I suspect that the llvm::LLVM_VF ISA coudl be used also outside of a VFABI context (like we do it now for the other vector extensions).

So, overall, I think we should stay with llvm::LLVM_VF.

[fpetrogalli]

llvm/include/llvm/Analysis/VectorUtils.h

51–53

*Never* reply to a code review before having coffee.

llvm::VFISAKind::LLVMwill be.

[fpetrogalli]

I have changed LLVM_VF to LLVM in the VFISAKind enum class.

[fpetrogalli]

I have updated the way we represent the token for the internal name ISA used by LLVM. The token is used only in a VFABI context, so I moved it in the VFABI namespace. In there, the name can be simplified to _LLVM_ as the VFABI namespace specializes the name already.

[fpetrogalli]

Cosmetic changes to comments and commit message. [NFC]

[jdoerfert]

LGTM

llvm/include/llvm/Analysis/VectorUtils.h

 /// Describes the type of Instruction Set Architecture
 enum class VFISAKind {
   AdvancedSIMD, // AArch64 Advanced SIMD (NEON)
   SVE,          // AArch64 Scalable Vector Extension
   SSE,          // x86 SSE
   AVX,          // x86 AVX
   AVX2,         // x86 AVX2
   AVX512,       // x86 AVX512
-  Unknown       // Unknown ISA
+  LLVM,         // LLVM internal ISA for functions that are not
+  // attached to an existing ABI via name mangling.
+  Unknown // Unknown ISA
 };
 
 /// Encapsulates information needed to describe a parameter.
 ///
 /// The description of the parameter is not linked directly to
 /// OpenMP or any other vector function description. This structure
 /// is extendible to handle other paradigms that describe vector
 /// functions and their parameters.
struct VFInfo {
   // Comparison operator.
   bool operator==(const VFInfo &Other) const {
     return std::tie(Shape, ScalarName, VectorName) ==
            std::tie(Shape, Other.ScalarName, Other.VectorName);
   }
 };
 
 namespace VFABI {
+/// LLVM Internal VFABI ISA token for Vector Functions (VF).
+static constexpr char const *_LLVM_ = "_LLVM_";
+
 /// Function to contruct a VFInfo out of a mangled names in the
 /// following format:
 ///
 /// <VFABI_name>{(<redirection>)}
 ///
 /// where <VFABI_name> is the name of the vector function, mangled according
 /// to the rules described in the Vector Function ABI of the target vector
 /// extentsion (or <isa> from now on). The <VFABI_name> is in the following

llvm/lib/Analysis/VFABIDemangling.cpp

 };
 
 /// Extracts the `<isa>` information from the mangled string, and
 /// sets the `ISA` accordingly.
 ParseRet tryParseISA(StringRef &MangledName, VFISAKind &ISA) {
   if (MangledName.empty())
     return ParseRet::Error;
 
+  if (MangledName.startswith(VFABI::_LLVM_)) {
+    MangledName = MangledName.drop_front(strlen(VFABI::_LLVM_));
+    ISA = VFISAKind::LLVM;
+  } else {
     ISA = StringSwitch<VFISAKind>(MangledName.take_front(1))
               .Case("n", VFISAKind::AdvancedSIMD)
               .Case("s", VFISAKind::SVE)
               .Case("b", VFISAKind::SSE)
               .Case("c", VFISAKind::AVX)
               .Case("d", VFISAKind::AVX2)
               .Case("e", VFISAKind::AVX512)
               .Default(VFISAKind::Unknown);
     MangledName = MangledName.drop_front(1);
+  }
 
   return ParseRet::OK;
 }
 
 /// Extracts the `<mask>` information from the mangled string, and
 /// sets `IsMasked` accordingly. The input string `MangledName` is
 /// left unmodified.
 ParseRet tryParseMask(StringRef &MangledName, bool &IsMasked) {
ParseRet tryParseAlign(StringRef &ParseString, Align &Alignment) {
 
   return ParseRet::None;
 }
 } // namespace
 
 // Format of the ABI name:
 // _ZGV<isa><mask><vlen><parameters>_<scalarname>[(<redirection>)]
 Optional<VFInfo> VFABI::tryDemangleForVFABI(StringRef MangledName) {
+  const StringRef OriginalName = MangledName;
   // Assume there is no custom name <redirection>, and therefore the
   // vector name consists of
   // _ZGV<isa><mask><vlen><parameters>_<scalarname>.
   StringRef VectorName = MangledName;
 
   // Parse the fixed size part of the manled name
   if (!MangledName.consume_front("_ZGV"))
     return None;
if (!MangledName.consume_back(")"))
       return None;
     // Update the vector variant with the one specified by the user.
     VectorName = MangledName;
     // If the vector name is missing, bail out.
     if (VectorName.empty())
       return None;
   }
 
+  // LLVM internal mapping via the TargetLibraryInfo (TLI) must be
+  // redirected to an existing name.
+  if (ISA == VFISAKind::LLVM && VectorName == OriginalName)
+    return None;
+
   // When <mask> is "M", we need to add a parameter that is used as
   // global predicate for the function.
   if (IsMasked) {
     const unsigned Pos = Parameters.size();
     Parameters.push_back({Pos, VFParamKind::GlobalPredicate});
   }
 
   // Asserts for parameters of type `VFParamKind::GlobalPredicate`, as

llvm/unittests/Analysis/VectorFunctionABITest.cpp

#define __COMMON_CHECKS                                                        \
   EXPECT_EQ(VectorName, "_ZGVdN2vls2Ls27Us4Rs5l1L10U100R1000u2_sin");
 
   // AVX512: <isa> = "e"
   EXPECT_TRUE(invokeParser("_ZGVeN2vls2Ls27Us4Rs5l1L10U100R1000u2_sin"));
   EXPECT_EQ(ISA, VFISAKind::AVX512);
   __COMMON_CHECKS;
   EXPECT_EQ(VectorName, "_ZGVeN2vls2Ls27Us4Rs5l1L10U100R1000u2_sin");
 
+  // LLVM_VF: <isa> = LLVM internal vector function.
+  EXPECT_TRUE(
+      invokeParser("_ZGV_LLVM_N2vls2Ls27Us4Rs5l1L10U100R1000u2_sin(vectorf)"));
+  EXPECT_EQ(ISA, VFISAKind::LLVM);
+  __COMMON_CHECKS;
+  EXPECT_EQ(VectorName, "vectorf");
+
   // Unknown ISA (randomly using "q"). This test will need update if
   // some targets decide to use "q" as their ISA token.
   EXPECT_TRUE(invokeParser("_ZGVqN2vls2Ls27Us4Rs5l1L10U100R1000u2_sin"));
   EXPECT_EQ(ISA, VFISAKind::Unknown);
   __COMMON_CHECKS;
   EXPECT_EQ(VectorName, "_ZGVqN2vls2Ls27Us4Rs5l1L10U100R1000u2_sin");
 
 #undef __COMMON_CHECKS

 
 TEST_F(VFABIAttrTest, Read) {
   VFABI::getVectorVariantNames(*CI, Mappings);
   SmallVector<std::string, 8> Exp;
   Exp.push_back("_ZGVnN2v_g(custom_vg)");
   Exp.push_back("_ZGVnN4v_g");
   EXPECT_EQ(Mappings, Exp);
 }
+
+TEST_F(VFABIParserTest, LLVM_InternalISA) {
+  EXPECT_FALSE(invokeParser("_ZGV_LLVM_N2v_sin"));
+  EXPECT_TRUE(invokeParser("_ZGV_LLVM_N2v_sin_(vector_name)"));
+  EXPECT_EQ(ISA, VFISAKind::LLVM);
+}