EIC code displayed by LXR master/​include/​llvm/​IR/​VFABIDemangler.h	Source navigation Diff markup Identifier search General search
	Version: master test Revert   Change

File indexing completed on 2026-05-10 08:44:11

 //===- VFABIDemangler.h - Vector Function ABI demangler ------- -*- C++ -*-===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // This file defines the VFABI demangling utility.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_IR_VFABIDEMANGLER_H
 #define LLVM_IR_VFABIDEMANGLER_H
 
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/IR/DerivedTypes.h"
 #include "llvm/IR/Instructions.h"
 #include "llvm/Support/Alignment.h"
 #include "llvm/Support/TypeSize.h"
 
 namespace llvm {
 
 /// Describes the type of Parameters
 enum class VFParamKind {
   Vector,            // No semantic information.
   OMP_Linear,        // declare simd linear(i)
   OMP_LinearRef,     // declare simd linear(ref(i))
   OMP_LinearVal,     // declare simd linear(val(i))
   OMP_LinearUVal,    // declare simd linear(uval(i))
   OMP_LinearPos,     // declare simd linear(i:c) uniform(c)
   OMP_LinearValPos,  // declare simd linear(val(i:c)) uniform(c)
   OMP_LinearRefPos,  // declare simd linear(ref(i:c)) uniform(c)
   OMP_LinearUValPos, // declare simd linear(uval(i:c)) uniform(c)
   OMP_Uniform,       // declare simd uniform(i)
   GlobalPredicate,   // Global logical predicate that acts on all lanes
                      // of the input and output mask concurrently. For
                      // example, it is implied by the `M` token in the
                      // Vector Function ABI mangled name.
   Unknown
 };
 
 /// Describes the type of Instruction Set Architecture
 enum class VFISAKind {
   AdvancedSIMD, // AArch64 Advanced SIMD (NEON)
   SVE,          // AArch64 Scalable Vector Extension
   RVV,          // RISC-V Vector Extension
   SSE,          // x86 SSE
   AVX,          // x86 AVX
   AVX2,         // x86 AVX2
   AVX512,       // x86 AVX512
   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 VFParameter {
   unsigned ParamPos;         // Parameter Position in Scalar Function.
   VFParamKind ParamKind;     // Kind of Parameter.
   int LinearStepOrPos = 0;   // Step or Position of the Parameter.
   Align Alignment = Align(); // Optional alignment in bytes, defaulted to 1.
 
   // Comparison operator.
   bool operator==(const VFParameter &Other) const {
     return std::tie(ParamPos, ParamKind, LinearStepOrPos, Alignment) ==
            std::tie(Other.ParamPos, Other.ParamKind, Other.LinearStepOrPos,
                     Other.Alignment);
   }
 };
 
 /// Contains the information about the kind of vectorization
 /// available.
 ///
 /// This object in independent on the paradigm used to
 /// represent vector functions. in particular, it is not attached to
 /// any target-specific ABI.
 struct VFShape {
   ElementCount VF;                        // Vectorization factor.
   SmallVector<VFParameter, 8> Parameters; // List of parameter information.
   // Comparison operator.
   bool operator==(const VFShape &Other) const {
     return std::tie(VF, Parameters) == std::tie(Other.VF, Other.Parameters);
   }
 
   /// Update the parameter in position P.ParamPos to P.
   void updateParam(VFParameter P) {
     assert(P.ParamPos < Parameters.size() && "Invalid parameter position.");
     Parameters[P.ParamPos] = P;
     assert(hasValidParameterList() && "Invalid parameter list");
   }
 
   /// Retrieve the VFShape that can be used to map a scalar function to itself,
   /// with VF = 1.
   static VFShape getScalarShape(const FunctionType *FTy) {
     return VFShape::get(FTy, ElementCount::getFixed(1),
                         /*HasGlobalPredicate*/ false);
   }
 
   /// Retrieve the basic vectorization shape of the function, where all
   /// parameters are mapped to VFParamKind::Vector with \p EC lanes. Specifies
   /// whether the function has a Global Predicate argument via \p HasGlobalPred.
   static VFShape get(const FunctionType *FTy, ElementCount EC,
                      bool HasGlobalPred) {
     SmallVector<VFParameter, 8> Parameters;
     for (unsigned I = 0; I < FTy->getNumParams(); ++I)
       Parameters.push_back(VFParameter({I, VFParamKind::Vector}));
     if (HasGlobalPred)
       Parameters.push_back(
           VFParameter({FTy->getNumParams(), VFParamKind::GlobalPredicate}));
 
     return {EC, Parameters};
   }
   /// Validation check on the Parameters in the VFShape.
   bool hasValidParameterList() const;
 };
 
 /// Holds the VFShape for a specific scalar to vector function mapping.
 struct VFInfo {
   VFShape Shape;          /// Classification of the vector function.
   std::string ScalarName; /// Scalar Function Name.
   std::string VectorName; /// Vector Function Name associated to this VFInfo.
   VFISAKind ISA;          /// Instruction Set Architecture.
 
   /// Returns the index of the first parameter with the kind 'GlobalPredicate',
   /// if any exist.
   std::optional<unsigned> getParamIndexForOptionalMask() const {
     unsigned ParamCount = Shape.Parameters.size();
     for (unsigned i = 0; i < ParamCount; ++i)
       if (Shape.Parameters[i].ParamKind == VFParamKind::GlobalPredicate)
         return i;
 
     return std::nullopt;
   }
 
   /// Returns true if at least one of the operands to the vectorized function
   /// has the kind 'GlobalPredicate'.
   bool isMasked() const { return getParamIndexForOptionalMask().has_value(); }
 };
 
 namespace VFABI {
 /// LLVM Internal VFABI ISA token for vector functions.
 static constexpr char const *_LLVM_ = "_LLVM_";
 /// Prefix for internal name redirection for vector function that
 /// tells the compiler to scalarize the call using the scalar name
 /// of the function. For example, a mangled name like
 /// `_ZGV_LLVM_N2v_foo(_LLVM_Scalarize_foo)` would tell the
 /// vectorizer to vectorize the scalar call `foo`, and to scalarize
 /// it once vectorization is done.
 static constexpr char const *_LLVM_Scalarize_ = "_LLVM_Scalarize_";
 
 /// Function to construct 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
 /// extension (or <isa> from now on). The <VFABI_name> is in the following
 /// format:
 ///
 /// _ZGV<isa><mask><vlen><parameters>_<scalarname>[(<redirection>)]
 ///
 /// This methods support demangling rules for the following <isa>:
 ///
 /// * AArch64: https://developer.arm.com/docs/101129/latest
 ///
 /// * x86 (libmvec): https://sourceware.org/glibc/wiki/libmvec and
 ///  https://sourceware.org/glibc/wiki/libmvec?action=AttachFile&do=view&target=VectorABI.txt
 ///
 /// \param MangledName -> input string in the format
 /// _ZGV<isa><mask><vlen><parameters>_<scalarname>[(<redirection>)].
 /// \param FTy -> FunctionType of the scalar function which we're trying to find
 /// a vectorized variant for. This is required to determine the vectorization
 /// factor for scalable vectors, since the mangled name doesn't encode that;
 /// it needs to be derived from the widest element types of vector arguments
 /// or return values.
 std::optional<VFInfo> tryDemangleForVFABI(StringRef MangledName,
                                           const FunctionType *FTy);
 
 /// Retrieve the `VFParamKind` from a string token.
 VFParamKind getVFParamKindFromString(const StringRef Token);
 
 // Name of the attribute where the variant mappings are stored.
 static constexpr char const *MappingsAttrName = "vector-function-abi-variant";
 
 /// Populates a set of strings representing the Vector Function ABI variants
 /// associated to the CallInst CI. If the CI does not contain the
 /// vector-function-abi-variant attribute, we return without populating
 /// VariantMappings, i.e. callers of getVectorVariantNames need not check for
 /// the presence of the attribute (see InjectTLIMappings).
 void getVectorVariantNames(const CallInst &CI,
                            SmallVectorImpl<std::string> &VariantMappings);
 
 /// Constructs a FunctionType by applying vector function information to the
 /// type of a matching scalar function.
 /// \param Info gets the vectorization factor (VF) and the VFParamKind of the
 /// parameters.
 /// \param ScalarFTy gets the Type information of parameters, as it is not
 /// stored in \p Info.
 /// \returns a pointer to a newly created vector FunctionType
 FunctionType *createFunctionType(const VFInfo &Info,
                                  const FunctionType *ScalarFTy);
 
 /// Overwrite the Vector Function ABI variants attribute with the names provide
 /// in \p VariantMappings.
 void setVectorVariantNames(CallInst *CI, ArrayRef<std::string> VariantMappings);
 
 } // end namespace VFABI
 
 } // namespace llvm
 
 #endif // LLVM_IR_VFABIDEMANGLER_H

This page was automatically generated by the 2.3.7 LXR engine. The LXR team