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>
43 using namespace llvm;
44
45 #define DEBUG_TYPE "insert-gcov-profiling"
46
47 static cl::opt<std::string>
48 DefaultGCOVVersion("default-gcov-version", cl::init("402*"), cl::Hidden,
49 cl::ValueRequired);
50 static cl::opt<bool> DefaultExitBlockBeforeBody("gcov-exit-block-before-body",
51 cl::init(false), cl::Hidden);
52
getDefault()53 GCOVOptions 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
69 namespace {
70 class GCOVFunction;
71
72 class GCOVProfiler : public ModulePass {
73 public:
74 static char ID;
GCOVProfiler()75 GCOVProfiler() : ModulePass(ID), Options(GCOVOptions::getDefault()) {
76 init();
77 }
GCOVProfiler(const GCOVOptions & Options)78 GCOVProfiler(const GCOVOptions &Options) : ModulePass(ID), Options(Options){
79 assert((Options.EmitNotes || Options.EmitData) &&
80 "GCOVProfiler asked to do nothing?");
81 init();
82 }
getPassName() const83 const char *getPassName() const override {
84 return "GCOV Profiler";
85 }
86
87 private:
init()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
148 char GCOVProfiler::ID = 0;
149 INITIALIZE_PASS(GCOVProfiler, "insert-gcov-profiling",
150 "Insert instrumentation for GCOV profiling", false, false)
151
createGCOVProfilerPass(const GCOVOptions & Options)152 ModulePass *llvm::createGCOVProfilerPass(const GCOVOptions &Options) {
153 return new GCOVProfiler(Options);
154 }
155
getFunctionName(DISubprogram SP)156 static StringRef getFunctionName(DISubprogram SP) {
157 if (!SP.getLinkageName().empty())
158 return SP.getLinkageName();
159 return SP.getName();
160 }
161
162 namespace {
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
GCOVRecord()170 GCOVRecord() {}
171
writeBytes(const char * Bytes,int Size)172 void writeBytes(const char *Bytes, int Size) {
173 os->write(Bytes, Size);
174 }
175
write(uint32_t i)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
lengthOfGCOVString(StringRef s)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
writeGCOVString(StringRef s)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:
addLine(uint32_t Line)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
length() const220 uint32_t length() const {
221 // Here 2 = 1 for string length + 1 for '0' id#.
222 return lengthOfGCOVString(Filename) + 2 + Lines.size();
223 }
224
writeOut()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
GCOVLines(StringRef F,raw_ostream * os)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:
getFile(StringRef Filename)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
addEdge(GCOVBlock & Successor)256 void addEdge(GCOVBlock &Successor) {
257 OutEdges.push_back(&Successor);
258 }
259
writeOut()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
~GCOVBlock()286 ~GCOVBlock() {
287 DeleteContainerSeconds(LinesByFile);
288 }
289
GCOVBlock(const GCOVBlock & RHS)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
GCOVBlock(uint32_t Number,raw_ostream * os)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:
GCOVFunction(DISubprogram SP,raw_ostream * os,uint32_t Ident,bool UseCfgChecksum,bool ExitBlockBeforeBody)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
getBlock(BasicBlock * BB)342 GCOVBlock &getBlock(BasicBlock *BB) {
343 return Blocks.find(BB)->second;
344 }
345
getReturnBlock()346 GCOVBlock &getReturnBlock() {
347 return ReturnBlock;
348 }
349
getEdgeDestinations()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
getFuncChecksum()362 uint32_t getFuncChecksum() {
363 return FuncChecksum;
364 }
365
setCfgChecksum(uint32_t Checksum)366 void setCfgChecksum(uint32_t Checksum) {
367 CfgChecksum = Checksum;
368 }
369
writeOut()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
mangleName(DICompileUnit CU,const char * NewStem)428 std::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
runOnModule(Module & M)453 bool 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
functionHasLines(Function * F)462 static 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
emitProfileNotes()484 void 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
emitProfileArcs()574 bool 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.
buildEdgeLookupTable(Function * F,GlobalVariable * Counters,const UniqueVector<BasicBlock * > & Preds,const UniqueVector<BasicBlock * > & Succs)717 GlobalVariable *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
getStartFileFunc()763 Constant *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
getIncrementIndirectCounterFunc()773 Constant *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
getEmitFunctionFunc()784 Constant *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
getEmitArcsFunc()796 Constant *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
getSummaryInfoFunc()805 Constant *GCOVProfiler::getSummaryInfoFunc() {
806 FunctionType *FTy = FunctionType::get(Type::getVoidTy(*Ctx), false);
807 return M->getOrInsertFunction("llvm_gcda_summary_info", FTy);
808 }
809
getDeleteWriteoutFunctionListFunc()810 Constant *GCOVProfiler::getDeleteWriteoutFunctionListFunc() {
811 FunctionType *FTy = FunctionType::get(Type::getVoidTy(*Ctx), false);
812 return M->getOrInsertFunction("llvm_delete_writeout_function_list", FTy);
813 }
814
getDeleteFlushFunctionListFunc()815 Constant *GCOVProfiler::getDeleteFlushFunctionListFunc() {
816 FunctionType *FTy = FunctionType::get(Type::getVoidTy(*Ctx), false);
817 return M->getOrInsertFunction("llvm_delete_flush_function_list", FTy);
818 }
819
getEndFileFunc()820 Constant *GCOVProfiler::getEndFileFunc() {
821 FunctionType *FTy = FunctionType::get(Type::getVoidTy(*Ctx), false);
822 return M->getOrInsertFunction("llvm_gcda_end_file", FTy);
823 }
824
getEdgeStateValue()825 GlobalVariable *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
insertCounterWriteout(ArrayRef<std::pair<GlobalVariable *,MDNode * >> CountersBySP)838 Function *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
insertIndirectCounterIncrement()897 void 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
948 Function *GCOVProfiler::
insertFlush(ArrayRef<std::pair<GlobalVariable *,MDNode * >> CountersBySP)949 insertFlush(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 }
991