ModuleSummaryAnalysis.cpp Source File (original) (raw)

56#include

57#include

58#include

60using namespace llvm;

63#define DEBUG_TYPE "module-summary-analysis"

67namespace llvm {

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

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

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

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

93}

100

101

102

103

104

105

106

107static bool

111 bool &RefLocalLinkageIFunc) {

112 bool HasBlockAddress = false;

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

116

117 while (!Worklist.empty()) {

120

121 for (const auto &OI : U->operands()) {

123 if (!Operand)

124 continue;

126 HasBlockAddress = true;

127 continue;

128 }

130

131

132

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

134

135

136

137

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

140 RefLocalLinkageIFunc = true;

141 continue;

142 }

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

144 }

145 continue;

146 }

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

149 }

150 }

151

153 if (I) {

155

156

159

160 for (const auto &V : ValueDataArray)

161 RefEdges.insert(Index.getOrInsertValueInfo(

162 V.Value));

163 }

164 return HasBlockAddress;

165}

166

177

181

182

183

187 &VCalls,

189 std::vectorFunctionSummary::ConstVCall> &ConstVCalls) {

190 std::vector<uint64_t> Args;

191

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

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

196 return;

197 }

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

199 }

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

201}

202

203

204

209 &TypeTestAssumeVCalls,

211 &TypeCheckedLoadVCalls,

213 std::vectorFunctionSummary::ConstVCall>

214 &TypeTestAssumeConstVCalls,

216 std::vectorFunctionSummary::ConstVCall>

217 &TypeCheckedLoadConstVCalls,

220 case Intrinsic::type_test:

221 case Intrinsic::public_type_test: {

224 if (!TypeId)

225 break;

228

229

230

231

232

234 return !isa(CIU.getUser());

235 });

236 if (HasNonAssumeUses)

237 TypeTests.insert(Guid);

238

242 for (auto &Call : DevirtCalls)

244 TypeTestAssumeConstVCalls);

245

246 break;

247 }

248

249 case Intrinsic::type_checked_load_relative:

250 case Intrinsic::type_checked_load: {

253 if (!TypeId)

254 break;

257

261 bool HasNonCallUses = false;

263 HasNonCallUses, CI, DT);

264

265

266 if (HasNonCallUses)

267 TypeTests.insert(Guid);

268 for (auto &Call : DevirtCalls)

270 TypeCheckedLoadConstVCalls);

271

272 break;

273 }

274 default:

275 break;

276 }

277}

278

281 return !LI->isVolatile();

282

283 return false;

284}

285

288 return ->isVolatile();

289

290 return false;

291}

292

293

294

295

296

297

299

300

301 assert(.isDeclaration());

303}

304

309 bool IsThinLTO,

311

312

314

315 unsigned NumInsts = 0;

316

317

320 CallGraphEdges;

322 StoreRefEdges;

325 TypeTestAssumeVCalls, TypeCheckedLoadVCalls;

327 std::vectorFunctionSummary::ConstVCall>

328 TypeTestAssumeConstVCalls, TypeCheckedLoadConstVCalls;

331

332

333

334 bool HasLocalIFuncCallOrRef = false;

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

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

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

338

339 std::vector Callsites;

340 std::vector Allocs;

341

342#ifndef NDEBUG

344#endif

345

346 bool HasInlineAsmMaybeReferencingInternal = false;

347 bool HasIndirBranchToBlockAddress = false;

348 bool HasUnknownCall = false;

349 bool MayThrow = false;

351

352

353

354

355 if (BB.hasAddressTaken()) {

358 HasIndirBranchToBlockAddress = true;

359 break;

360 }

361 }

362

364 if (I.isDebugOrPseudoInst())

365 continue;

366 ++NumInsts;

367

368

369

370

371 if (IsThinLTO) {

373

374

376 NonVolatileLoads.push_back(&I);

377 continue;

380 NonVolatileStores.push_back(&I);

381

382

383

384

385

386

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

389

390

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

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

394 continue;

395 }

396 }

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

399 if (!CB) {

400 if (I.mayThrow())

401 MayThrow = true;

402 continue;

403 }

404

406

407

408

409

410

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

412 HasInlineAsmMaybeReferencingInternal = true;

413

414

418

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

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

421 if (CalledValue && !CalledFunction) {

422 CalledValue = CalledValue->stripPointerCasts();

423

425 }

