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