Inliner.cpp Source File (original) (raw)

60#include

61#include

62#include

64using namespace llvm;

66#define DEBUG_TYPE "inline"

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

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

74 "Cost multiplier to multiply onto inlined call sites where the "

75 "new call was previously an intra-SCC call (not relevant when the "

76 "original call was already intra-SCC). This can accumulate over "

77 "multiple inlinings (e.g. if a call site already had a cost "

78 "multiplier and one of its inlined calls was also subject to "

79 "this, the inlined call would have the original multiplier "

80 "multiplied by intra-scc-cost-multiplier). This is to prevent tons of "

81 "inlining through a child SCC which can cause terrible compile times"));

97 "Optimization remarks file containing inline remarks to be replayed "

98 "by cgscc inlining."),

100

102 "cgscc-inline-replay-scope",

105 "Replay on functions that have remarks associated "

106 "with them (default)"),

108 "Replay on the entire module")),

109 cl::desc("Whether inline replay should be applied to the entire "

110 "Module or just the Functions (default) that are present as "

111 "callers in remarks during cgscc inlining."),

113

115 "cgscc-inline-replay-fallback",

120 "All decisions not in replay send to original advisor (default)"),

122 "AlwaysInline", "All decisions not in replay are inlined"),

124 "All decisions not in replay are not inlined")),

126 "How cgscc inline replay treats sites that don't come from the replay. "

127 "Original: defers to original advisor, AlwaysInline: inline all sites "

128 "not in replay, NeverInline: inline no sites not in replay"),

130

132 "cgscc-inline-replay-format",

137 ":"),

139 "LineDiscriminator", "."),

141 "LineColumnDiscriminator",

142 ":. (default)")),

144

145

146

148 Function *F, int InlineHistoryID,

149 const SmallVectorImpl<std::pair<Function *, int>> &InlineHistory) {

150 while (InlineHistoryID != -1) {

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

152 "Invalid inline history ID");

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

154 return true;

155 InlineHistoryID = InlineHistory[InlineHistoryID].second;

156 }

157 return false;

158}

159

161InlinerPass::getAdvisor(const ModuleAnalysisManagerCGSCCProxy::Result &MAM,

163 if (OwnedAdvisor)

164 return *OwnedAdvisor;

165

167 if (!IAA) {

168

169

170

171

172

173

174

175

176 OwnedAdvisor = std::make_unique(

179

182 M, FAM, M.getContext(), std::move(OwnedAdvisor),

183 ReplayInlinerSettings{CGSCCInlineReplayFile,

184 CGSCCInlineReplayScope,

185 CGSCCInlineReplayFallback,

186 {CGSCCInlineReplayFormat}},

187 true,

189

190 return *OwnedAdvisor;

191 }

192 assert(IAA->getAdvisor() &&

193 "Expected a present InlineAdvisorAnalysis also have an "

194 "InlineAdvisor initialized");

195 return *IAA->getAdvisor();

196}

197

199 F.dropAllReferences();

201 BB.eraseFromParent();

204}

205

209 const auto &MAMProxy =

212

213 assert(InitialC.size() > 0 && "Cannot handle an empty SCC!");

214 Module &M = *InitialC.begin()->getFunction().getParent();

216

219 .getManager();

220

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

246

247

248

250

251

252 for (auto &N : InitialC) {

253 auto &ORE =

255

256

257

258

259

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

263 if (!Callee->isDeclaration())

266 using namespace ore;

268 ORE.emit([&]() {

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

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

272 << " because its definition is unavailable"

273 << setIsVerbose();

274 });

275 }

276 }

277 }

278

279

280 auto *C = &InitialC;

281

283

284 if (Calls.empty())

286

287

288

289

290

292

293

294

295

297

298

299

301

302

303

305

306

307

308 for (int I = 0; I < (int)Calls.size(); ++I) {

309

310

311

312

313 Function &F = *Calls[I].first->getCaller();

316 continue;

317

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

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

320 << "\n");

321

324 };

325

326

327

328

329 bool DidInline = false;

330 for (; I < (int)Calls.size() && Calls[I].first->getCaller() == &F; ++I) {

331 auto &P = Calls[I];

333 const int InlineHistoryID = P.second;

335

336 if (InlineHistoryID != -1 &&

338 LLVM_DEBUG(dbgs() << "Skipping inlining due to history: " << F.getName()

339 << " -> " << Callee.getName() << "\n");

341

342

344 continue;

345 }

346

347

348

349

350

351

354 LLVM_DEBUG(dbgs() << "Skipping inlining internal SCC edge from a node "

355 "previously split out of this SCC by inlining: "

356 << F.getName() << " -> " << Callee.getName() << "\n");

358 continue;

359 }

