1 //===- PGOInstrumentation.cpp - MST-based PGO Instrumentation -------------===//
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 file implements PGO instrumentation using a minimum spanning tree based
11 // on the following paper:
12 //   [1] Donald E. Knuth, Francis R. Stevenson. Optimal measurement of points
13 //   for program frequency counts. BIT Numerical Mathematics 1973, Volume 13,
14 //   Issue 3, pp 313-322
15 // The idea of the algorithm based on the fact that for each node (except for
16 // the entry and exit), the sum of incoming edge counts equals the sum of
17 // outgoing edge counts. The count of edge on spanning tree can be derived from
18 // those edges not on the spanning tree. Knuth proves this method instruments
19 // the minimum number of edges.
20 //
21 // The minimal spanning tree here is actually a maximum weight tree -- on-tree
22 // edges have higher frequencies (more likely to execute). The idea is to
23 // instrument those less frequently executed edges to reduce the runtime
24 // overhead of instrumented binaries.
25 //
26 // This file contains two passes:
27 // (1) Pass PGOInstrumentationGen which instruments the IR to generate edge
28 // count profile, and generates the instrumentation for indirect call
29 // profiling.
30 // (2) Pass PGOInstrumentationUse which reads the edge count profile and
31 // annotates the branch weights. It also reads the indirect call value
32 // profiling records and annotate the indirect call instructions.
33 //
34 // To get the precise counter information, These two passes need to invoke at
35 // the same compilation point (so they see the same IR). For pass
36 // PGOInstrumentationGen, the real work is done in instrumentOneFunc(). For
37 // pass PGOInstrumentationUse, the real work in done in class PGOUseFunc and
38 // the profile is opened in module level and passed to each PGOUseFunc instance.
39 // The shared code for PGOInstrumentationGen and PGOInstrumentationUse is put
40 // in class FuncPGOInstrumentation.
41 //
42 // Class PGOEdge represents a CFG edge and some auxiliary information. Class
43 // BBInfo contains auxiliary information for each BB. These two classes are used
44 // in pass PGOInstrumentationGen. Class PGOUseEdge and UseBBInfo are the derived
45 // class of PGOEdge and BBInfo, respectively. They contains extra data structure
46 // used in populating profile counters.
47 // The MST implementation is in Class CFGMST (CFGMST.h).
48 //
49 //===----------------------------------------------------------------------===//
50 
51 #include "llvm/Transforms/Instrumentation/PGOInstrumentation.h"
52 #include "CFGMST.h"
53 #include "llvm/ADT/APInt.h"
54 #include "llvm/ADT/ArrayRef.h"
55 #include "llvm/ADT/STLExtras.h"
56 #include "llvm/ADT/SmallVector.h"
57 #include "llvm/ADT/Statistic.h"
58 #include "llvm/ADT/StringRef.h"
59 #include "llvm/ADT/Triple.h"
60 #include "llvm/ADT/Twine.h"
61 #include "llvm/ADT/iterator.h"
62 #include "llvm/ADT/iterator_range.h"
63 #include "llvm/Analysis/BlockFrequencyInfo.h"
64 #include "llvm/Analysis/BranchProbabilityInfo.h"
65 #include "llvm/Analysis/CFG.h"
66 #include "llvm/Analysis/IndirectCallSiteVisitor.h"
67 #include "llvm/Analysis/LoopInfo.h"
68 #include "llvm/Analysis/OptimizationRemarkEmitter.h"
69 #include "llvm/IR/Attributes.h"
70 #include "llvm/IR/BasicBlock.h"
71 #include "llvm/IR/CFG.h"
72 #include "llvm/IR/CallSite.h"
73 #include "llvm/IR/Comdat.h"
74 #include "llvm/IR/Constant.h"
75 #include "llvm/IR/Constants.h"
76 #include "llvm/IR/DiagnosticInfo.h"
77 #include "llvm/IR/Dominators.h"
78 #include "llvm/IR/Function.h"
79 #include "llvm/IR/GlobalAlias.h"
80 #include "llvm/IR/GlobalValue.h"
81 #include "llvm/IR/GlobalVariable.h"
82 #include "llvm/IR/IRBuilder.h"
83 #include "llvm/IR/InstVisitor.h"
84 #include "llvm/IR/InstrTypes.h"
85 #include "llvm/IR/Instruction.h"
86 #include "llvm/IR/Instructions.h"
87 #include "llvm/IR/IntrinsicInst.h"
88 #include "llvm/IR/Intrinsics.h"
89 #include "llvm/IR/LLVMContext.h"
90 #include "llvm/IR/MDBuilder.h"
91 #include "llvm/IR/Module.h"
92 #include "llvm/IR/PassManager.h"
93 #include "llvm/IR/ProfileSummary.h"
94 #include "llvm/IR/Type.h"
95 #include "llvm/IR/Value.h"
96 #include "llvm/Pass.h"
97 #include "llvm/ProfileData/InstrProf.h"
98 #include "llvm/ProfileData/InstrProfReader.h"
99 #include "llvm/Support/BranchProbability.h"
100 #include "llvm/Support/Casting.h"
101 #include "llvm/Support/CommandLine.h"
102 #include "llvm/Support/DOTGraphTraits.h"
103 #include "llvm/Support/Debug.h"
104 #include "llvm/Support/Error.h"
105 #include "llvm/Support/ErrorHandling.h"
106 #include "llvm/Support/GraphWriter.h"
107 #include "llvm/Support/JamCRC.h"
108 #include "llvm/Support/raw_ostream.h"
109 #include "llvm/Transforms/Instrumentation.h"
110 #include "llvm/Transforms/Utils/BasicBlockUtils.h"
111 #include <algorithm>
112 #include <cassert>
113 #include <cstdint>
114 #include <memory>
115 #include <numeric>
116 #include <string>
117 #include <unordered_map>
118 #include <utility>
119 #include <vector>
120 
121 using namespace llvm;
122 using ProfileCount = Function::ProfileCount;
123 
124 #define DEBUG_TYPE "pgo-instrumentation"
125 
126 STATISTIC(NumOfPGOInstrument, "Number of edges instrumented.");
127 STATISTIC(NumOfPGOSelectInsts, "Number of select instruction instrumented.");
128 STATISTIC(NumOfPGOMemIntrinsics, "Number of mem intrinsics instrumented.");
129 STATISTIC(NumOfPGOEdge, "Number of edges.");
130 STATISTIC(NumOfPGOBB, "Number of basic-blocks.");
131 STATISTIC(NumOfPGOSplit, "Number of critical edge splits.");
132 STATISTIC(NumOfPGOFunc, "Number of functions having valid profile counts.");
133 STATISTIC(NumOfPGOMismatch, "Number of functions having mismatch profile.");
134 STATISTIC(NumOfPGOMissing, "Number of functions without profile.");
135 STATISTIC(NumOfPGOICall, "Number of indirect call value instrumentations.");
136 
137 // Command line option to specify the file to read profile from. This is
138 // mainly used for testing.
139 static cl::opt<std::string>
140     PGOTestProfileFile("pgo-test-profile-file", cl::init(""), cl::Hidden,
141                        cl::value_desc("filename"),
142                        cl::desc("Specify the path of profile data file. This is"
143                                 "mainly for test purpose."));
144 
145 // Command line option to disable value profiling. The default is false:
146 // i.e. value profiling is enabled by default. This is for debug purpose.
147 static cl::opt<bool> DisableValueProfiling("disable-vp", cl::init(false),
148                                            cl::Hidden,
149                                            cl::desc("Disable Value Profiling"));
150 
151 // Command line option to set the maximum number of VP annotations to write to
152 // the metadata for a single indirect call callsite.
153 static cl::opt<unsigned> MaxNumAnnotations(
154     "icp-max-annotations", cl::init(3), cl::Hidden, cl::ZeroOrMore,
155     cl::desc("Max number of annotations for a single indirect "
156              "call callsite"));
157 
158 // Command line option to set the maximum number of value annotations
159 // to write to the metadata for a single memop intrinsic.
160 static cl::opt<unsigned> MaxNumMemOPAnnotations(
161     "memop-max-annotations", cl::init(4), cl::Hidden, cl::ZeroOrMore,
162     cl::desc("Max number of preicise value annotations for a single memop"
163              "intrinsic"));
164 
165 // Command line option to control appending FunctionHash to the name of a COMDAT
166 // function. This is to avoid the hash mismatch caused by the preinliner.
167 static cl::opt<bool> DoComdatRenaming(
168     "do-comdat-renaming", cl::init(false), cl::Hidden,
169     cl::desc("Append function hash to the name of COMDAT function to avoid "
170              "function hash mismatch due to the preinliner"));
171 
172 // Command line option to enable/disable the warning about missing profile
173 // information.
174 static cl::opt<bool>
175     PGOWarnMissing("pgo-warn-missing-function", cl::init(false), cl::Hidden,
176                    cl::desc("Use this option to turn on/off "
177                             "warnings about missing profile data for "
178                             "functions."));
179 
180 // Command line option to enable/disable the warning about a hash mismatch in
181 // the profile data.
182 static cl::opt<bool>
183     NoPGOWarnMismatch("no-pgo-warn-mismatch", cl::init(false), cl::Hidden,
184                       cl::desc("Use this option to turn off/on "
185                                "warnings about profile cfg mismatch."));
186 
187 // Command line option to enable/disable the warning about a hash mismatch in
188 // the profile data for Comdat functions, which often turns out to be false
189 // positive due to the pre-instrumentation inline.
190 static cl::opt<bool>
191     NoPGOWarnMismatchComdat("no-pgo-warn-mismatch-comdat", cl::init(true),
192                             cl::Hidden,
193                             cl::desc("The option is used to turn on/off "
194                                      "warnings about hash mismatch for comdat "
195                                      "functions."));
196 
197 // Command line option to enable/disable select instruction instrumentation.
198 static cl::opt<bool>
199     PGOInstrSelect("pgo-instr-select", cl::init(true), cl::Hidden,
200                    cl::desc("Use this option to turn on/off SELECT "
201                             "instruction instrumentation. "));
202 
203 // Command line option to turn on CFG dot or text dump of raw profile counts
204 static cl::opt<PGOViewCountsType> PGOViewRawCounts(
205     "pgo-view-raw-counts", cl::Hidden,
206     cl::desc("A boolean option to show CFG dag or text "
207              "with raw profile counts from "
208              "profile data. See also option "
209              "-pgo-view-counts. To limit graph "
210              "display to only one function, use "
211              "filtering option -view-bfi-func-name."),
212     cl::values(clEnumValN(PGOVCT_None, "none", "do not show."),
213                clEnumValN(PGOVCT_Graph, "graph", "show a graph."),
214                clEnumValN(PGOVCT_Text, "text", "show in text.")));
215 
216 // Command line option to enable/disable memop intrinsic call.size profiling.
217 static cl::opt<bool>
218     PGOInstrMemOP("pgo-instr-memop", cl::init(true), cl::Hidden,
219                   cl::desc("Use this option to turn on/off "
220                            "memory intrinsic size profiling."));
221 
222 // Emit branch probability as optimization remarks.
223 static cl::opt<bool>
224     EmitBranchProbability("pgo-emit-branch-prob", cl::init(false), cl::Hidden,
225                           cl::desc("When this option is on, the annotated "
226                                    "branch probability will be emitted as "
227                                    "optimization remarks: -{Rpass|"
228                                    "pass-remarks}=pgo-instrumentation"));
229 
230 // Command line option to turn on CFG dot dump after profile annotation.
231 // Defined in Analysis/BlockFrequencyInfo.cpp:  -pgo-view-counts
232 extern cl::opt<PGOViewCountsType> PGOViewCounts;
233 
234 // Command line option to specify the name of the function for CFG dump
235 // Defined in Analysis/BlockFrequencyInfo.cpp:  -view-bfi-func-name=
236 extern cl::opt<std::string> ViewBlockFreqFuncName;
237 
238 // Return a string describing the branch condition that can be
239 // used in static branch probability heuristics:
getBranchCondString(Instruction * TI)240 static std::string getBranchCondString(Instruction *TI) {
241   BranchInst *BI = dyn_cast<BranchInst>(TI);
242   if (!BI || !BI->isConditional())
243     return std::string();
244 
245   Value *Cond = BI->getCondition();
246   ICmpInst *CI = dyn_cast<ICmpInst>(Cond);
247   if (!CI)
248     return std::string();
249 
250   std::string result;
251   raw_string_ostream OS(result);
252   OS << CmpInst::getPredicateName(CI->getPredicate()) << "_";
253   CI->getOperand(0)->getType()->print(OS, true);
254 
255   Value *RHS = CI->getOperand(1);
256   ConstantInt *CV = dyn_cast<ConstantInt>(RHS);
257   if (CV) {
258     if (CV->isZero())
259       OS << "_Zero";
260     else if (CV->isOne())
261       OS << "_One";
262     else if (CV->isMinusOne())
263       OS << "_MinusOne";
264     else
265       OS << "_Const";
266   }
267   OS.flush();
268   return result;
269 }
270 
271 namespace {
272 
273 /// The select instruction visitor plays three roles specified
274 /// by the mode. In \c VM_counting mode, it simply counts the number of
275 /// select instructions. In \c VM_instrument mode, it inserts code to count
276 /// the number times TrueValue of select is taken. In \c VM_annotate mode,
277 /// it reads the profile data and annotate the select instruction with metadata.
278 enum VisitMode { VM_counting, VM_instrument, VM_annotate };
279 class PGOUseFunc;
280 
281 /// Instruction Visitor class to visit select instructions.
282 struct SelectInstVisitor : public InstVisitor<SelectInstVisitor> {
283   Function &F;
284   unsigned NSIs = 0;             // Number of select instructions instrumented.
285   VisitMode Mode = VM_counting;  // Visiting mode.
286   unsigned *CurCtrIdx = nullptr; // Pointer to current counter index.
287   unsigned TotalNumCtrs = 0;     // Total number of counters
288   GlobalVariable *FuncNameVar = nullptr;
289   uint64_t FuncHash = 0;
290   PGOUseFunc *UseFunc = nullptr;
291 
SelectInstVisitor__anoncbdd98c50111::SelectInstVisitor292   SelectInstVisitor(Function &Func) : F(Func) {}
293 
countSelects__anoncbdd98c50111::SelectInstVisitor294   void countSelects(Function &Func) {
295     NSIs = 0;
296     Mode = VM_counting;
297     visit(Func);
298   }
299 
300   // Visit the IR stream and instrument all select instructions. \p
301   // Ind is a pointer to the counter index variable; \p TotalNC
302   // is the total number of counters; \p FNV is the pointer to the
303   // PGO function name var; \p FHash is the function hash.
instrumentSelects__anoncbdd98c50111::SelectInstVisitor304   void instrumentSelects(Function &Func, unsigned *Ind, unsigned TotalNC,
305                          GlobalVariable *FNV, uint64_t FHash) {
306     Mode = VM_instrument;
307     CurCtrIdx = Ind;
308     TotalNumCtrs = TotalNC;
309     FuncHash = FHash;
310     FuncNameVar = FNV;
311     visit(Func);
312   }
313 
314   // Visit the IR stream and annotate all select instructions.
annotateSelects__anoncbdd98c50111::SelectInstVisitor315   void annotateSelects(Function &Func, PGOUseFunc *UF, unsigned *Ind) {
316     Mode = VM_annotate;
317     UseFunc = UF;
318     CurCtrIdx = Ind;
319     visit(Func);
320   }
321 
322   void instrumentOneSelectInst(SelectInst &SI);
323   void annotateOneSelectInst(SelectInst &SI);
324 
325   // Visit \p SI instruction and perform tasks according to visit mode.
326   void visitSelectInst(SelectInst &SI);
327 
328   // Return the number of select instructions. This needs be called after
329   // countSelects().
getNumOfSelectInsts__anoncbdd98c50111::SelectInstVisitor330   unsigned getNumOfSelectInsts() const { return NSIs; }
331 };
332 
333 /// Instruction Visitor class to visit memory intrinsic calls.
334 struct MemIntrinsicVisitor : public InstVisitor<MemIntrinsicVisitor> {
335   Function &F;
336   unsigned NMemIs = 0;          // Number of memIntrinsics instrumented.
337   VisitMode Mode = VM_counting; // Visiting mode.
338   unsigned CurCtrId = 0;        // Current counter index.
339   unsigned TotalNumCtrs = 0;    // Total number of counters
340   GlobalVariable *FuncNameVar = nullptr;
341   uint64_t FuncHash = 0;
342   PGOUseFunc *UseFunc = nullptr;
343   std::vector<Instruction *> Candidates;
344 
MemIntrinsicVisitor__anoncbdd98c50111::MemIntrinsicVisitor345   MemIntrinsicVisitor(Function &Func) : F(Func) {}
346 
countMemIntrinsics__anoncbdd98c50111::MemIntrinsicVisitor347   void countMemIntrinsics(Function &Func) {
348     NMemIs = 0;
349     Mode = VM_counting;
350     visit(Func);
351   }
352 
instrumentMemIntrinsics__anoncbdd98c50111::MemIntrinsicVisitor353   void instrumentMemIntrinsics(Function &Func, unsigned TotalNC,
354                                GlobalVariable *FNV, uint64_t FHash) {
355     Mode = VM_instrument;
356     TotalNumCtrs = TotalNC;
357     FuncHash = FHash;
358     FuncNameVar = FNV;
359     visit(Func);
360   }
361 
findMemIntrinsics__anoncbdd98c50111::MemIntrinsicVisitor362   std::vector<Instruction *> findMemIntrinsics(Function &Func) {
363     Candidates.clear();
364     Mode = VM_annotate;
365     visit(Func);
366     return Candidates;
367   }
368 
369   // Visit the IR stream and annotate all mem intrinsic call instructions.
370   void instrumentOneMemIntrinsic(MemIntrinsic &MI);
371 
372   // Visit \p MI instruction and perform tasks according to visit mode.
373   void visitMemIntrinsic(MemIntrinsic &SI);
374 
getNumOfMemIntrinsics__anoncbdd98c50111::MemIntrinsicVisitor375   unsigned getNumOfMemIntrinsics() const { return NMemIs; }
376 };
377 
378 class PGOInstrumentationGenLegacyPass : public ModulePass {
379 public:
380   static char ID;
381 
PGOInstrumentationGenLegacyPass()382   PGOInstrumentationGenLegacyPass() : ModulePass(ID) {
383     initializePGOInstrumentationGenLegacyPassPass(
384         *PassRegistry::getPassRegistry());
385   }
386 
getPassName() const387   StringRef getPassName() const override { return "PGOInstrumentationGenPass"; }
388 
389 private:
390   bool runOnModule(Module &M) override;
391 
getAnalysisUsage(AnalysisUsage & AU) const392   void getAnalysisUsage(AnalysisUsage &AU) const override {
393     AU.addRequired<BlockFrequencyInfoWrapperPass>();
394   }
395 };
396 
397 class PGOInstrumentationUseLegacyPass : public ModulePass {
398 public:
399   static char ID;
400 
401   // Provide the profile filename as the parameter.
PGOInstrumentationUseLegacyPass(std::string Filename="")402   PGOInstrumentationUseLegacyPass(std::string Filename = "")
403       : ModulePass(ID), ProfileFileName(std::move(Filename)) {
404     if (!PGOTestProfileFile.empty())
405       ProfileFileName = PGOTestProfileFile;
406     initializePGOInstrumentationUseLegacyPassPass(
407         *PassRegistry::getPassRegistry());
408   }
409 
getPassName() const410   StringRef getPassName() const override { return "PGOInstrumentationUsePass"; }
411 
412 private:
413   std::string ProfileFileName;
414 
415   bool runOnModule(Module &M) override;
416 
getAnalysisUsage(AnalysisUsage & AU) const417   void getAnalysisUsage(AnalysisUsage &AU) const override {
418     AU.addRequired<BlockFrequencyInfoWrapperPass>();
419   }
420 };
421 
422 } // end anonymous namespace
423 
424 char PGOInstrumentationGenLegacyPass::ID = 0;
425 
426 INITIALIZE_PASS_BEGIN(PGOInstrumentationGenLegacyPass, "pgo-instr-gen",
427                       "PGO instrumentation.", false, false)
INITIALIZE_PASS_DEPENDENCY(BlockFrequencyInfoWrapperPass)428 INITIALIZE_PASS_DEPENDENCY(BlockFrequencyInfoWrapperPass)
429 INITIALIZE_PASS_DEPENDENCY(BranchProbabilityInfoWrapperPass)
430 INITIALIZE_PASS_END(PGOInstrumentationGenLegacyPass, "pgo-instr-gen",
431                     "PGO instrumentation.", false, false)
432 
433 ModulePass *llvm::createPGOInstrumentationGenLegacyPass() {
434   return new PGOInstrumentationGenLegacyPass();
435 }
436 
437 char PGOInstrumentationUseLegacyPass::ID = 0;
438 
439 INITIALIZE_PASS_BEGIN(PGOInstrumentationUseLegacyPass, "pgo-instr-use",
440                       "Read PGO instrumentation profile.", false, false)
INITIALIZE_PASS_DEPENDENCY(BlockFrequencyInfoWrapperPass)441 INITIALIZE_PASS_DEPENDENCY(BlockFrequencyInfoWrapperPass)
442 INITIALIZE_PASS_DEPENDENCY(BranchProbabilityInfoWrapperPass)
443 INITIALIZE_PASS_END(PGOInstrumentationUseLegacyPass, "pgo-instr-use",
444                     "Read PGO instrumentation profile.", false, false)
445 
446 ModulePass *llvm::createPGOInstrumentationUseLegacyPass(StringRef Filename) {
447   return new PGOInstrumentationUseLegacyPass(Filename.str());
448 }
449 
450 namespace {
451 
452 /// An MST based instrumentation for PGO
453 ///
454 /// Implements a Minimum Spanning Tree (MST) based instrumentation for PGO
455 /// in the function level.
456 struct PGOEdge {
457   // This class implements the CFG edges. Note the CFG can be a multi-graph.
458   // So there might be multiple edges with same SrcBB and DestBB.
459   const BasicBlock *SrcBB;
460   const BasicBlock *DestBB;
461   uint64_t Weight;
462   bool InMST = false;
463   bool Removed = false;
464   bool IsCritical = false;
465 
PGOEdge__anoncbdd98c50211::PGOEdge466   PGOEdge(const BasicBlock *Src, const BasicBlock *Dest, uint64_t W = 1)
467       : SrcBB(Src), DestBB(Dest), Weight(W) {}
468 
469   // Return the information string of an edge.
infoString__anoncbdd98c50211::PGOEdge470   const std::string infoString() const {
471     return (Twine(Removed ? "-" : " ") + (InMST ? " " : "*") +
472             (IsCritical ? "c" : " ") + "  W=" + Twine(Weight)).str();
473   }
474 };
475 
476 // This class stores the auxiliary information for each BB.
477 struct BBInfo {
478   BBInfo *Group;
479   uint32_t Index;
480   uint32_t Rank = 0;
481 
BBInfo__anoncbdd98c50211::BBInfo482   BBInfo(unsigned IX) : Group(this), Index(IX) {}
483 
484   // Return the information string of this object.
infoString__anoncbdd98c50211::BBInfo485   const std::string infoString() const {
486     return (Twine("Index=") + Twine(Index)).str();
487   }
488 };
489 
490 // This class implements the CFG edges. Note the CFG can be a multi-graph.
491 template <class Edge, class BBInfo> class FuncPGOInstrumentation {
492 private:
493   Function &F;
494 
495   // A map that stores the Comdat group in function F.
496   std::unordered_multimap<Comdat *, GlobalValue *> &ComdatMembers;
497 
498   void computeCFGHash();
499   void renameComdatFunction();
500 
501 public:
502   std::vector<std::vector<Instruction *>> ValueSites;
503   SelectInstVisitor SIVisitor;
504   MemIntrinsicVisitor MIVisitor;
505   std::string FuncName;
506   GlobalVariable *FuncNameVar;
507 
508   // CFG hash value for this function.
509   uint64_t FunctionHash = 0;
510 
511   // The Minimum Spanning Tree of function CFG.
512   CFGMST<Edge, BBInfo> MST;
513 
514   // Give an edge, find the BB that will be instrumented.
515   // Return nullptr if there is no BB to be instrumented.
516   BasicBlock *getInstrBB(Edge *E);
517 
518   // Return the auxiliary BB information.
getBBInfo(const BasicBlock * BB) const519   BBInfo &getBBInfo(const BasicBlock *BB) const { return MST.getBBInfo(BB); }
520 
521   // Return the auxiliary BB information if available.
findBBInfo(const BasicBlock * BB) const522   BBInfo *findBBInfo(const BasicBlock *BB) const { return MST.findBBInfo(BB); }
523 
524   // Dump edges and BB information.
dumpInfo(std::string Str="") const525   void dumpInfo(std::string Str = "") const {
526     MST.dumpEdges(dbgs(), Twine("Dump Function ") + FuncName + " Hash: " +
527                               Twine(FunctionHash) + "\t" + Str);
528   }
529 
FuncPGOInstrumentation(Function & Func,std::unordered_multimap<Comdat *,GlobalValue * > & ComdatMembers,bool CreateGlobalVar=false,BranchProbabilityInfo * BPI=nullptr,BlockFrequencyInfo * BFI=nullptr)530   FuncPGOInstrumentation(
531       Function &Func,
532       std::unordered_multimap<Comdat *, GlobalValue *> &ComdatMembers,
533       bool CreateGlobalVar = false, BranchProbabilityInfo *BPI = nullptr,
534       BlockFrequencyInfo *BFI = nullptr)
535       : F(Func), ComdatMembers(ComdatMembers), ValueSites(IPVK_Last + 1),
536         SIVisitor(Func), MIVisitor(Func), MST(F, BPI, BFI) {
537     // This should be done before CFG hash computation.
538     SIVisitor.countSelects(Func);
539     MIVisitor.countMemIntrinsics(Func);
540     NumOfPGOSelectInsts += SIVisitor.getNumOfSelectInsts();
541     NumOfPGOMemIntrinsics += MIVisitor.getNumOfMemIntrinsics();
542     ValueSites[IPVK_IndirectCallTarget] = findIndirectCallSites(Func);
543     ValueSites[IPVK_MemOPSize] = MIVisitor.findMemIntrinsics(Func);
544 
545     FuncName = getPGOFuncName(F);
546     computeCFGHash();
547     if (!ComdatMembers.empty())
548       renameComdatFunction();
549     LLVM_DEBUG(dumpInfo("after CFGMST"));
550 
551     NumOfPGOBB += MST.BBInfos.size();
552     for (auto &E : MST.AllEdges) {
553       if (E->Removed)
554         continue;
555       NumOfPGOEdge++;
556       if (!E->InMST)
557         NumOfPGOInstrument++;
558     }
559 
560     if (CreateGlobalVar)
561       FuncNameVar = createPGOFuncNameVar(F, FuncName);
562   }
563 
564   // Return the number of profile counters needed for the function.
getNumCounters()565   unsigned getNumCounters() {
566     unsigned NumCounters = 0;
567     for (auto &E : this->MST.AllEdges) {
568       if (!E->InMST && !E->Removed)
569         NumCounters++;
570     }
571     return NumCounters + SIVisitor.getNumOfSelectInsts();
572   }
573 };
574 
575 } // end anonymous namespace
576 
577 // Compute Hash value for the CFG: the lower 32 bits are CRC32 of the index
578 // value of each BB in the CFG. The higher 32 bits record the number of edges.
579 template <class Edge, class BBInfo>
computeCFGHash()580 void FuncPGOInstrumentation<Edge, BBInfo>::computeCFGHash() {
581   std::vector<char> Indexes;
582   JamCRC JC;
583   for (auto &BB : F) {
584     const TerminatorInst *TI = BB.getTerminator();
585     for (unsigned I = 0, E = TI->getNumSuccessors(); I != E; ++I) {
586       BasicBlock *Succ = TI->getSuccessor(I);
587       auto BI = findBBInfo(Succ);
588       if (BI == nullptr)
589         continue;
590       uint32_t Index = BI->Index;
591       for (int J = 0; J < 4; J++)
592         Indexes.push_back((char)(Index >> (J * 8)));
593     }
594   }
595   JC.update(Indexes);
596   FunctionHash = (uint64_t)SIVisitor.getNumOfSelectInsts() << 56 |
597                  (uint64_t)ValueSites[IPVK_IndirectCallTarget].size() << 48 |
598                  (uint64_t)MST.AllEdges.size() << 32 | JC.getCRC();
599   LLVM_DEBUG(dbgs() << "Function Hash Computation for " << F.getName() << ":\n"
600                     << " CRC = " << JC.getCRC()
601                     << ", Selects = " << SIVisitor.getNumOfSelectInsts()
602                     << ", Edges = " << MST.AllEdges.size() << ", ICSites = "
603                     << ValueSites[IPVK_IndirectCallTarget].size()
604                     << ", Hash = " << FunctionHash << "\n";);
605 }
606 
607 // Check if we can safely rename this Comdat function.
canRenameComdat(Function & F,std::unordered_multimap<Comdat *,GlobalValue * > & ComdatMembers)608 static bool canRenameComdat(
609     Function &F,
610     std::unordered_multimap<Comdat *, GlobalValue *> &ComdatMembers) {
611   if (!DoComdatRenaming || !canRenameComdatFunc(F, true))
612     return false;
613 
614   // FIXME: Current only handle those Comdat groups that only containing one
615   // function and function aliases.
616   // (1) For a Comdat group containing multiple functions, we need to have a
617   // unique postfix based on the hashes for each function. There is a
618   // non-trivial code refactoring to do this efficiently.
619   // (2) Variables can not be renamed, so we can not rename Comdat function in a
620   // group including global vars.
621   Comdat *C = F.getComdat();
622   for (auto &&CM : make_range(ComdatMembers.equal_range(C))) {
623     if (dyn_cast<GlobalAlias>(CM.second))
624       continue;
625     Function *FM = dyn_cast<Function>(CM.second);
626     if (FM != &F)
627       return false;
628   }
629   return true;
630 }
631 
632 // Append the CFGHash to the Comdat function name.
633 template <class Edge, class BBInfo>
renameComdatFunction()634 void FuncPGOInstrumentation<Edge, BBInfo>::renameComdatFunction() {
635   if (!canRenameComdat(F, ComdatMembers))
636     return;
637   std::string OrigName = F.getName().str();
638   std::string NewFuncName =
639       Twine(F.getName() + "." + Twine(FunctionHash)).str();
640   F.setName(Twine(NewFuncName));
641   GlobalAlias::create(GlobalValue::WeakAnyLinkage, OrigName, &F);
642   FuncName = Twine(FuncName + "." + Twine(FunctionHash)).str();
643   Comdat *NewComdat;
644   Module *M = F.getParent();
645   // For AvailableExternallyLinkage functions, change the linkage to
646   // LinkOnceODR and put them into comdat. This is because after renaming, there
647   // is no backup external copy available for the function.
648   if (!F.hasComdat()) {
649     assert(F.getLinkage() == GlobalValue::AvailableExternallyLinkage);
650     NewComdat = M->getOrInsertComdat(StringRef(NewFuncName));
651     F.setLinkage(GlobalValue::LinkOnceODRLinkage);
652     F.setComdat(NewComdat);
653     return;
654   }
655 
656   // This function belongs to a single function Comdat group.
657   Comdat *OrigComdat = F.getComdat();
658   std::string NewComdatName =
659       Twine(OrigComdat->getName() + "." + Twine(FunctionHash)).str();
660   NewComdat = M->getOrInsertComdat(StringRef(NewComdatName));
661   NewComdat->setSelectionKind(OrigComdat->getSelectionKind());
662 
663   for (auto &&CM : make_range(ComdatMembers.equal_range(OrigComdat))) {
664     if (GlobalAlias *GA = dyn_cast<GlobalAlias>(CM.second)) {
665       // For aliases, change the name directly.
666       assert(dyn_cast<Function>(GA->getAliasee()->stripPointerCasts()) == &F);
667       std::string OrigGAName = GA->getName().str();
668       GA->setName(Twine(GA->getName() + "." + Twine(FunctionHash)));
669       GlobalAlias::create(GlobalValue::WeakAnyLinkage, OrigGAName, GA);
670       continue;
671     }
672     // Must be a function.
673     Function *CF = dyn_cast<Function>(CM.second);
674     assert(CF);
675     CF->setComdat(NewComdat);
676   }
677 }
678 
679 // Given a CFG E to be instrumented, find which BB to place the instrumented
680 // code. The function will split the critical edge if necessary.
681 template <class Edge, class BBInfo>
getInstrBB(Edge * E)682 BasicBlock *FuncPGOInstrumentation<Edge, BBInfo>::getInstrBB(Edge *E) {
683   if (E->InMST || E->Removed)
684     return nullptr;
685 
686   BasicBlock *SrcBB = const_cast<BasicBlock *>(E->SrcBB);
687   BasicBlock *DestBB = const_cast<BasicBlock *>(E->DestBB);
688   // For a fake edge, instrument the real BB.
689   if (SrcBB == nullptr)
690     return DestBB;
691   if (DestBB == nullptr)
692     return SrcBB;
693 
694   // Instrument the SrcBB if it has a single successor,
695   // otherwise, the DestBB if this is not a critical edge.
696   TerminatorInst *TI = SrcBB->getTerminator();
697   if (TI->getNumSuccessors() <= 1)
698     return SrcBB;
699   if (!E->IsCritical)
700     return DestBB;
701 
702   // For a critical edge, we have to split. Instrument the newly
703   // created BB.
704   NumOfPGOSplit++;
705   LLVM_DEBUG(dbgs() << "Split critical edge: " << getBBInfo(SrcBB).Index
706                     << " --> " << getBBInfo(DestBB).Index << "\n");
707   unsigned SuccNum = GetSuccessorNumber(SrcBB, DestBB);
708   BasicBlock *InstrBB = SplitCriticalEdge(TI, SuccNum);
709   assert(InstrBB && "Critical edge is not split");
710 
711   E->Removed = true;
712   return InstrBB;
713 }
714 
715 // Visit all edge and instrument the edges not in MST, and do value profiling.
716 // Critical edges will be split.
instrumentOneFunc(Function & F,Module * M,BranchProbabilityInfo * BPI,BlockFrequencyInfo * BFI,std::unordered_multimap<Comdat *,GlobalValue * > & ComdatMembers)717 static void instrumentOneFunc(
718     Function &F, Module *M, BranchProbabilityInfo *BPI, BlockFrequencyInfo *BFI,
719     std::unordered_multimap<Comdat *, GlobalValue *> &ComdatMembers) {
720   // Split indirectbr critical edges here before computing the MST rather than
721   // later in getInstrBB() to avoid invalidating it.
722   SplitIndirectBrCriticalEdges(F, BPI, BFI);
723   FuncPGOInstrumentation<PGOEdge, BBInfo> FuncInfo(F, ComdatMembers, true, BPI,
724                                                    BFI);
725   unsigned NumCounters = FuncInfo.getNumCounters();
726 
727   uint32_t I = 0;
728   Type *I8PtrTy = Type::getInt8PtrTy(M->getContext());
729   for (auto &E : FuncInfo.MST.AllEdges) {
730     BasicBlock *InstrBB = FuncInfo.getInstrBB(E.get());
731     if (!InstrBB)
732       continue;
733 
734     IRBuilder<> Builder(InstrBB, InstrBB->getFirstInsertionPt());
735     assert(Builder.GetInsertPoint() != InstrBB->end() &&
736            "Cannot get the Instrumentation point");
737     Builder.CreateCall(
738         Intrinsic::getDeclaration(M, Intrinsic::instrprof_increment),
739         {ConstantExpr::getBitCast(FuncInfo.FuncNameVar, I8PtrTy),
740          Builder.getInt64(FuncInfo.FunctionHash), Builder.getInt32(NumCounters),
741          Builder.getInt32(I++)});
742   }
743 
744   // Now instrument select instructions:
745   FuncInfo.SIVisitor.instrumentSelects(F, &I, NumCounters, FuncInfo.FuncNameVar,
746                                        FuncInfo.FunctionHash);
747   assert(I == NumCounters);
748 
749   if (DisableValueProfiling)
750     return;
751 
752   unsigned NumIndirectCallSites = 0;
753   for (auto &I : FuncInfo.ValueSites[IPVK_IndirectCallTarget]) {
754     CallSite CS(I);
755     Value *Callee = CS.getCalledValue();
756     LLVM_DEBUG(dbgs() << "Instrument one indirect call: CallSite Index = "
757                       << NumIndirectCallSites << "\n");
758     IRBuilder<> Builder(I);
759     assert(Builder.GetInsertPoint() != I->getParent()->end() &&
760            "Cannot get the Instrumentation point");
761     Builder.CreateCall(
762         Intrinsic::getDeclaration(M, Intrinsic::instrprof_value_profile),
763         {ConstantExpr::getBitCast(FuncInfo.FuncNameVar, I8PtrTy),
764          Builder.getInt64(FuncInfo.FunctionHash),
765          Builder.CreatePtrToInt(Callee, Builder.getInt64Ty()),
766          Builder.getInt32(IPVK_IndirectCallTarget),
767          Builder.getInt32(NumIndirectCallSites++)});
768   }
769   NumOfPGOICall += NumIndirectCallSites;
770 
771   // Now instrument memop intrinsic calls.
772   FuncInfo.MIVisitor.instrumentMemIntrinsics(
773       F, NumCounters, FuncInfo.FuncNameVar, FuncInfo.FunctionHash);
774 }
775 
776 namespace {
777 
778 // This class represents a CFG edge in profile use compilation.
779 struct PGOUseEdge : public PGOEdge {
780   bool CountValid = false;
781   uint64_t CountValue = 0;
782 
PGOUseEdge__anoncbdd98c50311::PGOUseEdge783   PGOUseEdge(const BasicBlock *Src, const BasicBlock *Dest, uint64_t W = 1)
784       : PGOEdge(Src, Dest, W) {}
785 
786   // Set edge count value
setEdgeCount__anoncbdd98c50311::PGOUseEdge787   void setEdgeCount(uint64_t Value) {
788     CountValue = Value;
789     CountValid = true;
790   }
791 
792   // Return the information string for this object.
infoString__anoncbdd98c50311::PGOUseEdge793   const std::string infoString() const {
794     if (!CountValid)
795       return PGOEdge::infoString();
796     return (Twine(PGOEdge::infoString()) + "  Count=" + Twine(CountValue))
797         .str();
798   }
799 };
800 
801 using DirectEdges = SmallVector<PGOUseEdge *, 2>;
802 
803 // This class stores the auxiliary information for each BB.
804 struct UseBBInfo : public BBInfo {
805   uint64_t CountValue = 0;
806   bool CountValid;
807   int32_t UnknownCountInEdge = 0;
808   int32_t UnknownCountOutEdge = 0;
809   DirectEdges InEdges;
810   DirectEdges OutEdges;
811 
UseBBInfo__anoncbdd98c50311::UseBBInfo812   UseBBInfo(unsigned IX) : BBInfo(IX), CountValid(false) {}
813 
UseBBInfo__anoncbdd98c50311::UseBBInfo814   UseBBInfo(unsigned IX, uint64_t C)
815       : BBInfo(IX), CountValue(C), CountValid(true) {}
816 
817   // Set the profile count value for this BB.
setBBInfoCount__anoncbdd98c50311::UseBBInfo818   void setBBInfoCount(uint64_t Value) {
819     CountValue = Value;
820     CountValid = true;
821   }
822 
823   // Return the information string of this object.
infoString__anoncbdd98c50311::UseBBInfo824   const std::string infoString() const {
825     if (!CountValid)
826       return BBInfo::infoString();
827     return (Twine(BBInfo::infoString()) + "  Count=" + Twine(CountValue)).str();
828   }
829 };
830 
831 } // end anonymous namespace
832 
833 // Sum up the count values for all the edges.
sumEdgeCount(const ArrayRef<PGOUseEdge * > Edges)834 static uint64_t sumEdgeCount(const ArrayRef<PGOUseEdge *> Edges) {
835   uint64_t Total = 0;
836   for (auto &E : Edges) {
837     if (E->Removed)
838       continue;
839     Total += E->CountValue;
840   }
841   return Total;
842 }
843 
844 namespace {
845 
846 class PGOUseFunc {
847 public:
PGOUseFunc(Function & Func,Module * Modu,std::unordered_multimap<Comdat *,GlobalValue * > & ComdatMembers,BranchProbabilityInfo * BPI=nullptr,BlockFrequencyInfo * BFIin=nullptr)848   PGOUseFunc(Function &Func, Module *Modu,
849              std::unordered_multimap<Comdat *, GlobalValue *> &ComdatMembers,
850              BranchProbabilityInfo *BPI = nullptr,
851              BlockFrequencyInfo *BFIin = nullptr)
852       : F(Func), M(Modu), BFI(BFIin),
853         FuncInfo(Func, ComdatMembers, false, BPI, BFIin),
854         FreqAttr(FFA_Normal) {}
855 
856   // Read counts for the instrumented BB from profile.
857   bool readCounters(IndexedInstrProfReader *PGOReader);
858 
859   // Populate the counts for all BBs.
860   void populateCounters();
861 
862   // Set the branch weights based on the count values.
863   void setBranchWeights();
864 
865   // Annotate the value profile call sites for all value kind.
866   void annotateValueSites();
867 
868   // Annotate the value profile call sites for one value kind.
869   void annotateValueSites(uint32_t Kind);
870 
871   // Annotate the irreducible loop header weights.
872   void annotateIrrLoopHeaderWeights();
873 
874   // The hotness of the function from the profile count.
875   enum FuncFreqAttr { FFA_Normal, FFA_Cold, FFA_Hot };
876 
877   // Return the function hotness from the profile.
getFuncFreqAttr() const878   FuncFreqAttr getFuncFreqAttr() const { return FreqAttr; }
879 
880   // Return the function hash.
getFuncHash() const881   uint64_t getFuncHash() const { return FuncInfo.FunctionHash; }
882 
883   // Return the profile record for this function;
getProfileRecord()884   InstrProfRecord &getProfileRecord() { return ProfileRecord; }
885 
886   // Return the auxiliary BB information.
getBBInfo(const BasicBlock * BB) const887   UseBBInfo &getBBInfo(const BasicBlock *BB) const {
888     return FuncInfo.getBBInfo(BB);
889   }
890 
891   // Return the auxiliary BB information if available.
findBBInfo(const BasicBlock * BB) const892   UseBBInfo *findBBInfo(const BasicBlock *BB) const {
893     return FuncInfo.findBBInfo(BB);
894   }
895 
getFunc() const896   Function &getFunc() const { return F; }
897 
dumpInfo(std::string Str="") const898   void dumpInfo(std::string Str = "") const {
899     FuncInfo.dumpInfo(Str);
900   }
901 
902 private:
903   Function &F;
904   Module *M;
905   BlockFrequencyInfo *BFI;
906 
907   // This member stores the shared information with class PGOGenFunc.
908   FuncPGOInstrumentation<PGOUseEdge, UseBBInfo> FuncInfo;
909 
910   // The maximum count value in the profile. This is only used in PGO use
911   // compilation.
912   uint64_t ProgramMaxCount;
913 
914   // Position of counter that remains to be read.
915   uint32_t CountPosition = 0;
916 
917   // Total size of the profile count for this function.
918   uint32_t ProfileCountSize = 0;
919 
920   // ProfileRecord for this function.
921   InstrProfRecord ProfileRecord;
922 
923   // Function hotness info derived from profile.
924   FuncFreqAttr FreqAttr;
925 
926   // Find the Instrumented BB and set the value.
927   void setInstrumentedCounts(const std::vector<uint64_t> &CountFromProfile);
928 
929   // Set the edge counter value for the unknown edge -- there should be only
930   // one unknown edge.
931   void setEdgeCount(DirectEdges &Edges, uint64_t Value);
932 
933   // Return FuncName string;
getFuncName() const934   const std::string getFuncName() const { return FuncInfo.FuncName; }
935 
936   // Set the hot/cold inline hints based on the count values.
937   // FIXME: This function should be removed once the functionality in
938   // the inliner is implemented.
markFunctionAttributes(uint64_t EntryCount,uint64_t MaxCount)939   void markFunctionAttributes(uint64_t EntryCount, uint64_t MaxCount) {
940     if (ProgramMaxCount == 0)
941       return;
942     // Threshold of the hot functions.
943     const BranchProbability HotFunctionThreshold(1, 100);
944     // Threshold of the cold functions.
945     const BranchProbability ColdFunctionThreshold(2, 10000);
946     if (EntryCount >= HotFunctionThreshold.scale(ProgramMaxCount))
947       FreqAttr = FFA_Hot;
948     else if (MaxCount <= ColdFunctionThreshold.scale(ProgramMaxCount))
949       FreqAttr = FFA_Cold;
950   }
951 };
952 
953 } // end anonymous namespace
954 
955 // Visit all the edges and assign the count value for the instrumented
956 // edges and the BB.
setInstrumentedCounts(const std::vector<uint64_t> & CountFromProfile)957 void PGOUseFunc::setInstrumentedCounts(
958     const std::vector<uint64_t> &CountFromProfile) {
959   assert(FuncInfo.getNumCounters() == CountFromProfile.size());
960   // Use a worklist as we will update the vector during the iteration.
961   std::vector<PGOUseEdge *> WorkList;
962   for (auto &E : FuncInfo.MST.AllEdges)
963     WorkList.push_back(E.get());
964 
965   uint32_t I = 0;
966   for (auto &E : WorkList) {
967     BasicBlock *InstrBB = FuncInfo.getInstrBB(E);
968     if (!InstrBB)
969       continue;
970     uint64_t CountValue = CountFromProfile[I++];
971     if (!E->Removed) {
972       getBBInfo(InstrBB).setBBInfoCount(CountValue);
973       E->setEdgeCount(CountValue);
974       continue;
975     }
976 
977     // Need to add two new edges.
978     BasicBlock *SrcBB = const_cast<BasicBlock *>(E->SrcBB);
979     BasicBlock *DestBB = const_cast<BasicBlock *>(E->DestBB);
980     // Add new edge of SrcBB->InstrBB.
981     PGOUseEdge &NewEdge = FuncInfo.MST.addEdge(SrcBB, InstrBB, 0);
982     NewEdge.setEdgeCount(CountValue);
983     // Add new edge of InstrBB->DestBB.
984     PGOUseEdge &NewEdge1 = FuncInfo.MST.addEdge(InstrBB, DestBB, 0);
985     NewEdge1.setEdgeCount(CountValue);
986     NewEdge1.InMST = true;
987     getBBInfo(InstrBB).setBBInfoCount(CountValue);
988   }
989   ProfileCountSize = CountFromProfile.size();
990   CountPosition = I;
991 }
992 
993 // Set the count value for the unknown edge. There should be one and only one
994 // unknown edge in Edges vector.
setEdgeCount(DirectEdges & Edges,uint64_t Value)995 void PGOUseFunc::setEdgeCount(DirectEdges &Edges, uint64_t Value) {
996   for (auto &E : Edges) {
997     if (E->CountValid)
998       continue;
999     E->setEdgeCount(Value);
1000 
1001     getBBInfo(E->SrcBB).UnknownCountOutEdge--;
1002     getBBInfo(E->DestBB).UnknownCountInEdge--;
1003     return;
1004   }
1005   llvm_unreachable("Cannot find the unknown count edge");
1006 }
1007 
1008 // Read the profile from ProfileFileName and assign the value to the
1009 // instrumented BB and the edges. This function also updates ProgramMaxCount.
1010 // Return true if the profile are successfully read, and false on errors.
readCounters(IndexedInstrProfReader * PGOReader)1011 bool PGOUseFunc::readCounters(IndexedInstrProfReader *PGOReader) {
1012   auto &Ctx = M->getContext();
1013   Expected<InstrProfRecord> Result =
1014       PGOReader->getInstrProfRecord(FuncInfo.FuncName, FuncInfo.FunctionHash);
1015   if (Error E = Result.takeError()) {
1016     handleAllErrors(std::move(E), [&](const InstrProfError &IPE) {
1017       auto Err = IPE.get();
1018       bool SkipWarning = false;
1019       if (Err == instrprof_error::unknown_function) {
1020         NumOfPGOMissing++;
1021         SkipWarning = !PGOWarnMissing;
1022       } else if (Err == instrprof_error::hash_mismatch ||
1023                  Err == instrprof_error::malformed) {
1024         NumOfPGOMismatch++;
1025         SkipWarning =
1026             NoPGOWarnMismatch ||
1027             (NoPGOWarnMismatchComdat &&
1028              (F.hasComdat() ||
1029               F.getLinkage() == GlobalValue::AvailableExternallyLinkage));
1030       }
1031 
1032       if (SkipWarning)
1033         return;
1034 
1035       std::string Msg = IPE.message() + std::string(" ") + F.getName().str();
1036       Ctx.diagnose(
1037           DiagnosticInfoPGOProfile(M->getName().data(), Msg, DS_Warning));
1038     });
1039     return false;
1040   }
1041   ProfileRecord = std::move(Result.get());
1042   std::vector<uint64_t> &CountFromProfile = ProfileRecord.Counts;
1043 
1044   NumOfPGOFunc++;
1045   LLVM_DEBUG(dbgs() << CountFromProfile.size() << " counts\n");
1046   uint64_t ValueSum = 0;
1047   for (unsigned I = 0, S = CountFromProfile.size(); I < S; I++) {
1048     LLVM_DEBUG(dbgs() << "  " << I << ": " << CountFromProfile[I] << "\n");
1049     ValueSum += CountFromProfile[I];
1050   }
1051 
1052   LLVM_DEBUG(dbgs() << "SUM =  " << ValueSum << "\n");
1053 
1054   getBBInfo(nullptr).UnknownCountOutEdge = 2;
1055   getBBInfo(nullptr).UnknownCountInEdge = 2;
1056 
1057   setInstrumentedCounts(CountFromProfile);
1058   ProgramMaxCount = PGOReader->getMaximumFunctionCount();
1059   return true;
1060 }
1061 
1062 // Populate the counters from instrumented BBs to all BBs.
1063 // In the end of this operation, all BBs should have a valid count value.
populateCounters()1064 void PGOUseFunc::populateCounters() {
1065   // First set up Count variable for all BBs.
1066   for (auto &E : FuncInfo.MST.AllEdges) {
1067     if (E->Removed)
1068       continue;
1069 
1070     const BasicBlock *SrcBB = E->SrcBB;
1071     const BasicBlock *DestBB = E->DestBB;
1072     UseBBInfo &SrcInfo = getBBInfo(SrcBB);
1073     UseBBInfo &DestInfo = getBBInfo(DestBB);
1074     SrcInfo.OutEdges.push_back(E.get());
1075     DestInfo.InEdges.push_back(E.get());
1076     SrcInfo.UnknownCountOutEdge++;
1077     DestInfo.UnknownCountInEdge++;
1078 
1079     if (!E->CountValid)
1080       continue;
1081     DestInfo.UnknownCountInEdge--;
1082     SrcInfo.UnknownCountOutEdge--;
1083   }
1084 
1085   bool Changes = true;
1086   unsigned NumPasses = 0;
1087   while (Changes) {
1088     NumPasses++;
1089     Changes = false;
1090 
1091     // For efficient traversal, it's better to start from the end as most
1092     // of the instrumented edges are at the end.
1093     for (auto &BB : reverse(F)) {
1094       UseBBInfo *Count = findBBInfo(&BB);
1095       if (Count == nullptr)
1096         continue;
1097       if (!Count->CountValid) {
1098         if (Count->UnknownCountOutEdge == 0) {
1099           Count->CountValue = sumEdgeCount(Count->OutEdges);
1100           Count->CountValid = true;
1101           Changes = true;
1102         } else if (Count->UnknownCountInEdge == 0) {
1103           Count->CountValue = sumEdgeCount(Count->InEdges);
1104           Count->CountValid = true;
1105           Changes = true;
1106         }
1107       }
1108       if (Count->CountValid) {
1109         if (Count->UnknownCountOutEdge == 1) {
1110           uint64_t Total = 0;
1111           uint64_t OutSum = sumEdgeCount(Count->OutEdges);
1112           // If the one of the successor block can early terminate (no-return),
1113           // we can end up with situation where out edge sum count is larger as
1114           // the source BB's count is collected by a post-dominated block.
1115           if (Count->CountValue > OutSum)
1116             Total = Count->CountValue - OutSum;
1117           setEdgeCount(Count->OutEdges, Total);
1118           Changes = true;
1119         }
1120         if (Count->UnknownCountInEdge == 1) {
1121           uint64_t Total = 0;
1122           uint64_t InSum = sumEdgeCount(Count->InEdges);
1123           if (Count->CountValue > InSum)
1124             Total = Count->CountValue - InSum;
1125           setEdgeCount(Count->InEdges, Total);
1126           Changes = true;
1127         }
1128       }
1129     }
1130   }
1131 
1132   LLVM_DEBUG(dbgs() << "Populate counts in " << NumPasses << " passes.\n");
1133 #ifndef NDEBUG
1134   // Assert every BB has a valid counter.
1135   for (auto &BB : F) {
1136     auto BI = findBBInfo(&BB);
1137     if (BI == nullptr)
1138       continue;
1139     assert(BI->CountValid && "BB count is not valid");
1140   }
1141 #endif
1142   uint64_t FuncEntryCount = getBBInfo(&*F.begin()).CountValue;
1143   F.setEntryCount(ProfileCount(FuncEntryCount, Function::PCT_Real));
1144   uint64_t FuncMaxCount = FuncEntryCount;
1145   for (auto &BB : F) {
1146     auto BI = findBBInfo(&BB);
1147     if (BI == nullptr)
1148       continue;
1149     FuncMaxCount = std::max(FuncMaxCount, BI->CountValue);
1150   }
1151   markFunctionAttributes(FuncEntryCount, FuncMaxCount);
1152 
1153   // Now annotate select instructions
1154   FuncInfo.SIVisitor.annotateSelects(F, this, &CountPosition);
1155   assert(CountPosition == ProfileCountSize);
1156 
1157   LLVM_DEBUG(FuncInfo.dumpInfo("after reading profile."));
1158 }
1159 
1160 // Assign the scaled count values to the BB with multiple out edges.
setBranchWeights()1161 void PGOUseFunc::setBranchWeights() {
1162   // Generate MD_prof metadata for every branch instruction.
1163   LLVM_DEBUG(dbgs() << "\nSetting branch weights.\n");
1164   for (auto &BB : F) {
1165     TerminatorInst *TI = BB.getTerminator();
1166     if (TI->getNumSuccessors() < 2)
1167       continue;
1168     if (!(isa<BranchInst>(TI) || isa<SwitchInst>(TI) ||
1169           isa<IndirectBrInst>(TI)))
1170       continue;
1171     if (getBBInfo(&BB).CountValue == 0)
1172       continue;
1173 
1174     // We have a non-zero Branch BB.
1175     const UseBBInfo &BBCountInfo = getBBInfo(&BB);
1176     unsigned Size = BBCountInfo.OutEdges.size();
1177     SmallVector<uint64_t, 2> EdgeCounts(Size, 0);
1178     uint64_t MaxCount = 0;
1179     for (unsigned s = 0; s < Size; s++) {
1180       const PGOUseEdge *E = BBCountInfo.OutEdges[s];
1181       const BasicBlock *SrcBB = E->SrcBB;
1182       const BasicBlock *DestBB = E->DestBB;
1183       if (DestBB == nullptr)
1184         continue;
1185       unsigned SuccNum = GetSuccessorNumber(SrcBB, DestBB);
1186       uint64_t EdgeCount = E->CountValue;
1187       if (EdgeCount > MaxCount)
1188         MaxCount = EdgeCount;
1189       EdgeCounts[SuccNum] = EdgeCount;
1190     }
1191     setProfMetadata(M, TI, EdgeCounts, MaxCount);
1192   }
1193 }
1194 
isIndirectBrTarget(BasicBlock * BB)1195 static bool isIndirectBrTarget(BasicBlock *BB) {
1196   for (pred_iterator PI = pred_begin(BB), E = pred_end(BB); PI != E; ++PI) {
1197     if (isa<IndirectBrInst>((*PI)->getTerminator()))
1198       return true;
1199   }
1200   return false;
1201 }
1202 
annotateIrrLoopHeaderWeights()1203 void PGOUseFunc::annotateIrrLoopHeaderWeights() {
1204   LLVM_DEBUG(dbgs() << "\nAnnotating irreducible loop header weights.\n");
1205   // Find irr loop headers
1206   for (auto &BB : F) {
1207     // As a heuristic also annotate indrectbr targets as they have a high chance
1208     // to become an irreducible loop header after the indirectbr tail
1209     // duplication.
1210     if (BFI->isIrrLoopHeader(&BB) || isIndirectBrTarget(&BB)) {
1211       TerminatorInst *TI = BB.getTerminator();
1212       const UseBBInfo &BBCountInfo = getBBInfo(&BB);
1213       setIrrLoopHeaderMetadata(M, TI, BBCountInfo.CountValue);
1214     }
1215   }
1216 }
1217 
instrumentOneSelectInst(SelectInst & SI)1218 void SelectInstVisitor::instrumentOneSelectInst(SelectInst &SI) {
1219   Module *M = F.getParent();
1220   IRBuilder<> Builder(&SI);
1221   Type *Int64Ty = Builder.getInt64Ty();
1222   Type *I8PtrTy = Builder.getInt8PtrTy();
1223   auto *Step = Builder.CreateZExt(SI.getCondition(), Int64Ty);
1224   Builder.CreateCall(
1225       Intrinsic::getDeclaration(M, Intrinsic::instrprof_increment_step),
1226       {ConstantExpr::getBitCast(FuncNameVar, I8PtrTy),
1227        Builder.getInt64(FuncHash), Builder.getInt32(TotalNumCtrs),
1228        Builder.getInt32(*CurCtrIdx), Step});
1229   ++(*CurCtrIdx);
1230 }
1231 
annotateOneSelectInst(SelectInst & SI)1232 void SelectInstVisitor::annotateOneSelectInst(SelectInst &SI) {
1233   std::vector<uint64_t> &CountFromProfile = UseFunc->getProfileRecord().Counts;
1234   assert(*CurCtrIdx < CountFromProfile.size() &&
1235          "Out of bound access of counters");
1236   uint64_t SCounts[2];
1237   SCounts[0] = CountFromProfile[*CurCtrIdx]; // True count
1238   ++(*CurCtrIdx);
1239   uint64_t TotalCount = 0;
1240   auto BI = UseFunc->findBBInfo(SI.getParent());
1241   if (BI != nullptr)
1242     TotalCount = BI->CountValue;
1243   // False Count
1244   SCounts[1] = (TotalCount > SCounts[0] ? TotalCount - SCounts[0] : 0);
1245   uint64_t MaxCount = std::max(SCounts[0], SCounts[1]);
1246   if (MaxCount)
1247     setProfMetadata(F.getParent(), &SI, SCounts, MaxCount);
1248 }
1249 
visitSelectInst(SelectInst & SI)1250 void SelectInstVisitor::visitSelectInst(SelectInst &SI) {
1251   if (!PGOInstrSelect)
1252     return;
1253   // FIXME: do not handle this yet.
1254   if (SI.getCondition()->getType()->isVectorTy())
1255     return;
1256 
1257   switch (Mode) {
1258   case VM_counting:
1259     NSIs++;
1260     return;
1261   case VM_instrument:
1262     instrumentOneSelectInst(SI);
1263     return;
1264   case VM_annotate:
1265     annotateOneSelectInst(SI);
1266     return;
1267   }
1268 
1269   llvm_unreachable("Unknown visiting mode");
1270 }
1271 
instrumentOneMemIntrinsic(MemIntrinsic & MI)1272 void MemIntrinsicVisitor::instrumentOneMemIntrinsic(MemIntrinsic &MI) {
1273   Module *M = F.getParent();
1274   IRBuilder<> Builder(&MI);
1275   Type *Int64Ty = Builder.getInt64Ty();
1276   Type *I8PtrTy = Builder.getInt8PtrTy();
1277   Value *Length = MI.getLength();
1278   assert(!dyn_cast<ConstantInt>(Length));
1279   Builder.CreateCall(
1280       Intrinsic::getDeclaration(M, Intrinsic::instrprof_value_profile),
1281       {ConstantExpr::getBitCast(FuncNameVar, I8PtrTy),
1282        Builder.getInt64(FuncHash), Builder.CreateZExtOrTrunc(Length, Int64Ty),
1283        Builder.getInt32(IPVK_MemOPSize), Builder.getInt32(CurCtrId)});
1284   ++CurCtrId;
1285 }
1286 
visitMemIntrinsic(MemIntrinsic & MI)1287 void MemIntrinsicVisitor::visitMemIntrinsic(MemIntrinsic &MI) {
1288   if (!PGOInstrMemOP)
1289     return;
1290   Value *Length = MI.getLength();
1291   // Not instrument constant length calls.
1292   if (dyn_cast<ConstantInt>(Length))
1293     return;
1294 
1295   switch (Mode) {
1296   case VM_counting:
1297     NMemIs++;
1298     return;
1299   case VM_instrument:
1300     instrumentOneMemIntrinsic(MI);
1301     return;
1302   case VM_annotate:
1303     Candidates.push_back(&MI);
1304     return;
1305   }
1306   llvm_unreachable("Unknown visiting mode");
1307 }
1308 
1309 // Traverse all valuesites and annotate the instructions for all value kind.
annotateValueSites()1310 void PGOUseFunc::annotateValueSites() {
1311   if (DisableValueProfiling)
1312     return;
1313 
1314   // Create the PGOFuncName meta data.
1315   createPGOFuncNameMetadata(F, FuncInfo.FuncName);
1316 
1317   for (uint32_t Kind = IPVK_First; Kind <= IPVK_Last; ++Kind)
1318     annotateValueSites(Kind);
1319 }
1320 
1321 // Annotate the instructions for a specific value kind.
annotateValueSites(uint32_t Kind)1322 void PGOUseFunc::annotateValueSites(uint32_t Kind) {
1323   unsigned ValueSiteIndex = 0;
1324   auto &ValueSites = FuncInfo.ValueSites[Kind];
1325   unsigned NumValueSites = ProfileRecord.getNumValueSites(Kind);
1326   if (NumValueSites != ValueSites.size()) {
1327     auto &Ctx = M->getContext();
1328     Ctx.diagnose(DiagnosticInfoPGOProfile(
1329         M->getName().data(),
1330         Twine("Inconsistent number of value sites for kind = ") + Twine(Kind) +
1331             " in " + F.getName().str(),
1332         DS_Warning));
1333     return;
1334   }
1335 
1336   for (auto &I : ValueSites) {
1337     LLVM_DEBUG(dbgs() << "Read one value site profile (kind = " << Kind
1338                       << "): Index = " << ValueSiteIndex << " out of "
1339                       << NumValueSites << "\n");
1340     annotateValueSite(*M, *I, ProfileRecord,
1341                       static_cast<InstrProfValueKind>(Kind), ValueSiteIndex,
1342                       Kind == IPVK_MemOPSize ? MaxNumMemOPAnnotations
1343                                              : MaxNumAnnotations);
1344     ValueSiteIndex++;
1345   }
1346 }
1347 
1348 // Create a COMDAT variable INSTR_PROF_RAW_VERSION_VAR to make the runtime
1349 // aware this is an ir_level profile so it can set the version flag.
createIRLevelProfileFlagVariable(Module & M)1350 static void createIRLevelProfileFlagVariable(Module &M) {
1351   Type *IntTy64 = Type::getInt64Ty(M.getContext());
1352   uint64_t ProfileVersion = (INSTR_PROF_RAW_VERSION | VARIANT_MASK_IR_PROF);
1353   auto IRLevelVersionVariable = new GlobalVariable(
1354       M, IntTy64, true, GlobalVariable::ExternalLinkage,
1355       Constant::getIntegerValue(IntTy64, APInt(64, ProfileVersion)),
1356       INSTR_PROF_QUOTE(INSTR_PROF_RAW_VERSION_VAR));
1357   IRLevelVersionVariable->setVisibility(GlobalValue::DefaultVisibility);
1358   Triple TT(M.getTargetTriple());
1359   if (!TT.supportsCOMDAT())
1360     IRLevelVersionVariable->setLinkage(GlobalValue::WeakAnyLinkage);
1361   else
1362     IRLevelVersionVariable->setComdat(M.getOrInsertComdat(
1363         StringRef(INSTR_PROF_QUOTE(INSTR_PROF_RAW_VERSION_VAR))));
1364 }
1365 
1366 // Collect the set of members for each Comdat in module M and store
1367 // in ComdatMembers.
collectComdatMembers(Module & M,std::unordered_multimap<Comdat *,GlobalValue * > & ComdatMembers)1368 static void collectComdatMembers(
1369     Module &M,
1370     std::unordered_multimap<Comdat *, GlobalValue *> &ComdatMembers) {
1371   if (!DoComdatRenaming)
1372     return;
1373   for (Function &F : M)
1374     if (Comdat *C = F.getComdat())
1375       ComdatMembers.insert(std::make_pair(C, &F));
1376   for (GlobalVariable &GV : M.globals())
1377     if (Comdat *C = GV.getComdat())
1378       ComdatMembers.insert(std::make_pair(C, &GV));
1379   for (GlobalAlias &GA : M.aliases())
1380     if (Comdat *C = GA.getComdat())
1381       ComdatMembers.insert(std::make_pair(C, &GA));
1382 }
1383 
InstrumentAllFunctions(Module & M,function_ref<BranchProbabilityInfo * (Function &)> LookupBPI,function_ref<BlockFrequencyInfo * (Function &)> LookupBFI)1384 static bool InstrumentAllFunctions(
1385     Module &M, function_ref<BranchProbabilityInfo *(Function &)> LookupBPI,
1386     function_ref<BlockFrequencyInfo *(Function &)> LookupBFI) {
1387   createIRLevelProfileFlagVariable(M);
1388   std::unordered_multimap<Comdat *, GlobalValue *> ComdatMembers;
1389   collectComdatMembers(M, ComdatMembers);
1390 
1391   for (auto &F : M) {
1392     if (F.isDeclaration())
1393       continue;
1394     auto *BPI = LookupBPI(F);
1395     auto *BFI = LookupBFI(F);
1396     instrumentOneFunc(F, &M, BPI, BFI, ComdatMembers);
1397   }
1398   return true;
1399 }
1400 
runOnModule(Module & M)1401 bool PGOInstrumentationGenLegacyPass::runOnModule(Module &M) {
1402   if (skipModule(M))
1403     return false;
1404 
1405   auto LookupBPI = [this](Function &F) {
1406     return &this->getAnalysis<BranchProbabilityInfoWrapperPass>(F).getBPI();
1407   };
1408   auto LookupBFI = [this](Function &F) {
1409     return &this->getAnalysis<BlockFrequencyInfoWrapperPass>(F).getBFI();
1410   };
1411   return InstrumentAllFunctions(M, LookupBPI, LookupBFI);
1412 }
1413 
run(Module & M,ModuleAnalysisManager & AM)1414 PreservedAnalyses PGOInstrumentationGen::run(Module &M,
1415                                              ModuleAnalysisManager &AM) {
1416   auto &FAM = AM.getResult<FunctionAnalysisManagerModuleProxy>(M).getManager();
1417   auto LookupBPI = [&FAM](Function &F) {
1418     return &FAM.getResult<BranchProbabilityAnalysis>(F);
1419   };
1420 
1421   auto LookupBFI = [&FAM](Function &F) {
1422     return &FAM.getResult<BlockFrequencyAnalysis>(F);
1423   };
1424 
1425   if (!InstrumentAllFunctions(M, LookupBPI, LookupBFI))
1426     return PreservedAnalyses::all();
1427 
1428   return PreservedAnalyses::none();
1429 }
1430 
annotateAllFunctions(Module & M,StringRef ProfileFileName,function_ref<BranchProbabilityInfo * (Function &)> LookupBPI,function_ref<BlockFrequencyInfo * (Function &)> LookupBFI)1431 static bool annotateAllFunctions(
1432     Module &M, StringRef ProfileFileName,
1433     function_ref<BranchProbabilityInfo *(Function &)> LookupBPI,
1434     function_ref<BlockFrequencyInfo *(Function &)> LookupBFI) {
1435   LLVM_DEBUG(dbgs() << "Read in profile counters: ");
1436   auto &Ctx = M.getContext();
1437   // Read the counter array from file.
1438   auto ReaderOrErr = IndexedInstrProfReader::create(ProfileFileName);
1439   if (Error E = ReaderOrErr.takeError()) {
1440     handleAllErrors(std::move(E), [&](const ErrorInfoBase &EI) {
1441       Ctx.diagnose(
1442           DiagnosticInfoPGOProfile(ProfileFileName.data(), EI.message()));
1443     });
1444     return false;
1445   }
1446 
1447   std::unique_ptr<IndexedInstrProfReader> PGOReader =
1448       std::move(ReaderOrErr.get());
1449   if (!PGOReader) {
1450     Ctx.diagnose(DiagnosticInfoPGOProfile(ProfileFileName.data(),
1451                                           StringRef("Cannot get PGOReader")));
1452     return false;
1453   }
1454   // TODO: might need to change the warning once the clang option is finalized.
1455   if (!PGOReader->isIRLevelProfile()) {
1456     Ctx.diagnose(DiagnosticInfoPGOProfile(
1457         ProfileFileName.data(), "Not an IR level instrumentation profile"));
1458     return false;
1459   }
1460 
1461   std::unordered_multimap<Comdat *, GlobalValue *> ComdatMembers;
1462   collectComdatMembers(M, ComdatMembers);
1463   std::vector<Function *> HotFunctions;
1464   std::vector<Function *> ColdFunctions;
1465   for (auto &F : M) {
1466     if (F.isDeclaration())
1467       continue;
1468     auto *BPI = LookupBPI(F);
1469     auto *BFI = LookupBFI(F);
1470     // Split indirectbr critical edges here before computing the MST rather than
1471     // later in getInstrBB() to avoid invalidating it.
1472     SplitIndirectBrCriticalEdges(F, BPI, BFI);
1473     PGOUseFunc Func(F, &M, ComdatMembers, BPI, BFI);
1474     if (!Func.readCounters(PGOReader.get()))
1475       continue;
1476     Func.populateCounters();
1477     Func.setBranchWeights();
1478     Func.annotateValueSites();
1479     Func.annotateIrrLoopHeaderWeights();
1480     PGOUseFunc::FuncFreqAttr FreqAttr = Func.getFuncFreqAttr();
1481     if (FreqAttr == PGOUseFunc::FFA_Cold)
1482       ColdFunctions.push_back(&F);
1483     else if (FreqAttr == PGOUseFunc::FFA_Hot)
1484       HotFunctions.push_back(&F);
1485     if (PGOViewCounts != PGOVCT_None &&
1486         (ViewBlockFreqFuncName.empty() ||
1487          F.getName().equals(ViewBlockFreqFuncName))) {
1488       LoopInfo LI{DominatorTree(F)};
1489       std::unique_ptr<BranchProbabilityInfo> NewBPI =
1490           llvm::make_unique<BranchProbabilityInfo>(F, LI);
1491       std::unique_ptr<BlockFrequencyInfo> NewBFI =
1492           llvm::make_unique<BlockFrequencyInfo>(F, *NewBPI, LI);
1493       if (PGOViewCounts == PGOVCT_Graph)
1494         NewBFI->view();
1495       else if (PGOViewCounts == PGOVCT_Text) {
1496         dbgs() << "pgo-view-counts: " << Func.getFunc().getName() << "\n";
1497         NewBFI->print(dbgs());
1498       }
1499     }
1500     if (PGOViewRawCounts != PGOVCT_None &&
1501         (ViewBlockFreqFuncName.empty() ||
1502          F.getName().equals(ViewBlockFreqFuncName))) {
1503       if (PGOViewRawCounts == PGOVCT_Graph)
1504         if (ViewBlockFreqFuncName.empty())
1505           WriteGraph(&Func, Twine("PGORawCounts_") + Func.getFunc().getName());
1506         else
1507           ViewGraph(&Func, Twine("PGORawCounts_") + Func.getFunc().getName());
1508       else if (PGOViewRawCounts == PGOVCT_Text) {
1509         dbgs() << "pgo-view-raw-counts: " << Func.getFunc().getName() << "\n";
1510         Func.dumpInfo();
1511       }
1512     }
1513   }
1514   M.setProfileSummary(PGOReader->getSummary().getMD(M.getContext()));
1515   // Set function hotness attribute from the profile.
1516   // We have to apply these attributes at the end because their presence
1517   // can affect the BranchProbabilityInfo of any callers, resulting in an
1518   // inconsistent MST between prof-gen and prof-use.
1519   for (auto &F : HotFunctions) {
1520     F->addFnAttr(Attribute::InlineHint);
1521     LLVM_DEBUG(dbgs() << "Set inline attribute to function: " << F->getName()
1522                       << "\n");
1523   }
1524   for (auto &F : ColdFunctions) {
1525     F->addFnAttr(Attribute::Cold);
1526     LLVM_DEBUG(dbgs() << "Set cold attribute to function: " << F->getName()
1527                       << "\n");
1528   }
1529   return true;
1530 }
1531 
PGOInstrumentationUse(std::string Filename)1532 PGOInstrumentationUse::PGOInstrumentationUse(std::string Filename)
1533     : ProfileFileName(std::move(Filename)) {
1534   if (!PGOTestProfileFile.empty())
1535     ProfileFileName = PGOTestProfileFile;
1536 }
1537 
run(Module & M,ModuleAnalysisManager & AM)1538 PreservedAnalyses PGOInstrumentationUse::run(Module &M,
1539                                              ModuleAnalysisManager &AM) {
1540 
1541   auto &FAM = AM.getResult<FunctionAnalysisManagerModuleProxy>(M).getManager();
1542   auto LookupBPI = [&FAM](Function &F) {
1543     return &FAM.getResult<BranchProbabilityAnalysis>(F);
1544   };
1545 
1546   auto LookupBFI = [&FAM](Function &F) {
1547     return &FAM.getResult<BlockFrequencyAnalysis>(F);
1548   };
1549 
1550   if (!annotateAllFunctions(M, ProfileFileName, LookupBPI, LookupBFI))
1551     return PreservedAnalyses::all();
1552 
1553   return PreservedAnalyses::none();
1554 }
1555 
runOnModule(Module & M)1556 bool PGOInstrumentationUseLegacyPass::runOnModule(Module &M) {
1557   if (skipModule(M))
1558     return false;
1559 
1560   auto LookupBPI = [this](Function &F) {
1561     return &this->getAnalysis<BranchProbabilityInfoWrapperPass>(F).getBPI();
1562   };
1563   auto LookupBFI = [this](Function &F) {
1564     return &this->getAnalysis<BlockFrequencyInfoWrapperPass>(F).getBFI();
1565   };
1566 
1567   return annotateAllFunctions(M, ProfileFileName, LookupBPI, LookupBFI);
1568 }
1569 
getSimpleNodeName(const BasicBlock * Node)1570 static std::string getSimpleNodeName(const BasicBlock *Node) {
1571   if (!Node->getName().empty())
1572     return Node->getName();
1573 
1574   std::string SimpleNodeName;
1575   raw_string_ostream OS(SimpleNodeName);
1576   Node->printAsOperand(OS, false);
1577   return OS.str();
1578 }
1579 
setProfMetadata(Module * M,Instruction * TI,ArrayRef<uint64_t> EdgeCounts,uint64_t MaxCount)1580 void llvm::setProfMetadata(Module *M, Instruction *TI,
1581                            ArrayRef<uint64_t> EdgeCounts,
1582                            uint64_t MaxCount) {
1583   MDBuilder MDB(M->getContext());
1584   assert(MaxCount > 0 && "Bad max count");
1585   uint64_t Scale = calculateCountScale(MaxCount);
1586   SmallVector<unsigned, 4> Weights;
1587   for (const auto &ECI : EdgeCounts)
1588     Weights.push_back(scaleBranchCount(ECI, Scale));
1589 
1590   LLVM_DEBUG(dbgs() << "Weight is: "; for (const auto &W
1591                                            : Weights) {
1592     dbgs() << W << " ";
1593   } dbgs() << "\n";);
1594   TI->setMetadata(LLVMContext::MD_prof, MDB.createBranchWeights(Weights));
1595   if (EmitBranchProbability) {
1596     std::string BrCondStr = getBranchCondString(TI);
1597     if (BrCondStr.empty())
1598       return;
1599 
1600     uint64_t WSum =
1601         std::accumulate(Weights.begin(), Weights.end(), (uint64_t)0,
1602                         [](uint64_t w1, uint64_t w2) { return w1 + w2; });
1603     uint64_t TotalCount =
1604         std::accumulate(EdgeCounts.begin(), EdgeCounts.end(), (uint64_t)0,
1605                         [](uint64_t c1, uint64_t c2) { return c1 + c2; });
1606     Scale = calculateCountScale(WSum);
1607     BranchProbability BP(scaleBranchCount(Weights[0], Scale),
1608                          scaleBranchCount(WSum, Scale));
1609     std::string BranchProbStr;
1610     raw_string_ostream OS(BranchProbStr);
1611     OS << BP;
1612     OS << " (total count : " << TotalCount << ")";
1613     OS.flush();
1614     Function *F = TI->getParent()->getParent();
1615     OptimizationRemarkEmitter ORE(F);
1616     ORE.emit([&]() {
1617       return OptimizationRemark(DEBUG_TYPE, "pgo-instrumentation", TI)
1618              << BrCondStr << " is true with probability : " << BranchProbStr;
1619     });
1620   }
1621 }
1622 
1623 namespace llvm {
1624 
setIrrLoopHeaderMetadata(Module * M,Instruction * TI,uint64_t Count)1625 void setIrrLoopHeaderMetadata(Module *M, Instruction *TI, uint64_t Count) {
1626   MDBuilder MDB(M->getContext());
1627   TI->setMetadata(llvm::LLVMContext::MD_irr_loop,
1628                   MDB.createIrrLoopHeaderWeight(Count));
1629 }
1630 
1631 template <> struct GraphTraits<PGOUseFunc *> {
1632   using NodeRef = const BasicBlock *;
1633   using ChildIteratorType = succ_const_iterator;
1634   using nodes_iterator = pointer_iterator<Function::const_iterator>;
1635 
getEntryNodellvm::GraphTraits1636   static NodeRef getEntryNode(const PGOUseFunc *G) {
1637     return &G->getFunc().front();
1638   }
1639 
child_beginllvm::GraphTraits1640   static ChildIteratorType child_begin(const NodeRef N) {
1641     return succ_begin(N);
1642   }
1643 
child_endllvm::GraphTraits1644   static ChildIteratorType child_end(const NodeRef N) { return succ_end(N); }
1645 
nodes_beginllvm::GraphTraits1646   static nodes_iterator nodes_begin(const PGOUseFunc *G) {
1647     return nodes_iterator(G->getFunc().begin());
1648   }
1649 
nodes_endllvm::GraphTraits1650   static nodes_iterator nodes_end(const PGOUseFunc *G) {
1651     return nodes_iterator(G->getFunc().end());
1652   }
1653 };
1654 
1655 template <> struct DOTGraphTraits<PGOUseFunc *> : DefaultDOTGraphTraits {
DOTGraphTraitsllvm::DOTGraphTraits1656   explicit DOTGraphTraits(bool isSimple = false)
1657       : DefaultDOTGraphTraits(isSimple) {}
1658 
getGraphNamellvm::DOTGraphTraits1659   static std::string getGraphName(const PGOUseFunc *G) {
1660     return G->getFunc().getName();
1661   }
1662 
getNodeLabelllvm::DOTGraphTraits1663   std::string getNodeLabel(const BasicBlock *Node, const PGOUseFunc *Graph) {
1664     std::string Result;
1665     raw_string_ostream OS(Result);
1666 
1667     OS << getSimpleNodeName(Node) << ":\\l";
1668     UseBBInfo *BI = Graph->findBBInfo(Node);
1669     OS << "Count : ";
1670     if (BI && BI->CountValid)
1671       OS << BI->CountValue << "\\l";
1672     else
1673       OS << "Unknown\\l";
1674 
1675     if (!PGOInstrSelect)
1676       return Result;
1677 
1678     for (auto BI = Node->begin(); BI != Node->end(); ++BI) {
1679       auto *I = &*BI;
1680       if (!isa<SelectInst>(I))
1681         continue;
1682       // Display scaled counts for SELECT instruction:
1683       OS << "SELECT : { T = ";
1684       uint64_t TC, FC;
1685       bool HasProf = I->extractProfMetadata(TC, FC);
1686       if (!HasProf)
1687         OS << "Unknown, F = Unknown }\\l";
1688       else
1689         OS << TC << ", F = " << FC << " }\\l";
1690     }
1691     return Result;
1692   }
1693 };
1694 
1695 } // end namespace llvm
1696