1 //===- ModuleSummaryAnalysis.cpp - Module summary index builder -----------===// 2 // 3 // The LLVM Compiler Infrastructure 4 // 5 // This file is distributed under the University of Illinois Open Source 6 // License. See LICENSE.TXT for details. 7 // 8 //===----------------------------------------------------------------------===// 9 // 10 // This pass builds a ModuleSummaryIndex object for the module, to be written 11 // to bitcode or LLVM assembly. 12 // 13 //===----------------------------------------------------------------------===// 14 15 #include "llvm/Analysis/ModuleSummaryAnalysis.h" 16 #include "llvm/ADT/MapVector.h" 17 #include "llvm/ADT/SetVector.h" 18 #include "llvm/ADT/Triple.h" 19 #include "llvm/Analysis/BlockFrequencyInfo.h" 20 #include "llvm/Analysis/BlockFrequencyInfoImpl.h" 21 #include "llvm/Analysis/BranchProbabilityInfo.h" 22 #include "llvm/Analysis/IndirectCallPromotionAnalysis.h" 23 #include "llvm/Analysis/LoopInfo.h" 24 #include "llvm/Analysis/ProfileSummaryInfo.h" 25 #include "llvm/Analysis/TypeMetadataUtils.h" 26 #include "llvm/IR/CallSite.h" 27 #include "llvm/IR/Dominators.h" 28 #include "llvm/IR/InstIterator.h" 29 #include "llvm/IR/IntrinsicInst.h" 30 #include "llvm/IR/ValueSymbolTable.h" 31 #include "llvm/Object/IRObjectFile.h" 32 #include "llvm/Pass.h" 33 using namespace llvm; 34 35 #define DEBUG_TYPE "module-summary-analysis" 36 37 // Walk through the operands of a given User via worklist iteration and populate 38 // the set of GlobalValue references encountered. Invoked either on an 39 // Instruction or a GlobalVariable (which walks its initializer). 40 static void findRefEdges(const User *CurUser, SetVector<ValueInfo> &RefEdges, 41 SmallPtrSet<const User *, 8> &Visited) { 42 SmallVector<const User *, 32> Worklist; 43 Worklist.push_back(CurUser); 44 45 while (!Worklist.empty()) { 46 const User *U = Worklist.pop_back_val(); 47 48 if (!Visited.insert(U).second) 49 continue; 50 51 ImmutableCallSite CS(U); 52 53 for (const auto &OI : U->operands()) { 54 const User *Operand = dyn_cast<User>(OI); 55 if (!Operand) 56 continue; 57 if (isa<BlockAddress>(Operand)) 58 continue; 59 if (auto *GV = dyn_cast<GlobalValue>(Operand)) { 60 // We have a reference to a global value. This should be added to 61 // the reference set unless it is a callee. Callees are handled 62 // specially by WriteFunction and are added to a separate list. 63 if (!(CS && CS.isCallee(&OI))) 64 RefEdges.insert(GV); 65 continue; 66 } 67 Worklist.push_back(Operand); 68 } 69 } 70 } 71 72 static CalleeInfo::HotnessType getHotness(uint64_t ProfileCount, 73 ProfileSummaryInfo *PSI) { 74 if (!PSI) 75 return CalleeInfo::HotnessType::Unknown; 76 if (PSI->isHotCount(ProfileCount)) 77 return CalleeInfo::HotnessType::Hot; 78 if (PSI->isColdCount(ProfileCount)) 79 return CalleeInfo::HotnessType::Cold; 80 return CalleeInfo::HotnessType::None; 81 } 82 83 static bool isNonRenamableLocal(const GlobalValue &GV) { 84 return GV.hasSection() && GV.hasLocalLinkage(); 85 } 86 87 /// Determine whether this call has all constant integer arguments (excluding 88 /// "this") and summarize it to VCalls or ConstVCalls as appropriate. 89 static void addVCallToSet(DevirtCallSite Call, GlobalValue::GUID Guid, 90 SetVector<FunctionSummary::VFuncId> &VCalls, 91 SetVector<FunctionSummary::ConstVCall> &ConstVCalls) { 92 std::vector<uint64_t> Args; 93 // Start from the second argument to skip the "this" pointer. 94 for (auto &Arg : make_range(Call.CS.arg_begin() + 1, Call.CS.arg_end())) { 95 auto *CI = dyn_cast<ConstantInt>(Arg); 96 if (!CI || CI->getBitWidth() > 64) { 97 VCalls.insert({Guid, Call.Offset}); 98 return; 99 } 100 Args.push_back(CI->getZExtValue()); 101 } 102 ConstVCalls.insert({{Guid, Call.Offset}, std::move(Args)}); 103 } 104 105 /// If this intrinsic call requires that we add information to the function 106 /// summary, do so via the non-constant reference arguments. 107 static void addIntrinsicToSummary( 108 const CallInst *CI, SetVector<GlobalValue::GUID> &TypeTests, 109 SetVector<FunctionSummary::VFuncId> &TypeTestAssumeVCalls, 110 SetVector<FunctionSummary::VFuncId> &TypeCheckedLoadVCalls, 111 SetVector<FunctionSummary::ConstVCall> &TypeTestAssumeConstVCalls, 112 SetVector<FunctionSummary::ConstVCall> &TypeCheckedLoadConstVCalls) { 113 switch (CI->getCalledFunction()->getIntrinsicID()) { 114 case Intrinsic::type_test: { 115 auto *TypeMDVal = cast<MetadataAsValue>(CI->getArgOperand(1)); 116 auto *TypeId = dyn_cast<MDString>(TypeMDVal->getMetadata()); 117 if (!TypeId) 118 break; 119 GlobalValue::GUID Guid = GlobalValue::getGUID(TypeId->getString()); 120 121 // Produce a summary from type.test intrinsics. We only summarize type.test 122 // intrinsics that are used other than by an llvm.assume intrinsic. 123 // Intrinsics that are assumed are relevant only to the devirtualization 124 // pass, not the type test lowering pass. 125 bool HasNonAssumeUses = llvm::any_of(CI->uses(), [](const Use &CIU) { 126 auto *AssumeCI = dyn_cast<CallInst>(CIU.getUser()); 127 if (!AssumeCI) 128 return true; 129 Function *F = AssumeCI->getCalledFunction(); 130 return !F || F->getIntrinsicID() != Intrinsic::assume; 131 }); 132 if (HasNonAssumeUses) 133 TypeTests.insert(Guid); 134 135 SmallVector<DevirtCallSite, 4> DevirtCalls; 136 SmallVector<CallInst *, 4> Assumes; 137 findDevirtualizableCallsForTypeTest(DevirtCalls, Assumes, CI); 138 for (auto &Call : DevirtCalls) 139 addVCallToSet(Call, Guid, TypeTestAssumeVCalls, 140 TypeTestAssumeConstVCalls); 141 142 break; 143 } 144 145 case Intrinsic::type_checked_load: { 146 auto *TypeMDVal = cast<MetadataAsValue>(CI->getArgOperand(2)); 147 auto *TypeId = dyn_cast<MDString>(TypeMDVal->getMetadata()); 148 if (!TypeId) 149 break; 150 GlobalValue::GUID Guid = GlobalValue::getGUID(TypeId->getString()); 151 152 SmallVector<DevirtCallSite, 4> DevirtCalls; 153 SmallVector<Instruction *, 4> LoadedPtrs; 154 SmallVector<Instruction *, 4> Preds; 155 bool HasNonCallUses = false; 156 findDevirtualizableCallsForTypeCheckedLoad(DevirtCalls, LoadedPtrs, Preds, 157 HasNonCallUses, CI); 158 // Any non-call uses of the result of llvm.type.checked.load will 159 // prevent us from optimizing away the llvm.type.test. 160 if (HasNonCallUses) 161 TypeTests.insert(Guid); 162 for (auto &Call : DevirtCalls) 163 addVCallToSet(Call, Guid, TypeCheckedLoadVCalls, 164 TypeCheckedLoadConstVCalls); 165 166 break; 167 } 168 default: 169 break; 170 } 171 } 172 173 static void 174 computeFunctionSummary(ModuleSummaryIndex &Index, const Module &M, 175 const Function &F, BlockFrequencyInfo *BFI, 176 ProfileSummaryInfo *PSI, bool HasLocalsInUsed, 177 DenseSet<GlobalValue::GUID> &CantBePromoted) { 178 // Summary not currently supported for anonymous functions, they should 179 // have been named. 180 assert(F.hasName()); 181 182 unsigned NumInsts = 0; 183 // Map from callee ValueId to profile count. Used to accumulate profile 184 // counts for all static calls to a given callee. 185 MapVector<ValueInfo, CalleeInfo> CallGraphEdges; 186 SetVector<ValueInfo> RefEdges; 187 SetVector<GlobalValue::GUID> TypeTests; 188 SetVector<FunctionSummary::VFuncId> TypeTestAssumeVCalls, 189 TypeCheckedLoadVCalls; 190 SetVector<FunctionSummary::ConstVCall> TypeTestAssumeConstVCalls, 191 TypeCheckedLoadConstVCalls; 192 ICallPromotionAnalysis ICallAnalysis; 193 194 bool HasInlineAsmMaybeReferencingInternal = false; 195 SmallPtrSet<const User *, 8> Visited; 196 for (const BasicBlock &BB : F) 197 for (const Instruction &I : BB) { 198 if (isa<DbgInfoIntrinsic>(I)) 199 continue; 200 ++NumInsts; 201 findRefEdges(&I, RefEdges, Visited); 202 auto CS = ImmutableCallSite(&I); 203 if (!CS) 204 continue; 205 206 const auto *CI = dyn_cast<CallInst>(&I); 207 // Since we don't know exactly which local values are referenced in inline 208 // assembly, conservatively mark the function as possibly referencing 209 // a local value from inline assembly to ensure we don't export a 210 // reference (which would require renaming and promotion of the 211 // referenced value). 212 if (HasLocalsInUsed && CI && CI->isInlineAsm()) 213 HasInlineAsmMaybeReferencingInternal = true; 214 215 auto *CalledValue = CS.getCalledValue(); 216 auto *CalledFunction = CS.getCalledFunction(); 217 // Check if this is an alias to a function. If so, get the 218 // called aliasee for the checks below. 219 if (auto *GA = dyn_cast<GlobalAlias>(CalledValue)) { 220 assert(!CalledFunction && "Expected null called function in callsite for alias"); 221 CalledFunction = dyn_cast<Function>(GA->getBaseObject()); 222 } 223 // Check if this is a direct call to a known function or a known 224 // intrinsic, or an indirect call with profile data. 225 if (CalledFunction) { 226 if (CI && CalledFunction->isIntrinsic()) { 227 addIntrinsicToSummary( 228 CI, TypeTests, TypeTestAssumeVCalls, TypeCheckedLoadVCalls, 229 TypeTestAssumeConstVCalls, TypeCheckedLoadConstVCalls); 230 continue; 231 } 232 // We should have named any anonymous globals 233 assert(CalledFunction->hasName()); 234 auto ScaledCount = BFI ? BFI->getBlockProfileCount(&BB) : None; 235 auto Hotness = ScaledCount ? getHotness(ScaledCount.getValue(), PSI) 236 : CalleeInfo::HotnessType::Unknown; 237 238 // Use the original CalledValue, in case it was an alias. We want 239 // to record the call edge to the alias in that case. Eventually 240 // an alias summary will be created to associate the alias and 241 // aliasee. 242 CallGraphEdges[cast<GlobalValue>(CalledValue)].updateHotness(Hotness); 243 } else { 244 // Skip inline assembly calls. 245 if (CI && CI->isInlineAsm()) 246 continue; 247 // Skip direct calls. 248 if (!CS.getCalledValue() || isa<Constant>(CS.getCalledValue())) 249 continue; 250 251 uint32_t NumVals, NumCandidates; 252 uint64_t TotalCount; 253 auto CandidateProfileData = 254 ICallAnalysis.getPromotionCandidatesForInstruction( 255 &I, NumVals, TotalCount, NumCandidates); 256 for (auto &Candidate : CandidateProfileData) 257 CallGraphEdges[Candidate.Value].updateHotness( 258 getHotness(Candidate.Count, PSI)); 259 } 260 } 261 262 bool NonRenamableLocal = isNonRenamableLocal(F); 263 bool NotEligibleForImport = 264 NonRenamableLocal || HasInlineAsmMaybeReferencingInternal || 265 // Inliner doesn't handle variadic functions. 266 // FIXME: refactor this to use the same code that inliner is using. 267 F.isVarArg(); 268 GlobalValueSummary::GVFlags Flags(F.getLinkage(), NotEligibleForImport, 269 /* LiveRoot = */ false); 270 auto FuncSummary = llvm::make_unique<FunctionSummary>( 271 Flags, NumInsts, RefEdges.takeVector(), CallGraphEdges.takeVector(), 272 TypeTests.takeVector(), TypeTestAssumeVCalls.takeVector(), 273 TypeCheckedLoadVCalls.takeVector(), 274 TypeTestAssumeConstVCalls.takeVector(), 275 TypeCheckedLoadConstVCalls.takeVector()); 276 if (NonRenamableLocal) 277 CantBePromoted.insert(F.getGUID()); 278 Index.addGlobalValueSummary(F.getName(), std::move(FuncSummary)); 279 } 280 281 static void 282 computeVariableSummary(ModuleSummaryIndex &Index, const GlobalVariable &V, 283 DenseSet<GlobalValue::GUID> &CantBePromoted) { 284 SetVector<ValueInfo> RefEdges; 285 SmallPtrSet<const User *, 8> Visited; 286 findRefEdges(&V, RefEdges, Visited); 287 bool NonRenamableLocal = isNonRenamableLocal(V); 288 GlobalValueSummary::GVFlags Flags(V.getLinkage(), NonRenamableLocal, 289 /* LiveRoot = */ false); 290 auto GVarSummary = 291 llvm::make_unique<GlobalVarSummary>(Flags, RefEdges.takeVector()); 292 if (NonRenamableLocal) 293 CantBePromoted.insert(V.getGUID()); 294 Index.addGlobalValueSummary(V.getName(), std::move(GVarSummary)); 295 } 296 297 static void 298 computeAliasSummary(ModuleSummaryIndex &Index, const GlobalAlias &A, 299 DenseSet<GlobalValue::GUID> &CantBePromoted) { 300 bool NonRenamableLocal = isNonRenamableLocal(A); 301 GlobalValueSummary::GVFlags Flags(A.getLinkage(), NonRenamableLocal, 302 /* LiveRoot = */ false); 303 auto AS = llvm::make_unique<AliasSummary>(Flags, ArrayRef<ValueInfo>{}); 304 auto *Aliasee = A.getBaseObject(); 305 auto *AliaseeSummary = Index.getGlobalValueSummary(*Aliasee); 306 assert(AliaseeSummary && "Alias expects aliasee summary to be parsed"); 307 AS->setAliasee(AliaseeSummary); 308 if (NonRenamableLocal) 309 CantBePromoted.insert(A.getGUID()); 310 Index.addGlobalValueSummary(A.getName(), std::move(AS)); 311 } 312 313 // Set LiveRoot flag on entries matching the given value name. 314 static void setLiveRoot(ModuleSummaryIndex &Index, StringRef Name) { 315 auto SummaryList = 316 Index.findGlobalValueSummaryList(GlobalValue::getGUID(Name)); 317 if (SummaryList == Index.end()) 318 return; 319 for (auto &Summary : SummaryList->second) 320 Summary->setLiveRoot(); 321 } 322 323 ModuleSummaryIndex llvm::buildModuleSummaryIndex( 324 const Module &M, 325 std::function<BlockFrequencyInfo *(const Function &F)> GetBFICallback, 326 ProfileSummaryInfo *PSI) { 327 ModuleSummaryIndex Index; 328 329 // Identify the local values in the llvm.used and llvm.compiler.used sets, 330 // which should not be exported as they would then require renaming and 331 // promotion, but we may have opaque uses e.g. in inline asm. We collect them 332 // here because we use this information to mark functions containing inline 333 // assembly calls as not importable. 334 SmallPtrSet<GlobalValue *, 8> LocalsUsed; 335 SmallPtrSet<GlobalValue *, 8> Used; 336 // First collect those in the llvm.used set. 337 collectUsedGlobalVariables(M, Used, /*CompilerUsed*/ false); 338 // Next collect those in the llvm.compiler.used set. 339 collectUsedGlobalVariables(M, Used, /*CompilerUsed*/ true); 340 DenseSet<GlobalValue::GUID> CantBePromoted; 341 for (auto *V : Used) { 342 if (V->hasLocalLinkage()) { 343 LocalsUsed.insert(V); 344 CantBePromoted.insert(V->getGUID()); 345 } 346 } 347 348 // Compute summaries for all functions defined in module, and save in the 349 // index. 350 for (auto &F : M) { 351 if (F.isDeclaration()) 352 continue; 353 354 BlockFrequencyInfo *BFI = nullptr; 355 std::unique_ptr<BlockFrequencyInfo> BFIPtr; 356 if (GetBFICallback) 357 BFI = GetBFICallback(F); 358 else if (F.getEntryCount().hasValue()) { 359 LoopInfo LI{DominatorTree(const_cast<Function &>(F))}; 360 BranchProbabilityInfo BPI{F, LI}; 361 BFIPtr = llvm::make_unique<BlockFrequencyInfo>(F, BPI, LI); 362 BFI = BFIPtr.get(); 363 } 364 365 computeFunctionSummary(Index, M, F, BFI, PSI, !LocalsUsed.empty(), 366 CantBePromoted); 367 } 368 369 // Compute summaries for all variables defined in module, and save in the 370 // index. 371 for (const GlobalVariable &G : M.globals()) { 372 if (G.isDeclaration()) 373 continue; 374 computeVariableSummary(Index, G, CantBePromoted); 375 } 376 377 // Compute summaries for all aliases defined in module, and save in the 378 // index. 379 for (const GlobalAlias &A : M.aliases()) 380 computeAliasSummary(Index, A, CantBePromoted); 381 382 for (auto *V : LocalsUsed) { 383 auto *Summary = Index.getGlobalValueSummary(*V); 384 assert(Summary && "Missing summary for global value"); 385 Summary->setNotEligibleToImport(); 386 } 387 388 // The linker doesn't know about these LLVM produced values, so we need 389 // to flag them as live in the index to ensure index-based dead value 390 // analysis treats them as live roots of the analysis. 391 setLiveRoot(Index, "llvm.used"); 392 setLiveRoot(Index, "llvm.compiler.used"); 393 setLiveRoot(Index, "llvm.global_ctors"); 394 setLiveRoot(Index, "llvm.global_dtors"); 395 setLiveRoot(Index, "llvm.global.annotations"); 396 397 if (!M.getModuleInlineAsm().empty()) { 398 // Collect the local values defined by module level asm, and set up 399 // summaries for these symbols so that they can be marked as NoRename, 400 // to prevent export of any use of them in regular IR that would require 401 // renaming within the module level asm. Note we don't need to create a 402 // summary for weak or global defs, as they don't need to be flagged as 403 // NoRename, and defs in module level asm can't be imported anyway. 404 // Also, any values used but not defined within module level asm should 405 // be listed on the llvm.used or llvm.compiler.used global and marked as 406 // referenced from there. 407 ModuleSymbolTable::CollectAsmSymbols( 408 Triple(M.getTargetTriple()), M.getModuleInlineAsm(), 409 [&M, &Index, &CantBePromoted](StringRef Name, 410 object::BasicSymbolRef::Flags Flags) { 411 // Symbols not marked as Weak or Global are local definitions. 412 if (Flags & (object::BasicSymbolRef::SF_Weak | 413 object::BasicSymbolRef::SF_Global)) 414 return; 415 GlobalValue *GV = M.getNamedValue(Name); 416 if (!GV) 417 return; 418 assert(GV->isDeclaration() && "Def in module asm already has definition"); 419 GlobalValueSummary::GVFlags GVFlags(GlobalValue::InternalLinkage, 420 /* NotEligibleToImport */ true, 421 /* LiveRoot */ true); 422 CantBePromoted.insert(GlobalValue::getGUID(Name)); 423 // Create the appropriate summary type. 424 if (isa<Function>(GV)) { 425 std::unique_ptr<FunctionSummary> Summary = 426 llvm::make_unique<FunctionSummary>( 427 GVFlags, 0, ArrayRef<ValueInfo>{}, 428 ArrayRef<FunctionSummary::EdgeTy>{}, 429 ArrayRef<GlobalValue::GUID>{}, 430 ArrayRef<FunctionSummary::VFuncId>{}, 431 ArrayRef<FunctionSummary::VFuncId>{}, 432 ArrayRef<FunctionSummary::ConstVCall>{}, 433 ArrayRef<FunctionSummary::ConstVCall>{}); 434 Index.addGlobalValueSummary(Name, std::move(Summary)); 435 } else { 436 std::unique_ptr<GlobalVarSummary> Summary = 437 llvm::make_unique<GlobalVarSummary>(GVFlags, 438 ArrayRef<ValueInfo>{}); 439 Index.addGlobalValueSummary(Name, std::move(Summary)); 440 } 441 }); 442 } 443 444 for (auto &GlobalList : Index) { 445 assert(GlobalList.second.size() == 1 && 446 "Expected module's index to have one summary per GUID"); 447 auto &Summary = GlobalList.second[0]; 448 bool AllRefsCanBeExternallyReferenced = 449 llvm::all_of(Summary->refs(), [&](const ValueInfo &VI) { 450 // If a global value definition references an unnamed global, 451 // be conservative. They're valid IR so we don't want to crash 452 // when we encounter any of them but they're infrequent enough 453 // that we don't bother optimizing them. 454 if (!VI.getValue()->hasName()) 455 return false; 456 return !CantBePromoted.count(VI.getValue()->getGUID()); 457 }); 458 if (!AllRefsCanBeExternallyReferenced) { 459 Summary->setNotEligibleToImport(); 460 continue; 461 } 462 463 if (auto *FuncSummary = dyn_cast<FunctionSummary>(Summary.get())) { 464 bool AllCallsCanBeExternallyReferenced = llvm::all_of( 465 FuncSummary->calls(), [&](const FunctionSummary::EdgeTy &Edge) { 466 auto GUID = Edge.first.isGUID() ? Edge.first.getGUID() 467 : Edge.first.getValue()->getGUID(); 468 return !CantBePromoted.count(GUID); 469 }); 470 if (!AllCallsCanBeExternallyReferenced) 471 Summary->setNotEligibleToImport(); 472 } 473 } 474 475 return Index; 476 } 477 478 AnalysisKey ModuleSummaryIndexAnalysis::Key; 479 480 ModuleSummaryIndex 481 ModuleSummaryIndexAnalysis::run(Module &M, ModuleAnalysisManager &AM) { 482 ProfileSummaryInfo &PSI = AM.getResult<ProfileSummaryAnalysis>(M); 483 auto &FAM = AM.getResult<FunctionAnalysisManagerModuleProxy>(M).getManager(); 484 return buildModuleSummaryIndex( 485 M, 486 [&FAM](const Function &F) { 487 return &FAM.getResult<BlockFrequencyAnalysis>( 488 *const_cast<Function *>(&F)); 489 }, 490 &PSI); 491 } 492 493 char ModuleSummaryIndexWrapperPass::ID = 0; 494 INITIALIZE_PASS_BEGIN(ModuleSummaryIndexWrapperPass, "module-summary-analysis", 495 "Module Summary Analysis", false, true) 496 INITIALIZE_PASS_DEPENDENCY(BlockFrequencyInfoWrapperPass) 497 INITIALIZE_PASS_DEPENDENCY(ProfileSummaryInfoWrapperPass) 498 INITIALIZE_PASS_END(ModuleSummaryIndexWrapperPass, "module-summary-analysis", 499 "Module Summary Analysis", false, true) 500 501 ModulePass *llvm::createModuleSummaryIndexWrapperPass() { 502 return new ModuleSummaryIndexWrapperPass(); 503 } 504 505 ModuleSummaryIndexWrapperPass::ModuleSummaryIndexWrapperPass() 506 : ModulePass(ID) { 507 initializeModuleSummaryIndexWrapperPassPass(*PassRegistry::getPassRegistry()); 508 } 509 510 bool ModuleSummaryIndexWrapperPass::runOnModule(Module &M) { 511 auto &PSI = *getAnalysis<ProfileSummaryInfoWrapperPass>().getPSI(); 512 Index = buildModuleSummaryIndex( 513 M, 514 [this](const Function &F) { 515 return &(this->getAnalysis<BlockFrequencyInfoWrapperPass>( 516 *const_cast<Function *>(&F)) 517 .getBFI()); 518 }, 519 &PSI); 520 return false; 521 } 522 523 bool ModuleSummaryIndexWrapperPass::doFinalization(Module &M) { 524 Index.reset(); 525 return false; 526 } 527 528 void ModuleSummaryIndexWrapperPass::getAnalysisUsage(AnalysisUsage &AU) const { 529 AU.setPreservesAll(); 530 AU.addRequired<BlockFrequencyInfoWrapperPass>(); 531 AU.addRequired<ProfileSummaryInfoWrapperPass>(); 532 } 533