360

361 std::unique_ptr Advice =

362 Advisor.getAdvice(*CB, OnlyMandatory);

363

364

365 if (!Advice)

366 continue;

367

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

369 Advice->recordUnattemptedInlining();

370 continue;

371 }

372

373 int CBCostMult =

376 .value_or(1);

377

378

379

381 GetAssumptionCache, PSI,

384

386 *CB, IFI, true,

389 if (.isSuccess()) {

390 Advice->recordUnsuccessfulInlining(IR);

391 continue;

392 }

393

394

396

397 DidInline = true;

398 InlinedCallees.insert(&Callee);

399 ++NumInlined;

400

402 << F.getInstructionCount() << "\n");

403

404

406 int NewHistoryID = InlineHistory.size();

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

408

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

412 "Intrinsic calls should not be tracked.");

413 if (!NewCallee) {

414

415

416

417

419 NewCallee = ICB->getCalledFunction();

420 }

421 if (NewCallee) {

423 Calls.push_back({ICB, NewHistoryID});

424

425

426

427

428

429

430

431

432

433 if (CalleeSCC != C &&

434 CalleeSCC == CG.lookupSCC(CG.get(*NewCallee))) {

436 M.getContext(),

439 ICB->addFnAttr(NewCBCostMult);

440 }

441 }

442 }

443 }

444 }

445

446

447

448

449

450

451 bool CalleeWasDeleted = false;

452 if (Callee.isDiscardableIfUnused() && Callee.hasZeroLiveUses() &&

454 if (Callee.hasLocalLinkage() || !Callee.hasComdat()) {

456 std::remove_if(Calls.begin() + I + 1, Calls.end(),

457 [&](const std::pair<CallBase *, int> &Call) {

458 return Call.first->getCaller() == &Callee;

459 }),

460 Calls.end());

461

462

463

464 Advice->recordInliningWithCalleeDeleted();

465

466

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

470 DeadFunctions.push_back(&Callee);

471 CalleeWasDeleted = true;

472 } else {

473 DeadFunctionsInComdats.push_back(&Callee);

474 }

475 }

476 if (!CalleeWasDeleted)

477 Advice->recordInlining();

478 }

479

480

481

482 --I;

483

484 if (!DidInline)

485 continue;

487

488

489

490

491

492

493

494

495

496

497

498

501 LLVM_DEBUG(dbgs() << "Updated inlining SCC: " << *C << "\n");

502

503

504

505

506

507

508

509

510

511

512

513

514

515

516

517

518

519

520

521

522

523 if ((C != OldC || UR.CWorklist.count(OldC)) &&

525 return CG.lookupSCC(*CG.lookup(*Callee)) == OldC;

526 })) {

527 LLVM_DEBUG(dbgs() << "Inlined an internal call edge and split an SCC, "

528 "retaining this to avoid infinite inlining.\n");

530 }

531 InlinedCallees.clear();

532

533

534

536 }

537

538

539

540 if (!DeadFunctionsInComdats.empty()) {

542 for (auto *Callee : DeadFunctionsInComdats)

544 DeadFunctions.append(DeadFunctionsInComdats);

545 }

546

547

548

549

550

551

552

553

554 for (Function *DeadF : DeadFunctions) {

556

557

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

560 AM.clear(DeadC, DeadC.getName());

561

562

563

565

567

568 ++NumDeleted;

569 }

570

573

575

576

578

580 return PA;

581}

582

584 bool MandatoryFirst,

587 unsigned MaxDevirtIterations)

588 : Params(Params), IC(IC), Mode(Mode),

589 MaxDevirtIterations(MaxDevirtIterations) {

590

591

592

593

594

595 if (MandatoryFirst) {

596 PM.addPass(InlinerPass( true));

599 }

603}

604

608 if (!IAA.tryCreate(Params, Mode,

609 {CGSCCInlineReplayFile,

610 CGSCCInlineReplayScope,

611 CGSCCInlineReplayFallback,

612 {CGSCCInlineReplayFormat}},

613 IC)) {

614 M.getContext().emitError(

615 "Could not setup Inlining Advisor for the requested "

616 "mode and/or options");

618 }

619

620

621

622

623

624

625

626

629 else

632

633 MPM.addPass(std::move(AfterCGMPM));