426

427

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

431 }

432

433

434 if (CalledFunction) {

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

437 CI, TypeTests, TypeTestAssumeVCalls, TypeCheckedLoadVCalls,

438 TypeTestAssumeConstVCalls, TypeCheckedLoadConstVCalls, DT);

439 continue;

440 }

441

442 assert(CalledFunction->hasName());

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

448

449

450

451

452

453 auto &ValueInfo = CallGraphEdges[Index.getOrInsertValueInfo(

455 ValueInfo.updateHotness(Hotness);

456 if (CB->isTailCall())

458

459

464 }

465 } else {

466 HasUnknownCall = true;

467

468

469

470

471

472

473

475 if (GI->hasLocalLinkage())

476 HasLocalIFuncCallOrRef = true;

477

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

479 continue;

480

482 continue;

483

484

485

486

487

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

489 for (const auto &Op : MD->operands()) {

491 if (Callee)

492 CallGraphEdges[Index.getOrInsertValueInfo(Callee)];

493 }

494 }

495

496 CandidateProfileData =

498 NumCandidates);

499 for (const auto &Candidate : CandidateProfileData)

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

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

502 }

503

504

505 if (!IsThinLTO)

506 continue;

507

508

510 continue;

511

512

513

514

516#ifndef NDEBUG

517 CallsThatMayHaveMemprofSummary.insert(CB);

518#endif

519

520

521

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

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

525 if (MemProfMD) {

526 std::vector MIBs;

527 std::vector<std::vector> ContextSizeInfos;

528 bool HasNonZeroContextSizeInfos = false;

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

535

536 for (auto ContextIter =

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

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

540

541

542

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

544 StackIdIndices.push_back(StackIdIdx);

545 }

546

547

548 assert(MIBMD->getNumOperands() > 2 ||

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

551 std::vector ContextSizes;

552 for (unsigned I = 2; I < MIBMD->getNumOperands(); I++) {

557 ->getZExtValue();

560 ->getZExtValue();

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

562 }

563

564

565 HasNonZeroContextSizeInfos = true;

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

567 } else {

568

569

570

571

572

573

574

575 ContextSizeInfos.push_back({{0, 0}});

576 }

577 MIBs.push_back(

579 }

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

581 assert(HasNonZeroContextSizeInfos ||

583

584

585

586

587 if (HasNonZeroContextSizeInfos) {

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

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

590 }

591 } else if (!InstCallsite.empty()) {

593 for (auto StackId : InstCallsite)

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

595 if (CalledFunction) {

596

597

598

599

600 auto CalleeValueInfo =

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

603 } else {

605

606

607

608

609 for (const auto &Candidate : CandidateProfileData) {

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

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

612 }

613 }

614 }

615 }

616 }

617

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

620

622 if (IsThinLTO) {

623 auto AddRefEdges =

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

627 for (const auto *I : Instrs) {

628 Cache.erase(I);

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

630 }

631 };

632

633

634

635

636 AddRefEdges(NonVolatileLoads, LoadRefEdges, Visited);

637

638

639

640

641

642

643

644

645

646

648 AddRefEdges(NonVolatileStores, StoreRefEdges, StoreCache);

649

650

651

652

653 for (const auto &VI : StoreRefEdges)

654 if (LoadRefEdges.remove(VI))

656

657 unsigned RefCnt = RefEdges.size();

658

659

660

662

663 unsigned FirstWORef = RefEdges.size();

665

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

668 Refs[RefCnt].setReadOnly();

669

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

671 Refs[RefCnt].setWriteOnly();

672 } else {

674 }

675

676

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

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

682

683#ifndef NDEBUG

684

685

686

687 if (IsThinLTO) {

691 if (!CB)

692 continue;

693

694 if (CallsThatMayHaveMemprofSummary.count(CB))

695 continue;

697 }

698 }

699 }

700#endif

701

703 bool NotEligibleForImport =

704 NonRenamableLocal || HasInlineAsmMaybeReferencingInternal ||

705 HasIndirBranchToBlockAddress || HasLocalIFuncCallOrRef;

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

708 false, F.isDSOLocal(), F.canBeOmittedFromSymbolTable(),

711 F.doesNotAccessMemory(), F.onlyReadsMemory() && .doesNotAccessMemory(),

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

713

714

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

