Movatterモバイル変換

Go to the documentation of this file.

1//===- ModuleInliner.cpp - Code related to module inliner -----------------===//

2//

3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.

4// See https://llvm.org/LICENSE.txt for license information.

5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception

6//

7//===----------------------------------------------------------------------===//

8//

9// This file implements the mechanics required to implement inlining without

10// missing any calls in the module level. It doesn't need any infromation about

11// SCC or call graph, which is different from the SCC inliner. The decisions of

12// which calls are profitable to inline are implemented elsewhere.

13//

14//===----------------------------------------------------------------------===//

16#include "llvm/Transforms/IPO/ModuleInliner.h"

17#include "llvm/ADT/ScopeExit.h"

18#include "llvm/ADT/SmallVector.h"

19#include "llvm/ADT/Statistic.h"

20#include "llvm/Analysis/AliasAnalysis.h"

21#include "llvm/Analysis/AssumptionCache.h"

22#include "llvm/Analysis/BlockFrequencyInfo.h"

23#include "llvm/Analysis/CtxProfAnalysis.h"

24#include "llvm/Analysis/InlineAdvisor.h"

25#include "llvm/Analysis/InlineCost.h"

26#include "llvm/Analysis/InlineOrder.h"

27#include "llvm/Analysis/OptimizationRemarkEmitter.h"

28#include "llvm/Analysis/ProfileSummaryInfo.h"

29#include "llvm/Analysis/ReplayInlineAdvisor.h"

30#include "llvm/Analysis/TargetLibraryInfo.h"

31#include "llvm/IR/DiagnosticInfo.h"

32#include "llvm/IR/Function.h"

33#include "llvm/IR/InstIterator.h"

34#include "llvm/IR/Instruction.h"

35#include "llvm/IR/IntrinsicInst.h"

36#include "llvm/IR/Module.h"

37#include "llvm/IR/PassManager.h"

38#include "llvm/Support/CommandLine.h"

39#include "llvm/Support/Debug.h"

40#include "llvm/Support/raw_ostream.h"

41#include "llvm/Transforms/Utils/CallPromotionUtils.h"

42#include "llvm/Transforms/Utils/Cloning.h"

43#include <cassert>

45using namespacellvm;

47#define DEBUG_TYPE "module-inline"

49STATISTIC(NumInlined,"Number of functions inlined");

50STATISTIC(NumDeleted,"Number of functions deleted because all callers found");

52cl::opt<bool>CtxProfPromoteAlwaysInline(

53"ctx-prof-promote-alwaysinline",cl::init(false),cl::Hidden,

54cl::desc("If using a contextual profile in this module, and an indirect "

55"call target is marked as alwaysinline, perform indirect call "

56"promotion for that target. If multiple targets for an indirect "

57"call site fit this description, they are all promoted."));

59/// Return true if the specified inline history ID

60/// indicates an inline history that includes the specified function.

61staticboolinlineHistoryIncludes(

62Function *F,int InlineHistoryID,

63constSmallVectorImpl<std::pair<Function *, int>> &InlineHistory) {

64while (InlineHistoryID != -1) {

65assert(unsigned(InlineHistoryID) < InlineHistory.size() &&

66"Invalid inline history ID");

67if (InlineHistory[InlineHistoryID].first ==F)

68returntrue;

69 InlineHistoryID = InlineHistory[InlineHistoryID].second;

70 }

71returnfalse;

72}

74InlineAdvisor &ModuleInlinerPass::getAdvisor(constModuleAnalysisManager &MAM,

75FunctionAnalysisManager &FAM,

76Module &M) {

77if (OwnedAdvisor)

78return *OwnedAdvisor;

80auto *IAA =MAM.getCachedResult<InlineAdvisorAnalysis>(M);

81if (!IAA) {

82// It should still be possible to run the inliner as a stand-alone module

83// pass, for test scenarios. In that case, we default to the

84// DefaultInlineAdvisor, which doesn't need to keep state between module

85// pass runs. It also uses just the default InlineParams. In this case, we

86// need to use the provided FAM, which is valid for the duration of the

87// inliner pass, and thus the lifetime of the owned advisor. The one we

88// would get from the MAM can be invalidated as a result of the inliner's

89// activity.

90 OwnedAdvisor = std::make_unique<DefaultInlineAdvisor>(

91 M,FAM, Params,InlineContext{LTOPhase,InlinePass::ModuleInliner});

93return *OwnedAdvisor;

94 }

95assert(IAA->getAdvisor() &&

96"Expected a present InlineAdvisorAnalysis also have an "

97"InlineAdvisor initialized");

98return *IAA->getAdvisor();

99}