635

636

637

641 return PA;

642}

643

647 OS, MapClassName2PassName);

648 if (OnlyMandatory)

649 OS << "";

650}

651

654

655

656

657 if (!MPM.isEmpty()) {

658 MPM.printPipeline(OS, MapClassName2PassName);

659 OS << ',';

660 }

661 OS << "cgscc(";

662 if (MaxDevirtIterations != 0)

663 OS << "devirt<" << MaxDevirtIterations << ">(";

664 PM.printPipeline(OS, MapClassName2PassName);

665 if (MaxDevirtIterations != 0)

666 OS << ')';

667 OS << ')';

668}

assert(UImm &&(UImm !=~static_cast< T >(0)) &&"Invalid immediate!")

Expand Atomic instructions

This file contains the simple types necessary to represent the attributes associated with functions a...

This is the interface for LLVM's primary stateless and local alias analysis.

This header provides classes for managing passes over SCCs of the call graph.

#define clEnumValN(ENUMVAL, FLAGNAME, DESC)

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

This header defines various interfaces for pass management in LLVM.

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:147

static cl::opt< ReplayInlinerSettings::Scope > CGSCCInlineReplayScope("cgscc-inline-replay-scope", cl::init(ReplayInlinerSettings::Scope::Function), cl::values(clEnumValN(ReplayInlinerSettings::Scope::Function, "Function", "Replay on functions that have remarks associated " "with them (default)"), clEnumValN(ReplayInlinerSettings::Scope::Module, "Module", "Replay on the entire module")), cl::desc("Whether inline replay should be applied to the entire " "Module or just the Functions (default) that are present as " "callers in remarks during cgscc inlining."), cl::Hidden)

static cl::opt< bool > KeepAdvisorForPrinting("keep-inline-advisor-for-printing", cl::init(false), cl::Hidden)

