LLVM  8.0.0svn
InstrProfiling.cpp
Go to the documentation of this file.
1 //===-- InstrProfiling.cpp - Frontend instrumentation based profiling -----===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // This pass lowers instrprof_* intrinsics emitted by a frontend for profiling.
11 // It also builds the data structures and initialization code needed for
12 // updating execution counts and emitting the profile at runtime.
13 //
14 //===----------------------------------------------------------------------===//
15 
17 #include "llvm/ADT/ArrayRef.h"
18 #include "llvm/ADT/SmallVector.h"
19 #include "llvm/ADT/StringRef.h"
20 #include "llvm/ADT/Triple.h"
21 #include "llvm/ADT/Twine.h"
22 #include "llvm/Analysis/LoopInfo.h"
24 #include "llvm/IR/Attributes.h"
25 #include "llvm/IR/BasicBlock.h"
26 #include "llvm/IR/Constant.h"
27 #include "llvm/IR/Constants.h"
28 #include "llvm/IR/DerivedTypes.h"
29 #include "llvm/IR/Dominators.h"
30 #include "llvm/IR/Function.h"
31 #include "llvm/IR/GlobalValue.h"
32 #include "llvm/IR/GlobalVariable.h"
33 #include "llvm/IR/IRBuilder.h"
34 #include "llvm/IR/Instruction.h"
35 #include "llvm/IR/Instructions.h"
36 #include "llvm/IR/IntrinsicInst.h"
37 #include "llvm/IR/Module.h"
38 #include "llvm/IR/Type.h"
39 #include "llvm/Pass.h"
41 #include "llvm/Support/Casting.h"
43 #include "llvm/Support/Error.h"
48 #include <algorithm>
49 #include <cassert>
50 #include <cstddef>
51 #include <cstdint>
52 #include <string>
53 
54 using namespace llvm;
55 
56 #define DEBUG_TYPE "instrprof"
57 
58 // The start and end values of precise value profile range for memory
59 // intrinsic sizes
61  "memop-size-range",
62  cl::desc("Set the range of size in memory intrinsic calls to be profiled "
63  "precisely, in a format of <start_val>:<end_val>"),
64  cl::init(""));
65 
66 // The value that considered to be large value in memory intrinsic.
68  "memop-size-large",
69  cl::desc("Set large value thresthold in memory intrinsic size profiling. "
70  "Value of 0 disables the large value profiling."),
71  cl::init(8192));
72 
73 namespace {
74 
75 cl::opt<bool> DoNameCompression("enable-name-compression",
76  cl::desc("Enable name string compression"),
77  cl::init(true));
78 
79 cl::opt<bool> DoHashBasedCounterSplit(
80  "hash-based-counter-split",
81  cl::desc("Rename counter variable of a comdat function based on cfg hash"),
82  cl::init(true));
83 
84 cl::opt<bool> ValueProfileStaticAlloc(
85  "vp-static-alloc",
86  cl::desc("Do static counter allocation for value profiler"),
87  cl::init(true));
88 
89 cl::opt<double> NumCountersPerValueSite(
90  "vp-counters-per-site",
91  cl::desc("The average number of profile counters allocated "
92  "per value profiling site."),
93  // This is set to a very small value because in real programs, only
94  // a very small percentage of value sites have non-zero targets, e.g, 1/30.
95  // For those sites with non-zero profile, the average number of targets
96  // is usually smaller than 2.
97  cl::init(1.0));
98 
99 cl::opt<bool> AtomicCounterUpdateAll(
100  "instrprof-atomic-counter-update-all", cl::ZeroOrMore,
101  cl::desc("Make all profile counter updates atomic (for testing only)"),
102  cl::init(false));
103 
104 cl::opt<bool> AtomicCounterUpdatePromoted(
105  "atomic-counter-update-promoted", cl::ZeroOrMore,
106  cl::desc("Do counter update using atomic fetch add "
107  " for promoted counters only"),
108  cl::init(false));
109 
110 // If the option is not specified, the default behavior about whether
111 // counter promotion is done depends on how instrumentaiton lowering
112 // pipeline is setup, i.e., the default value of true of this option
113 // does not mean the promotion will be done by default. Explicitly
114 // setting this option can override the default behavior.
115 cl::opt<bool> DoCounterPromotion("do-counter-promotion", cl::ZeroOrMore,
116  cl::desc("Do counter register promotion"),
117  cl::init(false));
118 cl::opt<unsigned> MaxNumOfPromotionsPerLoop(
119  cl::ZeroOrMore, "max-counter-promotions-per-loop", cl::init(20),
120  cl::desc("Max number counter promotions per loop to avoid"
121  " increasing register pressure too much"));
122 
123 // A debug option
125  MaxNumOfPromotions(cl::ZeroOrMore, "max-counter-promotions", cl::init(-1),
126  cl::desc("Max number of allowed counter promotions"));
127 
128 cl::opt<unsigned> SpeculativeCounterPromotionMaxExiting(
129  cl::ZeroOrMore, "speculative-counter-promotion-max-exiting", cl::init(3),
130  cl::desc("The max number of exiting blocks of a loop to allow "
131  " speculative counter promotion"));
132 
133 cl::opt<bool> SpeculativeCounterPromotionToLoop(
134  cl::ZeroOrMore, "speculative-counter-promotion-to-loop", cl::init(false),
135  cl::desc("When the option is false, if the target block is in a loop, "
136  "the promotion will be disallowed unless the promoted counter "
137  " update can be further/iteratively promoted into an acyclic "
138  " region."));
139 
140 cl::opt<bool> IterativeCounterPromotion(
141  cl::ZeroOrMore, "iterative-counter-promotion", cl::init(true),
142  cl::desc("Allow counter promotion across the whole loop nest."));
143 
144 class InstrProfilingLegacyPass : public ModulePass {
145  InstrProfiling InstrProf;
146 
147 public:
148  static char ID;
149 
150  InstrProfilingLegacyPass() : ModulePass(ID) {}
151  InstrProfilingLegacyPass(const InstrProfOptions &Options)
152  : ModulePass(ID), InstrProf(Options) {}
153 
154  StringRef getPassName() const override {
155  return "Frontend instrumentation-based coverage lowering";
156  }
157 
158  bool runOnModule(Module &M) override {
159  return InstrProf.run(M, getAnalysis<TargetLibraryInfoWrapperPass>().getTLI());
160  }
161 
162  void getAnalysisUsage(AnalysisUsage &AU) const override {
163  AU.setPreservesCFG();
165  }
166 };
167 
168 ///
169 /// A helper class to promote one counter RMW operation in the loop
170 /// into register update.
171 ///
172 /// RWM update for the counter will be sinked out of the loop after
173 /// the transformation.
174 ///
175 class PGOCounterPromoterHelper : public LoadAndStorePromoter {
176 public:
177  PGOCounterPromoterHelper(
179  BasicBlock *PH, ArrayRef<BasicBlock *> ExitBlocks,
180  ArrayRef<Instruction *> InsertPts,
182  LoopInfo &LI)
183  : LoadAndStorePromoter({L, S}, SSA), Store(S), ExitBlocks(ExitBlocks),
184  InsertPts(InsertPts), LoopToCandidates(LoopToCands), LI(LI) {
185  assert(isa<LoadInst>(L));
186  assert(isa<StoreInst>(S));
187  SSA.AddAvailableValue(PH, Init);
188  }
189 
190  void doExtraRewritesBeforeFinalDeletion() const override {
191  for (unsigned i = 0, e = ExitBlocks.size(); i != e; ++i) {
192  BasicBlock *ExitBlock = ExitBlocks[i];
193  Instruction *InsertPos = InsertPts[i];
194  // Get LiveIn value into the ExitBlock. If there are multiple
195  // predecessors, the value is defined by a PHI node in this
196  // block.
197  Value *LiveInValue = SSA.GetValueInMiddleOfBlock(ExitBlock);
198  Value *Addr = cast<StoreInst>(Store)->getPointerOperand();
199  IRBuilder<> Builder(InsertPos);
200  if (AtomicCounterUpdatePromoted)
201  // automic update currently can only be promoted across the current
202  // loop, not the whole loop nest.
203  Builder.CreateAtomicRMW(AtomicRMWInst::Add, Addr, LiveInValue,
205  else {
206  LoadInst *OldVal = Builder.CreateLoad(Addr, "pgocount.promoted");
207  auto *NewVal = Builder.CreateAdd(OldVal, LiveInValue);
208  auto *NewStore = Builder.CreateStore(NewVal, Addr);
209 
210  // Now update the parent loop's candidate list:
211  if (IterativeCounterPromotion) {
212  auto *TargetLoop = LI.getLoopFor(ExitBlock);
213  if (TargetLoop)
214  LoopToCandidates[TargetLoop].emplace_back(OldVal, NewStore);
215  }
216  }
217  }
218  }
219 
220 private:
222  ArrayRef<BasicBlock *> ExitBlocks;
223  ArrayRef<Instruction *> InsertPts;
225  LoopInfo &LI;
226 };
227 
228 /// A helper class to do register promotion for all profile counter
229 /// updates in a loop.
230 ///
231 class PGOCounterPromoter {
232 public:
233  PGOCounterPromoter(
235  Loop &CurLoop, LoopInfo &LI)
236  : LoopToCandidates(LoopToCands), ExitBlocks(), InsertPts(), L(CurLoop),
237  LI(LI) {
238 
239  SmallVector<BasicBlock *, 8> LoopExitBlocks;
241  L.getExitBlocks(LoopExitBlocks);
242 
243  for (BasicBlock *ExitBlock : LoopExitBlocks) {
244  if (BlockSet.insert(ExitBlock).second) {
245  ExitBlocks.push_back(ExitBlock);
246  InsertPts.push_back(&*ExitBlock->getFirstInsertionPt());
247  }
248  }
249  }
250 
251  bool run(int64_t *NumPromoted) {
252  // Skip 'infinite' loops:
253  if (ExitBlocks.size() == 0)
254  return false;
255  unsigned MaxProm = getMaxNumOfPromotionsInLoop(&L);
256  if (MaxProm == 0)
257  return false;
258 
259  unsigned Promoted = 0;
260  for (auto &Cand : LoopToCandidates[&L]) {
261 
263  SSAUpdater SSA(&NewPHIs);
264  Value *InitVal = ConstantInt::get(Cand.first->getType(), 0);
265 
266  PGOCounterPromoterHelper Promoter(Cand.first, Cand.second, SSA, InitVal,
267  L.getLoopPreheader(), ExitBlocks,
268  InsertPts, LoopToCandidates, LI);
269  Promoter.run(SmallVector<Instruction *, 2>({Cand.first, Cand.second}));
270  Promoted++;
271  if (Promoted >= MaxProm)
272  break;
273 
274  (*NumPromoted)++;
275  if (MaxNumOfPromotions != -1 && *NumPromoted >= MaxNumOfPromotions)
276  break;
277  }
278 
279  LLVM_DEBUG(dbgs() << Promoted << " counters promoted for loop (depth="
280  << L.getLoopDepth() << ")\n");
281  return Promoted != 0;
282  }
283 
284 private:
285  bool allowSpeculativeCounterPromotion(Loop *LP) {
286  SmallVector<BasicBlock *, 8> ExitingBlocks;
287  L.getExitingBlocks(ExitingBlocks);
288  // Not considierered speculative.
289  if (ExitingBlocks.size() == 1)
290  return true;
291  if (ExitingBlocks.size() > SpeculativeCounterPromotionMaxExiting)
292  return false;
293  return true;
294  }
295 
296  // Returns the max number of Counter Promotions for LP.
297  unsigned getMaxNumOfPromotionsInLoop(Loop *LP) {
298  // We can't insert into a catchswitch.
299  SmallVector<BasicBlock *, 8> LoopExitBlocks;
300  LP->getExitBlocks(LoopExitBlocks);
301  if (llvm::any_of(LoopExitBlocks, [](BasicBlock *Exit) {
302  return isa<CatchSwitchInst>(Exit->getTerminator());
303  }))
304  return 0;
305 
306  if (!LP->hasDedicatedExits())
307  return 0;
308 
309  BasicBlock *PH = LP->getLoopPreheader();
310  if (!PH)
311  return 0;
312 
313  SmallVector<BasicBlock *, 8> ExitingBlocks;
314  LP->getExitingBlocks(ExitingBlocks);
315  // Not considierered speculative.
316  if (ExitingBlocks.size() == 1)
317  return MaxNumOfPromotionsPerLoop;
318 
319  if (ExitingBlocks.size() > SpeculativeCounterPromotionMaxExiting)
320  return 0;
321 
322  // Whether the target block is in a loop does not matter:
323  if (SpeculativeCounterPromotionToLoop)
324  return MaxNumOfPromotionsPerLoop;
325 
326  // Now check the target block:
327  unsigned MaxProm = MaxNumOfPromotionsPerLoop;
328  for (auto *TargetBlock : LoopExitBlocks) {
329  auto *TargetLoop = LI.getLoopFor(TargetBlock);
330  if (!TargetLoop)
331  continue;
332  unsigned MaxPromForTarget = getMaxNumOfPromotionsInLoop(TargetLoop);
333  unsigned PendingCandsInTarget = LoopToCandidates[TargetLoop].size();
334  MaxProm =
335  std::min(MaxProm, std::max(MaxPromForTarget, PendingCandsInTarget) -
336  PendingCandsInTarget);
337  }
338  return MaxProm;
339  }
340 
342  SmallVector<BasicBlock *, 8> ExitBlocks;
344  Loop &L;
345  LoopInfo &LI;
346 };
347 
348 } // end anonymous namespace
349 
351  auto &TLI = AM.getResult<TargetLibraryAnalysis>(M);
352  if (!run(M, TLI))
353  return PreservedAnalyses::all();
354 
355  return PreservedAnalyses::none();
356 }
357 
360  InstrProfilingLegacyPass, "instrprof",
361  "Frontend instrumentation-based coverage lowering.", false, false)
364  InstrProfilingLegacyPass, "instrprof",
365  "Frontend instrumentation-based coverage lowering.", false, false)
366 
367 ModulePass *
369  return new InstrProfilingLegacyPass(Options);
370 }
371 
374  if (Inc)
375  return Inc;
376  return dyn_cast<InstrProfIncrementInst>(Instr);
377 }
378 
379 bool InstrProfiling::lowerIntrinsics(Function *F) {
380  bool MadeChange = false;
381  PromotionCandidates.clear();
382  for (BasicBlock &BB : *F) {
383  for (auto I = BB.begin(), E = BB.end(); I != E;) {
384  auto Instr = I++;
386  if (Inc) {
387  lowerIncrement(Inc);
388  MadeChange = true;
389  } else if (auto *Ind = dyn_cast<InstrProfValueProfileInst>(Instr)) {
390  lowerValueProfileInst(Ind);
391  MadeChange = true;
392  }
393  }
394  }
395 
396  if (!MadeChange)
397  return false;
398 
399  promoteCounterLoadStores(F);
400  return true;
401 }
402 
403 bool InstrProfiling::isCounterPromotionEnabled() const {
404  if (DoCounterPromotion.getNumOccurrences() > 0)
405  return DoCounterPromotion;
406 
407  return Options.DoCounterPromotion;
408 }
409 
410 void InstrProfiling::promoteCounterLoadStores(Function *F) {
411  if (!isCounterPromotionEnabled())
412  return;
413 
414  DominatorTree DT(*F);
415  LoopInfo LI(DT);
416  DenseMap<Loop *, SmallVector<LoadStorePair, 8>> LoopPromotionCandidates;
417 
418  for (const auto &LoadStore : PromotionCandidates) {
419  auto *CounterLoad = LoadStore.first;
420  auto *CounterStore = LoadStore.second;
421  BasicBlock *BB = CounterLoad->getParent();
422  Loop *ParentLoop = LI.getLoopFor(BB);
423  if (!ParentLoop)
424  continue;
425  LoopPromotionCandidates[ParentLoop].emplace_back(CounterLoad, CounterStore);
426  }
427 
429 
430  // Do a post-order traversal of the loops so that counter updates can be
431  // iteratively hoisted outside the loop nest.
432  for (auto *Loop : llvm::reverse(Loops)) {
433  PGOCounterPromoter Promoter(LoopPromotionCandidates, *Loop, LI);
434  Promoter.run(&TotalCountersPromoted);
435  }
436 }
437 
438 /// Check if the module contains uses of any profiling intrinsics.
440  if (auto *F = M.getFunction(
441  Intrinsic::getName(llvm::Intrinsic::instrprof_increment)))
442  if (!F->use_empty())
443  return true;
444  if (auto *F = M.getFunction(
445  Intrinsic::getName(llvm::Intrinsic::instrprof_increment_step)))
446  if (!F->use_empty())
447  return true;
448  if (auto *F = M.getFunction(
449  Intrinsic::getName(llvm::Intrinsic::instrprof_value_profile)))
450  if (!F->use_empty())
451  return true;
452  return false;
453 }
454 
456  this->M = &M;
457  this->TLI = &TLI;
458  NamesVar = nullptr;
459  NamesSize = 0;
460  ProfileDataMap.clear();
461  UsedVars.clear();
462  getMemOPSizeRangeFromOption(MemOPSizeRange, MemOPSizeRangeStart,
463  MemOPSizeRangeLast);
464  TT = Triple(M.getTargetTriple());
465 
466  // Emit the runtime hook even if no counters are present.
467  bool MadeChange = emitRuntimeHook();
468 
469  // Improve compile time by avoiding linear scans when there is no work.
470  GlobalVariable *CoverageNamesVar =
472  if (!containsProfilingIntrinsics(M) && !CoverageNamesVar)
473  return MadeChange;
474 
475  // We did not know how many value sites there would be inside
476  // the instrumented function. This is counting the number of instrumented
477  // target value sites to enter it as field in the profile data variable.
478  for (Function &F : M) {
479  InstrProfIncrementInst *FirstProfIncInst = nullptr;
480  for (BasicBlock &BB : F)
481  for (auto I = BB.begin(), E = BB.end(); I != E; I++)
482  if (auto *Ind = dyn_cast<InstrProfValueProfileInst>(I))
483  computeNumValueSiteCounts(Ind);
484  else if (FirstProfIncInst == nullptr)
485  FirstProfIncInst = dyn_cast<InstrProfIncrementInst>(I);
486 
487  // Value profiling intrinsic lowering requires per-function profile data
488  // variable to be created first.
489  if (FirstProfIncInst != nullptr)
490  static_cast<void>(getOrCreateRegionCounters(FirstProfIncInst));
491  }
492 
493  for (Function &F : M)
494  MadeChange |= lowerIntrinsics(&F);
495 
496  if (CoverageNamesVar) {
497  lowerCoverageData(CoverageNamesVar);
498  MadeChange = true;
499  }
500 
501  if (!MadeChange)
502  return false;
503 
504  emitVNodes();
505  emitNameData();
506  emitRegistration();
507  emitUses();
508  emitInitialization();
509  return true;
510 }
511 
513  const TargetLibraryInfo &TLI,
514  bool IsRange = false) {
515  LLVMContext &Ctx = M.getContext();
516  auto *ReturnTy = Type::getVoidTy(M.getContext());
517 
518  Constant *Res;
519  if (!IsRange) {
520  Type *ParamTypes[] = {
521 #define VALUE_PROF_FUNC_PARAM(ParamType, ParamName, ParamLLVMType) ParamLLVMType
523  };
524  auto *ValueProfilingCallTy =
525  FunctionType::get(ReturnTy, makeArrayRef(ParamTypes), false);
527  ValueProfilingCallTy);
528  } else {
529  Type *RangeParamTypes[] = {
530 #define VALUE_RANGE_PROF 1
531 #define VALUE_PROF_FUNC_PARAM(ParamType, ParamName, ParamLLVMType) ParamLLVMType
533 #undef VALUE_RANGE_PROF
534  };
535  auto *ValueRangeProfilingCallTy =
536  FunctionType::get(ReturnTy, makeArrayRef(RangeParamTypes), false);
538  ValueRangeProfilingCallTy);
539  }
540 
541  if (Function *FunRes = dyn_cast<Function>(Res)) {
542  if (auto AK = TLI.getExtAttrForI32Param(false))
543  FunRes->addParamAttr(2, AK);
544  }
545  return Res;
546 }
547 
548 void InstrProfiling::computeNumValueSiteCounts(InstrProfValueProfileInst *Ind) {
549  GlobalVariable *Name = Ind->getName();
550  uint64_t ValueKind = Ind->getValueKind()->getZExtValue();
551  uint64_t Index = Ind->getIndex()->getZExtValue();
552  auto It = ProfileDataMap.find(Name);
553  if (It == ProfileDataMap.end()) {
554  PerFunctionProfileData PD;
555  PD.NumValueSites[ValueKind] = Index + 1;
556  ProfileDataMap[Name] = PD;
557  } else if (It->second.NumValueSites[ValueKind] <= Index)
558  It->second.NumValueSites[ValueKind] = Index + 1;
559 }
560 
561 void InstrProfiling::lowerValueProfileInst(InstrProfValueProfileInst *Ind) {
562  GlobalVariable *Name = Ind->getName();
563  auto It = ProfileDataMap.find(Name);
564  assert(It != ProfileDataMap.end() && It->second.DataVar &&
565  "value profiling detected in function with no counter incerement");
566 
567  GlobalVariable *DataVar = It->second.DataVar;
568  uint64_t ValueKind = Ind->getValueKind()->getZExtValue();
569  uint64_t Index = Ind->getIndex()->getZExtValue();
570  for (uint32_t Kind = IPVK_First; Kind < ValueKind; ++Kind)
571  Index += It->second.NumValueSites[Kind];
572 
573  IRBuilder<> Builder(Ind);
574  bool IsRange = (Ind->getValueKind()->getZExtValue() ==
575  llvm::InstrProfValueKind::IPVK_MemOPSize);
576  CallInst *Call = nullptr;
577  if (!IsRange) {
578  Value *Args[3] = {Ind->getTargetValue(),
579  Builder.CreateBitCast(DataVar, Builder.getInt8PtrTy()),
580  Builder.getInt32(Index)};
581  Call = Builder.CreateCall(getOrInsertValueProfilingCall(*M, *TLI), Args);
582  } else {
583  Value *Args[6] = {
584  Ind->getTargetValue(),
585  Builder.CreateBitCast(DataVar, Builder.getInt8PtrTy()),
586  Builder.getInt32(Index),
587  Builder.getInt64(MemOPSizeRangeStart),
588  Builder.getInt64(MemOPSizeRangeLast),
589  Builder.getInt64(MemOPSizeLarge == 0 ? INT64_MIN : MemOPSizeLarge)};
590  Call =
591  Builder.CreateCall(getOrInsertValueProfilingCall(*M, *TLI, true), Args);
592  }
593  if (auto AK = TLI->getExtAttrForI32Param(false))
594  Call->addParamAttr(2, AK);
595  Ind->replaceAllUsesWith(Call);
596  Ind->eraseFromParent();
597 }
598 
599 void InstrProfiling::lowerIncrement(InstrProfIncrementInst *Inc) {
600  GlobalVariable *Counters = getOrCreateRegionCounters(Inc);
601 
602  IRBuilder<> Builder(Inc);
603  uint64_t Index = Inc->getIndex()->getZExtValue();
604  Value *Addr = Builder.CreateConstInBoundsGEP2_64(Counters, 0, Index);
605 
606  if (Options.Atomic || AtomicCounterUpdateAll) {
607  Builder.CreateAtomicRMW(AtomicRMWInst::Add, Addr, Inc->getStep(),
609  } else {
610  Value *Load = Builder.CreateLoad(Addr, "pgocount");
611  auto *Count = Builder.CreateAdd(Load, Inc->getStep());
612  auto *Store = Builder.CreateStore(Count, Addr);
613  if (isCounterPromotionEnabled())
614  PromotionCandidates.emplace_back(cast<Instruction>(Load), Store);
615  }
616  Inc->eraseFromParent();
617 }
618 
619 void InstrProfiling::lowerCoverageData(GlobalVariable *CoverageNamesVar) {
620  ConstantArray *Names =
621  cast<ConstantArray>(CoverageNamesVar->getInitializer());
622  for (unsigned I = 0, E = Names->getNumOperands(); I < E; ++I) {
623  Constant *NC = Names->getOperand(I);
624  Value *V = NC->stripPointerCasts();
625  assert(isa<GlobalVariable>(V) && "Missing reference to function name");
626  GlobalVariable *Name = cast<GlobalVariable>(V);
627 
629  ReferencedNames.push_back(Name);
630  NC->dropAllReferences();
631  }
632  CoverageNamesVar->eraseFromParent();
633 }
634 
635 /// Get the name of a profiling variable for a particular function.
637  StringRef NamePrefix = getInstrProfNameVarPrefix();
638  StringRef Name = Inc->getName()->getName().substr(NamePrefix.size());
639  Function *F = Inc->getParent()->getParent();
640  Module *M = F->getParent();
641  if (!DoHashBasedCounterSplit || !isIRPGOFlagSet(M) ||
642  !canRenameComdatFunc(*F))
643  return (Prefix + Name).str();
644  uint64_t FuncHash = Inc->getHash()->getZExtValue();
645  SmallVector<char, 24> HashPostfix;
646  if (Name.endswith((Twine(".") + Twine(FuncHash)).toStringRef(HashPostfix)))
647  return (Prefix + Name).str();
648  return (Prefix + Name + "." + Twine(FuncHash)).str();
649 }
650 
651 static inline bool shouldRecordFunctionAddr(Function *F) {
652  // Check the linkage
653  bool HasAvailableExternallyLinkage = F->hasAvailableExternallyLinkage();
654  if (!F->hasLinkOnceLinkage() && !F->hasLocalLinkage() &&
655  !HasAvailableExternallyLinkage)
656  return true;
657 
658  // A function marked 'alwaysinline' with available_externally linkage can't
659  // have its address taken. Doing so would create an undefined external ref to
660  // the function, which would fail to link.
661  if (HasAvailableExternallyLinkage &&
662  F->hasFnAttribute(Attribute::AlwaysInline))
663  return false;
664 
665  // Prohibit function address recording if the function is both internal and
666  // COMDAT. This avoids the profile data variable referencing internal symbols
667  // in COMDAT.
668  if (F->hasLocalLinkage() && F->hasComdat())
669  return false;
670 
671  // Check uses of this function for other than direct calls or invokes to it.
672  // Inline virtual functions have linkeOnceODR linkage. When a key method
673  // exists, the vtable will only be emitted in the TU where the key method
674  // is defined. In a TU where vtable is not available, the function won't
675  // be 'addresstaken'. If its address is not recorded here, the profile data
676  // with missing address may be picked by the linker leading to missing
677  // indirect call target info.
678  return F->hasAddressTaken() || F->hasLinkOnceLinkage();
679 }
680 
682  InstrProfIncrementInst *Inc) {
683  if (!needsComdatForCounter(F, M))
684  return nullptr;
685 
686  // COFF format requires a COMDAT section to have a key symbol with the same
687  // name. The linker targeting COFF also requires that the COMDAT
688  // a section is associated to must precede the associating section. For this
689  // reason, we must choose the counter var's name as the name of the comdat.
690  StringRef ComdatPrefix = (Triple(M.getTargetTriple()).isOSBinFormatCOFF()
693  return M.getOrInsertComdat(StringRef(getVarName(Inc, ComdatPrefix)));
694 }
695 
697  // Don't do this for Darwin. compiler-rt uses linker magic.
698  if (Triple(M.getTargetTriple()).isOSDarwin())
699  return false;
700 
701  // Use linker script magic to get data/cnts/name start/end.
702  if (Triple(M.getTargetTriple()).isOSLinux() ||
703  Triple(M.getTargetTriple()).isOSFreeBSD() ||
704  Triple(M.getTargetTriple()).isOSFuchsia() ||
705  Triple(M.getTargetTriple()).isPS4CPU())
706  return false;
707 
708  return true;
709 }
710 
712 InstrProfiling::getOrCreateRegionCounters(InstrProfIncrementInst *Inc) {
713  GlobalVariable *NamePtr = Inc->getName();
714  auto It = ProfileDataMap.find(NamePtr);
715  PerFunctionProfileData PD;
716  if (It != ProfileDataMap.end()) {
717  if (It->second.RegionCounters)
718  return It->second.RegionCounters;
719  PD = It->second;
720  }
721 
722  // Move the name variable to the right section. Place them in a COMDAT group
723  // if the associated function is a COMDAT. This will make sure that
724  // only one copy of counters of the COMDAT function will be emitted after
725  // linking.
726  Function *Fn = Inc->getParent()->getParent();
727  Comdat *ProfileVarsComdat = nullptr;
728  ProfileVarsComdat = getOrCreateProfileComdat(*M, *Fn, Inc);
729 
730  uint64_t NumCounters = Inc->getNumCounters()->getZExtValue();
731  LLVMContext &Ctx = M->getContext();
732  ArrayType *CounterTy = ArrayType::get(Type::getInt64Ty(Ctx), NumCounters);
733 
734  // Create the counters variable.
735  auto *CounterPtr =
736  new GlobalVariable(*M, CounterTy, false, NamePtr->getLinkage(),
737  Constant::getNullValue(CounterTy),
739  CounterPtr->setVisibility(NamePtr->getVisibility());
740  CounterPtr->setSection(
741  getInstrProfSectionName(IPSK_cnts, TT.getObjectFormat()));
742  CounterPtr->setAlignment(8);
743  CounterPtr->setComdat(ProfileVarsComdat);
744 
745  auto *Int8PtrTy = Type::getInt8PtrTy(Ctx);
746  // Allocate statically the array of pointers to value profile nodes for
747  // the current function.
748  Constant *ValuesPtrExpr = ConstantPointerNull::get(Int8PtrTy);
749  if (ValueProfileStaticAlloc && !needsRuntimeRegistrationOfSectionRange(*M)) {
750  uint64_t NS = 0;
751  for (uint32_t Kind = IPVK_First; Kind <= IPVK_Last; ++Kind)
752  NS += PD.NumValueSites[Kind];
753  if (NS) {
754  ArrayType *ValuesTy = ArrayType::get(Type::getInt64Ty(Ctx), NS);
755 
756  auto *ValuesVar =
757  new GlobalVariable(*M, ValuesTy, false, NamePtr->getLinkage(),
758  Constant::getNullValue(ValuesTy),
760  ValuesVar->setVisibility(NamePtr->getVisibility());
761  ValuesVar->setSection(
762  getInstrProfSectionName(IPSK_vals, TT.getObjectFormat()));
763  ValuesVar->setAlignment(8);
764  ValuesVar->setComdat(ProfileVarsComdat);
765  ValuesPtrExpr =
767  }
768  }
769 
770  // Create data variable.
771  auto *Int16Ty = Type::getInt16Ty(Ctx);
772  auto *Int16ArrayTy = ArrayType::get(Int16Ty, IPVK_Last + 1);
773  Type *DataTypes[] = {
774 #define INSTR_PROF_DATA(Type, LLVMType, Name, Init) LLVMType,
776  };
777  auto *DataTy = StructType::get(Ctx, makeArrayRef(DataTypes));
778 
779  Constant *FunctionAddr = shouldRecordFunctionAddr(Fn)
780  ? ConstantExpr::getBitCast(Fn, Int8PtrTy)
781  : ConstantPointerNull::get(Int8PtrTy);
782 
783  Constant *Int16ArrayVals[IPVK_Last + 1];
784  for (uint32_t Kind = IPVK_First; Kind <= IPVK_Last; ++Kind)
785  Int16ArrayVals[Kind] = ConstantInt::get(Int16Ty, PD.NumValueSites[Kind]);
786 
787  Constant *DataVals[] = {
788 #define INSTR_PROF_DATA(Type, LLVMType, Name, Init) Init,
790  };
791  auto *Data = new GlobalVariable(*M, DataTy, false, NamePtr->getLinkage(),
792  ConstantStruct::get(DataTy, DataVals),
794  Data->setVisibility(NamePtr->getVisibility());
795  Data->setSection(getInstrProfSectionName(IPSK_data, TT.getObjectFormat()));
796  Data->setAlignment(INSTR_PROF_DATA_ALIGNMENT);
797  Data->setComdat(ProfileVarsComdat);
798 
799  PD.RegionCounters = CounterPtr;
800  PD.DataVar = Data;
801  ProfileDataMap[NamePtr] = PD;
802 
803  // Mark the data variable as used so that it isn't stripped out.
804  UsedVars.push_back(Data);
805  // Now that the linkage set by the FE has been passed to the data and counter
806  // variables, reset Name variable's linkage and visibility to private so that
807  // it can be removed later by the compiler.
809  // Collect the referenced names to be used by emitNameData.
810  ReferencedNames.push_back(NamePtr);
811 
812  return CounterPtr;
813 }
814 
815 void InstrProfiling::emitVNodes() {
816  if (!ValueProfileStaticAlloc)
817  return;
818 
819  // For now only support this on platforms that do
820  // not require runtime registration to discover
821  // named section start/end.
823  return;
824 
825  size_t TotalNS = 0;
826  for (auto &PD : ProfileDataMap) {
827  for (uint32_t Kind = IPVK_First; Kind <= IPVK_Last; ++Kind)
828  TotalNS += PD.second.NumValueSites[Kind];
829  }
830 
831  if (!TotalNS)
832  return;
833 
834  uint64_t NumCounters = TotalNS * NumCountersPerValueSite;
835 // Heuristic for small programs with very few total value sites.
836 // The default value of vp-counters-per-site is chosen based on
837 // the observation that large apps usually have a low percentage
838 // of value sites that actually have any profile data, and thus
839 // the average number of counters per site is low. For small
840 // apps with very few sites, this may not be true. Bump up the
841 // number of counters in this case.
842 #define INSTR_PROF_MIN_VAL_COUNTS 10
843  if (NumCounters < INSTR_PROF_MIN_VAL_COUNTS)
844  NumCounters = std::max(INSTR_PROF_MIN_VAL_COUNTS, (int)NumCounters * 2);
845 
846  auto &Ctx = M->getContext();
847  Type *VNodeTypes[] = {
848 #define INSTR_PROF_VALUE_NODE(Type, LLVMType, Name, Init) LLVMType,
850  };
851  auto *VNodeTy = StructType::get(Ctx, makeArrayRef(VNodeTypes));
852 
853  ArrayType *VNodesTy = ArrayType::get(VNodeTy, NumCounters);
854  auto *VNodesVar = new GlobalVariable(
855  *M, VNodesTy, false, GlobalValue::PrivateLinkage,
857  VNodesVar->setSection(
858  getInstrProfSectionName(IPSK_vnodes, TT.getObjectFormat()));
859  UsedVars.push_back(VNodesVar);
860 }
861 
862 void InstrProfiling::emitNameData() {
863  std::string UncompressedData;
864 
865  if (ReferencedNames.empty())
866  return;
867 
868  std::string CompressedNameStr;
869  if (Error E = collectPGOFuncNameStrings(ReferencedNames, CompressedNameStr,
870  DoNameCompression)) {
871  report_fatal_error(toString(std::move(E)), false);
872  }
873 
874  auto &Ctx = M->getContext();
875  auto *NamesVal = ConstantDataArray::getString(
876  Ctx, StringRef(CompressedNameStr), false);
877  NamesVar = new GlobalVariable(*M, NamesVal->getType(), true,
878  GlobalValue::PrivateLinkage, NamesVal,
880  NamesSize = CompressedNameStr.size();
881  NamesVar->setSection(
882  getInstrProfSectionName(IPSK_name, TT.getObjectFormat()));
883  UsedVars.push_back(NamesVar);
884 
885  for (auto *NamePtr : ReferencedNames)
886  NamePtr->eraseFromParent();
887 }
888 
889 void InstrProfiling::emitRegistration() {
891  return;
892 
893  // Construct the function.
894  auto *VoidTy = Type::getVoidTy(M->getContext());
895  auto *VoidPtrTy = Type::getInt8PtrTy(M->getContext());
896  auto *Int64Ty = Type::getInt64Ty(M->getContext());
897  auto *RegisterFTy = FunctionType::get(VoidTy, false);
898  auto *RegisterF = Function::Create(RegisterFTy, GlobalValue::InternalLinkage,
900  RegisterF->setUnnamedAddr(GlobalValue::UnnamedAddr::Global);
901  if (Options.NoRedZone)
902  RegisterF->addFnAttr(Attribute::NoRedZone);
903 
904  auto *RuntimeRegisterTy = FunctionType::get(VoidTy, VoidPtrTy, false);
905  auto *RuntimeRegisterF =
908 
909  IRBuilder<> IRB(BasicBlock::Create(M->getContext(), "", RegisterF));
910  for (Value *Data : UsedVars)
911  if (Data != NamesVar && !isa<Function>(Data))
912  IRB.CreateCall(RuntimeRegisterF, IRB.CreateBitCast(Data, VoidPtrTy));
913 
914  if (NamesVar) {
915  Type *ParamTypes[] = {VoidPtrTy, Int64Ty};
916  auto *NamesRegisterTy =
917  FunctionType::get(VoidTy, makeArrayRef(ParamTypes), false);
918  auto *NamesRegisterF =
921  IRB.CreateCall(NamesRegisterF, {IRB.CreateBitCast(NamesVar, VoidPtrTy),
922  IRB.getInt64(NamesSize)});
923  }
924 
925  IRB.CreateRetVoid();
926 }
927 
928 bool InstrProfiling::emitRuntimeHook() {
929  // We expect the linker to be invoked with -u<hook_var> flag for linux,
930  // for which case there is no need to emit the user function.
931  if (Triple(M->getTargetTriple()).isOSLinux())
932  return false;
933 
934  // If the module's provided its own runtime, we don't need to do anything.
936  return false;
937 
938  // Declare an external variable that will pull in the runtime initialization.
939  auto *Int32Ty = Type::getInt32Ty(M->getContext());
940  auto *Var =
942  nullptr, getInstrProfRuntimeHookVarName());
943 
944  // Make a function that uses it.
948  User->addFnAttr(Attribute::NoInline);
949  if (Options.NoRedZone)
950  User->addFnAttr(Attribute::NoRedZone);
951  User->setVisibility(GlobalValue::HiddenVisibility);
952  if (Triple(M->getTargetTriple()).supportsCOMDAT())
953  User->setComdat(M->getOrInsertComdat(User->getName()));
954 
956  auto *Load = IRB.CreateLoad(Var);
957  IRB.CreateRet(Load);
958 
959  // Mark the user variable as used so that it isn't stripped out.
960  UsedVars.push_back(User);
961  return true;
962 }
963 
964 void InstrProfiling::emitUses() {
965  if (!UsedVars.empty())
966  appendToUsed(*M, UsedVars);
967 }
968 
969 void InstrProfiling::emitInitialization() {
970  StringRef InstrProfileOutput = Options.InstrProfileOutput;
971 
972  if (!InstrProfileOutput.empty()) {
973  // Create variable for profile name.
974  Constant *ProfileNameConst =
975  ConstantDataArray::getString(M->getContext(), InstrProfileOutput, true);
976  GlobalVariable *ProfileNameVar = new GlobalVariable(
977  *M, ProfileNameConst->getType(), true, GlobalValue::WeakAnyLinkage,
978  ProfileNameConst, INSTR_PROF_QUOTE(INSTR_PROF_PROFILE_NAME_VAR));
979  if (TT.supportsCOMDAT()) {
980  ProfileNameVar->setLinkage(GlobalValue::ExternalLinkage);
981  ProfileNameVar->setComdat(M->getOrInsertComdat(
982  StringRef(INSTR_PROF_QUOTE(INSTR_PROF_PROFILE_NAME_VAR))));
983  }
984  }
985 
986  Constant *RegisterF = M->getFunction(getInstrProfRegFuncsName());
987  if (!RegisterF)
988  return;
989 
990  // Create the initialization function.
991  auto *VoidTy = Type::getVoidTy(M->getContext());
992  auto *F = Function::Create(FunctionType::get(VoidTy, false),
995  F->setUnnamedAddr(GlobalValue::UnnamedAddr::Global);
996  F->addFnAttr(Attribute::NoInline);
997  if (Options.NoRedZone)
998  F->addFnAttr(Attribute::NoRedZone);
999 
1000  // Add the basic block and the necessary calls.
1001  IRBuilder<> IRB(BasicBlock::Create(M->getContext(), "", F));
1002  if (RegisterF)
1003  IRB.CreateCall(RegisterF, {});
1004  IRB.CreateRetVoid();
1005 
1006  appendToGlobalCtors(*M, F, 0);
1007 }
void setVisibility(VisibilityTypes V)
Definition: GlobalValue.h:239
cl::opt< std::string > MemOPSizeRange("memop-size-range", cl::desc("Set the range of size in memory intrinsic calls to be profiled " "precisely, in a format of <start_val>:<end_val>"), cl::init(""))
SymbolTableList< Instruction >::iterator eraseFromParent()
This method unlinks &#39;this&#39; from the containing basic block and deletes it.
Definition: Instruction.cpp:68
StringRef getInstrProfRuntimeHookVarUseFuncName()
Return the name of the compiler generated function that references the runtime hook variable...
Definition: InstrProf.h:157
const std::string & getTargetTriple() const
Get the target triple which is a string describing the target host.
Definition: Module.h:239
static Constant * getString(LLVMContext &Context, StringRef Initializer, bool AddNull=true)
This method constructs a CDS and initializes it with a text string.
Definition: Constants.cpp:2515
bool hasLocalLinkage() const
Definition: GlobalValue.h:436
Helper class for SSA formation on a set of values defined in multiple blocks.
Definition: SSAUpdater.h:39
Value * getPointerOperand(Value *V)
A helper function that returns the pointer operand of a load, store or GEP instruction.
GCNRegPressure max(const GCNRegPressure &P1, const GCNRegPressure &P2)
ConstantInt * getIndex() const
void dropAllReferences()
Drop all references to operands.
Definition: User.h:295
StringRef getInstrProfNameVarPrefix()
Return the name prefix of variables containing instrumented function names.
Definition: InstrProf.h:83
PassT::Result & getResult(IRUnitT &IR, ExtraArgTs... ExtraArgs)
Get the result of an analysis pass for a given IR unit.
Definition: PassManager.h:770
const Constant * getInitializer() const
getInitializer - Return the initializer for this global variable.
LLVM_ATTRIBUTE_NORETURN void report_fatal_error(Error Err, bool gen_crash_diag=true)
Report a serious error, calling any installed error handler.
Definition: Error.cpp:139
Compute iterated dominance frontiers using a linear time algorithm.
Definition: AllocatorList.h:24
cl::opt< unsigned > MemOPSizeLarge("memop-size-large", cl::desc("Set large value thresthold in memory intrinsic size profiling. " "Value of 0 disables the large value profiling."), cl::init(8192))
Constant * getOrInsertFunction(StringRef Name, FunctionType *T, AttributeList AttributeList)
Look up the specified function in the module symbol table.
Definition: Module.cpp:143
StringRef getInstrProfRegFuncsName()
Return the name of function that registers all the per-function control data at program startup time ...
Definition: InstrProf.h:127
A Module instance is used to store all the information related to an LLVM module. ...
Definition: Module.h:64
bool hasDedicatedExits() const
Return true if no exit block for the loop has a predecessor that is outside the loop.
Definition: LoopInfoImpl.h:86
LLVM_NODISCARD LLVM_ATTRIBUTE_ALWAYS_INLINE size_t size() const
size - Get the string size.
Definition: StringRef.h:138
static bool containsProfilingIntrinsics(Module &M)
Check if the module contains uses of any profiling intrinsics.
#define INSTR_PROF_MIN_VAL_COUNTS
This class represents a function call, abstracting a target machine&#39;s calling convention.
bool hasAvailableExternallyLinkage() const
Definition: GlobalValue.h:423
bool canRenameComdatFunc(const Function &F, bool CheckAddressTaken=false)
Check if we can safely rename this Comdat function.
Definition: InstrProf.cpp:971
BlockT * getLoopPreheader() const
If there is a preheader for this loop, return it.
Definition: LoopInfoImpl.h:174
const GlobalVariable * getNamedGlobal(StringRef Name) const
Return the global variable in the module with the specified name, of arbitrary type.
Definition: Module.h:396
Like Internal, but omit from symbol table.
Definition: GlobalValue.h:57
Externally visible function.
Definition: GlobalValue.h:49
bool hasFnAttribute(Attribute::AttrKind Kind) const
Return true if the function has the attribute.
Definition: Function.h:321
GlobalVariable * getGlobalVariable(StringRef Name) const
Look up the specified global variable in the module symbol table.
Definition: Module.h:381
This file provides the interface for LLVM&#39;s PGO Instrumentation lowering pass.
std::string getInstrProfSectionName(InstrProfSectKind IPSK, Triple::ObjectFormatType OF, bool AddSegmentInfo=true)
Return the name of the profile section corresponding to IPSK.
Definition: InstrProf.cpp:165
F(f)
An instruction for reading from memory.
Definition: Instructions.h:168
static IntegerType * getInt64Ty(LLVMContext &C)
Definition: Type.cpp:177
ModulePass * createInstrProfilingLegacyPass(const InstrProfOptions &Options=InstrProfOptions())
Insert frontend instrumentation based profiling.
static IntegerType * getInt16Ty(LLVMContext &C)
Definition: Type.cpp:175
StringRef getInstrProfValuesVarPrefix()
Return the name prefix of value profile variables.
Definition: InstrProf.h:92
void addParamAttr(unsigned ArgNo, Attribute::AttrKind Kind)
Adds the attribute to the indicated argument.
static Constant * getNullValue(Type *Ty)
Constructor to create a &#39;0&#39; constant of arbitrary type.
Definition: Constants.cpp:268
Attribute::AttrKind getExtAttrForI32Param(bool Signed=true) const
Returns extension attribute kind to be used for i32 parameters corresponding to C-level int or unsign...
LLVM_NODISCARD LLVM_ATTRIBUTE_ALWAYS_INLINE bool endswith(StringRef Suffix) const
Check if this string ends with the given Suffix.
Definition: StringRef.h:279
AnalysisUsage & addRequired()
#define INITIALIZE_PASS_DEPENDENCY(depName)
Definition: PassSupport.h:51
Hexagon Hardware Loops
StringRef getInstrProfInitFuncName()
Return the name of the runtime initialization method that is generated by the compiler.
Definition: InstrProf.h:146
std::string toString(Error E)
Write all error messages (if any) in E to a string.
Definition: Error.h:963
StringRef getName(ID id)
Return the LLVM name for an intrinsic, such as "llvm.ppc.altivec.lvx".
Definition: Function.cpp:627
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
Definition: Twine.h:81
LoopT * getLoopFor(const BlockT *BB) const
Return the inner most loop that BB lives in.
Definition: LoopInfo.h:684
ArrayRef< T > makeArrayRef(const T &OneElt)
Construct an ArrayRef from a single element.
Definition: ArrayRef.h:451
StringRef getInstrProfDataVarPrefix()
Return the name prefix of variables containing per-function control data.
Definition: InstrProf.h:86
#define INT64_MIN
Definition: DataTypes.h:80
LLVMContext & getContext() const
Get the global data context.
Definition: Module.h:243
Instrumentation based profiling lowering pass.
ReturnInst * CreateRet(Value *V)
Create a &#39;ret <val>&#39; instruction.
Definition: IRBuilder.h:817
This provides a uniform API for creating instructions and inserting them into a basic block: either a...
Definition: IRBuilder.h:731
This file contains the simple types necessary to represent the attributes associated with functions a...
Error collectPGOFuncNameStrings(ArrayRef< std::string > NameStrs, bool doCompression, std::string &Result)
Given a vector of strings (function PGO names) NameStrs, the method generates a combined string Resul...
Definition: InstrProf.cpp:378
Value * CreateAdd(Value *LHS, Value *RHS, const Twine &Name="", bool HasNUW=false, bool HasNSW=false)
Definition: IRBuilder.h:962
StringRef getCoverageUnusedNamesVarName()
Return the name of the internal variable recording the array of PGO name vars referenced by the cover...
Definition: InstrProf.h:118
static StructType * get(LLVMContext &Context, ArrayRef< Type *> Elements, bool isPacked=false)
This static method is the primary way to create a literal StructType.
Definition: Type.cpp:336
StringRef getInstrProfNamesRegFuncName()
Return the name of the runtime interface that registers the PGO name strings.
Definition: InstrProf.h:138
StoreInst * CreateStore(Value *Val, Value *Ptr, bool isVolatile=false)
Definition: IRBuilder.h:1321
void getExitBlocks(SmallVectorImpl< BlockT *> &ExitBlocks) const
Return all of the successor blocks of this loop.
Definition: LoopInfoImpl.h:63
auto reverse(ContainerTy &&C, typename std::enable_if< has_rbegin< ContainerTy >::value >::type *=nullptr) -> decltype(make_range(C.rbegin(), C.rend()))
Definition: STLExtras.h:251
Value * CreateBitCast(Value *V, Type *DestTy, const Twine &Name="")
Definition: IRBuilder.h:1629
Type * getType() const
All values are typed, get the type of this value.
Definition: Value.h:245
void appendToUsed(Module &M, ArrayRef< GlobalValue *> Values)
Adds global values to the llvm.used list.
Class to represent array types.
Definition: DerivedTypes.h:369
LLVM_NODISCARD LLVM_ATTRIBUTE_ALWAYS_INLINE bool empty() const
empty - Check if the string is empty.
Definition: StringRef.h:133
Memory SSA
Definition: MemorySSA.cpp:66
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory)...
Definition: APInt.h:33
LinkageTypes getLinkage() const
Definition: GlobalValue.h:451
void replaceAllUsesWith(Value *V)
Change all uses of this to point to a new Value.
Definition: Value.cpp:439
LLVM_NODISCARD LLVM_ATTRIBUTE_ALWAYS_INLINE StringRef substr(size_t Start, size_t N=npos) const
Return a reference to the substring from [Start, Start + N).
Definition: StringRef.h:598
bool hasLinkOnceLinkage() const
Definition: GlobalValue.h:426
GlobalVariable * getName() const
PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM)
Concrete subclass of DominatorTreeBase that is used to compute a normal dominator tree...
Definition: Dominators.h:145
Value * getOperand(unsigned i) const
Definition: User.h:170
ConstantInt * getNumCounters() const
static PreservedAnalyses none()
Convenience factory function for the empty preserved set.
Definition: PassManager.h:157
bool isIRPGOFlagSet(const Module *M)
Check if INSTR_PROF_RAW_VERSION_VAR is defined.
Definition: InstrProf.cpp:951
static std::string getVarName(InstrProfIncrementInst *Inc, StringRef Prefix)
Get the name of a profiling variable for a particular function.
static Constant * getBitCast(Constant *C, Type *Ty, bool OnlyIfReduced=false)
Definition: Constants.cpp:1750
LoadInst * CreateLoad(Value *Ptr, const char *Name)
Provided to resolve &#39;CreateLoad(Ptr, "...")&#39; correctly, instead of converting the string to &#39;bool&#39; fo...
Definition: IRBuilder.h:1305
void getMemOPSizeRangeFromOption(StringRef Str, int64_t &RangeStart, int64_t &RangeLast)
Definition: InstrProf.cpp:994
bool needsComdatForCounter(const Function &F, const Module &M)
Check if we can use Comdat for profile variables.
Definition: InstrProf.cpp:925
Same, but only replaced by something equivalent.
Definition: GlobalValue.h:52
initializer< Ty > init(const Ty &Val)
Definition: CommandLine.h:410
static Function * Create(FunctionType *Ty, LinkageTypes Linkage, unsigned AddrSpace, const Twine &N="", Module *M=nullptr)
Definition: Function.h:136
uint64_t getZExtValue() const
Return the constant as a 64-bit unsigned integer value after it has been zero extended as appropriate...
Definition: Constants.h:149
A set of analyses that are preserved following a run of a transformation pass.
Definition: PassManager.h:154
* if(!EatIfPresent(lltok::kw_thread_local)) return false
ParseOptionalThreadLocal := /*empty.
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:218
static ConstantPointerNull * get(PointerType *T)
Static factory methods - Return objects of the specified value.
Definition: Constants.cpp:1378
VisibilityTypes getVisibility() const
Definition: GlobalValue.h:233
ConstantInt * getIndex() const
static Constant * getOrInsertValueProfilingCall(Module &M, const TargetLibraryInfo &TLI, bool IsRange=false)
LLVM Basic Block Representation.
Definition: BasicBlock.h:59
The instances of the Type class are immutable: once they are created, they are never changed...
Definition: Type.h:46
This is an important class for using LLVM in a threaded context.
Definition: LLVMContext.h:69
StringRef getInstrProfValueProfFuncName()
Return the name profile runtime entry point to do value profiling for a given site.
Definition: InstrProf.h:73
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
This is an important base class in LLVM.
Definition: Constant.h:42
ValueKind
Value kinds.
This file contains the declarations for the subclasses of Constant, which represent the different fla...
std::pair< iterator, bool > insert(PtrType Ptr)
Inserts Ptr if and only if there is no element in the container equal to Ptr.
Definition: SmallPtrSet.h:371
StringRef getInstrProfNamesVarName()
Return the name of the variable holding the strings (possibly compressed) of all function&#39;s PGO names...
Definition: InstrProf.h:103
void eraseFromParent()
eraseFromParent - This method unlinks &#39;this&#39; from the containing module and deletes it...
Definition: Globals.cpp:359
Represent the analysis usage information of a pass.
static Type * getVoidTy(LLVMContext &C)
Definition: Type.cpp:161
bool any_of(R &&Range, UnaryPredicate P)
Provide wrappers to std::any_of which take ranges instead of having to pass begin/end explicitly...
Definition: STLExtras.h:1049
static bool shouldRecordFunctionAddr(Function *F)
static FunctionType * get(Type *Result, ArrayRef< Type *> Params, bool isVarArg)
This static method is the primary way of constructing a FunctionType.
Definition: Type.cpp:297
static Constant * get(StructType *T, ArrayRef< Constant *> V)
Definition: Constants.cpp:1021
static BasicBlock * Create(LLVMContext &Context, const Twine &Name="", Function *Parent=nullptr, BasicBlock *InsertBefore=nullptr)
Creates a new BasicBlock.
Definition: BasicBlock.h:101
ConstantInt * getInt64(uint64_t C)
Get a constant 64-bit value.
Definition: IRBuilder.h:312
AtomicRMWInst * CreateAtomicRMW(AtomicRMWInst::BinOp Op, Value *Ptr, Value *Val, AtomicOrdering Ordering, SyncScope::ID SSID=SyncScope::System)
Definition: IRBuilder.h:1368
void getExitingBlocks(SmallVectorImpl< BlockT *> &ExitingBlocks) const
Return all blocks inside the loop that have successors outside of the loop.
Definition: LoopInfoImpl.h:35
StringRef toStringRef(bool B)
Construct a string ref from a boolean.
Definition: StringExtras.h:53
const Constant * stripPointerCasts() const
Definition: Constant.h:173
Comdat * getOrInsertComdat(StringRef Name)
Return the Comdat in the module with the specified name.
Definition: Module.cpp:477
static PreservedAnalyses all()
Construct a special preserved set that preserves all passes.
Definition: PassManager.h:160
static bool needsRuntimeRegistrationOfSectionRange(const Module &M)
size_t size() const
Definition: SmallVector.h:53
static PointerType * getInt8PtrTy(LLVMContext &C, unsigned AS=0)
Definition: Type.cpp:220
INITIALIZE_PASS_END(RegBankSelect, DEBUG_TYPE, "Assign register bank of generic virtual registers", false, false) RegBankSelect
Triple - Helper class for working with autoconf configuration names.
Definition: Triple.h:44
StringRef getInstrProfCountersVarPrefix()
Return the name prefix of profile counter variables.
Definition: InstrProf.h:89
unsigned getNumOperands() const
Definition: User.h:192
SmallPtrSet - This class implements a set which is optimized for holding SmallSize or less elements...
Definition: SmallPtrSet.h:418
Helper class for promoting a collection of loads and stores into SSA Form using the SSAUpdater...
Definition: SSAUpdater.h:133
This is a &#39;vector&#39; (really, a variable-sized array), optimized for the case when the array is small...
Definition: SmallVector.h:847
Module.h This file contains the declarations for the Module class.
Provides information about what library functions are available for the current target.
static Constant * get(Type *Ty, uint64_t V, bool isSigned=false)
If Ty is a vector type, return a Constant with a splat of the given value.
Definition: Constants.cpp:621
void appendToGlobalCtors(Module &M, Function *F, int Priority, Constant *Data=nullptr)
Append F to the list of global ctors of module M with the given Priority.
Definition: ModuleUtils.cpp:84
void setPreservesCFG()
This function should be called by the pass, iff they do not:
Definition: Pass.cpp:286
#define NC
Definition: regutils.h:42
void setLinkage(LinkageTypes LT)
Definition: GlobalValue.h:445
raw_ostream & dbgs()
dbgs() - This returns a reference to a raw_ostream for debugging messages.
Definition: Debug.cpp:133
Function * getFunction(StringRef Name) const
Look up the specified function in the module symbol table.
Definition: Module.cpp:175
ConstantArray - Constant Array Declarations.
Definition: Constants.h:410
StringRef getInstrProfRuntimeHookVarName()
Return the name of the hook variable defined in profile runtime library.
Definition: InstrProf.h:151
StringRef getInstrProfRegFuncName()
Return the name of the runtime interface that registers per-function control data for one instrumente...
Definition: InstrProf.h:133
Options for the frontend instrumentation based profiling pass.
bool hasComdat() const
Definition: GlobalObject.h:100
Value * CreateConstInBoundsGEP2_64(Value *Ptr, uint64_t Idx0, uint64_t Idx1, const Twine &Name="")
Definition: IRBuilder.h:1514
This represents the llvm.instrprof_increment intrinsic.
ReturnInst * CreateRetVoid()
Create a &#39;ret void&#39; instruction.
Definition: IRBuilder.h:812
static IntegerType * getInt32Ty(LLVMContext &C)
Definition: Type.cpp:176
Represents a single loop in the control flow graph.
Definition: LoopInfo.h:459
ConstantInt * getHash() const
StringRef getName() const
Return a constant reference to the value&#39;s name.
Definition: Value.cpp:224
const Function * getParent() const
Return the enclosing method, or null if none.
Definition: BasicBlock.h:108
#define I(x, y, z)
Definition: MD5.cpp:58
ModulePass class - This class is used to implement unstructured interprocedural optimizations and ana...
Definition: Pass.h:225
static ArrayType * get(Type *ElementType, uint64_t NumElements)
This static method is the primary way to construct an ArrayType.
Definition: Type.cpp:568
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:323
Keep one copy of named function when linking (weak)
Definition: GlobalValue.h:53
Rename collisions when linking (static functions).
Definition: GlobalValue.h:56
SmallVector< LoopT *, 4 > getLoopsInPreorder()
Return all of the loops in the function in preorder across the loop nests, with siblings in forward p...
Definition: LoopInfoImpl.h:580
Analysis pass providing the TargetLibraryInfo.
const unsigned Kind
bool hasAddressTaken(const User **=nullptr) const
hasAddressTaken - returns true if there are any uses of this function other than direct calls or invo...
Definition: Function.cpp:1255
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
StringRef getInstrProfValueRangeProfFuncName()
Return the name profile runtime entry point to do value range profiling.
Definition: InstrProf.h:78
aarch64 promote const
Module * getParent()
Get the module that this global value is contained inside of...
Definition: GlobalValue.h:566
LLVM Value Representation.
Definition: Value.h:73
StringRef getInstrProfVNodesVarName()
Return the name of value profile node array variables:
Definition: InstrProf.h:95
GlobalVariable * getName() const
Lightweight error class with error context and mandatory checking.
Definition: Error.h:158
ConstantInt * getValueKind() const
static Comdat * getOrCreateProfileComdat(Module &M, Function &F, InstrProfIncrementInst *Inc)
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:49
A container for analyses that lazily runs them and caches their results.
StringRef getInstrProfComdatPrefix()
Return the name prefix of the COMDAT group for instrumentation variables associated with a COMDAT fun...
Definition: InstrProf.h:99
const TerminatorInst * 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:138
static bool lowerIntrinsics(Module &M)
#define LLVM_DEBUG(X)
Definition: Debug.h:123
This represents the llvm.instrprof_value_profile intrinsic.
static InstrProfIncrementInst * castToIncrementInst(Instruction *Instr)
void setSection(StringRef S)
Change the section for this global.
Definition: Globals.cpp:189
bool use_empty() const
Definition: Value.h:323
constexpr char Args[]
Key for Kernel::Metadata::mArgs.
IntegerType * Int32Ty
INITIALIZE_PASS_BEGIN(InstrProfilingLegacyPass, "instrprof", "Frontend instrumentation-based coverage lowering.", false, false) INITIALIZE_PASS_END(InstrProfilingLegacyPass
const BasicBlock * getParent() const
Definition: Instruction.h:67
CallInst * CreateCall(Value *Callee, ArrayRef< Value *> Args=None, const Twine &Name="", MDNode *FPMathTag=nullptr)
Definition: IRBuilder.h:1871