100

101staticboolisKnownLibFunction(Function &F,TargetLibraryInfo &TLI) {

102LibFunc LF;

103

104// Either this is a normal library function or a "vectorizable"

105// function. Not using the VFDatabase here because this query

106// is related only to libraries handled via the TLI.

107return TLI.getLibFunc(F, LF) ||

108 TLI.isKnownVectorFunctionInLibrary(F.getName());

109}

110

111PreservedAnalyses ModuleInlinerPass::run(Module &M,

112ModuleAnalysisManager &MAM) {

113LLVM_DEBUG(dbgs() <<"---- Module Inliner is Running ---- \n");

114

115auto &IAA =MAM.getResult<InlineAdvisorAnalysis>(M);

116if (!IAA.tryCreate(Params, Mode, {},

117InlineContext{LTOPhase, InlinePass::ModuleInliner})) {

118 M.getContext().emitError(

119"Could not setup Inlining Advisor for the requested "

120"mode and/or options");

121returnPreservedAnalyses::all();

122 }

123

124auto &CtxProf =MAM.getResult<CtxProfAnalysis>(M);

125

126bool Changed =false;

127

128ProfileSummaryInfo *PSI =MAM.getCachedResult<ProfileSummaryAnalysis>(M);

129

130FunctionAnalysisManager &FAM =

131MAM.getResult<FunctionAnalysisManagerModuleProxy>(M).getManager();

132

133auto GetTLI = [&FAM](Function &F) ->TargetLibraryInfo & {

134returnFAM.getResult<TargetLibraryAnalysis>(F);

135 };

136

137InlineAdvisor &Advisor = getAdvisor(MAM,FAM, M);

138 Advisor.onPassEntry();

139

140auto AdvisorOnExit =make_scope_exit([&] { Advisor.onPassExit(); });

141

142// In the module inliner, a priority-based worklist is used for calls across

143// the entire Module. With this module inliner, the inline order is not

144// limited to bottom-up order. More globally scope inline order is enabled.

145// Also, the inline deferral logic become unnecessary in this module inliner.

146// It is possible to use other priority heuristics, e.g. profile-based

147// heuristic.

148//

149// TODO: Here is a huge amount duplicate code between the module inliner and

150// the SCC inliner, which need some refactoring.

151auto Calls =getInlineOrder(FAM, Params,MAM, M);

152assert(Calls !=nullptr &&"Expected an initialized InlineOrder");

153

154// Populate the initial list of calls in this module.

155SetVector<std::pair<CallBase *, Function *>> ICPCandidates;

156for (Function &F : M) {

157auto &ORE =FAM.getResult<OptimizationRemarkEmitterAnalysis>(F);

158for (Instruction &I :instructions(F)) {

159if (auto *CB = dyn_cast<CallBase>(&I)) {

160if (Function *Callee = CB->getCalledFunction()) {

161if (!Callee->isDeclaration())

162 Calls->push({CB, -1});

163elseif (!isa<IntrinsicInst>(I)) {

164using namespaceore;

165setInlineRemark(*CB,"unavailable definition");

166 ORE.emit([&]() {

167returnOptimizationRemarkMissed(DEBUG_TYPE,"NoDefinition", &I)

168 << NV("Callee", Callee) <<" will not be inlined into "

169 << NV("Caller", CB->getCaller())

170 <<" because its definition is unavailable"

171 << setIsVerbose();

172 });

173 }

174 }elseif (CtxProfPromoteAlwaysInline && CtxProf &&

175 CB->isIndirectCall()) {

176CtxProfAnalysis::collectIndirectCallPromotionList(*CB, CtxProf,

177 ICPCandidates);

178 }

179 }

180 }

181 }

182for (auto &[CB,Target] : ICPCandidates) {

183if (auto *DirectCB =promoteCallWithIfThenElse(*CB, *Target, CtxProf))

184 Calls->push({DirectCB, -1});

185 }

186if (Calls->empty())

187returnPreservedAnalyses::all();

188

189// When inlining a callee produces new call sites, we want to keep track of

190// the fact that they were inlined from the callee. This allows us to avoid

191// infinite inlining in some obscure cases. To represent this, we use an

192// index into the InlineHistory vector.

193SmallVector<std::pair<Function *, int>, 16> InlineHistory;

194

195// Track the dead functions to delete once finished with inlining calls. We

196// defer deleting these to make it easier to handle the call graph updates.

197SmallVector<Function *, 4> DeadFunctions;

198

199// Loop forward over all of the calls.

200while (!Calls->empty()) {

201autoP = Calls->pop();

202CallBase *CB =P.first;

203constint InlineHistoryID =P.second;

204Function &F = *CB->getCaller();

205Function &Callee = *CB->getCalledFunction();

206

207LLVM_DEBUG(dbgs() <<"Inlining calls in: " <<F.getName() <<"\n"

208 <<" Function size: " <<F.getInstructionCount()

209 <<"\n");

210 (void)F;

211

212auto GetAssumptionCache = [&](Function &F) ->AssumptionCache & {

213returnFAM.getResult<AssumptionAnalysis>(F);

214 };

215

216if (InlineHistoryID != -1 &&

217inlineHistoryIncludes(&Callee, InlineHistoryID, InlineHistory)) {

218setInlineRemark(*CB,"recursive");

219continue;

220 }

221

222auto Advice = Advisor.getAdvice(*CB,/*OnlyMandatory*/false);

223// Check whether we want to inline this callsite.

224if (!Advice->isInliningRecommended()) {

225 Advice->recordUnattemptedInlining();

226continue;

227 }

228

229// Setup the data structure used to plumb customization into the

230// `InlineFunction` routine.

231InlineFunctionInfo IFI(

232 GetAssumptionCache, PSI,

233 &FAM.getResult<BlockFrequencyAnalysis>(*(CB->getCaller())),

234 &FAM.getResult<BlockFrequencyAnalysis>(Callee));

235

236InlineResult IR =

237InlineFunction(*CB, IFI, CtxProf,/*MergeAttributes=*/true,

238 &FAM.getResult<AAManager>(*CB->getCaller()));

239if (!IR.isSuccess()) {

240 Advice->recordUnsuccessfulInlining(IR);

241continue;

242 }

243

244 Changed =true;

245 ++NumInlined;

246

247LLVM_DEBUG(dbgs() <<" Size after inlining: " <<F.getInstructionCount()

248 <<"\n");

249

250// Add any new callsites to defined functions to the worklist.

251if (!IFI.InlinedCallSites.empty()) {

252int NewHistoryID = InlineHistory.size();

253 InlineHistory.push_back({&Callee, InlineHistoryID});

254

255for (CallBase *ICB :reverse(IFI.InlinedCallSites)) {

256Function *NewCallee = ICB->getCalledFunction();

257if (!NewCallee) {

258// Try to promote an indirect (virtual) call without waiting for

259// the post-inline cleanup and the next DevirtSCCRepeatedPass

260// iteration because the next iteration may not happen and we may

261// miss inlining it.

262// FIXME: enable for ctxprof.

263if (!CtxProf)

264if (tryPromoteCall(*ICB))

265 NewCallee = ICB->getCalledFunction();

266 }

267if (NewCallee)

268if (!NewCallee->isDeclaration())

269 Calls->push({ICB, NewHistoryID});

270 }

271 }

272

273// For local functions, check whether this makes the callee trivially

274// dead. In that case, we can drop the body of the function eagerly

275// which may reduce the number of callers of other functions to one,

276// changing inline cost thresholds.

277bool CalleeWasDeleted =false;

278if (Callee.hasLocalLinkage()) {

279// To check this we also need to nuke any dead constant uses (perhaps

280// made dead by this operation on other functions).

281Callee.removeDeadConstantUsers();

282// if (Callee.use_empty() && !CG.isLibFunction(Callee)) {

283if (Callee.use_empty() && !isKnownLibFunction(Callee, GetTLI(Callee))) {

284 Calls->erase_if([&](const std::pair<CallBase *, int> &Call) {

285returnCall.first->getCaller() == &Callee;

286 });

287// Clear the body and queue the function itself for deletion when we

288// finish inlining.

289// Note that after this point, it is an error to do anything other

290// than use the callee's address or delete it.

291Callee.dropAllReferences();

292assert(!is_contained(DeadFunctions, &Callee) &&

293"Cannot put cause a function to become dead twice!");

294 DeadFunctions.push_back(&Callee);

295 CalleeWasDeleted =true;

296 }

297 }

298if (CalleeWasDeleted)

299 Advice->recordInliningWithCalleeDeleted();

300else

301 Advice->recordInlining();

302 }

303

304// Now that we've finished inlining all of the calls across this module,

305// delete all of the trivially dead functions.

306//

307// Note that this walks a pointer set which has non-deterministic order but

308// that is OK as all we do is delete things and add pointers to unordered

309// sets.

310for (Function *DeadF : DeadFunctions) {

311// Clear out any cached analyses.

312FAM.clear(*DeadF, DeadF->getName());

313

314// And delete the actual function from the module.

315M.getFunctionList().erase(DeadF);

316

317 ++NumDeleted;

318 }

319

320if (!Changed)

321returnPreservedAnalyses::all();

322

323returnPreservedAnalyses::none();

324}

