CtxProfAnalysis.cpp Source File (original) (raw)

27#include

28#include

30#define DEBUG_TYPE "ctx_prof"

32using namespace llvm;

34namespace llvm {

38 cl::desc("Use the specified contextual profile file"));

41 "ctx-profile-printer-level",

44 "everything", "print everything - most verbose"),

46 "just the yaml representation of the profile")),

47 cl::desc("Verbosity level of the contextual profile printer pass."));

50 "ctx-profile-force-is-specialized", cl::init(false),

51 cl::desc("Treat the given module as-if it were containing the "

52 "post-thinlink module containing the root"));

58 class BBInfo;

59 struct EdgeInfo {

60 BBInfo *const Src;

61 BBInfo *const Dest;

62 std::optional<uint64_t> Count;

64 explicit EdgeInfo(BBInfo &Src, BBInfo &Dest) : Src(&Src), Dest(&Dest) {}

65 };

67 class BBInfo {

68 std::optional<uint64_t> Count;

76 size_t UnknownCountOutEdges = 0;

77 size_t UnknownCountInEdges = 0;

84 bool AssumeAllKnown) const {

85 std::optional<uint64_t> Sum;

86 for (const auto *E : Edges) {

88 if (E) {

89 if (!Sum.has_value())

90 Sum = 0;

91 *Sum += (AssumeAllKnown ? *E->Count : E->Count.value_or(0U));

92 }

93 }

94 return Sum;

95 }

97 bool computeCountFrom(const SmallVector<EdgeInfo *> &Edges) {

98 assert(!Count.has_value());

99 Count = getEdgeSum(Edges, true);

100 return Count.has_value();

101 }

102

103 void setSingleUnknownEdgeCount(SmallVector<EdgeInfo *> &Edges) {

104 uint64_t KnownSum = getEdgeSum(Edges, false).value_or(0U);

105 uint64_t EdgeVal = *Count > KnownSum ? *Count - KnownSum : 0U;

106 EdgeInfo *E = nullptr;

107 for (auto *I : Edges)

108 if (I && ->Count.has_value()) {

109 E = I;

110#ifdef NDEBUG

111 break;

112#else

114 "Expected exactly one edge to have an unknown count, "

115 "found a second one");

116 continue;

117#endif

118 }

119 assert(E && "Expected exactly one edge to have an unknown count");

120 assert(->Count.has_value());

121 E->Count = EdgeVal;

122 assert(E->Src->UnknownCountOutEdges > 0);

123 assert(E->Dest->UnknownCountInEdges > 0);

124 --E->Src->UnknownCountOutEdges;

125 --E->Dest->UnknownCountInEdges;

126 }

127

128 public:

129 BBInfo(size_t NumInEdges, size_t NumOutEdges, std::optional<uint64_t> Count)

130 : Count(Count) {

131

132

133

134

135

136 InEdges.reserve(NumInEdges);

137 OutEdges.resize(NumOutEdges);

138 }

139

140 bool tryTakeCountFromKnownOutEdges(const BasicBlock &BB) {

141 if (!UnknownCountOutEdges) {

142 return computeCountFrom(OutEdges);

143 }

144 return false;

145 }

146

147 bool tryTakeCountFromKnownInEdges(const BasicBlock &BB) {

148 if (!UnknownCountInEdges) {

149 return computeCountFrom(InEdges);

150 }

151 return false;

152 }

153

154 void addInEdge(EdgeInfo &Info) {

155 InEdges.push_back(&Info);

156 ++UnknownCountInEdges;

157 }

158

159

160

161

162

163 void addOutEdge(size_t Index, EdgeInfo &Info) {

165 ++UnknownCountOutEdges;

166 }

167

168 bool hasCount() const { return Count.has_value(); }

169

170 uint64_t getCount() const { return *Count; }

171

172 bool trySetSingleUnknownInEdgeCount() {

173 if (UnknownCountInEdges == 1) {

174 setSingleUnknownEdgeCount(InEdges);

175 return true;

176 }

177 return false;

178 }