A flag for test, so we can print the content of the advisor when running it as part of the default (e...

static cl::opt< std::string > CGSCCInlineReplayFile("cgscc-inline-replay", cl::init(""), cl::value_desc("filename"), cl::desc("Optimization remarks file containing inline remarks to be replayed " "by cgscc inlining."), cl::Hidden)

static cl::opt< bool > EnablePostSCCAdvisorPrinting("enable-scc-inline-advisor-printing", cl::init(false), cl::Hidden)

Allows printing the contents of the advisor after each SCC inliner pass.

static cl::opt< int > IntraSCCCostMultiplier("intra-scc-cost-multiplier", cl::init(2), cl::Hidden, cl::desc("Cost multiplier to multiply onto inlined call sites where the " "new call was previously an intra-SCC call (not relevant when the " "original call was already intra-SCC). This can accumulate over " "multiple inlinings (e.g. if a call site already had a cost " "multiplier and one of its inlined calls was also subject to " "this, the inlined call would have the original multiplier " "multiplied by intra-scc-cost-multiplier). This is to prevent tons of " "inlining through a child SCC which can cause terrible compile times"))

static cl::opt< CallSiteFormat::Format > CGSCCInlineReplayFormat("cgscc-inline-replay-format", cl::init(CallSiteFormat::Format::LineColumnDiscriminator), cl::values(clEnumValN(CallSiteFormat::Format::Line, "Line", ""), clEnumValN(CallSiteFormat::Format::LineColumn, "LineColumn", ":"), clEnumValN(CallSiteFormat::Format::LineDiscriminator, "LineDiscriminator", "."), clEnumValN(CallSiteFormat::Format::LineColumnDiscriminator, "LineColumnDiscriminator", ":. (default)")), cl::desc("How cgscc inline replay file is formatted"), cl::Hidden)

void makeFunctionBodyUnreachable(Function &F)

Definition Inliner.cpp:198

static cl::opt< ReplayInlinerSettings::Fallback > CGSCCInlineReplayFallback("cgscc-inline-replay-fallback", cl::init(ReplayInlinerSettings::Fallback::Original), cl::values(clEnumValN(ReplayInlinerSettings::Fallback::Original, "Original", "All decisions not in replay send to original advisor (default)"), clEnumValN(ReplayInlinerSettings::Fallback::AlwaysInline, "AlwaysInline", "All decisions not in replay are inlined"), clEnumValN(ReplayInlinerSettings::Fallback::NeverInline, "NeverInline", "All decisions not in replay are not inlined")), cl::desc("How cgscc inline replay treats sites that don't come from the replay. " "Original: defers to original advisor, AlwaysInline: inline all sites " "not in replay, NeverInline: inline no sites not in replay"), cl::Hidden)

Implements a lazy call graph analysis and related passes for the new pass manager.

Legalize the Machine IR a function s Machine IR

FunctionAnalysisManager FAM

ModuleAnalysisManager MAM

This file provides a priority worklist.

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

This file implements a set that has insertion order iteration characteristics.

This file defines the SmallPtrSet class.

This file defines the SmallVector class.

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

#define STATISTIC(VARNAME, DESC)

A manager for alias analyses.

This templated class represents "all analyses that operate over " (e....

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

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

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.

A function analysis which provides an AssumptionCache.

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

Functions, function parameters, and return types can have attributes to indicate how they should be t...

static LLVM_ABI Attribute get(LLVMContext &Context, AttrKind Kind, uint64_t Val=0)

Return a uniquified Attribute object.

LLVM Basic Block Representation.

static BasicBlock * Create(LLVMContext &Context, const Twine &Name="", Function *Parent=nullptr, BasicBlock *InsertBefore=nullptr)

Creates a new BasicBlock.

Analysis pass which computes BlockFrequencyInfo.

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

Function * getCalledFunction() const

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

LLVM_ABI Function * getCaller()

Helper to get the caller (the parent function).

A proxy from a FunctionAnalysisManager to an SCC.

bool isIntrinsic() const

isIntrinsic - Returns true if the function's name starts with "llvm.".

LLVM_ABI bool isDeclaration() const

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

Printer pass for the InlineAdvisorAnalysis results.

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

Result run(Module &M, ModuleAnalysisManager &MAM)

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

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

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

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

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

std::unique_ptr< InlineAdvice > getAdvice(CallBase &CB, bool MandatoryOnly=false)

Get an InlineAdvice containing a recommendation on whether to inline or not.

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

SmallVector< CallBase *, 8 > InlinedCallSites

All of the new call sites inlined into the caller.

InlineResult is basically true or false.

The inliner pass for the new pass manager.

LLVM_ABI void printPipeline(raw_ostream &OS, function_ref< StringRef(StringRef)> MapClassName2PassName)

Definition Inliner.cpp:644

LLVM_ABI PreservedAnalyses run(LazyCallGraph::SCC &C, CGSCCAnalysisManager &AM, LazyCallGraph &CG, CGSCCUpdateResult &UR)

Definition Inliner.cpp:206

A node in the call graph.

An SCC of the call graph.

A lazily constructed view of the call graph of a module.

bool isLibFunction(Function &F) const

Test whether a function is a known and defined library function tracked by the call graph.

LLVM_ABI void markDeadFunction(Function &F)

Mark a function as dead to be removed later by removeDeadFunctions().

Node & get(Function &F)

Get a graph node for a given function, scanning it to populate the graph data as necessary.

SCC * lookupSCC(Node &N) const

Lookup a function's SCC in the graph.

Node * lookup(const Function &F) const

Lookup a function in the graph which has already been scanned and added.

LLVM_ABI PreservedAnalyses run(Module &, ModuleAnalysisManager &)

Definition Inliner.cpp:605

LLVM_ABI void printPipeline(raw_ostream &OS, function_ref< StringRef(StringRef)> MapClassName2PassName)

Definition Inliner.cpp:652

LLVM_ABI ModuleInlinerWrapperPass(InlineParams Params=getInlineParams(), bool MandatoryFirst=true, InlineContext IC={}, InliningAdvisorMode Mode=InliningAdvisorMode::Default, unsigned MaxDevirtIterations=0)

Definition Inliner.cpp:583

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 none()

Convenience factory function for the empty preserved set.

static PreservedAnalyses all()

Construct a special preserved set that preserves all passes.

PreservedAnalyses & preserveSet()

Mark an analysis set as preserved.

PreservedAnalyses & preserve()

Mark an analysis as preserved.

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

Analysis providing profile information.

void clear()

Completely clear the SetVector.

bool insert(const value_type &X)

Insert a new element into the SetVector.

A SetVector that performs no allocations if smaller than a certain size.

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

iterator erase(const_iterator CI)

void append(ItTy in_start, ItTy in_end)

Add the specified range to the end of the SmallVector.

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.

This function has undefined behavior.

An efficient, type-erasing, non-owning reference to a callable.

This class implements an extremely fast bulk output stream that can only output to a stream.

@ C

The default llvm calling convention, compatible with C.

const char FunctionInlineCostMultiplierAttributeName[]

ValuesClass values(OptsTy... Options)

Helper to build a ValuesClass by forwarding a variable number of arguments as an initializer list to ...

initializer< Ty > init(const Ty &Val)

Add a small namespace to avoid name clashes with the classes used in the streaming interface.

This is an optimization pass for GlobalISel generic memory operations.

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

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

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

decltype(auto) dyn_cast(const From &Val)

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

InliningAdvisorMode

There are 4 scenarios we can use the InlineAdvisor:

LLVM_ABI std::optional< int > getStringFnAttrAsInt(CallBase &CB, StringRef AttrKind)

DevirtSCCRepeatedPass createDevirtSCCRepeatedPass(CGSCCPassT &&Pass, int MaxIterations)

A function to deduce a function pass type and wrap it in the templated adaptor.

LLVM_ABI LazyCallGraph::SCC & updateCGAndAnalysisManagerForCGSCCPass(LazyCallGraph &G, LazyCallGraph::SCC &C, LazyCallGraph::Node &N, CGSCCAnalysisManager &AM, CGSCCUpdateResult &UR, FunctionAnalysisManager &FAM)

Helper to update the call graph after running a CGSCC pass.

iterator_range< early_inc_iterator_impl< detail::IterOfRange< RangeT > > > make_early_inc_range(RangeT &&Range)

Make a range that does early increment to allow mutation of the underlying range without disrupting i...

LLVM_ABI void setInlineRemark(CallBase &CB, StringRef Message)

Set the inline-remark attribute.

AnalysisManager< LazyCallGraph::SCC, LazyCallGraph & > CGSCCAnalysisManager

The CGSCC analysis manager.

bool any_of(R &&range, UnaryPredicate P)

Provide wrappers to std::any_of which take ranges instead of having to pass begin/end explicitly.

ModuleToPostOrderCGSCCPassAdaptor createModuleToPostOrderCGSCCPassAdaptor(CGSCCPassT &&Pass)

A function to deduce a function pass type and wrap it in the templated adaptor.

auto reverse(ContainerTy &&C)

LLVM_ABI raw_ostream & dbgs()

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

std::unique_ptr< InlineAdvisor > getReplayInlineAdvisor(Module &M, FunctionAnalysisManager &FAM, LLVMContext &Context, std::unique_ptr< InlineAdvisor > OriginalAdvisor, const ReplayInlinerSettings &ReplaySettings, bool EmitRemarks, InlineContext IC)

bool isa(const From &Val)

isa - Return true if the parameter to the template is an instance of one of the template type argu...

OuterAnalysisManagerProxy< ModuleAnalysisManager, LazyCallGraph::SCC, LazyCallGraph & > ModuleAnalysisManagerCGSCCProxy

A proxy from a ModuleAnalysisManager to an SCC.

LLVM_ABI InlineParams getInlineParams()

Generate the parameters to tune the inline cost analysis based only on the commandline options.

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

Returns true if Element is found in Range.

LLVM_ABI void filterDeadComdatFunctions(SmallVectorImpl< Function * > &DeadComdatFunctions)

Filter out potentially dead comdat functions where other entries keep the entire comdat group alive.

LLVM_ABI bool tryPromoteCall(CallBase &CB)

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

AnalysisManager< Function > FunctionAnalysisManager

Convenience typedef for the Function analysis manager.

cl::opt< unsigned > MaxDevirtIterations("max-devirt-iterations", cl::ReallyHidden, cl::init(4))

std::string itostr(int64_t X)

AnalysisManager< Module > ModuleAnalysisManager

Convenience typedef for the Module analysis manager.

Support structure for SCC passes to communicate updates the call graph back to the CGSCC pass manager...

SmallPriorityWorklist< LazyCallGraph::SCC *, 1 > & CWorklist

Worklist of the SCCs queued for processing.

SmallDenseSet< std::pair< LazyCallGraph::Node *, LazyCallGraph::SCC * >, 4 > & InlinedInternalEdges

A hacky area where the inliner can retain history about inlining decisions that mutated the call grap...

SmallVector< Function *, 4 > & DeadFunctions

Functions that a pass has considered to be dead to be removed at the end of the call graph walk in ba...

SmallPtrSetImpl< LazyCallGraph::SCC * > & InvalidatedSCCs

The set of invalidated SCCs which should be skipped if they are found in CWorklist.

@ LineColumnDiscriminator

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

Thresholds to tune inline cost analysis.

A CRTP mix-in to automatically provide informational APIs needed for passes.