[GCOV] Handle correctly multiple CUs when profiling

[calixte]

Summary

Currently, clang crashes when there are several CUs with the same module.
It has been probably broken in:
https://github.com/llvm-mirror/llvm/commit/4eeaa0da042055b1cd17b339e2dde518a3026033#diff-fb31f653eead12db385ff358e2a2e504R499
So the goal of the patch is to fix it.

[vsk]

It would help to have a regression test for this (somewhere in test/Transforms/GCOVProfiling). Something that exercises emitProfileArcs with 2 CU's would work.

Here's a starting point:

0001-Add-a-regression-test-for-emitProfileArcs.patch1 KBDownload

Note that this actually crashes somewhere in emitProfileNotes. ASan reports a heap buffer overflow.

[calixte]

Thanks for the test case. The code for multiple CUs looks pretty buggy.
I'll have look on it to try to fix it.

[calixte]

Fix multiple CUs stuff and add a test (thanks to vsk).

[vsk]

Thank you for working on this. I don't have any experience or familiarity with gcov to give this a proper review. @uweigand or @sylvestre.ledru may be able to give a better review.

[marco-c]

Very nice simplification, I hope this won't introduce regressions.
I think we should test the patch on Mozilla CI before landing, so we can be reasonably confident that it doesn't break things.

lib/Transforms/Instrumentation/GCOVProfiling.cpp

135

It's a little confusing to have two variable names which are so similar. Maybe call the first CUToGCOVFunctions and the second CUToFunctions?

479

Nit: Maybe keep the same convention of using this-> for member variables?

755

There are some formatting changes here and there, did you make them with clang format?
Next time, can you do the formatting changes after review, so I don't have to see them

test/Transforms/GCOVProfiling/function-numbering.ll

27

Do we have another test for the case where CUToCounters is not empty? I assume we don't.
It would be nice to have it, even a basic one, so I can also see how the generated code looks like now.

lib/Transforms/Instrumentation/GCOVProfiling.cpp

 // "gcno" files next to the existing source, and instruments the code that runs
 // to records the edges between blocks that run and emit a complementary "gcda"
 // file on exit.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/Hashing.h"
+#include "llvm/ADT/MapVector.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/Sequence.h"
 #include "llvm/ADT/Statistic.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/ADT/StringMap.h"
 #include "llvm/Analysis/EHPersonalities.h"
 #include "llvm/Analysis/TargetLibraryInfo.h"
 #include "llvm/IR/CFG.h"
GCOVProfiler(const GCOVOptions &Opts) : Options(Opts) {
     ReversedVersion[1] = Options.Version[2];
     ReversedVersion[2] = Options.Version[1];
     ReversedVersion[3] = Options.Version[0];
     ReversedVersion[4] = '\0';
   }
   bool runOnModule(Module &M, const TargetLibraryInfo &TLI);
 
 private:
+  using GlobalCountersTy =
+      SmallVector<std::pair<GlobalVariable *, MDNode *>, 8>;
+  using CUCountersTy =
+      SmallVector<std::pair<DICompileUnit *, GlobalCountersTy>, 4>;
+  using CUFunctionsTy = MapVector<DICompileUnit *, SmallVector<Function *, 16>>;
+
   // Create the .gcno files for the Module based on DebugInfo.
   void emitProfileNotes();
 
   // Modify the program to track transitions along edges and call into the
   // profiling runtime to emit .gcda files when run.
   bool emitProfileArcs();
 
   // Get pointers to the functions in the runtime library.
   Constant *getStartFileFunc();
   Constant *getEmitFunctionFunc();
   Constant *getEmitArcsFunc();
   Constant *getSummaryInfoFunc();
   Constant *getEndFileFunc();
 
   // Add the function to write out all our counters to the global destructor
   // list.
-  Function *
-  insertCounterWriteout(ArrayRef<std::pair<GlobalVariable *, MDNode *>>);
-  Function *insertFlush(ArrayRef<std::pair<GlobalVariable *, MDNode *>>);
+  Function *insertCounterWriteout(CUCountersTy &CUToCounters);
+  Function *insertFlush(CUCountersTy &CUToCounters);
+
+  static CUFunctionsTy getCUToFunctions(Module &M);
 
   enum class GCovFileType { GCNO, GCDA };
   std::string mangleName(const DICompileUnit *CU, GCovFileType FileType);
 
   GCOVOptions Options;
 
   // Reversed, NUL-terminated copy of Options.Version.
   char ReversedVersion[5];
   // Checksum, produced by hash of EdgeDestinations
-  SmallVector<uint32_t, 4> FileChecksums;
+  DenseMap<DICompileUnit *, uint32_t> FileChecksums;
 
   Module *M;
   const TargetLibraryInfo *TLI;
   LLVMContext *Ctx;