179

180 bool trySetSingleUnknownOutEdgeCount() {

181 if (UnknownCountOutEdges == 1) {

182 setSingleUnknownEdgeCount(OutEdges);

183 return true;

184 }

185 return false;

186 }

187 size_t getNumOutEdges() const { return OutEdges.size(); }

188

189 uint64_t getEdgeCount(size_t Index) const {

190 if (auto *E = OutEdges[Index])

191 return *E->Count;

192 return 0U;

193 }

194 };

195

197 ArrayRef<uint64_t> Counters;

198

199 std::map<const BasicBlock *, BBInfo> BBInfos;

200 std::vector EdgeInfos;

201

202

203

204 bool shouldExcludeEdge(const BasicBlock &Src, const BasicBlock &Dest) const {

206 }

207

208 BBInfo &getBBInfo(const BasicBlock &BB) { return BBInfos.find(&BB)->second; }

209

210 const BBInfo &getBBInfo(const BasicBlock &BB) const {

211 return BBInfos.find(&BB)->second;

212 }

213

214

215

216 bool allCountersAreAssigned() const {

217 for (const auto &BBInfo : BBInfos)

218 if (!BBInfo.second.hasCount())

219 return false;

220 for (const auto &EdgeInfo : EdgeInfos)

221 if (!EdgeInfo.Count.has_value())

222 return false;

223 return true;

224 }

225

226

227

228 bool allTakenPathsExit() const {

229 std::deque<const BasicBlock *> Worklist;

230 DenseSet<const BasicBlock *> Visited;

231 Worklist.push_back(&F.getEntryBlock());

232 bool HitExit = false;

233 while (!Worklist.empty()) {

234 const auto *BB = Worklist.front();

235 Worklist.pop_front();

236 if (!Visited.insert(BB).second)

237 continue;

240 return false;

241 HitExit = true;

242 continue;

243 }

246 continue;

247 }

248 const auto &BBInfo = getBBInfo(*BB);

249 bool HasAWayOut = false;

250 for (auto I = 0U; I < BB->getTerminator()->getNumSuccessors(); ++I) {

252 if (!shouldExcludeEdge(*BB, *Succ)) {

253 if (BBInfo.getEdgeCount(I) > 0) {

254 HasAWayOut = true;

255 Worklist.push_back(Succ);

256 }

257 }

258 }

259 if (!HasAWayOut)

260 return false;

261 }

262 return HitExit;

263 }

264

265 bool allNonColdSelectsHaveProfile() const {

266 for (const auto &BB : F) {

267 if (getBBInfo(BB).getCount() > 0) {

268 for (const auto &I : BB) {

271 *const_cast<SelectInst *>(SI))) {

272 auto Index = Inst->getIndex()->getZExtValue();

273 assert(Index < Counters.size());

274 if (Counters[Index] == 0)

275 return false;

276 }

277 }

278 }

279 }

280 }

281 return true;

282 }

283

284

285

286 void propagateCounterValues() {

287 bool KeepGoing = true;

288 while (KeepGoing) {

289 KeepGoing = false;

290 for (const auto &BB : F) {

291 auto &Info = getBBInfo(BB);

292 if ( Info .hasCount())

293 KeepGoing |= Info.tryTakeCountFromKnownOutEdges(BB) ||

294 Info.tryTakeCountFromKnownInEdges(BB);

295 if (Info.hasCount()) {

296 KeepGoing |= Info.trySetSingleUnknownOutEdgeCount();

297 KeepGoing |= Info.trySetSingleUnknownInEdgeCount();

298 }

299 }

300 }

301 assert(allCountersAreAssigned() &&

302 "[ctx-prof] Expected all counters have been assigned.");

303 assert(allTakenPathsExit() &&

304 "[ctx-prof] Encountered a BB with more than one successor, where "

305 "all outgoing edges have a 0 count. This occurs in non-exiting "

306 "functions (message pumps, usually) which are not supported in the "

307 "contextual profiling case");

308 assert(allNonColdSelectsHaveProfile() &&

309 "[ctx-prof] All non-cold select instructions were expected to have "

310 "a profile.");

311 }

