Movatterモバイル変換

Go to the documentation of this file.

1//===- ModuleSummaryAnalysis.cpp - Module summary index builder -----------===//

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 pass builds a ModuleSummaryIndex object for the module, to be written

10// to bitcode or LLVM assembly.

11//

12//===----------------------------------------------------------------------===//

14#include "llvm/Analysis/ModuleSummaryAnalysis.h"

15#include "llvm/ADT/ArrayRef.h"

16#include "llvm/ADT/DenseSet.h"

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

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

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

20#include "llvm/ADT/SmallPtrSet.h"

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

22#include "llvm/ADT/StringRef.h"

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

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

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

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

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

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

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

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

31#include "llvm/Analysis/TypeMetadataUtils.h"

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

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

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

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

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

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

38#include "llvm/IR/GlobalAlias.h"

39#include "llvm/IR/GlobalValue.h"

40#include "llvm/IR/GlobalVariable.h"

41#include "llvm/IR/Instructions.h"

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

43#include "llvm/IR/Metadata.h"

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

45#include "llvm/IR/ModuleSummaryIndex.h"

46#include "llvm/IR/Use.h"

47#include "llvm/IR/User.h"

48#include "llvm/InitializePasses.h"

49#include "llvm/Object/ModuleSymbolTable.h"

50#include "llvm/Object/SymbolicFile.h"

51#include "llvm/Pass.h"

52#include "llvm/Support/Casting.h"

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

54#include "llvm/Support/FileSystem.h"

55#include <cassert>

56#include <cstdint>

57#include <vector>

59using namespacellvm;

60using namespacellvm::memprof;

62#define DEBUG_TYPE "module-summary-analysis"

64// Option to force edges cold which will block importing when the

65// -import-cold-multiplier is set to 0. Useful for debugging.

66namespacellvm {

67FunctionSummary::ForceSummaryHotnessType ForceSummaryEdgesCold =

68FunctionSummary::FSHT_None;

69}// namespace llvm

71staticcl::opt<FunctionSummary::ForceSummaryHotnessType, true>FSEC(

72"force-summary-edges-cold",cl::Hidden,cl::location(ForceSummaryEdgesCold),

73cl::desc("Force all edges in the function summary to cold"),

74cl::values(clEnumValN(FunctionSummary::FSHT_None,"none","None."),

75clEnumValN(FunctionSummary::FSHT_AllNonCritical,

76"all-non-critical","All non-critical edges."),

77clEnumValN(FunctionSummary::FSHT_All,"all","All edges.")));

79staticcl::opt<std::string>ModuleSummaryDotFile(

80"module-summary-dot-file",cl::Hidden,cl::value_desc("filename"),

81cl::desc("File to emit dot graph of new summary into"));

83staticcl::opt<bool>EnableMemProfIndirectCallSupport(

84"enable-memprof-indirect-call-support",cl::init(false),cl::Hidden,

85cl::desc(

86"Enable MemProf support for summarizing and cloning indirect calls"));

88externcl::opt<bool>ScalePartialSampleProfileWorkingSetSize;

90externcl::opt<unsigned>MaxNumVTableAnnotations;

92externcl::opt<bool>MemProfReportHintedSizes;

94// Walk through the operands of a given User via worklist iteration and populate

95// the set of GlobalValue references encountered. Invoked either on an

96// Instruction or a GlobalVariable (which walks its initializer).

97// Return true if any of the operands contains blockaddress. This is important

98// to know when computing summary for global var, because if global variable

99// references basic block address we can't import it separately from function

100// containing that basic block. For simplicity we currently don't import such

101// global vars at all. When importing function we aren't interested if any

102// instruction in it takes an address of any basic block, because instruction

103// can only take an address of basic block located in the same function.

104// Set `RefLocalLinkageIFunc` to true if the analyzed value references a

105// local-linkage ifunc.

106staticbool

107findRefEdges(ModuleSummaryIndex &Index,constUser *CurUser,

108SetVector<ValueInfo,SmallVector<ValueInfo, 0>> &RefEdges,

109SmallPtrSet<const User *, 8> &Visited,

110bool &RefLocalLinkageIFunc) {

111bool HasBlockAddress =false;

112SmallVector<const User *, 32> Worklist;

113if (Visited.insert(CurUser).second)

114 Worklist.push_back(CurUser);

115

116while (!Worklist.empty()) {

117constUser *U = Worklist.pop_back_val();

118constauto *CB = dyn_cast<CallBase>(U);

119

120for (constauto &OI : U->operands()) {

121constUser *Operand = dyn_cast<User>(OI);

122if (!Operand)

123continue;

124if (isa<BlockAddress>(Operand)) {

125 HasBlockAddress =true;

126continue;

127 }

128if (auto *GV = dyn_cast<GlobalValue>(Operand)) {

129// We have a reference to a global value. This should be added to

130// the reference set unless it is a callee. Callees are handled

131// specially by WriteFunction and are added to a separate list.

132if (!(CB && CB->isCallee(&OI))) {

133// If an ifunc has local linkage, do not add it into ref edges, and

134// sets `RefLocalLinkageIFunc` to true. The referencer is not eligible

135// for import. An ifunc doesn't have summary and ThinLTO cannot

136// promote it; importing the referencer may cause linkage errors.

137if (auto *GI = dyn_cast_if_present<GlobalIFunc>(GV);

138 GI && GI->hasLocalLinkage()) {

139 RefLocalLinkageIFunc =true;

140continue;

141 }

142 RefEdges.insert(Index.getOrInsertValueInfo(GV));

143 }

144continue;

145 }

146if (Visited.insert(Operand).second)

147 Worklist.push_back(Operand);

148 }

149 }

150

151constInstruction *I = dyn_cast<Instruction>(CurUser);

152if (I) {

153uint64_t TotalCount = 0;

154// MaxNumVTableAnnotations is the maximum number of vtables annotated on

155// the instruction.

156auto ValueDataArray =getValueProfDataFromInst(

157 *I, IPVK_VTableTarget,MaxNumVTableAnnotations, TotalCount);

158

159for (constauto &V : ValueDataArray)

160 RefEdges.insert(Index.getOrInsertValueInfo(/* VTableGUID = */

161 V.Value));

162 }

163return HasBlockAddress;

164}

165

166staticCalleeInfo::HotnessType getHotness(uint64_t ProfileCount,

167ProfileSummaryInfo *PSI) {

168if (!PSI)

169return CalleeInfo::HotnessType::Unknown;

170if (PSI->isHotCount(ProfileCount))

171return CalleeInfo::HotnessType::Hot;

172if (PSI->isColdCount(ProfileCount))

173return CalleeInfo::HotnessType::Cold;

174return CalleeInfo::HotnessType::None;

175}

176

177staticboolisNonRenamableLocal(constGlobalValue &GV) {

178return GV.hasSection() && GV.hasLocalLinkage();

179}

180

181/// Determine whether this call has all constant integer arguments (excluding

182/// "this") and summarize it to VCalls or ConstVCalls as appropriate.

183staticvoidaddVCallToSet(

184DevirtCallSite Call,GlobalValue::GUID Guid,

185SetVector<FunctionSummary::VFuncId, std::vector<FunctionSummary::VFuncId>>

186 &VCalls,

187SetVector<FunctionSummary::ConstVCall,

188 std::vector<FunctionSummary::ConstVCall>> &ConstVCalls) {

189 std::vector<uint64_t> Args;

190// Start from the second argument to skip the "this" pointer.

191for (auto &Arg :drop_begin(Call.CB.args())) {

192auto *CI = dyn_cast<ConstantInt>(Arg);

193if (!CI || CI->getBitWidth() > 64) {

194 VCalls.insert({Guid, Call.Offset});

195return;

196 }

197 Args.push_back(CI->getZExtValue());

198 }

199 ConstVCalls.insert({{Guid, Call.Offset}, std::move(Args)});

200}

201

202/// If this intrinsic call requires that we add information to the function

203/// summary, do so via the non-constant reference arguments.

204staticvoidaddIntrinsicToSummary(

205constCallInst *CI,

206SetVector<GlobalValue::GUID, std::vector<GlobalValue::GUID>> &TypeTests,

207SetVector<FunctionSummary::VFuncId, std::vector<FunctionSummary::VFuncId>>

208 &TypeTestAssumeVCalls,

209SetVector<FunctionSummary::VFuncId, std::vector<FunctionSummary::VFuncId>>

210 &TypeCheckedLoadVCalls,

211SetVector<FunctionSummary::ConstVCall,

212 std::vector<FunctionSummary::ConstVCall>>

213 &TypeTestAssumeConstVCalls,

214SetVector<FunctionSummary::ConstVCall,

215 std::vector<FunctionSummary::ConstVCall>>

216 &TypeCheckedLoadConstVCalls,

217DominatorTree &DT) {

218switch (CI->getCalledFunction()->getIntrinsicID()) {

219case Intrinsic::type_test:

220case Intrinsic::public_type_test: {

221auto *TypeMDVal = cast<MetadataAsValue>(CI->getArgOperand(1));

222auto *TypeId = dyn_cast<MDString>(TypeMDVal->getMetadata());

223if (!TypeId)

224break;

225GlobalValue::GUID Guid =GlobalValue::getGUID(TypeId->getString());

226

227// Produce a summary from type.test intrinsics. We only summarize type.test

228// intrinsics that are used other than by an llvm.assume intrinsic.

229// Intrinsics that are assumed are relevant only to the devirtualization

230// pass, not the type test lowering pass.

231bool HasNonAssumeUses =llvm::any_of(CI->uses(), [](constUse &CIU) {

232 return !isa<AssumeInst>(CIU.getUser());

233 });

234if (HasNonAssumeUses)

235 TypeTests.insert(Guid);

236

237SmallVector<DevirtCallSite, 4> DevirtCalls;

238SmallVector<CallInst *, 4> Assumes;

239findDevirtualizableCallsForTypeTest(DevirtCalls, Assumes, CI, DT);

240for (auto &Call : DevirtCalls)

241addVCallToSet(Call,Guid, TypeTestAssumeVCalls,

242 TypeTestAssumeConstVCalls);

243

244break;

245 }

246

247case Intrinsic::type_checked_load_relative:

248case Intrinsic::type_checked_load: {

249auto *TypeMDVal = cast<MetadataAsValue>(CI->getArgOperand(2));

250auto *TypeId = dyn_cast<MDString>(TypeMDVal->getMetadata());

251if (!TypeId)

252break;

253GlobalValue::GUID Guid =GlobalValue::getGUID(TypeId->getString());

254

255SmallVector<DevirtCallSite, 4> DevirtCalls;

256SmallVector<Instruction *, 4> LoadedPtrs;

257SmallVector<Instruction *, 4> Preds;

258bool HasNonCallUses =false;

259findDevirtualizableCallsForTypeCheckedLoad(DevirtCalls, LoadedPtrs, Preds,

260 HasNonCallUses, CI, DT);

261// Any non-call uses of the result of llvm.type.checked.load will

262// prevent us from optimizing away the llvm.type.test.

263if (HasNonCallUses)

264 TypeTests.insert(Guid);

265for (auto &Call : DevirtCalls)

266addVCallToSet(Call,Guid, TypeCheckedLoadVCalls,

267 TypeCheckedLoadConstVCalls);

268

269break;

270 }

271default:

272break;

273 }

274}

