Disable gcov instrumentation of functions using funclet-based exception handling

[marco-c]

Summary

This patch fixes the crash from https://bugs.llvm.org/show_bug.cgi?id=34659 and https://bugs.llvm.org/show_bug.cgi?id=34833.

[majnemer]

Please upload a diff with full context.

[majnemer]

lib/Transforms/Instrumentation/GCOVProfiling.cpp

637

I think I'd skip BB if TI->IsEHPad(), that would save a bunch of the checks you are doing on BB.

[rnk]

I think any invoke or cleanupret that unwinds to a catchswitch needs to look through the successors of the catchswitch. The unwind edge may be another catchswitch, which we must also look through. We should add all the non-catchswitch successors to ComplexEdgeSuccs.

lib/Transforms/Instrumentation/GCOVProfiling.cpp

642

I think continue is problematic because it fails to update Edge.

[marco-c]

I think any invoke or cleanupret that unwinds to a catchswitch needs to look through the successors of the catchswitch. The unwind edge may be another catchswitch, which we must also look through. We should add all the non-catchswitch successors to ComplexEdgeSuccs.

The current patch is achieving this, no? All successors from all basic blocks are stored in ComplexEdgeSuccs, but then catchswitchs are skipped.

BTW, the following test case crashes at runtime (after applying this patch, otherwise it doesn't compile at all):

#include <windows.h>
#include <stdio.h>

DWORD FilterFunction() {
  printf("1 ");
  return EXCEPTION_EXECUTE_HANDLER;
}

int main(void) {
  __try {
    __try {
      RaiseException(1, 0, 0, NULL);
    }
    __finally {
      printf("2 ");
    }
  }
  __except(FilterFunction()) {
    printf("3\n");
  }

  return 0;
}

[rnk]

In D38223#888141, @marco-c wrote:

I think any invoke or cleanupret that unwinds to a catchswitch needs to look through the successors of the catchswitch. The unwind edge may be another catchswitch, which we must also look through. We should add all the non-catchswitch successors to ComplexEdgeSuccs.

The current patch is achieving this, no? All successors from all basic blocks are stored in ComplexEdgeSuccs, but then catchswitchs are skipped.

Almost. I think what's missing is that single successor catchswitches should hit the else case instead of continuing the first loop. Also, notice how Edge indexes into a global array of length Edges. When you continue the loop, some of the slots in that array go unused. Maybe that's OK, but it seems like a bug. Sending catchswitch through the else case instead of continuing should fix that.

[marco-c]

Updated patch to add catchswitch successors to ComplexEdgeSuccs

[rnk]

I'm positive something is off here, but let's ship it and worry about that later.

[rnk]

On second thought, since we know this doesn't actually work (https://bugs.llvm.org/show_bug.cgi?id=34833), we should just disable gcov instrumentation of functions with funclets.

[rnk]

Actually marking it for changes...

[marco-c]

Disabled instrumentation for functions using funclet-based EH.

[rnk]

Oh, one consequence of this is that, when normal C++ exceptions are enabled (/EHsc), C++ functions with destructors will not be instrumented for coverage. Basically, this would make gcov incompatible with codebases that use exceptions on Windows. If you disable exceptions and occaisionally use SEH, they'll work fine, which I'm guessing is the case, since you only hit this on SEH code, not normal C++ try/catch.

I'm happy to defer fixing this until a user comes by who cares about enabling C++ EH and gcov. looks good

[marco-c]

Simply moved the isUsingFuncletBasedEH check before setting Result, otherwise it could be set to true even when it wasn't supposed to.

[rnk]

Thanks!

lib/Transforms/Instrumentation/GCOVProfiling.cpp

 
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/Hashing.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/Statistic.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/ADT/StringMap.h"
 #include "llvm/ADT/UniqueVector.h"
+#include "llvm/Analysis/EHPersonalities.h"
 #include "llvm/IR/DebugInfo.h"
 #include "llvm/IR/DebugLoc.h"
 #include "llvm/IR/IRBuilder.h"
 #include "llvm/IR/InstIterator.h"
 #include "llvm/IR/Instructions.h"
 #include "llvm/IR/IntrinsicInst.h"
 #include "llvm/IR/Module.h"
 #include "llvm/Pass.h"
for (auto &I : BB) {
       if (Loc.getLine() == 0) continue;
 
       return true;
     }
   }
   return false;
 }
 
+static bool isUsingFuncletBasedEH(Function &F) {
+  if (!F.hasPersonalityFn()) return false;
+
+  EHPersonality Personality = classifyEHPersonality(F.getPersonalityFn());
+  return isFuncletEHPersonality(Personality);
+}
+
 static bool shouldKeepInEntry(BasicBlock::iterator It) {
   if (isa<AllocaInst>(*It)) return true;
   if (isa<DbgInfoIntrinsic>(*It)) return true;
   if (auto *II = dyn_cast<IntrinsicInst>(It)) {
     if (II->getIntrinsicID() == llvm::Intrinsic::localescape) return true;
   }
 
   return false;
for (unsigned i = 0, e = CU_Nodes->getNumOperands(); i != e; ++i) {
 
     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 funclet-based EH are currently not supported.
+      if (isUsingFuncletBasedEH(F)) continue;
 
       // 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::iterator It = EntryBlock.begin();
       while (shouldKeepInEntry(It))
         ++It;
       EntryBlock.splitBasicBlock(It);
bool GCOVProfiler::emitProfileArcs() {
   bool InsertIndCounterIncrCode = 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;
       if (!Result) Result = true;
+      // TODO: Functions using funclet-based EH are currently not supported.
+      if (isUsingFuncletBasedEH(F)) continue;
+
       unsigned Edges = 0;
       for (auto &BB : F) {
         TerminatorInst *TI = BB.getTerminator();
         if (isa<ReturnInst>(TI))
           ++Edges;
         else
           Edges += TI->getNumSuccessors();
       }
 
       ArrayType *CounterTy =
         ArrayType::get(Type::getInt64Ty(*Ctx), Edges);
       GlobalVariable *Counters =
         new GlobalVariable(*M, CounterTy, false,
                            GlobalValue::InternalLinkage,
                            Constant::getNullValue(CounterTy),