312

313public:

315 : F(F), Counters(Counters) {

316 assert(!F.isDeclaration());

317 assert(!Counters.empty());

318 size_t NrEdges = 0;

319 for (const auto &BB : F) {

320 std::optional<uint64_t> Count;

323 auto Index = Ins->getIndex()->getZExtValue();

324 assert(Index < Counters.size() &&

325 "The index must be inside the counters vector by construction - "

326 "tripping this assertion indicates a bug in how the contextual "

327 "profile is managed by IPO transforms");

328 (void)Index;

329 Count = Counters[Ins->getIndex()->getZExtValue()];

331

333 }

334 auto [It, Ins] =

336 (void)Ins;

337 assert(Ins && "We iterate through the function's BBs, no reason to "

338 "insert one more than once");

340 return !shouldExcludeEdge(BB, *Succ);

341 });

342 }

343

344 EdgeInfos.reserve(NrEdges);

345 for (const auto &BB : F) {

346 auto &Info = getBBInfo(BB);

347 for (auto I = 0U; I < BB.getTerminator()->getNumSuccessors(); ++I) {

348 const auto *Succ = BB.getTerminator()->getSuccessor(I);

349 if (!shouldExcludeEdge(BB, *Succ)) {

350 auto &EI = EdgeInfos.emplace_back(getBBInfo(BB), getBBInfo(*Succ));

351 Info.addOutEdge(I, EI);

352 getBBInfo(*Succ).addInEdge(EI);

353 }

354 }

355 }

356 assert(EdgeInfos.capacity() == NrEdges &&

357 "The capacity of EdgeInfos should have stayed unchanged it was "

358 "populated, because we need pointers to its contents to be stable");

359 propagateCounterValues();

360 }

361

363};

364

365}

366

370

372

374 return PImpl->getBBCount(BB);

375}

376

379 uint64_t &FalseCount) const {

380 const auto &BBInfo = PImpl->getBBInfo(*SI.getParent());

381 TrueCount = FalseCount = 0;

382 if (BBInfo.getCount() == 0)

383 return false;

384

386 if (!Step)

387 return false;

388 auto Index = Step->getIndex()->getZExtValue();

390 "The index of the step instruction must be inside the "

391 "counters vector by "

392 "construction - tripping this assertion indicates a bug in "

393 "how the contextual profile is managed by IPO transforms");

394 auto TotalCount = BBInfo.getCount();

395 TrueCount = PImpl->Counters[Index];

396 FalseCount = (TotalCount > TrueCount ? TotalCount - TrueCount : 0U);

397 return true;

398}

399

404

406 return false;

407

409 Profile.resize(Term->getNumSuccessors());

410

411 const auto &BBInfo = PImpl->getBBInfo(BB);

412 MaxCount = 0;

413 for (unsigned SuccIdx = 0, Size = BBInfo.getNumOutEdges(); SuccIdx < Size;

414 ++SuccIdx) {

415 uint64_t EdgeCount = BBInfo.getEdgeCount(SuccIdx);

416 if (EdgeCount > MaxCount)

417 MaxCount = EdgeCount;

418 Profile[SuccIdx] = EdgeCount;

419 }

420 return MaxCount > 0;

421}

422

424 for (auto &F : M.functions()) {

425 if (F.isDeclaration())

426 continue;

428 continue;

432 {ConstantAsMetadata::get(ConstantInt::get(

433 Type::getInt64Ty(M.getContext()), GUID))}));

434 }

436}

437

439 if (F.isDeclaration()) {

441 return F.getGUID();

442 }

444 assert(MD && "guid not found for defined function");

446 ->getValue()

447 ->stripPointerCasts())