275

276staticboolisNonVolatileLoad(constInstruction *I) {

277if (constauto *LI = dyn_cast<LoadInst>(I))

278return !LI->isVolatile();

279

280returnfalse;

281}

282

283staticboolisNonVolatileStore(constInstruction *I) {

284if (constauto *SI = dyn_cast<StoreInst>(I))

285return !SI->isVolatile();

286

287returnfalse;

288}

289

290// Returns true if the function definition must be unreachable.

291//

292// Note if this helper function returns true, `F` is guaranteed

293// to be unreachable; if it returns false, `F` might still

294// be unreachable but not covered by this helper function.

295staticboolmustBeUnreachableFunction(constFunction &F) {

296// A function must be unreachable if its entry block ends with an

297// 'unreachable'.

298assert(!F.isDeclaration());

299return isa<UnreachableInst>(F.getEntryBlock().getTerminator());

300}

301

302staticvoidcomputeFunctionSummary(

303ModuleSummaryIndex &Index,constModule &M,constFunction &F,

304BlockFrequencyInfo *BFI,ProfileSummaryInfo *PSI,DominatorTree &DT,

305bool HasLocalsInUsedOrAsm,DenseSet<GlobalValue::GUID> &CantBePromoted,

306bool IsThinLTO,

307 std::function<constStackSafetyInfo *(constFunction &F)> GetSSICallback) {

308// Summary not currently supported for anonymous functions, they should

309// have been named.

310assert(F.hasName());

311

312unsigned NumInsts = 0;

313// Map from callee ValueId to profile count. Used to accumulate profile

314// counts for all static calls to a given callee.

315MapVector<ValueInfo, CalleeInfo, DenseMap<ValueInfo, unsigned>,

316SmallVector<FunctionSummary::EdgeTy, 0>>

317 CallGraphEdges;

318SetVector<ValueInfo, SmallVector<ValueInfo, 0>> RefEdges, LoadRefEdges,

319 StoreRefEdges;

320SetVector<GlobalValue::GUID, std::vector<GlobalValue::GUID>> TypeTests;

321SetVector<FunctionSummary::VFuncId, std::vector<FunctionSummary::VFuncId>>

322 TypeTestAssumeVCalls, TypeCheckedLoadVCalls;

323SetVector<FunctionSummary::ConstVCall,

324 std::vector<FunctionSummary::ConstVCall>>

325 TypeTestAssumeConstVCalls, TypeCheckedLoadConstVCalls;

326ICallPromotionAnalysis ICallAnalysis;

327SmallPtrSet<const User *, 8> Visited;

328

329// Add personality function, prefix data and prologue data to function's ref

330// list.

331bool HasLocalIFuncCallOrRef =false;

332findRefEdges(Index, &F, RefEdges, Visited, HasLocalIFuncCallOrRef);

333 std::vector<const Instruction *> NonVolatileLoads;

334 std::vector<const Instruction *> NonVolatileStores;

335

336 std::vector<CallsiteInfo> Callsites;

337 std::vector<AllocInfo> Allocs;

338

339#ifndef NDEBUG

340DenseSet<const CallBase *> CallsThatMayHaveMemprofSummary;

341#endif

342

343bool HasInlineAsmMaybeReferencingInternal =false;

344bool HasIndirBranchToBlockAddress =false;

345bool HasUnknownCall =false;

346bool MayThrow =false;

347for (constBasicBlock &BB :F) {

348// We don't allow inlining of function with indirect branch to blockaddress.

349// If the blockaddress escapes the function, e.g., via a global variable,

350// inlining may lead to an invalid cross-function reference. So we shouldn't

351// import such function either.

352if (BB.hasAddressTaken()) {

353for (User *U :BlockAddress::get(const_cast<BasicBlock *>(&BB))->users())

354if (!isa<CallBrInst>(*U)) {

355 HasIndirBranchToBlockAddress =true;

356break;

357 }

358 }

359

360for (constInstruction &I : BB) {

361if (I.isDebugOrPseudoInst())

362continue;

363 ++NumInsts;

364

365// Regular LTO module doesn't participate in ThinLTO import,

366// so no reference from it can be read/writeonly, since this

367// would require importing variable as local copy

368if (IsThinLTO) {

369if (isNonVolatileLoad(&I)) {

370// Postpone processing of non-volatile load instructions

371// See comments below

372 Visited.insert(&I);

373 NonVolatileLoads.push_back(&I);

374continue;

375 }elseif (isNonVolatileStore(&I)) {

376 Visited.insert(&I);

377 NonVolatileStores.push_back(&I);

378// All references from second operand of store (destination address)

379// can be considered write-only if they're not referenced by any

380// non-store instruction. References from first operand of store

381// (stored value) can't be treated either as read- or as write-only

382// so we add them to RefEdges as we do with all other instructions

383// except non-volatile load.

384Value *Stored =I.getOperand(0);

385if (auto *GV = dyn_cast<GlobalValue>(Stored))

386// findRefEdges will try to examine GV operands, so instead

387// of calling it we should add GV to RefEdges directly.

388 RefEdges.insert(Index.getOrInsertValueInfo(GV));

389elseif (auto *U = dyn_cast<User>(Stored))

390findRefEdges(Index, U, RefEdges, Visited, HasLocalIFuncCallOrRef);

391continue;

392 }

393 }

394findRefEdges(Index, &I, RefEdges, Visited, HasLocalIFuncCallOrRef);

395constauto *CB = dyn_cast<CallBase>(&I);

396if (!CB) {

397if (I.mayThrow())

398 MayThrow =true;

399continue;

400 }

401

402constauto *CI = dyn_cast<CallInst>(&I);

403// Since we don't know exactly which local values are referenced in inline

404// assembly, conservatively mark the function as possibly referencing

405// a local value from inline assembly to ensure we don't export a

406// reference (which would require renaming and promotion of the

407// referenced value).

408if (HasLocalsInUsedOrAsm && CI && CI->isInlineAsm())

409 HasInlineAsmMaybeReferencingInternal =true;

410

411// Compute this once per indirect call.

412uint32_t NumCandidates = 0;

413uint64_t TotalCount = 0;

414MutableArrayRef<InstrProfValueData> CandidateProfileData;

415

416auto *CalledValue = CB->getCalledOperand();

417auto *CalledFunction = CB->getCalledFunction();

418if (CalledValue && !CalledFunction) {

419 CalledValue = CalledValue->stripPointerCasts();

420// Stripping pointer casts can reveal a called function.

421 CalledFunction = dyn_cast<Function>(CalledValue);

422 }

423// Check if this is an alias to a function. If so, get the

424// called aliasee for the checks below.

425if (auto *GA = dyn_cast<GlobalAlias>(CalledValue)) {

426assert(!CalledFunction &&"Expected null called function in callsite for alias");

427 CalledFunction = dyn_cast<Function>(GA->getAliaseeObject());

428 }

429// Check if this is a direct call to a known function or a known

430// intrinsic, or an indirect call with profile data.

431if (CalledFunction) {

432if (CI && CalledFunction->isIntrinsic()) {

433addIntrinsicToSummary(

434 CI, TypeTests, TypeTestAssumeVCalls, TypeCheckedLoadVCalls,

435 TypeTestAssumeConstVCalls, TypeCheckedLoadConstVCalls, DT);

436continue;

437 }

438// We should have named any anonymous globals

439assert(CalledFunction->hasName());

440auto ScaledCount = PSI->getProfileCount(*CB, BFI);

441auto Hotness = ScaledCount ?getHotness(*ScaledCount, PSI)

442 : CalleeInfo::HotnessType::Unknown;

443if (ForceSummaryEdgesCold !=FunctionSummary::FSHT_None)

444 Hotness = CalleeInfo::HotnessType::Cold;

445

446// Use the original CalledValue, in case it was an alias. We want

447// to record the call edge to the alias in that case. Eventually

448// an alias summary will be created to associate the alias and

449// aliasee.

450auto &ValueInfo = CallGraphEdges[Index.getOrInsertValueInfo(

451 cast<GlobalValue>(CalledValue))];

452ValueInfo.updateHotness(Hotness);

453if (CB->isTailCall())

454ValueInfo.setHasTailCall(true);

455// Add the relative block frequency to CalleeInfo if there is no profile

456// information.

457if (BFI !=nullptr && Hotness == CalleeInfo::HotnessType::Unknown) {

458uint64_t BBFreq = BFI->getBlockFreq(&BB).getFrequency();

459uint64_t EntryFreq = BFI->getEntryFreq().getFrequency();

460ValueInfo.updateRelBlockFreq(BBFreq, EntryFreq);

461 }

462 }else {

463 HasUnknownCall =true;

464// If F is imported, a local linkage ifunc (e.g. target_clones on a

465// static function) called by F will be cloned. Since summaries don't

466// track ifunc, we do not know implementation functions referenced by

467// the ifunc resolver need to be promoted in the exporter, and we will

468// get linker errors due to cloned declarations for implementation

469// functions. As a simple fix, just mark F as not eligible for import.

470// Non-local ifunc is not cloned and does not have the issue.

471if (auto *GI = dyn_cast_if_present<GlobalIFunc>(CalledValue))

472if (GI->hasLocalLinkage())

473 HasLocalIFuncCallOrRef =true;

474// Skip inline assembly calls.

475if (CI && CI->isInlineAsm())

476continue;

477// Skip direct calls.

478if (!CalledValue || isa<Constant>(CalledValue))

479continue;

480

481// Check if the instruction has a callees metadata. If so, add callees

482// to CallGraphEdges to reflect the references from the metadata, and

483// to enable importing for subsequent indirect call promotion and

484// inlining.

485if (auto *MD =I.getMetadata(LLVMContext::MD_callees)) {

486for (constauto &Op : MD->operands()) {

487Function *Callee = mdconst::extract_or_null<Function>(Op);

488if (Callee)

489 CallGraphEdges[Index.getOrInsertValueInfo(Callee)];

490 }

491 }

492

493 CandidateProfileData =

494 ICallAnalysis.getPromotionCandidatesForInstruction(&I, TotalCount,

495 NumCandidates);

496for (constauto &Candidate : CandidateProfileData)

497 CallGraphEdges[Index.getOrInsertValueInfo(Candidate.Value)]

498 .updateHotness(getHotness(Candidate.Count, PSI));

499 }

500

501// Summarize memprof related metadata. This is only needed for ThinLTO.

502if (!IsThinLTO)

503continue;

504

505// Skip indirect calls if we haven't enabled memprof ICP.

506if (!CalledFunction && !EnableMemProfIndirectCallSupport)

507continue;

508

509// Ensure we keep this analysis in sync with the handling in the ThinLTO

510// backend (see MemProfContextDisambiguation::applyImport). Save this call

511// so that we can skip it in checking the reverse case later.

512assert(mayHaveMemprofSummary(CB));

513#ifndef NDEBUG

514 CallsThatMayHaveMemprofSummary.insert(CB);

515#endif

516

517// Compute the list of stack ids first (so we can trim them from the stack

518// ids on any MIBs).

519CallStack<MDNode, MDNode::op_iterator> InstCallsite(

520I.getMetadata(LLVMContext::MD_callsite));

521auto *MemProfMD =I.getMetadata(LLVMContext::MD_memprof);

522if (MemProfMD) {

523 std::vector<MIBInfo> MIBs;

524 std::vector<uint64_t> TotalSizes;

525 std::vector<std::vector<ContextTotalSize>> ContextSizeInfos;

526for (auto &MDOp : MemProfMD->operands()) {

527auto *MIBMD = cast<const MDNode>(MDOp);

528MDNode *StackNode =getMIBStackNode(MIBMD);

529assert(StackNode);

530SmallVector<unsigned> StackIdIndices;

531CallStack<MDNode, MDNode::op_iterator> StackContext(StackNode);

532// Collapse out any on the allocation call (inlining).

533for (auto ContextIter =

534 StackContext.beginAfterSharedPrefix(InstCallsite);

535 ContextIter != StackContext.end(); ++ContextIter) {

536unsigned StackIdIdx = Index.addOrGetStackIdIndex(*ContextIter);

537// If this is a direct recursion, simply skip the duplicate

538// entries. If this is mutual recursion, handling is left to

539// the LTO link analysis client.

540if (StackIdIndices.empty() || StackIdIndices.back() != StackIdIdx)

541 StackIdIndices.push_back(StackIdIdx);

542 }

543// If we have context size information, collect it for inclusion in

544// the summary.

545assert(MIBMD->getNumOperands() > 2 || !MemProfReportHintedSizes);

546if (MIBMD->getNumOperands() > 2) {

547 std::vector<ContextTotalSize> ContextSizes;

548for (unsignedI = 2;I < MIBMD->getNumOperands();I++) {

549MDNode *ContextSizePair = dyn_cast<MDNode>(MIBMD->getOperand(I));

550assert(ContextSizePair->getNumOperands() == 2);

551uint64_t FullStackId = mdconst::dyn_extract<ConstantInt>(

552 ContextSizePair->getOperand(0))

553 ->getZExtValue();

554uint64_t TS = mdconst::dyn_extract<ConstantInt>(

555 ContextSizePair->getOperand(1))

556 ->getZExtValue();

557 ContextSizes.push_back({FullStackId, TS});

558 }

559 ContextSizeInfos.push_back(std::move(ContextSizes));

560 }

561 MIBs.push_back(

562MIBInfo(getMIBAllocType(MIBMD), std::move(StackIdIndices)));

563 }

564 Allocs.push_back(AllocInfo(std::move(MIBs)));

565assert(!ContextSizeInfos.empty() || !MemProfReportHintedSizes);

566if (!ContextSizeInfos.empty()) {

567assert(Allocs.back().MIBs.size() == ContextSizeInfos.size());

568 Allocs.back().ContextSizeInfos = std::move(ContextSizeInfos);

569 }

570 }elseif (!InstCallsite.empty()) {

571SmallVector<unsigned> StackIdIndices;

572for (auto StackId : InstCallsite)

573 StackIdIndices.push_back(Index.addOrGetStackIdIndex(StackId));

574if (CalledFunction) {

575// Use the original CalledValue, in case it was an alias. We want

576// to record the call edge to the alias in that case. Eventually

577// an alias summary will be created to associate the alias and

578// aliasee.

579auto CalleeValueInfo =

580 Index.getOrInsertValueInfo(cast<GlobalValue>(CalledValue));

581 Callsites.push_back({CalleeValueInfo, StackIdIndices});

582 }else {

583assert(EnableMemProfIndirectCallSupport);

584// For indirect callsites, create multiple Callsites, one per target.

585// This enables having a different set of clone versions per target,

586// and we will apply the cloning decisions while speculatively

587// devirtualizing in the ThinLTO backends.

588for (constauto &Candidate : CandidateProfileData) {

589auto CalleeValueInfo = Index.getOrInsertValueInfo(Candidate.Value);

590 Callsites.push_back({CalleeValueInfo, StackIdIndices});

591 }

592 }

593 }

594 }

595 }

596

597if (PSI->hasPartialSampleProfile() &&ScalePartialSampleProfileWorkingSetSize)

598 Index.addBlockCount(F.size());

599

600SmallVector<ValueInfo, 0> Refs;

601if (IsThinLTO) {

602auto AddRefEdges =

603 [&](const std::vector<const Instruction *> &Instrs,

604SetVector<ValueInfo, SmallVector<ValueInfo, 0>> &Edges,

605SmallPtrSet<const User *, 8> &Cache) {

606for (constauto *I : Instrs) {

607 Cache.erase(I);

608findRefEdges(Index,I, Edges, Cache, HasLocalIFuncCallOrRef);

609 }

610 };

611

612// By now we processed all instructions in a function, except

613// non-volatile loads and non-volatile value stores. Let's find

614// ref edges for both of instruction sets

615 AddRefEdges(NonVolatileLoads, LoadRefEdges, Visited);

616// We can add some values to the Visited set when processing load

617// instructions which are also used by stores in NonVolatileStores.

618// For example this can happen if we have following code:

619//

620// store %Derived* @foo, %Derived** bitcast (%Base** @bar to %Derived**)

621// %42 = load %Derived*, %Derived** bitcast (%Base** @bar to %Derived**)

622//

623// After processing loads we'll add bitcast to the Visited set, and if

624// we use the same set while processing stores, we'll never see store

625// to @bar and @bar will be mistakenly treated as readonly.

626SmallPtrSet<const llvm::User *, 8> StoreCache;

627 AddRefEdges(NonVolatileStores, StoreRefEdges, StoreCache);

628

629// If both load and store instruction reference the same variable

630// we won't be able to optimize it. Add all such reference edges

631// to RefEdges set.

632for (constauto &VI : StoreRefEdges)

633if (LoadRefEdges.remove(VI))

634 RefEdges.insert(VI);

635

636unsigned RefCnt = RefEdges.size();

637// All new reference edges inserted in two loops below are either

638// read or write only. They will be grouped in the end of RefEdges

639// vector, so we can use a single integer value to identify them.

640for (constauto &VI : LoadRefEdges)

641 RefEdges.insert(VI);

642

643unsigned FirstWORef = RefEdges.size();

644for (constauto &VI : StoreRefEdges)

645 RefEdges.insert(VI);

646

647 Refs = RefEdges.takeVector();

648for (; RefCnt < FirstWORef; ++RefCnt)

649 Refs[RefCnt].setReadOnly();

650

651for (; RefCnt < Refs.size(); ++RefCnt)

652 Refs[RefCnt].setWriteOnly();

653 }else {

654 Refs = RefEdges.takeVector();

655 }

656// Explicit add hot edges to enforce importing for designated GUIDs for

657// sample PGO, to enable the same inlines as the profiled optimized binary.

658for (auto &I :F.getImportGUIDs())

659 CallGraphEdges[Index.getOrInsertValueInfo(I)].updateHotness(

660ForceSummaryEdgesCold ==FunctionSummary::FSHT_All

661 ? CalleeInfo::HotnessType::Cold

662 : CalleeInfo::HotnessType::Critical);

663

664#ifndef NDEBUG

665// Make sure that all calls we decided could not have memprof summaries get a

666// false value for mayHaveMemprofSummary, to ensure that this handling remains

667// in sync with the ThinLTO backend handling.

668if (IsThinLTO) {

669for (constBasicBlock &BB :F) {

670for (constInstruction &I : BB) {

671constauto *CB = dyn_cast<CallBase>(&I);

672if (!CB)

673continue;

674// We already checked these above.

675if (CallsThatMayHaveMemprofSummary.count(CB))

676continue;

677assert(!mayHaveMemprofSummary(CB));

678 }

679 }

680 }

681#endif

682

683bool NonRenamableLocal =isNonRenamableLocal(F);

684bool NotEligibleForImport =

685 NonRenamableLocal || HasInlineAsmMaybeReferencingInternal ||

686 HasIndirBranchToBlockAddress || HasLocalIFuncCallOrRef;

687GlobalValueSummary::GVFlags Flags(

688F.getLinkage(),F.getVisibility(), NotEligibleForImport,

689/* Live = */false,F.isDSOLocal(),F.canBeOmittedFromSymbolTable(),

690 GlobalValueSummary::ImportKind::Definition);

691FunctionSummary::FFlags FunFlags{

692F.doesNotAccessMemory(),F.onlyReadsMemory() && !F.doesNotAccessMemory(),

693F.hasFnAttribute(Attribute::NoRecurse),F.returnDoesNotAlias(),

694// FIXME: refactor this to use the same code that inliner is using.

695// Don't try to import functions with noinline attribute.

696F.getAttributes().hasFnAttr(Attribute::NoInline),

697F.hasFnAttribute(Attribute::AlwaysInline),

698F.hasFnAttribute(Attribute::NoUnwind), MayThrow, HasUnknownCall,

699mustBeUnreachableFunction(F)};

700 std::vector<FunctionSummary::ParamAccess> ParamAccesses;

701if (auto *SSI = GetSSICallback(F))

702 ParamAccesses = SSI->getParamAccesses(Index);

703auto FuncSummary = std::make_unique<FunctionSummary>(

704 Flags, NumInsts, FunFlags, std::move(Refs), CallGraphEdges.takeVector(),

705 TypeTests.takeVector(), TypeTestAssumeVCalls.takeVector(),

706 TypeCheckedLoadVCalls.takeVector(),

707 TypeTestAssumeConstVCalls.takeVector(),

708 TypeCheckedLoadConstVCalls.takeVector(), std::move(ParamAccesses),

709 std::move(Callsites), std::move(Allocs));

710if (NonRenamableLocal)

711 CantBePromoted.insert(F.getGUID());

712 Index.addGlobalValueSummary(F, std::move(FuncSummary));

713}