-  SmallVector<std::unique_ptr<GCOVFunction>, 16> Funcs;
+  DenseMap<DICompileUnit *, SmallVector<std::unique_ptr<GCOVFunction>, 16>>
+      CUToFuncs;
+  CUFunctionsTy CUToFunctions;
 };
 
 class GCOVProfilerLegacyPass : public ModulePass {
 public:
   static char ID;
   GCOVProfilerLegacyPass()
       : GCOVProfilerLegacyPass(GCOVOptions::getDefault()) {}
   GCOVProfilerLegacyPass(const GCOVOptions &Opts)
std::string GCOVProfiler::mangleName(const DICompileUnit *CU,
   if (sys::fs::current_path(CurPath)) return FName;
   sys::path::append(CurPath, FName);
   return CurPath.str();
 }
 
 bool GCOVProfiler::runOnModule(Module &M, const TargetLibraryInfo &TLI) {
   this->M = &M;
   this->TLI = &TLI;
+  CUToFunctions = getCUToFunctions(M);
   Ctx = &M.getContext();
 
   if (Options.EmitNotes) emitProfileNotes();
   if (Options.EmitData) return emitProfileArcs();
   return false;
 }
 
 PreservedAnalyses GCOVProfilerPass::run(Module &M,
static bool shouldKeepInEntry(BasicBlock::iterator It) {
   if (isa<DbgInfoIntrinsic>(*It)) return true;
   if (auto *II = dyn_cast<IntrinsicInst>(It)) {
     if (II->getIntrinsicID() == llvm::Intrinsic::localescape) return true;
   }
 
   return false;
 }
 
-void GCOVProfiler::emitProfileNotes() {
-  NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu");
-  if (!CU_Nodes) return;
+GCOVProfiler::CUFunctionsTy GCOVProfiler::getCUToFunctions(Module &M) {
+  CUFunctionsTy Map;
+  NamedMDNode *CU_Nodes = M.getNamedMetadata("llvm.dbg.cu");
+  if (!CU_Nodes)
+    return Map;
 
-  for (unsigned i = 0, e = CU_Nodes->getNumOperands(); i != e; ++i) {
-    // Each compile unit gets its own .gcno file. This means that whether we run
-    // this pass over the original .o's as they're produced, or run it after
-    // LTO, we'll generate the same .gcno files.
+  for (auto &F : M.functions()) {
+    DISubprogram *SP = F.getSubprogram();
+    if (!SP)
+      continue;
+    if (!functionHasLines(F))
+      continue;
+    // TODO: Functions using scope-based EH are currently not supported.
+    if (isUsingScopeBasedEH(F))
+      continue;
 
-    auto *CU = cast<DICompileUnit>(CU_Nodes->getOperand(i));
+    DICompileUnit *CU = SP->getUnit();
+    if (!CU)
+      continue;
 
     // Skip module skeleton (and module) CUs.
     if (CU->getDWOId())
       continue;
 
+    Map[CU].push_back(&F);
+  }
+  return Map;
+}
+
+void GCOVProfiler::emitProfileNotes() {
+  for (auto &CUFs : CUToFunctions) {
+    // Each compile unit gets its own .gcno file. This means that whether we run
+    // this pass over the original .o's as they're produced, or run it after
+    // LTO, we'll generate the same .gcno files.
+
+    auto *CU = CUFs.first;
+    auto &Functions = CUFs.second;
+
     std::error_code EC;
     raw_fd_ostream out(mangleName(CU, GCovFileType::GCNO), EC, sys::fs::F_None);
     if (EC) {
       Ctx->emitError(Twine("failed to open coverage notes file for writing: ") +
                      EC.message());
       continue;
     }
 
     std::string EdgeDestinations;
-
     unsigned FunctionIdent = 0;
-    for (auto &F : M->functions()) {
-      DISubprogram *SP = F.getSubprogram();
-      if (!SP) continue;
-      if (!functionHasLines(F)) continue;
-      // TODO: Functions using scope-based EH are currently not supported.
-      if (isUsingScopeBasedEH(F)) continue;
+    auto &Funcs = CUToFuncs[CU];
 
+    for (auto *F : Functions) {
+      DISubprogram *SP = F->getSubprogram();
       // gcov expects every function to start with an entry block that has a
       // single successor, so split the entry block to make sure of that.
-      BasicBlock &EntryBlock = F.getEntryBlock();
+      BasicBlock &EntryBlock = F->getEntryBlock();
       BasicBlock::iterator It = EntryBlock.begin();
       while (shouldKeepInEntry(It))
         ++It;
       EntryBlock.splitBasicBlock(It);
 
-      Funcs.push_back(make_unique<GCOVFunction>(SP, &F, &out, FunctionIdent++,
+      Funcs.push_back(make_unique<GCOVFunction>(SP, F, &out, FunctionIdent++,
                                                 Options.UseCfgChecksum,
                                                 Options.ExitBlockBeforeBody));
       GCOVFunction &Func = *Funcs.back();
 
       // Add the function line number to the lines of the entry block
       // to have a counter for the function definition.
       Func.getBlock(&EntryBlock)
           .getFile(SP->getFilename())
           .addLine(SP->getLine());
 
-      for (auto &BB : F) {
+      for (auto &BB : *F) {
         GCOVBlock &Block = Func.getBlock(&BB);
         Instruction *TI = BB.getTerminator();
         if (int successors = TI->getNumSuccessors()) {
           for (int i = 0; i != successors; ++i) {
             Block.addEdge(Func.getBlock(TI->getSuccessor(i)));
           }
         } else if (isa<ReturnInst>(TI)) {
           Block.addEdge(Func.getReturnBlock());
         }
 
         uint32_t Line = 0;
         for (auto &I : BB) {
           // Debug intrinsic locations correspond to the location of the
           // declaration, not necessarily any statements or expressions.
-          if (isa<DbgInfoIntrinsic>(&I)) continue;
+          if (isa<DbgInfoIntrinsic>(&I))
+            continue;
 
           const DebugLoc &Loc = I.getDebugLoc();
           if (!Loc)
             continue;
 
           // Artificial lines such as calls to the global constructors.
           if (Loc.getLine() == 0 || Loc.isImplicitCode())
             continue;
 
-          if (Line == Loc.getLine()) continue;
+          if (Line == Loc.getLine())
+            continue;
           Line = Loc.getLine();
           if (SP != getDISubprogram(Loc.getScope()))
             continue;
 
           GCOVLines &Lines = Block.getFile(SP->getFilename());
           Lines.addLine(Loc.getLine());
         }
       }
       EdgeDestinations += Func.getEdgeDestinations();
     }
 
-    FileChecksums.push_back(hash_value(EdgeDestinations));
+    uint32_t hash = hash_value(EdgeDestinations);
+    FileChecksums[CU] = hash;
     out.write("oncg", 4);
     out.write(ReversedVersion, 4);
-    out.write(reinterpret_cast<char*>(&FileChecksums.back()), 4);
+    out.write(reinterpret_cast<char *>(&hash), 4);
 
     for (auto &Func : Funcs) {
-      Func->setCfgChecksum(FileChecksums.back());
+      Func->setCfgChecksum(hash);
       Func->writeOut();
     }
 
-    out.write("\0\0\0\0\0\0\0\0", 8);  // EOF
+    out.write("\0\0\0\0\0\0\0\0", 8); // EOF
     out.close();
   }
 }
 
 bool GCOVProfiler::emitProfileArcs() {
-  NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu");
-  if (!CU_Nodes) return false;
-
   bool Result = false;
-  for (unsigned i = 0, e = CU_Nodes->getNumOperands(); i != e; ++i) {
-    SmallVector<std::pair<GlobalVariable *, MDNode *>, 8> CountersBySP;
-    for (auto &F : M->functions()) {
-      DISubprogram *SP = F.getSubprogram();
-      if (!SP) continue;
-      if (!functionHasLines(F)) continue;
-      // TODO: Functions using scope-based EH are currently not supported.
-      if (isUsingScopeBasedEH(F)) continue;
-      if (!Result) Result = true;
+  CUCountersTy CUToCounters;
+  for (auto &CUFs : CUToFunctions) {
+    auto *CU = CUFs.first;
+    CUToCounters.push_back({CU, {}});
+    auto &CountersBySP = CUToCounters.back().second;
+
+    for (auto *F : CUFs.second) {
+      if (!Result)
+        Result = true;
 
       DenseMap<std::pair<BasicBlock *, BasicBlock *>, unsigned> EdgeToCounter;
       unsigned Edges = 0;
-      for (auto &BB : F) {
+      for (auto &BB : *F) {
         Instruction *TI = BB.getTerminator();
         if (isa<ReturnInst>(TI)) {
           EdgeToCounter[{&BB, nullptr}] = Edges++;
         } else {
           for (BasicBlock *Succ : successors(TI)) {
             EdgeToCounter[{&BB, Succ}] = Edges++;
           }
         }
       }
 
-      ArrayType *CounterTy =
-        ArrayType::get(Type::getInt64Ty(*Ctx), Edges);
-      GlobalVariable *Counters =
-        new GlobalVariable(*M, CounterTy, false,
-                           GlobalValue::InternalLinkage,
-                           Constant::getNullValue(CounterTy),
-                           "__llvm_gcov_ctr");
-      CountersBySP.push_back(std::make_pair(Counters, SP));
+      ArrayType *CounterTy = ArrayType::get(Type::getInt64Ty(*Ctx), Edges);
+      GlobalVariable *Counters = new GlobalVariable(
+          *M, CounterTy, false, GlobalValue::InternalLinkage,
+          Constant::getNullValue(CounterTy), "__llvm_gcov_ctr");
+      CountersBySP.push_back({Counters, F->getSubprogram()});
 
       // If a BB has several predecessors, use a PHINode to select
       // the correct counter.
-      for (auto &BB : F) {
+      for (auto &BB : *F) {
         const unsigned EdgeCount =
             std::distance(pred_begin(&BB), pred_end(&BB));
         if (EdgeCount) {
           // The phi node must be at the begin of the BB.
           IRBuilder<> BuilderForPhi(&*BB.begin());
           Type *Int64PtrTy = Type::getInt64PtrTy(*Ctx);
           PHINode *Phi = BuilderForPhi.CreatePHI(Int64PtrTy, EdgeCount);
           for (BasicBlock *Pred : predecessors(&BB)) {
for (auto *F : CUFs.second) {
                 Builder.CreateConstInBoundsGEP2_64(Counters, 0, Edge);
             Value *Count = Builder.CreateLoad(Counter);
             Count = Builder.CreateAdd(Count, Builder.getInt64(1));
             Builder.CreateStore(Count, Counter);
           }
         }
       }
     }
+  }
 
-    Function *WriteoutF = insertCounterWriteout(CountersBySP);
-    Function *FlushF = insertFlush(CountersBySP);
+  Function *WriteoutF = insertCounterWriteout(CUToCounters);
+  Function *FlushF = insertFlush(CUToCounters);
 
-    // Create a small bit of code that registers the "__llvm_gcov_writeout" to
-    // be executed at exit and the "__llvm_gcov_flush" function to be executed
-    // when "__gcov_flush" is called.
-    FunctionType *FTy = FunctionType::get(Type::getVoidTy(*Ctx), false);
-    Function *F = Function::Create(FTy, GlobalValue::InternalLinkage,
-                                   "__llvm_gcov_init", M);
-    F->setUnnamedAddr(GlobalValue::UnnamedAddr::Global);
-    F->setLinkage(GlobalValue::InternalLinkage);
-    F->addFnAttr(Attribute::NoInline);
-    if (Options.NoRedZone)
-      F->addFnAttr(Attribute::NoRedZone);
 
-    BasicBlock *BB = BasicBlock::Create(*Ctx, "entry", F);
-    IRBuilder<> Builder(BB);
 
-    FTy = FunctionType::get(Type::getVoidTy(*Ctx), false);
-    Type *Params[] = {
-      PointerType::get(FTy, 0),
-      PointerType::get(FTy, 0)
-    };
-    FTy = FunctionType::get(Builder.getVoidTy(), Params, false);
+  Type *Params[] = {PointerType::get(FTy, 0), PointerType::get(FTy, 0)};
 
-    // Initialize the environment and register the local writeout and flush
-    // functions.
-    Constant *GCOVInit = M->getOrInsertFunction("llvm_gcov_init", FTy);
-    Builder.CreateCall(GCOVInit, {WriteoutF, FlushF});
-    Builder.CreateRetVoid();
 
-    appendToGlobalCtors(*M, F, 0);
-  }
 
   return Result;
 }
 
 Constant *GCOVProfiler::getStartFileFunc() {
   Type *Args[] = {
     Type::getInt8PtrTy(*Ctx),  // const char *orig_filename
     Type::getInt8PtrTy(*Ctx),  // const char version[4]
Constant *GCOVProfiler::getSummaryInfoFunc() {
   return M->getOrInsertFunction("llvm_gcda_summary_info", FTy);
 }
 
 Constant *GCOVProfiler::getEndFileFunc() {
   FunctionType *FTy = FunctionType::get(Type::getVoidTy(*Ctx), false);
   return M->getOrInsertFunction("llvm_gcda_end_file", FTy);
 }
 
-Function *GCOVProfiler::insertCounterWriteout(
-    ArrayRef<std::pair<GlobalVariable *, MDNode *> > CountersBySP) {
+Function *GCOVProfiler::insertCounterWriteout(CUCountersTy &CUToCounters) {
   FunctionType *WriteoutFTy = FunctionType::get(Type::getVoidTy(*Ctx), false);
   Function *WriteoutF = M->getFunction("__llvm_gcov_writeout");
   if (!WriteoutF)
     WriteoutF = Function::Create(WriteoutFTy, GlobalValue::InternalLinkage,
                                  "__llvm_gcov_writeout", M);
   WriteoutF->setUnnamedAddr(GlobalValue::UnnamedAddr::Global);
   WriteoutF->addFnAttr(Attribute::NoInline);
   if (Options.NoRedZone)
     WriteoutF->addFnAttr(Attribute::NoRedZone);
 
   BasicBlock *BB = BasicBlock::Create(*Ctx, "entry", WriteoutF);
   IRBuilder<> Builder(BB);
 
+  if (CUToCounters.empty()) {
+    Builder.CreateRetVoid();
+    return WriteoutF;
+  }
+
   Constant *StartFile = getStartFileFunc();
   Constant *EmitFunction = getEmitFunctionFunc();
   Constant *EmitArcs = getEmitArcsFunc();
   Constant *SummaryInfo = getSummaryInfoFunc();
   Constant *EndFile = getEndFileFunc();
 
-  NamedMDNode *CUNodes = M->getNamedMetadata("llvm.dbg.cu");
-  if (!CUNodes) {
-    Builder.CreateRetVoid();
-    return WriteoutF;
-  }
-
-  // Collect the relevant data into a large constant data structure that we can
-  // walk to write out everything.
-  StructType *StartFileCallArgsTy = StructType::create(
-      {Builder.getInt8PtrTy(), Builder.getInt8PtrTy(), Builder.getInt32Ty()});
-  StructType *EmitFunctionCallArgsTy = StructType::create(
-      {Builder.getInt32Ty(), Builder.getInt8PtrTy(), Builder.getInt32Ty(),
-       Builder.getInt8Ty(), Builder.getInt32Ty()});
-  StructType *EmitArcsCallArgsTy = StructType::create(
-      {Builder.getInt32Ty(), Builder.getInt64Ty()->getPointerTo()});
-  StructType *FileInfoTy =
-      StructType::create({StartFileCallArgsTy, Builder.getInt32Ty(),
-                          EmitFunctionCallArgsTy->getPointerTo(),
-                          EmitArcsCallArgsTy->getPointerTo()});
-
   Constant *Zero32 = Builder.getInt32(0);
   // Build an explicit array of two zeros for use in ConstantExpr GEP building.
   Constant *TwoZero32s[] = {Zero32, Zero32};
 
-  SmallVector<Constant *, 8> FileInfos;
-  for (int i : llvm::seq<int>(0, CUNodes->getNumOperands())) {
-    auto *CU = cast<DICompileUnit>(CUNodes->getOperand(i));
-
-    // Skip module skeleton (and module) CUs.
-    if (CU->getDWOId())
-      continue;
+  Constant *Version = Builder.CreateGlobalStringPtr(ReversedVersion);
+  Constant *UseCfgChecksum = Builder.getInt8(Options.UseCfgChecksum);
+  Constant *NullCharPtr = Options.FunctionNamesInData
+                              ? nullptr
+                              : Constant::getNullValue(Builder.getInt8PtrTy());
+
+  for (auto &CUCs : CUToCounters) {
+    auto *CU = CUCs.first;
+    auto &CountersBySP = CUCs.second;
+    auto &Funcs = CUToFuncs[CU];
 
     std::string FilenameGcda = mangleName(CU, GCovFileType::GCDA);
-    uint32_t CfgChecksum = FileChecksums.empty() ? 0 : FileChecksums[i];
-    auto *StartFileCallArgs = ConstantStruct::get(
-        StartFileCallArgsTy, {Builder.CreateGlobalStringPtr(FilenameGcda),
-                              Builder.CreateGlobalStringPtr(ReversedVersion),
-                              Builder.getInt32(CfgChecksum)});
+    Constant *CfgChecksum =
+        Builder.getInt32(FileChecksums.empty() ? 0 : FileChecksums[CU]);
+
+    Builder.CreateCall(StartFile, {Builder.CreateGlobalStringPtr(FilenameGcda),
+                                   Version, CfgChecksum});
 
-    SmallVector<Constant *, 8> EmitFunctionCallArgsArray;
-    SmallVector<Constant *, 8> EmitArcsCallArgsArray;
     for (int j : llvm::seq<int>(0, CountersBySP.size())) {
       auto *SP = cast_or_null<DISubprogram>(CountersBySP[j].second);
-      uint32_t FuncChecksum = Funcs.empty() ? 0 : Funcs[j]->getFuncChecksum();
-      EmitFunctionCallArgsArray.push_back(ConstantStruct::get(
-          EmitFunctionCallArgsTy,
+      const uint32_t FuncChecksum =
+          Funcs.empty() ? 0 : Funcs[j]->getFuncChecksum();
+      Builder.CreateCall(
+          EmitFunction,
           {Builder.getInt32(j),
-           Options.FunctionNamesInData
-               ? Builder.CreateGlobalStringPtr(getFunctionName(SP))
-               : Constant::getNullValue(Builder.getInt8PtrTy()),
-           Builder.getInt32(FuncChecksum),
-           Builder.getInt8(Options.UseCfgChecksum),
-           Builder.getInt32(CfgChecksum)}));
+           NullCharPtr ? NullCharPtr
+                       : Builder.CreateGlobalStringPtr(getFunctionName(SP)),
+           Builder.getInt32(FuncChecksum), UseCfgChecksum, CfgChecksum});
 
       GlobalVariable *GV = CountersBySP[j].first;
       unsigned Arcs = cast<ArrayType>(GV->getValueType())->getNumElements();
-      EmitArcsCallArgsArray.push_back(ConstantStruct::get(
-          EmitArcsCallArgsTy,
-          {Builder.getInt32(Arcs), ConstantExpr::getInBoundsGetElementPtr(
-                                       GV->getValueType(), GV, TwoZero32s)}));
-    }
-    // Create global arrays for the two emit calls.
-    int CountersSize = CountersBySP.size();
-    assert(CountersSize == (int)EmitFunctionCallArgsArray.size() &&
-           "Mismatched array size!");
-    assert(CountersSize == (int)EmitArcsCallArgsArray.size() &&
-           "Mismatched array size!");
-    auto *EmitFunctionCallArgsArrayTy =
-        ArrayType::get(EmitFunctionCallArgsTy, CountersSize);
-    auto *EmitFunctionCallArgsArrayGV = new GlobalVariable(
-        *M, EmitFunctionCallArgsArrayTy, /*isConstant*/ true,
-        GlobalValue::InternalLinkage,
-        ConstantArray::get(EmitFunctionCallArgsArrayTy,
-                           EmitFunctionCallArgsArray),
-        Twine("__llvm_internal_gcov_emit_function_args.") + Twine(i));
-    auto *EmitArcsCallArgsArrayTy =
-        ArrayType::get(EmitArcsCallArgsTy, CountersSize);
-    EmitFunctionCallArgsArrayGV->setUnnamedAddr(
-        GlobalValue::UnnamedAddr::Global);
-    auto *EmitArcsCallArgsArrayGV = new GlobalVariable(
-        *M, EmitArcsCallArgsArrayTy, /*isConstant*/ true,
-        GlobalValue::InternalLinkage,
-        ConstantArray::get(EmitArcsCallArgsArrayTy, EmitArcsCallArgsArray),
-        Twine("__llvm_internal_gcov_emit_arcs_args.") + Twine(i));
-    EmitArcsCallArgsArrayGV->setUnnamedAddr(GlobalValue::UnnamedAddr::Global);
-
-    FileInfos.push_back(ConstantStruct::get(
-        FileInfoTy,
-        {StartFileCallArgs, Builder.getInt32(CountersSize),
-         ConstantExpr::getInBoundsGetElementPtr(EmitFunctionCallArgsArrayTy,
-                                                EmitFunctionCallArgsArrayGV,
-                                                TwoZero32s),
+      Builder.CreateCall(EmitArcs, {Builder.getInt32(Arcs),
                                     ConstantExpr::getInBoundsGetElementPtr(
-             EmitArcsCallArgsArrayTy, EmitArcsCallArgsArrayGV, TwoZero32s)}));
-  }
-
-  // If we didn't find anything to actually emit, bail on out.
-  if (FileInfos.empty()) {
-    Builder.CreateRetVoid();
-    return WriteoutF;
+                                        GV->getValueType(), GV, TwoZero32s)});
     }
 
-  // To simplify code, we cap the number of file infos we write out to fit
-  // easily in a 32-bit signed integer. This gives consistent behavior between
-  // 32-bit and 64-bit systems without requiring (potentially very slow) 64-bit
-  // operations on 32-bit systems. It also seems unreasonable to try to handle
-  // more than 2 billion files.
-  if ((int64_t)FileInfos.size() > (int64_t)INT_MAX)
-    FileInfos.resize(INT_MAX);
-
-  // Create a global for the entire data structure so we can walk it more
-  // easily.
-  auto *FileInfoArrayTy = ArrayType::get(FileInfoTy, FileInfos.size());
-  auto *FileInfoArrayGV = new GlobalVariable(
-      *M, FileInfoArrayTy, /*isConstant*/ true, GlobalValue::InternalLinkage,
-      ConstantArray::get(FileInfoArrayTy, FileInfos),
-      "__llvm_internal_gcov_emit_file_info");
-  FileInfoArrayGV->setUnnamedAddr(GlobalValue::UnnamedAddr::Global);
-
-  // Create the CFG for walking this data structure.
-  auto *FileLoopHeader =
-      BasicBlock::Create(*Ctx, "file.loop.header", WriteoutF);
-  auto *CounterLoopHeader =
-      BasicBlock::Create(*Ctx, "counter.loop.header", WriteoutF);
-  auto *FileLoopLatch = BasicBlock::Create(*Ctx, "file.loop.latch", WriteoutF);
-  auto *ExitBB = BasicBlock::Create(*Ctx, "exit", WriteoutF);
-
-  // We always have at least one file, so just branch to the header.
-  Builder.CreateBr(FileLoopHeader);
-
-  // The index into the files structure is our loop induction variable.
-  Builder.SetInsertPoint(FileLoopHeader);
-  PHINode *IV =
-      Builder.CreatePHI(Builder.getInt32Ty(), /*NumReservedValues*/ 2);
-  IV->addIncoming(Builder.getInt32(0), BB);
-  auto *FileInfoPtr =
-      Builder.CreateInBoundsGEP(FileInfoArrayGV, {Builder.getInt32(0), IV});
-  auto *StartFileCallArgsPtr = Builder.CreateStructGEP(FileInfoPtr, 0);
-  auto *StartFileCall = Builder.CreateCall(
-      StartFile,
-      {Builder.CreateLoad(Builder.CreateStructGEP(StartFileCallArgsPtr, 0)),
-       Builder.CreateLoad(Builder.CreateStructGEP(StartFileCallArgsPtr, 1)),
-       Builder.CreateLoad(Builder.CreateStructGEP(StartFileCallArgsPtr, 2))});
-  if (auto AK = TLI->getExtAttrForI32Param(false))
-    StartFileCall->addParamAttr(2, AK);
-  auto *NumCounters =
-      Builder.CreateLoad(Builder.CreateStructGEP(FileInfoPtr, 1));
-  auto *EmitFunctionCallArgsArray =
-      Builder.CreateLoad(Builder.CreateStructGEP(FileInfoPtr, 2));
-  auto *EmitArcsCallArgsArray =
-      Builder.CreateLoad(Builder.CreateStructGEP(FileInfoPtr, 3));
-  auto *EnterCounterLoopCond =
-      Builder.CreateICmpSLT(Builder.getInt32(0), NumCounters);
-  Builder.CreateCondBr(EnterCounterLoopCond, CounterLoopHeader, FileLoopLatch);
-
-  Builder.SetInsertPoint(CounterLoopHeader);
-  auto *JV = Builder.CreatePHI(Builder.getInt32Ty(), /*NumReservedValues*/ 2);
-  JV->addIncoming(Builder.getInt32(0), FileLoopHeader);
-  auto *EmitFunctionCallArgsPtr =
-      Builder.CreateInBoundsGEP(EmitFunctionCallArgsArray, {JV});
-  auto *EmitFunctionCall = Builder.CreateCall(
-      EmitFunction,
-      {Builder.CreateLoad(Builder.CreateStructGEP(EmitFunctionCallArgsPtr, 0)),
-       Builder.CreateLoad(Builder.CreateStructGEP(EmitFunctionCallArgsPtr, 1)),
-       Builder.CreateLoad(Builder.CreateStructGEP(EmitFunctionCallArgsPtr, 2)),
-       Builder.CreateLoad(Builder.CreateStructGEP(EmitFunctionCallArgsPtr, 3)),
-       Builder.CreateLoad(
-           Builder.CreateStructGEP(EmitFunctionCallArgsPtr, 4))});
-  if (auto AK = TLI->getExtAttrForI32Param(false)) {
-    EmitFunctionCall->addParamAttr(0, AK);
-    EmitFunctionCall->addParamAttr(2, AK);
-    EmitFunctionCall->addParamAttr(3, AK);
-    EmitFunctionCall->addParamAttr(4, AK);
-  }
-  auto *EmitArcsCallArgsPtr =
-      Builder.CreateInBoundsGEP(EmitArcsCallArgsArray, {JV});
-  auto *EmitArcsCall = Builder.CreateCall(
-      EmitArcs,
-      {Builder.CreateLoad(Builder.CreateStructGEP(EmitArcsCallArgsPtr, 0)),
-       Builder.CreateLoad(Builder.CreateStructGEP(EmitArcsCallArgsPtr, 1))});
-  if (auto AK = TLI->getExtAttrForI32Param(false))
-    EmitArcsCall->addParamAttr(0, AK);
-  auto *NextJV = Builder.CreateAdd(JV, Builder.getInt32(1));
-  auto *CounterLoopCond = Builder.CreateICmpSLT(NextJV, NumCounters);
-  Builder.CreateCondBr(CounterLoopCond, CounterLoopHeader, FileLoopLatch);
-  JV->addIncoming(NextJV, CounterLoopHeader);
-
-  Builder.SetInsertPoint(FileLoopLatch);
     Builder.CreateCall(SummaryInfo, {});
     Builder.CreateCall(EndFile, {});
-  auto *NextIV = Builder.CreateAdd(IV, Builder.getInt32(1));
-  auto *FileLoopCond =
-      Builder.CreateICmpSLT(NextIV, Builder.getInt32(FileInfos.size()));
-  Builder.CreateCondBr(FileLoopCond, FileLoopHeader, ExitBB);
-  IV->addIncoming(NextIV, FileLoopLatch);
+  }
 
-  Builder.SetInsertPoint(ExitBB);
   Builder.CreateRetVoid();
-
   return WriteoutF;
 }
 
-Function *GCOVProfiler::
-insertFlush(ArrayRef<std::pair<GlobalVariable*, MDNode*> > CountersBySP) {
+Function *GCOVProfiler::insertFlush(CUCountersTy &CUToCounters) {
   FunctionType *FTy = FunctionType::get(Type::getVoidTy(*Ctx), false);
   Function *FlushF = M->getFunction("__llvm_gcov_flush");
   if (!FlushF)
     FlushF = Function::Create(FTy, GlobalValue::InternalLinkage,
                               "__llvm_gcov_flush", M);
   else
     FlushF->setLinkage(GlobalValue::InternalLinkage);
   FlushF->setUnnamedAddr(GlobalValue::UnnamedAddr::Global);
   FlushF->addFnAttr(Attribute::NoInline);
   if (Options.NoRedZone)
     FlushF->addFnAttr(Attribute::NoRedZone);
 
   BasicBlock *Entry = BasicBlock::Create(*Ctx, "entry", FlushF);
 
   // Write out the current counters.
   Constant *WriteoutF = M->getFunction("__llvm_gcov_writeout");
   assert(WriteoutF && "Need to create the writeout function first!");
 
   IRBuilder<> Builder(Entry);
   Builder.CreateCall(WriteoutF, {});
 
   // Zero out the counters.
-  for (const auto &I : CountersBySP) {
+  for (auto &CUCs : CUToCounters) {
+    for (const auto &I : CUCs.second) {
       GlobalVariable *GV = I.first;
       Constant *Null = Constant::getNullValue(GV->getValueType());
       Builder.CreateStore(Null, GV);
     }
+  }
 
   Type *RetTy = FlushF->getReturnType();
   if (RetTy == Type::getVoidTy(*Ctx))
     Builder.CreateRetVoid();
   else if (RetTy->isIntegerTy())
     // Used if __llvm_gcov_flush was implicitly declared.
     Builder.CreateRet(ConstantInt::get(RetTy, 0));
   else
     report_fatal_error("invalid return type for __llvm_gcov_flush");
 
   return FlushF;
 }

test/Transforms/GCOVProfiling/Inputs/empty-function-1.ll

+define void @empty1() {
+  ret void
+}
 No newline at end of file

test/Transforms/GCOVProfiling/Inputs/empty-function-2.ll

+define void @empty2() {
+  ret void
+}
 No newline at end of file

test/Transforms/GCOVProfiling/Inputs/main-calls-empty-functions.ll

+define i32 @main() {
+  call void @empty1()
+  call void @empty2()
+  ret i32 0
+}
+
+declare void @empty1()
+declare void @empty2()
 No newline at end of file

test/Transforms/GCOVProfiling/function-numbering.ll

 ; RUN: llvm-cov gcov -n -dump %t/function-numbering.gcno 2>&1 | FileCheck --check-prefix GCNO %s
 
 target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-apple-macosx10.10.0"
 
 ; GCDA: @[[FOO:[0-9]+]] = private unnamed_addr constant [4 x i8] c"foo\00"
 ; GCDA-NOT: @{{[0-9]+}} = private unnamed_addr constant .* c"bar\00"
 ; GCDA: @[[BAZ:[0-9]+]] = private unnamed_addr constant [4 x i8] c"baz\00"
-; GCDA: @__llvm_internal_gcov_emit_function_args.0 = internal unnamed_addr constant
-; GCDA-SAME: { i32 0, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @[[FOO]]
-; GCDA-SAME: { i32 1, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @[[BAZ]]
 ;
 ; GCDA-LABEL: define internal void @__llvm_gcov_writeout() {{.*}} {
 ; GCDA-NEXT:  entry:
-; GCDA-NEXT:    br label %[[FILE_LOOP_HEADER:.*]]
-;
-; GCDA:       [[FILE_LOOP_HEADER]]:
-; GCDA-NEXT:    %[[IV:.*]] = phi i32 [ 0, %entry ], [ %[[NEXT_IV:.*]], %[[FILE_LOOP_LATCH:.*]] ]
-; GCDA-NEXT:    %[[FILE_INFO:.*]] = getelementptr inbounds {{.*}}, {{.*}}* @__llvm_internal_gcov_emit_file_info, i32 0, i32 %[[IV]]
-; GCDA-NEXT:    %[[START_FILE_ARGS:.*]] = getelementptr inbounds {{.*}}, {{.*}}* %[[FILE_INFO]], i32 0, i32 0
-; GCDA-NEXT:    %[[START_FILE_ARG_0_PTR:.*]] = getelementptr inbounds {{.*}}, {{.*}}* %[[START_FILE_ARGS]], i32 0, i32 0
-; GCDA-NEXT:    %[[START_FILE_ARG_0:.*]] = load i8*, i8** %[[START_FILE_ARG_0_PTR]]
-; GCDA-NEXT:    %[[START_FILE_ARG_1_PTR:.*]] = getelementptr inbounds {{.*}}, {{.*}}* %[[START_FILE_ARGS]], i32 0, i32 1
-; GCDA-NEXT:    %[[START_FILE_ARG_1:.*]] = load i8*, i8** %[[START_FILE_ARG_1_PTR]]
-; GCDA-NEXT:    %[[START_FILE_ARG_2_PTR:.*]] = getelementptr inbounds {{.*}}, {{.*}}* %[[START_FILE_ARGS]], i32 0, i32 2
-; GCDA-NEXT:    %[[START_FILE_ARG_2:.*]] = load i32, i32* %[[START_FILE_ARG_2_PTR]]
-; GCDA-NEXT:    call void @llvm_gcda_start_file(i8* %[[START_FILE_ARG_0]], i8* %[[START_FILE_ARG_1]], i32 %[[START_FILE_ARG_2]])
-; GCDA-NEXT:    %[[NUM_COUNTERS_PTR:.*]] = getelementptr inbounds {{.*}}, {{.*}}* %[[FILE_INFO]], i32 0, i32 1
-; GCDA-NEXT:    %[[NUM_COUNTERS:.*]] = load i32, i32* %[[NUM_COUNTERS_PTR]]
-; GCDA-NEXT:    %[[EMIT_FUN_ARGS_ARRAY_PTR:.*]] = getelementptr inbounds {{.*}}, {{.*}}* %[[FILE_INFO]], i32 0, i32 2
-; GCDA-NEXT:    %[[EMIT_FUN_ARGS_ARRAY:.*]] = load {{.*}}*, {{.*}}** %[[EMIT_FUN_ARGS_ARRAY_PTR]]
-; GCDA-NEXT:    %[[EMIT_ARCS_ARGS_ARRAY_PTR:.*]] = getelementptr inbounds {{.*}}, {{.*}}* %[[FILE_INFO]], i32 0, i32 3
-; GCDA-NEXT:    %[[EMIT_ARCS_ARGS_ARRAY:.*]] = load {{.*}}*, {{.*}}** %[[EMIT_ARCS_ARGS_ARRAY_PTR]]
-; GCDA-NEXT:    %[[ENTER_COUNTER_LOOP_COND:.*]] = icmp slt i32 0, %[[NUM_COUNTERS]]
-; GCDA-NEXT:    br i1 %[[ENTER_COUNTER_LOOP_COND]], label %[[COUNTER_LOOP:.*]], label %[[FILE_LOOP_LATCH]]
-;
-; GCDA:       [[COUNTER_LOOP]]:
-; GCDA-NEXT:    %[[JV:.*]] = phi i32 [ 0, %[[FILE_LOOP_HEADER]] ], [ %[[NEXT_JV:.*]], %[[COUNTER_LOOP]] ]
-; GCDA-NEXT:    %[[EMIT_FUN_ARGS:.*]] = getelementptr inbounds {{.*}}, {{.*}}* %[[EMIT_FUN_ARGS_ARRAY]], i32 %[[JV]]
-; GCDA-NEXT:    %[[EMIT_FUN_ARG_0_PTR:.*]] = getelementptr inbounds {{.*}}, {{.*}}* %[[EMIT_FUN_ARGS]], i32 0, i32 0
-; GCDA-NEXT:    %[[EMIT_FUN_ARG_0:.*]] = load i32, i32* %[[EMIT_FUN_ARG_0_PTR]]
-; GCDA-NEXT:    %[[EMIT_FUN_ARG_1_PTR:.*]] = getelementptr inbounds {{.*}}, {{.*}}* %[[EMIT_FUN_ARGS]], i32 0, i32 1
-; GCDA-NEXT:    %[[EMIT_FUN_ARG_1:.*]] = load i8*, i8** %[[EMIT_FUN_ARG_1_PTR]]
-; GCDA-NEXT:    %[[EMIT_FUN_ARG_2_PTR:.*]] = getelementptr inbounds {{.*}}, {{.*}}* %[[EMIT_FUN_ARGS]], i32 0, i32 2
-; GCDA-NEXT:    %[[EMIT_FUN_ARG_2:.*]] = load i32, i32* %[[EMIT_FUN_ARG_2_PTR]]
-; GCDA-NEXT:    %[[EMIT_FUN_ARG_3_PTR:.*]] = getelementptr inbounds {{.*}}, {{.*}}* %[[EMIT_FUN_ARGS]], i32 0, i32 3
-; GCDA-NEXT:    %[[EMIT_FUN_ARG_3:.*]] = load i8, i8* %[[EMIT_FUN_ARG_3_PTR]]
-; GCDA-NEXT:    %[[EMIT_FUN_ARG_4_PTR:.*]] = getelementptr inbounds {{.*}}, {{.*}}* %[[EMIT_FUN_ARGS]], i32 0, i32 4
-; GCDA-NEXT:    %[[EMIT_FUN_ARG_4:.*]] = load i32, i32* %[[EMIT_FUN_ARG_4_PTR]]
-; GCDA-NEXT:    call void @llvm_gcda_emit_function(i32 %[[EMIT_FUN_ARG_0]],
-; GCDA-SAME:                                       i8* %[[EMIT_FUN_ARG_1]],
-; GCDA-SAME:                                       i32 %[[EMIT_FUN_ARG_2]],
-; GCDA-SAME:                                       i8 %[[EMIT_FUN_ARG_3]],
-; GCDA-SAME:                                       i32 %[[EMIT_FUN_ARG_4]])
-; GCDA-NEXT:    %[[EMIT_ARCS_ARGS:.*]] = getelementptr inbounds {{.*}}, {{.*}}* %[[EMIT_ARCS_ARGS_ARRAY]], i32 %[[JV]]
-; GCDA-NEXT:    %[[EMIT_ARCS_ARG_0_PTR:.*]] = getelementptr inbounds {{.*}}, {{.*}}* %[[EMIT_ARCS_ARGS]], i32 0, i32 0
-; GCDA-NEXT:    %[[EMIT_ARCS_ARG_0:.*]] = load i32, i32* %[[EMIT_ARCS_ARG_0_PTR]]
-; GCDA-NEXT:    %[[EMIT_ARCS_ARG_1_PTR:.*]] = getelementptr inbounds {{.*}}, {{.*}}* %[[EMIT_ARCS_ARGS]], i32 0, i32 1
-; GCDA-NEXT:    %[[EMIT_ARCS_ARG_1:.*]] = load i64*, i64** %[[EMIT_ARCS_ARG_1_PTR]]
-; GCDA-NEXT:    call void @llvm_gcda_emit_arcs(i32 %[[EMIT_ARCS_ARG_0]],
-; GCDA-SAME:                                   i64* %[[EMIT_ARCS_ARG_1]])
-; GCDA-NEXT:    %[[NEXT_JV]] = add i32 %[[JV]], 1
-; GCDA-NEXT:    %[[COUNTER_LOOP_COND:.*]] = icmp slt i32 %[[NEXT_JV]], %[[NUM_COUNTERS]]
-; GCDA-NEXT:    br i1 %[[COUNTER_LOOP_COND]], label %[[COUNTER_LOOP]], label %[[FILE_LOOP_LATCH]]
-;
-; GCDA:       [[FILE_LOOP_LATCH]]:
-; GCDA-NEXT:    call void @llvm_gcda_summary_info()
-; GCDA-NEXT:    call void @llvm_gcda_end_file()
-; GCDA-NEXT:    %[[NEXT_IV]] = add i32 %[[IV]], 1
-; GCDA-NEXT:    %[[FILE_LOOP_COND:.*]] = icmp slt i32 %[[NEXT_IV]], 1
-; GCDA-NEXT:    br i1 %[[FILE_LOOP_COND]], label %[[FILE_LOOP_HEADER]], label %[[EXIT:.*]]
-;
-; GCDA:       [[EXIT]]:
-; GCDA-NEXT:    ret void
+; GCDA:         call void @llvm_gcda_emit_function({{.*}} @[[FOO]]{{.*}})
+; GCDA:         call void @llvm_gcda_emit_function({{.*}} @[[BAZ]]{{.*}})
+; GCDA:    ret void
 
 ; GCNO: == foo (0) @
 ; GCNO-NOT: == bar ({{[0-9]+}}) @
 ; GCNO: == baz (1) @
 
 define void @foo() !dbg !4 {
   ret void, !dbg !12
 }

test/Transforms/GCOVProfiling/multiple-cus.ll

+; RUN: opt -debugify %S/Inputs/empty-function-1.ll -o %t.1.bc
+; RUN: opt -debugify %S/Inputs/empty-function-2.ll -o %t.2.bc
+; RUN: opt -debugify %S/Inputs/main-calls-empty-functions.ll -o %t.main.bc
+; RUN: llvm-link %t.1.bc %t.2.bc %t.main.bc -o %t.lto.bc
+; RUN: opt -S -insert-gcov-profiling %t.lto.bc -o - | FileCheck %s
+
+; CHECK: @[[EMPTYONE:[0-9]+]] = private unnamed_addr constant {{.*}}empty-function-1.gcda{{.*}}
+; CHECK: @[[EMPTYTWO:[0-9]+]] = private unnamed_addr constant {{.*}}empty-function-2.gcda{{.*}}
+; CHECK: @[[MAIN:[0-9]+]] = private unnamed_addr constant {{.*}}main-calls-empty-functions.gcda{{.*}}
+
+; CHECK: define internal void @__llvm_gcov_writeout(){{.*}}
+; CHECK: {{.*}}call void @llvm_gcda_start_file({{.*}} @[[EMPTYONE]]{{.*}})
+; CHECK: {{.*}}call void @llvm_gcda_start_file({{.*}} @[[EMPTYTWO]]{{.*}})
+; CHECK: {{.*}}call void @llvm_gcda_start_file({{.*}} @[[MAIN]]{{.*}})