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