714

715/// Find function pointers referenced within the given vtable initializer

716/// (or subset of an initializer) \p I. The starting offset of \p I within

717/// the vtable initializer is \p StartingOffset. Any discovered function

718/// pointers are added to \p VTableFuncs along with their cumulative offset

719/// within the initializer.

720staticvoidfindFuncPointers(constConstant *I,uint64_t StartingOffset,

721constModule &M,ModuleSummaryIndex &Index,

722VTableFuncList &VTableFuncs,

723constGlobalVariable &OrigGV) {

724// First check if this is a function pointer.

725if (I->getType()->isPointerTy()) {

726autoC =I->stripPointerCasts();

727autoA = dyn_cast<GlobalAlias>(C);

728if (isa<Function>(C) || (A && isa<Function>(A->getAliasee()))) {

729auto GV = dyn_cast<GlobalValue>(C);

730assert(GV);

731// We can disregard __cxa_pure_virtual as a possible call target, as

732// calls to pure virtuals are UB.

733if (GV && GV->getName() !="__cxa_pure_virtual")

734 VTableFuncs.push_back({Index.getOrInsertValueInfo(GV), StartingOffset});

735return;

736 }

737 }

738

739// Walk through the elements in the constant struct or array and recursively

740// look for virtual function pointers.

741constDataLayout &DL = M.getDataLayout();

742if (auto *C = dyn_cast<ConstantStruct>(I)) {

743StructType *STy = dyn_cast<StructType>(C->getType());

744assert(STy);

745constStructLayout *SL =DL.getStructLayout(C->getType());

746

747for (auto EI :llvm::enumerate(STy->elements())) {

748autoOffset = SL->getElementOffset(EI.index());

749unsignedOp = SL->getElementContainingOffset(Offset);

750findFuncPointers(cast<Constant>(I->getOperand(Op)),

751 StartingOffset +Offset, M, Index, VTableFuncs, OrigGV);

752 }

753 }elseif (auto *C = dyn_cast<ConstantArray>(I)) {

754ArrayType *ATy =C->getType();

755Type *EltTy = ATy->getElementType();

756uint64_t EltSize =DL.getTypeAllocSize(EltTy);

757for (unsigned i = 0, e = ATy->getNumElements(); i != e; ++i) {

758findFuncPointers(cast<Constant>(I->getOperand(i)),

759 StartingOffset + i * EltSize, M, Index, VTableFuncs,

760 OrigGV);

761 }

762 }elseif (constauto *CE = dyn_cast<ConstantExpr>(I)) {

763// For relative vtables, the next sub-component should be a trunc.

764if (CE->getOpcode() != Instruction::Trunc ||

765 !(CE = dyn_cast<ConstantExpr>(CE->getOperand(0))))

766return;

767

768// If this constant can be reduced to the offset between a function and a

769// global, then we know this is a valid virtual function if the RHS is the

770// original vtable we're scanning through.

771if (CE->getOpcode() == Instruction::Sub) {

772GlobalValue *LHS, *RHS;

773APSInt LHSOffset, RHSOffset;

774if (IsConstantOffsetFromGlobal(CE->getOperand(0),LHS, LHSOffset,DL) &&

775IsConstantOffsetFromGlobal(CE->getOperand(1),RHS, RHSOffset,DL) &&

776RHS == &OrigGV &&

777

778// For relative vtables, this component should point to the callable

779// function without any offsets.

780 LHSOffset == 0 &&

781

782// Also, the RHS should always point to somewhere within the vtable.

783 RHSOffset <=

784static_cast<uint64_t>(DL.getTypeAllocSize(OrigGV.getInitializer()->getType()))) {

785findFuncPointers(LHS, StartingOffset, M, Index, VTableFuncs, OrigGV);

786 }

787 }

788 }

789}

