InjectTLIMappings.cpp Source File (original) (raw)

24using namespace llvm;

26#define DEBUG_TYPE "inject-tli-mappings"

29 "Number of calls in which the mappings have been injected.");

32 "Number of function declarations that have been added.");

34 "Number of `@llvm.compiler.used` operands that have been added.");

45 assert(!ScalarFTy->isVarArg() && "VarArg functions are not supported.");

50 assert(Info && "Failed to demangle vector variant");

51 assert(Info->Shape.VF == VF && "Mangled name does not match VF");

56 Function::Create(VectorFTy, Function::ExternalLinkage, VFName, M);

58 ++NumVFDeclAdded;

60 << "` of type " << *VectorFTy << "\n");

64 assert(!VecFunc->size() && "VFABI attribute requires `@llvm.compiler.used` "

65 "only on declarations.");

68 << "` to `@llvm.compiler.used`.\n");

69 ++NumCompUsedAdded;

70}

79 return;

86 return;

91 Mappings.end());

93 auto AddVariantDecl = [&](const ElementCount &VF, bool Predicate) {

97 if (!OriginalSetOfMappings.count(MangledName)) {

99 ++NumCallInjected;

100 }

102 if (!VariantF)

104 }

105 };

106

107

108 ElementCount WidestFixedVF, WidestScalableVF;

109 TLI.getWidestVF(ScalarName, WidestFixedVF, WidestScalableVF);

110

111 for (bool Predicated : {false, true}) {

113 ElementCount::isKnownLE(VF, WidestFixedVF); VF *= 2)

115

117 ElementCount::isKnownLE(VF, WidestScalableVF); VF *= 2)

119 }

120

122}

123

126 if (auto CI = dyn_cast(&I))

128

129 return false;

130}

131

132

133

134

139

141}

Expand Atomic instructions

Analysis containing CSE Info

static bool runImpl(Function &F, const TargetLowering &TLI)

This is the interface for a simple mod/ref and alias analysis over globals.

static void addMappingsFromTLI(const TargetLibraryInfo &TLI, CallInst &CI)

static void addVariantDeclaration(CallInst &CI, const ElementCount &VF, const VecDesc *VD)

A helper function that adds the vector variant declaration for vectorizing the CallInst CI with a vec...

static bool runImpl(const TargetLibraryInfo &TLI, Function &F)

assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())

This file defines the 'Statistic' class, which is designed to be an easy way to expose various metric...

#define STATISTIC(VARNAME, DESC)

A container for analyses that lazily runs them and caches their results.

PassT::Result & getResult(IRUnitT &IR, ExtraArgTs... ExtraArgs)

Get the result of an analysis pass for a given IR unit.

bool isNoBuiltin() const

Return true if the call should not be treated as a call to a builtin.

Function * getCalledFunction() const

Returns the function called, or null if this is an indirect function invocation or the function signa...

FunctionType * getFunctionType() const

This class represents a function call, abstracting a target machine's calling convention.

static constexpr ElementCount getScalable(ScalarTy MinVal)

static constexpr ElementCount getFixed(ScalarTy MinVal)

static Function * Create(FunctionType *Ty, LinkageTypes Linkage, unsigned AddrSpace, const Twine &N="", Module *M=nullptr)

void copyAttributesFrom(const Function *Src)

copyAttributesFrom - copy all additional attributes (those not needed to create a Function) from the ...

PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM)

const Module * getModule() const

Return the module owning the function this instruction belongs to or nullptr it the function does not...

A Module instance is used to store all the information related to an LLVM module.

A set of analyses that are preserved following a run of a transformation pass.

static PreservedAnalyses all()

Construct a special preserved set that preserves all passes.

A vector that has set insertion semantics.

size_type count(const key_type &key) const

Count the number of elements of a given key in the SetVector.

void push_back(const T &Elt)

This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.

StringRef - Represent a constant reference to a string, i.e.

constexpr bool empty() const

empty - Check if the string is empty.

Analysis pass providing the TargetLibraryInfo.

Provides information about what library functions are available for the current target.

void getWidestVF(StringRef ScalarF, ElementCount &FixedVF, ElementCount &ScalableVF) const

Returns the largest vectorization factor used in the list of vector functions.

const VecDesc * getVectorMappingInfo(StringRef F, const ElementCount &VF, bool Masked) const

bool isFunctionVectorizable(StringRef F, const ElementCount &VF) const

StringRef getName() const

Return a constant reference to the value's name.

Provides info so a possible vectorization of a function can be computed.

std::string getVectorFunctionABIVariantString() const

Returns a vector function ABI variant string on the form: ZGV(<...

StringRef getVectorFnName() const

std::optional< VFInfo > tryDemangleForVFABI(StringRef MangledName, const FunctionType *FTy)

Function to construct a VFInfo out of a mangled names in the following format:

FunctionType * createFunctionType(const VFInfo &Info, const FunctionType *ScalarFTy)

Constructs a FunctionType by applying vector function information to the type of a matching scalar fu...

void getVectorVariantNames(const CallInst &CI, SmallVectorImpl< std::string > &VariantMappings)

Populates a set of strings representing the Vector Function ABI variants associated to the CallInst C...

void setVectorVariantNames(CallInst *CI, ArrayRef< std::string > VariantMappings)

Overwrite the Vector Function ABI variants attribute with the names provide in VariantMappings.

This is an optimization pass for GlobalISel generic memory operations.

raw_ostream & dbgs()

dbgs() - This returns a reference to a raw_ostream for debugging messages.

void appendToCompilerUsed(Module &M, ArrayRef< GlobalValue * > Values)

Adds global values to the llvm.compiler.used list.