716 F.hasFnAttribute(Attribute::AlwaysInline),

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

719 std::vectorFunctionSummary::ParamAccess ParamAccesses;

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

721 ParamAccesses = SSI->getParamAccesses(Index);

722 auto FuncSummary = std::make_unique(

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

726 TypeTestAssumeConstVCalls.takeVector(),

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

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

729 if (NonRenamableLocal)

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

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

732}

733

734

735

736

737

738

743

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

745 auto C = I->stripPointerCasts();

750

751

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

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

754 return;

755 }

756 }

757

758

759

764 const StructLayout *SL = DL.getStructLayout(C->getType());

765

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

771 }

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

775 uint64_t EltSize = DL.getTypeAllocSize(EltTy);

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

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

779 OrigGV);

780 }

782

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

785 return;

786

787

788

789

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

792 APSInt LHSOffset, RHSOffset;

795 RHS == &OrigGV &&

796

797

798

799 LHSOffset == 0 &&

800

801

802 RHSOffset <=

805 }

806 }

807 }

808}

809

810

814 if (!V.isConstant())

815 return;

816

817 findFuncPointers(V.getInitializer(), 0, M, Index,

818 VTableFuncs, V);

819

820#ifndef NDEBUG

821

823 for (auto &P : VTableFuncs) {

824

825

826

827 assert(P.VTableOffset >= PrevOffset);

828 PrevOffset = P.VTableOffset;

829 }

830#endif

831}

832

833

834static void

839 auto TypeID = Type->getOperand(1).get();

840

844 ->getZExtValue();

845

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

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

849 }

850}

851

859 bool RefLocalIFunc = false;

860 bool HasBlockAddress =

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

862 const bool NotEligibleForImport = (HasBlockAddress || RefLocalIFunc);

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

866 false, V.isDSOLocal(), V.canBeOmittedFromSymbolTable(),

868

870

871

872 if (!Index.enableSplitLTOUnit()) {

873 Types.clear();

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

875 if (!Types.empty()) {

876

878

879

881 }

882 }

883

884

885 bool CanBeInternalized =

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

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

888 bool Constant = V.isConstant();

890 Constant ? false : CanBeInternalized,

891 Constant, V.getVCallVisibility());

892 auto GVarSummary = std::make_unique(Flags, VarFlags,

894 if (NonRenamableLocal)

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

896 if (NotEligibleForImport)

897 GVarSummary->setNotEligibleToImport();

898 if (!VTableFuncs.empty())

899 GVarSummary->setVTableFuncs(VTableFuncs);

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

901}

902

905

906

907 const GlobalObject *Aliasee = A.getAliaseeObject();

909 return;

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

913 false, A.isDSOLocal(), A.canBeOmittedFromSymbolTable(),

915 auto AS = std::make_unique(Flags);

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

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

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

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

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

921 if (NonRenamableLocal)

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

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

924}

925

926

930 for (const auto &Summary : VI.getSummaryList())

931 Summary->setLive(true);

932}

933

940 bool EnableSplitLTOUnit = false;

941 bool UnifiedLTO = false;

943 M.getModuleFlag("EnableSplitLTOUnit")))

944 EnableSplitLTOUnit = MD->getZExtValue();

945 if (auto *MD =

947 UnifiedLTO = MD->getZExtValue();

948 ModuleSummaryIndex Index(true, EnableSplitLTOUnit, UnifiedLTO);

949

950

951

952

953

954

957

959

962 for (auto *V : Used) {

963 if (V->hasLocalLinkage()) {

964 LocalsUsed.insert(V);

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

966 }

967 }

968

969 bool HasLocalInlineAsmSymbol = false;

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

971

972

973

974

975

976

977

978

979

982

985 return;

986 HasLocalInlineAsmSymbol = true;

988 if (!GV)

989 return;

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

993 true,

994 true,

998

1000 std::unique_ptr Summary =

1001 std::make_unique(

1002 GVFlags, 0,

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

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

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

1007 F->returnDoesNotAlias(),

1008 false,

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

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

1011 true,

1012 true,

1013 false},

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

1024 } else {

1025 std::unique_ptr Summary =

1026 std::make_unique(

1027 GVFlags,

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

1033 }

1034 });

1035 }

1036

1037 bool IsThinLTO = true;

