1 //===- GCOVProfiling.cpp - Insert edge counters for gcov profiling --------===//
2 //
3 //                      The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // This pass implements GCOV-style profiling. When this pass is run it emits
11 // "gcno" files next to the existing source, and instruments the code that runs
12 // to records the edges between blocks that run and emit a complementary "gcda"
13 // file on exit.
14 //
15 //===----------------------------------------------------------------------===//
16 
17 #include "llvm/ADT/DenseMap.h"
18 #include "llvm/ADT/Hashing.h"
19 #include "llvm/ADT/STLExtras.h"
20 #include "llvm/ADT/Sequence.h"
21 #include "llvm/ADT/Statistic.h"
22 #include "llvm/ADT/StringExtras.h"
23 #include "llvm/ADT/StringMap.h"
24 #include "llvm/Analysis/EHPersonalities.h"
25 #include "llvm/Analysis/TargetLibraryInfo.h"
26 #include "llvm/IR/CFG.h"
27 #include "llvm/IR/DebugInfo.h"
28 #include "llvm/IR/DebugLoc.h"
29 #include "llvm/IR/IRBuilder.h"
30 #include "llvm/IR/InstIterator.h"
31 #include "llvm/IR/Instructions.h"
32 #include "llvm/IR/IntrinsicInst.h"
33 #include "llvm/IR/Module.h"
34 #include "llvm/Pass.h"
35 #include "llvm/Support/CommandLine.h"
36 #include "llvm/Support/Debug.h"
37 #include "llvm/Support/FileSystem.h"
38 #include "llvm/Support/Path.h"
39 #include "llvm/Support/Regex.h"
40 #include "llvm/Support/raw_ostream.h"
41 #include "llvm/Transforms/Instrumentation.h"
42 #include "llvm/Transforms/Instrumentation/GCOVProfiler.h"
43 #include "llvm/Transforms/Utils/ModuleUtils.h"
44 #include <algorithm>
45 #include <memory>
46 #include <string>
47 #include <utility>
48 using namespace llvm;
49 
50 #define DEBUG_TYPE "insert-gcov-profiling"
51 
52 static cl::opt<std::string>
53 DefaultGCOVVersion("default-gcov-version", cl::init("402*"), cl::Hidden,
54                    cl::ValueRequired);
55 static cl::opt<bool> DefaultExitBlockBeforeBody("gcov-exit-block-before-body",
56                                                 cl::init(false), cl::Hidden);
57 
58 GCOVOptions GCOVOptions::getDefault() {
59   GCOVOptions Options;
60   Options.EmitNotes = true;
61   Options.EmitData = true;
62   Options.UseCfgChecksum = false;
63   Options.NoRedZone = false;
64   Options.FunctionNamesInData = true;
65   Options.ExitBlockBeforeBody = DefaultExitBlockBeforeBody;
66 
67   if (DefaultGCOVVersion.size() != 4) {
68     llvm::report_fatal_error(std::string("Invalid -default-gcov-version: ") +
69                              DefaultGCOVVersion);
70   }
71   memcpy(Options.Version, DefaultGCOVVersion.c_str(), 4);
72   return Options;
73 }
74 
75 namespace {
76 class GCOVFunction;
77 
78 class GCOVProfiler {
79 public:
80   GCOVProfiler() : GCOVProfiler(GCOVOptions::getDefault()) {}
81   GCOVProfiler(const GCOVOptions &Opts) : Options(Opts) {
82     assert((Options.EmitNotes || Options.EmitData) &&
83            "GCOVProfiler asked to do nothing?");
84     ReversedVersion[0] = Options.Version[3];
85     ReversedVersion[1] = Options.Version[2];
86     ReversedVersion[2] = Options.Version[1];
87     ReversedVersion[3] = Options.Version[0];
88     ReversedVersion[4] = '\0';
89   }
90   bool runOnModule(Module &M, const TargetLibraryInfo &TLI);
91 
92 private:
93   // Create the .gcno files for the Module based on DebugInfo.
94   void emitProfileNotes();
95 
96   // Modify the program to track transitions along edges and call into the
97   // profiling runtime to emit .gcda files when run.
98   bool emitProfileArcs();
99 
100   bool isFunctionInstrumented(const Function &F);
101   std::vector<Regex> createRegexesFromString(StringRef RegexesStr);
102   static bool doesFilenameMatchARegex(StringRef Filename,
103                                       std::vector<Regex> &Regexes);
104 
105   // Get pointers to the functions in the runtime library.
106   Constant *getStartFileFunc();
107   Constant *getEmitFunctionFunc();
108   Constant *getEmitArcsFunc();
109   Constant *getSummaryInfoFunc();
110   Constant *getEndFileFunc();
111 
112   // Add the function to write out all our counters to the global destructor
113   // list.
114   Function *
115   insertCounterWriteout(ArrayRef<std::pair<GlobalVariable *, MDNode *>>);
116   Function *insertFlush(ArrayRef<std::pair<GlobalVariable *, MDNode *>>);
117 
118   void AddFlushBeforeForkAndExec();
119 
120   enum class GCovFileType { GCNO, GCDA };
121   std::string mangleName(const DICompileUnit *CU, GCovFileType FileType);
122 
123   GCOVOptions Options;
124 
125   // Reversed, NUL-terminated copy of Options.Version.
126   char ReversedVersion[5];
127   // Checksum, produced by hash of EdgeDestinations
128   SmallVector<uint32_t, 4> FileChecksums;
129 
130   Module *M;
131   const TargetLibraryInfo *TLI;
132   LLVMContext *Ctx;
133   SmallVector<std::unique_ptr<GCOVFunction>, 16> Funcs;
134   std::vector<Regex> FilterRe;
135   std::vector<Regex> ExcludeRe;
136   StringMap<bool> InstrumentedFiles;
137 };
138 
139 class GCOVProfilerLegacyPass : public ModulePass {
140 public:
141   static char ID;
142   GCOVProfilerLegacyPass()
143       : GCOVProfilerLegacyPass(GCOVOptions::getDefault()) {}
144   GCOVProfilerLegacyPass(const GCOVOptions &Opts)
145       : ModulePass(ID), Profiler(Opts) {
146     initializeGCOVProfilerLegacyPassPass(*PassRegistry::getPassRegistry());
147   }
148   StringRef getPassName() const override { return "GCOV Profiler"; }
149 
150   bool runOnModule(Module &M) override {
151     auto &TLI = getAnalysis<TargetLibraryInfoWrapperPass>().getTLI();
152     return Profiler.runOnModule(M, TLI);
153   }
154 
155   void getAnalysisUsage(AnalysisUsage &AU) const override {
156     AU.addRequired<TargetLibraryInfoWrapperPass>();
157   }
158 
159 private:
160   GCOVProfiler Profiler;
161 };
162 }
163 
164 char GCOVProfilerLegacyPass::ID = 0;
165 INITIALIZE_PASS_BEGIN(
166     GCOVProfilerLegacyPass, "insert-gcov-profiling",
167     "Insert instrumentation for GCOV profiling", false, false)
168 INITIALIZE_PASS_DEPENDENCY(TargetLibraryInfoWrapperPass)
169 INITIALIZE_PASS_END(
170     GCOVProfilerLegacyPass, "insert-gcov-profiling",
171     "Insert instrumentation for GCOV profiling", false, false)
172 
173 ModulePass *llvm::createGCOVProfilerPass(const GCOVOptions &Options) {
174   return new GCOVProfilerLegacyPass(Options);
175 }
176 
177 static StringRef getFunctionName(const DISubprogram *SP) {
178   if (!SP->getLinkageName().empty())
179     return SP->getLinkageName();
180   return SP->getName();
181 }
182 
183 namespace {
184   class GCOVRecord {
185    protected:
186     static const char *const LinesTag;
187     static const char *const FunctionTag;
188     static const char *const BlockTag;
189     static const char *const EdgeTag;
190 
191     GCOVRecord() = default;
192 
193     void writeBytes(const char *Bytes, int Size) {
194       os->write(Bytes, Size);
195     }
196 
197     void write(uint32_t i) {
198       writeBytes(reinterpret_cast<char*>(&i), 4);
199     }
200 
201     // Returns the length measured in 4-byte blocks that will be used to
202     // represent this string in a GCOV file
203     static unsigned lengthOfGCOVString(StringRef s) {
204       // A GCOV string is a length, followed by a NUL, then between 0 and 3 NULs
205       // padding out to the next 4-byte word. The length is measured in 4-byte
206       // words including padding, not bytes of actual string.
207       return (s.size() / 4) + 1;
208     }
209 
210     void writeGCOVString(StringRef s) {
211       uint32_t Len = lengthOfGCOVString(s);
212       write(Len);
213       writeBytes(s.data(), s.size());
214 
215       // Write 1 to 4 bytes of NUL padding.
216       assert((unsigned)(4 - (s.size() % 4)) > 0);
217       assert((unsigned)(4 - (s.size() % 4)) <= 4);
218       writeBytes("\0\0\0\0", 4 - (s.size() % 4));
219     }
220 
221     raw_ostream *os;
222   };
223   const char *const GCOVRecord::LinesTag = "\0\0\x45\x01";
224   const char *const GCOVRecord::FunctionTag = "\0\0\0\1";
225   const char *const GCOVRecord::BlockTag = "\0\0\x41\x01";
226   const char *const GCOVRecord::EdgeTag = "\0\0\x43\x01";
227 
228   class GCOVFunction;
229   class GCOVBlock;
230 
231   // Constructed only by requesting it from a GCOVBlock, this object stores a
232   // list of line numbers and a single filename, representing lines that belong
233   // to the block.
234   class GCOVLines : public GCOVRecord {
235    public:
236     void addLine(uint32_t Line) {
237       assert(Line != 0 && "Line zero is not a valid real line number.");
238       Lines.push_back(Line);
239     }
240 
241     uint32_t length() const {
242       // Here 2 = 1 for string length + 1 for '0' id#.
243       return lengthOfGCOVString(Filename) + 2 + Lines.size();
244     }
245 
246     void writeOut() {
247       write(0);
248       writeGCOVString(Filename);
249       for (int i = 0, e = Lines.size(); i != e; ++i)
250         write(Lines[i]);
251     }
252 
253     GCOVLines(StringRef F, raw_ostream *os)
254       : Filename(F) {
255       this->os = os;
256     }
257 
258    private:
259     StringRef Filename;
260     SmallVector<uint32_t, 32> Lines;
261   };
262 
263 
264   // Represent a basic block in GCOV. Each block has a unique number in the
265   // function, number of lines belonging to each block, and a set of edges to
266   // other blocks.
267   class GCOVBlock : public GCOVRecord {
268    public:
269     GCOVLines &getFile(StringRef Filename) {
270       return LinesByFile.try_emplace(Filename, Filename, os).first->second;
271     }
272 
273     void addEdge(GCOVBlock &Successor) {
274       OutEdges.push_back(&Successor);
275     }
276 
277     void writeOut() {
278       uint32_t Len = 3;
279       SmallVector<StringMapEntry<GCOVLines> *, 32> SortedLinesByFile;
280       for (auto &I : LinesByFile) {
281         Len += I.second.length();
282         SortedLinesByFile.push_back(&I);
283       }
284 
285       writeBytes(LinesTag, 4);
286       write(Len);
287       write(Number);
288 
289       llvm::sort(SortedLinesByFile, [](StringMapEntry<GCOVLines> *LHS,
290                                        StringMapEntry<GCOVLines> *RHS) {
291         return LHS->getKey() < RHS->getKey();
292       });
293       for (auto &I : SortedLinesByFile)
294         I->getValue().writeOut();
295       write(0);
296       write(0);
297     }
298 
299     GCOVBlock(const GCOVBlock &RHS) : GCOVRecord(RHS), Number(RHS.Number) {
300       // Only allow copy before edges and lines have been added. After that,
301       // there are inter-block pointers (eg: edges) that won't take kindly to
302       // blocks being copied or moved around.
303       assert(LinesByFile.empty());
304       assert(OutEdges.empty());
305     }
306 
307    private:
308     friend class GCOVFunction;
309 
310     GCOVBlock(uint32_t Number, raw_ostream *os)
311         : Number(Number) {
312       this->os = os;
313     }
314 
315     uint32_t Number;
316     StringMap<GCOVLines> LinesByFile;
317     SmallVector<GCOVBlock *, 4> OutEdges;
318   };
319 
320   // A function has a unique identifier, a checksum (we leave as zero) and a
321   // set of blocks and a map of edges between blocks. This is the only GCOV
322   // object users can construct, the blocks and lines will be rooted here.
323   class GCOVFunction : public GCOVRecord {
324    public:
325      GCOVFunction(const DISubprogram *SP, Function *F, raw_ostream *os,
326                   uint32_t Ident, bool UseCfgChecksum, bool ExitBlockBeforeBody)
327          : SP(SP), Ident(Ident), UseCfgChecksum(UseCfgChecksum), CfgChecksum(0),
328            ReturnBlock(1, os) {
329       this->os = os;
330 
331       LLVM_DEBUG(dbgs() << "Function: " << getFunctionName(SP) << "\n");
332 
333       uint32_t i = 0;
334       for (auto &BB : *F) {
335         // Skip index 1 if it's assigned to the ReturnBlock.
336         if (i == 1 && ExitBlockBeforeBody)
337           ++i;
338         Blocks.insert(std::make_pair(&BB, GCOVBlock(i++, os)));
339       }
340       if (!ExitBlockBeforeBody)
341         ReturnBlock.Number = i;
342 
343       std::string FunctionNameAndLine;
344       raw_string_ostream FNLOS(FunctionNameAndLine);
345       FNLOS << getFunctionName(SP) << SP->getLine();
346       FNLOS.flush();
347       FuncChecksum = hash_value(FunctionNameAndLine);
348     }
349 
350     GCOVBlock &getBlock(BasicBlock *BB) {
351       return Blocks.find(BB)->second;
352     }
353 
354     GCOVBlock &getReturnBlock() {
355       return ReturnBlock;
356     }
357 
358     std::string getEdgeDestinations() {
359       std::string EdgeDestinations;
360       raw_string_ostream EDOS(EdgeDestinations);
361       Function *F = Blocks.begin()->first->getParent();
362       for (BasicBlock &I : *F) {
363         GCOVBlock &Block = getBlock(&I);
364         for (int i = 0, e = Block.OutEdges.size(); i != e; ++i)
365           EDOS << Block.OutEdges[i]->Number;
366       }
367       return EdgeDestinations;
368     }
369 
370     uint32_t getFuncChecksum() {
371       return FuncChecksum;
372     }
373 
374     void setCfgChecksum(uint32_t Checksum) {
375       CfgChecksum = Checksum;
376     }
377 
378     void writeOut() {
379       writeBytes(FunctionTag, 4);
380       uint32_t BlockLen = 1 + 1 + 1 + lengthOfGCOVString(getFunctionName(SP)) +
381                           1 + lengthOfGCOVString(SP->getFilename()) + 1;
382       if (UseCfgChecksum)
383         ++BlockLen;
384       write(BlockLen);
385       write(Ident);
386       write(FuncChecksum);
387       if (UseCfgChecksum)
388         write(CfgChecksum);
389       writeGCOVString(getFunctionName(SP));
390       writeGCOVString(SP->getFilename());
391       write(SP->getLine());
392 
393       // Emit count of blocks.
394       writeBytes(BlockTag, 4);
395       write(Blocks.size() + 1);
396       for (int i = 0, e = Blocks.size() + 1; i != e; ++i) {
397         write(0);  // No flags on our blocks.
398       }
399       LLVM_DEBUG(dbgs() << Blocks.size() << " blocks.\n");
400 
401       // Emit edges between blocks.
402       if (Blocks.empty()) return;
403       Function *F = Blocks.begin()->first->getParent();
404       for (BasicBlock &I : *F) {
405         GCOVBlock &Block = getBlock(&I);
406         if (Block.OutEdges.empty()) continue;
407 
408         writeBytes(EdgeTag, 4);
409         write(Block.OutEdges.size() * 2 + 1);
410         write(Block.Number);
411         for (int i = 0, e = Block.OutEdges.size(); i != e; ++i) {
412           LLVM_DEBUG(dbgs() << Block.Number << " -> "
413                             << Block.OutEdges[i]->Number << "\n");
414           write(Block.OutEdges[i]->Number);
415           write(0);  // no flags
416         }
417       }
418 
419       // Emit lines for each block.
420       for (BasicBlock &I : *F)
421         getBlock(&I).writeOut();
422     }
423 
424    private:
425      const DISubprogram *SP;
426     uint32_t Ident;
427     uint32_t FuncChecksum;
428     bool UseCfgChecksum;
429     uint32_t CfgChecksum;
430     DenseMap<BasicBlock *, GCOVBlock> Blocks;
431     GCOVBlock ReturnBlock;
432   };
433 }
434 
435 // RegexesStr is a string containing differents regex separated by a semi-colon.
436 // For example "foo\..*$;bar\..*$".
437 std::vector<Regex> GCOVProfiler::createRegexesFromString(StringRef RegexesStr) {
438   std::vector<Regex> Regexes;
439   while (!RegexesStr.empty()) {
440     std::pair<StringRef, StringRef> HeadTail = RegexesStr.split(';');
441     if (!HeadTail.first.empty()) {
442       Regex Re(HeadTail.first);
443       std::string Err;
444       if (!Re.isValid(Err)) {
445         Ctx->emitError(Twine("Regex ") + HeadTail.first +
446                        " is not valid: " + Err);
447       }
448       Regexes.emplace_back(std::move(Re));
449     }
450     RegexesStr = HeadTail.second;
451   }
452   return Regexes;
453 }
454 
455 bool GCOVProfiler::doesFilenameMatchARegex(StringRef Filename,
456                                            std::vector<Regex> &Regexes) {
457   for (Regex &Re : Regexes) {
458     if (Re.match(Filename)) {
459       return true;
460     }
461   }
462   return false;
463 }
464 
465 bool GCOVProfiler::isFunctionInstrumented(const Function &F) {
466   if (FilterRe.empty() && ExcludeRe.empty()) {
467     return true;
468   }
469   const StringRef Filename = F.getSubprogram()->getFilename();
470   auto It = InstrumentedFiles.find(Filename);
471   if (It != InstrumentedFiles.end()) {
472     return It->second;
473   }
474 
475   SmallString<256> RealPath;
476   StringRef RealFilename;
477 
478   // Path can be
479   // /usr/lib/gcc/x86_64-linux-gnu/8/../../../../include/c++/8/bits/*.h so for
480   // such a case we must get the real_path.
481   if (sys::fs::real_path(Filename, RealPath)) {
482     // real_path can fail with path like "foo.c".
483     RealFilename = Filename;
484   } else {
485     RealFilename = RealPath;
486   }
487 
488   bool ShouldInstrument;
489   if (FilterRe.empty()) {
490     ShouldInstrument = !doesFilenameMatchARegex(RealFilename, ExcludeRe);
491   } else if (ExcludeRe.empty()) {
492     ShouldInstrument = doesFilenameMatchARegex(RealFilename, FilterRe);
493   } else {
494     ShouldInstrument = doesFilenameMatchARegex(RealFilename, FilterRe) &&
495                        !doesFilenameMatchARegex(RealFilename, ExcludeRe);
496   }
497   InstrumentedFiles[Filename] = ShouldInstrument;
498   return ShouldInstrument;
499 }
500 
501 std::string GCOVProfiler::mangleName(const DICompileUnit *CU,
502                                      GCovFileType OutputType) {
503   bool Notes = OutputType == GCovFileType::GCNO;
504 
505   if (NamedMDNode *GCov = M->getNamedMetadata("llvm.gcov")) {
506     for (int i = 0, e = GCov->getNumOperands(); i != e; ++i) {
507       MDNode *N = GCov->getOperand(i);
508       bool ThreeElement = N->getNumOperands() == 3;
509       if (!ThreeElement && N->getNumOperands() != 2)
510         continue;
511       if (dyn_cast<MDNode>(N->getOperand(ThreeElement ? 2 : 1)) != CU)
512         continue;
513 
514       if (ThreeElement) {
515         // These nodes have no mangling to apply, it's stored mangled in the
516         // bitcode.
517         MDString *NotesFile = dyn_cast<MDString>(N->getOperand(0));
518         MDString *DataFile = dyn_cast<MDString>(N->getOperand(1));
519         if (!NotesFile || !DataFile)
520           continue;
521         return Notes ? NotesFile->getString() : DataFile->getString();
522       }
523 
524       MDString *GCovFile = dyn_cast<MDString>(N->getOperand(0));
525       if (!GCovFile)
526         continue;
527 
528       SmallString<128> Filename = GCovFile->getString();
529       sys::path::replace_extension(Filename, Notes ? "gcno" : "gcda");
530       return Filename.str();
531     }
532   }
533 
534   SmallString<128> Filename = CU->getFilename();
535   sys::path::replace_extension(Filename, Notes ? "gcno" : "gcda");
536   StringRef FName = sys::path::filename(Filename);
537   SmallString<128> CurPath;
538   if (sys::fs::current_path(CurPath)) return FName;
539   sys::path::append(CurPath, FName);
540   return CurPath.str();
541 }
542 
543 bool GCOVProfiler::runOnModule(Module &M, const TargetLibraryInfo &TLI) {
544   this->M = &M;
545   this->TLI = &TLI;
546   Ctx = &M.getContext();
547 
548   AddFlushBeforeForkAndExec();
549 
550   FilterRe = createRegexesFromString(Options.Filter);
551   ExcludeRe = createRegexesFromString(Options.Exclude);
552 
553   if (Options.EmitNotes) emitProfileNotes();
554   if (Options.EmitData) return emitProfileArcs();
555   return false;
556 }
557 
558 PreservedAnalyses GCOVProfilerPass::run(Module &M,
559                                         ModuleAnalysisManager &AM) {
560 
561   GCOVProfiler Profiler(GCOVOpts);
562 
563   auto &TLI = AM.getResult<TargetLibraryAnalysis>(M);
564   if (!Profiler.runOnModule(M, TLI))
565     return PreservedAnalyses::all();
566 
567   return PreservedAnalyses::none();
568 }
569 
570 static bool functionHasLines(Function &F) {
571   // Check whether this function actually has any source lines. Not only
572   // do these waste space, they also can crash gcov.
573   for (auto &BB : F) {
574     for (auto &I : BB) {
575       // Debug intrinsic locations correspond to the location of the
576       // declaration, not necessarily any statements or expressions.
577       if (isa<DbgInfoIntrinsic>(&I)) continue;
578 
579       const DebugLoc &Loc = I.getDebugLoc();
580       if (!Loc)
581         continue;
582 
583       // Artificial lines such as calls to the global constructors.
584       if (Loc.getLine() == 0) continue;
585 
586       return true;
587     }
588   }
589   return false;
590 }
591 
592 static bool isUsingScopeBasedEH(Function &F) {
593   if (!F.hasPersonalityFn()) return false;
594 
595   EHPersonality Personality = classifyEHPersonality(F.getPersonalityFn());
596   return isScopedEHPersonality(Personality);
597 }
598 
599 static bool shouldKeepInEntry(BasicBlock::iterator It) {
600 	if (isa<AllocaInst>(*It)) return true;
601 	if (isa<DbgInfoIntrinsic>(*It)) return true;
602 	if (auto *II = dyn_cast<IntrinsicInst>(It)) {
603 		if (II->getIntrinsicID() == llvm::Intrinsic::localescape) return true;
604 	}
605 
606 	return false;
607 }
608 
609 void GCOVProfiler::AddFlushBeforeForkAndExec() {
610   SmallVector<Instruction *, 2> ForkAndExecs;
611   for (auto &F : M->functions()) {
612     for (auto &I : instructions(F)) {
613       if (CallInst *CI = dyn_cast<CallInst>(&I)) {
614         if (Function *Callee = CI->getCalledFunction()) {
615           LibFunc LF;
616           if (TLI->getLibFunc(*Callee, LF) &&
617               (LF == LibFunc_fork || LF == LibFunc_execl ||
618                LF == LibFunc_execle || LF == LibFunc_execlp ||
619                LF == LibFunc_execv || LF == LibFunc_execvp ||
620                LF == LibFunc_execve || LF == LibFunc_execvpe ||
621                LF == LibFunc_execvP)) {
622             ForkAndExecs.push_back(&I);
623           }
624         }
625       }
626     }
627   }
628 
629   // We need to split the block after the fork/exec call
630   // because else the counters for the lines after will be
631   // the same as before the call.
632   for (auto I : ForkAndExecs) {
633     IRBuilder<> Builder(I);
634     FunctionType *FTy = FunctionType::get(Builder.getVoidTy(), {}, false);
635     Constant *GCOVFlush = M->getOrInsertFunction("__gcov_flush", FTy);
636     Builder.CreateCall(GCOVFlush);
637     I->getParent()->splitBasicBlock(I);
638   }
639 }
640 
641 void GCOVProfiler::emitProfileNotes() {
642   NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu");
643   if (!CU_Nodes) return;
644 
645   for (unsigned i = 0, e = CU_Nodes->getNumOperands(); i != e; ++i) {
646     // Each compile unit gets its own .gcno file. This means that whether we run
647     // this pass over the original .o's as they're produced, or run it after
648     // LTO, we'll generate the same .gcno files.
649 
650     auto *CU = cast<DICompileUnit>(CU_Nodes->getOperand(i));
651 
652     // Skip module skeleton (and module) CUs.
653     if (CU->getDWOId())
654       continue;
655 
656     std::error_code EC;
657     raw_fd_ostream out(mangleName(CU, GCovFileType::GCNO), EC, sys::fs::F_None);
658     if (EC) {
659       Ctx->emitError(Twine("failed to open coverage notes file for writing: ") +
660                      EC.message());
661       continue;
662     }
663 
664     std::string EdgeDestinations;
665 
666     unsigned FunctionIdent = 0;
667     for (auto &F : M->functions()) {
668       DISubprogram *SP = F.getSubprogram();
669       if (!SP) continue;
670       if (!functionHasLines(F) || !isFunctionInstrumented(F))
671         continue;
672       // TODO: Functions using scope-based EH are currently not supported.
673       if (isUsingScopeBasedEH(F)) continue;
674 
675       // gcov expects every function to start with an entry block that has a
676       // single successor, so split the entry block to make sure of that.
677       BasicBlock &EntryBlock = F.getEntryBlock();
678       BasicBlock::iterator It = EntryBlock.begin();
679       while (shouldKeepInEntry(It))
680         ++It;
681       EntryBlock.splitBasicBlock(It);
682 
683       Funcs.push_back(make_unique<GCOVFunction>(SP, &F, &out, FunctionIdent++,
684                                                 Options.UseCfgChecksum,
685                                                 Options.ExitBlockBeforeBody));
686       GCOVFunction &Func = *Funcs.back();
687 
688       // Add the function line number to the lines of the entry block
689       // to have a counter for the function definition.
690       uint32_t Line = SP->getLine();
691       Func.getBlock(&EntryBlock).getFile(SP->getFilename()).addLine(Line);
692 
693       for (auto &BB : F) {
694         GCOVBlock &Block = Func.getBlock(&BB);
695         Instruction *TI = BB.getTerminator();
696         if (int successors = TI->getNumSuccessors()) {
697           for (int i = 0; i != successors; ++i) {
698             Block.addEdge(Func.getBlock(TI->getSuccessor(i)));
699           }
700         } else if (isa<ReturnInst>(TI)) {
701           Block.addEdge(Func.getReturnBlock());
702         }
703 
704         for (auto &I : BB) {
705           // Debug intrinsic locations correspond to the location of the
706           // declaration, not necessarily any statements or expressions.
707           if (isa<DbgInfoIntrinsic>(&I)) continue;
708 
709           const DebugLoc &Loc = I.getDebugLoc();
710           if (!Loc)
711             continue;
712 
713           // Artificial lines such as calls to the global constructors.
714           if (Loc.getLine() == 0 || Loc.isImplicitCode())
715             continue;
716 
717           if (Line == Loc.getLine()) continue;
718           Line = Loc.getLine();
719           if (SP != getDISubprogram(Loc.getScope()))
720             continue;
721 
722           GCOVLines &Lines = Block.getFile(SP->getFilename());
723           Lines.addLine(Loc.getLine());
724         }
725         Line = 0;
726       }
727       EdgeDestinations += Func.getEdgeDestinations();
728     }
729 
730     FileChecksums.push_back(hash_value(EdgeDestinations));
731     out.write("oncg", 4);
732     out.write(ReversedVersion, 4);
733     out.write(reinterpret_cast<char*>(&FileChecksums.back()), 4);
734 
735     for (auto &Func : Funcs) {
736       Func->setCfgChecksum(FileChecksums.back());
737       Func->writeOut();
738     }
739 
740     out.write("\0\0\0\0\0\0\0\0", 8);  // EOF
741     out.close();
742   }
743 }
744 
745 bool GCOVProfiler::emitProfileArcs() {
746   NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu");
747   if (!CU_Nodes) return false;
748 
749   bool Result = false;
750   for (unsigned i = 0, e = CU_Nodes->getNumOperands(); i != e; ++i) {
751     SmallVector<std::pair<GlobalVariable *, MDNode *>, 8> CountersBySP;
752     for (auto &F : M->functions()) {
753       DISubprogram *SP = F.getSubprogram();
754       if (!SP) continue;
755       if (!functionHasLines(F) || !isFunctionInstrumented(F))
756         continue;
757       // TODO: Functions using scope-based EH are currently not supported.
758       if (isUsingScopeBasedEH(F)) continue;
759       if (!Result) Result = true;
760 
761       DenseMap<std::pair<BasicBlock *, BasicBlock *>, unsigned> EdgeToCounter;
762       unsigned Edges = 0;
763       for (auto &BB : F) {
764         Instruction *TI = BB.getTerminator();
765         if (isa<ReturnInst>(TI)) {
766           EdgeToCounter[{&BB, nullptr}] = Edges++;
767         } else {
768           for (BasicBlock *Succ : successors(TI)) {
769             EdgeToCounter[{&BB, Succ}] = Edges++;
770           }
771         }
772       }
773 
774       ArrayType *CounterTy =
775         ArrayType::get(Type::getInt64Ty(*Ctx), Edges);
776       GlobalVariable *Counters =
777         new GlobalVariable(*M, CounterTy, false,
778                            GlobalValue::InternalLinkage,
779                            Constant::getNullValue(CounterTy),
780                            "__llvm_gcov_ctr");
781       CountersBySP.push_back(std::make_pair(Counters, SP));
782 
783       // If a BB has several predecessors, use a PHINode to select
784       // the correct counter.
785       for (auto &BB : F) {
786         const unsigned EdgeCount =
787             std::distance(pred_begin(&BB), pred_end(&BB));
788         if (EdgeCount) {
789           // The phi node must be at the begin of the BB.
790           IRBuilder<> BuilderForPhi(&*BB.begin());
791           Type *Int64PtrTy = Type::getInt64PtrTy(*Ctx);
792           PHINode *Phi = BuilderForPhi.CreatePHI(Int64PtrTy, EdgeCount);
793           for (BasicBlock *Pred : predecessors(&BB)) {
794             auto It = EdgeToCounter.find({Pred, &BB});
795             assert(It != EdgeToCounter.end());
796             const unsigned Edge = It->second;
797             Value *EdgeCounter =
798                 BuilderForPhi.CreateConstInBoundsGEP2_64(Counters, 0, Edge);
799             Phi->addIncoming(EdgeCounter, Pred);
800           }
801 
802           // Skip phis, landingpads.
803           IRBuilder<> Builder(&*BB.getFirstInsertionPt());
804           Value *Count = Builder.CreateLoad(Phi);
805           Count = Builder.CreateAdd(Count, Builder.getInt64(1));
806           Builder.CreateStore(Count, Phi);
807 
808           Instruction *TI = BB.getTerminator();
809           if (isa<ReturnInst>(TI)) {
810             auto It = EdgeToCounter.find({&BB, nullptr});
811             assert(It != EdgeToCounter.end());
812             const unsigned Edge = It->second;
813             Value *Counter =
814                 Builder.CreateConstInBoundsGEP2_64(Counters, 0, Edge);
815             Value *Count = Builder.CreateLoad(Counter);
816             Count = Builder.CreateAdd(Count, Builder.getInt64(1));
817             Builder.CreateStore(Count, Counter);
818           }
819         }
820       }
821     }
822 
823     Function *WriteoutF = insertCounterWriteout(CountersBySP);
824     Function *FlushF = insertFlush(CountersBySP);
825 
826     // Create a small bit of code that registers the "__llvm_gcov_writeout" to
827     // be executed at exit and the "__llvm_gcov_flush" function to be executed
828     // when "__gcov_flush" is called.
829     FunctionType *FTy = FunctionType::get(Type::getVoidTy(*Ctx), false);
830     Function *F = Function::Create(FTy, GlobalValue::InternalLinkage,
831                                    "__llvm_gcov_init", M);
832     F->setUnnamedAddr(GlobalValue::UnnamedAddr::Global);
833     F->setLinkage(GlobalValue::InternalLinkage);
834     F->addFnAttr(Attribute::NoInline);
835     if (Options.NoRedZone)
836       F->addFnAttr(Attribute::NoRedZone);
837 
838     BasicBlock *BB = BasicBlock::Create(*Ctx, "entry", F);
839     IRBuilder<> Builder(BB);
840 
841     FTy = FunctionType::get(Type::getVoidTy(*Ctx), false);
842     Type *Params[] = {
843       PointerType::get(FTy, 0),
844       PointerType::get(FTy, 0)
845     };
846     FTy = FunctionType::get(Builder.getVoidTy(), Params, false);
847 
848     // Initialize the environment and register the local writeout and flush
849     // functions.
850     Constant *GCOVInit = M->getOrInsertFunction("llvm_gcov_init", FTy);
851     Builder.CreateCall(GCOVInit, {WriteoutF, FlushF});
852     Builder.CreateRetVoid();
853 
854     appendToGlobalCtors(*M, F, 0);
855   }
856 
857   return Result;
858 }
859 
860 Constant *GCOVProfiler::getStartFileFunc() {
861   Type *Args[] = {
862     Type::getInt8PtrTy(*Ctx),  // const char *orig_filename
863     Type::getInt8PtrTy(*Ctx),  // const char version[4]
864     Type::getInt32Ty(*Ctx),    // uint32_t checksum
865   };
866   FunctionType *FTy = FunctionType::get(Type::getVoidTy(*Ctx), Args, false);
867   auto *Res = M->getOrInsertFunction("llvm_gcda_start_file", FTy);
868   if (Function *FunRes = dyn_cast<Function>(Res))
869     if (auto AK = TLI->getExtAttrForI32Param(false))
870       FunRes->addParamAttr(2, AK);
871   return Res;
872 
873 }
874 
875 Constant *GCOVProfiler::getEmitFunctionFunc() {
876   Type *Args[] = {
877     Type::getInt32Ty(*Ctx),    // uint32_t ident
878     Type::getInt8PtrTy(*Ctx),  // const char *function_name
879     Type::getInt32Ty(*Ctx),    // uint32_t func_checksum
880     Type::getInt8Ty(*Ctx),     // uint8_t use_extra_checksum
881     Type::getInt32Ty(*Ctx),    // uint32_t cfg_checksum
882   };
883   FunctionType *FTy = FunctionType::get(Type::getVoidTy(*Ctx), Args, false);
884   auto *Res = M->getOrInsertFunction("llvm_gcda_emit_function", FTy);
885   if (Function *FunRes = dyn_cast<Function>(Res))
886     if (auto AK = TLI->getExtAttrForI32Param(false)) {
887       FunRes->addParamAttr(0, AK);
888       FunRes->addParamAttr(2, AK);
889       FunRes->addParamAttr(3, AK);
890       FunRes->addParamAttr(4, AK);
891     }
892   return Res;
893 }
894 
895 Constant *GCOVProfiler::getEmitArcsFunc() {
896   Type *Args[] = {
897     Type::getInt32Ty(*Ctx),     // uint32_t num_counters
898     Type::getInt64PtrTy(*Ctx),  // uint64_t *counters
899   };
900   FunctionType *FTy = FunctionType::get(Type::getVoidTy(*Ctx), Args, false);
901   auto *Res = M->getOrInsertFunction("llvm_gcda_emit_arcs", FTy);
902   if (Function *FunRes = dyn_cast<Function>(Res))
903     if (auto AK = TLI->getExtAttrForI32Param(false))
904       FunRes->addParamAttr(0, AK);
905   return Res;
906 }
907 
908 Constant *GCOVProfiler::getSummaryInfoFunc() {
909   FunctionType *FTy = FunctionType::get(Type::getVoidTy(*Ctx), false);
910   return M->getOrInsertFunction("llvm_gcda_summary_info", FTy);
911 }
912 
913 Constant *GCOVProfiler::getEndFileFunc() {
914   FunctionType *FTy = FunctionType::get(Type::getVoidTy(*Ctx), false);
915   return M->getOrInsertFunction("llvm_gcda_end_file", FTy);
916 }
917 
918 Function *GCOVProfiler::insertCounterWriteout(
919     ArrayRef<std::pair<GlobalVariable *, MDNode *> > CountersBySP) {
920   FunctionType *WriteoutFTy = FunctionType::get(Type::getVoidTy(*Ctx), false);
921   Function *WriteoutF = M->getFunction("__llvm_gcov_writeout");
922   if (!WriteoutF)
923     WriteoutF = Function::Create(WriteoutFTy, GlobalValue::InternalLinkage,
924                                  "__llvm_gcov_writeout", M);
925   WriteoutF->setUnnamedAddr(GlobalValue::UnnamedAddr::Global);
926   WriteoutF->addFnAttr(Attribute::NoInline);
927   if (Options.NoRedZone)
928     WriteoutF->addFnAttr(Attribute::NoRedZone);
929 
930   BasicBlock *BB = BasicBlock::Create(*Ctx, "entry", WriteoutF);
931   IRBuilder<> Builder(BB);
932 
933   Constant *StartFile = getStartFileFunc();
934   Constant *EmitFunction = getEmitFunctionFunc();
935   Constant *EmitArcs = getEmitArcsFunc();
936   Constant *SummaryInfo = getSummaryInfoFunc();
937   Constant *EndFile = getEndFileFunc();
938 
939   NamedMDNode *CUNodes = M->getNamedMetadata("llvm.dbg.cu");
940   if (!CUNodes) {
941     Builder.CreateRetVoid();
942     return WriteoutF;
943   }
944 
945   // Collect the relevant data into a large constant data structure that we can
946   // walk to write out everything.
947   StructType *StartFileCallArgsTy = StructType::create(
948       {Builder.getInt8PtrTy(), Builder.getInt8PtrTy(), Builder.getInt32Ty()});
949   StructType *EmitFunctionCallArgsTy = StructType::create(
950       {Builder.getInt32Ty(), Builder.getInt8PtrTy(), Builder.getInt32Ty(),
951        Builder.getInt8Ty(), Builder.getInt32Ty()});
952   StructType *EmitArcsCallArgsTy = StructType::create(
953       {Builder.getInt32Ty(), Builder.getInt64Ty()->getPointerTo()});
954   StructType *FileInfoTy =
955       StructType::create({StartFileCallArgsTy, Builder.getInt32Ty(),
956                           EmitFunctionCallArgsTy->getPointerTo(),
957                           EmitArcsCallArgsTy->getPointerTo()});
958 
959   Constant *Zero32 = Builder.getInt32(0);
960   // Build an explicit array of two zeros for use in ConstantExpr GEP building.
961   Constant *TwoZero32s[] = {Zero32, Zero32};
962 
963   SmallVector<Constant *, 8> FileInfos;
964   for (int i : llvm::seq<int>(0, CUNodes->getNumOperands())) {
965     auto *CU = cast<DICompileUnit>(CUNodes->getOperand(i));
966 
967     // Skip module skeleton (and module) CUs.
968     if (CU->getDWOId())
969       continue;
970 
971     std::string FilenameGcda = mangleName(CU, GCovFileType::GCDA);
972     uint32_t CfgChecksum = FileChecksums.empty() ? 0 : FileChecksums[i];
973     auto *StartFileCallArgs = ConstantStruct::get(
974         StartFileCallArgsTy, {Builder.CreateGlobalStringPtr(FilenameGcda),
975                               Builder.CreateGlobalStringPtr(ReversedVersion),
976                               Builder.getInt32(CfgChecksum)});
977 
978     SmallVector<Constant *, 8> EmitFunctionCallArgsArray;
979     SmallVector<Constant *, 8> EmitArcsCallArgsArray;
980     for (int j : llvm::seq<int>(0, CountersBySP.size())) {
981       auto *SP = cast_or_null<DISubprogram>(CountersBySP[j].second);
982       uint32_t FuncChecksum = Funcs.empty() ? 0 : Funcs[j]->getFuncChecksum();
983       EmitFunctionCallArgsArray.push_back(ConstantStruct::get(
984           EmitFunctionCallArgsTy,
985           {Builder.getInt32(j),
986            Options.FunctionNamesInData
987                ? Builder.CreateGlobalStringPtr(getFunctionName(SP))
988                : Constant::getNullValue(Builder.getInt8PtrTy()),
989            Builder.getInt32(FuncChecksum),
990            Builder.getInt8(Options.UseCfgChecksum),
991            Builder.getInt32(CfgChecksum)}));
992 
993       GlobalVariable *GV = CountersBySP[j].first;
994       unsigned Arcs = cast<ArrayType>(GV->getValueType())->getNumElements();
995       EmitArcsCallArgsArray.push_back(ConstantStruct::get(
996           EmitArcsCallArgsTy,
997           {Builder.getInt32(Arcs), ConstantExpr::getInBoundsGetElementPtr(
998                                        GV->getValueType(), GV, TwoZero32s)}));
999     }
1000     // Create global arrays for the two emit calls.
1001     int CountersSize = CountersBySP.size();
1002     assert(CountersSize == (int)EmitFunctionCallArgsArray.size() &&
1003            "Mismatched array size!");
1004     assert(CountersSize == (int)EmitArcsCallArgsArray.size() &&
1005            "Mismatched array size!");
1006     auto *EmitFunctionCallArgsArrayTy =
1007         ArrayType::get(EmitFunctionCallArgsTy, CountersSize);
1008     auto *EmitFunctionCallArgsArrayGV = new GlobalVariable(
1009         *M, EmitFunctionCallArgsArrayTy, /*isConstant*/ true,
1010         GlobalValue::InternalLinkage,
1011         ConstantArray::get(EmitFunctionCallArgsArrayTy,
1012                            EmitFunctionCallArgsArray),
1013         Twine("__llvm_internal_gcov_emit_function_args.") + Twine(i));
1014     auto *EmitArcsCallArgsArrayTy =
1015         ArrayType::get(EmitArcsCallArgsTy, CountersSize);
1016     EmitFunctionCallArgsArrayGV->setUnnamedAddr(
1017         GlobalValue::UnnamedAddr::Global);
1018     auto *EmitArcsCallArgsArrayGV = new GlobalVariable(
1019         *M, EmitArcsCallArgsArrayTy, /*isConstant*/ true,
1020         GlobalValue::InternalLinkage,
1021         ConstantArray::get(EmitArcsCallArgsArrayTy, EmitArcsCallArgsArray),
1022         Twine("__llvm_internal_gcov_emit_arcs_args.") + Twine(i));
1023     EmitArcsCallArgsArrayGV->setUnnamedAddr(GlobalValue::UnnamedAddr::Global);
1024 
1025     FileInfos.push_back(ConstantStruct::get(
1026         FileInfoTy,
1027         {StartFileCallArgs, Builder.getInt32(CountersSize),
1028          ConstantExpr::getInBoundsGetElementPtr(EmitFunctionCallArgsArrayTy,
1029                                                 EmitFunctionCallArgsArrayGV,
1030                                                 TwoZero32s),
1031          ConstantExpr::getInBoundsGetElementPtr(
1032              EmitArcsCallArgsArrayTy, EmitArcsCallArgsArrayGV, TwoZero32s)}));
1033   }
1034 
1035   // If we didn't find anything to actually emit, bail on out.
1036   if (FileInfos.empty()) {
1037     Builder.CreateRetVoid();
1038     return WriteoutF;
1039   }
1040 
1041   // To simplify code, we cap the number of file infos we write out to fit
1042   // easily in a 32-bit signed integer. This gives consistent behavior between
1043   // 32-bit and 64-bit systems without requiring (potentially very slow) 64-bit
1044   // operations on 32-bit systems. It also seems unreasonable to try to handle
1045   // more than 2 billion files.
1046   if ((int64_t)FileInfos.size() > (int64_t)INT_MAX)
1047     FileInfos.resize(INT_MAX);
1048 
1049   // Create a global for the entire data structure so we can walk it more
1050   // easily.
1051   auto *FileInfoArrayTy = ArrayType::get(FileInfoTy, FileInfos.size());
1052   auto *FileInfoArrayGV = new GlobalVariable(
1053       *M, FileInfoArrayTy, /*isConstant*/ true, GlobalValue::InternalLinkage,
1054       ConstantArray::get(FileInfoArrayTy, FileInfos),
1055       "__llvm_internal_gcov_emit_file_info");
1056   FileInfoArrayGV->setUnnamedAddr(GlobalValue::UnnamedAddr::Global);
1057 
1058   // Create the CFG for walking this data structure.
1059   auto *FileLoopHeader =
1060       BasicBlock::Create(*Ctx, "file.loop.header", WriteoutF);
1061   auto *CounterLoopHeader =
1062       BasicBlock::Create(*Ctx, "counter.loop.header", WriteoutF);
1063   auto *FileLoopLatch = BasicBlock::Create(*Ctx, "file.loop.latch", WriteoutF);
1064   auto *ExitBB = BasicBlock::Create(*Ctx, "exit", WriteoutF);
1065 
1066   // We always have at least one file, so just branch to the header.
1067   Builder.CreateBr(FileLoopHeader);
1068 
1069   // The index into the files structure is our loop induction variable.
1070   Builder.SetInsertPoint(FileLoopHeader);
1071   PHINode *IV =
1072       Builder.CreatePHI(Builder.getInt32Ty(), /*NumReservedValues*/ 2);
1073   IV->addIncoming(Builder.getInt32(0), BB);
1074   auto *FileInfoPtr =
1075       Builder.CreateInBoundsGEP(FileInfoArrayGV, {Builder.getInt32(0), IV});
1076   auto *StartFileCallArgsPtr = Builder.CreateStructGEP(FileInfoPtr, 0);
1077   auto *StartFileCall = Builder.CreateCall(
1078       StartFile,
1079       {Builder.CreateLoad(Builder.CreateStructGEP(StartFileCallArgsPtr, 0)),
1080        Builder.CreateLoad(Builder.CreateStructGEP(StartFileCallArgsPtr, 1)),
1081        Builder.CreateLoad(Builder.CreateStructGEP(StartFileCallArgsPtr, 2))});
1082   if (auto AK = TLI->getExtAttrForI32Param(false))
1083     StartFileCall->addParamAttr(2, AK);
1084   auto *NumCounters =
1085       Builder.CreateLoad(Builder.CreateStructGEP(FileInfoPtr, 1));
1086   auto *EmitFunctionCallArgsArray =
1087       Builder.CreateLoad(Builder.CreateStructGEP(FileInfoPtr, 2));
1088   auto *EmitArcsCallArgsArray =
1089       Builder.CreateLoad(Builder.CreateStructGEP(FileInfoPtr, 3));
1090   auto *EnterCounterLoopCond =
1091       Builder.CreateICmpSLT(Builder.getInt32(0), NumCounters);
1092   Builder.CreateCondBr(EnterCounterLoopCond, CounterLoopHeader, FileLoopLatch);
1093 
1094   Builder.SetInsertPoint(CounterLoopHeader);
1095   auto *JV = Builder.CreatePHI(Builder.getInt32Ty(), /*NumReservedValues*/ 2);
1096   JV->addIncoming(Builder.getInt32(0), FileLoopHeader);
1097   auto *EmitFunctionCallArgsPtr =
1098       Builder.CreateInBoundsGEP(EmitFunctionCallArgsArray, {JV});
1099   auto *EmitFunctionCall = Builder.CreateCall(
1100       EmitFunction,
1101       {Builder.CreateLoad(Builder.CreateStructGEP(EmitFunctionCallArgsPtr, 0)),
1102        Builder.CreateLoad(Builder.CreateStructGEP(EmitFunctionCallArgsPtr, 1)),
1103        Builder.CreateLoad(Builder.CreateStructGEP(EmitFunctionCallArgsPtr, 2)),
1104        Builder.CreateLoad(Builder.CreateStructGEP(EmitFunctionCallArgsPtr, 3)),
1105        Builder.CreateLoad(
1106            Builder.CreateStructGEP(EmitFunctionCallArgsPtr, 4))});
1107   if (auto AK = TLI->getExtAttrForI32Param(false)) {
1108     EmitFunctionCall->addParamAttr(0, AK);
1109     EmitFunctionCall->addParamAttr(2, AK);
1110     EmitFunctionCall->addParamAttr(3, AK);
1111     EmitFunctionCall->addParamAttr(4, AK);
1112   }
1113   auto *EmitArcsCallArgsPtr =
1114       Builder.CreateInBoundsGEP(EmitArcsCallArgsArray, {JV});
1115   auto *EmitArcsCall = Builder.CreateCall(
1116       EmitArcs,
1117       {Builder.CreateLoad(Builder.CreateStructGEP(EmitArcsCallArgsPtr, 0)),
1118        Builder.CreateLoad(Builder.CreateStructGEP(EmitArcsCallArgsPtr, 1))});
1119   if (auto AK = TLI->getExtAttrForI32Param(false))
1120     EmitArcsCall->addParamAttr(0, AK);
1121   auto *NextJV = Builder.CreateAdd(JV, Builder.getInt32(1));
1122   auto *CounterLoopCond = Builder.CreateICmpSLT(NextJV, NumCounters);
1123   Builder.CreateCondBr(CounterLoopCond, CounterLoopHeader, FileLoopLatch);
1124   JV->addIncoming(NextJV, CounterLoopHeader);
1125 
1126   Builder.SetInsertPoint(FileLoopLatch);
1127   Builder.CreateCall(SummaryInfo, {});
1128   Builder.CreateCall(EndFile, {});
1129   auto *NextIV = Builder.CreateAdd(IV, Builder.getInt32(1));
1130   auto *FileLoopCond =
1131       Builder.CreateICmpSLT(NextIV, Builder.getInt32(FileInfos.size()));
1132   Builder.CreateCondBr(FileLoopCond, FileLoopHeader, ExitBB);
1133   IV->addIncoming(NextIV, FileLoopLatch);
1134 
1135   Builder.SetInsertPoint(ExitBB);
1136   Builder.CreateRetVoid();
1137 
1138   return WriteoutF;
1139 }
1140 
1141 Function *GCOVProfiler::
1142 insertFlush(ArrayRef<std::pair<GlobalVariable*, MDNode*> > CountersBySP) {
1143   FunctionType *FTy = FunctionType::get(Type::getVoidTy(*Ctx), false);
1144   Function *FlushF = M->getFunction("__llvm_gcov_flush");
1145   if (!FlushF)
1146     FlushF = Function::Create(FTy, GlobalValue::InternalLinkage,
1147                               "__llvm_gcov_flush", M);
1148   else
1149     FlushF->setLinkage(GlobalValue::InternalLinkage);
1150   FlushF->setUnnamedAddr(GlobalValue::UnnamedAddr::Global);
1151   FlushF->addFnAttr(Attribute::NoInline);
1152   if (Options.NoRedZone)
1153     FlushF->addFnAttr(Attribute::NoRedZone);
1154 
1155   BasicBlock *Entry = BasicBlock::Create(*Ctx, "entry", FlushF);
1156 
1157   // Write out the current counters.
1158   Constant *WriteoutF = M->getFunction("__llvm_gcov_writeout");
1159   assert(WriteoutF && "Need to create the writeout function first!");
1160 
1161   IRBuilder<> Builder(Entry);
1162   Builder.CreateCall(WriteoutF, {});
1163 
1164   // Zero out the counters.
1165   for (const auto &I : CountersBySP) {
1166     GlobalVariable *GV = I.first;
1167     Constant *Null = Constant::getNullValue(GV->getValueType());
1168     Builder.CreateStore(Null, GV);
1169   }
1170 
1171   Type *RetTy = FlushF->getReturnType();
1172   if (RetTy == Type::getVoidTy(*Ctx))
1173     Builder.CreateRetVoid();
1174   else if (RetTy->isIntegerTy())
1175     // Used if __llvm_gcov_flush was implicitly declared.
1176     Builder.CreateRet(ConstantInt::get(RetTy, 0));
1177   else
1178     report_fatal_error("invalid return type for __llvm_gcov_flush");
1179 
1180   return FlushF;
1181 }
1182