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