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