Home | History | Annotate | Download | only in Instrumentation 
      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 #define DEBUG_TYPE "insert-gcov-profiling"
     18 
     19 #include "ProfilingUtils.h"
     20 #include "llvm/Transforms/Instrumentation.h"
     21 #include "llvm/Analysis/DebugInfo.h"
     22 #include "llvm/Module.h"
     23 #include "llvm/Pass.h"
     24 #include "llvm/Instructions.h"
     25 #include "llvm/Support/raw_ostream.h"
     26 #include "llvm/Support/Debug.h"
     27 #include "llvm/Support/DebugLoc.h"
     28 #include "llvm/Support/InstIterator.h"
     29 #include "llvm/Support/IRBuilder.h"
     30 #include "llvm/Support/PathV2.h"
     31 #include "llvm/ADT/DenseMap.h"
     32 #include "llvm/ADT/Statistic.h"
     33 #include "llvm/ADT/STLExtras.h"
     34 #include "llvm/ADT/StringExtras.h"
     35 #include "llvm/ADT/StringMap.h"
     36 #include "llvm/ADT/UniqueVector.h"
     37 #include <string>
     38 #include <utility>
     39 using namespace llvm;
     40 
     41 namespace {
     42   class GCOVProfiler : public ModulePass {
     43   public:
     44     static char ID;
     45     GCOVProfiler()
     46         : ModulePass(ID), EmitNotes(true), EmitData(true), Use402Format(false) {
     47       initializeGCOVProfilerPass(*PassRegistry::getPassRegistry());
     48     }
     49     GCOVProfiler(bool EmitNotes, bool EmitData, bool use402Format = false)
     50         : ModulePass(ID), EmitNotes(EmitNotes), EmitData(EmitData),
     51           Use402Format(use402Format) {
     52       assert((EmitNotes || EmitData) && "GCOVProfiler asked to do nothing?");
     53       initializeGCOVProfilerPass(*PassRegistry::getPassRegistry());
     54     }
     55     virtual const char *getPassName() const {
     56       return "GCOV Profiler";
     57     }
     58 
     59   private:
     60     bool runOnModule(Module &M);
     61 
     62     // Create the GCNO files for the Module based on DebugInfo.
     63     void emitGCNO();
     64 
     65     // Modify the program to track transitions along edges and call into the
     66     // profiling runtime to emit .gcda files when run.
     67     bool emitProfileArcs();
     68 
     69     // Get pointers to the functions in the runtime library.
     70     Constant *getStartFileFunc();
     71     Constant *getIncrementIndirectCounterFunc();
     72     Constant *getEmitFunctionFunc();
     73     Constant *getEmitArcsFunc();
     74     Constant *getEndFileFunc();
     75 
     76     // Create or retrieve an i32 state value that is used to represent the
     77     // pred block number for certain non-trivial edges.
     78     GlobalVariable *getEdgeStateValue();
     79 
     80     // Produce a table of pointers to counters, by predecessor and successor
     81     // block number.
     82     GlobalVariable *buildEdgeLookupTable(Function *F,
     83                                          GlobalVariable *Counter,
     84                                          const UniqueVector<BasicBlock *> &Preds,
     85                                          const UniqueVector<BasicBlock *> &Succs);
     86 
     87     // Add the function to write out all our counters to the global destructor
     88     // list.
     89     void insertCounterWriteout(SmallVector<std::pair<GlobalVariable *,
     90                                                      MDNode *>, 8> &);
     91 
     92     std::string mangleName(DICompileUnit CU, std::string NewStem);
     93 
     94     bool EmitNotes;
     95     bool EmitData;
     96     bool Use402Format;
     97 
     98     Module *M;
     99     LLVMContext *Ctx;
    100   };
    101 }
    102 
    103 char GCOVProfiler::ID = 0;
    104 INITIALIZE_PASS(GCOVProfiler, "insert-gcov-profiling",
    105                 "Insert instrumentation for GCOV profiling", false, false)
    106 
    107 ModulePass *llvm::createGCOVProfilerPass(bool EmitNotes, bool EmitData,
    108                                          bool Use402Format) {
    109   return new GCOVProfiler(EmitNotes, EmitData, Use402Format);
    110 }
    111 
    112 namespace {
    113   class GCOVRecord {
    114    protected:
    115     static const char *LinesTag;
    116     static const char *FunctionTag;
    117     static const char *BlockTag;
    118     static const char *EdgeTag;
    119 
    120     GCOVRecord() {}
    121 
    122     void writeBytes(const char *Bytes, int Size) {
    123       os->write(Bytes, Size);
    124     }
    125 
    126     void write(uint32_t i) {
    127       writeBytes(reinterpret_cast<char*>(&i), 4);
    128     }
    129 
    130     // Returns the length measured in 4-byte blocks that will be used to
    131     // represent this string in a GCOV file
    132     unsigned lengthOfGCOVString(StringRef s) {
    133       // A GCOV string is a length, followed by a NUL, then between 0 and 3 NULs
    134       // padding out to the next 4-byte word. The length is measured in 4-byte
    135       // words including padding, not bytes of actual string.
    136       return (s.size() / 4) + 1;
    137     }
    138 
    139     void writeGCOVString(StringRef s) {
    140       uint32_t Len = lengthOfGCOVString(s);
    141       write(Len);
    142       writeBytes(s.data(), s.size());
    143 
    144       // Write 1 to 4 bytes of NUL padding.
    145       assert((unsigned)(4 - (s.size() % 4)) > 0);
    146       assert((unsigned)(4 - (s.size() % 4)) <= 4);
    147       writeBytes("\0\0\0\0", 4 - (s.size() % 4));
    148     }
    149 
    150     raw_ostream *os;
    151   };
    152   const char *GCOVRecord::LinesTag = "\0\0\x45\x01";
    153   const char *GCOVRecord::FunctionTag = "\0\0\0\1";
    154   const char *GCOVRecord::BlockTag = "\0\0\x41\x01";
    155   const char *GCOVRecord::EdgeTag = "\0\0\x43\x01";
    156 
    157   class GCOVFunction;
    158   class GCOVBlock;
    159 
    160   // Constructed only by requesting it from a GCOVBlock, this object stores a
    161   // list of line numbers and a single filename, representing lines that belong
    162   // to the block.
    163   class GCOVLines : public GCOVRecord {
    164    public:
    165     void addLine(uint32_t Line) {
    166       Lines.push_back(Line);
    167     }
    168 
    169     uint32_t length() {
    170       // Here 2 = 1 for string lenght + 1 for '0' id#.
    171       return lengthOfGCOVString(Filename) + 2 + Lines.size();
    172     }
    173 
    174     void writeOut() {
    175       write(0);
    176       writeGCOVString(Filename);
    177       for (int i = 0, e = Lines.size(); i != e; ++i)
    178         write(Lines[i]);
    179     }
    180 
    181     GCOVLines(StringRef F, raw_ostream *os)
    182       : Filename(F) {
    183       this->os = os;
    184     }
    185 
    186    private:
    187     StringRef Filename;
    188     SmallVector<uint32_t, 32> Lines;
    189   };
    190 
    191   // Represent a basic block in GCOV. Each block has a unique number in the
    192   // function, number of lines belonging to each block, and a set of edges to
    193   // other blocks.
    194   class GCOVBlock : public GCOVRecord {
    195    public:
    196     GCOVLines &getFile(StringRef Filename) {
    197       GCOVLines *&Lines = LinesByFile[Filename];
    198       if (!Lines) {
    199         Lines = new GCOVLines(Filename, os);
    200       }
    201       return *Lines;
    202     }
    203 
    204     void addEdge(GCOVBlock &Successor) {
    205       OutEdges.push_back(&Successor);
    206     }
    207 
    208     void writeOut() {
    209       uint32_t Len = 3;
    210       for (StringMap<GCOVLines *>::iterator I = LinesByFile.begin(),
    211                E = LinesByFile.end(); I != E; ++I) {
    212         Len += I->second->length();
    213       }
    214 
    215       writeBytes(LinesTag, 4);
    216       write(Len);
    217       write(Number);
    218       for (StringMap<GCOVLines *>::iterator I = LinesByFile.begin(),
    219                E = LinesByFile.end(); I != E; ++I)
    220         I->second->writeOut();
    221       write(0);
    222       write(0);
    223     }
    224 
    225     ~GCOVBlock() {
    226       DeleteContainerSeconds(LinesByFile);
    227     }
    228 
    229    private:
    230     friend class GCOVFunction;
    231 
    232     GCOVBlock(uint32_t Number, raw_ostream *os)
    233         : Number(Number) {
    234       this->os = os;
    235     }
    236 
    237     uint32_t Number;
    238     StringMap<GCOVLines *> LinesByFile;
    239     SmallVector<GCOVBlock *, 4> OutEdges;
    240   };
    241 
    242   // A function has a unique identifier, a checksum (we leave as zero) and a
    243   // set of blocks and a map of edges between blocks. This is the only GCOV
    244   // object users can construct, the blocks and lines will be rooted here.
    245   class GCOVFunction : public GCOVRecord {
    246    public:
    247     GCOVFunction(DISubprogram SP, raw_ostream *os, bool Use402Format) {
    248       this->os = os;
    249 
    250       Function *F = SP.getFunction();
    251       uint32_t i = 0;
    252       for (Function::iterator BB = F->begin(), E = F->end(); BB != E; ++BB) {
    253         Blocks[BB] = new GCOVBlock(i++, os);
    254       }
    255       ReturnBlock = new GCOVBlock(i++, os);
    256 
    257       writeBytes(FunctionTag, 4);
    258       uint32_t BlockLen = 1 + 1 + 1 + lengthOfGCOVString(SP.getName()) +
    259           1 + lengthOfGCOVString(SP.getFilename()) + 1;
    260       if (!Use402Format)
    261         ++BlockLen; // For second checksum.
    262       write(BlockLen);
    263       uint32_t Ident = reinterpret_cast<intptr_t>((MDNode*)SP);
    264       write(Ident);
    265       write(0);  // checksum #1
    266       if (!Use402Format)
    267         write(0);  // checksum #2
    268       writeGCOVString(SP.getName());
    269       writeGCOVString(SP.getFilename());
    270       write(SP.getLineNumber());
    271     }
    272 
    273     ~GCOVFunction() {
    274       DeleteContainerSeconds(Blocks);
    275       delete ReturnBlock;
    276     }
    277 
    278     GCOVBlock &getBlock(BasicBlock *BB) {
    279       return *Blocks[BB];
    280     }
    281 
    282     GCOVBlock &getReturnBlock() {
    283       return *ReturnBlock;
    284     }
    285 
    286     void writeOut() {
    287       // Emit count of blocks.
    288       writeBytes(BlockTag, 4);
    289       write(Blocks.size() + 1);
    290       for (int i = 0, e = Blocks.size() + 1; i != e; ++i) {
    291         write(0);  // No flags on our blocks.
    292       }
    293 
    294       // Emit edges between blocks.
    295       for (DenseMap<BasicBlock *, GCOVBlock *>::iterator I = Blocks.begin(),
    296                E = Blocks.end(); I != E; ++I) {
    297         GCOVBlock &Block = *I->second;
    298         if (Block.OutEdges.empty()) continue;
    299 
    300         writeBytes(EdgeTag, 4);
    301         write(Block.OutEdges.size() * 2 + 1);
    302         write(Block.Number);
    303         for (int i = 0, e = Block.OutEdges.size(); i != e; ++i) {
    304           write(Block.OutEdges[i]->Number);
    305           write(0);  // no flags
    306         }
    307       }
    308 
    309       // Emit lines for each block.
    310       for (DenseMap<BasicBlock *, GCOVBlock *>::iterator I = Blocks.begin(),
    311                E = Blocks.end(); I != E; ++I) {
    312         I->second->writeOut();
    313       }
    314     }
    315 
    316    private:
    317     DenseMap<BasicBlock *, GCOVBlock *> Blocks;
    318     GCOVBlock *ReturnBlock;
    319   };
    320 }
    321 
    322 std::string GCOVProfiler::mangleName(DICompileUnit CU, std::string NewStem) {
    323   if (NamedMDNode *GCov = M->getNamedMetadata("llvm.gcov")) {
    324     for (int i = 0, e = GCov->getNumOperands(); i != e; ++i) {
    325       MDNode *N = GCov->getOperand(i);
    326       if (N->getNumOperands() != 2) continue;
    327       MDString *GCovFile = dyn_cast<MDString>(N->getOperand(0));
    328       MDNode *CompileUnit = dyn_cast<MDNode>(N->getOperand(1));
    329       if (!GCovFile || !CompileUnit) continue;
    330       if (CompileUnit == CU) {
    331         SmallString<128> Filename = GCovFile->getString();
    332         sys::path::replace_extension(Filename, NewStem);
    333         return Filename.str();
    334       }
    335     }
    336   }
    337 
    338   SmallString<128> Filename = CU.getFilename();
    339   sys::path::replace_extension(Filename, NewStem);
    340   return sys::path::filename(Filename.str());
    341 }
    342 
    343 bool GCOVProfiler::runOnModule(Module &M) {
    344   this->M = &M;
    345   Ctx = &M.getContext();
    346 
    347   if (EmitNotes) emitGCNO();
    348   if (EmitData) return emitProfileArcs();
    349   return false;
    350 }
    351 
    352 void GCOVProfiler::emitGCNO() {
    353   DenseMap<const MDNode *, raw_fd_ostream *> GcnoFiles;
    354   NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu");
    355   if (CU_Nodes) {
    356     for (unsigned i = 0, e = CU_Nodes->getNumOperands(); i != e; ++i) {
    357       // Each compile unit gets its own .gcno file. This means that whether we run
    358       // this pass over the original .o's as they're produced, or run it after
    359       // LTO, we'll generate the same .gcno files.
    360 
    361       DICompileUnit CU(CU_Nodes->getOperand(i));
    362       raw_fd_ostream *&out = GcnoFiles[CU];
    363       std::string ErrorInfo;
    364       out = new raw_fd_ostream(mangleName(CU, "gcno").c_str(), ErrorInfo,
    365                                raw_fd_ostream::F_Binary);
    366       if (!Use402Format)
    367         out->write("oncg*404MVLL", 12);
    368       else
    369         out->write("oncg*204MVLL", 12);
    370 
    371       DIArray SPs = CU.getSubprograms();
    372       for (unsigned i = 0, e = SPs.getNumElements(); i != e; ++i) {
    373         DISubprogram SP(SPs.getElement(i));
    374         if (!SP.Verify()) continue;
    375         raw_fd_ostream *&os = GcnoFiles[CU];
    376 
    377         Function *F = SP.getFunction();
    378         if (!F) continue;
    379         GCOVFunction Func(SP, os, Use402Format);
    380 
    381         for (Function::iterator BB = F->begin(), E = F->end(); BB != E; ++BB) {
    382           GCOVBlock &Block = Func.getBlock(BB);
    383           TerminatorInst *TI = BB->getTerminator();
    384           if (int successors = TI->getNumSuccessors()) {
    385             for (int i = 0; i != successors; ++i) {
    386               Block.addEdge(Func.getBlock(TI->getSuccessor(i)));
    387             }
    388           } else if (isa<ReturnInst>(TI)) {
    389             Block.addEdge(Func.getReturnBlock());
    390           }
    391 
    392           uint32_t Line = 0;
    393           for (BasicBlock::iterator I = BB->begin(), IE = BB->end(); I != IE; ++I) {
    394             const DebugLoc &Loc = I->getDebugLoc();
    395             if (Loc.isUnknown()) continue;
    396             if (Line == Loc.getLine()) continue;
    397             Line = Loc.getLine();
    398             if (SP != getDISubprogram(Loc.getScope(*Ctx))) continue;
    399 
    400             GCOVLines &Lines = Block.getFile(SP.getFilename());
    401             Lines.addLine(Loc.getLine());
    402           }
    403         }
    404         Func.writeOut();
    405       }
    406     }
    407   }
    408 
    409   for (DenseMap<const MDNode *, raw_fd_ostream *>::iterator
    410            I = GcnoFiles.begin(), E = GcnoFiles.end(); I != E; ++I) {
    411     raw_fd_ostream *&out = I->second;
    412     out->write("\0\0\0\0\0\0\0\0", 8);  // EOF
    413     out->close();
    414     delete out;
    415   }
    416 }
    417 
    418 bool GCOVProfiler::emitProfileArcs() {
    419   NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu");
    420   if (!CU_Nodes) return false;
    421 
    422   bool Result = false;
    423   for (unsigned i = 0, e = CU_Nodes->getNumOperands(); i != e; ++i) {
    424     DICompileUnit CU(CU_Nodes->getOperand(i));
    425     DIArray SPs = CU.getSubprograms();
    426     SmallVector<std::pair<GlobalVariable *, MDNode *>, 8> CountersBySP;
    427     for (unsigned i = 0, e = SPs.getNumElements(); i != e; ++i) {
    428       DISubprogram SP(SPs.getElement(i));
    429       if (!SP.Verify()) continue;
    430       Function *F = SP.getFunction();
    431       if (!F) continue;
    432       if (!Result) Result = true;
    433       unsigned Edges = 0;
    434       for (Function::iterator BB = F->begin(), E = F->end(); BB != E; ++BB) {
    435         TerminatorInst *TI = BB->getTerminator();
    436         if (isa<ReturnInst>(TI))
    437           ++Edges;
    438         else
    439           Edges += TI->getNumSuccessors();
    440       }
    441 
    442       ArrayType *CounterTy =
    443         ArrayType::get(Type::getInt64Ty(*Ctx), Edges);
    444       GlobalVariable *Counters =
    445         new GlobalVariable(*M, CounterTy, false,
    446                            GlobalValue::InternalLinkage,
    447                            Constant::getNullValue(CounterTy),
    448                            "__llvm_gcov_ctr", 0, false, 0);
    449       CountersBySP.push_back(std::make_pair(Counters, (MDNode*)SP));
    450 
    451       UniqueVector<BasicBlock *> ComplexEdgePreds;
    452       UniqueVector<BasicBlock *> ComplexEdgeSuccs;
    453 
    454       unsigned Edge = 0;
    455       for (Function::iterator BB = F->begin(), E = F->end(); BB != E; ++BB) {
    456         TerminatorInst *TI = BB->getTerminator();
    457         int Successors = isa<ReturnInst>(TI) ? 1 : TI->getNumSuccessors();
    458         if (Successors) {
    459           IRBuilder<> Builder(TI);
    460 
    461           if (Successors == 1) {
    462             Value *Counter = Builder.CreateConstInBoundsGEP2_64(Counters, 0,
    463                                                                 Edge);
    464             Value *Count = Builder.CreateLoad(Counter);
    465             Count = Builder.CreateAdd(Count,
    466                                       ConstantInt::get(Type::getInt64Ty(*Ctx),1));
    467             Builder.CreateStore(Count, Counter);
    468           } else if (BranchInst *BI = dyn_cast<BranchInst>(TI)) {
    469             Value *Sel = Builder.CreateSelect(
    470               BI->getCondition(),
    471               ConstantInt::get(Type::getInt64Ty(*Ctx), Edge),
    472               ConstantInt::get(Type::getInt64Ty(*Ctx), Edge + 1));
    473             SmallVector<Value *, 2> Idx;
    474             Idx.push_back(Constant::getNullValue(Type::getInt64Ty(*Ctx)));
    475             Idx.push_back(Sel);
    476             Value *Counter = Builder.CreateInBoundsGEP(Counters, Idx);
    477             Value *Count = Builder.CreateLoad(Counter);
    478             Count = Builder.CreateAdd(Count,
    479                                       ConstantInt::get(Type::getInt64Ty(*Ctx),1));
    480             Builder.CreateStore(Count, Counter);
    481           } else {
    482             ComplexEdgePreds.insert(BB);
    483             for (int i = 0; i != Successors; ++i)
    484               ComplexEdgeSuccs.insert(TI->getSuccessor(i));
    485           }
    486           Edge += Successors;
    487         }
    488       }
    489 
    490       if (!ComplexEdgePreds.empty()) {
    491         GlobalVariable *EdgeTable =
    492           buildEdgeLookupTable(F, Counters,
    493                                ComplexEdgePreds, ComplexEdgeSuccs);
    494         GlobalVariable *EdgeState = getEdgeStateValue();
    495 
    496         Type *Int32Ty = Type::getInt32Ty(*Ctx);
    497         for (int i = 0, e = ComplexEdgePreds.size(); i != e; ++i) {
    498           IRBuilder<> Builder(ComplexEdgePreds[i+1]->getTerminator());
    499           Builder.CreateStore(ConstantInt::get(Int32Ty, i), EdgeState);
    500         }
    501         for (int i = 0, e = ComplexEdgeSuccs.size(); i != e; ++i) {
    502           // call runtime to perform increment
    503           BasicBlock::iterator InsertPt =
    504             ComplexEdgeSuccs[i+1]->getFirstInsertionPt();
    505           IRBuilder<> Builder(InsertPt);
    506           Value *CounterPtrArray =
    507             Builder.CreateConstInBoundsGEP2_64(EdgeTable, 0,
    508                                                i * ComplexEdgePreds.size());
    509           Builder.CreateCall2(getIncrementIndirectCounterFunc(),
    510                               EdgeState, CounterPtrArray);
    511           // clear the predecessor number
    512           Builder.CreateStore(ConstantInt::get(Int32Ty, 0xffffffff), EdgeState);
    513         }
    514       }
    515     }
    516     insertCounterWriteout(CountersBySP);
    517   }
    518   return Result;
    519 }
    520 
    521 // All edges with successors that aren't branches are "complex", because it
    522 // requires complex logic to pick which counter to update.
    523 GlobalVariable *GCOVProfiler::buildEdgeLookupTable(
    524     Function *F,
    525     GlobalVariable *Counters,
    526     const UniqueVector<BasicBlock *> &Preds,
    527     const UniqueVector<BasicBlock *> &Succs) {
    528   // TODO: support invoke, threads. We rely on the fact that nothing can modify
    529   // the whole-Module pred edge# between the time we set it and the time we next
    530   // read it. Threads and invoke make this untrue.
    531 
    532   // emit [(succs * preds) x i64*], logically [succ x [pred x i64*]].
    533   Type *Int64PtrTy = Type::getInt64PtrTy(*Ctx);
    534   ArrayType *EdgeTableTy = ArrayType::get(
    535       Int64PtrTy, Succs.size() * Preds.size());
    536 
    537   Constant **EdgeTable = new Constant*[Succs.size() * Preds.size()];
    538   Constant *NullValue = Constant::getNullValue(Int64PtrTy);
    539   for (int i = 0, ie = Succs.size() * Preds.size(); i != ie; ++i)
    540     EdgeTable[i] = NullValue;
    541 
    542   unsigned Edge = 0;
    543   for (Function::iterator BB = F->begin(), E = F->end(); BB != E; ++BB) {
    544     TerminatorInst *TI = BB->getTerminator();
    545     int Successors = isa<ReturnInst>(TI) ? 1 : TI->getNumSuccessors();
    546     if (Successors > 1 && !isa<BranchInst>(TI) && !isa<ReturnInst>(TI)) {
    547       for (int i = 0; i != Successors; ++i) {
    548         BasicBlock *Succ = TI->getSuccessor(i);
    549         IRBuilder<> builder(Succ);
    550         Value *Counter = builder.CreateConstInBoundsGEP2_64(Counters, 0,
    551                                                             Edge + i);
    552         EdgeTable[((Succs.idFor(Succ)-1) * Preds.size()) +
    553                   (Preds.idFor(BB)-1)] = cast<Constant>(Counter);
    554       }
    555     }
    556     Edge += Successors;
    557   }
    558 
    559   ArrayRef<Constant*> V(&EdgeTable[0], Succs.size() * Preds.size());
    560   GlobalVariable *EdgeTableGV =
    561       new GlobalVariable(
    562           *M, EdgeTableTy, true, GlobalValue::InternalLinkage,
    563           ConstantArray::get(EdgeTableTy, V),
    564           "__llvm_gcda_edge_table");
    565   EdgeTableGV->setUnnamedAddr(true);
    566   return EdgeTableGV;
    567 }
    568 
    569 Constant *GCOVProfiler::getStartFileFunc() {
    570   FunctionType *FTy = FunctionType::get(Type::getVoidTy(*Ctx),
    571                                               Type::getInt8PtrTy(*Ctx), false);
    572   return M->getOrInsertFunction("llvm_gcda_start_file", FTy);
    573 }
    574 
    575 Constant *GCOVProfiler::getIncrementIndirectCounterFunc() {
    576   Type *Args[] = {
    577     Type::getInt32PtrTy(*Ctx),                  // uint32_t *predecessor
    578     Type::getInt64PtrTy(*Ctx)->getPointerTo(),  // uint64_t **state_table_row
    579   };
    580   FunctionType *FTy = FunctionType::get(Type::getVoidTy(*Ctx),
    581                                               Args, false);
    582   return M->getOrInsertFunction("llvm_gcda_increment_indirect_counter", FTy);
    583 }
    584 
    585 Constant *GCOVProfiler::getEmitFunctionFunc() {
    586   Type *Args[2] = {
    587     Type::getInt32Ty(*Ctx),    // uint32_t ident
    588     Type::getInt8PtrTy(*Ctx),  // const char *function_name
    589   };
    590   FunctionType *FTy = FunctionType::get(Type::getVoidTy(*Ctx),
    591                                               Args, false);
    592   return M->getOrInsertFunction("llvm_gcda_emit_function", FTy);
    593 }
    594 
    595 Constant *GCOVProfiler::getEmitArcsFunc() {
    596   Type *Args[] = {
    597     Type::getInt32Ty(*Ctx),     // uint32_t num_counters
    598     Type::getInt64PtrTy(*Ctx),  // uint64_t *counters
    599   };
    600   FunctionType *FTy = FunctionType::get(Type::getVoidTy(*Ctx),
    601                                               Args, false);
    602   return M->getOrInsertFunction("llvm_gcda_emit_arcs", FTy);
    603 }
    604 
    605 Constant *GCOVProfiler::getEndFileFunc() {
    606   FunctionType *FTy = FunctionType::get(Type::getVoidTy(*Ctx), false);
    607   return M->getOrInsertFunction("llvm_gcda_end_file", FTy);
    608 }
    609 
    610 GlobalVariable *GCOVProfiler::getEdgeStateValue() {
    611   GlobalVariable *GV = M->getGlobalVariable("__llvm_gcov_global_state_pred");
    612   if (!GV) {
    613     GV = new GlobalVariable(*M, Type::getInt32Ty(*Ctx), false,
    614                             GlobalValue::InternalLinkage,
    615                             ConstantInt::get(Type::getInt32Ty(*Ctx),
    616                                              0xffffffff),
    617                             "__llvm_gcov_global_state_pred");
    618     GV->setUnnamedAddr(true);
    619   }
    620   return GV;
    621 }
    622 
    623 void GCOVProfiler::insertCounterWriteout(
    624     SmallVector<std::pair<GlobalVariable *, MDNode *>, 8> &CountersBySP) {
    625   FunctionType *WriteoutFTy =
    626       FunctionType::get(Type::getVoidTy(*Ctx), false);
    627   Function *WriteoutF = Function::Create(WriteoutFTy,
    628                                          GlobalValue::InternalLinkage,
    629                                          "__llvm_gcov_writeout", M);
    630   WriteoutF->setUnnamedAddr(true);
    631   BasicBlock *BB = BasicBlock::Create(*Ctx, "", WriteoutF);
    632   IRBuilder<> Builder(BB);
    633 
    634   Constant *StartFile = getStartFileFunc();
    635   Constant *EmitFunction = getEmitFunctionFunc();
    636   Constant *EmitArcs = getEmitArcsFunc();
    637   Constant *EndFile = getEndFileFunc();
    638 
    639   NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu");
    640   if (CU_Nodes) {
    641     for (unsigned i = 0, e = CU_Nodes->getNumOperands(); i != e; ++i) {
    642       DICompileUnit compile_unit(CU_Nodes->getOperand(i));
    643       std::string FilenameGcda = mangleName(compile_unit, "gcda");
    644       Builder.CreateCall(StartFile,
    645                          Builder.CreateGlobalStringPtr(FilenameGcda));
    646       for (SmallVector<std::pair<GlobalVariable *, MDNode *>, 8>::iterator
    647              I = CountersBySP.begin(), E = CountersBySP.end();
    648            I != E; ++I) {
    649         DISubprogram SP(I->second);
    650         intptr_t ident = reinterpret_cast<intptr_t>(I->second);
    651         Builder.CreateCall2(EmitFunction,
    652                             ConstantInt::get(Type::getInt32Ty(*Ctx), ident),
    653                             Builder.CreateGlobalStringPtr(SP.getName()));
    654 
    655         GlobalVariable *GV = I->first;
    656         unsigned Arcs =
    657           cast<ArrayType>(GV->getType()->getElementType())->getNumElements();
    658         Builder.CreateCall2(EmitArcs,
    659                             ConstantInt::get(Type::getInt32Ty(*Ctx), Arcs),
    660                             Builder.CreateConstGEP2_64(GV, 0, 0));
    661       }
    662       Builder.CreateCall(EndFile);
    663     }
    664   }
    665   Builder.CreateRetVoid();
    666 
    667   InsertProfilingShutdownCall(WriteoutF, M);
    668 }
    669