LLVM  4.0.0
GCOVProfiling.cpp
Go to the documentation of this file.
1 //===- GCOVProfiling.cpp - Insert edge counters for gcov 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 implements GCOV-style profiling. When this pass is run it emits
11 // "gcno" files next to the existing source, and instruments the code that runs
12 // to records the edges between blocks that run and emit a complementary "gcda"
13 // file on exit.
14 //
15 //===----------------------------------------------------------------------===//
16 
17 #include "llvm/ADT/DenseMap.h"
18 #include "llvm/ADT/Hashing.h"
19 #include "llvm/ADT/STLExtras.h"
20 #include "llvm/ADT/Statistic.h"
21 #include "llvm/ADT/StringExtras.h"
22 #include "llvm/ADT/StringMap.h"
23 #include "llvm/ADT/UniqueVector.h"
24 #include "llvm/IR/DebugInfo.h"
25 #include "llvm/IR/DebugLoc.h"
26 #include "llvm/IR/IRBuilder.h"
27 #include "llvm/IR/InstIterator.h"
28 #include "llvm/IR/Instructions.h"
29 #include "llvm/IR/IntrinsicInst.h"
30 #include "llvm/IR/Module.h"
31 #include "llvm/Pass.h"
33 #include "llvm/Support/Debug.h"
35 #include "llvm/Support/Path.h"
40 #include <algorithm>
41 #include <memory>
42 #include <string>
43 #include <utility>
44 using namespace llvm;
45 
46 #define DEBUG_TYPE "insert-gcov-profiling"
47 
49 DefaultGCOVVersion("default-gcov-version", cl::init("402*"), cl::Hidden,
51 static cl::opt<bool> DefaultExitBlockBeforeBody("gcov-exit-block-before-body",
52  cl::init(false), cl::Hidden);
53 
55  GCOVOptions Options;
56  Options.EmitNotes = true;
57  Options.EmitData = true;
58  Options.UseCfgChecksum = false;
59  Options.NoRedZone = false;
60  Options.FunctionNamesInData = true;
62 
63  if (DefaultGCOVVersion.size() != 4) {
64  llvm::report_fatal_error(std::string("Invalid -default-gcov-version: ") +
66  }
67  memcpy(Options.Version, DefaultGCOVVersion.c_str(), 4);
68  return Options;
69 }
70 
71 namespace {
72 class GCOVFunction;
73 
74 class GCOVProfiler {
75 public:
76  GCOVProfiler() : GCOVProfiler(GCOVOptions::getDefault()) {}
77  GCOVProfiler(const GCOVOptions &Opts) : Options(Opts) {
78  assert((Options.EmitNotes || Options.EmitData) &&
79  "GCOVProfiler asked to do nothing?");
80  ReversedVersion[0] = Options.Version[3];
81  ReversedVersion[1] = Options.Version[2];
82  ReversedVersion[2] = Options.Version[1];
83  ReversedVersion[3] = Options.Version[0];
84  ReversedVersion[4] = '\0';
85  }
86  bool runOnModule(Module &M);
87 
88 private:
89  // Create the .gcno files for the Module based on DebugInfo.
90  void emitProfileNotes();
91 
92  // Modify the program to track transitions along edges and call into the
93  // profiling runtime to emit .gcda files when run.
94  bool emitProfileArcs();
95 
96  // Get pointers to the functions in the runtime library.
97  Constant *getStartFileFunc();
98  Constant *getIncrementIndirectCounterFunc();
99  Constant *getEmitFunctionFunc();
100  Constant *getEmitArcsFunc();
101  Constant *getSummaryInfoFunc();
102  Constant *getEndFileFunc();
103 
104  // Create or retrieve an i32 state value that is used to represent the
105  // pred block number for certain non-trivial edges.
106  GlobalVariable *getEdgeStateValue();
107 
108  // Produce a table of pointers to counters, by predecessor and successor
109  // block number.
110  GlobalVariable *buildEdgeLookupTable(Function *F, GlobalVariable *Counter,
111  const UniqueVector<BasicBlock *> &Preds,
112  const UniqueVector<BasicBlock *> &Succs);
113 
114  // Add the function to write out all our counters to the global destructor
115  // list.
116  Function *
117  insertCounterWriteout(ArrayRef<std::pair<GlobalVariable *, MDNode *>>);
118  Function *insertFlush(ArrayRef<std::pair<GlobalVariable *, MDNode *>>);
119  void insertIndirectCounterIncrement();
120 
121  enum class GCovFileType { GCNO, GCDA };
122  std::string mangleName(const DICompileUnit *CU, GCovFileType FileType);
123 
124  GCOVOptions Options;
125 
126  // Reversed, NUL-terminated copy of Options.Version.
127  char ReversedVersion[5];
128  // Checksum, produced by hash of EdgeDestinations
130 
131  Module *M;
132  LLVMContext *Ctx;
134 };
135 
136 class GCOVProfilerLegacyPass : public ModulePass {
137 public:
138  static char ID;
139  GCOVProfilerLegacyPass()
140  : GCOVProfilerLegacyPass(GCOVOptions::getDefault()) {}
141  GCOVProfilerLegacyPass(const GCOVOptions &Opts)
142  : ModulePass(ID), Profiler(Opts) {
144  }
145  StringRef getPassName() const override { return "GCOV Profiler"; }
146 
147  bool runOnModule(Module &M) override { return Profiler.runOnModule(M); }
148 
149 private:
150  GCOVProfiler Profiler;
151 };
152 }
153 
155 INITIALIZE_PASS(GCOVProfilerLegacyPass, "insert-gcov-profiling",
156  "Insert instrumentation for GCOV profiling", false, false)
157 
159  return new GCOVProfilerLegacyPass(Options);
160 }
161 
163  if (!SP->getLinkageName().empty())
164  return SP->getLinkageName();
165  return SP->getName();
166 }
167 
168 namespace {
169  class GCOVRecord {
170  protected:
171  static const char *const LinesTag;
172  static const char *const FunctionTag;
173  static const char *const BlockTag;
174  static const char *const EdgeTag;
175 
176  GCOVRecord() = default;
177 
178  void writeBytes(const char *Bytes, int Size) {
179  os->write(Bytes, Size);
180  }
181 
182  void write(uint32_t i) {
183  writeBytes(reinterpret_cast<char*>(&i), 4);
184  }
185 
186  // Returns the length measured in 4-byte blocks that will be used to
187  // represent this string in a GCOV file
188  static unsigned lengthOfGCOVString(StringRef s) {
189  // A GCOV string is a length, followed by a NUL, then between 0 and 3 NULs
190  // padding out to the next 4-byte word. The length is measured in 4-byte
191  // words including padding, not bytes of actual string.
192  return (s.size() / 4) + 1;
193  }
194 
195  void writeGCOVString(StringRef s) {
196  uint32_t Len = lengthOfGCOVString(s);
197  write(Len);
198  writeBytes(s.data(), s.size());
199 
200  // Write 1 to 4 bytes of NUL padding.
201  assert((unsigned)(4 - (s.size() % 4)) > 0);
202  assert((unsigned)(4 - (s.size() % 4)) <= 4);
203  writeBytes("\0\0\0\0", 4 - (s.size() % 4));
204  }
205 
206  raw_ostream *os;
207  };
208  const char *const GCOVRecord::LinesTag = "\0\0\x45\x01";
209  const char *const GCOVRecord::FunctionTag = "\0\0\0\1";
210  const char *const GCOVRecord::BlockTag = "\0\0\x41\x01";
211  const char *const GCOVRecord::EdgeTag = "\0\0\x43\x01";
212 
213  class GCOVFunction;
214  class GCOVBlock;
215 
216  // Constructed only by requesting it from a GCOVBlock, this object stores a
217  // list of line numbers and a single filename, representing lines that belong
218  // to the block.
219  class GCOVLines : public GCOVRecord {
220  public:
221  void addLine(uint32_t Line) {
222  assert(Line != 0 && "Line zero is not a valid real line number.");
223  Lines.push_back(Line);
224  }
225 
226  uint32_t length() const {
227  // Here 2 = 1 for string length + 1 for '0' id#.
228  return lengthOfGCOVString(Filename) + 2 + Lines.size();
229  }
230 
231  void writeOut() {
232  write(0);
233  writeGCOVString(Filename);
234  for (int i = 0, e = Lines.size(); i != e; ++i)
235  write(Lines[i]);
236  }
237 
238  GCOVLines(StringRef F, raw_ostream *os)
239  : Filename(F) {
240  this->os = os;
241  }
242 
243  private:
244  StringRef Filename;
246  };
247 
248 
249  // Represent a basic block in GCOV. Each block has a unique number in the
250  // function, number of lines belonging to each block, and a set of edges to
251  // other blocks.
252  class GCOVBlock : public GCOVRecord {
253  public:
254  GCOVLines &getFile(StringRef Filename) {
255  return LinesByFile.try_emplace(Filename, Filename, os).first->second;
256  }
257 
258  void addEdge(GCOVBlock &Successor) {
259  OutEdges.push_back(&Successor);
260  }
261 
262  void writeOut() {
263  uint32_t Len = 3;
264  SmallVector<StringMapEntry<GCOVLines> *, 32> SortedLinesByFile;
265  for (auto &I : LinesByFile) {
266  Len += I.second.length();
267  SortedLinesByFile.push_back(&I);
268  }
269 
270  writeBytes(LinesTag, 4);
271  write(Len);
272  write(Number);
273 
274  std::sort(
275  SortedLinesByFile.begin(), SortedLinesByFile.end(),
277  return LHS->getKey() < RHS->getKey();
278  });
279  for (auto &I : SortedLinesByFile)
280  I->getValue().writeOut();
281  write(0);
282  write(0);
283  }
284 
285  GCOVBlock(const GCOVBlock &RHS) : GCOVRecord(RHS), Number(RHS.Number) {
286  // Only allow copy before edges and lines have been added. After that,
287  // there are inter-block pointers (eg: edges) that won't take kindly to
288  // blocks being copied or moved around.
289  assert(LinesByFile.empty());
290  assert(OutEdges.empty());
291  }
292 
293  private:
294  friend class GCOVFunction;
295 
296  GCOVBlock(uint32_t Number, raw_ostream *os)
297  : Number(Number) {
298  this->os = os;
299  }
300 
301  uint32_t Number;
302  StringMap<GCOVLines> LinesByFile;
304  };
305 
306  // A function has a unique identifier, a checksum (we leave as zero) and a
307  // set of blocks and a map of edges between blocks. This is the only GCOV
308  // object users can construct, the blocks and lines will be rooted here.
309  class GCOVFunction : public GCOVRecord {
310  public:
312  uint32_t Ident, bool UseCfgChecksum, bool ExitBlockBeforeBody)
313  : SP(SP), Ident(Ident), UseCfgChecksum(UseCfgChecksum), CfgChecksum(0),
314  ReturnBlock(1, os) {
315  this->os = os;
316 
317  DEBUG(dbgs() << "Function: " << getFunctionName(SP) << "\n");
318 
319  uint32_t i = 0;
320  for (auto &BB : *F) {
321  // Skip index 1 if it's assigned to the ReturnBlock.
322  if (i == 1 && ExitBlockBeforeBody)
323  ++i;
324  Blocks.insert(std::make_pair(&BB, GCOVBlock(i++, os)));
325  }
326  if (!ExitBlockBeforeBody)
327  ReturnBlock.Number = i;
328 
329  std::string FunctionNameAndLine;
330  raw_string_ostream FNLOS(FunctionNameAndLine);
331  FNLOS << getFunctionName(SP) << SP->getLine();
332  FNLOS.flush();
333  FuncChecksum = hash_value(FunctionNameAndLine);
334  }
335 
336  GCOVBlock &getBlock(BasicBlock *BB) {
337  return Blocks.find(BB)->second;
338  }
339 
340  GCOVBlock &getReturnBlock() {
341  return ReturnBlock;
342  }
343 
344  std::string getEdgeDestinations() {
345  std::string EdgeDestinations;
346  raw_string_ostream EDOS(EdgeDestinations);
347  Function *F = Blocks.begin()->first->getParent();
348  for (BasicBlock &I : *F) {
349  GCOVBlock &Block = getBlock(&I);
350  for (int i = 0, e = Block.OutEdges.size(); i != e; ++i)
351  EDOS << Block.OutEdges[i]->Number;
352  }
353  return EdgeDestinations;
354  }
355 
356  uint32_t getFuncChecksum() {
357  return FuncChecksum;
358  }
359 
360  void setCfgChecksum(uint32_t Checksum) {
361  CfgChecksum = Checksum;
362  }
363 
364  void writeOut() {
365  writeBytes(FunctionTag, 4);
366  uint32_t BlockLen = 1 + 1 + 1 + lengthOfGCOVString(getFunctionName(SP)) +
367  1 + lengthOfGCOVString(SP->getFilename()) + 1;
368  if (UseCfgChecksum)
369  ++BlockLen;
370  write(BlockLen);
371  write(Ident);
372  write(FuncChecksum);
373  if (UseCfgChecksum)
374  write(CfgChecksum);
375  writeGCOVString(getFunctionName(SP));
376  writeGCOVString(SP->getFilename());
377  write(SP->getLine());
378 
379  // Emit count of blocks.
380  writeBytes(BlockTag, 4);
381  write(Blocks.size() + 1);
382  for (int i = 0, e = Blocks.size() + 1; i != e; ++i) {
383  write(0); // No flags on our blocks.
384  }
385  DEBUG(dbgs() << Blocks.size() << " blocks.\n");
386 
387  // Emit edges between blocks.
388  if (Blocks.empty()) return;
389  Function *F = Blocks.begin()->first->getParent();
390  for (BasicBlock &I : *F) {
391  GCOVBlock &Block = getBlock(&I);
392  if (Block.OutEdges.empty()) continue;
393 
394  writeBytes(EdgeTag, 4);
395  write(Block.OutEdges.size() * 2 + 1);
396  write(Block.Number);
397  for (int i = 0, e = Block.OutEdges.size(); i != e; ++i) {
398  DEBUG(dbgs() << Block.Number << " -> " << Block.OutEdges[i]->Number
399  << "\n");
400  write(Block.OutEdges[i]->Number);
401  write(0); // no flags
402  }
403  }
404 
405  // Emit lines for each block.
406  for (BasicBlock &I : *F)
407  getBlock(&I).writeOut();
408  }
409 
410  private:
411  const DISubprogram *SP;
412  uint32_t Ident;
413  uint32_t FuncChecksum;
414  bool UseCfgChecksum;
415  uint32_t CfgChecksum;
417  GCOVBlock ReturnBlock;
418  };
419 }
420 
421 std::string GCOVProfiler::mangleName(const DICompileUnit *CU,
422  GCovFileType OutputType) {
423  bool Notes = OutputType == GCovFileType::GCNO;
424 
425  if (NamedMDNode *GCov = M->getNamedMetadata("llvm.gcov")) {
426  for (int i = 0, e = GCov->getNumOperands(); i != e; ++i) {
427  MDNode *N = GCov->getOperand(i);
428  bool ThreeElement = N->getNumOperands() == 3;
429  if (!ThreeElement && N->getNumOperands() != 2)
430  continue;
431  if (dyn_cast<MDNode>(N->getOperand(ThreeElement ? 2 : 1)) != CU)
432  continue;
433 
434  if (ThreeElement) {
435  // These nodes have no mangling to apply, it's stored mangled in the
436  // bitcode.
437  MDString *NotesFile = dyn_cast<MDString>(N->getOperand(0));
438  MDString *DataFile = dyn_cast<MDString>(N->getOperand(1));
439  if (!NotesFile || !DataFile)
440  continue;
441  return Notes ? NotesFile->getString() : DataFile->getString();
442  }
443 
444  MDString *GCovFile = dyn_cast<MDString>(N->getOperand(0));
445  if (!GCovFile)
446  continue;
447 
448  SmallString<128> Filename = GCovFile->getString();
449  sys::path::replace_extension(Filename, Notes ? "gcno" : "gcda");
450  return Filename.str();
451  }
452  }
453 
454  SmallString<128> Filename = CU->getFilename();
455  sys::path::replace_extension(Filename, Notes ? "gcno" : "gcda");
456  StringRef FName = sys::path::filename(Filename);
457  SmallString<128> CurPath;
458  if (sys::fs::current_path(CurPath)) return FName;
459  sys::path::append(CurPath, FName);
460  return CurPath.str();
461 }
462 
463 bool GCOVProfiler::runOnModule(Module &M) {
464  this->M = &M;
465  Ctx = &M.getContext();
466 
467  if (Options.EmitNotes) emitProfileNotes();
468  if (Options.EmitData) return emitProfileArcs();
469  return false;
470 }
471 
473  ModuleAnalysisManager &AM) {
474 
475  GCOVProfiler Profiler(GCOVOpts);
476 
477  if (!Profiler.runOnModule(M))
478  return PreservedAnalyses::all();
479 
480  return PreservedAnalyses::none();
481 }
482 
483 static bool functionHasLines(Function &F) {
484  // Check whether this function actually has any source lines. Not only
485  // do these waste space, they also can crash gcov.
486  for (auto &BB : F) {
487  for (auto &I : BB) {
488  // Debug intrinsic locations correspond to the location of the
489  // declaration, not necessarily any statements or expressions.
490  if (isa<DbgInfoIntrinsic>(&I)) continue;
491 
492  const DebugLoc &Loc = I.getDebugLoc();
493  if (!Loc)
494  continue;
495 
496  // Artificial lines such as calls to the global constructors.
497  if (Loc.getLine() == 0) continue;
498 
499  return true;
500  }
501  }
502  return false;
503 }
504 
505 void GCOVProfiler::emitProfileNotes() {
506  NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu");
507  if (!CU_Nodes) return;
508 
509  for (unsigned i = 0, e = CU_Nodes->getNumOperands(); i != e; ++i) {
510  // Each compile unit gets its own .gcno file. This means that whether we run
511  // this pass over the original .o's as they're produced, or run it after
512  // LTO, we'll generate the same .gcno files.
513 
514  auto *CU = cast<DICompileUnit>(CU_Nodes->getOperand(i));
515 
516  // Skip module skeleton (and module) CUs.
517  if (CU->getDWOId())
518  continue;
519 
520  std::error_code EC;
521  raw_fd_ostream out(mangleName(CU, GCovFileType::GCNO), EC, sys::fs::F_None);
522  std::string EdgeDestinations;
523 
524  unsigned FunctionIdent = 0;
525  for (auto &F : M->functions()) {
526  DISubprogram *SP = F.getSubprogram();
527  if (!SP) continue;
528  if (!functionHasLines(F)) continue;
529 
530  // gcov expects every function to start with an entry block that has a
531  // single successor, so split the entry block to make sure of that.
532  BasicBlock &EntryBlock = F.getEntryBlock();
533  BasicBlock::iterator It = EntryBlock.begin();
534  while (isa<AllocaInst>(*It) || isa<DbgInfoIntrinsic>(*It))
535  ++It;
536  EntryBlock.splitBasicBlock(It);
537 
538  Funcs.push_back(make_unique<GCOVFunction>(SP, &F, &out, FunctionIdent++,
539  Options.UseCfgChecksum,
540  Options.ExitBlockBeforeBody));
541  GCOVFunction &Func = *Funcs.back();
542 
543  for (auto &BB : F) {
544  GCOVBlock &Block = Func.getBlock(&BB);
545  TerminatorInst *TI = BB.getTerminator();
546  if (int successors = TI->getNumSuccessors()) {
547  for (int i = 0; i != successors; ++i) {
548  Block.addEdge(Func.getBlock(TI->getSuccessor(i)));
549  }
550  } else if (isa<ReturnInst>(TI)) {
551  Block.addEdge(Func.getReturnBlock());
552  }
553 
554  uint32_t Line = 0;
555  for (auto &I : BB) {
556  // Debug intrinsic locations correspond to the location of the
557  // declaration, not necessarily any statements or expressions.
558  if (isa<DbgInfoIntrinsic>(&I)) continue;
559 
560  const DebugLoc &Loc = I.getDebugLoc();
561  if (!Loc)
562  continue;
563 
564  // Artificial lines such as calls to the global constructors.
565  if (Loc.getLine() == 0) continue;
566 
567  if (Line == Loc.getLine()) continue;
568  Line = Loc.getLine();
569  if (SP != getDISubprogram(Loc.getScope()))
570  continue;
571 
572  GCOVLines &Lines = Block.getFile(SP->getFilename());
573  Lines.addLine(Loc.getLine());
574  }
575  }
576  EdgeDestinations += Func.getEdgeDestinations();
577  }
578 
579  FileChecksums.push_back(hash_value(EdgeDestinations));
580  out.write("oncg", 4);
581  out.write(ReversedVersion, 4);
582  out.write(reinterpret_cast<char*>(&FileChecksums.back()), 4);
583 
584  for (auto &Func : Funcs) {
585  Func->setCfgChecksum(FileChecksums.back());
586  Func->writeOut();
587  }
588 
589  out.write("\0\0\0\0\0\0\0\0", 8); // EOF
590  out.close();
591  }
592 }
593 
594 bool GCOVProfiler::emitProfileArcs() {
595  NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu");
596  if (!CU_Nodes) return false;
597 
598  bool Result = false;
599  bool InsertIndCounterIncrCode = false;
600  for (unsigned i = 0, e = CU_Nodes->getNumOperands(); i != e; ++i) {
602  for (auto &F : M->functions()) {
603  DISubprogram *SP = F.getSubprogram();
604  if (!SP) continue;
605  if (!functionHasLines(F)) continue;
606  if (!Result) Result = true;
607  unsigned Edges = 0;
608  for (auto &BB : F) {
609  TerminatorInst *TI = BB.getTerminator();
610  if (isa<ReturnInst>(TI))
611  ++Edges;
612  else
613  Edges += TI->getNumSuccessors();
614  }
615 
616  ArrayType *CounterTy =
617  ArrayType::get(Type::getInt64Ty(*Ctx), Edges);
618  GlobalVariable *Counters =
619  new GlobalVariable(*M, CounterTy, false,
621  Constant::getNullValue(CounterTy),
622  "__llvm_gcov_ctr");
623  CountersBySP.push_back(std::make_pair(Counters, SP));
624 
625  UniqueVector<BasicBlock *> ComplexEdgePreds;
626  UniqueVector<BasicBlock *> ComplexEdgeSuccs;
627 
628  unsigned Edge = 0;
629  for (auto &BB : F) {
630  TerminatorInst *TI = BB.getTerminator();
631  int Successors = isa<ReturnInst>(TI) ? 1 : TI->getNumSuccessors();
632  if (Successors) {
633  if (Successors == 1) {
634  IRBuilder<> Builder(&*BB.getFirstInsertionPt());
635  Value *Counter = Builder.CreateConstInBoundsGEP2_64(Counters, 0,
636  Edge);
637  Value *Count = Builder.CreateLoad(Counter);
638  Count = Builder.CreateAdd(Count, Builder.getInt64(1));
639  Builder.CreateStore(Count, Counter);
640  } else if (BranchInst *BI = dyn_cast<BranchInst>(TI)) {
641  IRBuilder<> Builder(BI);
642  Value *Sel = Builder.CreateSelect(BI->getCondition(),
643  Builder.getInt64(Edge),
644  Builder.getInt64(Edge + 1));
645  Value *Counter = Builder.CreateInBoundsGEP(
646  Counters->getValueType(), Counters, {Builder.getInt64(0), Sel});
647  Value *Count = Builder.CreateLoad(Counter);
648  Count = Builder.CreateAdd(Count, Builder.getInt64(1));
649  Builder.CreateStore(Count, Counter);
650  } else {
651  ComplexEdgePreds.insert(&BB);
652  for (int i = 0; i != Successors; ++i)
653  ComplexEdgeSuccs.insert(TI->getSuccessor(i));
654  }
655 
656  Edge += Successors;
657  }
658  }
659 
660  if (!ComplexEdgePreds.empty()) {
661  GlobalVariable *EdgeTable =
662  buildEdgeLookupTable(&F, Counters,
663  ComplexEdgePreds, ComplexEdgeSuccs);
664  GlobalVariable *EdgeState = getEdgeStateValue();
665 
666  for (int i = 0, e = ComplexEdgePreds.size(); i != e; ++i) {
667  IRBuilder<> Builder(&*ComplexEdgePreds[i + 1]->getFirstInsertionPt());
668  Builder.CreateStore(Builder.getInt32(i), EdgeState);
669  }
670 
671  for (int i = 0, e = ComplexEdgeSuccs.size(); i != e; ++i) {
672  // Call runtime to perform increment.
673  IRBuilder<> Builder(&*ComplexEdgeSuccs[i + 1]->getFirstInsertionPt());
674  Value *CounterPtrArray =
675  Builder.CreateConstInBoundsGEP2_64(EdgeTable, 0,
676  i * ComplexEdgePreds.size());
677 
678  // Build code to increment the counter.
679  InsertIndCounterIncrCode = true;
680  Builder.CreateCall(getIncrementIndirectCounterFunc(),
681  {EdgeState, CounterPtrArray});
682  }
683  }
684  }
685 
686  Function *WriteoutF = insertCounterWriteout(CountersBySP);
687  Function *FlushF = insertFlush(CountersBySP);
688 
689  // Create a small bit of code that registers the "__llvm_gcov_writeout" to
690  // be executed at exit and the "__llvm_gcov_flush" function to be executed
691  // when "__gcov_flush" is called.
692  FunctionType *FTy = FunctionType::get(Type::getVoidTy(*Ctx), false);
694  "__llvm_gcov_init", M);
697  F->addFnAttr(Attribute::NoInline);
698  if (Options.NoRedZone)
699  F->addFnAttr(Attribute::NoRedZone);
700 
701  BasicBlock *BB = BasicBlock::Create(*Ctx, "entry", F);
702  IRBuilder<> Builder(BB);
703 
704  FTy = FunctionType::get(Type::getVoidTy(*Ctx), false);
705  Type *Params[] = {
706  PointerType::get(FTy, 0),
707  PointerType::get(FTy, 0)
708  };
709  FTy = FunctionType::get(Builder.getVoidTy(), Params, false);
710 
711  // Initialize the environment and register the local writeout and flush
712  // functions.
713  Constant *GCOVInit = M->getOrInsertFunction("llvm_gcov_init", FTy);
714  Builder.CreateCall(GCOVInit, {WriteoutF, FlushF});
715  Builder.CreateRetVoid();
716 
717  appendToGlobalCtors(*M, F, 0);
718  }
719 
720  if (InsertIndCounterIncrCode)
721  insertIndirectCounterIncrement();
722 
723  return Result;
724 }
725 
726 // All edges with successors that aren't branches are "complex", because it
727 // requires complex logic to pick which counter to update.
728 GlobalVariable *GCOVProfiler::buildEdgeLookupTable(
729  Function *F,
730  GlobalVariable *Counters,
731  const UniqueVector<BasicBlock *> &Preds,
732  const UniqueVector<BasicBlock *> &Succs) {
733  // TODO: support invoke, threads. We rely on the fact that nothing can modify
734  // the whole-Module pred edge# between the time we set it and the time we next
735  // read it. Threads and invoke make this untrue.
736 
737  // emit [(succs * preds) x i64*], logically [succ x [pred x i64*]].
738  size_t TableSize = Succs.size() * Preds.size();
739  Type *Int64PtrTy = Type::getInt64PtrTy(*Ctx);
740  ArrayType *EdgeTableTy = ArrayType::get(Int64PtrTy, TableSize);
741 
742  std::unique_ptr<Constant * []> EdgeTable(new Constant *[TableSize]);
743  Constant *NullValue = Constant::getNullValue(Int64PtrTy);
744  for (size_t i = 0; i != TableSize; ++i)
745  EdgeTable[i] = NullValue;
746 
747  unsigned Edge = 0;
748  for (BasicBlock &BB : *F) {
749  TerminatorInst *TI = BB.getTerminator();
750  int Successors = isa<ReturnInst>(TI) ? 1 : TI->getNumSuccessors();
751  if (Successors > 1 && !isa<BranchInst>(TI) && !isa<ReturnInst>(TI)) {
752  for (int i = 0; i != Successors; ++i) {
753  BasicBlock *Succ = TI->getSuccessor(i);
754  IRBuilder<> Builder(Succ);
755  Value *Counter = Builder.CreateConstInBoundsGEP2_64(Counters, 0,
756  Edge + i);
757  EdgeTable[((Succs.idFor(Succ) - 1) * Preds.size()) +
758  (Preds.idFor(&BB) - 1)] = cast<Constant>(Counter);
759  }
760  }
761  Edge += Successors;
762  }
763 
764  GlobalVariable *EdgeTableGV =
765  new GlobalVariable(
766  *M, EdgeTableTy, true, GlobalValue::InternalLinkage,
767  ConstantArray::get(EdgeTableTy,
768  makeArrayRef(&EdgeTable[0],TableSize)),
769  "__llvm_gcda_edge_table");
771  return EdgeTableGV;
772 }
773 
774 Constant *GCOVProfiler::getStartFileFunc() {
775  Type *Args[] = {
776  Type::getInt8PtrTy(*Ctx), // const char *orig_filename
777  Type::getInt8PtrTy(*Ctx), // const char version[4]
778  Type::getInt32Ty(*Ctx), // uint32_t checksum
779  };
780  FunctionType *FTy = FunctionType::get(Type::getVoidTy(*Ctx), Args, false);
781  return M->getOrInsertFunction("llvm_gcda_start_file", FTy);
782 }
783 
784 Constant *GCOVProfiler::getIncrementIndirectCounterFunc() {
785  Type *Int32Ty = Type::getInt32Ty(*Ctx);
786  Type *Int64Ty = Type::getInt64Ty(*Ctx);
787  Type *Args[] = {
788  Int32Ty->getPointerTo(), // uint32_t *predecessor
789  Int64Ty->getPointerTo()->getPointerTo() // uint64_t **counters
790  };
791  FunctionType *FTy = FunctionType::get(Type::getVoidTy(*Ctx), Args, false);
792  return M->getOrInsertFunction("__llvm_gcov_indirect_counter_increment", FTy);
793 }
794 
795 Constant *GCOVProfiler::getEmitFunctionFunc() {
796  Type *Args[] = {
797  Type::getInt32Ty(*Ctx), // uint32_t ident
798  Type::getInt8PtrTy(*Ctx), // const char *function_name
799  Type::getInt32Ty(*Ctx), // uint32_t func_checksum
800  Type::getInt8Ty(*Ctx), // uint8_t use_extra_checksum
801  Type::getInt32Ty(*Ctx), // uint32_t cfg_checksum
802  };
803  FunctionType *FTy = FunctionType::get(Type::getVoidTy(*Ctx), Args, false);
804  return M->getOrInsertFunction("llvm_gcda_emit_function", FTy);
805 }
806 
807 Constant *GCOVProfiler::getEmitArcsFunc() {
808  Type *Args[] = {
809  Type::getInt32Ty(*Ctx), // uint32_t num_counters
810  Type::getInt64PtrTy(*Ctx), // uint64_t *counters
811  };
812  FunctionType *FTy = FunctionType::get(Type::getVoidTy(*Ctx), Args, false);
813  return M->getOrInsertFunction("llvm_gcda_emit_arcs", FTy);
814 }
815 
816 Constant *GCOVProfiler::getSummaryInfoFunc() {
817  FunctionType *FTy = FunctionType::get(Type::getVoidTy(*Ctx), false);
818  return M->getOrInsertFunction("llvm_gcda_summary_info", FTy);
819 }
820 
821 Constant *GCOVProfiler::getEndFileFunc() {
822  FunctionType *FTy = FunctionType::get(Type::getVoidTy(*Ctx), false);
823  return M->getOrInsertFunction("llvm_gcda_end_file", FTy);
824 }
825 
826 GlobalVariable *GCOVProfiler::getEdgeStateValue() {
827  GlobalVariable *GV = M->getGlobalVariable("__llvm_gcov_global_state_pred");
828  if (!GV) {
829  GV = new GlobalVariable(*M, Type::getInt32Ty(*Ctx), false,
832  0xffffffff),
833  "__llvm_gcov_global_state_pred");
835  }
836  return GV;
837 }
838 
839 Function *GCOVProfiler::insertCounterWriteout(
840  ArrayRef<std::pair<GlobalVariable *, MDNode *> > CountersBySP) {
841  FunctionType *WriteoutFTy = FunctionType::get(Type::getVoidTy(*Ctx), false);
842  Function *WriteoutF = M->getFunction("__llvm_gcov_writeout");
843  if (!WriteoutF)
844  WriteoutF = Function::Create(WriteoutFTy, GlobalValue::InternalLinkage,
845  "__llvm_gcov_writeout", M);
847  WriteoutF->addFnAttr(Attribute::NoInline);
848  if (Options.NoRedZone)
849  WriteoutF->addFnAttr(Attribute::NoRedZone);
850 
851  BasicBlock *BB = BasicBlock::Create(*Ctx, "entry", WriteoutF);
852  IRBuilder<> Builder(BB);
853 
854  Constant *StartFile = getStartFileFunc();
855  Constant *EmitFunction = getEmitFunctionFunc();
856  Constant *EmitArcs = getEmitArcsFunc();
857  Constant *SummaryInfo = getSummaryInfoFunc();
858  Constant *EndFile = getEndFileFunc();
859 
860  NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu");
861  if (CU_Nodes) {
862  for (unsigned i = 0, e = CU_Nodes->getNumOperands(); i != e; ++i) {
863  auto *CU = cast<DICompileUnit>(CU_Nodes->getOperand(i));
864 
865  // Skip module skeleton (and module) CUs.
866  if (CU->getDWOId())
867  continue;
868 
869  std::string FilenameGcda = mangleName(CU, GCovFileType::GCDA);
870  uint32_t CfgChecksum = FileChecksums.empty() ? 0 : FileChecksums[i];
871  Builder.CreateCall(StartFile,
872  {Builder.CreateGlobalStringPtr(FilenameGcda),
873  Builder.CreateGlobalStringPtr(ReversedVersion),
874  Builder.getInt32(CfgChecksum)});
875  for (unsigned j = 0, e = CountersBySP.size(); j != e; ++j) {
876  auto *SP = cast_or_null<DISubprogram>(CountersBySP[j].second);
877  uint32_t FuncChecksum = Funcs.empty() ? 0 : Funcs[j]->getFuncChecksum();
878  Builder.CreateCall(
879  EmitFunction,
880  {Builder.getInt32(j),
881  Options.FunctionNamesInData
882  ? Builder.CreateGlobalStringPtr(getFunctionName(SP))
883  : Constant::getNullValue(Builder.getInt8PtrTy()),
884  Builder.getInt32(FuncChecksum),
885  Builder.getInt8(Options.UseCfgChecksum),
886  Builder.getInt32(CfgChecksum)});
887 
888  GlobalVariable *GV = CountersBySP[j].first;
889  unsigned Arcs =
890  cast<ArrayType>(GV->getValueType())->getNumElements();
891  Builder.CreateCall(EmitArcs, {Builder.getInt32(Arcs),
892  Builder.CreateConstGEP2_64(GV, 0, 0)});
893  }
894  Builder.CreateCall(SummaryInfo, {});
895  Builder.CreateCall(EndFile, {});
896  }
897  }
898 
899  Builder.CreateRetVoid();
900  return WriteoutF;
901 }
902 
903 void GCOVProfiler::insertIndirectCounterIncrement() {
904  Function *Fn =
905  cast<Function>(GCOVProfiler::getIncrementIndirectCounterFunc());
908  Fn->addFnAttr(Attribute::NoInline);
909  if (Options.NoRedZone)
910  Fn->addFnAttr(Attribute::NoRedZone);
911 
912  // Create basic blocks for function.
913  BasicBlock *BB = BasicBlock::Create(*Ctx, "entry", Fn);
914  IRBuilder<> Builder(BB);
915 
916  BasicBlock *PredNotNegOne = BasicBlock::Create(*Ctx, "", Fn);
917  BasicBlock *CounterEnd = BasicBlock::Create(*Ctx, "", Fn);
918  BasicBlock *Exit = BasicBlock::Create(*Ctx, "exit", Fn);
919 
920  // uint32_t pred = *predecessor;
921  // if (pred == 0xffffffff) return;
922  Argument *Arg = &*Fn->arg_begin();
923  Arg->setName("predecessor");
924  Value *Pred = Builder.CreateLoad(Arg, "pred");
925  Value *Cond = Builder.CreateICmpEQ(Pred, Builder.getInt32(0xffffffff));
926  BranchInst::Create(Exit, PredNotNegOne, Cond, BB);
927 
928  Builder.SetInsertPoint(PredNotNegOne);
929 
930  // uint64_t *counter = counters[pred];
931  // if (!counter) return;
932  Value *ZExtPred = Builder.CreateZExt(Pred, Builder.getInt64Ty());
933  Arg = &*std::next(Fn->arg_begin());
934  Arg->setName("counters");
935  Value *GEP = Builder.CreateGEP(Type::getInt64PtrTy(*Ctx), Arg, ZExtPred);
936  Value *Counter = Builder.CreateLoad(GEP, "counter");
937  Cond = Builder.CreateICmpEQ(Counter,
939  Builder.getInt64Ty()->getPointerTo()));
940  Builder.CreateCondBr(Cond, Exit, CounterEnd);
941 
942  // ++*counter;
943  Builder.SetInsertPoint(CounterEnd);
944  Value *Add = Builder.CreateAdd(Builder.CreateLoad(Counter),
945  Builder.getInt64(1));
946  Builder.CreateStore(Add, Counter);
947  Builder.CreateBr(Exit);
948 
949  // Fill in the exit block.
950  Builder.SetInsertPoint(Exit);
951  Builder.CreateRetVoid();
952 }
953 
954 Function *GCOVProfiler::
955 insertFlush(ArrayRef<std::pair<GlobalVariable*, MDNode*> > CountersBySP) {
956  FunctionType *FTy = FunctionType::get(Type::getVoidTy(*Ctx), false);
957  Function *FlushF = M->getFunction("__llvm_gcov_flush");
958  if (!FlushF)
960  "__llvm_gcov_flush", M);
961  else
964  FlushF->addFnAttr(Attribute::NoInline);
965  if (Options.NoRedZone)
966  FlushF->addFnAttr(Attribute::NoRedZone);
967 
968  BasicBlock *Entry = BasicBlock::Create(*Ctx, "entry", FlushF);
969 
970  // Write out the current counters.
971  Constant *WriteoutF = M->getFunction("__llvm_gcov_writeout");
972  assert(WriteoutF && "Need to create the writeout function first!");
973 
974  IRBuilder<> Builder(Entry);
975  Builder.CreateCall(WriteoutF, {});
976 
977  // Zero out the counters.
978  for (const auto &I : CountersBySP) {
979  GlobalVariable *GV = I.first;
981  Builder.CreateStore(Null, GV);
982  }
983 
984  Type *RetTy = FlushF->getReturnType();
985  if (RetTy == Type::getVoidTy(*Ctx))
986  Builder.CreateRetVoid();
987  else if (RetTy->isIntegerTy())
988  // Used if __llvm_gcov_flush was implicitly declared.
989  Builder.CreateRet(ConstantInt::get(RetTy, 0));
990  else
991  report_fatal_error("invalid return type for __llvm_gcov_flush");
992 
993  return FlushF;
994 }
static StringRef getFunctionName(TargetLowering::CallLoweringInfo &CLI)
GCOVBlock(GCOVFunction &P, uint32_t N)
Definition: GCOV.h:325
static PassRegistry * getPassRegistry()
getPassRegistry - Access the global registry object, which is automatically initialized at applicatio...
LLVM Argument representation.
Definition: Argument.h:34
size_t i
LLVM_ATTRIBUTE_NORETURN void report_fatal_error(Error Err, bool gen_crash_diag=true)
Report a serious error, calling any installed error handler.
MDNode * getScope() const
Definition: DebugLoc.cpp:35
StringMapEntry - This is used to represent one value that is inserted into a StringMap.
Definition: StringMap.h:36
static cl::opt< bool > DefaultExitBlockBeforeBody("gcov-exit-block-before-body", cl::init(false), cl::Hidden)
A Module instance is used to store all the information related to an LLVM module. ...
Definition: Module.h:52
INITIALIZE_PASS(GCOVProfilerLegacyPass,"insert-gcov-profiling","Insert instrumentation for GCOV profiling", false, false) ModulePass *llvm
static GCOVOptions getDefault()
ModulePass * createGCOVProfilerPass(const GCOVOptions &Options=GCOVOptions::getDefault())
unsigned getNumOperands() const
Return number of MDNode operands.
Definition: Metadata.h:1040
Type * getValueType() const
Definition: GlobalValue.h:261
static void addEdge(SmallVectorImpl< LazyCallGraph::Edge > &Edges, DenseMap< Function *, int > &EdgeIndexMap, Function &F, LazyCallGraph::Edge::Kind EK)
static int Counter
static PointerType * get(Type *ElementType, unsigned AddressSpace)
This constructs a pointer to an object of the specified type in a numbered address space...
Definition: Type.cpp:655
void replace_extension(SmallVectorImpl< char > &path, const Twine &extension)
Replace the file extension of path with extension.
Definition: Path.cpp:507
std::error_code current_path(SmallVectorImpl< char > &result)
Get the current path.
Type * getReturnType() const
Returns the type of the ret val.
Definition: Function.cpp:238
A debug info location.
Definition: DebugLoc.h:34
Metadata node.
Definition: Metadata.h:830
static IntegerType * getInt64Ty(LLVMContext &C)
Definition: Type.cpp:170
Hexagon Common GEP
static PointerType * getInt64PtrTy(LLVMContext &C, unsigned AS=0)
Definition: Type.cpp:225
uint64_t getDWOId() const
static Constant * getNullValue(Type *Ty)
Constructor to create a '0' constant of arbitrary type.
Definition: Constants.cpp:195
iterator begin()
Instruction iterator methods.
Definition: BasicBlock.h:228
void append(SmallVectorImpl< char > &path, const Twine &a, const Twine &b="", const Twine &c="", const Twine &d="")
Append to path.
Definition: Path.cpp:448
A tuple of MDNodes.
Definition: Metadata.h:1282
ArrayRef< T > makeArrayRef(const T &OneElt)
Construct an ArrayRef from a single element.
Definition: ArrayRef.h:440
This provides a uniform API for creating instructions and inserting them into a basic block: either a...
Definition: IRBuilder.h:588
StringRef getFilename() const
void setName(const Twine &Name)
Change the name of the value.
Definition: Value.cpp:257
DISubprogram * getDISubprogram(const MDNode *Scope)
Find subprogram that is enclosing this scope.
Definition: DebugInfo.cpp:34
unsigned idFor(const T &Entry) const
idFor - return the ID for an existing entry.
Definition: UniqueVector.h:59
Subprogram description.
Class to represent function types.
Definition: DerivedTypes.h:102
#define F(x, y, z)
Definition: MD5.cpp:51
This file provides the interface for the GCOV style profiler pass.
Class to represent array types.
Definition: DerivedTypes.h:345
static FunctionType * get(Type *Result, ArrayRef< Type * > Params, bool isVarArg)
This static method is the primary way of constructing a FunctionType.
Definition: Type.cpp:291
GCOVBlock - Collects block information.
Definition: GCOV.h:308
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory)...
Definition: APInt.h:33
GCOVFunction(GCOVFile &P)
Definition: GCOV.h:278
hash_code hash_value(const APFloat &Arg)
See friend declarations above.
Definition: APFloat.cpp:4132
LLVM_NODISCARD LLVM_ATTRIBUTE_ALWAYS_INLINE size_t size() const
size - Get the string size.
Definition: StringRef.h:135
Value * CreateInBoundsGEP(Value *Ptr, ArrayRef< Value * > IdxList, const Twine &Name="")
Definition: IRBuilder.h:1158
static PreservedAnalyses none()
Convenience factory function for the empty preserved set.
Definition: PassManager.h:110
Function * getFunction(StringRef Name) const
Look up the specified function in the module symbol table.
Definition: Module.cpp:196
unsigned getNumSuccessors() const
Return the number of successors that this terminator has.
Definition: InstrTypes.h:74
unsigned getLine() const
Definition: DebugLoc.cpp:25
StringRef filename(StringRef path)
Get filename.
Definition: Path.cpp:584
initializer< Ty > init(const Ty &Val)
Definition: CommandLine.h:395
Subclasses of this class are all able to terminate a basic block.
Definition: InstrTypes.h:52
A set of analyses that are preserved following a run of a transformation pass.
Definition: PassManager.h:107
iterator_range< iterator > functions()
Definition: Module.h:546
StringRef getName() const
bool empty() const
empty - Returns true if the vector is empty.
Definition: UniqueVector.h:95
Constant * getOrInsertFunction(StringRef Name, FunctionType *T, AttributeSet AttributeList)
Look up the specified function in the module symbol table.
Definition: Module.cpp:123
LLVM Basic Block Representation.
Definition: BasicBlock.h:51
The instances of the Type class are immutable: once they are created, they are never changed...
Definition: Type.h:45
BasicBlock * getSuccessor(unsigned idx) const
Return the specified successor.
Definition: InstrTypes.h:79
This is an important class for using LLVM in a threaded context.
Definition: LLVMContext.h:48
Conditional or Unconditional Branch instruction.
This is an important base class in LLVM.
Definition: Constant.h:42
LLVM_ATTRIBUTE_ALWAYS_INLINE iterator begin()
Definition: SmallVector.h:115
static Constant * get(ArrayType *T, ArrayRef< Constant * > V)
Definition: Constants.cpp:888
static Type * getVoidTy(LLVMContext &C)
Definition: Type.cpp:154
MDNode * getOperand(unsigned i) const
Definition: Metadata.cpp:1042
static BasicBlock * Create(LLVMContext &Context, const Twine &Name="", Function *Parent=nullptr, BasicBlock *InsertBefore=nullptr)
Creates a new BasicBlock.
Definition: BasicBlock.h:93
arg_iterator arg_begin()
Definition: Function.h:550
cl::opt< TargetMachine::CodeGenFileType > FileType("filetype", cl::init(TargetMachine::CGFT_AssemblyFile), cl::desc("Choose a file type (not all types are supported by all targets):"), cl::values(clEnumValN(TargetMachine::CGFT_AssemblyFile,"asm","Emit an assembly ('.s') file"), clEnumValN(TargetMachine::CGFT_ObjectFile,"obj","Emit a native object ('.o') file"), clEnumValN(TargetMachine::CGFT_Null,"null","Emit nothing, for performance testing")))
static void write(bool isBE, void *P, T V)
static PreservedAnalyses all()
Construct a special preserved set that preserves all passes.
Definition: PassManager.h:113
static PointerType * getInt8PtrTy(LLVMContext &C, unsigned AS=0)
Definition: Type.cpp:213
StringRef getString() const
Definition: Metadata.cpp:424
const MDOperand & getOperand(unsigned I) const
Definition: Metadata.h:1034
Iterator for intrusive lists based on ilist_node.
static bool functionHasLines(Function &F)
Module.h This file contains the declarations for the Module class.
void initializeGCOVProfilerLegacyPassPass(PassRegistry &)
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:558
static BranchInst * Create(BasicBlock *IfTrue, Instruction *InsertBefore=nullptr)
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 setLinkage(LinkageTypes LT)
Definition: GlobalValue.h:424
raw_ostream & dbgs()
dbgs() - This returns a reference to a raw_ostream for debugging messages.
Definition: Debug.cpp:132
StringMap - This is an unconventional map that is specialized for handling keys that are "strings"...
Definition: StringMap.h:223
StringRef getKey() const
Definition: StringMap.h:139
StringRef str() const
Explicit conversion to StringRef.
Definition: SmallString.h:267
bool isIntegerTy() const
True if this is an instance of IntegerType.
Definition: Type.h:195
static cl::opt< std::string > DefaultGCOVVersion("default-gcov-version", cl::init("402*"), cl::Hidden, cl::ValueRequired)
NamedMDNode * getNamedMetadata(const Twine &Name) const
Return the first NamedMDNode in the module with the specified name.
Definition: Module.cpp:265
LLVM_ATTRIBUTE_ALWAYS_INLINE iterator end()
Definition: SmallVector.h:119
GCOVFunction - Collects function information.
Definition: GCOV.h:273
A raw_ostream that writes to a file descriptor.
Definition: raw_ostream.h:357
void setUnnamedAddr(UnnamedAddr Val)
Definition: GlobalValue.h:203
static IntegerType * getInt32Ty(LLVMContext &C)
Definition: Type.cpp:169
unsigned insert(const T &Entry)
insert - Append entry to the vector if it doesn't already exist.
Definition: UniqueVector.h:42
size_t size() const
size - Returns the number of entries in the vector.
Definition: UniqueVector.h:91
#define I(x, y, z)
Definition: MD5.cpp:54
#define N
TerminatorInst * getTerminator()
Returns the terminator instruction if the block is well formed or null if the block is not well forme...
Definition: BasicBlock.cpp:124
LLVM_ATTRIBUTE_ALWAYS_INLINE size_type size() const
Definition: SmallVector.h:135
ModulePass class - This class is used to implement unstructured interprocedural optimizations and ana...
Definition: Pass.h:235
static ArrayType * get(Type *ElementType, uint64_t NumElements)
This static method is the primary way to construct an ArrayType.
Definition: Type.cpp:606
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:287
Rename collisions when linking (static functions).
Definition: GlobalValue.h:56
BasicBlock * splitBasicBlock(iterator I, const Twine &BBName="")
Split the basic block into two basic blocks at the specified instruction.
Definition: BasicBlock.cpp:374
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
A raw_ostream that writes to an std::string.
Definition: raw_ostream.h:463
aarch64 promote const
LLVM Value Representation.
Definition: Value.h:71
succ_range successors(BasicBlock *BB)
Definition: IR/CFG.h:143
unsigned getNumOperands() const
Definition: Metadata.cpp:1038
This class implements an extremely fast bulk output stream that can only output to a stream...
Definition: raw_ostream.h:44
LLVM_NODISCARD LLVM_ATTRIBUTE_ALWAYS_INLINE const char * data() const
data - Get a pointer to the start of the string (which may not be null terminated).
Definition: StringRef.h:125
#define DEBUG(X)
Definition: Debug.h:100
void addFnAttr(Attribute::AttrKind Kind)
Add function attributes to this function.
Definition: Function.h:182
PointerType * getPointerTo(unsigned AddrSpace=0) const
Return a pointer to the current type.
Definition: Type.cpp:678
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:47
A single uniqued string.
Definition: Metadata.h:586
A container for analyses that lazily runs them and caches their results.
static Function * Create(FunctionType *Ty, LinkageTypes Linkage, const Twine &N="", Module *M=nullptr)
Definition: Function.h:117
DISubprogram * getSubprogram() const
Get the subprogram for this scope.
static IntegerType * getInt8Ty(LLVMContext &C)
Definition: Type.cpp:167
UniqueVector - This class produces a sequential ID number (base 1) for each unique entry that is adde...
Definition: UniqueVector.h:25
GlobalVariable * getGlobalVariable(StringRef Name) const
Look up the specified global variable in the module symbol table.
Definition: Module.h:344
IntegerType * Int32Ty
LLVMContext & getContext() const
Get the global data context.
Definition: Module.h:222
PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM)