[PGO] Handle cases of non-instrument BBs

[xur]

Summary

As shown in PR41279, some basic blocks (such as catchswitch) cannot be instrumented.
This patch filters out these BBs in PGO instrumentation.

[xur]

Another change of this patch is to move down statistic collection code for critical edge. I think this is a better place.

[davidxl]

llvm/lib/Transforms/Instrumentation/PGOInstrumentation.cpp

801

Add a comment here explaining the predicate.

[xur]

My previous patch was not complete -- we need to set the profile count to the fail-to-instrument edge. Otherwise, we cannot propagate the counts in the CFG.
The new patch has this part of change.
Updated the test to test the profile-use.

Also added comments suggested by David.

[davidxl]

llvm/lib/Transforms/Instrumentation/PGOInstrumentation.cpp

1120

The change seems pretty substantial. Is it enough just do one pass and set all edges not already with a valid count to zero count?

[xur]

llvm/lib/Transforms/Instrumentation/PGOInstrumentation.cpp

1120

After MST, we mark the edges that will be instrumented. The instrumentation needs to be done in BB. So we have getInstrBB() to decide which BB to instrument. in getInstrBB, we split BB for critical edges, so edges can be added and remove. BB could be added too.

Previous implementation assumes that all edges that marked instrument will be instrumented. So we have one pass that sets the instrumented BB and the instrumented edges.
With that assumption, all the instrumented edges will have a valid count. After that we can populate the count to all the remaining edges.

Now, some of the BBs that supposed to instrumented has no count. Some of the instrumented edges have no count, so the population fails.
I fix this by setting counts in two steps: first step to read all the counts in profile files to set count for the instrumented BB.
In the second step, I check all the instrumented edges: I should get the counts from source or sink. Otherwise, it should be case of not able to instrument. I set the count to 0.

Doing this in one step is more tricky. Note that previously set the population data structure (OutEdges, InEdges) after the getInstrBB(). This way we don't need to update them for split BBs.

I think doing this in two steps simplifies the code and is clearly conceptually.

We probably should not mark all edges as valid in reading count step. This could mask some errors in count population. The valid bit should be set by count population, I think.

[davidxl]

llvm/lib/Transforms/Instrumentation/PGOInstrumentation.cpp

1120

I understand the need to do two pass annotation, but in the first pass when BB is annotated with count, setting inedge and outedge count like

if (Info.InEdges.size() == 1) {

   ....
}

is still correct.

What I meant is that why can't the second pass be as simple as just mark remaining edges (not annotated in the first pass) with zero count?

[xur]

llvm/lib/Transforms/Instrumentation/PGOInstrumentation.cpp

1120

InEdges is initialized after the first step. So that piece code is effectively dead code.

[davidxl]

llvm/lib/Transforms/Instrumentation/PGOInstrumentation.cpp

1120

Can the InEdges/OutEdges be set in getInstrumentedBBs? It seems a natural place to set the CFG after critical edge split.

[xur]

llvm/lib/Transforms/Instrumentation/PGOInstrumentation.cpp

1120

Do you mean setting the InEdges/OutEdges before getInstrumentedBBs() and updating them when splitting?
Yes. It can be done.

I chose not to that for two reasons:
(1) the edges are stored in vectors. Deletion in a vector is not efficient.
(2) InEdges/OutEdges are only used in fdo-use compilation. getInstrumentedBBs() is shared by fdo-use and fdo-instrument. Doing it in instrumentation is redundant.

[davidxl]

llvm/lib/Transforms/Instrumentation/PGOInstrumentation.cpp

1120

No need to update. Just split the following from popluteCounters and put it at the end of getInstrumentedBBs:

for (auto &E : FuncInfo.MST.AllEdges) {
  if (E->Removed)
    continue;

  const BasicBlock *SrcBB = E->SrcBB;
  const BasicBlock *DestBB = E->DestBB;
  UseBBInfo &SrcInfo = getBBInfo(SrcBB);
  UseBBInfo &DestInfo = getBBInfo(DestBB);
  SrcInfo.OutEdges.push_back(E.get());
  DestInfo.InEdges.push_back(E.get());

}

[xur]

llvm/lib/Transforms/Instrumentation/PGOInstrumentation.cpp

1120

getInstrumentedBBs() is a template funciton. The one instantiated for instrumentation does not have InEdges/OutEdges (it uses BBInfo). We would need a specialization for UseBBInfo type.

