LLVM  9.0.0svn
PGOInstrumentation.cpp
Go to the documentation of this file.
1 //===- PGOInstrumentation.cpp - MST-based PGO Instrumentation -------------===//
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 // This file implements PGO instrumentation using a minimum spanning tree based
10 // on the following paper:
11 // [1] Donald E. Knuth, Francis R. Stevenson. Optimal measurement of points
12 // for program frequency counts. BIT Numerical Mathematics 1973, Volume 13,
13 // Issue 3, pp 313-322
14 // The idea of the algorithm based on the fact that for each node (except for
15 // the entry and exit), the sum of incoming edge counts equals the sum of
16 // outgoing edge counts. The count of edge on spanning tree can be derived from
17 // those edges not on the spanning tree. Knuth proves this method instruments
18 // the minimum number of edges.
19 //
20 // The minimal spanning tree here is actually a maximum weight tree -- on-tree
21 // edges have higher frequencies (more likely to execute). The idea is to
22 // instrument those less frequently executed edges to reduce the runtime
23 // overhead of instrumented binaries.
24 //
25 // This file contains two passes:
26 // (1) Pass PGOInstrumentationGen which instruments the IR to generate edge
27 // count profile, and generates the instrumentation for indirect call
28 // profiling.
29 // (2) Pass PGOInstrumentationUse which reads the edge count profile and
30 // annotates the branch weights. It also reads the indirect call value
31 // profiling records and annotate the indirect call instructions.
32 //
33 // To get the precise counter information, These two passes need to invoke at
34 // the same compilation point (so they see the same IR). For pass
35 // PGOInstrumentationGen, the real work is done in instrumentOneFunc(). For
36 // pass PGOInstrumentationUse, the real work in done in class PGOUseFunc and
37 // the profile is opened in module level and passed to each PGOUseFunc instance.
38 // The shared code for PGOInstrumentationGen and PGOInstrumentationUse is put
39 // in class FuncPGOInstrumentation.
40 //
41 // Class PGOEdge represents a CFG edge and some auxiliary information. Class
42 // BBInfo contains auxiliary information for each BB. These two classes are used
43 // in pass PGOInstrumentationGen. Class PGOUseEdge and UseBBInfo are the derived
44 // class of PGOEdge and BBInfo, respectively. They contains extra data structure
45 // used in populating profile counters.
46 // The MST implementation is in Class CFGMST (CFGMST.h).
47 //
48 //===----------------------------------------------------------------------===//
49 
50 #include "CFGMST.h"
51 #include "llvm/ADT/APInt.h"
52 #include "llvm/ADT/ArrayRef.h"
53 #include "llvm/ADT/STLExtras.h"
54 #include "llvm/ADT/SmallVector.h"
55 #include "llvm/ADT/Statistic.h"
56 #include "llvm/ADT/StringRef.h"
57 #include "llvm/ADT/Triple.h"
58 #include "llvm/ADT/Twine.h"
59 #include "llvm/ADT/iterator.h"
63 #include "llvm/Analysis/CFG.h"
65 #include "llvm/Analysis/LoopInfo.h"
68 #include "llvm/IR/Attributes.h"
69 #include "llvm/IR/BasicBlock.h"
70 #include "llvm/IR/CFG.h"
71 #include "llvm/IR/CallSite.h"
72 #include "llvm/IR/Comdat.h"
73 #include "llvm/IR/Constant.h"
74 #include "llvm/IR/Constants.h"
75 #include "llvm/IR/DiagnosticInfo.h"
76 #include "llvm/IR/Dominators.h"
77 #include "llvm/IR/Function.h"
78 #include "llvm/IR/GlobalAlias.h"
79 #include "llvm/IR/GlobalValue.h"
80 #include "llvm/IR/GlobalVariable.h"
81 #include "llvm/IR/IRBuilder.h"
82 #include "llvm/IR/InstVisitor.h"
83 #include "llvm/IR/InstrTypes.h"
84 #include "llvm/IR/Instruction.h"
85 #include "llvm/IR/Instructions.h"
86 #include "llvm/IR/IntrinsicInst.h"
87 #include "llvm/IR/Intrinsics.h"
88 #include "llvm/IR/LLVMContext.h"
89 #include "llvm/IR/MDBuilder.h"
90 #include "llvm/IR/Module.h"
91 #include "llvm/IR/PassManager.h"
92 #include "llvm/IR/ProfileSummary.h"
93 #include "llvm/IR/Type.h"
94 #include "llvm/IR/Value.h"
95 #include "llvm/Pass.h"
99 #include "llvm/Support/Casting.h"
102 #include "llvm/Support/Debug.h"
103 #include "llvm/Support/Error.h"
106 #include "llvm/Support/JamCRC.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;
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 STATISTIC(NumOfCSPGOInstrument, "Number of edges instrumented in CSPGO.");
137 STATISTIC(NumOfCSPGOSelectInsts,
138  "Number of select instruction instrumented in CSPGO.");
139 STATISTIC(NumOfCSPGOMemIntrinsics,
140  "Number of mem intrinsics instrumented in CSPGO.");
141 STATISTIC(NumOfCSPGOEdge, "Number of edges in CSPGO.");
142 STATISTIC(NumOfCSPGOBB, "Number of basic-blocks in CSPGO.");
143 STATISTIC(NumOfCSPGOSplit, "Number of critical edge splits in CSPGO.");
144 STATISTIC(NumOfCSPGOFunc,
145  "Number of functions having valid profile counts in CSPGO.");
146 STATISTIC(NumOfCSPGOMismatch,
147  "Number of functions having mismatch profile in CSPGO.");
148 STATISTIC(NumOfCSPGOMissing, "Number of functions without profile in CSPGO.");
149 
150 // Command line option to specify the file to read profile from. This is
151 // mainly used for testing.
153  PGOTestProfileFile("pgo-test-profile-file", cl::init(""), cl::Hidden,
154  cl::value_desc("filename"),
155  cl::desc("Specify the path of profile data file. This is"
156  "mainly for test purpose."));
158  "pgo-test-profile-remapping-file", cl::init(""), cl::Hidden,
159  cl::value_desc("filename"),
160  cl::desc("Specify the path of profile remapping file. This is mainly for "
161  "test purpose."));
162 
163 // Command line option to disable value profiling. The default is false:
164 // i.e. value profiling is enabled by default. This is for debug purpose.
165 static cl::opt<bool> DisableValueProfiling("disable-vp", cl::init(false),
166  cl::Hidden,
167  cl::desc("Disable Value Profiling"));
168 
169 // Command line option to set the maximum number of VP annotations to write to
170 // the metadata for a single indirect call callsite.
172  "icp-max-annotations", cl::init(3), cl::Hidden, cl::ZeroOrMore,
173  cl::desc("Max number of annotations for a single indirect "
174  "call callsite"));
175 
176 // Command line option to set the maximum number of value annotations
177 // to write to the metadata for a single memop intrinsic.
179  "memop-max-annotations", cl::init(4), cl::Hidden, cl::ZeroOrMore,
180  cl::desc("Max number of preicise value annotations for a single memop"
181  "intrinsic"));
182 
183 // Command line option to control appending FunctionHash to the name of a COMDAT
184 // function. This is to avoid the hash mismatch caused by the preinliner.
186  "do-comdat-renaming", cl::init(false), cl::Hidden,
187  cl::desc("Append function hash to the name of COMDAT function to avoid "
188  "function hash mismatch due to the preinliner"));
189 
190 // Command line option to enable/disable the warning about missing profile
191 // information.
192 static cl::opt<bool>
193  PGOWarnMissing("pgo-warn-missing-function", cl::init(false), cl::Hidden,
194  cl::desc("Use this option to turn on/off "
195  "warnings about missing profile data for "
196  "functions."));
197 
198 // Command line option to enable/disable the warning about a hash mismatch in
199 // the profile data.
200 static cl::opt<bool>
201  NoPGOWarnMismatch("no-pgo-warn-mismatch", cl::init(false), cl::Hidden,
202  cl::desc("Use this option to turn off/on "
203  "warnings about profile cfg mismatch."));
204 
205 // Command line option to enable/disable the warning about a hash mismatch in
206 // the profile data for Comdat functions, which often turns out to be false
207 // positive due to the pre-instrumentation inline.
208 static cl::opt<bool>
209  NoPGOWarnMismatchComdat("no-pgo-warn-mismatch-comdat", cl::init(true),
210  cl::Hidden,
211  cl::desc("The option is used to turn on/off "
212  "warnings about hash mismatch for comdat "
213  "functions."));
214 
215 // Command line option to enable/disable select instruction instrumentation.
216 static cl::opt<bool>
217  PGOInstrSelect("pgo-instr-select", cl::init(true), cl::Hidden,
218  cl::desc("Use this option to turn on/off SELECT "
219  "instruction instrumentation. "));
220 
221 // Command line option to turn on CFG dot or text dump of raw profile counts
223  "pgo-view-raw-counts", cl::Hidden,
224  cl::desc("A boolean option to show CFG dag or text "
225  "with raw profile counts from "
226  "profile data. See also option "
227  "-pgo-view-counts. To limit graph "
228  "display to only one function, use "
229  "filtering option -view-bfi-func-name."),
230  cl::values(clEnumValN(PGOVCT_None, "none", "do not show."),
231  clEnumValN(PGOVCT_Graph, "graph", "show a graph."),
232  clEnumValN(PGOVCT_Text, "text", "show in text.")));
233 
234 // Command line option to enable/disable memop intrinsic call.size profiling.
235 static cl::opt<bool>
236  PGOInstrMemOP("pgo-instr-memop", cl::init(true), cl::Hidden,
237  cl::desc("Use this option to turn on/off "
238  "memory intrinsic size profiling."));
239 
240 // Emit branch probability as optimization remarks.
241 static cl::opt<bool>
242  EmitBranchProbability("pgo-emit-branch-prob", cl::init(false), cl::Hidden,
243  cl::desc("When this option is on, the annotated "
244  "branch probability will be emitted as "
245  "optimization remarks: -{Rpass|"
246  "pass-remarks}=pgo-instrumentation"));
247 
248 // Command line option to turn on CFG dot dump after profile annotation.
249 // Defined in Analysis/BlockFrequencyInfo.cpp: -pgo-view-counts
251 
252 // Command line option to specify the name of the function for CFG dump
253 // Defined in Analysis/BlockFrequencyInfo.cpp: -view-bfi-func-name=
255 
256 // Return a string describing the branch condition that can be
257 // used in static branch probability heuristics:
258 static std::string getBranchCondString(Instruction *TI) {
259  BranchInst *BI = dyn_cast<BranchInst>(TI);
260  if (!BI || !BI->isConditional())
261  return std::string();
262 
263  Value *Cond = BI->getCondition();
264  ICmpInst *CI = dyn_cast<ICmpInst>(Cond);
265  if (!CI)
266  return std::string();
267 
268  std::string result;
269  raw_string_ostream OS(result);
270  OS << CmpInst::getPredicateName(CI->getPredicate()) << "_";
271  CI->getOperand(0)->getType()->print(OS, true);
272 
273  Value *RHS = CI->getOperand(1);
274  ConstantInt *CV = dyn_cast<ConstantInt>(RHS);
275  if (CV) {
276  if (CV->isZero())
277  OS << "_Zero";
278  else if (CV->isOne())
279  OS << "_One";
280  else if (CV->isMinusOne())
281  OS << "_MinusOne";
282  else
283  OS << "_Const";
284  }
285  OS.flush();
286  return result;
287 }
288 
289 namespace {
290 
291 /// The select instruction visitor plays three roles specified
292 /// by the mode. In \c VM_counting mode, it simply counts the number of
293 /// select instructions. In \c VM_instrument mode, it inserts code to count
294 /// the number times TrueValue of select is taken. In \c VM_annotate mode,
295 /// it reads the profile data and annotate the select instruction with metadata.
296 enum VisitMode { VM_counting, VM_instrument, VM_annotate };
297 class PGOUseFunc;
298 
299 /// Instruction Visitor class to visit select instructions.
300 struct SelectInstVisitor : public InstVisitor<SelectInstVisitor> {
301  Function &F;
302  unsigned NSIs = 0; // Number of select instructions instrumented.
303  VisitMode Mode = VM_counting; // Visiting mode.
304  unsigned *CurCtrIdx = nullptr; // Pointer to current counter index.
305  unsigned TotalNumCtrs = 0; // Total number of counters
306  GlobalVariable *FuncNameVar = nullptr;
307  uint64_t FuncHash = 0;
308  PGOUseFunc *UseFunc = nullptr;
309 
310  SelectInstVisitor(Function &Func) : F(Func) {}
311 
312  void countSelects(Function &Func) {
313  NSIs = 0;
314  Mode = VM_counting;
315  visit(Func);
316  }
317 
318  // Visit the IR stream and instrument all select instructions. \p
319  // Ind is a pointer to the counter index variable; \p TotalNC
320  // is the total number of counters; \p FNV is the pointer to the
321  // PGO function name var; \p FHash is the function hash.
322  void instrumentSelects(Function &Func, unsigned *Ind, unsigned TotalNC,
323  GlobalVariable *FNV, uint64_t FHash) {
324  Mode = VM_instrument;
325  CurCtrIdx = Ind;
326  TotalNumCtrs = TotalNC;
327  FuncHash = FHash;
328  FuncNameVar = FNV;
329  visit(Func);
330  }
331 
332  // Visit the IR stream and annotate all select instructions.
333  void annotateSelects(Function &Func, PGOUseFunc *UF, unsigned *Ind) {
334  Mode = VM_annotate;
335  UseFunc = UF;
336  CurCtrIdx = Ind;
337  visit(Func);
338  }
339 
340  void instrumentOneSelectInst(SelectInst &SI);
341  void annotateOneSelectInst(SelectInst &SI);
342 
343  // Visit \p SI instruction and perform tasks according to visit mode.
344  void visitSelectInst(SelectInst &SI);
345 
346  // Return the number of select instructions. This needs be called after
347  // countSelects().
348  unsigned getNumOfSelectInsts() const { return NSIs; }
349 };
350 
351 /// Instruction Visitor class to visit memory intrinsic calls.
352 struct MemIntrinsicVisitor : public InstVisitor<MemIntrinsicVisitor> {
353  Function &F;
354  unsigned NMemIs = 0; // Number of memIntrinsics instrumented.
355  VisitMode Mode = VM_counting; // Visiting mode.
356  unsigned CurCtrId = 0; // Current counter index.
357  unsigned TotalNumCtrs = 0; // Total number of counters
358  GlobalVariable *FuncNameVar = nullptr;
359  uint64_t FuncHash = 0;
360  PGOUseFunc *UseFunc = nullptr;
361  std::vector<Instruction *> Candidates;
362 
363  MemIntrinsicVisitor(Function &Func) : F(Func) {}
364 
365  void countMemIntrinsics(Function &Func) {
366  NMemIs = 0;
367  Mode = VM_counting;
368  visit(Func);
369  }
370 
371  void instrumentMemIntrinsics(Function &Func, unsigned TotalNC,
372  GlobalVariable *FNV, uint64_t FHash) {
373  Mode = VM_instrument;
374  TotalNumCtrs = TotalNC;
375  FuncHash = FHash;
376  FuncNameVar = FNV;
377  visit(Func);
378  }
379 
380  std::vector<Instruction *> findMemIntrinsics(Function &Func) {
381  Candidates.clear();
382  Mode = VM_annotate;
383  visit(Func);
384  return Candidates;
385  }
386 
387  // Visit the IR stream and annotate all mem intrinsic call instructions.
388  void instrumentOneMemIntrinsic(MemIntrinsic &MI);
389 
390  // Visit \p MI instruction and perform tasks according to visit mode.
391  void visitMemIntrinsic(MemIntrinsic &SI);
392 
393  unsigned getNumOfMemIntrinsics() const { return NMemIs; }
394 };
395 
396 class PGOInstrumentationGenLegacyPass : public ModulePass {
397 public:
398  static char ID;
399 
400  PGOInstrumentationGenLegacyPass(bool IsCS = false)
401  : ModulePass(ID), IsCS(IsCS) {
404  }
405 
406  StringRef getPassName() const override { return "PGOInstrumentationGenPass"; }
407 
408 private:
409  // Is this is context-sensitive instrumentation.
410  bool IsCS;
411  bool runOnModule(Module &M) override;
412 
413  void getAnalysisUsage(AnalysisUsage &AU) const override {
415  }
416 };
417 
418 class PGOInstrumentationUseLegacyPass : public ModulePass {
419 public:
420  static char ID;
421 
422  // Provide the profile filename as the parameter.
423  PGOInstrumentationUseLegacyPass(std::string Filename = "", bool IsCS = false)
424  : ModulePass(ID), ProfileFileName(std::move(Filename)), IsCS(IsCS) {
425  if (!PGOTestProfileFile.empty())
426  ProfileFileName = PGOTestProfileFile;
429  }
430 
431  StringRef getPassName() const override { return "PGOInstrumentationUsePass"; }
432 
433 private:
434  std::string ProfileFileName;
435  // Is this is context-sensitive instrumentation use.
436  bool IsCS;
437 
438  bool runOnModule(Module &M) override;
439 
440  void getAnalysisUsage(AnalysisUsage &AU) const override {
443  }
444 };
445 
446 class PGOInstrumentationGenCreateVarLegacyPass : public ModulePass {
447 public:
448  static char ID;
449  StringRef getPassName() const override {
450  return "PGOInstrumentationGenCreateVarPass";
451  }
452  PGOInstrumentationGenCreateVarLegacyPass(std::string CSInstrName = "")
453  : ModulePass(ID), InstrProfileOutput(CSInstrName) {
456  }
457 
458 private:
459  bool runOnModule(Module &M) override {
460  createProfileFileNameVar(M, InstrProfileOutput);
462  return false;
463  }
464  std::string InstrProfileOutput;
465 };
466 
467 } // end anonymous namespace
468 
470 
471 INITIALIZE_PASS_BEGIN(PGOInstrumentationGenLegacyPass, "pgo-instr-gen",
472  "PGO instrumentation.", false, false)
475 INITIALIZE_PASS_END(PGOInstrumentationGenLegacyPass, "pgo-instr-gen",
476  "PGO instrumentation.", false, false)
477 
479  return new PGOInstrumentationGenLegacyPass(IsCS);
480 }
481 
483 
484 INITIALIZE_PASS_BEGIN(PGOInstrumentationUseLegacyPass, "pgo-instr-use",
485  "Read PGO instrumentation profile.", false, false)
489 INITIALIZE_PASS_END(PGOInstrumentationUseLegacyPass, "pgo-instr-use",
490  "Read PGO instrumentation profile.", false, false)
491 
493  bool IsCS) {
494  return new PGOInstrumentationUseLegacyPass(Filename.str(), IsCS);
495 }
496 
498 
499 INITIALIZE_PASS(PGOInstrumentationGenCreateVarLegacyPass,
500  "pgo-instr-gen-create-var",
501  "Create PGO instrumentation version variable for CSPGO.", false,
502  false)
503 
504 ModulePass *
506  return new PGOInstrumentationGenCreateVarLegacyPass(CSInstrName);
507 }
508 
509 namespace {
510 
511 /// An MST based instrumentation for PGO
512 ///
513 /// Implements a Minimum Spanning Tree (MST) based instrumentation for PGO
514 /// in the function level.
515 struct PGOEdge {
516  // This class implements the CFG edges. Note the CFG can be a multi-graph.
517  // So there might be multiple edges with same SrcBB and DestBB.
518  const BasicBlock *SrcBB;
519  const BasicBlock *DestBB;
520  uint64_t Weight;
521  bool InMST = false;
522  bool Removed = false;
523  bool IsCritical = false;
524 
525  PGOEdge(const BasicBlock *Src, const BasicBlock *Dest, uint64_t W = 1)
526  : SrcBB(Src), DestBB(Dest), Weight(W) {}
527 
528  // Return the information string of an edge.
529  const std::string infoString() const {
530  return (Twine(Removed ? "-" : " ") + (InMST ? " " : "*") +
531  (IsCritical ? "c" : " ") + " W=" + Twine(Weight)).str();
532  }
533 };
534 
535 // This class stores the auxiliary information for each BB.
536 struct BBInfo {
537  BBInfo *Group;
538  uint32_t Index;
539  uint32_t Rank = 0;
540 
541  BBInfo(unsigned IX) : Group(this), Index(IX) {}
542 
543  // Return the information string of this object.
544  const std::string infoString() const {
545  return (Twine("Index=") + Twine(Index)).str();
546  }
547 };
548 
549 // This class implements the CFG edges. Note the CFG can be a multi-graph.
550 template <class Edge, class BBInfo> class FuncPGOInstrumentation {
551 private:
552  Function &F;
553 
554  // Is this is context-sensitive instrumentation.
555  bool IsCS;
556 
557  // A map that stores the Comdat group in function F.
558  std::unordered_multimap<Comdat *, GlobalValue *> &ComdatMembers;
559 
560  void computeCFGHash();
561  void renameComdatFunction();
562 
563 public:
564  std::vector<std::vector<Instruction *>> ValueSites;
565  SelectInstVisitor SIVisitor;
566  MemIntrinsicVisitor MIVisitor;
567  std::string FuncName;
568  GlobalVariable *FuncNameVar;
569 
570  // CFG hash value for this function.
571  uint64_t FunctionHash = 0;
572 
573  // The Minimum Spanning Tree of function CFG.
575 
576  // Give an edge, find the BB that will be instrumented.
577  // Return nullptr if there is no BB to be instrumented.
578  BasicBlock *getInstrBB(Edge *E);
579 
580  // Return the auxiliary BB information.
581  BBInfo &getBBInfo(const BasicBlock *BB) const { return MST.getBBInfo(BB); }
582 
583  // Return the auxiliary BB information if available.
584  BBInfo *findBBInfo(const BasicBlock *BB) const { return MST.findBBInfo(BB); }
585 
586  // Dump edges and BB information.
587  void dumpInfo(std::string Str = "") const {
588  MST.dumpEdges(dbgs(), Twine("Dump Function ") + FuncName + " Hash: " +
589  Twine(FunctionHash) + "\t" + Str);
590  }
591 
592  FuncPGOInstrumentation(
593  Function &Func,
594  std::unordered_multimap<Comdat *, GlobalValue *> &ComdatMembers,
595  bool CreateGlobalVar = false, BranchProbabilityInfo *BPI = nullptr,
596  BlockFrequencyInfo *BFI = nullptr, bool IsCS = false)
597  : F(Func), IsCS(IsCS), ComdatMembers(ComdatMembers),
598  ValueSites(IPVK_Last + 1), SIVisitor(Func), MIVisitor(Func),
599  MST(F, BPI, BFI) {
600  // This should be done before CFG hash computation.
601  SIVisitor.countSelects(Func);
602  MIVisitor.countMemIntrinsics(Func);
603  if (!IsCS) {
604  NumOfPGOSelectInsts += SIVisitor.getNumOfSelectInsts();
605  NumOfPGOMemIntrinsics += MIVisitor.getNumOfMemIntrinsics();
606  NumOfPGOBB += MST.BBInfos.size();
607  ValueSites[IPVK_IndirectCallTarget] = findIndirectCalls(Func);
608  } else {
609  NumOfCSPGOSelectInsts += SIVisitor.getNumOfSelectInsts();
610  NumOfCSPGOMemIntrinsics += MIVisitor.getNumOfMemIntrinsics();
611  NumOfCSPGOBB += MST.BBInfos.size();
612  }
613  ValueSites[IPVK_MemOPSize] = MIVisitor.findMemIntrinsics(Func);
614 
615  FuncName = getPGOFuncName(F);
616  computeCFGHash();
617  if (!ComdatMembers.empty())
618  renameComdatFunction();
619  LLVM_DEBUG(dumpInfo("after CFGMST"));
620 
621  for (auto &E : MST.AllEdges) {
622  if (E->Removed)
623  continue;
624  IsCS ? NumOfCSPGOEdge++ : NumOfPGOEdge++;
625  if (!E->InMST)
626  IsCS ? NumOfCSPGOInstrument++ : NumOfPGOInstrument++;
627  }
628 
629  if (CreateGlobalVar)
630  FuncNameVar = createPGOFuncNameVar(F, FuncName);
631  }
632 
633  // Return the number of profile counters needed for the function.
634  unsigned getNumCounters() {
635  unsigned NumCounters = 0;
636  for (auto &E : this->MST.AllEdges) {
637  if (!E->InMST && !E->Removed)
638  NumCounters++;
639  }
640  return NumCounters + SIVisitor.getNumOfSelectInsts();
641  }
642 };
643 
644 } // end anonymous namespace
645 
646 // Compute Hash value for the CFG: the lower 32 bits are CRC32 of the index
647 // value of each BB in the CFG. The higher 32 bits record the number of edges.
648 template <class Edge, class BBInfo>
649 void FuncPGOInstrumentation<Edge, BBInfo>::computeCFGHash() {
650  std::vector<char> Indexes;
651  JamCRC JC;
652  for (auto &BB : F) {
653  const Instruction *TI = BB.getTerminator();
654  for (unsigned I = 0, E = TI->getNumSuccessors(); I != E; ++I) {
655  BasicBlock *Succ = TI->getSuccessor(I);
656  auto BI = findBBInfo(Succ);
657  if (BI == nullptr)
658  continue;
659  uint32_t Index = BI->Index;
660  for (int J = 0; J < 4; J++)
661  Indexes.push_back((char)(Index >> (J * 8)));
662  }
663  }
664  JC.update(Indexes);
665 
666  // Hash format for context sensitive profile. Reserve 4 bits for other
667  // information.
668  FunctionHash = (uint64_t)SIVisitor.getNumOfSelectInsts() << 56 |
669  (uint64_t)ValueSites[IPVK_IndirectCallTarget].size() << 48 |
670  //(uint64_t)ValueSites[IPVK_MemOPSize].size() << 40 |
671  (uint64_t)MST.AllEdges.size() << 32 | JC.getCRC();
672  // Reserve bit 60-63 for other information purpose.
673  FunctionHash &= 0x0FFFFFFFFFFFFFFF;
674  if (IsCS)
676  LLVM_DEBUG(dbgs() << "Function Hash Computation for " << F.getName() << ":\n"
677  << " CRC = " << JC.getCRC()
678  << ", Selects = " << SIVisitor.getNumOfSelectInsts()
679  << ", Edges = " << MST.AllEdges.size() << ", ICSites = "
680  << ValueSites[IPVK_IndirectCallTarget].size()
681  << ", Hash = " << FunctionHash << "\n";);
682 }
683 
684 // Check if we can safely rename this Comdat function.
685 static bool canRenameComdat(
686  Function &F,
687  std::unordered_multimap<Comdat *, GlobalValue *> &ComdatMembers) {
688  if (!DoComdatRenaming || !canRenameComdatFunc(F, true))
689  return false;
690 
691  // FIXME: Current only handle those Comdat groups that only containing one
692  // function and function aliases.
693  // (1) For a Comdat group containing multiple functions, we need to have a
694  // unique postfix based on the hashes for each function. There is a
695  // non-trivial code refactoring to do this efficiently.
696  // (2) Variables can not be renamed, so we can not rename Comdat function in a
697  // group including global vars.
698  Comdat *C = F.getComdat();
699  for (auto &&CM : make_range(ComdatMembers.equal_range(C))) {
700  if (dyn_cast<GlobalAlias>(CM.second))
701  continue;
702  Function *FM = dyn_cast<Function>(CM.second);
703  if (FM != &F)
704  return false;
705  }
706  return true;
707 }
708 
709 // Append the CFGHash to the Comdat function name.
710 template <class Edge, class BBInfo>
711 void FuncPGOInstrumentation<Edge, BBInfo>::renameComdatFunction() {
712  if (!canRenameComdat(F, ComdatMembers))
713  return;
714  std::string OrigName = F.getName().str();
715  std::string NewFuncName =
716  Twine(F.getName() + "." + Twine(FunctionHash)).str();
717  F.setName(Twine(NewFuncName));
719  FuncName = Twine(FuncName + "." + Twine(FunctionHash)).str();
720  Comdat *NewComdat;
721  Module *M = F.getParent();
722  // For AvailableExternallyLinkage functions, change the linkage to
723  // LinkOnceODR and put them into comdat. This is because after renaming, there
724  // is no backup external copy available for the function.
725  if (!F.hasComdat()) {
727  NewComdat = M->getOrInsertComdat(StringRef(NewFuncName));
729  F.setComdat(NewComdat);
730  return;
731  }
732 
733  // This function belongs to a single function Comdat group.
734  Comdat *OrigComdat = F.getComdat();
735  std::string NewComdatName =
736  Twine(OrigComdat->getName() + "." + Twine(FunctionHash)).str();
737  NewComdat = M->getOrInsertComdat(StringRef(NewComdatName));
738  NewComdat->setSelectionKind(OrigComdat->getSelectionKind());
739 
740  for (auto &&CM : make_range(ComdatMembers.equal_range(OrigComdat))) {
741  if (GlobalAlias *GA = dyn_cast<GlobalAlias>(CM.second)) {
742  // For aliases, change the name directly.
743  assert(dyn_cast<Function>(GA->getAliasee()->stripPointerCasts()) == &F);
744  std::string OrigGAName = GA->getName().str();
745  GA->setName(Twine(GA->getName() + "." + Twine(FunctionHash)));
747  continue;
748  }
749  // Must be a function.
750  Function *CF = dyn_cast<Function>(CM.second);
751  assert(CF);
752  CF->setComdat(NewComdat);
753  }
754 }
755 
756 // Given a CFG E to be instrumented, find which BB to place the instrumented
757 // code. The function will split the critical edge if necessary.
758 template <class Edge, class BBInfo>
759 BasicBlock *FuncPGOInstrumentation<Edge, BBInfo>::getInstrBB(Edge *E) {
760  if (E->InMST || E->Removed)
761  return nullptr;
762 
763  BasicBlock *SrcBB = const_cast<BasicBlock *>(E->SrcBB);
764  BasicBlock *DestBB = const_cast<BasicBlock *>(E->DestBB);
765  // For a fake edge, instrument the real BB.
766  if (SrcBB == nullptr)
767  return DestBB;
768  if (DestBB == nullptr)
769  return SrcBB;
770 
771  // Instrument the SrcBB if it has a single successor,
772  // otherwise, the DestBB if this is not a critical edge.
773  Instruction *TI = SrcBB->getTerminator();
774  if (TI->getNumSuccessors() <= 1)
775  return SrcBB;
776  if (!E->IsCritical)
777  return DestBB;
778 
779  // For a critical edge, we have to split. Instrument the newly
780  // created BB.
781  IsCS ? NumOfCSPGOSplit++ : NumOfPGOSplit++;
782  LLVM_DEBUG(dbgs() << "Split critical edge: " << getBBInfo(SrcBB).Index
783  << " --> " << getBBInfo(DestBB).Index << "\n");
784  unsigned SuccNum = GetSuccessorNumber(SrcBB, DestBB);
785  BasicBlock *InstrBB = SplitCriticalEdge(TI, SuccNum);
786  assert(InstrBB && "Critical edge is not split");
787 
788  E->Removed = true;
789  return InstrBB;
790 }
791 
792 // Visit all edge and instrument the edges not in MST, and do value profiling.
793 // Critical edges will be split.
794 static void instrumentOneFunc(
796  std::unordered_multimap<Comdat *, GlobalValue *> &ComdatMembers,
797  bool IsCS) {
798  // Split indirectbr critical edges here before computing the MST rather than
799  // later in getInstrBB() to avoid invalidating it.
800  SplitIndirectBrCriticalEdges(F, BPI, BFI);
801 
802  FuncPGOInstrumentation<PGOEdge, BBInfo> FuncInfo(F, ComdatMembers, true, BPI,
803  BFI, IsCS);
804  unsigned NumCounters = FuncInfo.getNumCounters();
805 
806  uint32_t I = 0;
807  Type *I8PtrTy = Type::getInt8PtrTy(M->getContext());
808  for (auto &E : FuncInfo.MST.AllEdges) {
809  BasicBlock *InstrBB = FuncInfo.getInstrBB(E.get());
810  if (!InstrBB)
811  continue;
812 
813  IRBuilder<> Builder(InstrBB, InstrBB->getFirstInsertionPt());
814  assert(Builder.GetInsertPoint() != InstrBB->end() &&
815  "Cannot get the Instrumentation point");
816  Builder.CreateCall(
817  Intrinsic::getDeclaration(M, Intrinsic::instrprof_increment),
818  {ConstantExpr::getBitCast(FuncInfo.FuncNameVar, I8PtrTy),
819  Builder.getInt64(FuncInfo.FunctionHash), Builder.getInt32(NumCounters),
820  Builder.getInt32(I++)});
821  }
822 
823  // Now instrument select instructions:
824  FuncInfo.SIVisitor.instrumentSelects(F, &I, NumCounters, FuncInfo.FuncNameVar,
825  FuncInfo.FunctionHash);
826  assert(I == NumCounters);
827 
829  return;
830 
831  unsigned NumIndirectCalls = 0;
832  for (auto &I : FuncInfo.ValueSites[IPVK_IndirectCallTarget]) {
833  CallSite CS(I);
834  Value *Callee = CS.getCalledValue();
835  LLVM_DEBUG(dbgs() << "Instrument one indirect call: CallSite Index = "
836  << NumIndirectCalls << "\n");
837  IRBuilder<> Builder(I);
838  assert(Builder.GetInsertPoint() != I->getParent()->end() &&
839  "Cannot get the Instrumentation point");
840  Builder.CreateCall(
841  Intrinsic::getDeclaration(M, Intrinsic::instrprof_value_profile),
842  {ConstantExpr::getBitCast(FuncInfo.FuncNameVar, I8PtrTy),
843  Builder.getInt64(FuncInfo.FunctionHash),
844  Builder.CreatePtrToInt(Callee, Builder.getInt64Ty()),
845  Builder.getInt32(IPVK_IndirectCallTarget),
846  Builder.getInt32(NumIndirectCalls++)});
847  }
848  NumOfPGOICall += NumIndirectCalls;
849 
850  // Now instrument memop intrinsic calls.
851  FuncInfo.MIVisitor.instrumentMemIntrinsics(
852  F, NumCounters, FuncInfo.FuncNameVar, FuncInfo.FunctionHash);
853 }
854 
855 namespace {
856 
857 // This class represents a CFG edge in profile use compilation.
858 struct PGOUseEdge : public PGOEdge {
859  bool CountValid = false;
860  uint64_t CountValue = 0;
861 
862  PGOUseEdge(const BasicBlock *Src, const BasicBlock *Dest, uint64_t W = 1)
863  : PGOEdge(Src, Dest, W) {}
864 
865  // Set edge count value
866  void setEdgeCount(uint64_t Value) {
867  CountValue = Value;
868  CountValid = true;
869  }
870 
871  // Return the information string for this object.
872  const std::string infoString() const {
873  if (!CountValid)
874  return PGOEdge::infoString();
875  return (Twine(PGOEdge::infoString()) + " Count=" + Twine(CountValue))
876  .str();
877  }
878 };
879 
880 using DirectEdges = SmallVector<PGOUseEdge *, 2>;
881 
882 // This class stores the auxiliary information for each BB.
883 struct UseBBInfo : public BBInfo {
884  uint64_t CountValue = 0;
885  bool CountValid;
886  int32_t UnknownCountInEdge = 0;
887  int32_t UnknownCountOutEdge = 0;
888  DirectEdges InEdges;
889  DirectEdges OutEdges;
890 
891  UseBBInfo(unsigned IX) : BBInfo(IX), CountValid(false) {}
892 
893  UseBBInfo(unsigned IX, uint64_t C)
894  : BBInfo(IX), CountValue(C), CountValid(true) {}
895 
896  // Set the profile count value for this BB.
897  void setBBInfoCount(uint64_t Value) {
898  CountValue = Value;
899  CountValid = true;
900  }
901 
902  // Return the information string of this object.
903  const std::string infoString() const {
904  if (!CountValid)
905  return BBInfo::infoString();
906  return (Twine(BBInfo::infoString()) + " Count=" + Twine(CountValue)).str();
907  }
908 };
909 
910 } // end anonymous namespace
911 
912 // Sum up the count values for all the edges.
913 static uint64_t sumEdgeCount(const ArrayRef<PGOUseEdge *> Edges) {
914  uint64_t Total = 0;
915  for (auto &E : Edges) {
916  if (E->Removed)
917  continue;
918  Total += E->CountValue;
919  }
920  return Total;
921 }
922 
923 namespace {
924 
925 class PGOUseFunc {
926 public:
927  PGOUseFunc(Function &Func, Module *Modu,
928  std::unordered_multimap<Comdat *, GlobalValue *> &ComdatMembers,
929  BranchProbabilityInfo *BPI = nullptr,
930  BlockFrequencyInfo *BFIin = nullptr, bool IsCS = false)
931  : F(Func), M(Modu), BFI(BFIin),
932  FuncInfo(Func, ComdatMembers, false, BPI, BFIin, IsCS),
933  FreqAttr(FFA_Normal), IsCS(IsCS) {}
934 
935  // Read counts for the instrumented BB from profile.
936  bool readCounters(IndexedInstrProfReader *PGOReader, bool &AllZeros);
937 
938  // Populate the counts for all BBs.
939  void populateCounters();
940 
941  // Set the branch weights based on the count values.
942  void setBranchWeights();
943 
944  // Annotate the value profile call sites for all value kind.
945  void annotateValueSites();
946 
947  // Annotate the value profile call sites for one value kind.
948  void annotateValueSites(uint32_t Kind);
949 
950  // Annotate the irreducible loop header weights.
951  void annotateIrrLoopHeaderWeights();
952 
953  // The hotness of the function from the profile count.
954  enum FuncFreqAttr { FFA_Normal, FFA_Cold, FFA_Hot };
955 
956  // Return the function hotness from the profile.
957  FuncFreqAttr getFuncFreqAttr() const { return FreqAttr; }
958 
959  // Return the function hash.
960  uint64_t getFuncHash() const { return FuncInfo.FunctionHash; }
961 
962  // Return the profile record for this function;
963  InstrProfRecord &getProfileRecord() { return ProfileRecord; }
964 
965  // Return the auxiliary BB information.
966  UseBBInfo &getBBInfo(const BasicBlock *BB) const {
967  return FuncInfo.getBBInfo(BB);
968  }
969 
970  // Return the auxiliary BB information if available.
971  UseBBInfo *findBBInfo(const BasicBlock *BB) const {
972  return FuncInfo.findBBInfo(BB);
973  }
974 
975  Function &getFunc() const { return F; }
976 
977  void dumpInfo(std::string Str = "") const {
978  FuncInfo.dumpInfo(Str);
979  }
980 
981  uint64_t getProgramMaxCount() const { return ProgramMaxCount; }
982 private:
983  Function &F;
984  Module *M;
986 
987  // This member stores the shared information with class PGOGenFunc.
988  FuncPGOInstrumentation<PGOUseEdge, UseBBInfo> FuncInfo;
989 
990  // The maximum count value in the profile. This is only used in PGO use
991  // compilation.
992  uint64_t ProgramMaxCount;
993 
994  // Position of counter that remains to be read.
995  uint32_t CountPosition = 0;
996 
997  // Total size of the profile count for this function.
998  uint32_t ProfileCountSize = 0;
999 
1000  // ProfileRecord for this function.
1001  InstrProfRecord ProfileRecord;
1002 
1003  // Function hotness info derived from profile.
1004  FuncFreqAttr FreqAttr;
1005 
1006  // Is to use the context sensitive profile.
1007  bool IsCS;
1008 
1009  // Find the Instrumented BB and set the value.
1010  void setInstrumentedCounts(const std::vector<uint64_t> &CountFromProfile);
1011 
1012  // Set the edge counter value for the unknown edge -- there should be only
1013  // one unknown edge.
1014  void setEdgeCount(DirectEdges &Edges, uint64_t Value);
1015 
1016  // Return FuncName string;
1017  const std::string getFuncName() const { return FuncInfo.FuncName; }
1018 
1019  // Set the hot/cold inline hints based on the count values.
1020  // FIXME: This function should be removed once the functionality in
1021  // the inliner is implemented.
1022  void markFunctionAttributes(uint64_t EntryCount, uint64_t MaxCount) {
1023  if (ProgramMaxCount == 0)
1024  return;
1025  // Threshold of the hot functions.
1026  const BranchProbability HotFunctionThreshold(1, 100);
1027  // Threshold of the cold functions.
1028  const BranchProbability ColdFunctionThreshold(2, 10000);
1029  if (EntryCount >= HotFunctionThreshold.scale(ProgramMaxCount))
1030  FreqAttr = FFA_Hot;
1031  else if (MaxCount <= ColdFunctionThreshold.scale(ProgramMaxCount))
1032  FreqAttr = FFA_Cold;
1033  }
1034 };
1035 
1036 } // end anonymous namespace
1037 
1038 // Visit all the edges and assign the count value for the instrumented
1039 // edges and the BB.
1040 void PGOUseFunc::setInstrumentedCounts(
1041  const std::vector<uint64_t> &CountFromProfile) {
1042  assert(FuncInfo.getNumCounters() == CountFromProfile.size());
1043  // Use a worklist as we will update the vector during the iteration.
1044  std::vector<PGOUseEdge *> WorkList;
1045  for (auto &E : FuncInfo.MST.AllEdges)
1046  WorkList.push_back(E.get());
1047 
1048  uint32_t I = 0;
1049  for (auto &E : WorkList) {
1050  BasicBlock *InstrBB = FuncInfo.getInstrBB(E);
1051  if (!InstrBB)
1052  continue;
1053  uint64_t CountValue = CountFromProfile[I++];
1054  if (!E->Removed) {
1055  getBBInfo(InstrBB).setBBInfoCount(CountValue);
1056  E->setEdgeCount(CountValue);
1057  continue;
1058  }
1059 
1060  // Need to add two new edges.
1061  BasicBlock *SrcBB = const_cast<BasicBlock *>(E->SrcBB);
1062  BasicBlock *DestBB = const_cast<BasicBlock *>(E->DestBB);
1063  // Add new edge of SrcBB->InstrBB.
1064  PGOUseEdge &NewEdge = FuncInfo.MST.addEdge(SrcBB, InstrBB, 0);
1065  NewEdge.setEdgeCount(CountValue);
1066  // Add new edge of InstrBB->DestBB.
1067  PGOUseEdge &NewEdge1 = FuncInfo.MST.addEdge(InstrBB, DestBB, 0);
1068  NewEdge1.setEdgeCount(CountValue);
1069  NewEdge1.InMST = true;
1070  getBBInfo(InstrBB).setBBInfoCount(CountValue);
1071  }
1072  ProfileCountSize = CountFromProfile.size();
1073  CountPosition = I;
1074 }
1075 
1076 // Set the count value for the unknown edge. There should be one and only one
1077 // unknown edge in Edges vector.
1078 void PGOUseFunc::setEdgeCount(DirectEdges &Edges, uint64_t Value) {
1079  for (auto &E : Edges) {
1080  if (E->CountValid)
1081  continue;
1082  E->setEdgeCount(Value);
1083 
1084  getBBInfo(E->SrcBB).UnknownCountOutEdge--;
1085  getBBInfo(E->DestBB).UnknownCountInEdge--;
1086  return;
1087  }
1088  llvm_unreachable("Cannot find the unknown count edge");
1089 }
1090 
1091 // Read the profile from ProfileFileName and assign the value to the
1092 // instrumented BB and the edges. This function also updates ProgramMaxCount.
1093 // Return true if the profile are successfully read, and false on errors.
1094 bool PGOUseFunc::readCounters(IndexedInstrProfReader *PGOReader, bool &AllZeros) {
1095  auto &Ctx = M->getContext();
1096  Expected<InstrProfRecord> Result =
1097  PGOReader->getInstrProfRecord(FuncInfo.FuncName, FuncInfo.FunctionHash);
1098  if (Error E = Result.takeError()) {
1099  handleAllErrors(std::move(E), [&](const InstrProfError &IPE) {
1100  auto Err = IPE.get();
1101  bool SkipWarning = false;
1102  LLVM_DEBUG(dbgs() << "Error in reading profile for Func "
1103  << FuncInfo.FuncName << ": ");
1104  if (Err == instrprof_error::unknown_function) {
1105  IsCS ? NumOfCSPGOMissing++ : NumOfPGOMissing++;
1106  SkipWarning = !PGOWarnMissing;
1107  LLVM_DEBUG(dbgs() << "unknown function");
1108  } else if (Err == instrprof_error::hash_mismatch ||
1109  Err == instrprof_error::malformed) {
1110  IsCS ? NumOfCSPGOMismatch++ : NumOfPGOMismatch++;
1111  SkipWarning =
1114  (F.hasComdat() ||
1115  F.getLinkage() == GlobalValue::AvailableExternallyLinkage));
1116  LLVM_DEBUG(dbgs() << "hash mismatch (skip=" << SkipWarning << ")");
1117  }
1118 
1119  LLVM_DEBUG(dbgs() << " IsCS=" << IsCS << "\n");
1120  if (SkipWarning)
1121  return;
1122 
1123  std::string Msg = IPE.message() + std::string(" ") + F.getName().str() +
1124  std::string(" Hash = ") +
1125  std::to_string(FuncInfo.FunctionHash);
1126 
1127  Ctx.diagnose(
1128  DiagnosticInfoPGOProfile(M->getName().data(), Msg, DS_Warning));
1129  });
1130  return false;
1131  }
1132  ProfileRecord = std::move(Result.get());
1133  std::vector<uint64_t> &CountFromProfile = ProfileRecord.Counts;
1134 
1135  IsCS ? NumOfCSPGOFunc++ : NumOfPGOFunc++;
1136  LLVM_DEBUG(dbgs() << CountFromProfile.size() << " counts\n");
1137  uint64_t ValueSum = 0;
1138  for (unsigned I = 0, S = CountFromProfile.size(); I < S; I++) {
1139  LLVM_DEBUG(dbgs() << " " << I << ": " << CountFromProfile[I] << "\n");
1140  ValueSum += CountFromProfile[I];
1141  }
1142  AllZeros = (ValueSum == 0);
1143 
1144  LLVM_DEBUG(dbgs() << "SUM = " << ValueSum << "\n");
1145 
1146  getBBInfo(nullptr).UnknownCountOutEdge = 2;
1147  getBBInfo(nullptr).UnknownCountInEdge = 2;
1148 
1149  setInstrumentedCounts(CountFromProfile);
1150  ProgramMaxCount = PGOReader->getMaximumFunctionCount(IsCS);
1151  return true;
1152 }
1153 
1154 // Populate the counters from instrumented BBs to all BBs.
1155 // In the end of this operation, all BBs should have a valid count value.
1156 void PGOUseFunc::populateCounters() {
1157  // First set up Count variable for all BBs.
1158  for (auto &E : FuncInfo.MST.AllEdges) {
1159  if (E->Removed)
1160  continue;
1161 
1162  const BasicBlock *SrcBB = E->SrcBB;
1163  const BasicBlock *DestBB = E->DestBB;
1164  UseBBInfo &SrcInfo = getBBInfo(SrcBB);
1165  UseBBInfo &DestInfo = getBBInfo(DestBB);
1166  SrcInfo.OutEdges.push_back(E.get());
1167  DestInfo.InEdges.push_back(E.get());
1168  SrcInfo.UnknownCountOutEdge++;
1169  DestInfo.UnknownCountInEdge++;
1170 
1171  if (!E->CountValid)
1172  continue;
1173  DestInfo.UnknownCountInEdge--;
1174  SrcInfo.UnknownCountOutEdge--;
1175  }
1176 
1177  bool Changes = true;
1178  unsigned NumPasses = 0;
1179  while (Changes) {
1180  NumPasses++;
1181  Changes = false;
1182 
1183  // For efficient traversal, it's better to start from the end as most
1184  // of the instrumented edges are at the end.
1185  for (auto &BB : reverse(F)) {
1186  UseBBInfo *Count = findBBInfo(&BB);
1187  if (Count == nullptr)
1188  continue;
1189  if (!Count->CountValid) {
1190  if (Count->UnknownCountOutEdge == 0) {
1191  Count->CountValue = sumEdgeCount(Count->OutEdges);
1192  Count->CountValid = true;
1193  Changes = true;
1194  } else if (Count->UnknownCountInEdge == 0) {
1195  Count->CountValue = sumEdgeCount(Count->InEdges);
1196  Count->CountValid = true;
1197  Changes = true;
1198  }
1199  }
1200  if (Count->CountValid) {
1201  if (Count->UnknownCountOutEdge == 1) {
1202  uint64_t Total = 0;
1203  uint64_t OutSum = sumEdgeCount(Count->OutEdges);
1204  // If the one of the successor block can early terminate (no-return),
1205  // we can end up with situation where out edge sum count is larger as
1206  // the source BB's count is collected by a post-dominated block.
1207  if (Count->CountValue > OutSum)
1208  Total = Count->CountValue - OutSum;
1209  setEdgeCount(Count->OutEdges, Total);
1210  Changes = true;
1211  }
1212  if (Count->UnknownCountInEdge == 1) {
1213  uint64_t Total = 0;
1214  uint64_t InSum = sumEdgeCount(Count->InEdges);
1215  if (Count->CountValue > InSum)
1216  Total = Count->CountValue - InSum;
1217  setEdgeCount(Count->InEdges, Total);
1218  Changes = true;
1219  }
1220  }
1221  }
1222  }
1223 
1224  LLVM_DEBUG(dbgs() << "Populate counts in " << NumPasses << " passes.\n");
1225 #ifndef NDEBUG
1226  // Assert every BB has a valid counter.
1227  for (auto &BB : F) {
1228  auto BI = findBBInfo(&BB);
1229  if (BI == nullptr)
1230  continue;
1231  assert(BI->CountValid && "BB count is not valid");
1232  }
1233 #endif
1234  uint64_t FuncEntryCount = getBBInfo(&*F.begin()).CountValue;
1235  F.setEntryCount(ProfileCount(FuncEntryCount, Function::PCT_Real));
1236  uint64_t FuncMaxCount = FuncEntryCount;
1237  for (auto &BB : F) {
1238  auto BI = findBBInfo(&BB);
1239  if (BI == nullptr)
1240  continue;
1241  FuncMaxCount = std::max(FuncMaxCount, BI->CountValue);
1242  }
1243  markFunctionAttributes(FuncEntryCount, FuncMaxCount);
1244 
1245  // Now annotate select instructions
1246  FuncInfo.SIVisitor.annotateSelects(F, this, &CountPosition);
1247  assert(CountPosition == ProfileCountSize);
1248 
1249  LLVM_DEBUG(FuncInfo.dumpInfo("after reading profile."));
1250 }
1251 
1252 // Assign the scaled count values to the BB with multiple out edges.
1254  // Generate MD_prof metadata for every branch instruction.
1255  LLVM_DEBUG(dbgs() << "\nSetting branch weights for func " << F.getName()
1256  << " IsCS=" << IsCS << "\n");
1257  for (auto &BB : F) {
1258  Instruction *TI = BB.getTerminator();
1259  if (TI->getNumSuccessors() < 2)
1260  continue;
1261  if (!(isa<BranchInst>(TI) || isa<SwitchInst>(TI) ||
1262  isa<IndirectBrInst>(TI)))
1263  continue;
1264 
1265  if (getBBInfo(&BB).CountValue == 0)
1266  continue;
1267 
1268  // We have a non-zero Branch BB.
1269  const UseBBInfo &BBCountInfo = getBBInfo(&BB);
1270  unsigned Size = BBCountInfo.OutEdges.size();
1271  SmallVector<uint64_t, 2> EdgeCounts(Size, 0);
1272  uint64_t MaxCount = 0;
1273  for (unsigned s = 0; s < Size; s++) {
1274  const PGOUseEdge *E = BBCountInfo.OutEdges[s];
1275  const BasicBlock *SrcBB = E->SrcBB;
1276  const BasicBlock *DestBB = E->DestBB;
1277  if (DestBB == nullptr)
1278  continue;
1279  unsigned SuccNum = GetSuccessorNumber(SrcBB, DestBB);
1280  uint64_t EdgeCount = E->CountValue;
1281  if (EdgeCount > MaxCount)
1282  MaxCount = EdgeCount;
1283  EdgeCounts[SuccNum] = EdgeCount;
1284  }
1285  setProfMetadata(M, TI, EdgeCounts, MaxCount);
1286  }
1287 }
1288 
1289 static bool isIndirectBrTarget(BasicBlock *BB) {
1290  for (pred_iterator PI = pred_begin(BB), E = pred_end(BB); PI != E; ++PI) {
1291  if (isa<IndirectBrInst>((*PI)->getTerminator()))
1292  return true;
1293  }
1294  return false;
1295 }
1296 
1297 void PGOUseFunc::annotateIrrLoopHeaderWeights() {
1298  LLVM_DEBUG(dbgs() << "\nAnnotating irreducible loop header weights.\n");
1299  // Find irr loop headers
1300  for (auto &BB : F) {
1301  // As a heuristic also annotate indrectbr targets as they have a high chance
1302  // to become an irreducible loop header after the indirectbr tail
1303  // duplication.
1304  if (BFI->isIrrLoopHeader(&BB) || isIndirectBrTarget(&BB)) {
1305  Instruction *TI = BB.getTerminator();
1306  const UseBBInfo &BBCountInfo = getBBInfo(&BB);
1307  setIrrLoopHeaderMetadata(M, TI, BBCountInfo.CountValue);
1308  }
1309  }
1310 }
1311 
1312 void SelectInstVisitor::instrumentOneSelectInst(SelectInst &SI) {
1313  Module *M = F.getParent();
1314  IRBuilder<> Builder(&SI);
1315  Type *Int64Ty = Builder.getInt64Ty();
1316  Type *I8PtrTy = Builder.getInt8PtrTy();
1317  auto *Step = Builder.CreateZExt(SI.getCondition(), Int64Ty);
1318  Builder.CreateCall(
1319  Intrinsic::getDeclaration(M, Intrinsic::instrprof_increment_step),
1320  {ConstantExpr::getBitCast(FuncNameVar, I8PtrTy),
1321  Builder.getInt64(FuncHash), Builder.getInt32(TotalNumCtrs),
1322  Builder.getInt32(*CurCtrIdx), Step});
1323  ++(*CurCtrIdx);
1324 }
1325 
1326 void SelectInstVisitor::annotateOneSelectInst(SelectInst &SI) {
1327  std::vector<uint64_t> &CountFromProfile = UseFunc->getProfileRecord().Counts;
1328  assert(*CurCtrIdx < CountFromProfile.size() &&
1329  "Out of bound access of counters");
1330  uint64_t SCounts[2];
1331  SCounts[0] = CountFromProfile[*CurCtrIdx]; // True count
1332  ++(*CurCtrIdx);
1333  uint64_t TotalCount = 0;
1334  auto BI = UseFunc->findBBInfo(SI.getParent());
1335  if (BI != nullptr)
1336  TotalCount = BI->CountValue;
1337  // False Count
1338  SCounts[1] = (TotalCount > SCounts[0] ? TotalCount - SCounts[0] : 0);
1339  uint64_t MaxCount = std::max(SCounts[0], SCounts[1]);
1340  if (MaxCount)
1341  setProfMetadata(F.getParent(), &SI, SCounts, MaxCount);
1342 }
1343 
1344 void SelectInstVisitor::visitSelectInst(SelectInst &SI) {
1345  if (!PGOInstrSelect)
1346  return;
1347  // FIXME: do not handle this yet.
1348  if (SI.getCondition()->getType()->isVectorTy())
1349  return;
1350 
1351  switch (Mode) {
1352  case VM_counting:
1353  NSIs++;
1354  return;
1355  case VM_instrument:
1356  instrumentOneSelectInst(SI);
1357  return;
1358  case VM_annotate:
1359  annotateOneSelectInst(SI);
1360  return;
1361  }
1362 
1363  llvm_unreachable("Unknown visiting mode");
1364 }
1365 
1366 void MemIntrinsicVisitor::instrumentOneMemIntrinsic(MemIntrinsic &MI) {
1367  Module *M = F.getParent();
1368  IRBuilder<> Builder(&MI);
1369  Type *Int64Ty = Builder.getInt64Ty();
1370  Type *I8PtrTy = Builder.getInt8PtrTy();
1371  Value *Length = MI.getLength();
1372  assert(!dyn_cast<ConstantInt>(Length));
1373  Builder.CreateCall(
1374  Intrinsic::getDeclaration(M, Intrinsic::instrprof_value_profile),
1375  {ConstantExpr::getBitCast(FuncNameVar, I8PtrTy),
1376  Builder.getInt64(FuncHash), Builder.CreateZExtOrTrunc(Length, Int64Ty),
1377  Builder.getInt32(IPVK_MemOPSize), Builder.getInt32(CurCtrId)});
1378  ++CurCtrId;
1379 }
1380 
1381 void MemIntrinsicVisitor::visitMemIntrinsic(MemIntrinsic &MI) {
1382  if (!PGOInstrMemOP)
1383  return;
1384  Value *Length = MI.getLength();
1385  // Not instrument constant length calls.
1386  if (dyn_cast<ConstantInt>(Length))
1387  return;
1388 
1389  switch (Mode) {
1390  case VM_counting:
1391  NMemIs++;
1392  return;
1393  case VM_instrument:
1394  instrumentOneMemIntrinsic(MI);
1395  return;
1396  case VM_annotate:
1397  Candidates.push_back(&MI);
1398  return;
1399  }
1400  llvm_unreachable("Unknown visiting mode");
1401 }
1402 
1403 // Traverse all valuesites and annotate the instructions for all value kind.
1404 void PGOUseFunc::annotateValueSites() {
1406  return;
1407 
1408  // Create the PGOFuncName meta data.
1409  createPGOFuncNameMetadata(F, FuncInfo.FuncName);
1410 
1411  for (uint32_t Kind = IPVK_First; Kind <= IPVK_Last; ++Kind)
1412  annotateValueSites(Kind);
1413 }
1414 
1415 // Annotate the instructions for a specific value kind.
1416 void PGOUseFunc::annotateValueSites(uint32_t Kind) {
1417  unsigned ValueSiteIndex = 0;
1418  auto &ValueSites = FuncInfo.ValueSites[Kind];
1419  unsigned NumValueSites = ProfileRecord.getNumValueSites(Kind);
1420  if (NumValueSites != ValueSites.size()) {
1421  auto &Ctx = M->getContext();
1422  Ctx.diagnose(DiagnosticInfoPGOProfile(
1423  M->getName().data(),
1424  Twine("Inconsistent number of value sites for kind = ") + Twine(Kind) +
1425  " in " + F.getName().str(),
1426  DS_Warning));
1427  return;
1428  }
1429 
1430  for (auto &I : ValueSites) {
1431  LLVM_DEBUG(dbgs() << "Read one value site profile (kind = " << Kind
1432  << "): Index = " << ValueSiteIndex << " out of "
1433  << NumValueSites << "\n");
1434  annotateValueSite(*M, *I, ProfileRecord,
1435  static_cast<InstrProfValueKind>(Kind), ValueSiteIndex,
1436  Kind == IPVK_MemOPSize ? MaxNumMemOPAnnotations
1437  : MaxNumAnnotations);
1438  ValueSiteIndex++;
1439  }
1440 }
1441 
1442 // Collect the set of members for each Comdat in module M and store
1443 // in ComdatMembers.
1445  Module &M,
1446  std::unordered_multimap<Comdat *, GlobalValue *> &ComdatMembers) {
1447  if (!DoComdatRenaming)
1448  return;
1449  for (Function &F : M)
1450  if (Comdat *C = F.getComdat())
1451  ComdatMembers.insert(std::make_pair(C, &F));
1452  for (GlobalVariable &GV : M.globals())
1453  if (Comdat *C = GV.getComdat())
1454  ComdatMembers.insert(std::make_pair(C, &GV));
1455  for (GlobalAlias &GA : M.aliases())
1456  if (Comdat *C = GA.getComdat())
1457  ComdatMembers.insert(std::make_pair(C, &GA));
1458 }
1459 
1461  Module &M, function_ref<BranchProbabilityInfo *(Function &)> LookupBPI,
1462  function_ref<BlockFrequencyInfo *(Function &)> LookupBFI, bool IsCS) {
1463  // For the context-sensitve instrumentation, we should have a separated pass
1464  // (before LTO/ThinLTO linking) to create these variables.
1465  if (!IsCS)
1466  createIRLevelProfileFlagVar(M, /* IsCS */ false);
1467  std::unordered_multimap<Comdat *, GlobalValue *> ComdatMembers;
1468  collectComdatMembers(M, ComdatMembers);
1469 
1470  for (auto &F : M) {
1471  if (F.isDeclaration())
1472  continue;
1473  auto *BPI = LookupBPI(F);
1474  auto *BFI = LookupBFI(F);
1475  instrumentOneFunc(F, &M, BPI, BFI, ComdatMembers, IsCS);
1476  }
1477  return true;
1478 }
1479 
1482  createProfileFileNameVar(M, CSInstrName);
1483  createIRLevelProfileFlagVar(M, /* IsCS */ true);
1484  return PreservedAnalyses::all();
1485 }
1486 
1487 bool PGOInstrumentationGenLegacyPass::runOnModule(Module &M) {
1488  if (skipModule(M))
1489  return false;
1490 
1491  auto LookupBPI = [this](Function &F) {
1492  return &this->getAnalysis<BranchProbabilityInfoWrapperPass>(F).getBPI();
1493  };
1494  auto LookupBFI = [this](Function &F) {
1495  return &this->getAnalysis<BlockFrequencyInfoWrapperPass>(F).getBFI();
1496  };
1497  return InstrumentAllFunctions(M, LookupBPI, LookupBFI, IsCS);
1498 }
1499 
1501  ModuleAnalysisManager &AM) {
1502  auto &FAM = AM.getResult<FunctionAnalysisManagerModuleProxy>(M).getManager();
1503  auto LookupBPI = [&FAM](Function &F) {
1504  return &FAM.getResult<BranchProbabilityAnalysis>(F);
1505  };
1506 
1507  auto LookupBFI = [&FAM](Function &F) {
1508  return &FAM.getResult<BlockFrequencyAnalysis>(F);
1509  };
1510 
1511  if (!InstrumentAllFunctions(M, LookupBPI, LookupBFI, IsCS))
1512  return PreservedAnalyses::all();
1513 
1514  return PreservedAnalyses::none();
1515 }
1516 
1518  Module &M, StringRef ProfileFileName, StringRef ProfileRemappingFileName,
1520  function_ref<BlockFrequencyInfo *(Function &)> LookupBFI, bool IsCS) {
1521  LLVM_DEBUG(dbgs() << "Read in profile counters: ");
1522  auto &Ctx = M.getContext();
1523  // Read the counter array from file.
1524  auto ReaderOrErr =
1525  IndexedInstrProfReader::create(ProfileFileName, ProfileRemappingFileName);
1526  if (Error E = ReaderOrErr.takeError()) {
1527  handleAllErrors(std::move(E), [&](const ErrorInfoBase &EI) {
1528  Ctx.diagnose(
1529  DiagnosticInfoPGOProfile(ProfileFileName.data(), EI.message()));
1530  });
1531  return false;
1532  }
1533 
1534  std::unique_ptr<IndexedInstrProfReader> PGOReader =
1535  std::move(ReaderOrErr.get());
1536  if (!PGOReader) {
1537  Ctx.diagnose(DiagnosticInfoPGOProfile(ProfileFileName.data(),
1538  StringRef("Cannot get PGOReader")));
1539  return false;
1540  }
1541  if (!PGOReader->hasCSIRLevelProfile() && IsCS)
1542  return false;
1543 
1544  // TODO: might need to change the warning once the clang option is finalized.
1545  if (!PGOReader->isIRLevelProfile()) {
1546  Ctx.diagnose(DiagnosticInfoPGOProfile(
1547  ProfileFileName.data(), "Not an IR level instrumentation profile"));
1548  return false;
1549  }
1550 
1551  std::unordered_multimap<Comdat *, GlobalValue *> ComdatMembers;
1552  collectComdatMembers(M, ComdatMembers);
1553  std::vector<Function *> HotFunctions;
1554  std::vector<Function *> ColdFunctions;
1555  for (auto &F : M) {
1556  if (F.isDeclaration())
1557  continue;
1558  auto *BPI = LookupBPI(F);
1559  auto *BFI = LookupBFI(F);
1560  // Split indirectbr critical edges here before computing the MST rather than
1561  // later in getInstrBB() to avoid invalidating it.
1563  PGOUseFunc Func(F, &M, ComdatMembers, BPI, BFI, IsCS);
1564  bool AllZeros = false;
1565  if (!Func.readCounters(PGOReader.get(), AllZeros))
1566  continue;
1567  if (AllZeros) {
1568  F.setEntryCount(ProfileCount(0, Function::PCT_Real));
1569  if (Func.getProgramMaxCount() != 0)
1570  ColdFunctions.push_back(&F);
1571  continue;
1572  }
1573  Func.populateCounters();
1574  Func.setBranchWeights();
1575  Func.annotateValueSites();
1576  Func.annotateIrrLoopHeaderWeights();
1577  PGOUseFunc::FuncFreqAttr FreqAttr = Func.getFuncFreqAttr();
1578  if (FreqAttr == PGOUseFunc::FFA_Cold)
1579  ColdFunctions.push_back(&F);
1580  else if (FreqAttr == PGOUseFunc::FFA_Hot)
1581  HotFunctions.push_back(&F);
1582  if (PGOViewCounts != PGOVCT_None &&
1583  (ViewBlockFreqFuncName.empty() ||
1584  F.getName().equals(ViewBlockFreqFuncName))) {
1585  LoopInfo LI{DominatorTree(F)};
1586  std::unique_ptr<BranchProbabilityInfo> NewBPI =
1587  llvm::make_unique<BranchProbabilityInfo>(F, LI);
1588  std::unique_ptr<BlockFrequencyInfo> NewBFI =
1589  llvm::make_unique<BlockFrequencyInfo>(F, *NewBPI, LI);
1590  if (PGOViewCounts == PGOVCT_Graph)
1591  NewBFI->view();
1592  else if (PGOViewCounts == PGOVCT_Text) {
1593  dbgs() << "pgo-view-counts: " << Func.getFunc().getName() << "\n";
1594  NewBFI->print(dbgs());
1595  }
1596  }
1597  if (PGOViewRawCounts != PGOVCT_None &&
1598  (ViewBlockFreqFuncName.empty() ||
1599  F.getName().equals(ViewBlockFreqFuncName))) {
1601  if (ViewBlockFreqFuncName.empty())
1602  WriteGraph(&Func, Twine("PGORawCounts_") + Func.getFunc().getName());
1603  else
1604  ViewGraph(&Func, Twine("PGORawCounts_") + Func.getFunc().getName());
1605  else if (PGOViewRawCounts == PGOVCT_Text) {
1606  dbgs() << "pgo-view-raw-counts: " << Func.getFunc().getName() << "\n";
1607  Func.dumpInfo();
1608  }
1609  }
1610  }
1611  M.setProfileSummary(PGOReader->getSummary(IsCS).getMD(M.getContext()),
1614 
1615  // Set function hotness attribute from the profile.
1616  // We have to apply these attributes at the end because their presence
1617  // can affect the BranchProbabilityInfo of any callers, resulting in an
1618  // inconsistent MST between prof-gen and prof-use.
1619  for (auto &F : HotFunctions) {
1620  F->addFnAttr(Attribute::InlineHint);
1621  LLVM_DEBUG(dbgs() << "Set inline attribute to function: " << F->getName()
1622  << "\n");
1623  }
1624  for (auto &F : ColdFunctions) {
1625  F->addFnAttr(Attribute::Cold);
1626  LLVM_DEBUG(dbgs() << "Set cold attribute to function: " << F->getName()
1627  << "\n");
1628  }
1629  return true;
1630 }
1631 
1633  std::string RemappingFilename,
1634  bool IsCS)
1635  : ProfileFileName(std::move(Filename)),
1636  ProfileRemappingFileName(std::move(RemappingFilename)), IsCS(IsCS) {
1637  if (!PGOTestProfileFile.empty())
1638  ProfileFileName = PGOTestProfileFile;
1639  if (!PGOTestProfileRemappingFile.empty())
1640  ProfileRemappingFileName = PGOTestProfileRemappingFile;
1641 }
1642 
1644  ModuleAnalysisManager &AM) {
1645 
1646  auto &FAM = AM.getResult<FunctionAnalysisManagerModuleProxy>(M).getManager();
1647  auto LookupBPI = [&FAM](Function &F) {
1648  return &FAM.getResult<BranchProbabilityAnalysis>(F);
1649  };
1650 
1651  auto LookupBFI = [&FAM](Function &F) {
1652  return &FAM.getResult<BlockFrequencyAnalysis>(F);
1653  };
1654 
1655  if (!annotateAllFunctions(M, ProfileFileName, ProfileRemappingFileName,
1656  LookupBPI, LookupBFI, IsCS))
1657  return PreservedAnalyses::all();
1658 
1659  return PreservedAnalyses::none();
1660 }
1661 
1662 bool PGOInstrumentationUseLegacyPass::runOnModule(Module &M) {
1663  if (skipModule(M))
1664  return false;
1665 
1666  auto LookupBPI = [this](Function &F) {
1667  return &this->getAnalysis<BranchProbabilityInfoWrapperPass>(F).getBPI();
1668  };
1669  auto LookupBFI = [this](Function &F) {
1670  return &this->getAnalysis<BlockFrequencyInfoWrapperPass>(F).getBFI();
1671  };
1672 
1673  return annotateAllFunctions(M, ProfileFileName, "", LookupBPI, LookupBFI,
1674  IsCS);
1675 }
1676 
1677 static std::string getSimpleNodeName(const BasicBlock *Node) {
1678  if (!Node->getName().empty())
1679  return Node->getName();
1680 
1681  std::string SimpleNodeName;
1682  raw_string_ostream OS(SimpleNodeName);
1683  Node->printAsOperand(OS, false);
1684  return OS.str();
1685 }
1686 
1688  ArrayRef<uint64_t> EdgeCounts,
1689  uint64_t MaxCount) {
1690  MDBuilder MDB(M->getContext());
1691  assert(MaxCount > 0 && "Bad max count");
1692  uint64_t Scale = calculateCountScale(MaxCount);
1693  SmallVector<unsigned, 4> Weights;
1694  for (const auto &ECI : EdgeCounts)
1695  Weights.push_back(scaleBranchCount(ECI, Scale));
1696 
1697  LLVM_DEBUG(dbgs() << "Weight is: "; for (const auto &W
1698  : Weights) {
1699  dbgs() << W << " ";
1700  } dbgs() << "\n";);
1701  TI->setMetadata(LLVMContext::MD_prof, MDB.createBranchWeights(Weights));
1702  if (EmitBranchProbability) {
1703  std::string BrCondStr = getBranchCondString(TI);
1704  if (BrCondStr.empty())
1705  return;
1706 
1707  uint64_t WSum =
1708  std::accumulate(Weights.begin(), Weights.end(), (uint64_t)0,
1709  [](uint64_t w1, uint64_t w2) { return w1 + w2; });
1710  uint64_t TotalCount =
1711  std::accumulate(EdgeCounts.begin(), EdgeCounts.end(), (uint64_t)0,
1712  [](uint64_t c1, uint64_t c2) { return c1 + c2; });
1713  Scale = calculateCountScale(WSum);
1714  BranchProbability BP(scaleBranchCount(Weights[0], Scale),
1715  scaleBranchCount(WSum, Scale));
1716  std::string BranchProbStr;
1717  raw_string_ostream OS(BranchProbStr);
1718  OS << BP;
1719  OS << " (total count : " << TotalCount << ")";
1720  OS.flush();
1721  Function *F = TI->getParent()->getParent();
1723  ORE.emit([&]() {
1724  return OptimizationRemark(DEBUG_TYPE, "pgo-instrumentation", TI)
1725  << BrCondStr << " is true with probability : " << BranchProbStr;
1726  });
1727  }
1728 }
1729 
1730 namespace llvm {
1731 
1732 void setIrrLoopHeaderMetadata(Module *M, Instruction *TI, uint64_t Count) {
1733  MDBuilder MDB(M->getContext());
1735  MDB.createIrrLoopHeaderWeight(Count));
1736 }
1737 
1738 template <> struct GraphTraits<PGOUseFunc *> {
1739  using NodeRef = const BasicBlock *;
1742 
1743  static NodeRef getEntryNode(const PGOUseFunc *G) {
1744  return &G->getFunc().front();
1745  }
1746 
1748  return succ_begin(N);
1749  }
1750 
1751  static ChildIteratorType child_end(const NodeRef N) { return succ_end(N); }
1752 
1753  static nodes_iterator nodes_begin(const PGOUseFunc *G) {
1754  return nodes_iterator(G->getFunc().begin());
1755  }
1756 
1757  static nodes_iterator nodes_end(const PGOUseFunc *G) {
1758  return nodes_iterator(G->getFunc().end());
1759  }
1760 };
1761 
1762 template <> struct DOTGraphTraits<PGOUseFunc *> : DefaultDOTGraphTraits {
1763  explicit DOTGraphTraits(bool isSimple = false)
1765 
1766  static std::string getGraphName(const PGOUseFunc *G) {
1767  return G->getFunc().getName();
1768  }
1769 
1770  std::string getNodeLabel(const BasicBlock *Node, const PGOUseFunc *Graph) {
1771  std::string Result;
1772  raw_string_ostream OS(Result);
1773 
1774  OS << getSimpleNodeName(Node) << ":\\l";
1775  UseBBInfo *BI = Graph->findBBInfo(Node);
1776  OS << "Count : ";
1777  if (BI && BI->CountValid)
1778  OS << BI->CountValue << "\\l";
1779  else
1780  OS << "Unknown\\l";
1781 
1782  if (!PGOInstrSelect)
1783  return Result;
1784 
1785  for (auto BI = Node->begin(); BI != Node->end(); ++BI) {
1786  auto *I = &*BI;
1787  if (!isa<SelectInst>(I))
1788  continue;
1789  // Display scaled counts for SELECT instruction:
1790  OS << "SELECT : { T = ";
1791  uint64_t TC, FC;
1792  bool HasProf = I->extractProfMetadata(TC, FC);
1793  if (!HasProf)
1794  OS << "Unknown, F = Unknown }\\l";
1795  else
1796  OS << TC << ", F = " << FC << " }\\l";
1797  }
1798  return Result;
1799  }
1800 };
1801 
1802 } // end namespace llvm
ModulePass * createPGOInstrumentationGenLegacyPass(bool IsCS=false)
uint64_t CallInst * C
static uint64_t sumEdgeCount(const ArrayRef< PGOUseEdge *> Edges)
uint32_t getCRC() const
Definition: JamCRC.h:41
void setProfMetadata(Module *M, Instruction *TI, ArrayRef< uint64_t > EdgeCounts, uint64_t MaxCount)
static cl::opt< bool > NoPGOWarnMismatch("no-pgo-warn-mismatch", cl::init(false), cl::Hidden, cl::desc("Use this option to turn off/on " "warnings about profile cfg mismatch."))
static PassRegistry * getPassRegistry()
getPassRegistry - Access the global registry object, which is automatically initialized at applicatio...
GCNRegPressure max(const GCNRegPressure &P1, const GCNRegPressure &P2)
Base class for instruction visitors.
Definition: InstVisitor.h:80
SI Whole Quad Mode
Value * CreateZExtOrTrunc(Value *V, Type *DestTy, const Twine &Name="")
Create a ZExt or Trunc from the integer value V to DestTy.
Definition: IRBuilder.h:1704
PassT::Result & getResult(IRUnitT &IR, ExtraArgTs... ExtraArgs)
Get the result of an analysis pass for a given IR unit.
Definition: PassManager.h:769
This class represents lattice values for constants.
Definition: AllocatorList.h:23
static cl::opt< bool > PGOWarnMissing("pgo-warn-missing-function", cl::init(false), cl::Hidden, cl::desc("Use this option to turn on/off " "warnings about missing profile data for " "functions."))
A Module instance is used to store all the information related to an LLVM module. ...
Definition: Module.h:65
BasicBlock * getSuccessor(unsigned Idx) const
Return the specified successor. This instruction must be a terminator.
static ChildIteratorType child_begin(const NodeRef N)
std::vector< std::unique_ptr< Edge > > AllEdges
Definition: CFGMST.h:43
Diagnostic information for the PGO profiler.
Available for inspection, not emission.
Definition: GlobalValue.h:49
void push_back(const T &Elt)
Definition: SmallVector.h:211
std::string getNodeLabel(const BasicBlock *Node, const PGOUseFunc *Graph)
This provides a very simple, boring adaptor for a begin and end iterator into a range type...
bool canRenameComdatFunc(const Function &F, bool CheckAddressTaken=false)
Check if we can safely rename this Comdat function.
Definition: InstrProf.cpp:971
PGOInstrumentationUse(std::string Filename="", std::string RemappingFilename="", bool IsCS=false)
pgo instr gen
An efficient, type-erasing, non-owning reference to a callable.
Definition: STLExtras.h:116
INITIALIZE_PASS_BEGIN(PGOInstrumentationGenLegacyPass, "pgo-instr-gen", "PGO instrumentation.", false, false) INITIALIZE_PASS_END(PGOInstrumentationGenLegacyPass
This file contains the declaration of the Comdat class, which represents a single COMDAT in LLVM...
virtual std::string message() const
Return the error message as a string.
Definition: Error.h:56
static cl::opt< bool > PGOInstrMemOP("pgo-instr-memop", cl::init(true), cl::Hidden, cl::desc("Use this option to turn on/off " "memory intrinsic size profiling."))
static bool InstrumentAllFunctions(Module &M, function_ref< BranchProbabilityInfo *(Function &)> LookupBPI, function_ref< BlockFrequencyInfo *(Function &)> LookupBFI, bool IsCS)
STATISTIC(NumFunctions, "Total number of functions")
F(f)
Value * getCondition() const
const Instruction * getTerminator() const LLVM_READONLY
Returns the terminator instruction if the block is well formed or null if the block is not well forme...
Definition: BasicBlock.cpp:137
bool isVectorTy() const
True if this is an instance of VectorType.
Definition: Type.h:229
Error takeError()
Take ownership of the stored error.
Definition: Error.h:552
SuccIterator< const Instruction, const BasicBlock > succ_const_iterator
Definition: CFG.h:241
Value * getLength() const
Base class for error info classes.
Definition: Error.h:48
An union-find based Minimum Spanning Tree for CFG.
Definition: CFGMST.h:37
*ViewGraph Emit a dot run run gv on the postscript *then cleanup For use from the debugger *void ViewGraph(const GraphType &G, const Twine &Name, bool ShortNames=false, const Twine &Title="", GraphProgram::Name Program=GraphProgram::DOT)
Definition: GraphWriter.h:366
Function::ProfileCount ProfileCount
iterator begin()
Instruction iterator methods.
Definition: BasicBlock.h:268
ModulePass * createPGOInstrumentationGenCreateVarLegacyPass(StringRef CSInstrName=StringRef(""))
AnalysisUsage & addRequired()
#define INITIALIZE_PASS_DEPENDENCY(depName)
Definition: PassSupport.h:50
Definition: BitVector.h:937
This class represents the LLVM &#39;select&#39; instruction.
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
Definition: Twine.h:80
An analysis pass based on legacy pass manager to deliver ProfileSummaryInfo.
IntegerType * getInt64Ty()
Fetch the type representing a 64-bit integer.
Definition: IRBuilder.h:351
LLVMContext & getContext() const
Get the global data context.
Definition: Module.h:244
ValTy * getCalledValue() const
Return the pointer to function that is being called.
Definition: CallSite.h:104
static bool annotateAllFunctions(Module &M, StringRef ProfileFileName, StringRef ProfileRemappingFileName, function_ref< BranchProbabilityInfo *(Function &)> LookupBPI, function_ref< BlockFrequencyInfo *(Function &)> LookupBFI, bool IsCS)
static cl::opt< std::string > PGOTestProfileRemappingFile("pgo-test-profile-remapping-file", cl::init(""), cl::Hidden, cl::value_desc("filename"), cl::desc("Specify the path of profile remapping file. This is mainly for " "test purpose."))
This provides a uniform API for creating instructions and inserting them into a basic block: either a...
Definition: IRBuilder.h:742
This file contains the simple types necessary to represent the attributes associated with functions a...
Legacy analysis pass which computes BlockFrequencyInfo.
static std::string getGraphName(const PGOUseFunc *G)
void initializePGOInstrumentationGenCreateVarLegacyPassPass(PassRegistry &)
VisitMode
The select instruction visitor plays three roles specified by the mode.
Tagged union holding either a T or a Error.
Definition: CachePruning.h:22
LLVM_NODISCARD bool empty() const
empty - Check if the string is empty.
Definition: StringRef.h:126
This file implements a class to represent arbitrary precision integral constant values and operations...
Interval::succ_iterator succ_begin(Interval *I)
succ_begin/succ_end - define methods so that Intervals may be used just like BasicBlocks can with the...
Definition: Interval.h:102
static bool isSimple(Instruction *I)
Analysis pass which computes BranchProbabilityInfo.
auto reverse(ContainerTy &&C, typename std::enable_if< has_rbegin< ContainerTy >::value >::type *=nullptr) -> decltype(make_range(C.rbegin(), C.rend()))
Definition: STLExtras.h:266
bool isOne() const
This is just a convenience method to make client code smaller for a common case.
Definition: Constants.h:200
This file provides the interface for IR based instrumentation passes ( (profile-gen, and profile-use).
Type * getType() const
All values are typed, get the type of this value.
Definition: Value.h:244
static cl::opt< bool > DisableValueProfiling("disable-vp", cl::init(false), cl::Hidden, cl::desc("Disable Value Profiling"))
static NodeRef getEntryNode(const PGOUseFunc *G)
static bool isIndirectBrTarget(BasicBlock *BB)
void setComdat(Comdat *C)
Definition: GlobalObject.h:102
static void setBranchWeights(SwitchInst *SI, ArrayRef< uint32_t > Weights)
raw_ostream & WriteGraph(raw_ostream &O, const GraphType &G, bool ShortNames=false, const Twine &Title="")
Definition: GraphWriter.h:309
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory)...
Definition: APInt.h:32
BasicBlock * SplitCriticalEdge(Instruction *TI, unsigned SuccNum, const CriticalEdgeSplittingOptions &Options=CriticalEdgeSplittingOptions())
If this edge is a critical edge, insert a new node to split the critical edge.
void initializePGOInstrumentationGenLegacyPassPass(PassRegistry &)
bool isMinusOne() const
This function will return true iff every bit in this constant is set to true.
Definition: Constants.h:208
static bool canRenameComdat(Function &F, std::unordered_multimap< Comdat *, GlobalValue *> &ComdatMembers)
Value * CreateZExt(Value *V, Type *DestTy, const Twine &Name="")
Definition: IRBuilder.h:1694
static nodes_iterator nodes_end(const PGOUseFunc *G)
Concrete subclass of DominatorTreeBase that is used to compute a normal dominator tree...
Definition: Dominators.h:144
Function * getDeclaration(Module *M, ID id, ArrayRef< Type *> Tys=None)
Create or insert an LLVM Function declaration for an intrinsic, and return it.
Definition: Function.cpp:1018
instrprof_error get() const
Definition: InstrProf.h:319
Legacy analysis pass which computes BranchProbabilityInfo.
unsigned getNumSuccessors() const
Return the number of successors that this instruction has.
Value * getOperand(unsigned i) const
Definition: User.h:169
static PreservedAnalyses none()
Convenience factory function for the empty preserved set.
Definition: PassManager.h:156
static ChildIteratorType child_end(const NodeRef N)
Interval::succ_iterator succ_end(Interval *I)
Definition: Interval.h:105
static cl::opt< unsigned > MaxNumMemOPAnnotations("memop-max-annotations", cl::init(4), cl::Hidden, cl::ZeroOrMore, cl::desc("Max number of preicise value annotations for a single memop" "intrinsic"))
std::string message() const override
Return the error message as a string.
Definition: InstrProf.cpp:208
static Constant * getBitCast(Constant *C, Type *Ty, bool OnlyIfReduced=false)
Definition: Constants.cpp:1782
BlockFrequencyInfo pass uses BlockFrequencyInfoImpl implementation to estimate IR basic block frequen...
Same, but only replaced by something equivalent.
Definition: GlobalValue.h:51
initializer< Ty > init(const Ty &Val)
Definition: CommandLine.h:423
StringRef getName() const
Definition: Comdat.cpp:26
A set of analyses that are preserved following a run of a transformation pass.
Definition: PassManager.h:153
const_iterator getFirstInsertionPt() const
Returns an iterator to the first instruction in this block that is suitable for inserting a non-PHI i...
Definition: BasicBlock.cpp:216
void createProfileFileNameVar(Module &M, StringRef InstrProfileOutput)
Definition: InstrProf.cpp:1034
LLVM Basic Block Representation.
Definition: BasicBlock.h:57
The instances of the Type class are immutable: once they are created, they are never changed...
Definition: Type.h:45
Conditional or Unconditional Branch instruction.
#define DEBUG_TYPE
void setIrrLoopHeaderMetadata(Module *M, Instruction *TI, uint64_t Count)
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
ValuesClass values(OptsTy... Options)
Helper to build a ValuesClass by forwarding a variable number of arguments as an initializer list to ...
Definition: CommandLine.h:643
static StringRef getPredicateName(Predicate P)
This file contains the declarations for the subclasses of Constant, which represent the different fla...
Diagnostic information for applied optimization remarks.
Interval::pred_iterator pred_begin(Interval *I)
pred_begin/pred_end - define methods so that Intervals may be used just like BasicBlocks can with the...
Definition: Interval.h:112
Represent the analysis usage information of a pass.
static cl::opt< PGOViewCountsType > PGOViewRawCounts("pgo-view-raw-counts", cl::Hidden, cl::desc("A boolean option to show CFG dag or text " "with raw profile counts from " "profile data. See also option " "-pgo-view-counts. To limit graph " "display to only one function, use " "filtering option -view-bfi-func-name."), cl::values(clEnumValN(PGOVCT_None, "none", "do not show."), clEnumValN(PGOVCT_Graph, "graph", "show a graph."), clEnumValN(PGOVCT_Text, "text", "show in text.")))
static cl::opt< bool > DoComdatRenaming("do-comdat-renaming", cl::init(false), cl::Hidden, cl::desc("Append function hash to the name of COMDAT function to avoid " "function hash mismatch due to the preinliner"))
This instruction compares its operands according to the predicate given to the constructor.
static std::string getBranchCondString(Instruction *TI)
Interval::pred_iterator pred_end(Interval *I)
Definition: Interval.h:115
static uint64_t calculateCountScale(uint64_t MaxCount)
Calculate what to divide by to scale counts.
ConstantInt * getInt64(uint64_t C)
Get a constant 64-bit value.
Definition: IRBuilder.h:311
INITIALIZE_PASS(PGOInstrumentationGenCreateVarLegacyPass, "pgo-instr-gen-create-var", "Create PGO instrumentation version variable for CSPGO.", false, false) ModulePass *llvm
static cl::opt< bool > NoPGOWarnMismatchComdat("no-pgo-warn-mismatch-comdat", cl::init(true), cl::Hidden, cl::desc("The option is used to turn on/off " "warnings about hash mismatch for comdat " "functions."))
void initializePGOInstrumentationUseLegacyPassPass(PassRegistry &)
DenseMap< const BasicBlock *, std::unique_ptr< BBInfo > > BBInfos
Definition: CFGMST.h:46
const Value * getCondition() const
static uint32_t scaleBranchCount(uint64_t Count, uint64_t Scale)
Scale an individual branch count.
Comdat * getOrInsertComdat(StringRef Name)
Return the Comdat in the module with the specified name.
Definition: Module.cpp:482
void annotateValueSite(Module &M, Instruction &Inst, const InstrProfRecord &InstrProfR, InstrProfValueKind ValueKind, uint32_t SiteIndx, uint32_t MaxMDCount=3)
Get the value profile data for value site SiteIdx from InstrProfR and annotate the instruction Inst w...
Definition: InstrProf.cpp:812
static PreservedAnalyses all()
Construct a special preserved set that preserves all passes.
Definition: PassManager.h:159
Class to represent profile counts.
Definition: Function.h:260
void createPGOFuncNameMetadata(Function &F, StringRef PGOFuncName)
Create the PGOFuncName meta data if PGOFuncName is different from function&#39;s raw name.
Definition: InstrProf.cpp:913
PointerType * getInt8PtrTy(unsigned AddrSpace=0)
Fetch the type representing a pointer to an 8-bit integer value.
Definition: IRBuilder.h:384
static PointerType * getInt8PtrTy(LLVMContext &C, unsigned AS=0)
Definition: Type.cpp:219
void printAsOperand(raw_ostream &O, bool PrintType=true, const Module *M=nullptr) const
Print the name of this Value out to the specified raw_ostream.
Definition: AsmWriter.cpp:4269
std::string & str()
Flushes the stream contents to the target string and returns the string&#39;s reference.
Definition: raw_ostream.h:498
INITIALIZE_PASS_END(RegBankSelect, DEBUG_TYPE, "Assign register bank of generic virtual registers", false, false) RegBankSelect
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
void setMetadata(unsigned KindID, MDNode *Node)
Set the metadata of the specified kind to the specified node.
Definition: Metadata.cpp:1225
DOTGraphTraits - Template class that can be specialized to customize how graphs are converted to &#39;dot...
BBInfo * findBBInfo(const BasicBlock *BB) const
Definition: CFGMST.h:88
iterator_range< T > make_range(T x, T y)
Convenience function for iterating over sub-ranges.
void handleAllErrors(Error E, HandlerTs &&... Handlers)
Behaves the same as handleErrors, except that by contract all errors must be handled by the given han...
Definition: Error.h:904
Analysis pass which computes BlockFrequencyInfo.
This is the common base class for memset/memcpy/memmove.
This is the shared class of boolean and integer constants.
Definition: Constants.h:83
void setSelectionKind(SelectionKind Val)
Definition: Comdat.h:45
void emit(DiagnosticInfoOptimizationBase &OptDiag)
Output the remark via the diagnostic handler and to the optimization record file. ...
auto size(R &&Range, typename std::enable_if< std::is_same< typename std::iterator_traits< decltype(Range.begin())>::iterator_category, std::random_access_iterator_tag >::value, void >::type *=nullptr) -> decltype(std::distance(Range.begin(), Range.end()))
Get the size of a range.
Definition: STLExtras.h:1166
static nodes_iterator nodes_begin(const PGOUseFunc *G)
static cl::opt< bool > PGOInstrSelect("pgo-instr-select", cl::init(true), cl::Hidden, cl::desc("Use this option to turn on/off SELECT " "instruction instrumentation. "))
iterator end()
Definition: BasicBlock.h:270
uint64_t getMaximumFunctionCount(bool UseCS)
Return the maximum of all known function counts.
This is a &#39;vector&#39; (really, a variable-sized array), optimized for the case when the array is small...
Definition: SmallVector.h:841
Module.h This file contains the declarations for the Module class.
pgo instr PGO instrumentation
const DataFlowGraph & G
Definition: RDFGraph.cpp:202
PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM)
static void instrumentOneFunc(Function &F, Module *M, BranchProbabilityInfo *BPI, BlockFrequencyInfo *BFI, std::unordered_multimap< Comdat *, GlobalValue *> &ComdatMembers, bool IsCS)
ConstantInt * getInt32(uint32_t C)
Get a constant 32-bit value.
Definition: IRBuilder.h:306
PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM)
uint64_t scale(uint64_t Num) const
Scale a large integer.
reference get()
Returns a reference to the stored T value.
Definition: Error.h:532
bool isConditional() const
void dumpEdges(raw_ostream &OS, const Twine &Message) const
Definition: CFGMST.h:235
raw_ostream & dbgs()
dbgs() - This returns a reference to a raw_ostream for debugging messages.
Definition: Debug.cpp:132
ModulePass * createPGOInstrumentationUseLegacyPass(StringRef Filename=StringRef(""), bool IsCS=false)
static cl::opt< std::string > PGOTestProfileFile("pgo-test-profile-file", cl::init(""), cl::Hidden, cl::value_desc("filename"), cl::desc("Specify the path of profile data file. This is" "mainly for test purpose."))
amdgpu Simplify well known AMD library false FunctionCallee Callee
static void setCSFlagInHash(uint64_t &FuncHash)
Definition: InstrProf.h:781
BBInfo & getBBInfo(const BasicBlock *BB) const
Definition: CFGMST.h:81
#define clEnumValN(ENUMVAL, FLAGNAME, DESC)
Definition: CommandLine.h:618
const Comdat * getComdat() const
Definition: GlobalObject.h:100
pgo instr Read PGO instrumentation profile
Predicate getPredicate() const
Return the predicate for this instruction.
Definition: InstrTypes.h:721
This file provides various utilities for inspecting and working with the control flow graph in LLVM I...
std::vector< Instruction * > findIndirectCalls(Function &F)
Analysis providing branch probability information.
unsigned GetSuccessorNumber(const BasicBlock *BB, const BasicBlock *Succ)
Search for the specified successor of basic block BB and return its position in the terminator instru...
Definition: CFG.cpp:71
Profiling information for a single function.
Definition: InstrProf.h:621
Expected< InstrProfRecord > getInstrProfRecord(StringRef FuncName, uint64_t FuncHash)
Return the NamedInstrProfRecord associated with FuncName and FuncHash.
void print(raw_ostream &O, bool IsForDebug=false, bool NoDetails=false) const
Print the current type.
Definition: AsmWriter.cpp:4166
std::string getPGOFuncName(const Function &F, bool InLTO=false, uint64_t Version=INSTR_PROF_INDEX_VERSION)
Return the modified name for function F suitable to be used the key for profile lookup.
Definition: InstrProf.cpp:252
bool SplitIndirectBrCriticalEdges(Function &F, BranchProbabilityInfo *BPI=nullptr, BlockFrequencyInfo *BFI=nullptr)
StringRef getName() const
Return a constant reference to the value&#39;s name.
Definition: Value.cpp:214
const Function * getParent() const
Return the enclosing method, or null if none.
Definition: BasicBlock.h:106
#define I(x, y, z)
Definition: MD5.cpp:58
#define N
ModulePass class - This class is used to implement unstructured interprocedural optimizations and ana...
Definition: Pass.h:224
GlobalVariable * createPGOFuncNameVar(Function &F, StringRef PGOFuncName)
Create and return the global variable for function name used in PGO instrumentation.
Definition: InstrProf.cpp:331
bool isZero() const
This is just a convenience method to make client code smaller for a common code.
Definition: Constants.h:192
LLVM_NODISCARD std::enable_if<!is_simple_type< Y >::value, typename cast_retty< X, const Y >::ret_type >::type dyn_cast(const Y &Val)
Definition: Casting.h:322
uint32_t Size
Definition: Profile.cpp:46
Keep one copy of named function when linking (weak)
Definition: GlobalValue.h:52
CallInst * CreateCall(FunctionType *FTy, Value *Callee, ArrayRef< Value *> Args=None, const Twine &Name="", MDNode *FPMathTag=nullptr)
Definition: IRBuilder.h:2009
static cl::opt< unsigned > MaxNumAnnotations("icp-max-annotations", cl::init(3), cl::Hidden, cl::ZeroOrMore, cl::desc("Max number of annotations for a single indirect " "call callsite"))
pgo instr use
std::string str() const
Return the twine contents as a std::string.
Definition: Twine.cpp:17
cl::opt< PGOViewCountsType > PGOViewCounts
Value * CreatePtrToInt(Value *V, Type *DestTy, const Twine &Name="")
Definition: IRBuilder.h:1757
const std::string to_string(const T &Value)
Definition: ScopedPrinter.h:61
LLVM_NODISCARD const char * data() const
data - Get a pointer to the start of the string (which may not be null terminated).
Definition: StringRef.h:122
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
A raw_ostream that writes to an std::string.
Definition: raw_ostream.h:482
LLVM Value Representation.
Definition: Value.h:72
void createIRLevelProfileFlagVar(Module &M, bool IsCS)
Definition: InstrProf.cpp:1016
void update(ArrayRef< char > Data)
Definition: JamCRC.cpp:91
Lightweight error class with error context and mandatory checking.
Definition: Error.h:157
BasicBlock::iterator GetInsertPoint() const
Definition: IRBuilder.h:121
DefaultDOTGraphTraits - This class provides the default implementations of all of the DOTGraphTraits ...
IRTranslator LLVM IR MI
cl::opt< std::string > ViewBlockFreqFuncName
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:48
Reader for the indexed binary instrprof format.
A container for analyses that lazily runs them and caches their results.
static void collectComdatMembers(Module &M, std::unordered_multimap< Comdat *, GlobalValue *> &ComdatMembers)
This header defines various interfaces for pass management in LLVM.
static std::string getSimpleNodeName(const BasicBlock *Node)
static cl::opt< bool > EmitBranchProbability("pgo-emit-branch-prob", cl::init(false), cl::Hidden, cl::desc("When this option is on, the annotated " "branch probability will be emitted as " "optimization remarks: -{Rpass|" "pass-remarks}=pgo-instrumentation"))
#define LLVM_DEBUG(X)
Definition: Debug.h:122
static Expected< std::unique_ptr< IndexedInstrProfReader > > create(const Twine &Path, const Twine &RemappingPath="")
Factory method to create an indexed reader.
The optimization diagnostic interface.
static GlobalAlias * create(Type *Ty, unsigned AddressSpace, LinkageTypes Linkage, const Twine &Name, Constant *Aliasee, Module *Parent)
If a parent module is specified, the alias is automatically inserted into the end of the specified mo...
Definition: Globals.cpp:422
PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM)
const BasicBlock * getParent() const
Definition: Instruction.h:66
SelectionKind getSelectionKind() const
Definition: Comdat.h:44
An analysis over an "outer" IR unit that provides access to an analysis manager over an "inner" IR un...
Definition: PassManager.h:1037