448 ->getZExtValue();

449}

451

453 : Profile([&]() -> std::optional<StringRef> {

454 if (Profile)

455 return *Profile;

458 return std::nullopt;

459 }()) {}

460

463 if (!Profile)

464 return {};

466 if (auto EC = MB.getError()) {

467 M.getContext().emitError("could not open contextual profile file: " +

468 EC.message());

469 return {};

470 }

473 if (!MaybeProfiles) {

474 M.getContext().emitError("contextual profile file is invalid: " +

475 toString(MaybeProfiles.takeError()));

476 return {};

477 }

478

479

480

481

482

485 auto ModName = M.getName();

487

488 Filename = Filename.substr(0, Filename.find_last_of('.'));

489

491

492

493 if (!Filename.getAsInteger(0, Guid))

494 ProfileRootsInModule.insert(Guid.getZExtValue());

495 return ProfileRootsInModule;

496 };

497 const auto ProfileRootsInModule = DetermineRootsInModule();

499

500

501

502

503

504 if (!ProfileRootsInModule.empty()) {

505 Result.IsInSpecializedModule = true;

506

507 for (auto &[RootGuid, _] :

509 if (!ProfileRootsInModule.contains(RootGuid))

510 MaybeProfiles->Contexts.erase(RootGuid);

511

512 MaybeProfiles->FlatProfiles.clear();

513 }

514

515 for (const auto &F : M) {

516 if (F.isDeclaration())

517 continue;

519 assert(GUID && "guid not found for defined function");

520 const auto &Entry = F.begin();

521 uint32_t MaxCounters = 0;

522 for (const auto &I : *Entry)

524 MaxCounters =

525 static_cast<uint32_t>(C->getNumCounters()->getZExtValue());

526 break;

527 }

528 if (!MaxCounters)

529 continue;

531 for (const auto &BB : F)

532 for (const auto &I : BB)

534 MaxCallsites =

535 static_cast<uint32_t>(C->getNumCounters()->getZExtValue());

536 break;

537 }

538 auto [It, Ins] = Result.FuncInfo.insert(

539 {GUID, PGOContextualProfile::FunctionInfo(F.getName())});

540 (void)Ins;

542 It->second.NextCallsiteIndex = MaxCallsites;

543 It->second.NextCounterIndex = MaxCounters;

544 }

545

546

547 Result.Profiles = std::move(*MaybeProfiles);

550}

551

553PGOContextualProfile::getDefinedFunctionGUID(const Function &F) const {

555 return It->first;

556 return 0;

557}

558

561

565 if (C.contexts().empty()) {

566 OS << "No contextual profile was provided.\n";

568 }

569

571 OS << "Function Info:\n";

572 for (const auto &[Guid, FuncInfo] : C.FuncInfo)

573 OS << Guid << " : " << FuncInfo.Name

574 << ". MaxCounterID: " << FuncInfo.NextCounterIndex

575 << ". MaxCallsiteID: " << FuncInfo.NextCallsiteIndex << "\n";

576 }

577

579 OS << "\nCurrent Profile:\n";

581 OS << "\n";

584

585 OS << "\nFlat Profile:\n";

586 auto Flat = C.flatten();

588 OS << Guid << " : ";

590 OS << V << " ";

591 OS << "\n";

592 }

594}

595

598 return nullptr;

601 return IPC;

603 "didn't expect to find another call, that's not the callsite "

604 "instrumentation, before an instrumentable callsite");

605 }

606 return nullptr;

607}

608

610 for (auto &I : BB)

613 return Incr;

614 return nullptr;

615}

616

622 return Step;

623 return nullptr;

624}

625

626template

629 std::function<void(ProfTy &)> Traverser = [&](auto &Ctx) {

630 Visitor(Ctx);

631 for (auto &[_, SubCtxSet] : Ctx.callsites())

632 for (auto &[__, Subctx] : SubCtxSet)

633 Traverser(Subctx);

634 };