[davidxl]

This can be handled this way:

BBInfo &SrcInfo = getBBInfo(SrcBB);    // BBInfo is the template type
BBInfo &DestInfo = getBBInfo(DestBB);
SrcInfo.addOutEdge(E.get());
DestInfo.addInEdge(E.get());

For base class BBInfo, addOutEdge, addInEdge will be empty, while it is defined for UseBBInfo class.

By so doing, the code is more readable.

[xur]

Integrated David's review suggestions.

[xur]

In D62700#1536841, @davidxl wrote:

This can be handled this way:

BBInfo &SrcInfo = getBBInfo(SrcBB);    // BBInfo is the template type
BBInfo &DestInfo = getBBInfo(DestBB);
SrcInfo.addOutEdge(E.get());
DestInfo.addInEdge(E.get());

For base class BBInfo, addOutEdge, addInEdge will be empty, while it is defined for UseBBInfo class.

By so doing, the code is more readable.

Done.

[davidxl]

lgtm

llvm/lib/Transforms/Instrumentation/PGOInstrumentation.cpp

struct BBInfo {
   uint32_t Rank = 0;
 
   BBInfo(unsigned IX) : Group(this), Index(IX) {}
 
   // Return the information string of this object.
   const std::string infoString() const {
     return (Twine("Index=") + Twine(Index)).str();
   }
+
+  // Empty function -- only applicable to UseBBInfo.
+  void addOutEdge(PGOEdge *E LLVM_ATTRIBUTE_UNUSED) {}
+
+  // Empty function -- only applicable to UseBBInfo.
+  void addInEdge(PGOEdge *E LLVM_ATTRIBUTE_UNUSED) {}
 };
 
 // This class implements the CFG edges. Note the CFG can be a multi-graph.
 template <class Edge, class BBInfo> class FuncPGOInstrumentation {
 private:
   Function &F;
 
   // Is this is context-sensitive instrumentation.
for (auto &&CM : make_range(ComdatMembers.equal_range(OrigComdat))) {
     // Must be a function.
     Function *CF = dyn_cast<Function>(CM.second);
     assert(CF);
     CF->setComdat(NewComdat);
   }
 }
 
 // Collect all the BBs that will be instruments and return them in
