1 //===-- CGProfile.cpp -----------------------------------------------------===// 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 #include "llvm/Transforms/Instrumentation/CGProfile.h" 10 11 #include "llvm/ADT/MapVector.h" 12 #include "llvm/Analysis/BlockFrequencyInfo.h" 13 #include "llvm/Analysis/LazyBlockFrequencyInfo.h" 14 #include "llvm/Analysis/TargetTransformInfo.h" 15 #include "llvm/IR/Constants.h" 16 #include "llvm/IR/Instructions.h" 17 #include "llvm/IR/MDBuilder.h" 18 #include "llvm/IR/PassManager.h" 19 #include "llvm/InitializePasses.h" 20 #include "llvm/ProfileData/InstrProf.h" 21 #include "llvm/Transforms/Instrumentation.h" 22 23 #include <array> 24 25 using namespace llvm; 26 27 static bool 28 addModuleFlags(Module &M, 29 MapVector<std::pair<Function *, Function *>, uint64_t> &Counts) { 30 if (Counts.empty()) 31 return false; 32 33 LLVMContext &Context = M.getContext(); 34 MDBuilder MDB(Context); 35 std::vector<Metadata *> Nodes; 36 37 for (auto E : Counts) { 38 Metadata *Vals[] = {ValueAsMetadata::get(E.first.first), 39 ValueAsMetadata::get(E.first.second), 40 MDB.createConstant(ConstantInt::get( 41 Type::getInt64Ty(Context), E.second))}; 42 Nodes.push_back(MDNode::get(Context, Vals)); 43 } 44 45 M.addModuleFlag(Module::Append, "CG Profile", MDNode::get(Context, Nodes)); 46 return true; 47 } 48 49 static bool runCGProfilePass( 50 Module &M, function_ref<BlockFrequencyInfo &(Function &)> GetBFI, 51 function_ref<TargetTransformInfo &(Function &)> GetTTI, bool LazyBFI) { 52 MapVector<std::pair<Function *, Function *>, uint64_t> Counts; 53 InstrProfSymtab Symtab; 54 auto UpdateCounts = [&](TargetTransformInfo &TTI, Function *F, 55 Function *CalledF, uint64_t NewCount) { 56 if (NewCount == 0) 57 return; 58 if (!CalledF || !TTI.isLoweredToCall(CalledF) || 59 CalledF->hasDLLImportStorageClass()) 60 return; 61 uint64_t &Count = Counts[std::make_pair(F, CalledF)]; 62 Count = SaturatingAdd(Count, NewCount); 63 }; 64 // Ignore error here. Indirect calls are ignored if this fails. 65 (void)(bool) Symtab.create(M); 66 for (auto &F : M) { 67 // Avoid extra cost of running passes for BFI when the function doesn't have 68 // entry count. Since LazyBlockFrequencyInfoPass only exists in LPM, check 69 // if using LazyBlockFrequencyInfoPass. 70 // TODO: Remove LazyBFI when LazyBlockFrequencyInfoPass is available in NPM. 71 if (F.isDeclaration() || (LazyBFI && !F.getEntryCount())) 72 continue; 73 auto &BFI = GetBFI(F); 74 if (BFI.getEntryFreq() == 0) 75 continue; 76 TargetTransformInfo &TTI = GetTTI(F); 77 for (auto &BB : F) { 78 Optional<uint64_t> BBCount = BFI.getBlockProfileCount(&BB); 79 if (!BBCount) 80 continue; 81 for (auto &I : BB) { 82 CallBase *CB = dyn_cast<CallBase>(&I); 83 if (!CB) 84 continue; 85 if (CB->isIndirectCall()) { 86 InstrProfValueData ValueData[8]; 87 uint32_t ActualNumValueData; 88 uint64_t TotalC; 89 if (!getValueProfDataFromInst(*CB, IPVK_IndirectCallTarget, 8, 90 ValueData, ActualNumValueData, TotalC)) 91 continue; 92 for (const auto &VD : 93 ArrayRef<InstrProfValueData>(ValueData, ActualNumValueData)) { 94 UpdateCounts(TTI, &F, Symtab.getFunction(VD.Value), VD.Count); 95 } 96 continue; 97 } 98 UpdateCounts(TTI, &F, CB->getCalledFunction(), *BBCount); 99 } 100 } 101 } 102 103 return addModuleFlags(M, Counts); 104 } 105 106 namespace { 107 struct CGProfileLegacyPass final : public ModulePass { 108 static char ID; 109 CGProfileLegacyPass() : ModulePass(ID) { 110 initializeCGProfileLegacyPassPass(*PassRegistry::getPassRegistry()); 111 } 112 113 void getAnalysisUsage(AnalysisUsage &AU) const override { 114 AU.setPreservesCFG(); 115 AU.addRequired<LazyBlockFrequencyInfoPass>(); 116 AU.addRequired<TargetTransformInfoWrapperPass>(); 117 } 118 119 bool runOnModule(Module &M) override { 120 auto GetBFI = [this](Function &F) -> BlockFrequencyInfo & { 121 return this->getAnalysis<LazyBlockFrequencyInfoPass>(F).getBFI(); 122 }; 123 auto GetTTI = [this](Function &F) -> TargetTransformInfo & { 124 return this->getAnalysis<TargetTransformInfoWrapperPass>().getTTI(F); 125 }; 126 127 return runCGProfilePass(M, GetBFI, GetTTI, true); 128 } 129 }; 130 131 } // namespace 132 133 char CGProfileLegacyPass::ID = 0; 134 135 INITIALIZE_PASS(CGProfileLegacyPass, "cg-profile", "Call Graph Profile", false, 136 false) 137 138 ModulePass *llvm::createCGProfileLegacyPass() { 139 return new CGProfileLegacyPass(); 140 } 141 142 PreservedAnalyses CGProfilePass::run(Module &M, ModuleAnalysisManager &MAM) { 143 FunctionAnalysisManager &FAM = 144 MAM.getResult<FunctionAnalysisManagerModuleProxy>(M).getManager(); 145 auto GetBFI = [&FAM](Function &F) -> BlockFrequencyInfo & { 146 return FAM.getResult<BlockFrequencyAnalysis>(F); 147 }; 148 auto GetTTI = [&FAM](Function &F) -> TargetTransformInfo & { 149 return FAM.getResult<TargetIRAnalysis>(F); 150 }; 151 152 runCGProfilePass(M, GetBFI, GetTTI, false); 153 154 return PreservedAnalyses::all(); 155 } 156