790

791// Identify the function pointers referenced by vtable definition \p V.

792staticvoidcomputeVTableFuncs(ModuleSummaryIndex &Index,

793constGlobalVariable &V,constModule &M,

794VTableFuncList &VTableFuncs) {

795if (!V.isConstant())

796return;

797

798findFuncPointers(V.getInitializer(),/*StartingOffset=*/0, M, Index,

799 VTableFuncs, V);

800

801#ifndef NDEBUG

802// Validate that the VTableFuncs list is ordered by offset.

803uint64_t PrevOffset = 0;

804for (auto &P : VTableFuncs) {

805// The findVFuncPointers traversal should have encountered the

806// functions in offset order. We need to use ">=" since PrevOffset

807// starts at 0.

808assert(P.VTableOffset >= PrevOffset);

809 PrevOffset =P.VTableOffset;

810 }

811#endif

812}

813

814/// Record vtable definition \p V for each type metadata it references.

815staticvoid

816recordTypeIdCompatibleVtableReferences(ModuleSummaryIndex &Index,

817constGlobalVariable &V,

818SmallVectorImpl<MDNode *> &Types) {

819for (MDNode *Type : Types) {

820autoTypeID =Type->getOperand(1).get();

821

822uint64_t Offset =

823 cast<ConstantInt>(

824 cast<ConstantAsMetadata>(Type->getOperand(0))->getValue())

825 ->getZExtValue();

826

827if (auto *TypeId = dyn_cast<MDString>(TypeID))

828 Index.getOrInsertTypeIdCompatibleVtableSummary(TypeId->getString())

829 .push_back({Offset, Index.getOrInsertValueInfo(&V)});

830 }

831}

832

833staticvoidcomputeVariableSummary(ModuleSummaryIndex &Index,

834constGlobalVariable &V,

835DenseSet<GlobalValue::GUID> &CantBePromoted,

836constModule &M,

837SmallVectorImpl<MDNode *> &Types) {

838SetVector<ValueInfo, SmallVector<ValueInfo, 0>> RefEdges;

839SmallPtrSet<const User *, 8> Visited;

840bool RefLocalIFunc =false;

841bool HasBlockAddress =

842findRefEdges(Index, &V, RefEdges, Visited, RefLocalIFunc);

843constbool NotEligibleForImport = (HasBlockAddress || RefLocalIFunc);

844bool NonRenamableLocal =isNonRenamableLocal(V);

845GlobalValueSummary::GVFlags Flags(

846 V.getLinkage(), V.getVisibility(), NonRenamableLocal,

847/* Live = */false, V.isDSOLocal(), V.canBeOmittedFromSymbolTable(),

848GlobalValueSummary::Definition);

849

850VTableFuncList VTableFuncs;

851// If splitting is not enabled, then we compute the summary information

852// necessary for index-based whole program devirtualization.

853if (!Index.enableSplitLTOUnit()) {

854 Types.clear();

855 V.getMetadata(LLVMContext::MD_type, Types);

856if (!Types.empty()) {

857// Identify the function pointers referenced by this vtable definition.

858computeVTableFuncs(Index, V, M, VTableFuncs);

859

860// Record this vtable definition for each type metadata it references.

861recordTypeIdCompatibleVtableReferences(Index, V, Types);

862 }

863 }

864

865// Don't mark variables we won't be able to internalize as read/write-only.

866bool CanBeInternalized =

867 !V.hasComdat() && !V.hasAppendingLinkage() && !V.isInterposable() &&

868 !V.hasAvailableExternallyLinkage() && !V.hasDLLExportStorageClass();

869boolConstant = V.isConstant();

870GlobalVarSummary::GVarFlags VarFlags(CanBeInternalized,

871Constant ?false : CanBeInternalized,

872Constant, V.getVCallVisibility());

873auto GVarSummary = std::make_unique<GlobalVarSummary>(Flags, VarFlags,

874 RefEdges.takeVector());

875if (NonRenamableLocal)

876 CantBePromoted.insert(V.getGUID());

877if (NotEligibleForImport)

878 GVarSummary->setNotEligibleToImport();

879if (!VTableFuncs.empty())

880 GVarSummary->setVTableFuncs(VTableFuncs);

881 Index.addGlobalValueSummary(V, std::move(GVarSummary));

882}

883

884staticvoidcomputeAliasSummary(ModuleSummaryIndex &Index,constGlobalAlias &A,

885DenseSet<GlobalValue::GUID> &CantBePromoted) {

886// Skip summary for indirect function aliases as summary for aliasee will not

887// be emitted.

888constGlobalObject *Aliasee =A.getAliaseeObject();

889if (isa<GlobalIFunc>(Aliasee))

890return;

891bool NonRenamableLocal =isNonRenamableLocal(A);

892GlobalValueSummary::GVFlags Flags(

893A.getLinkage(),A.getVisibility(), NonRenamableLocal,

894/* Live = */false,A.isDSOLocal(),A.canBeOmittedFromSymbolTable(),

895GlobalValueSummary::Definition);

896auto AS = std::make_unique<AliasSummary>(Flags);

897auto AliaseeVI = Index.getValueInfo(Aliasee->getGUID());

898assert(AliaseeVI &&"Alias expects aliasee summary to be available");

899assert(AliaseeVI.getSummaryList().size() == 1 &&

900"Expected a single entry per aliasee in per-module index");

901 AS->setAliasee(AliaseeVI, AliaseeVI.getSummaryList()[0].get());

902if (NonRenamableLocal)

903 CantBePromoted.insert(A.getGUID());

904 Index.addGlobalValueSummary(A, std::move(AS));

905}

906

907// Set LiveRoot flag on entries matching the given value name.

908staticvoidsetLiveRoot(ModuleSummaryIndex &Index,StringRef Name) {

909if (ValueInfo VI = Index.getValueInfo(GlobalValue::getGUID(Name)))

910for (constauto &Summary : VI.getSummaryList())

911 Summary->setLive(true);

912}

913