-// InstrumentBBs.
+// InstrumentBBs and setup InEdges/OutEdge for UseBBInfo.
 template <class Edge, class BBInfo>
 void FuncPGOInstrumentation<Edge, BBInfo>::getInstrumentBBs(
     std::vector<BasicBlock *> &InstrumentBBs) {
   // Use a worklist as we will update the vector during the iteration.
   std::vector<Edge *> EdgeList;
   EdgeList.reserve(MST.AllEdges.size());
   for (auto &E : MST.AllEdges)
     EdgeList.push_back(E.get());
 
   for (auto &E : EdgeList) {
     BasicBlock *InstrBB = getInstrBB(E);
     if (InstrBB)
       InstrumentBBs.push_back(InstrBB);
   }
+
+  // Set up InEdges/OutEdges for all BBs.
+  for (auto &E : MST.AllEdges) {
+    if (E->Removed)
+      continue;
+    const BasicBlock *SrcBB = E->SrcBB;
+    const BasicBlock *DestBB = E->DestBB;
+    BBInfo &SrcInfo = getBBInfo(SrcBB);
+    BBInfo &DestInfo = getBBInfo(DestBB);
+    SrcInfo.addOutEdge(E.get());
+    DestInfo.addInEdge(E.get());
+  }
 }
 
 // Given a CFG E to be instrumented, find which BB to place the instrumented
 // code. The function will split the critical edge if necessary.
 template <class Edge, class BBInfo>
 BasicBlock *FuncPGOInstrumentation<Edge, BBInfo>::getInstrBB(Edge *E) {
   if (E->InMST || E->Removed)
     return nullptr;
 
   BasicBlock *SrcBB = const_cast<BasicBlock *>(E->SrcBB);
   BasicBlock *DestBB = const_cast<BasicBlock *>(E->DestBB);
   // For a fake edge, instrument the real BB.
   if (SrcBB == nullptr)
     return DestBB;
   if (DestBB == nullptr)
     return SrcBB;
 
+  auto canInstrument = [this](BasicBlock *BB) -> BasicBlock * {
+    // There are basic blocks (such as catchswitch) cannot be instrumented.
+    // If the returned first insertion point is the end of BB, skip this BB.
+    if (BB->getFirstInsertionPt() == BB->end()) {
+      LLVM_DEBUG(dbgs() << "Cannot instrument BB index=" << getBBInfo(BB).Index
+                        << "\n");
+      return nullptr;
+    }
+    return BB;
+  };
+
   // Instrument the SrcBB if it has a single successor,
   // otherwise, the DestBB if this is not a critical edge.
   Instruction *TI = SrcBB->getTerminator();
   if (TI->getNumSuccessors() <= 1)
-    return SrcBB;
+    return canInstrument(SrcBB);
   if (!E->IsCritical)
-    return DestBB;
+    return canInstrument(DestBB);
 
-  // For a critical edge, we have to split. Instrument the newly
-  // created BB.
-  IsCS ? NumOfCSPGOSplit++ : NumOfPGOSplit++;
-  LLVM_DEBUG(dbgs() << "Split critical edge: " << getBBInfo(SrcBB).Index
-                    << " --> " << getBBInfo(DestBB).Index << "\n");
   unsigned SuccNum = GetSuccessorNumber(SrcBB, DestBB);
   BasicBlock *InstrBB = SplitCriticalEdge(TI, SuccNum);
   if (!InstrBB) {
     LLVM_DEBUG(
         dbgs() << "Fail to split critical edge: not instrument this edge.\n");
     return nullptr;
   }
+  // For a critical edge, we have to split. Instrument the newly
+  // created BB.
+  IsCS ? NumOfCSPGOSplit++ : NumOfPGOSplit++;
+  LLVM_DEBUG(dbgs() << "Split critical edge: " << getBBInfo(SrcBB).Index
+                    << " --> " << getBBInfo(DestBB).Index << "\n");
   // Need to add two new edges. First one: Add new edge of SrcBB->InstrBB.
   MST.addEdge(SrcBB, InstrBB, 0);
   // Second one: Add new edge of InstrBB->DestBB.
   Edge &NewEdge1 = MST.addEdge(InstrBB, DestBB, 0);
   NewEdge1.InMST = true;
   E->Removed = true;
 
-  return InstrBB;
+  return canInstrument(InstrBB);
 }
 
 // Visit all edge and instrument the edges not in MST, and do value profiling.
 // Critical edges will be split.
 static void instrumentOneFunc(
     Function &F, Module *M, BranchProbabilityInfo *BPI, BlockFrequencyInfo *BFI,
     std::unordered_multimap<Comdat *, GlobalValue *> &ComdatMembers,
     bool IsCS) {
struct UseBBInfo : public BBInfo {
   }
 
   // Return the information string of this object.
   const std::string infoString() const {
     if (!CountValid)
       return BBInfo::infoString();
     return (Twine(BBInfo::infoString()) + "  Count=" + Twine(CountValue)).str();
   }
+
+  // Add an OutEdge and update the edge count.
+  void addOutEdge(PGOUseEdge *E) {
+    OutEdges.push_back(E);
+    UnknownCountOutEdge++;
+  }
+
+  // Add an InEdge and update the edge count.
+  void addInEdge(PGOUseEdge *E) {
+    InEdges.push_back(E);
+    UnknownCountInEdge++;
+  }
 };
 
 } // end anonymous namespace
 
 // Sum up the count values for all the edges.
 static uint64_t sumEdgeCount(const ArrayRef<PGOUseEdge *> Edges) {
   uint64_t Total = 0;
   for (auto &E : Edges) {
bool PGOUseFunc::setInstrumentedCounts(
   FuncInfo.getInstrumentBBs(InstrumentBBs);
   unsigned NumCounters =
       InstrumentBBs.size() + FuncInfo.SIVisitor.getNumOfSelectInsts();
   // The number of counters here should match the number of counters
   // in profile. Return if they mismatch.
   if (NumCounters != CountFromProfile.size()) {
     return false;
   }
+  // Set the profile count to the Instrumented BBs.
   uint32_t I = 0;
   for (BasicBlock *InstrBB : InstrumentBBs) {
     uint64_t CountValue = CountFromProfile[I++];
     UseBBInfo &Info = getBBInfo(InstrBB);
     Info.setBBInfoCount(CountValue);
-    // If only one in-edge, the edge profile count should be the same as BB
-    // profile count.
-    if (Info.InEdges.size() == 1) {
-      Info.InEdges[0]->setEdgeCount(CountValue);
-    }
+  ProfileCountSize = CountFromProfile.size();
+  CountPosition = I;
+
+  // Set the edge count and update the count of unknown edges for BBs.
+  auto setEdgeCount = [this](PGOUseEdge *E, uint64_t Value) -> void {
+    E->setEdgeCount(Value);
+    this->getBBInfo(E->SrcBB).UnknownCountOutEdge--;
+    this->getBBInfo(E->DestBB).UnknownCountInEdge--;
+  };
+
+  // Set the profile count the Instrumented edges. There are BBs that not in
+  // MST but not instrumented. Need to set the edge count value so that we can
+  // populate the profile counts later.
+  for (auto &E : FuncInfo.MST.AllEdges) {
+    if (E->Removed || E->InMST)
+      continue;
+    const BasicBlock *SrcBB = E->SrcBB;
+    UseBBInfo &SrcInfo = getBBInfo(SrcBB);
+
     // If only one out-edge, the edge profile count should be the same as BB
     // profile count.
-    if (Info.OutEdges.size() == 1) {
-      Info.OutEdges[0]->setEdgeCount(CountValue);
+    if (SrcInfo.CountValid && SrcInfo.OutEdges.size() == 1)
+      setEdgeCount(E.get(), SrcInfo.CountValue);
+    else {
+      const BasicBlock *DestBB = E->DestBB;
+      UseBBInfo &DestInfo = getBBInfo(DestBB);
+      // If only one in-edge, the edge profile count should be the same as BB
+      // profile count.
+      if (DestInfo.CountValid && DestInfo.InEdges.size() == 1)
+        setEdgeCount(E.get(), DestInfo.CountValue);
     }
+    if (E->CountValid)
+      continue;
+    // E's count should have been set from profile. If not, this meenas E skips
+    // the instrumentation. We set the count to 0.
+    setEdgeCount(E.get(), 0);
   }
-  ProfileCountSize = CountFromProfile.size();
-  CountPosition = I;
   return true;
 }
 
 // Set the count value for the unknown edge. There should be one and only one
 // unknown edge in Edges vector.
 void PGOUseFunc::setEdgeCount(DirectEdges &Edges, uint64_t Value) {
   for (auto &E : Edges) {
     if (E->CountValid)
bool PGOUseFunc::readCounters(IndexedInstrProfReader *PGOReader, bool &AllZeros) {
   }
   ProgramMaxCount = PGOReader->getMaximumFunctionCount(IsCS);
   return true;
 }
 
 // Populate the counters from instrumented BBs to all BBs.
 // In the end of this operation, all BBs should have a valid count value.
 void PGOUseFunc::populateCounters() {
-  // First set up Count variable for all BBs.
-  for (auto &E : FuncInfo.MST.AllEdges) {
-    if (E->Removed)
-      continue;
-
-    const BasicBlock *SrcBB = E->SrcBB;
-    const BasicBlock *DestBB = E->DestBB;
-    UseBBInfo &SrcInfo = getBBInfo(SrcBB);
-    UseBBInfo &DestInfo = getBBInfo(DestBB);
-    SrcInfo.OutEdges.push_back(E.get());
-    DestInfo.InEdges.push_back(E.get());
-    SrcInfo.UnknownCountOutEdge++;
-    DestInfo.UnknownCountInEdge++;
-
-    if (!E->CountValid)
-      continue;
-    DestInfo.UnknownCountInEdge--;
-    SrcInfo.UnknownCountOutEdge--;
-  }
-
   bool Changes = true;
   unsigned NumPasses = 0;
   while (Changes) {
     NumPasses++;
     Changes = false;
 
     // For efficient traversal, it's better to start from the end as most
     // of the instrumented edges are at the end.

llvm/test/Transforms/PGOProfile/Inputs/PR41279.proftext

+:ir
+foo
[phone]
+4
+3
+2
+3
+2
+

llvm/test/Transforms/PGOProfile/Inputs/PR41279_2.proftext

+:ir
+f
[phone]
+2
+3
+2
+

llvm/test/Transforms/PGOProfile/PR41279.ll

 ; Test that instrumentaiton works fine for the case of failing the split critical edges.
 ; RUN: opt < %s -pgo-instr-gen -S | FileCheck %s --check-prefix=GEN
 ; RUN: opt < %s -passes=pgo-instr-gen -S | FileCheck %s --check-prefix=GEN
+; RUN: llvm-profdata merge %S/Inputs/PR41279.proftext -o %t.profdata
+; RUN: opt < %s -pgo-instr-use -pgo-test-profile-file=%t.profdata -S | FileCheck %s --check-prefix=USE
+; RUN: opt < %s -passes=pgo-instr-use -pgo-test-profile-file=%t.profdata -S | FileCheck %s --check-prefix=USE
 
 declare void @f3({ i8*, i64 }*, { i8*, i64 }*, i64)
 declare { i8*, i64 } @f0({ i8*, i64 }*)
 declare i64 @f1()
 declare void @invok2({ i8*, i64 }*, i8* noalias readonly align 1, i64)
 declare void @invok1({ i8*, i64 }*, { i8*, i64 }*, i64)
 declare i32 @__CxxFrameHandler3(...)
 
-define internal void @foo({ i8*, i64 }*, { i8*, i64 }*) personality i32 (...)* @__CxxFrameHandler3 {
+define void @foo({ i8*, i64 }*, { i8*, i64 }*) personality i32 (...)* @__CxxFrameHandler3 {
+; USE-LABEL: @foo
+; USE-SAME: !prof ![[FUNC_ENTRY_COUNT:[0-9]+]]
+
   %3 = alloca i8, align 1
   store i8 0, i8* %3, align 1
   %4 = call i64 @f1()
   %5 = icmp ult i64 %4, 32
   br i1 %5, label %7, label %13
+; USE: br i1 %5, label %7, label %13
+; USE-SAME: !prof ![[BW_ENTRY1:[0-9]+]]
 
 6:
   cleanupret from %17 unwind to caller
 ; GEN: 6:
-; GEN:  call void @llvm.instrprof.increment(i8* getelementptr inbounds ([11 x i8], [11 x i8]* @__profn__stdin__foo, i32 0, i32 0), i64 60927483247, i32 4, i32 2)
+; GEN:  call void @llvm.instrprof.increment(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @__profn_foo, i32 0, i32 0), i64 60927483247, i32 4, i32 2)
 
 7:
   store i8 1, i8* %3, align 1
   %8 = call { i8*, i64 } @f0({ i8*, i64 }* %0)
   %9 = extractvalue { i8*, i64 } %8, 0
   %10 = extractvalue { i8*, i64 } %8, 1
   invoke void @invok1({ i8*, i64 }* %1, { i8*, i64 }* %0, i64 1)
           to label %11 unwind label %16
 ; GEN: 7:
 ; GEN-NOT: call void @llvm.instrprof.increment
 
 11:
   store i8 0, i8* %3, align 1
   invoke void @invok2({ i8*, i64 }* %1, i8* noalias readonly align 1 %9, i64 %10)
           to label %12 unwind label %16
 ; GEN: 11:
 ; GEN-NOT: call void @llvm.instrprof.increment
 
 12:
   store i8 0, i8* %3, align 1
   br label %14
 ; GEN: 12:
-; GEN:  call void @llvm.instrprof.increment(i8* getelementptr inbounds ([11 x i8], [11 x i8]* @__profn__stdin__foo, i32 0, i32 0), i64 60927483247, i32 4, i32 1)
+; GEN:  call void @llvm.instrprof.increment(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @__profn_foo, i32 0, i32 0), i64 60927483247, i32 4, i32 1)
 
 13:
   call void @f3({ i8*, i64 }* %0, { i8*, i64 }* %1, i64 1)
   br label %14
 ; GEN: 13:
-; GEN:  call void @llvm.instrprof.increment(i8* getelementptr inbounds ([11 x i8], [11 x i8]* @__profn__stdin__foo, i32 0, i32 0), i64 60927483247, i32 4, i32 0)
+; GEN:  call void @llvm.instrprof.increment(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @__profn_foo, i32 0, i32 0), i64 60927483247, i32 4, i32 0)
 
 14:
   ret void
 
 15:
   store i8 0, i8* %3, align 1
   br label %6
 ; GEN: 15:
-; GEN:  call void @llvm.instrprof.increment(i8* getelementptr inbounds ([11 x i8], [11 x i8]* @__profn__stdin__foo, i32 0, i32 0), i64 60927483247, i32 4, i32 3)
+; GEN:  call void @llvm.instrprof.increment(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @__profn_foo, i32 0, i32 0), i64 60927483247, i32 4, i32 3)
 
 16:
   %17 = cleanuppad within none []
   %18 = load i8, i8* %3, align 1
   %19 = trunc i8 %18 to i1
   br i1 %19, label %15, label %6
+; USE: br i1 %19, label %15, label %6
+; USE-SAME: !prof ![[BW_ENTRY2:[0-9]+]]
 }
+
+; USE-DAG: {{![0-9]+}} = !{i32 1, !"ProfileSummary", {{![0-9]+}}}
+; USE-DAG: {{![0-9]+}} = !{!"DetailedSummary", {{![0-9]+}}}
+; USE-DAG: ![[FUNC_ENTRY_COUNT]] = !{!"function_entry_count", i64 8}
+; USE_DAG: ![[BW_ENTRY1]] = !{!"branch_weights", i32 5, i32 3}
+; USE_DAG: ![[BW_ENTRY2]] = !{!"branch_weights", i32 2, i32 1}
+

llvm/test/Transforms/PGOProfile/PR41279_2.ll

+; Test that instrumentaiton works fine for the case of catchswitch stmts.
+; RUN: opt < %s -pgo-instr-gen -S | FileCheck %s --check-prefix=GEN
+; RUN: opt < %s -passes=pgo-instr-gen -S | FileCheck %s --check-prefix=GEN
+; RUN: llvm-profdata merge %S/Inputs/PR41279_2.proftext -o %t.profdata
+; RUN: opt < %s -pgo-instr-use -pgo-test-profile-file=%t.profdata -S | FileCheck %s --check-prefix=USE
+; RUN: opt < %s -passes=pgo-instr-use -pgo-test-profile-file=%t.profdata -S | FileCheck %s --check-prefix=USE
+
+
+define dso_local void @f() personality i8* bitcast (i32 (...)* @__C_specific_handler to i8*) {
+; USE-LABEL: @f
+; USE-SAME: !prof ![[FUNC_ENTRY_COUNT:[0-9]+]]
+; USE-DAG: {{![0-9]+}} = !{i32 1, !"ProfileSummary", {{![0-9]+}}}
+; USE-DAG: {{![0-9]+}} = !{!"DetailedSummary", {{![0-9]+}}}
+; USE-DAG: ![[FUNC_ENTRY_COUNT]] = !{!"function_entry_count", i64 5}
+entry:
+  %__exception_code = alloca i32, align 4
+  %__exception_code2 = alloca i32, align 4
+  invoke void @f() #2
+          to label %invoke.cont unwind label %catch.dispatch
+
+catch.dispatch:
+  %0 = catchswitch within none [label %__except] unwind to caller
+
+__except:
+  %1 = catchpad within %0 [i8* null]
+  catchret from %1 to label %__except1
+
+__except1:
+  %2 = call i32 @llvm.eh.exceptioncode(token %1)
+  store i32 %2, i32* %__exception_code, align 4
+  br label %__try.cont7
+;GEN:  _except1:
+;GEN:    call void @llvm.instrprof.increment(i8* getelementptr inbounds ([1 x i8], [1 x i8]* @__profn_f, i32 0, i32 0), i64 62077759478, i32 2, i32 1)
+
+invoke.cont:
+  br label %__try.cont
+
+__try.cont:
+  invoke void @f()
+          to label %invoke.cont3 unwind label %catch.dispatch4
+
+catch.dispatch4:
+  %3 = catchswitch within none [label %__except5] unwind to caller
+; GEN: catch.dispatch4:
+; GEN-NOT: call void @llvm.instrprof.increment
+
+__except5:
+  %4 = catchpad within %3 [i8* null]
+  catchret from %4 to label %__except6
+
+__except6:
+  %5 = call i32 @llvm.eh.exceptioncode(token %4)
+  store i32 %5, i32* %__exception_code2, align 4
+  br label %__try.cont7
+
+__try.cont7:
+  ret void
+
+invoke.cont3:
+  br label %__try.cont7
+;GEN: invoke.cont3:
+;GEN:  call void @llvm.instrprof.increment(i8* getelementptr inbounds ([1 x i8], [1 x i8]* @__profn_f, i32 0, i32 0), i64 62077759478, i32 2, i32 0)
+
+}
+
+declare dso_local i32 @__C_specific_handler(...)
+
+declare i32 @llvm.eh.exceptioncode(token)