source: icGREP/icgrep-devel/llvm-3.6.1.src/lib/Transforms/Instrumentation/GCOVProfiling.cpp @ 4664

Last change on this file since 4664 was 4664, checked in by cameron, 4 years ago

Upgrade LLVM to 3.6.1

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