914ModuleSummaryIndex llvm::buildModuleSummaryIndex(

915constModule &M,

916 std::function<BlockFrequencyInfo *(constFunction &F)> GetBFICallback,

917ProfileSummaryInfo *PSI,

918 std::function<constStackSafetyInfo *(constFunction &F)> GetSSICallback) {

919assert(PSI);

920bool EnableSplitLTOUnit =false;

921bool UnifiedLTO =false;

922if (auto *MD = mdconst::extract_or_null<ConstantInt>(

923 M.getModuleFlag("EnableSplitLTOUnit")))

924 EnableSplitLTOUnit = MD->getZExtValue();

925if (auto *MD =

926 mdconst::extract_or_null<ConstantInt>(M.getModuleFlag("UnifiedLTO")))

927 UnifiedLTO = MD->getZExtValue();

928ModuleSummaryIndex Index(/*HaveGVs=*/true, EnableSplitLTOUnit, UnifiedLTO);

929

930// Identify the local values in the llvm.used and llvm.compiler.used sets,

931// which should not be exported as they would then require renaming and

932// promotion, but we may have opaque uses e.g. in inline asm. We collect them

933// here because we use this information to mark functions containing inline

934// assembly calls as not importable.

935SmallPtrSet<GlobalValue *, 4> LocalsUsed;

936SmallVector<GlobalValue *, 4> Used;

937// First collect those in the llvm.used set.

938collectUsedGlobalVariables(M, Used,/*CompilerUsed=*/false);

939// Next collect those in the llvm.compiler.used set.

940collectUsedGlobalVariables(M, Used,/*CompilerUsed=*/true);

941DenseSet<GlobalValue::GUID> CantBePromoted;

942for (auto *V : Used) {

943if (V->hasLocalLinkage()) {

944 LocalsUsed.insert(V);

945 CantBePromoted.insert(V->getGUID());

946 }

947 }

948

949bool HasLocalInlineAsmSymbol =false;

950if (!M.getModuleInlineAsm().empty()) {

951// Collect the local values defined by module level asm, and set up

952// summaries for these symbols so that they can be marked as NoRename,

953// to prevent export of any use of them in regular IR that would require

954// renaming within the module level asm. Note we don't need to create a

955// summary for weak or global defs, as they don't need to be flagged as

956// NoRename, and defs in module level asm can't be imported anyway.

957// Also, any values used but not defined within module level asm should

958// be listed on the llvm.used or llvm.compiler.used global and marked as

959// referenced from there.

960ModuleSymbolTable::CollectAsmSymbols(

961 M, [&](StringRef Name,object::BasicSymbolRef::Flags Flags) {

962// Symbols not marked as Weak or Global are local definitions.

963if (Flags & (object::BasicSymbolRef::SF_Weak |

964object::BasicSymbolRef::SF_Global))

965return;

966 HasLocalInlineAsmSymbol =true;

967GlobalValue *GV = M.getNamedValue(Name);

968if (!GV)

969return;

970assert(GV->isDeclaration() &&"Def in module asm already has definition");

971GlobalValueSummary::GVFlags GVFlags(

972GlobalValue::InternalLinkage,GlobalValue::DefaultVisibility,

973/* NotEligibleToImport = */true,

974/* Live = */true,

975/* Local */ GV->isDSOLocal(), GV->canBeOmittedFromSymbolTable(),

976GlobalValueSummary::Definition);

977 CantBePromoted.insert(GV->getGUID());

978// Create the appropriate summary type.

979if (Function *F = dyn_cast<Function>(GV)) {

980 std::unique_ptr<FunctionSummary> Summary =

981 std::make_unique<FunctionSummary>(

982 GVFlags,/*InstCount=*/0,

983FunctionSummary::FFlags{

984F->hasFnAttribute(Attribute::ReadNone),

985F->hasFnAttribute(Attribute::ReadOnly),

986F->hasFnAttribute(Attribute::NoRecurse),

987F->returnDoesNotAlias(),

988/* NoInline = */false,

989F->hasFnAttribute(Attribute::AlwaysInline),

990F->hasFnAttribute(Attribute::NoUnwind),

991/* MayThrow */true,

992/* HasUnknownCall */true,

993/* MustBeUnreachable */false},

994SmallVector<ValueInfo, 0>{},

995SmallVector<FunctionSummary::EdgeTy, 0>{},

996ArrayRef<GlobalValue::GUID>{},

997ArrayRef<FunctionSummary::VFuncId>{},

998ArrayRef<FunctionSummary::VFuncId>{},

999ArrayRef<FunctionSummary::ConstVCall>{},

1000ArrayRef<FunctionSummary::ConstVCall>{},

1001ArrayRef<FunctionSummary::ParamAccess>{},

1002ArrayRef<CallsiteInfo>{},ArrayRef<AllocInfo>{});

1003 Index.addGlobalValueSummary(*GV, std::move(Summary));

1004 }else {

1005 std::unique_ptr<GlobalVarSummary> Summary =

1006 std::make_unique<GlobalVarSummary>(

1007 GVFlags,

1008GlobalVarSummary::GVarFlags(

1009false,false, cast<GlobalVariable>(GV)->isConstant(),

1010GlobalObject::VCallVisibilityPublic),

1011SmallVector<ValueInfo, 0>{});

1012 Index.addGlobalValueSummary(*GV, std::move(Summary));

1013 }

1014 });

1015 }

1016

1017bool IsThinLTO =true;

1018if (auto *MD =

1019 mdconst::extract_or_null<ConstantInt>(M.getModuleFlag("ThinLTO")))

1020 IsThinLTO = MD->getZExtValue();

1021

1022// Compute summaries for all functions defined in module, and save in the

1023// index.

1024for (constauto &F : M) {

1025if (F.isDeclaration())

1026continue;

1027

1028DominatorTree DT(const_cast<Function &>(F));

1029BlockFrequencyInfo *BFI =nullptr;

1030 std::unique_ptr<BlockFrequencyInfo> BFIPtr;

1031if (GetBFICallback)

1032 BFI = GetBFICallback(F);

1033elseif (F.hasProfileData()) {

1034LoopInfo LI{DT};

1035BranchProbabilityInfo BPI{F, LI};

1036 BFIPtr = std::make_unique<BlockFrequencyInfo>(F, BPI, LI);

1037 BFI = BFIPtr.get();

1038 }

1039

1040computeFunctionSummary(Index, M,F, BFI, PSI, DT,

1041 !LocalsUsed.empty() || HasLocalInlineAsmSymbol,

1042 CantBePromoted, IsThinLTO, GetSSICallback);

1043 }

1044

1045// Compute summaries for all variables defined in module, and save in the

1046// index.

1047SmallVector<MDNode *, 2> Types;

1048for (constGlobalVariable &G : M.globals()) {

1049if (G.isDeclaration())

1050continue;

1051computeVariableSummary(Index,G, CantBePromoted, M, Types);

1052 }

1053

1054// Compute summaries for all aliases defined in module, and save in the

1055// index.

1056for (constGlobalAlias &A : M.aliases())

1057computeAliasSummary(Index,A, CantBePromoted);

1058

1059// Iterate through ifuncs, set their resolvers all alive.

1060for (constGlobalIFunc &I : M.ifuncs()) {

1061I.applyAlongResolverPath([&Index](constGlobalValue &GV) {

1062 Index.getGlobalValueSummary(GV)->setLive(true);

1063 });

1064 }

1065

1066for (auto *V : LocalsUsed) {

1067auto *Summary = Index.getGlobalValueSummary(*V);

1068assert(Summary &&"Missing summary for global value");

1069 Summary->setNotEligibleToImport();

1070 }

1071

1072// The linker doesn't know about these LLVM produced values, so we need

1073// to flag them as live in the index to ensure index-based dead value

1074// analysis treats them as live roots of the analysis.

1075setLiveRoot(Index,"llvm.used");

1076setLiveRoot(Index,"llvm.compiler.used");

1077setLiveRoot(Index,"llvm.global_ctors");

1078setLiveRoot(Index,"llvm.global_dtors");

1079setLiveRoot(Index,"llvm.global.annotations");

1080

1081for (auto &GlobalList : Index) {

1082// Ignore entries for references that are undefined in the current module.

1083if (GlobalList.second.SummaryList.empty())

1084continue;

1085

1086assert(GlobalList.second.SummaryList.size() == 1 &&

1087"Expected module's index to have one summary per GUID");

1088auto &Summary = GlobalList.second.SummaryList[0];

1089if (!IsThinLTO) {

1090 Summary->setNotEligibleToImport();

1091continue;

1092 }

1093

1094bool AllRefsCanBeExternallyReferenced =

1095llvm::all_of(Summary->refs(), [&](constValueInfo &VI) {

1096 return !CantBePromoted.count(VI.getGUID());

1097 });

1098if (!AllRefsCanBeExternallyReferenced) {

1099 Summary->setNotEligibleToImport();

1100continue;

1101 }

1102

1103if (auto *FuncSummary = dyn_cast<FunctionSummary>(Summary.get())) {

1104bool AllCallsCanBeExternallyReferenced =llvm::all_of(

1105 FuncSummary->calls(), [&](constFunctionSummary::EdgeTy &Edge) {

1106 return !CantBePromoted.count(Edge.first.getGUID());

1107 });

1108if (!AllCallsCanBeExternallyReferenced)

1109 Summary->setNotEligibleToImport();

1110 }

1111 }

1112

1113if (!ModuleSummaryDotFile.empty()) {

1114 std::error_code EC;

1115raw_fd_ostream OSDot(ModuleSummaryDotFile, EC, sys::fs::OpenFlags::OF_Text);

1116if (EC)

1117report_fatal_error(Twine("Failed to open dot file ") +

1118ModuleSummaryDotFile +": " + EC.message() +"\n");

1119 Index.exportToDot(OSDot, {});

1120 }

1121

1122return Index;

1123}

1124

1125AnalysisKey ModuleSummaryIndexAnalysis::Key;

1126

1127ModuleSummaryIndex

1128ModuleSummaryIndexAnalysis::run(Module &M,ModuleAnalysisManager &AM) {

1129ProfileSummaryInfo &PSI = AM.getResult<ProfileSummaryAnalysis>(M);

1130auto &FAM = AM.getResult<FunctionAnalysisManagerModuleProxy>(M).getManager();

1131bool NeedSSI =needsParamAccessSummary(M);

1132returnbuildModuleSummaryIndex(

1133 M,

1134 [&FAM](constFunction &F) {

1135return &FAM.getResult<BlockFrequencyAnalysis>(

1136 *const_cast<Function *>(&F));

1137 },

1138 &PSI,

1139 [&FAM, NeedSSI](constFunction &F) ->constStackSafetyInfo * {

1140return NeedSSI ? &FAM.getResult<StackSafetyAnalysis>(

1141const_cast<Function &>(F))

1142 :nullptr;

1143 });

1144}

1145

1146charModuleSummaryIndexWrapperPass::ID = 0;

1147

1148INITIALIZE_PASS_BEGIN(ModuleSummaryIndexWrapperPass,"module-summary-analysis",

1149"Module Summary Analysis",false,true)

1150INITIALIZE_PASS_DEPENDENCY(BlockFrequencyInfoWrapperPass)

1151INITIALIZE_PASS_DEPENDENCY(ProfileSummaryInfoWrapperPass)

1152INITIALIZE_PASS_DEPENDENCY(StackSafetyInfoWrapperPass)

1153INITIALIZE_PASS_END(ModuleSummaryIndexWrapperPass, "module-summary-analysis",

1154 "Module SummaryAnalysis",false,true)

1155

1156ModulePass *llvm::createModuleSummaryIndexWrapperPass() {

1157returnnewModuleSummaryIndexWrapperPass();

1158}

1159

1160ModuleSummaryIndexWrapperPass::ModuleSummaryIndexWrapperPass()

1161 :ModulePass(ID) {

1162initializeModuleSummaryIndexWrapperPassPass(*PassRegistry::getPassRegistry());

1163}

1164

1165boolModuleSummaryIndexWrapperPass::runOnModule(Module &M) {

1166auto *PSI = &getAnalysis<ProfileSummaryInfoWrapperPass>().getPSI();

1167bool NeedSSI =needsParamAccessSummary(M);

1168 Index.emplace(buildModuleSummaryIndex(

1169 M,

1170 [this](constFunction &F) {

1171return &(this->getAnalysis<BlockFrequencyInfoWrapperPass>(

1172 *const_cast<Function *>(&F))

1173 .getBFI());

1174 },

1175 PSI,

1176 [&](constFunction &F) ->constStackSafetyInfo * {

1177return NeedSSI ? &getAnalysis<StackSafetyInfoWrapperPass>(

1178const_cast<Function &>(F))

1179 .getResult()

1180 :nullptr;

1181 }));

1182returnfalse;

1183}

1184

1185boolModuleSummaryIndexWrapperPass::doFinalization(Module &M) {

1186 Index.reset();

1187returnfalse;

1188}

1189

1190voidModuleSummaryIndexWrapperPass::getAnalysisUsage(AnalysisUsage &AU) const{

1191 AU.setPreservesAll();

1192 AU.addRequired<BlockFrequencyInfoWrapperPass>();

1193 AU.addRequired<ProfileSummaryInfoWrapperPass>();

1194 AU.addRequired<StackSafetyInfoWrapperPass>();

1195}

1196

1197charImmutableModuleSummaryIndexWrapperPass::ID = 0;

1198

1199ImmutableModuleSummaryIndexWrapperPass::ImmutableModuleSummaryIndexWrapperPass(

1200constModuleSummaryIndex *Index)

1201 :ImmutablePass(ID), Index(Index) {

1202initializeImmutableModuleSummaryIndexWrapperPassPass(

1203 *PassRegistry::getPassRegistry());

1204}