1038 if (auto *MD =

1040 IsThinLTO = MD->getZExtValue();

1041

1042

1043

1044 for (const auto &F : M) {

1045 if (F.isDeclaration())

1046 continue;

1047

1050 std::unique_ptr BFIPtr;

1051 if (GetBFICallback)

1052 BFI = GetBFICallback(F);

1053 else if (F.hasProfileData()) {

1056 BFIPtr = std::make_unique(F, BPI, LI);

1057 BFI = BFIPtr.get();

1058 }

1059

1061 !LocalsUsed.empty() || HasLocalInlineAsmSymbol,

1062 CantBePromoted, IsThinLTO, GetSSICallback);

1063 }

1064

1065

1066

1069 if (G.isDeclaration())

1070 continue;

1072 }

1073

1074

1075

1078

1079

1081 I.applyAlongResolverPath([&Index](const GlobalValue &GV) {

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

1083 });

1084 }

1085

1086 for (auto *V : LocalsUsed) {

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

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

1089 Summary->setNotEligibleToImport();

1090 }

1091

1092

1093

1094

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

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

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

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

1100

1101 for (auto &GlobalList : Index) {

1102

1103 if (GlobalList.second.getSummaryList().empty())

1104 continue;

1105

1106 assert(GlobalList.second.getSummaryList().size() == 1 &&

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

1108 auto &Summary = GlobalList.second.getSummaryList()[0];

1109 if (!IsThinLTO) {

1110 Summary->setNotEligibleToImport();

1111 continue;

1112 }

1113

1114 bool AllRefsCanBeExternallyReferenced =

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

1117 });

1118 if (!AllRefsCanBeExternallyReferenced) {

1119 Summary->setNotEligibleToImport();

1120 continue;

1121 }

1122

1124 bool AllCallsCanBeExternallyReferenced = llvm::all_of(

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

1127 });

1128 if (!AllCallsCanBeExternallyReferenced)

1129 Summary->setNotEligibleToImport();

1130 }

1131 }

1132

1134 std::error_code EC;

1136 if (EC)

1139 Index.exportToDot(OSDot, {});

1140 }

1141

1142 return Index;

1143}

1144

1145AnalysisKey ModuleSummaryIndexAnalysis::Key;

1146

1153 M,

1157 },

1158 &PSI,

1162 : nullptr;

1163 });

1164}

1165

1167

1169 "Module Summary Analysis", false, true)

1175

1179

1182

1187 M,

1191 .getBFI());

1192 },

1193 PSI,

1197 .getResult()

1198 : nullptr;

1199 }));

1200 return false;

1201}

1202

1204 Index.reset();

1205 return false;

1206}

1207

1214

1216

1220

1225

1230

1232 "Module summary info", false, true)

1233

1235 if (!CB)

1236 return false;

1237 if (CB->isDebugOrPseudoInst())

1238 return false;

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

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

1242 if (CalledValue && !CalledFunction) {

1243 CalledValue = CalledValue->stripPointerCasts();

1244

1246 }

1247

1248

1250 assert(!CalledFunction &&

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

1253 }

1254

1255

1256 if (CalledFunction) {

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

1258 return false;

1259 } else {

1260

1262 return false;

1263

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

1265 return false;

1266

1268 return false;

1269 return true;

1270 }

1271 return true;

1272}

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

static bool isConstant(const MachineInstr &MI)

MachineBasicBlock MachineBasicBlock::iterator DebugLoc DL

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

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

#define clEnumValN(ENUMVAL, FLAGNAME, DESC)

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

This file defines the DenseSet and SmallDenseSet classes.

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

This defines the Use class.

This file implements a map that provides insertion order iteration.

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

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

Definition ModuleSummaryAnalysis.cpp:811

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

Definition ModuleSummaryAnalysis.cpp:903

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

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

Definition ModuleSummaryAnalysis.cpp:852

static void setLiveRoot(ModuleSummaryIndex &Index, StringRef Name)

Definition ModuleSummaryAnalysis.cpp:927

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

Definition ModuleSummaryAnalysis.cpp:167

static bool isNonVolatileLoad(const Instruction *I)

Definition ModuleSummaryAnalysis.cpp:279

static bool isNonRenamableLocal(const GlobalValue &GV)

Definition ModuleSummaryAnalysis.cpp:178

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

static bool mustBeUnreachableFunction(const Function &F)

Definition ModuleSummaryAnalysis.cpp:298

