[GCOV] Flush counters before to avoid counting the execution before fork twice and for exec** functions we must flush before the call

[calixte]

Summary

This is replacement for patch in https://reviews.llvm.org/D49460.
When we fork, the counters are duplicate as they're and so the values are finally wrong when writing gcda for parent and child.
So just before to fork, we flush the counters and so the parent and the child have new counters set to zero.
For exec** functions, we need to flush before the call to have some data.

[vsk]

Don't you just want to reset the counters in the child process?

lib/Transforms/Instrumentation/GCOVProfiling.cpp

535

See InstIterator.h. The instructions() range helper might be more convenient.

541

Take a look at TargetLibraryInfo.{h, def}. It might be cleaner to define fork() there, then check if you see a LibFunc_fork.

556

Why is this needed?

[calixte]

lib/Transforms/Instrumentation/GCOVProfiling.cpp

556

The line after the fork is executed 2 times: 1 time with the parent and 1 time with the child. So if we don't split the block the counter for this line (and the next ones in the same block as the fork) is only 1. So in putting a new block here and so a new counter in it we can reflect that the lines after the fork are executed two times.

[calixte]

Fix comments from vsk and handle exec** functions too.

[marco-c]

include/llvm/Analysis/TargetLibraryInfo.def

588 ↗

(On Diff #172800)

There's also execve.

lib/Transforms/Instrumentation/GCOVProfiling.cpp

473

We should do the flushing before fork/exec when we are cross-compiling from Windows to a target that supports fork/exec.
We have two options:

1. Instead of using _WIN32, check that the target of the compilation isn't Windows;
2. Just add the flush always, as it's effect is not important if we are on Windows and the function is defined by a user.

[calixte]

Handle execve, fix issues with execvp and remove _WIN32.

lib/Transforms/Instrumentation/GCOVProfiling.cpp

private:
   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 *>>);
 
+  void AddFlushBeforeFork();
+
   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
std::string GCOVProfiler::mangleName(const DICompileUnit *CU,
   return CurPath.str();
 }
 
 bool GCOVProfiler::runOnModule(Module &M, const TargetLibraryInfo &TLI) {
   this->M = &M;
   this->TLI = &TLI;
   Ctx = &M.getContext();
 
+  AddFlushBeforeFork();
+
   if (Options.EmitNotes) emitProfileNotes();
   if (Options.EmitData) return emitProfileArcs();
   return false;
 }
 
 PreservedAnalyses GCOVProfilerPass::run(Module &M,
                                         ModuleAnalysisManager &AM) {
 
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::AddFlushBeforeFork() {
+  SmallVector<Instruction *, 2> Forks;
+  for (auto &F : M->functions()) {
+    for (auto &BB : F) {
+      for (auto &I : BB) {
+        if (CallInst *CI = dyn_cast<CallInst>(&I)) {
+          if (Function *Callee = CI->getCalledFunction()) {
+            if (Callee->getName() == "fork") {
+              FunctionType *FT = Callee->getFunctionType();
+              if (FT->getReturnType()->isIntegerTy(32) &&
+                  FT->getNumParams() == 0) {
+                Forks.push_back(&I);
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+
+  for (auto I : Forks) {
+    IRBuilder<> Builder(I);
+    FunctionType *FTy = FunctionType::get(Builder.getVoidTy(), {}, false);
+    Constant *GCOVFlush = M->getOrInsertFunction("__gcov_flush", FTy);
+    Builder.CreateCall(GCOVFlush);
+    I->getParent()->splitBasicBlock(I);
+  }
+}
+
 void GCOVProfiler::emitProfileNotes() {
   NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu");
   if (!CU_Nodes) return;
 
   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.