1205

1206voidImmutableModuleSummaryIndexWrapperPass::getAnalysisUsage(

1207AnalysisUsage &AU) const{

1208 AU.setPreservesAll();

1209}

1210

1211ImmutablePass *llvm::createImmutableModuleSummaryIndexWrapperPass(

1212constModuleSummaryIndex *Index) {

1213returnnewImmutableModuleSummaryIndexWrapperPass(Index);

1214}

1215

1216INITIALIZE_PASS(ImmutableModuleSummaryIndexWrapperPass,"module-summary-info",

1217"Module summary info",false,true)

1218

1219bool llvm::mayHaveMemprofSummary(const CallBase *CB) {

1220if (!CB)

1221returnfalse;

1222if (CB->isDebugOrPseudoInst())

1223returnfalse;

1224auto *CI = dyn_cast<CallInst>(CB);

1225auto *CalledValue = CB->getCalledOperand();

1226auto *CalledFunction = CB->getCalledFunction();

1227if (CalledValue && !CalledFunction) {

1228 CalledValue = CalledValue->stripPointerCasts();

1229// Stripping pointer casts can reveal a called function.

1230 CalledFunction = dyn_cast<Function>(CalledValue);

1231 }

1232// Check if this is an alias to a function. If so, get the

1233// called aliasee for the checks below.

1234if (auto *GA = dyn_cast<GlobalAlias>(CalledValue)) {

1235assert(!CalledFunction &&

1236"Expected null called function in callsite for alias");

1237 CalledFunction = dyn_cast<Function>(GA->getAliaseeObject());

1238 }

1239// Check if this is a direct call to a known function or a known

1240// intrinsic, or an indirect call with profile data.

1241if (CalledFunction) {

1242if (CI && CalledFunction->isIntrinsic())

1243returnfalse;

1244 }else {

1245// Skip indirect calls if we haven't enabled memprof ICP.

1246if (!EnableMemProfIndirectCallSupport)

1247returnfalse;

1248// Skip inline assembly calls.

1249if (CI && CI->isInlineAsm())

1250returnfalse;

1251// Skip direct calls via Constant.

1252if (!CalledValue || isa<Constant>(CalledValue))

1253returnfalse;

1254returntrue;

1255 }

1256returntrue;

1257}

const

aarch64 promote const

Definition:AArch64PromoteConstant.cpp:230

isConstant

static bool isConstant(const MachineInstr &MI)

Definition:AMDGPUInstructionSelector.cpp:2862

MachineBasicBlock MachineBasicBlock::iterator DebugLoc DL

Definition:ARMSLSHardening.cpp:73

ArrayRef.h

PGOMapFeaturesEnum::BBFreq

@ BBFreq

Attributes.h

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

true

basic Basic Alias true

Definition:BasicAliasAnalysis.cpp:1981

Analysis

block Block Frequency Analysis

Definition:BlockFrequencyInfo.cpp:300

BlockFrequencyInfo.h

BranchProbabilityInfo.h

static GCRegistry::Add< ErlangGC > A("erlang", "erlang-compatible garbage collector")

Casting.h

CommandLine.h

clEnumValN

#define clEnumValN(ENUMVAL, FLAGNAME, DESC)

Definition:CommandLine.h:686

ConstantFolding.h

Constants.h

This file contains the declarations for the subclasses of Constant, which represent the different fla...

DenseSet.h

This file defines the DenseSet and SmallDenseSet classes.

Dominators.h

Name

std::string Name

Definition:ELFObjHandler.cpp:77

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

Use.h

This defines the Use class.

User.h

users

iv users

Definition:IVUsers.cpp:48

IndirectCallPromotionAnalysis.h

Interface to identify indirect call promotion candidates.

InitializePasses.h

Instructions.h

LoopInfo.h

#define F(x, y, z)

Definition:MD5.cpp:55

#define I(x, y, z)

Definition:MD5.cpp:58

#define G(x, y, z)

Definition:MD5.cpp:56

MapVector.h

This file implements a map that provides insertion order iteration.

MemoryProfileInfo.h

Metadata.h

This file contains the declarations for metadata subclasses.

addVCallToSet

static void addVCallToSet(DevirtCallSite Call, GlobalValue::GUID Guid, SetVector< FunctionSummary::VFuncId, std::vector< FunctionSummary::VFuncId > > &VCalls, SetVector< FunctionSummary::ConstVCall, std::vector< FunctionSummary::ConstVCall > > &ConstVCalls)

Determine whether this call has all constant integer arguments (excluding "this") and summarize it to...

Definition:ModuleSummaryAnalysis.cpp:183

MaxNumVTableAnnotations

cl::opt< unsigned > MaxNumVTableAnnotations

computeVTableFuncs

static void computeVTableFuncs(ModuleSummaryIndex &Index, const GlobalVariable &V, const Module &M, VTableFuncList &VTableFuncs)

Definition:ModuleSummaryAnalysis.cpp:792

computeAliasSummary

static void computeAliasSummary(ModuleSummaryIndex &Index, const GlobalAlias &A, DenseSet< GlobalValue::GUID > &CantBePromoted)

Definition:ModuleSummaryAnalysis.cpp:884

findFuncPointers

static void findFuncPointers(const Constant *I, uint64_t StartingOffset, const Module &M, ModuleSummaryIndex &Index, VTableFuncList &VTableFuncs, const GlobalVariable &OrigGV)

Find function pointers referenced within the given vtable initializer (or subset of an initializer) I...

Definition:ModuleSummaryAnalysis.cpp:720

computeVariableSummary

static void computeVariableSummary(ModuleSummaryIndex &Index, const GlobalVariable &V, DenseSet< GlobalValue::GUID > &CantBePromoted, const Module &M, SmallVectorImpl< MDNode * > &Types)

Definition:ModuleSummaryAnalysis.cpp:833

setLiveRoot

static void setLiveRoot(ModuleSummaryIndex &Index, StringRef Name)

Definition:ModuleSummaryAnalysis.cpp:908

getHotness

static CalleeInfo::HotnessType getHotness(uint64_t ProfileCount, ProfileSummaryInfo *PSI)

Definition:ModuleSummaryAnalysis.cpp:166

EnableMemProfIndirectCallSupport

static cl::opt< bool > EnableMemProfIndirectCallSupport("enable-memprof-indirect-call-support", cl::init(false), cl::Hidden, cl::desc("Enable MemProf support for summarizing and cloning indirect calls"))

isNonVolatileLoad

static bool isNonVolatileLoad(const Instruction *I)

Definition:ModuleSummaryAnalysis.cpp:276

ScalePartialSampleProfileWorkingSetSize

cl::opt< bool > ScalePartialSampleProfileWorkingSetSize

MemProfReportHintedSizes

cl::opt< bool > MemProfReportHintedSizes

isNonRenamableLocal

static bool isNonRenamableLocal(const GlobalValue &GV)

Definition:ModuleSummaryAnalysis.cpp:177

computeFunctionSummary

static void computeFunctionSummary(ModuleSummaryIndex &Index, const Module &M, const Function &F, BlockFrequencyInfo *BFI, ProfileSummaryInfo *PSI, DominatorTree &DT, bool HasLocalsInUsedOrAsm, DenseSet< GlobalValue::GUID > &CantBePromoted, bool IsThinLTO, std::function< const StackSafetyInfo *(const Function &F)> GetSSICallback)

Definition:ModuleSummaryAnalysis.cpp:302

FSEC

static cl::opt< FunctionSummary::ForceSummaryHotnessType, true > FSEC("force-summary-edges-cold", cl::Hidden, cl::location(ForceSummaryEdgesCold), cl::desc("Force all edges in the function summary to cold"), cl::values(clEnumValN(FunctionSummary::FSHT_None, "none", "None."), clEnumValN(FunctionSummary::FSHT_AllNonCritical, "all-non-critical", "All non-critical edges."), clEnumValN(FunctionSummary::FSHT_All, "all", "All edges.")))

mustBeUnreachableFunction

static bool mustBeUnreachableFunction(const Function &F)

Definition:ModuleSummaryAnalysis.cpp:295

isNonVolatileStore

static bool isNonVolatileStore(const Instruction *I)

Definition:ModuleSummaryAnalysis.cpp:283

analysis

module summary analysis

Definition:ModuleSummaryAnalysis.cpp:1153

ModuleSummaryDotFile

static cl::opt< std::string > ModuleSummaryDotFile("module-summary-dot-file", cl::Hidden, cl::value_desc("filename"), cl::desc("File to emit dot graph of new summary into"))

findRefEdges

static bool findRefEdges(ModuleSummaryIndex &Index, const User *CurUser, SetVector< ValueInfo, SmallVector< ValueInfo, 0 > > &RefEdges, SmallPtrSet< const User *, 8 > &Visited, bool &RefLocalLinkageIFunc)

Definition:ModuleSummaryAnalysis.cpp:107

addIntrinsicToSummary

static void addIntrinsicToSummary(const CallInst *CI, SetVector< GlobalValue::GUID, std::vector< GlobalValue::GUID > > &TypeTests, SetVector< FunctionSummary::VFuncId, std::vector< FunctionSummary::VFuncId > > &TypeTestAssumeVCalls, SetVector< FunctionSummary::VFuncId, std::vector< FunctionSummary::VFuncId > > &TypeCheckedLoadVCalls, SetVector< FunctionSummary::ConstVCall, std::vector< FunctionSummary::ConstVCall > > &TypeTestAssumeConstVCalls, SetVector< FunctionSummary::ConstVCall, std::vector< FunctionSummary::ConstVCall > > &TypeCheckedLoadConstVCalls, DominatorTree &DT)

If this intrinsic call requires that we add information to the function summary, do so via the non-co...

Definition:ModuleSummaryAnalysis.cpp:204

recordTypeIdCompatibleVtableReferences

static void recordTypeIdCompatibleVtableReferences(ModuleSummaryIndex &Index, const GlobalVariable &V, SmallVectorImpl< MDNode * > &Types)

Record vtable definition V for each type metadata it references.

Definition:ModuleSummaryAnalysis.cpp:816

ModuleSummaryAnalysis.h

This is the interface to build a ModuleSummaryIndex for a module.

ModuleSummaryIndex.h

ModuleSummaryIndex.h This file contains the declarations the classes that hold the module index and s...

ModuleSymbolTable.h

#define P(N)

FAM

FunctionAnalysisManager FAM

Definition:PassBuilderBindings.cpp:61

INITIALIZE_PASS_DEPENDENCY

#define INITIALIZE_PASS_DEPENDENCY(depName)

Definition:PassSupport.h:55

INITIALIZE_PASS_END

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

Definition:PassSupport.h:57

INITIALIZE_PASS_BEGIN

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

Definition:PassSupport.h:52

INITIALIZE_PASS

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

Definition:PassSupport.h:38

Pass.h

ProfileSummaryInfo.h

assert

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

STLExtras.h

This file contains some templates that are useful if you are working with the STL at all.

SetVector.h

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

SmallPtrSet.h

This file defines the SmallPtrSet class.

