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 (!CalledF || !TTI.isLoweredToCall(CalledF) || 57 CalledF->hasDLLImportStorageClass()) 58 return; 59 uint64_t &Count = Counts[std::make_pair(F, CalledF)]; 60 Count = SaturatingAdd(Count, NewCount); 61 }; 62 // Ignore error here. Indirect calls are ignored if this fails. 63 (void)(bool) Symtab.create(M); 64 for (auto &F : M) { 65 // Avoid extra cost of running passes for BFI when the function doesn't have 66 // entry count. Since LazyBlockFrequencyInfoPass only exists in LPM, check 67 // if using LazyBlockFrequencyInfoPass. 68 // TODO: Remove LazyBFI when LazyBlockFrequencyInfoPass is available in NPM. 69 if (F.isDeclaration() || (LazyBFI && !F.getEntryCount())) 70 continue; 71 auto &BFI = GetBFI(F); 72 if (BFI.getEntryFreq() == 0) 73 continue; 74 TargetTransformInfo &TTI = GetTTI(F); 75 for (auto &BB : F) { 76 Optional<uint64_t> BBCount = BFI.getBlockProfileCount(&BB); 77 if (!BBCount) 78 continue; 79 for (auto &I : BB) { 80 CallBase *CB = dyn_cast<CallBase>(&I); 81 if (!CB) 82 continue; 83 if (CB->isIndirectCall()) { 84 InstrProfValueData ValueData[8]; 85 uint32_t ActualNumValueData; 86 uint64_t TotalC; 87 if (!getValueProfDataFromInst(*CB, IPVK_IndirectCallTarget, 8, 88 ValueData, ActualNumValueData, TotalC)) 89 continue; 90 for (const auto &VD : 91 ArrayRef<InstrProfValueData>(ValueData, ActualNumValueData)) { 92 UpdateCounts(TTI, &F, Symtab.getFunction(VD.Value), VD.Count); 93 } 94 continue; 95 } 96 UpdateCounts(TTI, &F, CB->getCalledFunction(), *BBCount); 97 } 98 } 99 } 100 101 return addModuleFlags(M, Counts); 102 } 103 104 namespace { 105 struct CGProfileLegacyPass final : public ModulePass { 106 static char ID; 107 CGProfileLegacyPass() : ModulePass(ID) { 108 initializeCGProfileLegacyPassPass(*PassRegistry::getPassRegistry()); 109 } 110 111 void getAnalysisUsage(AnalysisUsage &AU) const override { 112 AU.setPreservesCFG(); 113 AU.addRequired<LazyBlockFrequencyInfoPass>(); 114 AU.addRequired<TargetTransformInfoWrapperPass>(); 115 } 116 117 bool runOnModule(Module &M) override { 118 auto GetBFI = [this](Function &F) -> BlockFrequencyInfo & { 119 return this->getAnalysis<LazyBlockFrequencyInfoPass>(F).getBFI(); 120 }; 121 auto GetTTI = [this](Function &F) -> TargetTransformInfo & { 122 return this->getAnalysis<TargetTransformInfoWrapperPass>().getTTI(F); 123 }; 124 125 return runCGProfilePass(M, GetBFI, GetTTI, true); 126 } 127 }; 128 129 } // namespace 130 131 char CGProfileLegacyPass::ID = 0; 132 133 INITIALIZE_PASS(CGProfileLegacyPass, "cg-profile", "Call Graph Profile", false, 134 false) 135 136 ModulePass *llvm::createCGProfileLegacyPass() { 137 return new CGProfileLegacyPass(); 138 } 139 140 PreservedAnalyses CGProfilePass::run(Module &M, ModuleAnalysisManager &MAM) { 141 FunctionAnalysisManager &FAM = 142 MAM.getResult<FunctionAnalysisManagerModuleProxy>(M).getManager(); 143 auto GetBFI = [&FAM](Function &F) -> BlockFrequencyInfo & { 144 return FAM.getResult<BlockFrequencyAnalysis>(F); 145 }; 146 auto GetTTI = [&FAM](Function &F) -> TargetTransformInfo & { 147 return FAM.getResult<TargetIRAnalysis>(F); 148 }; 149 150 runCGProfilePass(M, GetBFI, GetTTI, false); 151 152 return PreservedAnalyses::all(); 153 } 154