static bool isNonVolatileStore(const Instruction *I)

Definition ModuleSummaryAnalysis.cpp:286

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

Definition ModuleSummaryAnalysis.cpp:108

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

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

Record vtable definition V for each type metadata it references.

Definition ModuleSummaryAnalysis.cpp:835

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

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

FunctionAnalysisManager FAM

#define INITIALIZE_PASS_DEPENDENCY(depName)

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

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

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

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

This file defines the SmallPtrSet class.

This file defines the SmallVector class.

An arbitrary precision integer that knows its signedness.

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

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

Represent the analysis usage information of a pass.

AnalysisUsage & addRequired()

void setPreservesAll()

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

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

LLVM Basic Block Representation.

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

Return a BlockAddress for the specified function and basic block.

Analysis pass which computes BlockFrequencyInfo.

Legacy analysis pass which computes BlockFrequencyInfo.

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

LLVM_ABI BlockFrequency getEntryFreq() const

LLVM_ABI BlockFrequency getBlockFreq(const BasicBlock *BB) const

getblockFreq - Return block frequency.

uint64_t getFrequency() const

Returns the frequency as a fixpoint number scaled by the entry frequency.

Analysis providing branch probability information.

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

Function * getCalledFunction() const

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

Value * getArgOperand(unsigned i) const

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

This is an important base class in LLVM.

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

Implements a dense probed hash-table based set.

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

std::pair< ValueInfo, CalleeInfo > EdgeTy

<CalleeValueInfo, CalleeInfo> call edge pair.

ForceSummaryHotnessType

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

Intrinsic::ID getIntrinsicID() const LLVM_READONLY

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

static LLVM_ABI GUID getGUIDAssumingExternalLinkage(StringRef GlobalName)

Return a 64-bit global unique ID constructed from the name of a global symbol.

LLVM_ABI bool isDeclaration() const

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

uint64_t GUID

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

bool hasLocalLinkage() const

GUID getGUID() const

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

@ DefaultVisibility

The GV is visible.

LLVM_ABI bool canBeOmittedFromSymbolTable() const

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

@ InternalLinkage

Rename collisions when linking (static functions).

const Constant * getInitializer() const

getInitializer - Return the initializer for this global variable.

Legacy wrapper pass to provide the ModuleSummaryIndex object.

ImmutableModuleSummaryIndexWrapperPass(const ModuleSummaryIndex *Index=nullptr)

Definition ModuleSummaryAnalysis.cpp:1217

void getAnalysisUsage(AnalysisUsage &AU) const override

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

Definition ModuleSummaryAnalysis.cpp:1221

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

const MDOperand & getOperand(unsigned I) const

unsigned getNumOperands() const

Return number of MDNode operands.

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

VectorType takeVector()

Clear the MapVector and return the underlying vector.

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

LLVM_ABI Result run(Module &M, ModuleAnalysisManager &AM)

Definition ModuleSummaryAnalysis.cpp:1148

Legacy wrapper pass to provide the ModuleSummaryIndex object.

void getAnalysisUsage(AnalysisUsage &AU) const override

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

Definition ModuleSummaryAnalysis.cpp:1208

bool doFinalization(Module &M) override

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

Definition ModuleSummaryAnalysis.cpp:1203

ModuleSummaryIndexWrapperPass()

Definition ModuleSummaryAnalysis.cpp:1180

bool runOnModule(Module &M) override

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

Definition ModuleSummaryAnalysis.cpp:1183

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

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

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

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

AnalysisType & getAnalysis() const

getAnalysis() - This function is used by subclasses to get to the analysis information ...

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

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

Analysis providing profile information.

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

Returns the profile count for CallInst.

LLVM_ABI bool isColdCount(uint64_t C) const

Returns true if count C is considered cold.

LLVM_ABI bool hasPartialSampleProfile() const

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

LLVM_ABI bool isHotCount(uint64_t C) const

Returns true if count C is considered hot.

A vector that has set insertion semantics.

bool remove(const value_type &X)

Remove an item from the set vector.

size_type size() const

Determine the number of elements in the SetVector.

void insert_range(Range &&R)

Vector takeVector()

Clear the SetVector and return the underlying vector.

bool insert(const value_type &X)

Insert a new element into the SetVector.

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

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

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

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

void push_back(const T &Elt)

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

