PartiallyInlineLibCalls.cpp Source File (original) (raw)

27#include

29using namespace llvm;

31namespace llvm {

33}

35#define DEBUG_TYPE "partially-inline-libcalls"

37 DEBUG_COUNTER(PILCounter, "partially-inline-libcalls-transform",

38 "Controls transformations in partially-inline-libcalls");

46 if (Call->onlyReadsMemory())

47 return false;

50 return false;

70 Builder.getTrue(), Call->getNextNode(), false,

71 nullptr, DTU);

80 Builder.SetInsertPoint(JoinBB, JoinBB->begin());

81 PHINode *Phi = Builder.CreatePHI(Ty, 2);

82 Call->replaceAllUsesWith(Phi);

86 LibCallBB->setName("call.sqrt");

87 Builder.SetInsertPoint(LibCallTerm);

89 Builder.Insert(LibCall);

93 Call->setDoesNotAccessMemory();

96 Builder.SetInsertPoint(CurrBBTerm);

97 Value *FCmp = TTI->isFCmpOrdCheaperThanFCmpZero(Ty)

98 ? Builder.CreateFCmpORD(Call, Call)

99 : Builder.CreateFCmpOGE(Call->getOperand(0),

100 ConstantFP::get(Ty, 0.0));

101 CurrBBTerm->setCondition(FCmp);

103 CurrBBTerm->getFunction()->getEntryCount()) {

104

105

106 MDBuilder MDB(CurrBBTerm->getContext());

107 CurrBBTerm->setMetadata(LLVMContext::MD_prof,

109 }

110

111 Phi->addIncoming(Call, &CurrBB);

112 Phi->addIncoming(LibCall, LibCallBB);

113

115 return true;

116}

117

122 std::optional DTU;

123 if (DT)

124 DTU.emplace(DT, DomTreeUpdater::UpdateStrategy::Lazy);

125

127

130 CurrBB = BB++;

131

133 II != IE; ++II) {

136

137 if ( Call || !(CalledFunc = Call->getCalledFunction()))

138 continue;

139

140 if (Call->isNoBuiltin() || Call->isStrictFP())

141 continue;

142

143 if (Call->isMustTailCall())

144 continue;

145

146

147

148 LibFunc LF;

150 !TLI->getLibFunc(*CalledFunc, LF) || !TLI->has(LF))

151 continue;

152

153 switch (LF) {

154 case LibFunc_sqrtf:

155 case LibFunc_sqrt:

156 if (TTI->haveFastSqrt(Call->getType()) &&

158 DTU ? &*DTU : nullptr, ORE))

159 break;

160 continue;

161 default:

162 continue;

163 }

164

166 break;

167 }

168 }

169

171}

172

185

186namespace {

187class PartiallyInlineLibCallsLegacyPass : public FunctionPass {

188public:

189 static char ID;

190

191 PartiallyInlineLibCallsLegacyPass() : FunctionPass(ID) {

194 }

195

196 void getAnalysisUsage(AnalysisUsage &AU) const override {

202 }

203

205 if (skipFunction(F))

206 return false;

207

208 TargetLibraryInfo *TLI =

209 &getAnalysis().getTLI(F);

210 const TargetTransformInfo *TTI =

211 &getAnalysis().getTTI(F);

212 DominatorTree *DT = nullptr;

213 if (auto *DTWP = getAnalysisIfAvailable())

214 DT = &DTWP->getDomTree();

215 auto *ORE = &getAnalysis().getORE();

217 }

218};

219}

220

221char PartiallyInlineLibCallsLegacyPass::ID = 0;

223 "partially-inline-libcalls",

224 "Partially inline calls to library functions", false,

225 false)

231 "partially-inline-libcalls",

232 "Partially inline calls to library functions", false, false)

233

235 return new PartiallyInlineLibCallsLegacyPass();

236}

This file provides an implementation of debug counters.

#define DEBUG_COUNTER(VARNAME, COUNTERNAME, DESC)

static bool runOnFunction(Function &F, bool PostInlining)

uint64_t IntrinsicInst * II

static bool runPartiallyInlineLibCalls(Function &F, TargetLibraryInfo *TLI, const TargetTransformInfo *TTI, DominatorTree *DT, OptimizationRemarkEmitter *ORE)

Definition PartiallyInlineLibCalls.cpp:118