636}

637

638template <class ProfilesTy, class ProfTy>

641 for (auto &[_, P] : Profiles)

643}

644

645void PGOContextualProfile::initIndex() {

646

647

648 DenseMap<GlobalValue::GUID, PGOCtxProfContext *> InsertionPoints;

649 for (auto &[Guid, FI] : FuncInfo)

650 InsertionPoints[Guid] = &FI.Index;

652 Profiles.Contexts, [&](PGOCtxProfContext &Ctx) {

653 auto InsertIt = InsertionPoints.find(Ctx.guid());

654 if (InsertIt == InsertionPoints.end())

655 return;

656

657

658

659

660 InsertIt->second->Next = &Ctx;

661 Ctx.Previous = InsertIt->second;

662 InsertIt->second = &Ctx;

663 });

664}

665

669 : IsInSpecializedModule;

670}

671

675 for (auto *Node = FuncInfo.find(G)->second.Index.Next; Node;

678}

679

681 if ()

686 for (const auto *Node = FuncInfo.find(G)->second.Index.Next; Node;

689}

690

696 if (Into.empty())

699 "All contexts corresponding to a function should have the exact "

700 "same number of counters.");

701 for (size_t I = 0, E = Into.size(); I < E; ++I)

702 Into[I] += From[I] * SamplingRate;

703 };

704

705 for (const auto &[_, CtxRoot] : Profiles.Contexts) {

706 const uint64_t SamplingFactor = CtxRoot.getTotalRootEntryCount();

709 Accummulate(Flat[Ctx.guid()], Ctx.counters(), SamplingFactor);

710 });

711

712 for (const auto &[G, Unh] : CtxRoot.getUnhandled())

713 Accummulate(Flat[G], Unh, SamplingFactor);

714 }

715

716 for (const auto &[G, FC] : Profiles.FlatProfiles)

717 Accummulate(Flat[G], FC, 1);

718 return Flat;

719}

720

724 for (const auto &[_, CtxRoot] : Profiles.Contexts) {

728 auto &Targets = Ret[Ctx.guid()];

729 for (const auto &[ID, SubctxSet] : Ctx.callsites())

730 for (const auto &Subctx : SubctxSet)

731 Targets[ID][Subctx.first] +=

733 });

734 }

735 return Ret;

736}

737

740 SetVector<std::pair<CallBase *, Function *>> &Candidates) {

742 if (!Instr)

743 return;

745 const uint32_t CallID = Instr->getIndex()->getZExtValue();

746 Profile.visit(

748 const auto &Targets = Ctx.callsites().find(CallID);

749 if (Targets == Ctx.callsites().end())

750 return;

751 for (const auto &[Guid, _] : Targets->second)

752 if (auto Name = Profile.getFunctionName(Guid); !Name.empty())

753 if (auto *Target = M.getFunction(Name))

754 if (Target->hasFnAttribute(Attribute::AlwaysInline))

755 Candidates.insert({&IC, Target});

756 },

758}

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

This file implements a class to represent arbitrary precision integral constant values and operations...

static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")

Analysis containing CSE Info

#define clEnumValN(ENUMVAL, FLAGNAME, DESC)

static void preorderVisit(ProfilesTy &Profiles, function_ref< void(ProfTy &)> Visitor)

Definition CtxProfAnalysis.cpp:639

static void preorderVisitOneRoot(ProfTy &Profile, function_ref< void(ProfTy &)> Visitor)

Definition CtxProfAnalysis.cpp:627

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

This header defines various interfaces for pass management in LLVM.

Reader for contextual iFDO profile, which comes in bitstream format.

ModuleAnalysisManager MAM

Class for arbitrary precision integers.

ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory),...

static LLVM_ABI uint64_t getGUID(const Function &F)

Definition CtxProfAnalysis.cpp:438

LLVM_ABI PreservedAnalyses run(Module &M, ModuleAnalysisManager &MAM)