StackSafetyInfo wrapper for the new pass manager.

StackSafetyInfo wrapper for the legacy pass manager.

Interface to access stack safety analysis results for single function.

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

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

LLVM_ABI unsigned getElementContainingOffset(uint64_t FixedOffset) const

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

TypeSize getElementOffset(unsigned Idx) const

Class to represent struct types.

ArrayRef< Type * > elements() const

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

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

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

LLVM Value Representation.

Type * getType() const

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

iterator_range< use_iterator > uses()

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

size_type count(const_arg_type_t< ValueT > V) const

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

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

CallStackIterator beginAfterSharedPrefix(const CallStack &Other)

CallStackIterator end() const

A raw_ostream that writes to a file descriptor.

@ 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)

LocationClass< Ty > location(Ty &L)

std::enable_if_t< detail::IsValidPointer< X, Y >::value, X * > extract_or_null(Y &&MD)

Extract a Value from Metadata, allowing null.

std::enable_if_t< detail::IsValidPointer< X, Y >::value, X * > dyn_extract(Y &&MD)

Extract a Value from Metadata, if any.

LLVM_ABI bool metadataIncludesAllContextSizeInfo()

Whether the alloc memeprof metadata will include context size info for all MIBs.

LLVM_ABI AllocationType getMIBAllocType(const MDNode *MIB)

Returns the allocation type from an MIB metadata node.

LLVM_ABI MDNode * getMIBStackNode(const MDNode *MIB)

Returns the stack node from an MIB metadata node.

@ OF_Text

The file should be opened in text mode on platforms like z/OS that make this distinction.

This is an optimization pass for GlobalISel generic memory operations.

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

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

cl::opt< bool > MemProfReportHintedSizes("memprof-report-hinted-sizes", cl::init(false), cl::Hidden, cl::desc("Report total allocation sizes of hinted allocations"))

Definition ModuleSummaryAnalysis.cpp:92

std::vector< VirtFuncOffset > VTableFuncList

List of functions referenced by a particular vtable definition.

bool all_of(R &&range, UnaryPredicate P)

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

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

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

decltype(auto) dyn_cast(const From &Val)

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

LLVM_ABI bool mayHaveMemprofSummary(const CallBase *CB)

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

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

auto dyn_cast_if_present(const Y &Val)

dyn_cast_if_present - Functionally identical to dyn_cast, except that a null (or none in the case ...

FunctionSummary::ForceSummaryHotnessType ForceSummaryEdgesCold

Definition ModuleSummaryAnalysis.cpp:68

bool needsParamAccessSummary(const Module &M)

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"))

InnerAnalysisManagerProxy< FunctionAnalysisManager, Module > FunctionAnalysisManagerModuleProxy

Provide the FunctionAnalysisManager to Module proxy.

LLVM_ABI 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:934

cl::opt< unsigned > MaxNumVTableAnnotations("icp-max-num-vtables", cl::init(6), cl::Hidden, cl::desc("Max number of vtables annotated for a vtable load instruction."))

Definition ModuleSummaryAnalysis.cpp:90

LLVM_ABI cl::opt< bool > ScalePartialSampleProfileWorkingSetSize

bool any_of(R &&range, UnaryPredicate P)

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

LLVM_ABI void report_fatal_error(Error Err, bool gen_crash_diag=true)

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

Function::ProfileCount ProfileCount

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

LLVM_ABI ModulePass * createModuleSummaryIndexWrapperPass()

Definition ModuleSummaryAnalysis.cpp:1176

bool isa(const From &Val)

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

DWARFExpression::Operation Op

LLVM_ABI ImmutablePass * createImmutableModuleSummaryIndexWrapperPass(const ModuleSummaryIndex *Index)

Definition ModuleSummaryAnalysis.cpp:1226

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

decltype(auto) cast(const From &Val)

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

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

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

AnalysisManager< Module > ModuleAnalysisManager

Convenience typedef for the Module analysis manager.

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

Summary of memprof metadata on allocations.

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

A call site that could be devirtualized.

A specification for a virtual function call with all constant integer arguments.

Flags specific to function summaries.

An "identifier" for a virtual function.

Group flags (Linkage, NotEligibleToImport, etc.) as a bitfield.

Summary of a single MIB in a memprof metadata on allocations.

Struct that holds a reference to a particular GUID in a global value summary.