static bool optimizeSQRT(CallInst *Call, Function *CalledFunc, BasicBlock &CurrBB, Function::iterator &BB, const TargetTransformInfo *TTI, DomTreeUpdater *DTU, OptimizationRemarkEmitter *ORE)

Definition PartiallyInlineLibCalls.cpp:40

#define INITIALIZE_PASS_DEPENDENCY(depName)

#define INITIALIZE_PASS_END(passName, arg, name, cfg, analysis)

#define INITIALIZE_PASS_BEGIN(passName, arg, name, cfg, analysis)

This pass exposes codegen information to IR-level passes.

PassT::Result * getCachedResult(IRUnitT &IR) const

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

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

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

Represent the analysis usage information of a pass.

AnalysisUsage & addRequired()

AnalysisUsage & addPreserved()

Add the specified Pass class to the set of analyses preserved by this pass.

LLVM Basic Block Representation.

iterator begin()

Instruction iterator methods.

InstListType::iterator iterator

Instruction iterators...

const Instruction * getTerminator() const LLVM_READONLY

Returns the terminator instruction if the block is well formed or null if the block is not well forme...

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

static bool shouldExecute(CounterInfo &Counter)

Analysis pass which computes a DominatorTree.

Legacy analysis pass which computes a DominatorTree.

Concrete subclass of DominatorTreeBase that is used to compute a normal dominator tree.

FunctionPass class - This class is used to implement most global optimizations.

BasicBlockListType::iterator iterator

bool hasLocalLinkage() const

This provides a uniform API for creating instructions and inserting them into a basic block: either a...

LLVM_ABI BasicBlock * getSuccessor(unsigned Idx) const LLVM_READONLY

Return the specified successor. This instruction must be a terminator.

LLVM_ABI MDNode * createLikelyBranchWeights()

Return metadata containing two branch weights, with significant bias towards true destination.

PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM)

Definition PartiallyInlineLibCalls.cpp:174

static LLVM_ABI PassRegistry * getPassRegistry()

getPassRegistry - Access the global registry object, which is automatically initialized at applicatio...

virtual void getAnalysisUsage(AnalysisUsage &) const

getAnalysisUsage - This function should be overriden by passes that need analysis information to do t...

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.

PreservedAnalyses & preserve()

Mark an analysis as preserved.

Analysis pass providing the TargetTransformInfo.

Analysis pass providing the TargetLibraryInfo.

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

bool has(LibFunc F) const

Tests whether a library function is available.

bool getLibFunc(StringRef funcName, LibFunc &F) const

Searches for a particular function name.

Wrapper pass for TargetTransformInfo.

This pass provides access to the codegen interfaces that are needed for IR-level transformations.

The instances of the Type class are immutable: once they are created, they are never changed.

LLVM Value Representation.

LLVM_ABI void setName(const Twine &Name)

Change the name of the value.

LLVM_ABI StringRef getName() const

Return a constant reference to the value's name.

const ParentTy * getParent() const

self_iterator getIterator()

unsigned ID

LLVM IR allows to use arbitrary numbers as calling convention identifiers.

This is an optimization pass for GlobalISel generic memory operations.

decltype(auto) dyn_cast(const From &Val)

dyn_cast - Return the argument parameter cast to the specified type.

decltype(auto) cast(const From &Val)

cast - Return the argument parameter cast to the specified type.

cl::opt< bool > ProfcheckDisableMetadataFixes("profcheck-disable-metadata-fixes", cl::Hidden, cl::init(false), cl::desc("Disable metadata propagation fixes discovered through Issue #147390"))

LLVM_ABI FunctionPass * createPartiallyInlineLibCallsPass()

Definition PartiallyInlineLibCalls.cpp:234

LLVM_ABI Instruction * SplitBlockAndInsertIfThen(Value *Cond, BasicBlock::iterator SplitBefore, bool Unreachable, MDNode *BranchWeights=nullptr, DomTreeUpdater *DTU=nullptr, LoopInfo *LI=nullptr, BasicBlock *ThenBlock=nullptr)

Split the containing block at the specified instruction - everything before SplitBefore stays in the ...

AnalysisManager< Function > FunctionAnalysisManager

Convenience typedef for the Function analysis manager.

LLVM_ABI void initializePartiallyInlineLibCallsLegacyPassPass(PassRegistry &)