AliasAnalysis.h

AssumptionCache.h

instructions

Expand Atomic instructions

Definition:AtomicExpandPass.cpp:172

#define LLVM_DEBUG(...)

Definition:Debug.h:106

DiagnosticInfo.h

DEBUG_TYPE

#define DEBUG_TYPE

Definition:GenericCycleImpl.h:31

Module.h This file contains the declarations for the Module class.

PassManager.h

This header defines various interfaces for pass management in LLVM.

InlineAdvisor.h

InlineCost.h

InlineOrder.h

inlineHistoryIncludes

static bool inlineHistoryIncludes(Function *F, int InlineHistoryID, const SmallVectorImpl< std::pair< Function *, int > > &InlineHistory)

Return true if the specified inline history ID indicates an inline history that includes the specifie...

Definition:Inliner.cpp:146

InstIterator.h

isKnownLibFunction

static bool isKnownLibFunction(Function &F, TargetLibraryInfo &TLI)

Definition:LazyCallGraph.cpp:146

Legalize the Machine IR a function s Machine IR

Definition:Legalizer.cpp:80

#define F(x, y, z)

Definition:MD5.cpp:55

#define I(x, y, z)

Definition:MD5.cpp:58

inlineHistoryIncludes

static bool inlineHistoryIncludes(Function *F, int InlineHistoryID, const SmallVectorImpl< std::pair< Function *, int > > &InlineHistory)