Assign a GUID if one is not already assign, as a function metadata named GUIDMetadataName.

Definition CtxProfAnalysis.cpp:423

static LLVM_ABI const char * GUIDMetadataName

LLVM Basic Block Representation.

LLVM_ABI const BasicBlock * getUniqueSuccessor() const

Return the successor of this block if it has a unique successor.

const Instruction & front() const

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...

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

LLVM_ABI Function * getCaller()

Helper to get the caller (the parent function).

LLVM_ABI PreservedAnalyses run(Module &M, ModuleAnalysisManager &MAM)

Definition CtxProfAnalysis.cpp:562

LLVM_ABI CtxProfAnalysisPrinterPass(raw_ostream &OS)

Definition CtxProfAnalysis.cpp:559

LLVM_ABI PGOContextualProfile run(Module &M, ModuleAnalysisManager &MAM)

Definition CtxProfAnalysis.cpp:461

static LLVM_ABI InstrProfIncrementInst * getBBInstrumentation(BasicBlock &BB)

Get the instruction instrumenting a BB, or nullptr if not present.

Definition CtxProfAnalysis.cpp:609

static LLVM_ABI InstrProfIncrementInstStep * getSelectInstrumentation(SelectInst &SI)

Get the step instrumentation associated with a select

Definition CtxProfAnalysis.cpp:618

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

Definition CtxProfAnalysis.cpp:738

static LLVM_ABI InstrProfCallsite * getCallsiteInstrumentation(CallBase &CB)

Get the instruction instrumenting a callsite, or nullptr if that cannot be found.

Definition CtxProfAnalysis.cpp:596

static LLVM_ABI AnalysisKey Key

PGOContextualProfile Result

LLVM_ABI CtxProfAnalysis(std::optional< StringRef > Profile=std::nullopt)

Definition CtxProfAnalysis.cpp:452

Implements a dense probed hash-table based set.

Represents either an error or a value T.

std::error_code getError() const

uint64_t GUID

Declare a type to represent a global unique identifier for a global value.

static bool isExternalLinkage(LinkageTypes Linkage)

This represents the llvm.instrprof.callsite intrinsic.

static bool canInstrumentCallsite(const CallBase &CB)

This represents the llvm.instrprof.increment.step intrinsic.

This represents the llvm.instrprof.increment intrinsic.

LLVM_ABI BasicBlock * getSuccessor(unsigned Idx) const LLVM_READONLY

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

static MDTuple * get(LLVMContext &Context, ArrayRef< Metadata * > MDs)

static ErrorOr< std::unique_ptr< MemoryBuffer > > getFile(const Twine &Filename, bool IsText=false, bool RequiresNullTerminator=true, bool IsVolatile=false, std::optional< Align > Alignment=std::nullopt)

Open the specified file as a MemoryBuffer, returning a new MemoryBuffer if successful,...

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

The instrumented contextual profile, produced by the CtxProfAnalysis.

LLVM_ABI void visit(ConstVisitor, const Function *F=nullptr) const

Definition CtxProfAnalysis.cpp:680

LLVM_ABI const CtxProfFlatProfile flatten() const

Definition CtxProfAnalysis.cpp:691

LLVM_ABI bool isInSpecializedModule() const

Definition CtxProfAnalysis.cpp:666

LLVM_ABI void update(Visitor, const Function &F)

Definition CtxProfAnalysis.cpp:672

function_ref< void(PGOCtxProfContext &)> Visitor

function_ref< void(const PGOCtxProfContext &)> ConstVisitor

LLVM_ABI const CtxProfFlatIndirectCallProfile flattenVirtCalls() const

Definition CtxProfAnalysis.cpp:722

bool isFunctionKnown(const Function &F) const

A node (context) in the loaded contextual profile, suitable for mutation during IPO passes.

std::map< GlobalValue::GUID, PGOCtxProfContext > CallTargetMapTy

LLVM_ABI Expected< PGOCtxProfile > loadProfiles()

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.

