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