GCOVProfiling.cpp revision 309124
1221337Sdim//===- GCOVProfiling.cpp - Insert edge counters for gcov profiling --------===// 2221337Sdim// 3221337Sdim// The LLVM Compiler Infrastructure 4221337Sdim// 5221337Sdim// This file is distributed under the University of Illinois Open Source 6221337Sdim// License. See LICENSE.TXT for details. 7221337Sdim// 8221337Sdim//===----------------------------------------------------------------------===// 9221337Sdim// 10221337Sdim// This pass implements GCOV-style profiling. When this pass is run it emits 11221337Sdim// "gcno" files next to the existing source, and instruments the code that runs 12221337Sdim// to records the edges between blocks that run and emit a complementary "gcda" 13221337Sdim// file on exit. 14221337Sdim// 15221337Sdim//===----------------------------------------------------------------------===// 16221337Sdim 17221337Sdim#include "llvm/ADT/DenseMap.h" 18276479Sdim#include "llvm/ADT/Hashing.h" 19239462Sdim#include "llvm/ADT/STLExtras.h" 20221337Sdim#include "llvm/ADT/Statistic.h" 21221337Sdim#include "llvm/ADT/StringExtras.h" 22221337Sdim#include "llvm/ADT/StringMap.h" 23221337Sdim#include "llvm/ADT/UniqueVector.h" 24276479Sdim#include "llvm/IR/DebugInfo.h" 25276479Sdim#include "llvm/IR/DebugLoc.h" 26249423Sdim#include "llvm/IR/IRBuilder.h" 27276479Sdim#include "llvm/IR/InstIterator.h" 28249423Sdim#include "llvm/IR/Instructions.h" 29276479Sdim#include "llvm/IR/IntrinsicInst.h" 30249423Sdim#include "llvm/IR/Module.h" 31249423Sdim#include "llvm/Pass.h" 32249423Sdim#include "llvm/Support/CommandLine.h" 33239462Sdim#include "llvm/Support/Debug.h" 34249423Sdim#include "llvm/Support/FileSystem.h" 35261991Sdim#include "llvm/Support/Path.h" 36239462Sdim#include "llvm/Support/raw_ostream.h" 37309124Sdim#include "llvm/Transforms/GCOVProfiler.h" 38309124Sdim#include "llvm/Transforms/Instrumentation.h" 39239462Sdim#include "llvm/Transforms/Utils/ModuleUtils.h" 40261991Sdim#include <algorithm> 41276479Sdim#include <memory> 42221337Sdim#include <string> 43221337Sdim#include <utility> 44221337Sdimusing namespace llvm; 45221337Sdim 46276479Sdim#define DEBUG_TYPE "insert-gcov-profiling" 47276479Sdim 48249423Sdimstatic cl::opt<std::string> 49249423SdimDefaultGCOVVersion("default-gcov-version", cl::init("402*"), cl::Hidden, 50249423Sdim cl::ValueRequired); 51283526Sdimstatic cl::opt<bool> DefaultExitBlockBeforeBody("gcov-exit-block-before-body", 52283526Sdim cl::init(false), cl::Hidden); 53249423Sdim 54249423SdimGCOVOptions GCOVOptions::getDefault() { 55249423Sdim GCOVOptions Options; 56249423Sdim Options.EmitNotes = true; 57249423Sdim Options.EmitData = true; 58249423Sdim Options.UseCfgChecksum = false; 59249423Sdim Options.NoRedZone = false; 60249423Sdim Options.FunctionNamesInData = true; 61288943Sdim Options.ExitBlockBeforeBody = DefaultExitBlockBeforeBody; 62249423Sdim 63249423Sdim if (DefaultGCOVVersion.size() != 4) { 64249423Sdim llvm::report_fatal_error(std::string("Invalid -default-gcov-version: ") + 65249423Sdim DefaultGCOVVersion); 66249423Sdim } 67249423Sdim memcpy(Options.Version, DefaultGCOVVersion.c_str(), 4); 68249423Sdim return Options; 69249423Sdim} 70249423Sdim 71221337Sdimnamespace { 72309124Sdimclass GCOVFunction; 73276479Sdim 74309124Sdimclass GCOVProfiler { 75309124Sdimpublic: 76309124Sdim GCOVProfiler() : GCOVProfiler(GCOVOptions::getDefault()) {} 77309124Sdim GCOVProfiler(const GCOVOptions &Opts) : Options(Opts) { 78309124Sdim assert((Options.EmitNotes || Options.EmitData) && 79309124Sdim "GCOVProfiler asked to do nothing?"); 80309124Sdim ReversedVersion[0] = Options.Version[3]; 81309124Sdim ReversedVersion[1] = Options.Version[2]; 82309124Sdim ReversedVersion[2] = Options.Version[1]; 83309124Sdim ReversedVersion[3] = Options.Version[0]; 84309124Sdim ReversedVersion[4] = '\0'; 85309124Sdim } 86309124Sdim bool runOnModule(Module &M); 87288943Sdim 88309124Sdimprivate: 89309124Sdim // Create the .gcno files for the Module based on DebugInfo. 90309124Sdim void emitProfileNotes(); 91249423Sdim 92309124Sdim // Modify the program to track transitions along edges and call into the 93309124Sdim // profiling runtime to emit .gcda files when run. 94309124Sdim bool emitProfileArcs(); 95221337Sdim 96309124Sdim // Get pointers to the functions in the runtime library. 97309124Sdim Constant *getStartFileFunc(); 98309124Sdim Constant *getIncrementIndirectCounterFunc(); 99309124Sdim Constant *getEmitFunctionFunc(); 100309124Sdim Constant *getEmitArcsFunc(); 101309124Sdim Constant *getSummaryInfoFunc(); 102309124Sdim Constant *getEndFileFunc(); 103221337Sdim 104309124Sdim // Create or retrieve an i32 state value that is used to represent the 105309124Sdim // pred block number for certain non-trivial edges. 106309124Sdim GlobalVariable *getEdgeStateValue(); 107221337Sdim 108309124Sdim // Produce a table of pointers to counters, by predecessor and successor 109309124Sdim // block number. 110309124Sdim GlobalVariable *buildEdgeLookupTable(Function *F, GlobalVariable *Counter, 111309124Sdim const UniqueVector<BasicBlock *> &Preds, 112309124Sdim const UniqueVector<BasicBlock *> &Succs); 113221337Sdim 114309124Sdim // Add the function to write out all our counters to the global destructor 115309124Sdim // list. 116309124Sdim Function * 117309124Sdim insertCounterWriteout(ArrayRef<std::pair<GlobalVariable *, MDNode *>>); 118309124Sdim Function *insertFlush(ArrayRef<std::pair<GlobalVariable *, MDNode *>>); 119309124Sdim void insertIndirectCounterIncrement(); 120221337Sdim 121309124Sdim std::string mangleName(const DICompileUnit *CU, const char *NewStem); 122221337Sdim 123309124Sdim GCOVOptions Options; 124223017Sdim 125309124Sdim // Reversed, NUL-terminated copy of Options.Version. 126309124Sdim char ReversedVersion[5]; 127309124Sdim // Checksum, produced by hash of EdgeDestinations 128309124Sdim SmallVector<uint32_t, 4> FileChecksums; 129221337Sdim 130309124Sdim Module *M; 131309124Sdim LLVMContext *Ctx; 132309124Sdim SmallVector<std::unique_ptr<GCOVFunction>, 16> Funcs; 133309124Sdim}; 134249423Sdim 135309124Sdimclass GCOVProfilerLegacyPass : public ModulePass { 136309124Sdimpublic: 137309124Sdim static char ID; 138309124Sdim GCOVProfilerLegacyPass() 139309124Sdim : GCOVProfilerLegacyPass(GCOVOptions::getDefault()) {} 140309124Sdim GCOVProfilerLegacyPass(const GCOVOptions &Opts) 141309124Sdim : ModulePass(ID), Profiler(Opts) { 142309124Sdim initializeGCOVProfilerLegacyPassPass(*PassRegistry::getPassRegistry()); 143309124Sdim } 144309124Sdim const char *getPassName() const override { return "GCOV Profiler"; } 145309124Sdim 146309124Sdim bool runOnModule(Module &M) override { return Profiler.runOnModule(M); } 147309124Sdim 148309124Sdimprivate: 149309124Sdim GCOVProfiler Profiler; 150309124Sdim}; 151221337Sdim} 152221337Sdim 153309124Sdimchar GCOVProfilerLegacyPass::ID = 0; 154309124SdimINITIALIZE_PASS(GCOVProfilerLegacyPass, "insert-gcov-profiling", 155221337Sdim "Insert instrumentation for GCOV profiling", false, false) 156221337Sdim 157249423SdimModulePass *llvm::createGCOVProfilerPass(const GCOVOptions &Options) { 158309124Sdim return new GCOVProfilerLegacyPass(Options); 159221337Sdim} 160221337Sdim 161288943Sdimstatic StringRef getFunctionName(const DISubprogram *SP) { 162288943Sdim if (!SP->getLinkageName().empty()) 163288943Sdim return SP->getLinkageName(); 164288943Sdim return SP->getName(); 165249423Sdim} 166249423Sdim 167221337Sdimnamespace { 168221337Sdim class GCOVRecord { 169221337Sdim protected: 170261991Sdim static const char *const LinesTag; 171261991Sdim static const char *const FunctionTag; 172261991Sdim static const char *const BlockTag; 173261991Sdim static const char *const EdgeTag; 174221337Sdim 175288943Sdim GCOVRecord() = default; 176221337Sdim 177221337Sdim void writeBytes(const char *Bytes, int Size) { 178221337Sdim os->write(Bytes, Size); 179221337Sdim } 180221337Sdim 181221337Sdim void write(uint32_t i) { 182221337Sdim writeBytes(reinterpret_cast<char*>(&i), 4); 183221337Sdim } 184221337Sdim 185221337Sdim // Returns the length measured in 4-byte blocks that will be used to 186221337Sdim // represent this string in a GCOV file 187261991Sdim static unsigned lengthOfGCOVString(StringRef s) { 188221337Sdim // A GCOV string is a length, followed by a NUL, then between 0 and 3 NULs 189221337Sdim // padding out to the next 4-byte word. The length is measured in 4-byte 190221337Sdim // words including padding, not bytes of actual string. 191223017Sdim return (s.size() / 4) + 1; 192221337Sdim } 193221337Sdim 194221337Sdim void writeGCOVString(StringRef s) { 195221337Sdim uint32_t Len = lengthOfGCOVString(s); 196221337Sdim write(Len); 197221337Sdim writeBytes(s.data(), s.size()); 198221337Sdim 199221337Sdim // Write 1 to 4 bytes of NUL padding. 200221337Sdim assert((unsigned)(4 - (s.size() % 4)) > 0); 201221337Sdim assert((unsigned)(4 - (s.size() % 4)) <= 4); 202221337Sdim writeBytes("\0\0\0\0", 4 - (s.size() % 4)); 203221337Sdim } 204221337Sdim 205221337Sdim raw_ostream *os; 206221337Sdim }; 207261991Sdim const char *const GCOVRecord::LinesTag = "\0\0\x45\x01"; 208261991Sdim const char *const GCOVRecord::FunctionTag = "\0\0\0\1"; 209261991Sdim const char *const GCOVRecord::BlockTag = "\0\0\x41\x01"; 210261991Sdim const char *const GCOVRecord::EdgeTag = "\0\0\x43\x01"; 211221337Sdim 212221337Sdim class GCOVFunction; 213221337Sdim class GCOVBlock; 214221337Sdim 215221337Sdim // Constructed only by requesting it from a GCOVBlock, this object stores a 216221337Sdim // list of line numbers and a single filename, representing lines that belong 217221337Sdim // to the block. 218221337Sdim class GCOVLines : public GCOVRecord { 219221337Sdim public: 220221337Sdim void addLine(uint32_t Line) { 221276479Sdim assert(Line != 0 && "Line zero is not a valid real line number."); 222221337Sdim Lines.push_back(Line); 223221337Sdim } 224221337Sdim 225261991Sdim uint32_t length() const { 226234353Sdim // Here 2 = 1 for string length + 1 for '0' id#. 227221337Sdim return lengthOfGCOVString(Filename) + 2 + Lines.size(); 228221337Sdim } 229221337Sdim 230226633Sdim void writeOut() { 231226633Sdim write(0); 232226633Sdim writeGCOVString(Filename); 233226633Sdim for (int i = 0, e = Lines.size(); i != e; ++i) 234226633Sdim write(Lines[i]); 235226633Sdim } 236221337Sdim 237276479Sdim GCOVLines(StringRef F, raw_ostream *os) 238226633Sdim : Filename(F) { 239221337Sdim this->os = os; 240221337Sdim } 241221337Sdim 242226633Sdim private: 243226633Sdim StringRef Filename; 244221337Sdim SmallVector<uint32_t, 32> Lines; 245221337Sdim }; 246221337Sdim 247261991Sdim 248221337Sdim // Represent a basic block in GCOV. Each block has a unique number in the 249221337Sdim // function, number of lines belonging to each block, and a set of edges to 250221337Sdim // other blocks. 251221337Sdim class GCOVBlock : public GCOVRecord { 252221337Sdim public: 253226633Sdim GCOVLines &getFile(StringRef Filename) { 254221337Sdim GCOVLines *&Lines = LinesByFile[Filename]; 255221337Sdim if (!Lines) { 256221337Sdim Lines = new GCOVLines(Filename, os); 257221337Sdim } 258221337Sdim return *Lines; 259221337Sdim } 260221337Sdim 261221337Sdim void addEdge(GCOVBlock &Successor) { 262221337Sdim OutEdges.push_back(&Successor); 263221337Sdim } 264221337Sdim 265221337Sdim void writeOut() { 266221337Sdim uint32_t Len = 3; 267261991Sdim SmallVector<StringMapEntry<GCOVLines *> *, 32> SortedLinesByFile; 268309124Sdim for (auto &I : LinesByFile) { 269309124Sdim Len += I.second->length(); 270309124Sdim SortedLinesByFile.push_back(&I); 271221337Sdim } 272221337Sdim 273221337Sdim writeBytes(LinesTag, 4); 274221337Sdim write(Len); 275221337Sdim write(Number); 276261991Sdim 277276479Sdim std::sort(SortedLinesByFile.begin(), SortedLinesByFile.end(), 278276479Sdim [](StringMapEntry<GCOVLines *> *LHS, 279276479Sdim StringMapEntry<GCOVLines *> *RHS) { 280276479Sdim return LHS->getKey() < RHS->getKey(); 281276479Sdim }); 282309124Sdim for (auto &I : SortedLinesByFile) 283309124Sdim I->getValue()->writeOut(); 284221337Sdim write(0); 285221337Sdim write(0); 286221337Sdim } 287221337Sdim 288221337Sdim ~GCOVBlock() { 289221337Sdim DeleteContainerSeconds(LinesByFile); 290221337Sdim } 291221337Sdim 292280031Sdim GCOVBlock(const GCOVBlock &RHS) : GCOVRecord(RHS), Number(RHS.Number) { 293280031Sdim // Only allow copy before edges and lines have been added. After that, 294280031Sdim // there are inter-block pointers (eg: edges) that won't take kindly to 295280031Sdim // blocks being copied or moved around. 296280031Sdim assert(LinesByFile.empty()); 297280031Sdim assert(OutEdges.empty()); 298280031Sdim } 299280031Sdim 300221337Sdim private: 301221337Sdim friend class GCOVFunction; 302221337Sdim 303221337Sdim GCOVBlock(uint32_t Number, raw_ostream *os) 304221337Sdim : Number(Number) { 305221337Sdim this->os = os; 306221337Sdim } 307221337Sdim 308221337Sdim uint32_t Number; 309221337Sdim StringMap<GCOVLines *> LinesByFile; 310221337Sdim SmallVector<GCOVBlock *, 4> OutEdges; 311221337Sdim }; 312221337Sdim 313221337Sdim // A function has a unique identifier, a checksum (we leave as zero) and a 314221337Sdim // set of blocks and a map of edges between blocks. This is the only GCOV 315221337Sdim // object users can construct, the blocks and lines will be rooted here. 316221337Sdim class GCOVFunction : public GCOVRecord { 317221337Sdim public: 318296417Sdim GCOVFunction(const DISubprogram *SP, Function *F, raw_ostream *os, 319296417Sdim uint32_t Ident, bool UseCfgChecksum, bool ExitBlockBeforeBody) 320280031Sdim : SP(SP), Ident(Ident), UseCfgChecksum(UseCfgChecksum), CfgChecksum(0), 321280031Sdim ReturnBlock(1, os) { 322221337Sdim this->os = os; 323221337Sdim 324276479Sdim DEBUG(dbgs() << "Function: " << getFunctionName(SP) << "\n"); 325280031Sdim 326221337Sdim uint32_t i = 0; 327280031Sdim for (auto &BB : *F) { 328283526Sdim // Skip index 1 if it's assigned to the ReturnBlock. 329283526Sdim if (i == 1 && ExitBlockBeforeBody) 330283526Sdim ++i; 331283526Sdim Blocks.insert(std::make_pair(&BB, GCOVBlock(i++, os))); 332221337Sdim } 333283526Sdim if (!ExitBlockBeforeBody) 334283526Sdim ReturnBlock.Number = i; 335221337Sdim 336276479Sdim std::string FunctionNameAndLine; 337276479Sdim raw_string_ostream FNLOS(FunctionNameAndLine); 338288943Sdim FNLOS << getFunctionName(SP) << SP->getLine(); 339276479Sdim FNLOS.flush(); 340276479Sdim FuncChecksum = hash_value(FunctionNameAndLine); 341221337Sdim } 342221337Sdim 343221337Sdim GCOVBlock &getBlock(BasicBlock *BB) { 344280031Sdim return Blocks.find(BB)->second; 345221337Sdim } 346221337Sdim 347221337Sdim GCOVBlock &getReturnBlock() { 348280031Sdim return ReturnBlock; 349221337Sdim } 350221337Sdim 351276479Sdim std::string getEdgeDestinations() { 352276479Sdim std::string EdgeDestinations; 353276479Sdim raw_string_ostream EDOS(EdgeDestinations); 354276479Sdim Function *F = Blocks.begin()->first->getParent(); 355296417Sdim for (BasicBlock &I : *F) { 356296417Sdim GCOVBlock &Block = getBlock(&I); 357276479Sdim for (int i = 0, e = Block.OutEdges.size(); i != e; ++i) 358276479Sdim EDOS << Block.OutEdges[i]->Number; 359276479Sdim } 360276479Sdim return EdgeDestinations; 361276479Sdim } 362276479Sdim 363276479Sdim uint32_t getFuncChecksum() { 364276479Sdim return FuncChecksum; 365276479Sdim } 366276479Sdim 367276479Sdim void setCfgChecksum(uint32_t Checksum) { 368276479Sdim CfgChecksum = Checksum; 369276479Sdim } 370276479Sdim 371221337Sdim void writeOut() { 372276479Sdim writeBytes(FunctionTag, 4); 373276479Sdim uint32_t BlockLen = 1 + 1 + 1 + lengthOfGCOVString(getFunctionName(SP)) + 374288943Sdim 1 + lengthOfGCOVString(SP->getFilename()) + 1; 375276479Sdim if (UseCfgChecksum) 376276479Sdim ++BlockLen; 377276479Sdim write(BlockLen); 378276479Sdim write(Ident); 379276479Sdim write(FuncChecksum); 380276479Sdim if (UseCfgChecksum) 381276479Sdim write(CfgChecksum); 382276479Sdim writeGCOVString(getFunctionName(SP)); 383288943Sdim writeGCOVString(SP->getFilename()); 384288943Sdim write(SP->getLine()); 385276479Sdim 386221337Sdim // Emit count of blocks. 387221337Sdim writeBytes(BlockTag, 4); 388221337Sdim write(Blocks.size() + 1); 389221337Sdim for (int i = 0, e = Blocks.size() + 1; i != e; ++i) { 390221337Sdim write(0); // No flags on our blocks. 391221337Sdim } 392234353Sdim DEBUG(dbgs() << Blocks.size() << " blocks.\n"); 393221337Sdim 394221337Sdim // Emit edges between blocks. 395261991Sdim if (Blocks.empty()) return; 396261991Sdim Function *F = Blocks.begin()->first->getParent(); 397296417Sdim for (BasicBlock &I : *F) { 398296417Sdim GCOVBlock &Block = getBlock(&I); 399221337Sdim if (Block.OutEdges.empty()) continue; 400221337Sdim 401221337Sdim writeBytes(EdgeTag, 4); 402221337Sdim write(Block.OutEdges.size() * 2 + 1); 403221337Sdim write(Block.Number); 404221337Sdim for (int i = 0, e = Block.OutEdges.size(); i != e; ++i) { 405234353Sdim DEBUG(dbgs() << Block.Number << " -> " << Block.OutEdges[i]->Number 406234353Sdim << "\n"); 407221337Sdim write(Block.OutEdges[i]->Number); 408221337Sdim write(0); // no flags 409221337Sdim } 410221337Sdim } 411221337Sdim 412221337Sdim // Emit lines for each block. 413296417Sdim for (BasicBlock &I : *F) 414296417Sdim getBlock(&I).writeOut(); 415221337Sdim } 416221337Sdim 417221337Sdim private: 418288943Sdim const DISubprogram *SP; 419276479Sdim uint32_t Ident; 420276479Sdim uint32_t FuncChecksum; 421276479Sdim bool UseCfgChecksum; 422276479Sdim uint32_t CfgChecksum; 423280031Sdim DenseMap<BasicBlock *, GCOVBlock> Blocks; 424280031Sdim GCOVBlock ReturnBlock; 425221337Sdim }; 426221337Sdim} 427221337Sdim 428288943Sdimstd::string GCOVProfiler::mangleName(const DICompileUnit *CU, 429288943Sdim const char *NewStem) { 430223017Sdim if (NamedMDNode *GCov = M->getNamedMetadata("llvm.gcov")) { 431223017Sdim for (int i = 0, e = GCov->getNumOperands(); i != e; ++i) { 432223017Sdim MDNode *N = GCov->getOperand(i); 433223017Sdim if (N->getNumOperands() != 2) continue; 434223017Sdim MDString *GCovFile = dyn_cast<MDString>(N->getOperand(0)); 435223017Sdim MDNode *CompileUnit = dyn_cast<MDNode>(N->getOperand(1)); 436223017Sdim if (!GCovFile || !CompileUnit) continue; 437223017Sdim if (CompileUnit == CU) { 438223017Sdim SmallString<128> Filename = GCovFile->getString(); 439223017Sdim sys::path::replace_extension(Filename, NewStem); 440223017Sdim return Filename.str(); 441223017Sdim } 442223017Sdim } 443223017Sdim } 444223017Sdim 445288943Sdim SmallString<128> Filename = CU->getFilename(); 446223017Sdim sys::path::replace_extension(Filename, NewStem); 447249423Sdim StringRef FName = sys::path::filename(Filename); 448249423Sdim SmallString<128> CurPath; 449249423Sdim if (sys::fs::current_path(CurPath)) return FName; 450288943Sdim sys::path::append(CurPath, FName); 451249423Sdim return CurPath.str(); 452221337Sdim} 453221337Sdim 454221337Sdimbool GCOVProfiler::runOnModule(Module &M) { 455221337Sdim this->M = &M; 456221337Sdim Ctx = &M.getContext(); 457221337Sdim 458249423Sdim if (Options.EmitNotes) emitProfileNotes(); 459249423Sdim if (Options.EmitData) return emitProfileArcs(); 460221337Sdim return false; 461221337Sdim} 462221337Sdim 463309124SdimPreservedAnalyses GCOVProfilerPass::run(Module &M, 464309124Sdim AnalysisManager<Module> &AM) { 465309124Sdim 466309124Sdim GCOVProfiler Profiler(GCOVOpts); 467309124Sdim 468309124Sdim if (!Profiler.runOnModule(M)) 469309124Sdim return PreservedAnalyses::all(); 470309124Sdim 471309124Sdim return PreservedAnalyses::none(); 472309124Sdim} 473309124Sdim 474309124Sdimstatic bool functionHasLines(Function &F) { 475276479Sdim // Check whether this function actually has any source lines. Not only 476276479Sdim // do these waste space, they also can crash gcov. 477309124Sdim for (auto &BB : F) { 478309124Sdim for (auto &I : BB) { 479276479Sdim // Debug intrinsic locations correspond to the location of the 480276479Sdim // declaration, not necessarily any statements or expressions. 481309124Sdim if (isa<DbgInfoIntrinsic>(&I)) continue; 482276479Sdim 483309124Sdim const DebugLoc &Loc = I.getDebugLoc(); 484288943Sdim if (!Loc) 485288943Sdim continue; 486276479Sdim 487276479Sdim // Artificial lines such as calls to the global constructors. 488283526Sdim if (Loc.getLine() == 0) continue; 489276479Sdim 490276479Sdim return true; 491276479Sdim } 492276479Sdim } 493276479Sdim return false; 494276479Sdim} 495276479Sdim 496249423Sdimvoid GCOVProfiler::emitProfileNotes() { 497226633Sdim NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu"); 498234353Sdim if (!CU_Nodes) return; 499234353Sdim 500234353Sdim for (unsigned i = 0, e = CU_Nodes->getNumOperands(); i != e; ++i) { 501234353Sdim // Each compile unit gets its own .gcno file. This means that whether we run 502234353Sdim // this pass over the original .o's as they're produced, or run it after 503234353Sdim // LTO, we'll generate the same .gcno files. 504234353Sdim 505288943Sdim auto *CU = cast<DICompileUnit>(CU_Nodes->getOperand(i)); 506296417Sdim 507296417Sdim // Skip module skeleton (and module) CUs. 508296417Sdim if (CU->getDWOId()) 509296417Sdim continue; 510296417Sdim 511280031Sdim std::error_code EC; 512280031Sdim raw_fd_ostream out(mangleName(CU, "gcno"), EC, sys::fs::F_None); 513276479Sdim std::string EdgeDestinations; 514234353Sdim 515280031Sdim unsigned FunctionIdent = 0; 516309124Sdim for (auto &F : M->functions()) { 517309124Sdim DISubprogram *SP = F.getSubprogram(); 518309124Sdim if (!SP) continue; 519276479Sdim if (!functionHasLines(F)) continue; 520234353Sdim 521276479Sdim // gcov expects every function to start with an entry block that has a 522276479Sdim // single successor, so split the entry block to make sure of that. 523309124Sdim BasicBlock &EntryBlock = F.getEntryBlock(); 524276479Sdim BasicBlock::iterator It = EntryBlock.begin(); 525276479Sdim while (isa<AllocaInst>(*It) || isa<DbgInfoIntrinsic>(*It)) 526276479Sdim ++It; 527276479Sdim EntryBlock.splitBasicBlock(It); 528276479Sdim 529309124Sdim Funcs.push_back(make_unique<GCOVFunction>(SP, &F, &out, FunctionIdent++, 530283526Sdim Options.UseCfgChecksum, 531288943Sdim Options.ExitBlockBeforeBody)); 532276479Sdim GCOVFunction &Func = *Funcs.back(); 533276479Sdim 534309124Sdim for (auto &BB : F) { 535309124Sdim GCOVBlock &Block = Func.getBlock(&BB); 536309124Sdim TerminatorInst *TI = BB.getTerminator(); 537234353Sdim if (int successors = TI->getNumSuccessors()) { 538234353Sdim for (int i = 0; i != successors; ++i) { 539234353Sdim Block.addEdge(Func.getBlock(TI->getSuccessor(i))); 540226633Sdim } 541234353Sdim } else if (isa<ReturnInst>(TI)) { 542234353Sdim Block.addEdge(Func.getReturnBlock()); 543221337Sdim } 544234353Sdim 545234353Sdim uint32_t Line = 0; 546309124Sdim for (auto &I : BB) { 547276479Sdim // Debug intrinsic locations correspond to the location of the 548276479Sdim // declaration, not necessarily any statements or expressions. 549309124Sdim if (isa<DbgInfoIntrinsic>(&I)) continue; 550276479Sdim 551309124Sdim const DebugLoc &Loc = I.getDebugLoc(); 552288943Sdim if (!Loc) 553288943Sdim continue; 554276479Sdim 555276479Sdim // Artificial lines such as calls to the global constructors. 556276479Sdim if (Loc.getLine() == 0) continue; 557276479Sdim 558234353Sdim if (Line == Loc.getLine()) continue; 559234353Sdim Line = Loc.getLine(); 560288943Sdim if (SP != getDISubprogram(Loc.getScope())) 561288943Sdim continue; 562234353Sdim 563288943Sdim GCOVLines &Lines = Block.getFile(SP->getFilename()); 564234353Sdim Lines.addLine(Loc.getLine()); 565234353Sdim } 566221337Sdim } 567276479Sdim EdgeDestinations += Func.getEdgeDestinations(); 568221337Sdim } 569276479Sdim 570276479Sdim FileChecksums.push_back(hash_value(EdgeDestinations)); 571276479Sdim out.write("oncg", 4); 572276479Sdim out.write(ReversedVersion, 4); 573276479Sdim out.write(reinterpret_cast<char*>(&FileChecksums.back()), 4); 574276479Sdim 575276479Sdim for (auto &Func : Funcs) { 576276479Sdim Func->setCfgChecksum(FileChecksums.back()); 577276479Sdim Func->writeOut(); 578276479Sdim } 579276479Sdim 580234353Sdim out.write("\0\0\0\0\0\0\0\0", 8); // EOF 581234353Sdim out.close(); 582221337Sdim } 583221337Sdim} 584221337Sdim 585226633Sdimbool GCOVProfiler::emitProfileArcs() { 586226633Sdim NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu"); 587226633Sdim if (!CU_Nodes) return false; 588221337Sdim 589276479Sdim bool Result = false; 590239462Sdim bool InsertIndCounterIncrCode = false; 591226633Sdim for (unsigned i = 0, e = CU_Nodes->getNumOperands(); i != e; ++i) { 592226633Sdim SmallVector<std::pair<GlobalVariable *, MDNode *>, 8> CountersBySP; 593309124Sdim for (auto &F : M->functions()) { 594309124Sdim DISubprogram *SP = F.getSubprogram(); 595309124Sdim if (!SP) continue; 596276479Sdim if (!functionHasLines(F)) continue; 597226633Sdim if (!Result) Result = true; 598226633Sdim unsigned Edges = 0; 599309124Sdim for (auto &BB : F) { 600309124Sdim TerminatorInst *TI = BB.getTerminator(); 601226633Sdim if (isa<ReturnInst>(TI)) 602226633Sdim ++Edges; 603226633Sdim else 604226633Sdim Edges += TI->getNumSuccessors(); 605226633Sdim } 606276479Sdim 607226633Sdim ArrayType *CounterTy = 608221337Sdim ArrayType::get(Type::getInt64Ty(*Ctx), Edges); 609226633Sdim GlobalVariable *Counters = 610221337Sdim new GlobalVariable(*M, CounterTy, false, 611221337Sdim GlobalValue::InternalLinkage, 612221337Sdim Constant::getNullValue(CounterTy), 613239462Sdim "__llvm_gcov_ctr"); 614288943Sdim CountersBySP.push_back(std::make_pair(Counters, SP)); 615276479Sdim 616226633Sdim UniqueVector<BasicBlock *> ComplexEdgePreds; 617226633Sdim UniqueVector<BasicBlock *> ComplexEdgeSuccs; 618276479Sdim 619226633Sdim unsigned Edge = 0; 620309124Sdim for (auto &BB : F) { 621309124Sdim TerminatorInst *TI = BB.getTerminator(); 622226633Sdim int Successors = isa<ReturnInst>(TI) ? 1 : TI->getNumSuccessors(); 623226633Sdim if (Successors) { 624226633Sdim if (Successors == 1) { 625309124Sdim IRBuilder<> Builder(&*BB.getFirstInsertionPt()); 626226633Sdim Value *Counter = Builder.CreateConstInBoundsGEP2_64(Counters, 0, 627226633Sdim Edge); 628226633Sdim Value *Count = Builder.CreateLoad(Counter); 629249423Sdim Count = Builder.CreateAdd(Count, Builder.getInt64(1)); 630226633Sdim Builder.CreateStore(Count, Counter); 631226633Sdim } else if (BranchInst *BI = dyn_cast<BranchInst>(TI)) { 632261991Sdim IRBuilder<> Builder(BI); 633249423Sdim Value *Sel = Builder.CreateSelect(BI->getCondition(), 634249423Sdim Builder.getInt64(Edge), 635249423Sdim Builder.getInt64(Edge + 1)); 636309124Sdim Value *Counter = Builder.CreateInBoundsGEP( 637309124Sdim Counters->getValueType(), Counters, {Builder.getInt64(0), Sel}); 638226633Sdim Value *Count = Builder.CreateLoad(Counter); 639249423Sdim Count = Builder.CreateAdd(Count, Builder.getInt64(1)); 640226633Sdim Builder.CreateStore(Count, Counter); 641226633Sdim } else { 642309124Sdim ComplexEdgePreds.insert(&BB); 643226633Sdim for (int i = 0; i != Successors; ++i) 644226633Sdim ComplexEdgeSuccs.insert(TI->getSuccessor(i)); 645226633Sdim } 646261991Sdim 647226633Sdim Edge += Successors; 648221337Sdim } 649221337Sdim } 650276479Sdim 651226633Sdim if (!ComplexEdgePreds.empty()) { 652226633Sdim GlobalVariable *EdgeTable = 653309124Sdim buildEdgeLookupTable(&F, Counters, 654221337Sdim ComplexEdgePreds, ComplexEdgeSuccs); 655226633Sdim GlobalVariable *EdgeState = getEdgeStateValue(); 656276479Sdim 657226633Sdim for (int i = 0, e = ComplexEdgePreds.size(); i != e; ++i) { 658296417Sdim IRBuilder<> Builder(&*ComplexEdgePreds[i + 1]->getFirstInsertionPt()); 659249423Sdim Builder.CreateStore(Builder.getInt32(i), EdgeState); 660226633Sdim } 661261991Sdim 662226633Sdim for (int i = 0, e = ComplexEdgeSuccs.size(); i != e; ++i) { 663261991Sdim // Call runtime to perform increment. 664296417Sdim IRBuilder<> Builder(&*ComplexEdgeSuccs[i + 1]->getFirstInsertionPt()); 665226633Sdim Value *CounterPtrArray = 666221337Sdim Builder.CreateConstInBoundsGEP2_64(EdgeTable, 0, 667221337Sdim i * ComplexEdgePreds.size()); 668239462Sdim 669239462Sdim // Build code to increment the counter. 670239462Sdim InsertIndCounterIncrCode = true; 671288943Sdim Builder.CreateCall(getIncrementIndirectCounterFunc(), 672288943Sdim {EdgeState, CounterPtrArray}); 673226633Sdim } 674221337Sdim } 675221337Sdim } 676239462Sdim 677249423Sdim Function *WriteoutF = insertCounterWriteout(CountersBySP); 678249423Sdim Function *FlushF = insertFlush(CountersBySP); 679249423Sdim 680249423Sdim // Create a small bit of code that registers the "__llvm_gcov_writeout" to 681249423Sdim // be executed at exit and the "__llvm_gcov_flush" function to be executed 682249423Sdim // when "__gcov_flush" is called. 683249423Sdim FunctionType *FTy = FunctionType::get(Type::getVoidTy(*Ctx), false); 684249423Sdim Function *F = Function::Create(FTy, GlobalValue::InternalLinkage, 685249423Sdim "__llvm_gcov_init", M); 686309124Sdim F->setUnnamedAddr(GlobalValue::UnnamedAddr::Global); 687249423Sdim F->setLinkage(GlobalValue::InternalLinkage); 688249423Sdim F->addFnAttr(Attribute::NoInline); 689249423Sdim if (Options.NoRedZone) 690249423Sdim F->addFnAttr(Attribute::NoRedZone); 691249423Sdim 692249423Sdim BasicBlock *BB = BasicBlock::Create(*Ctx, "entry", F); 693249423Sdim IRBuilder<> Builder(BB); 694249423Sdim 695249423Sdim FTy = FunctionType::get(Type::getVoidTy(*Ctx), false); 696249423Sdim Type *Params[] = { 697249423Sdim PointerType::get(FTy, 0), 698249423Sdim PointerType::get(FTy, 0) 699249423Sdim }; 700249423Sdim FTy = FunctionType::get(Builder.getVoidTy(), Params, false); 701249423Sdim 702261991Sdim // Initialize the environment and register the local writeout and flush 703249423Sdim // functions. 704249423Sdim Constant *GCOVInit = M->getOrInsertFunction("llvm_gcov_init", FTy); 705288943Sdim Builder.CreateCall(GCOVInit, {WriteoutF, FlushF}); 706249423Sdim Builder.CreateRetVoid(); 707249423Sdim 708249423Sdim appendToGlobalCtors(*M, F, 0); 709221337Sdim } 710239462Sdim 711239462Sdim if (InsertIndCounterIncrCode) 712239462Sdim insertIndirectCounterIncrement(); 713239462Sdim 714226633Sdim return Result; 715221337Sdim} 716221337Sdim 717221337Sdim// All edges with successors that aren't branches are "complex", because it 718221337Sdim// requires complex logic to pick which counter to update. 719221337SdimGlobalVariable *GCOVProfiler::buildEdgeLookupTable( 720221337Sdim Function *F, 721221337Sdim GlobalVariable *Counters, 722221337Sdim const UniqueVector<BasicBlock *> &Preds, 723221337Sdim const UniqueVector<BasicBlock *> &Succs) { 724221337Sdim // TODO: support invoke, threads. We rely on the fact that nothing can modify 725221337Sdim // the whole-Module pred edge# between the time we set it and the time we next 726221337Sdim // read it. Threads and invoke make this untrue. 727221337Sdim 728221337Sdim // emit [(succs * preds) x i64*], logically [succ x [pred x i64*]]. 729249423Sdim size_t TableSize = Succs.size() * Preds.size(); 730226633Sdim Type *Int64PtrTy = Type::getInt64PtrTy(*Ctx); 731249423Sdim ArrayType *EdgeTableTy = ArrayType::get(Int64PtrTy, TableSize); 732221337Sdim 733276479Sdim std::unique_ptr<Constant * []> EdgeTable(new Constant *[TableSize]); 734221337Sdim Constant *NullValue = Constant::getNullValue(Int64PtrTy); 735249423Sdim for (size_t i = 0; i != TableSize; ++i) 736221337Sdim EdgeTable[i] = NullValue; 737221337Sdim 738221337Sdim unsigned Edge = 0; 739309124Sdim for (BasicBlock &BB : *F) { 740309124Sdim TerminatorInst *TI = BB.getTerminator(); 741221337Sdim int Successors = isa<ReturnInst>(TI) ? 1 : TI->getNumSuccessors(); 742221337Sdim if (Successors > 1 && !isa<BranchInst>(TI) && !isa<ReturnInst>(TI)) { 743221337Sdim for (int i = 0; i != Successors; ++i) { 744221337Sdim BasicBlock *Succ = TI->getSuccessor(i); 745249423Sdim IRBuilder<> Builder(Succ); 746249423Sdim Value *Counter = Builder.CreateConstInBoundsGEP2_64(Counters, 0, 747221337Sdim Edge + i); 748296417Sdim EdgeTable[((Succs.idFor(Succ) - 1) * Preds.size()) + 749309124Sdim (Preds.idFor(&BB) - 1)] = cast<Constant>(Counter); 750221337Sdim } 751221337Sdim } 752221337Sdim Edge += Successors; 753221337Sdim } 754221337Sdim 755221337Sdim GlobalVariable *EdgeTableGV = 756221337Sdim new GlobalVariable( 757221337Sdim *M, EdgeTableTy, true, GlobalValue::InternalLinkage, 758280031Sdim ConstantArray::get(EdgeTableTy, 759280031Sdim makeArrayRef(&EdgeTable[0],TableSize)), 760221337Sdim "__llvm_gcda_edge_table"); 761309124Sdim EdgeTableGV->setUnnamedAddr(GlobalValue::UnnamedAddr::Global); 762221337Sdim return EdgeTableGV; 763221337Sdim} 764221337Sdim 765221337SdimConstant *GCOVProfiler::getStartFileFunc() { 766249423Sdim Type *Args[] = { 767249423Sdim Type::getInt8PtrTy(*Ctx), // const char *orig_filename 768249423Sdim Type::getInt8PtrTy(*Ctx), // const char version[4] 769276479Sdim Type::getInt32Ty(*Ctx), // uint32_t checksum 770249423Sdim }; 771249423Sdim FunctionType *FTy = FunctionType::get(Type::getVoidTy(*Ctx), Args, false); 772221337Sdim return M->getOrInsertFunction("llvm_gcda_start_file", FTy); 773221337Sdim} 774221337Sdim 775221337SdimConstant *GCOVProfiler::getIncrementIndirectCounterFunc() { 776239462Sdim Type *Int32Ty = Type::getInt32Ty(*Ctx); 777239462Sdim Type *Int64Ty = Type::getInt64Ty(*Ctx); 778224145Sdim Type *Args[] = { 779239462Sdim Int32Ty->getPointerTo(), // uint32_t *predecessor 780239462Sdim Int64Ty->getPointerTo()->getPointerTo() // uint64_t **counters 781221337Sdim }; 782239462Sdim FunctionType *FTy = FunctionType::get(Type::getVoidTy(*Ctx), Args, false); 783239462Sdim return M->getOrInsertFunction("__llvm_gcov_indirect_counter_increment", FTy); 784221337Sdim} 785221337Sdim 786221337SdimConstant *GCOVProfiler::getEmitFunctionFunc() { 787276479Sdim Type *Args[] = { 788223017Sdim Type::getInt32Ty(*Ctx), // uint32_t ident 789223017Sdim Type::getInt8PtrTy(*Ctx), // const char *function_name 790276479Sdim Type::getInt32Ty(*Ctx), // uint32_t func_checksum 791249423Sdim Type::getInt8Ty(*Ctx), // uint8_t use_extra_checksum 792276479Sdim Type::getInt32Ty(*Ctx), // uint32_t cfg_checksum 793223017Sdim }; 794239462Sdim FunctionType *FTy = FunctionType::get(Type::getVoidTy(*Ctx), Args, false); 795221337Sdim return M->getOrInsertFunction("llvm_gcda_emit_function", FTy); 796221337Sdim} 797221337Sdim 798221337SdimConstant *GCOVProfiler::getEmitArcsFunc() { 799224145Sdim Type *Args[] = { 800221337Sdim Type::getInt32Ty(*Ctx), // uint32_t num_counters 801221337Sdim Type::getInt64PtrTy(*Ctx), // uint64_t *counters 802221337Sdim }; 803249423Sdim FunctionType *FTy = FunctionType::get(Type::getVoidTy(*Ctx), Args, false); 804221337Sdim return M->getOrInsertFunction("llvm_gcda_emit_arcs", FTy); 805221337Sdim} 806221337Sdim 807261991SdimConstant *GCOVProfiler::getSummaryInfoFunc() { 808261991Sdim FunctionType *FTy = FunctionType::get(Type::getVoidTy(*Ctx), false); 809261991Sdim return M->getOrInsertFunction("llvm_gcda_summary_info", FTy); 810261991Sdim} 811261991Sdim 812221337SdimConstant *GCOVProfiler::getEndFileFunc() { 813226633Sdim FunctionType *FTy = FunctionType::get(Type::getVoidTy(*Ctx), false); 814221337Sdim return M->getOrInsertFunction("llvm_gcda_end_file", FTy); 815221337Sdim} 816221337Sdim 817221337SdimGlobalVariable *GCOVProfiler::getEdgeStateValue() { 818221337Sdim GlobalVariable *GV = M->getGlobalVariable("__llvm_gcov_global_state_pred"); 819221337Sdim if (!GV) { 820221337Sdim GV = new GlobalVariable(*M, Type::getInt32Ty(*Ctx), false, 821221337Sdim GlobalValue::InternalLinkage, 822221337Sdim ConstantInt::get(Type::getInt32Ty(*Ctx), 823221337Sdim 0xffffffff), 824221337Sdim "__llvm_gcov_global_state_pred"); 825309124Sdim GV->setUnnamedAddr(GlobalValue::UnnamedAddr::Global); 826221337Sdim } 827221337Sdim return GV; 828221337Sdim} 829221337Sdim 830249423SdimFunction *GCOVProfiler::insertCounterWriteout( 831243830Sdim ArrayRef<std::pair<GlobalVariable *, MDNode *> > CountersBySP) { 832243830Sdim FunctionType *WriteoutFTy = FunctionType::get(Type::getVoidTy(*Ctx), false); 833243830Sdim Function *WriteoutF = M->getFunction("__llvm_gcov_writeout"); 834243830Sdim if (!WriteoutF) 835243830Sdim WriteoutF = Function::Create(WriteoutFTy, GlobalValue::InternalLinkage, 836243830Sdim "__llvm_gcov_writeout", M); 837309124Sdim WriteoutF->setUnnamedAddr(GlobalValue::UnnamedAddr::Global); 838249423Sdim WriteoutF->addFnAttr(Attribute::NoInline); 839249423Sdim if (Options.NoRedZone) 840249423Sdim WriteoutF->addFnAttr(Attribute::NoRedZone); 841243830Sdim 842243830Sdim BasicBlock *BB = BasicBlock::Create(*Ctx, "entry", WriteoutF); 843221337Sdim IRBuilder<> Builder(BB); 844221337Sdim 845221337Sdim Constant *StartFile = getStartFileFunc(); 846221337Sdim Constant *EmitFunction = getEmitFunctionFunc(); 847221337Sdim Constant *EmitArcs = getEmitArcsFunc(); 848261991Sdim Constant *SummaryInfo = getSummaryInfoFunc(); 849221337Sdim Constant *EndFile = getEndFileFunc(); 850221337Sdim 851226633Sdim NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu"); 852226633Sdim if (CU_Nodes) { 853226633Sdim for (unsigned i = 0, e = CU_Nodes->getNumOperands(); i != e; ++i) { 854288943Sdim auto *CU = cast<DICompileUnit>(CU_Nodes->getOperand(i)); 855296417Sdim 856296417Sdim // Skip module skeleton (and module) CUs. 857296417Sdim if (CU->getDWOId()) 858296417Sdim continue; 859296417Sdim 860243830Sdim std::string FilenameGcda = mangleName(CU, "gcda"); 861276479Sdim uint32_t CfgChecksum = FileChecksums.empty() ? 0 : FileChecksums[i]; 862288943Sdim Builder.CreateCall(StartFile, 863288943Sdim {Builder.CreateGlobalStringPtr(FilenameGcda), 864276479Sdim Builder.CreateGlobalStringPtr(ReversedVersion), 865288943Sdim Builder.getInt32(CfgChecksum)}); 866249423Sdim for (unsigned j = 0, e = CountersBySP.size(); j != e; ++j) { 867288943Sdim auto *SP = cast_or_null<DISubprogram>(CountersBySP[j].second); 868276479Sdim uint32_t FuncChecksum = Funcs.empty() ? 0 : Funcs[j]->getFuncChecksum(); 869288943Sdim Builder.CreateCall( 870288943Sdim EmitFunction, 871288943Sdim {Builder.getInt32(j), 872288943Sdim Options.FunctionNamesInData 873288943Sdim ? Builder.CreateGlobalStringPtr(getFunctionName(SP)) 874288943Sdim : Constant::getNullValue(Builder.getInt8PtrTy()), 875288943Sdim Builder.getInt32(FuncChecksum), 876288943Sdim Builder.getInt8(Options.UseCfgChecksum), 877288943Sdim Builder.getInt32(CfgChecksum)}); 878249423Sdim 879249423Sdim GlobalVariable *GV = CountersBySP[j].first; 880226633Sdim unsigned Arcs = 881309124Sdim cast<ArrayType>(GV->getValueType())->getNumElements(); 882288943Sdim Builder.CreateCall(EmitArcs, {Builder.getInt32(Arcs), 883288943Sdim Builder.CreateConstGEP2_64(GV, 0, 0)}); 884226633Sdim } 885288943Sdim Builder.CreateCall(SummaryInfo, {}); 886288943Sdim Builder.CreateCall(EndFile, {}); 887221337Sdim } 888221337Sdim } 889221337Sdim 890239462Sdim Builder.CreateRetVoid(); 891249423Sdim return WriteoutF; 892221337Sdim} 893239462Sdim 894239462Sdimvoid GCOVProfiler::insertIndirectCounterIncrement() { 895239462Sdim Function *Fn = 896239462Sdim cast<Function>(GCOVProfiler::getIncrementIndirectCounterFunc()); 897309124Sdim Fn->setUnnamedAddr(GlobalValue::UnnamedAddr::Global); 898239462Sdim Fn->setLinkage(GlobalValue::InternalLinkage); 899249423Sdim Fn->addFnAttr(Attribute::NoInline); 900249423Sdim if (Options.NoRedZone) 901249423Sdim Fn->addFnAttr(Attribute::NoRedZone); 902239462Sdim 903239462Sdim // Create basic blocks for function. 904239462Sdim BasicBlock *BB = BasicBlock::Create(*Ctx, "entry", Fn); 905239462Sdim IRBuilder<> Builder(BB); 906239462Sdim 907239462Sdim BasicBlock *PredNotNegOne = BasicBlock::Create(*Ctx, "", Fn); 908239462Sdim BasicBlock *CounterEnd = BasicBlock::Create(*Ctx, "", Fn); 909239462Sdim BasicBlock *Exit = BasicBlock::Create(*Ctx, "exit", Fn); 910239462Sdim 911239462Sdim // uint32_t pred = *predecessor; 912239462Sdim // if (pred == 0xffffffff) return; 913296417Sdim Argument *Arg = &*Fn->arg_begin(); 914239462Sdim Arg->setName("predecessor"); 915239462Sdim Value *Pred = Builder.CreateLoad(Arg, "pred"); 916249423Sdim Value *Cond = Builder.CreateICmpEQ(Pred, Builder.getInt32(0xffffffff)); 917239462Sdim BranchInst::Create(Exit, PredNotNegOne, Cond, BB); 918239462Sdim 919239462Sdim Builder.SetInsertPoint(PredNotNegOne); 920239462Sdim 921239462Sdim // uint64_t *counter = counters[pred]; 922239462Sdim // if (!counter) return; 923249423Sdim Value *ZExtPred = Builder.CreateZExt(Pred, Builder.getInt64Ty()); 924296417Sdim Arg = &*std::next(Fn->arg_begin()); 925239462Sdim Arg->setName("counters"); 926288943Sdim Value *GEP = Builder.CreateGEP(Type::getInt64PtrTy(*Ctx), Arg, ZExtPred); 927239462Sdim Value *Counter = Builder.CreateLoad(GEP, "counter"); 928239462Sdim Cond = Builder.CreateICmpEQ(Counter, 929249423Sdim Constant::getNullValue( 930249423Sdim Builder.getInt64Ty()->getPointerTo())); 931239462Sdim Builder.CreateCondBr(Cond, Exit, CounterEnd); 932239462Sdim 933239462Sdim // ++*counter; 934239462Sdim Builder.SetInsertPoint(CounterEnd); 935239462Sdim Value *Add = Builder.CreateAdd(Builder.CreateLoad(Counter), 936249423Sdim Builder.getInt64(1)); 937239462Sdim Builder.CreateStore(Add, Counter); 938239462Sdim Builder.CreateBr(Exit); 939239462Sdim 940239462Sdim // Fill in the exit block. 941239462Sdim Builder.SetInsertPoint(Exit); 942239462Sdim Builder.CreateRetVoid(); 943239462Sdim} 944243830Sdim 945249423SdimFunction *GCOVProfiler:: 946243830SdiminsertFlush(ArrayRef<std::pair<GlobalVariable*, MDNode*> > CountersBySP) { 947243830Sdim FunctionType *FTy = FunctionType::get(Type::getVoidTy(*Ctx), false); 948249423Sdim Function *FlushF = M->getFunction("__llvm_gcov_flush"); 949243830Sdim if (!FlushF) 950243830Sdim FlushF = Function::Create(FTy, GlobalValue::InternalLinkage, 951249423Sdim "__llvm_gcov_flush", M); 952243830Sdim else 953243830Sdim FlushF->setLinkage(GlobalValue::InternalLinkage); 954309124Sdim FlushF->setUnnamedAddr(GlobalValue::UnnamedAddr::Global); 955249423Sdim FlushF->addFnAttr(Attribute::NoInline); 956249423Sdim if (Options.NoRedZone) 957249423Sdim FlushF->addFnAttr(Attribute::NoRedZone); 958243830Sdim 959243830Sdim BasicBlock *Entry = BasicBlock::Create(*Ctx, "entry", FlushF); 960243830Sdim 961243830Sdim // Write out the current counters. 962243830Sdim Constant *WriteoutF = M->getFunction("__llvm_gcov_writeout"); 963243830Sdim assert(WriteoutF && "Need to create the writeout function first!"); 964243830Sdim 965243830Sdim IRBuilder<> Builder(Entry); 966288943Sdim Builder.CreateCall(WriteoutF, {}); 967243830Sdim 968243830Sdim // Zero out the counters. 969309124Sdim for (const auto &I : CountersBySP) { 970309124Sdim GlobalVariable *GV = I.first; 971309124Sdim Constant *Null = Constant::getNullValue(GV->getValueType()); 972243830Sdim Builder.CreateStore(Null, GV); 973243830Sdim } 974243830Sdim 975243830Sdim Type *RetTy = FlushF->getReturnType(); 976243830Sdim if (RetTy == Type::getVoidTy(*Ctx)) 977243830Sdim Builder.CreateRetVoid(); 978243830Sdim else if (RetTy->isIntegerTy()) 979249423Sdim // Used if __llvm_gcov_flush was implicitly declared. 980243830Sdim Builder.CreateRet(ConstantInt::get(RetTy, 0)); 981243830Sdim else 982249423Sdim report_fatal_error("invalid return type for __llvm_gcov_flush"); 983249423Sdim 984249423Sdim return FlushF; 985243830Sdim} 986