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