Return true if the specified inline history ID indicates an inline history that includes the specifie...

Definition:ModuleInliner.cpp:61

CtxProfPromoteAlwaysInline

cl::opt< bool > CtxProfPromoteAlwaysInline("ctx-prof-promote-alwaysinline", cl::init(false), cl::Hidden, cl::desc("If using a contextual profile in this module, and an indirect " "call target is marked as alwaysinline, perform indirect call " "promotion for that target. If multiple targets for an indirect " "call site fit this description, they are all promoted."))

ModuleInliner.h

OptimizationRemarkEmitter.h

#define P(N)

FAM

FunctionAnalysisManager FAM

Definition:PassBuilderBindings.cpp:61

MAM

ModuleAnalysisManager MAM

Definition:PassBuilderBindings.cpp:63

ProfileSummaryInfo.h

ReplayInlineAdvisor.h

assert

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

ScopeExit.h

This file defines the make_scope_exit function, which executes user-defined cleanup logic at scope ex...

SmallVector.h

This file defines the SmallVector class.

Statistic.h

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

STATISTIC

#define STATISTIC(VARNAME, DESC)

Definition:Statistic.h:166

TargetLibraryInfo.h

llvm::AAManager

A manager for alias analyses.

Definition:AliasAnalysis.h:933

llvm::AnalysisManager

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