SmallVector.h

This file defines the SmallVector class.

StackSafetyAnalysis.h

Value * RHS

Definition:X86PartialReduction.cpp:74

LHS

Value * LHS

Definition:X86PartialReduction.cpp:73

ArrayType

Definition:ItaniumDemangle.h:785

StackNode

Definition:LoopUnroll.cpp:221

bool

llvm::APSInt

An arbitrary precision integer that knows its signedness.

Definition:APSInt.h:23

llvm::AnalysisManager

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

Definition:PassManager.h:253

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

Represent the analysis usage information of a pass.

Definition:PassAnalysisSupport.h:47

llvm::AnalysisUsage::addRequired

AnalysisUsage & addRequired()

Definition:PassAnalysisSupport.h:75

llvm::AnalysisUsage::setPreservesAll

void setPreservesAll()

Set by analyses that do not transform their input at all.

Definition:PassAnalysisSupport.h:130

llvm::ArrayRef

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

Definition:ArrayRef.h:41

llvm::BasicBlock

LLVM Basic Block Representation.

Definition:BasicBlock.h:61

llvm::BlockAddress::get

static BlockAddress * get(Function *F, BasicBlock *BB)

Return a BlockAddress for the specified function and basic block.

Definition:Constants.cpp:1897

llvm::BlockFrequencyAnalysis

Analysis pass which computes BlockFrequencyInfo.

Definition:BlockFrequencyInfo.h:114

llvm::BlockFrequencyInfoWrapperPass

Legacy analysis pass which computes BlockFrequencyInfo.

Definition:BlockFrequencyInfo.h:141

llvm::BlockFrequencyInfo

BlockFrequencyInfo pass uses BlockFrequencyInfoImpl implementation to estimate IR basic block frequen...

Definition:BlockFrequencyInfo.h:37

llvm::BranchProbabilityInfo

Analysis providing branch probability information.

Definition:BranchProbabilityInfo.h:112

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

Value * getArgOperand(unsigned i) const

Definition:InstrTypes.h:1286

llvm::CallInst

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

Definition:Instructions.h:1479

llvm::Constant

This is an important base class in LLVM.

Definition:Constant.h:42

llvm::DWARFExpression::Operation

This class represents an Operation in the Expression.

Definition:DWARFExpression.h:32

llvm::DataLayout

A parsed version of the target data layout string in and methods for querying it.

Definition:DataLayout.h:63

llvm::DenseSet

Implements a dense probed hash-table based set.

Definition:DenseSet.h:278

llvm::DominatorTree

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

Definition:Dominators.h:162

llvm::FunctionSummary::EdgeTy

std::pair< ValueInfo, CalleeInfo > EdgeTy

<CalleeValueInfo, CalleeInfo> call edge pair.

Definition:ModuleSummaryIndex.h:723

llvm::FunctionSummary::ForceSummaryHotnessType

ForceSummaryHotnessType

Types for -force-summary-edges-cold debugging option.

Definition:ModuleSummaryIndex.h:726

llvm::FunctionSummary::FSHT_None

@ FSHT_None

Definition:ModuleSummaryIndex.h:727

llvm::FunctionSummary::FSHT_AllNonCritical

@ FSHT_AllNonCritical

Definition:ModuleSummaryIndex.h:728

llvm::FunctionSummary::FSHT_All

@ FSHT_All

Definition:ModuleSummaryIndex.h:729

llvm::Function::ProfileCount

Class to represent profile counts.

Definition:Function.h:292

llvm::Function

Definition:Function.h:63

llvm::Function::getIntrinsicID

Intrinsic::ID getIntrinsicID() const LLVM_READONLY

getIntrinsicID - This method returns the ID number of the specified function, or Intrinsic::not_intri...

Definition:Function.h:251

llvm::GlobalAlias

Definition:GlobalAlias.h:28

llvm::GlobalIFunc

Definition:GlobalIFunc.h:34

llvm::GlobalObject

Definition:GlobalObject.h:27

llvm::GlobalObject::VCallVisibilityPublic

@ VCallVisibilityPublic

Definition:GlobalObject.h:34

llvm::GlobalValueSummary::Definition

@ Definition

Definition:ModuleSummaryIndex.h:474

llvm::GlobalValue

Definition:GlobalValue.h:48

llvm::GlobalValue::isDSOLocal

bool isDSOLocal() const

Definition:GlobalValue.h:306

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::GlobalValue::hasLocalLinkage

bool hasLocalLinkage() const

Definition:GlobalValue.h:529

llvm::GlobalValue::getGUID

static GUID getGUID(StringRef GlobalName)