Definition CtxProfAnalysis.cpp:56

uint64_t getBBCount(const BasicBlock &BB)

Definition CtxProfAnalysis.cpp:362

ProfileAnnotatorImpl(const Function &F, ArrayRef< uint64_t > Counters)

Definition CtxProfAnalysis.cpp:314

friend class ProfileAnnotator

Definition CtxProfAnalysis.cpp:57

LLVM_ABI ~ProfileAnnotator()

LLVM_ABI bool getSelectInstrProfile(SelectInst &SI, uint64_t &TrueCount, uint64_t &FalseCount) const

Definition CtxProfAnalysis.cpp:377

LLVM_ABI bool getOutgoingBranchWeights(BasicBlock &BB, SmallVectorImpl< uint64_t > &Profile, uint64_t &MaxCount) const

Definition CtxProfAnalysis.cpp:400

LLVM_ABI uint64_t getBBCount(const BasicBlock &BB) const

Definition CtxProfAnalysis.cpp:373

LLVM_ABI ProfileAnnotator(const Function &F, ArrayRef< uint64_t > RawCounters)

Definition CtxProfAnalysis.cpp:367

This class represents the LLVM 'select' instruction.

A vector that has set insertion semantics.

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

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.

Target - Wrapper for Target specific information.

std::pair< iterator, bool > insert(const ValueT &V)

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

const ParentTy * getParent() const

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

Pass manager infrastructure for declaring and invalidating analyses.

unsigned ID

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

@ C

The default llvm calling convention, compatible with C.

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)

LLVM_ABI StringRef filename(StringRef path LLVM_LIFETIME_BOUND, Style style=Style::native)

Get filename.

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.

std::map< GlobalValue::GUID, SmallVector< uint64_t, 1 > > CtxProfFlatProfile

static cl::opt< bool > ForceIsInSpecializedModule("ctx-profile-force-is-specialized", cl::init(false), cl::desc("Treat the given module as-if it were containing the " "post-thinlink module containing the root"))

auto successors(const MachineBasicBlock *BB)

cl::opt< std::string > UseCtxProfile("use-ctx-profile", cl::init(""), cl::Hidden, cl::desc("Use the specified contextual profile file"))

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...

auto pred_size(const MachineBasicBlock *BB)

FunctionAddr VTableAddr Count

auto succ_size(const MachineBasicBlock *BB)

bool isa(const From &Val)

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

std::string toString(const APInt &I, unsigned Radix, bool Signed, bool formatAsCLiteral=false, bool UpperCase=true, bool InsertSeparators=false)

auto count_if(R &&Range, UnaryPredicate P)

Wrapper function around std::count_if to count the number of times an element satisfying a given pred...

DenseMap< GlobalValue::GUID, DenseMap< uint32_t, FlatIndirectTargets > > CtxProfFlatIndirectCallProfile

LLVM_ABI bool isPresplitCoroSuspendExitEdge(const BasicBlock &Src, const BasicBlock &Dest)

decltype(auto) cast(const From &Val)

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

static cl::opt< CtxProfAnalysisPrinterPass::PrintMode > PrintLevel("ctx-profile-printer-level", cl::init(CtxProfAnalysisPrinterPass::PrintMode::YAML), cl::Hidden, cl::values(clEnumValN(CtxProfAnalysisPrinterPass::PrintMode::Everything, "everything", "print everything - most verbose"), clEnumValN(CtxProfAnalysisPrinterPass::PrintMode::YAML, "yaml", "just the yaml representation of the profile")), cl::desc("Verbosity level of the contextual profile printer pass."))

LLVM_ABI void convertCtxProfToYaml(raw_ostream &OS, const PGOCtxProfile &Profile)

AnalysisManager< Module > ModuleAnalysisManager

Convenience typedef for the Module analysis manager.

Implement std::hash so that hash_code can be used in STL containers.

A special type used by analysis passes to provide an address that identifies that particular analysis...