Definition:PassManager.h:253

llvm::AnalysisManager::clear

void clear(IRUnitT &IR, llvm::StringRef Name)

Clear any cached analysis results for a single unit of IR.

Definition:PassManagerImpl.h:119

llvm::AnalysisManager::getCachedResult

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

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

Definition:PassManager.h:429

llvm::AnalysisManager::getResult

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

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

Definition:PassManager.h:410

llvm::AssumptionAnalysis

A function analysis which provides an AssumptionCache.

Definition:AssumptionCache.h:173

llvm::AssumptionCache

A cache of @llvm.assume calls within a function.

Definition:AssumptionCache.h:42

llvm::BlockFrequencyAnalysis

Analysis pass which computes BlockFrequencyInfo.

Definition:BlockFrequencyInfo.h:114

llvm::CallBase

Base class for all callable instructions (InvokeInst and CallInst) Holds everything related to callin...

Definition:InstrTypes.h:1112

llvm::CallBase::getCalledFunction

Function * getCalledFunction() const

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

Definition:InstrTypes.h:1341

llvm::CallBase::getCaller

Function * getCaller()

Helper to get the caller (the parent function).

Definition:Instructions.cpp:327

llvm::CtxProfAnalysis

Definition:CtxProfAnalysis.h:113

llvm::CtxProfAnalysis::collectIndirectCallPromotionList

static void collectIndirectCallPromotionList(CallBase &IC, Result &Profile, SetVector< std::pair< CallBase *, Function * > > &Candidates)

Definition:CtxProfAnalysis.cpp:301

llvm::Function

Definition:Function.h:63

llvm::GlobalValue::isDeclaration

bool isDeclaration() const

Return true if the primary definition of this global value is outside of the current translation unit...

Definition:Globals.cpp:296

llvm::InlineAdvisorAnalysis

The InlineAdvisorAnalysis is a module pass because the InlineAdvisor needs to capture state right bef...

Definition:InlineAdvisor.h:307

llvm::InlineAdvisor

Interface for deciding whether to inline a call site or not.

Definition:InlineAdvisor.h:163

llvm::InlineAdvisor::onPassEntry

virtual void onPassEntry(LazyCallGraph::SCC *SCC=nullptr)

This must be called when the Inliner pass is entered, to allow the InlineAdvisor update internal stat...

Definition:InlineAdvisor.h:184

llvm::InlineAdvisor::onPassExit

virtual void onPassExit(LazyCallGraph::SCC *SCC=nullptr)

This must be called when the Inliner pass is exited, as function passes may be run subsequently.

Definition:InlineAdvisor.h:189

llvm::InlineFunctionInfo

This class captures the data input to the InlineFunction call, and records the auxiliary results prod...

Definition:Cloning.h:268

llvm::InlineResult

InlineResult is basically true or false.

Definition:InlineCost.h:179

llvm::InnerAnalysisManagerProxy

An analysis over an "outer" IR unit that provides access to an analysis manager over an "inner" IR un...

Definition:PassManager.h:567

llvm::Instruction

Definition:Instruction.h:68

llvm::ModuleInlinerPass::run

PreservedAnalyses run(Module &, ModuleAnalysisManager &)

Definition:ModuleInliner.cpp:111

llvm::Module

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

Definition:Module.h:65

llvm::OptimizationRemarkEmitterAnalysis

Definition:OptimizationRemarkEmitter.h:164

llvm::OptimizationRemarkMissed

Diagnostic information for missed-optimization remarks.

Definition:DiagnosticInfo.h:807

llvm::PreservedAnalyses

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

Definition:Analysis.h:111

llvm::PreservedAnalyses::none

static PreservedAnalyses none()

Convenience factory function for the empty preserved set.

Definition:Analysis.h:114

llvm::PreservedAnalyses::all

static PreservedAnalyses all()

Construct a special preserved set that preserves all passes.

Definition:Analysis.h:117

llvm::ProfileSummaryAnalysis

An analysis pass based on the new PM to deliver ProfileSummaryInfo.

Definition:ProfileSummaryInfo.h:372