Return a 64-bit global unique ID constructed from global value name (i.e.

Definition:Globals.cpp:75

llvm::GlobalValue::getGUID

GUID getGUID() const

Return a 64-bit global unique ID constructed from global value name (i.e.

Definition:GlobalValue.h:596

llvm::GlobalValue::DefaultVisibility

@ DefaultVisibility

The GV is visible.

Definition:GlobalValue.h:67

llvm::GlobalValue::hasSection

bool hasSection() const

Definition:GlobalValue.h:291

llvm::GlobalValue::canBeOmittedFromSymbolTable

bool canBeOmittedFromSymbolTable() const

True if GV can be left out of the object symbol table.

Definition:Globals.cpp:425

llvm::GlobalValue::InternalLinkage

@ InternalLinkage

Rename collisions when linking (static functions).

Definition:GlobalValue.h:59

llvm::GlobalVariable

Definition:GlobalVariable.h:39

llvm::GlobalVariable::getInitializer

const Constant * getInitializer() const

getInitializer - Return the initializer for this global variable.

Definition:GlobalVariable.h:150

llvm::ICallPromotionAnalysis

Definition:IndirectCallPromotionAnalysis.h:24

llvm::ICallPromotionAnalysis::getPromotionCandidatesForInstruction

MutableArrayRef< InstrProfValueData > getPromotionCandidatesForInstruction(const Instruction *I, uint64_t &TotalCount, uint32_t &NumCandidates)

Returns reference to array of InstrProfValueData for the given instruction I.

Definition:IndirectCallPromotionAnalysis.cpp:84

llvm::ImmutableModuleSummaryIndexWrapperPass

Legacy wrapper pass to provide the ModuleSummaryIndex object.

Definition:ModuleSummaryAnalysis.h:82

llvm::ImmutableModuleSummaryIndexWrapperPass::ID

static char ID

Definition:ModuleSummaryAnalysis.h:86

llvm::ImmutableModuleSummaryIndexWrapperPass::ImmutableModuleSummaryIndexWrapperPass

ImmutableModuleSummaryIndexWrapperPass(const ModuleSummaryIndex *Index=nullptr)

Definition:ModuleSummaryAnalysis.cpp:1199

llvm::ImmutableModuleSummaryIndexWrapperPass::getAnalysisUsage

void getAnalysisUsage(AnalysisUsage &AU) const override

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

Definition:ModuleSummaryAnalysis.cpp:1206

llvm::ImmutablePass

ImmutablePass class - This class is used to provide information that does not need to be run.

Definition:Pass.h:281

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

Definition:LoopInfo.h:407

llvm::MDNode

Metadata node.

Definition:Metadata.h:1073

llvm::MDNode::getOperand

const MDOperand & getOperand(unsigned I) const

Definition:Metadata.h:1434

llvm::MDNode::getNumOperands

unsigned getNumOperands() const

Return number of MDNode operands.

Definition:Metadata.h:1440

llvm::MapVector

This class implements a map that also provides access to all stored values in a deterministic order.

Definition:MapVector.h:36

llvm::MapVector::takeVector

VectorType takeVector()

Clear the MapVector and return the underlying vector.

Definition:MapVector.h:55

llvm::ModulePass

ModulePass class - This class is used to implement unstructured interprocedural optimizations and ana...

Definition:Pass.h:251

llvm::ModuleSummaryIndexAnalysis::run

Result run(Module &M, ModuleAnalysisManager &AM)

Definition:ModuleSummaryAnalysis.cpp:1128

llvm::ModuleSummaryIndexWrapperPass

Legacy wrapper pass to provide the ModuleSummaryIndex object.

Definition:ModuleSummaryAnalysis.h:57

llvm::ModuleSummaryIndexWrapperPass::getAnalysisUsage

void getAnalysisUsage(AnalysisUsage &AU) const override

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

Definition:ModuleSummaryAnalysis.cpp:1190

llvm::ModuleSummaryIndexWrapperPass::doFinalization

bool doFinalization(Module &M) override

doFinalization - Virtual method overriden by subclasses to do any necessary clean up after all passes...

Definition:ModuleSummaryAnalysis.cpp:1185

llvm::ModuleSummaryIndexWrapperPass::ModuleSummaryIndexWrapperPass

ModuleSummaryIndexWrapperPass()

Definition:ModuleSummaryAnalysis.cpp:1160

llvm::ModuleSummaryIndexWrapperPass::runOnModule

bool runOnModule(Module &M) override

runOnModule - Virtual method overriden by subclasses to process the module being operated on.

Definition:ModuleSummaryAnalysis.cpp:1165

llvm::ModuleSummaryIndexWrapperPass::ID

static char ID

Definition:ModuleSummaryAnalysis.h:61

llvm::ModuleSummaryIndex

Class to hold module path string table and global value map, and encapsulate methods for operating on...

Definition:ModuleSummaryIndex.h:1345

llvm::ModuleSymbolTable::CollectAsmSymbols

static void CollectAsmSymbols(const Module &M, function_ref< void(StringRef, object::BasicSymbolRef::Flags)> AsmSymbol)

Parse inline ASM and collect the symbols that are defined or referenced in the current module.

Definition:ModuleSymbolTable.cpp:140

llvm::Module

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

Definition:Module.h:65

llvm::MutableArrayRef

MutableArrayRef - Represent a mutable reference to an array (0 or more elements consecutively in memo...

Definition:ArrayRef.h:310

llvm::PassRegistry::getPassRegistry

static PassRegistry * getPassRegistry()

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

Definition:PassRegistry.cpp:24

llvm::ProfileSummaryAnalysis

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

Definition:ProfileSummaryInfo.h:372

llvm::ProfileSummaryInfoWrapperPass

An analysis pass based on legacy pass manager to deliver ProfileSummaryInfo.

Definition:ProfileSummaryInfo.h:353

llvm::ProfileSummaryInfo

Analysis providing profile information.

Definition:ProfileSummaryInfo.h:41

llvm::ProfileSummaryInfo::getProfileCount

std::optional< uint64_t > getProfileCount(const CallBase &CallInst, BlockFrequencyInfo *BFI, bool AllowSynthetic=false) const

Returns the profile count for CallInst.

Definition:ProfileSummaryInfo.cpp:69

llvm::ProfileSummaryInfo::isColdCount

bool isColdCount(uint64_t C) const

Returns true if count C is considered cold.

Definition:ProfileSummaryInfo.cpp:168

llvm::ProfileSummaryInfo::hasPartialSampleProfile

bool hasPartialSampleProfile() const

Returns true if module M has partial-profile sample profile.

Definition:ProfileSummaryInfo.cpp:217

llvm::ProfileSummaryInfo::isHotCount

bool isHotCount(uint64_t C) const

Returns true if count C is considered hot.

Definition:ProfileSummaryInfo.cpp:164

llvm::SetVector

A vector that has set insertion semantics.

Definition:SetVector.h:57

llvm::SetVector::remove

bool remove(const value_type &X)

Remove an item from the set vector.

Definition:SetVector.h:188

llvm::SetVector::size

size_type size() const

Determine the number of elements in the SetVector.

Definition:SetVector.h:98

llvm::SetVector::takeVector

Vector takeVector()

Clear the SetVector and return the underlying vector.

Definition:SetVector.h:87

llvm::SetVector::insert

bool insert(const value_type &X)

Insert a new element into the SetVector.

Definition:SetVector.h:162

llvm::SmallPtrSetImplBase::empty

bool empty() const

Definition:SmallPtrSet.h:93

llvm::SmallPtrSetImpl::insert

std::pair< iterator, bool > insert(PtrType Ptr)

Inserts Ptr if and only if there is no element in the container equal to Ptr.

Definition:SmallPtrSet.h:384

llvm::SmallPtrSet

SmallPtrSet - This class implements a set which is optimized for holding SmallSize or less elements.

Definition:SmallPtrSet.h:519

llvm::SmallVectorBase::empty

bool empty() const

Definition:SmallVector.h:81

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::SmallVectorImpl::pop_back_val

T pop_back_val()

Definition:SmallVector.h:673

llvm::SmallVectorImpl::erase

iterator erase(const_iterator CI)

Definition:SmallVector.h:737

llvm::SmallVectorTemplateBase::push_back

void push_back(const T &Elt)

Definition:SmallVector.h:413

llvm::SmallVectorTemplateCommon::back

reference back()

Definition:SmallVector.h:308

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

StackSafetyInfo wrapper for the new pass manager.

Definition:StackSafetyAnalysis.h:92

llvm::StackSafetyInfoWrapperPass

StackSafetyInfo wrapper for the legacy pass manager.

Definition:StackSafetyAnalysis.h:112

llvm::StackSafetyInfo

Interface to access stack safety analysis results for single function.

Definition:StackSafetyAnalysis.h:26

llvm::StringRef

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

Definition:StringRef.h:51

llvm::StructLayout

Used to lazily calculate structure layout information for a target machine, based on the DataLayout s...

Definition:DataLayout.h:567

llvm::StructLayout::getElementContainingOffset

unsigned getElementContainingOffset(uint64_t FixedOffset) const

Given a valid byte offset into the structure, returns the structure index that contains it.

Definition:DataLayout.cpp:92

llvm::StructLayout::getElementOffset

TypeSize getElementOffset(unsigned Idx) const

Definition:DataLayout.h:596

llvm::StructType

Class to represent struct types.

Definition:DerivedTypes.h:218

llvm::StructType::elements

ArrayRef< Type * > elements() const

Definition:DerivedTypes.h:357

llvm::Twine

Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...

Definition:Twine.h:81

llvm::Type

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

Definition:Type.h:45

llvm::Type::TypeID

TypeID

Definitions of all of the base types for the Type system.

Definition:Type.h:54

llvm::Use

A Use represents the edge between a Value definition and its users.

Definition:Use.h:43

llvm::User

Definition:User.h:44

llvm::Value

LLVM Value Representation.

Definition:Value.h:74

llvm::Value::getType

Type * getType() const

All values are typed, get the type of this value.

Definition:Value.h:255

llvm::Value::uses

iterator_range< use_iterator > uses()

Definition:Value.h:376

llvm::cl::opt

Definition:CommandLine.h:1423

llvm::detail::DenseSetImpl::insert

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

Definition:DenseSet.h:213

llvm::detail::DenseSetImpl::count

size_type count(const_arg_type_t< ValueT > V) const

Return 1 if the specified key is in the set, 0 otherwise.

Definition:DenseSet.h:95

llvm::memprof::CallStack

Helper class to iterate through stack ids in both metadata (memprof MIB and callsite) and the corresp...

Definition:MemoryProfileInfo.h:147

llvm::memprof::CallStack::end

CallStackIterator end() const

Definition:MemoryProfileInfo.h:168

llvm::memprof::CallStack::beginAfterSharedPrefix

CallStackIterator beginAfterSharedPrefix(CallStack &Other)

Definition:MemoryProfileInfo.h:207

llvm::memprof::CallStack::empty

bool empty() const

Definition:MemoryProfileInfo.h:165

llvm::object::BasicSymbolRef::Flags

Flags

Definition:SymbolicFile.h:108

llvm::object::BasicSymbolRef::SF_Global

@ SF_Global

Definition:SymbolicFile.h:111

llvm::object::BasicSymbolRef::SF_Weak

@ SF_Weak

Definition:SymbolicFile.h:112

llvm::raw_fd_ostream

A raw_ostream that writes to a file descriptor.

Definition:raw_ostream.h:460

Definition:StackSlotColoring.cpp:193

llvm::CallingConv::C

@ C

The default llvm calling convention, compatible with C.

Definition:CallingConv.h:34

llvm::cl::Hidden

@ Hidden

Definition:CommandLine.h:137

llvm::cl::values

ValuesClass values(OptsTy... Options)

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

Definition:CommandLine.h:711

llvm::cl::init

initializer< Ty > init(const Ty &Val)

Definition:CommandLine.h:443

llvm::cl::location

LocationClass< Ty > location(Ty &L)

Definition:CommandLine.h:463

llvm::memprof

Definition:MemoryProfileInfo.h:21

llvm::memprof::getMIBAllocType

AllocationType getMIBAllocType(const MDNode *MIB)

Returns the allocation type from an MIB metadata node.

Definition:MemoryProfileInfo.cpp:94

llvm::memprof::getMIBStackNode

MDNode * getMIBStackNode(const MDNode *MIB)

Returns the stack node from an MIB metadata node.

Definition:MemoryProfileInfo.cpp:88

llvm

This is an optimization pass for GlobalISel generic memory operations.

Definition:AddressRanges.h:18

llvm::drop_begin

auto drop_begin(T &&RangeOrContainer, size_t N=1)

Return a range covering RangeOrContainer with the first N elements excluded.

Definition:STLExtras.h:329

llvm::Offset

@ Offset

Definition:DWP.cpp:480

llvm::all_of

bool all_of(R &&range, UnaryPredicate P)

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

Definition:STLExtras.h:1739

llvm::enumerate

auto enumerate(FirstRange &&First, RestRanges &&...Rest)

Given two or more input ranges, returns a new range whose values are tuples (A, B,...

Definition:STLExtras.h:2448

llvm::IsConstantOffsetFromGlobal

bool IsConstantOffsetFromGlobal(Constant *C, GlobalValue *&GV, APInt &Offset, const DataLayout &DL, DSOLocalEquivalent **DSOEquiv=nullptr)

If this constant is a constant offset from a global, return the global and the constant.

Definition:ConstantFolding.cpp:299

llvm::ForceSummaryEdgesCold

FunctionSummary::ForceSummaryHotnessType ForceSummaryEdgesCold

Definition:ModuleSummaryAnalysis.cpp:67

llvm::needsParamAccessSummary

bool needsParamAccessSummary(const Module &M)

Definition:StackSafetyAnalysis.cpp:1127

llvm::buildModuleSummaryIndex

ModuleSummaryIndex buildModuleSummaryIndex(const Module &M, std::function< BlockFrequencyInfo *(const Function &F)> GetBFICallback, ProfileSummaryInfo *PSI, std::function< const StackSafetyInfo *(const Function &F)> GetSSICallback=[](const Function &F) -> const StackSafetyInfo *{ return nullptr;})

Direct function to compute a ModuleSummaryIndex from a given module.

Definition:ModuleSummaryAnalysis.cpp:914

llvm::initializeModuleSummaryIndexWrapperPassPass

void initializeModuleSummaryIndexWrapperPassPass(PassRegistry &)

llvm::VTableFuncList

std::vector< VirtFuncOffset > VTableFuncList

List of functions referenced by a particular vtable definition.

Definition:ModuleSummaryIndex.h:1133

llvm::any_of

bool any_of(R &&range, UnaryPredicate P)

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

Definition:STLExtras.h:1746

llvm::report_fatal_error

void report_fatal_error(Error Err, bool gen_crash_diag=true)

Report a serious error, calling any installed error handler.

Definition:Error.cpp:167

llvm::findDevirtualizableCallsForTypeCheckedLoad

void findDevirtualizableCallsForTypeCheckedLoad(SmallVectorImpl< DevirtCallSite > &DevirtCalls, SmallVectorImpl< Instruction * > &LoadedPtrs, SmallVectorImpl< Instruction * > &Preds, bool &HasNonCallUses, const CallInst *CI, DominatorTree &DT)

Given a call to the intrinsic @llvm.type.checked.load, find all devirtualizable call sites based on t...

Definition:TypeMetadataUtils.cpp:106

llvm::getValueProfDataFromInst

SmallVector< InstrProfValueData, 4 > getValueProfDataFromInst(const Instruction &Inst, InstrProfValueKind ValueKind, uint32_t MaxNumValueData, uint64_t &TotalC, bool GetNoICPValue=false)

Extract the value profile data from Inst and returns them if Inst is annotated with value profile dat...

Definition:InstrProf.cpp:1369

llvm::createModuleSummaryIndexWrapperPass

ModulePass * createModuleSummaryIndexWrapperPass()

Definition:ModuleSummaryAnalysis.cpp:1156

llvm::createImmutableModuleSummaryIndexWrapperPass

ImmutablePass * createImmutableModuleSummaryIndexWrapperPass(const ModuleSummaryIndex *Index)

Definition:ModuleSummaryAnalysis.cpp:1211

llvm::initializeImmutableModuleSummaryIndexWrapperPassPass

void initializeImmutableModuleSummaryIndexWrapperPassPass(PassRegistry &)

llvm::Guid

@ Guid

Definition:PGOCtxProfWriter.h:22

llvm::mayHaveMemprofSummary

bool mayHaveMemprofSummary(const CallBase *CB)

Returns true if the instruction could have memprof metadata, used to ensure consistency between summa...

llvm::findDevirtualizableCallsForTypeTest

void findDevirtualizableCallsForTypeTest(SmallVectorImpl< DevirtCallSite > &DevirtCalls, SmallVectorImpl< CallInst * > &Assumes, const CallInst *CI, DominatorTree &DT)

Given a call to the intrinsic @llvm.type.test, find all devirtualizable call sites based on the call ...

Definition:TypeMetadataUtils.cpp:84

llvm::collectUsedGlobalVariables

GlobalVariable * collectUsedGlobalVariables(const Module &M, SmallVectorImpl< GlobalValue * > &Vec, bool CompilerUsed)

Given "llvm.used" or "llvm.compiler.used" as a global name, collect the initializer elements of that ...

Definition:Module.cpp:865

llvm::AllocInfo

Summary of memprof metadata on allocations.

Definition:ModuleSummaryIndex.h:405

llvm::AnalysisKey

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

Definition:Analysis.h:28