llvm::ProfileSummaryInfo

Analysis providing profile information.

Definition:ProfileSummaryInfo.h:41

llvm::SetVector

A vector that has set insertion semantics.

Definition:SetVector.h:57

llvm::SmallVectorBase::size

size_t size() const

Definition:SmallVector.h:78

llvm::SmallVectorImpl

This class consists of common code factored out of the SmallVector class to reduce code duplication b...

Definition:SmallVector.h:573

llvm::SmallVectorTemplateBase::push_back

void push_back(const T &Elt)

Definition:SmallVector.h:413

llvm::SmallVector

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

Definition:SmallVector.h:1196

llvm::TargetLibraryAnalysis

Analysis pass providing the TargetLibraryInfo.

Definition:TargetLibraryInfo.h:614

llvm::TargetLibraryInfo

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

Definition:TargetLibraryInfo.h:280

llvm::TargetLibraryInfo::isKnownVectorFunctionInLibrary

bool isKnownVectorFunctionInLibrary(StringRef F) const

Check if the function "F" is listed in a library known to LLVM.

Definition:TargetLibraryInfo.h:605

llvm::TargetLibraryInfo::getLibFunc

bool getLibFunc(StringRef funcName, LibFunc &F) const

Searches for a particular function name.

Definition:TargetLibraryInfo.h:345

llvm::Target

Target - Wrapper for Target specific information.

Definition:TargetRegistry.h:144

llvm::cl::opt

Definition:CommandLine.h:1423

llvm::ARM::ProfileKind::M

@ M

llvm::MCID::Call

@ Call

Definition:MCInstrDesc.h:156

llvm::cl::Hidden

@ Hidden

Definition:CommandLine.h:137

llvm::cl::init

initializer< Ty > init(const Ty &Val)

Definition:CommandLine.h:443

llvm::pdb::PDB_SymType::Callee

@ Callee

llvm

This is an optimization pass for GlobalISel generic memory operations.

Definition:AddressRanges.h:18

llvm::InlinePass::ModuleInliner

@ ModuleInliner

llvm::make_scope_exit

detail::scope_exit< std::decay_t< Callable > > make_scope_exit(Callable &&F)

Definition:ScopeExit.h:59

llvm::promoteCallWithIfThenElse

CallBase & promoteCallWithIfThenElse(CallBase &CB, Function *Callee, MDNode *BranchWeights=nullptr)

Promote the given indirect call site to conditionally call Callee.

Definition:CallPromotionUtils.cpp:567

llvm::LibFunc

LibFunc

Definition:TargetLibraryInfo.h:68

llvm::setInlineRemark

void setInlineRemark(CallBase &CB, StringRef Message)

Set the inline-remark attribute.

Definition:InlineAdvisor.cpp:364

llvm::reverse

auto reverse(ContainerTy &&C)

Definition:STLExtras.h:420

llvm::getInlineOrder

std::unique_ptr< InlineOrder< std::pair< CallBase *, int > > > getInlineOrder(FunctionAnalysisManager &FAM, const InlineParams &Params, ModuleAnalysisManager &MAM, Module &M)

Definition:InlineOrder.cpp:313

llvm::dbgs

raw_ostream & dbgs()

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

Definition:Debug.cpp:163

llvm::InlineFunction

InlineResult InlineFunction(CallBase &CB, InlineFunctionInfo &IFI, bool MergeAttributes=false, AAResults *CalleeAAR=nullptr, bool InsertLifetime=true, Function *ForwardVarArgsTo=nullptr)

This function inlines the called function into the basic block of the caller.

Definition:InlineFunction.cpp:2460

llvm::is_contained

bool is_contained(R &&Range, const E &Element)

Returns true if Element is found in Range.

Definition:STLExtras.h:1903

llvm::tryPromoteCall

bool tryPromoteCall(CallBase &CB)

Try to promote (devirtualize) a virtual call on an Alloca.

Definition:CallPromotionUtils.cpp:685

raw_ostream.h

llvm::InlineContext

Provides context on when an inline advisor is constructed in the pipeline (e.g., link phase,...

Definition:InlineAdvisor.h:58

llvm::cl::desc

Definition:CommandLine.h:409