[WebAssembly] Split BBs after throw instructions

[aheejin]

Summary

throw instruction is a terminator in wasm, but BBs were not splitted
after throw instructions, causing machine instruction verifier to
fail.

This patch

• Splits BBs after throw instructions in WasmEHPrepare and adding an unreachable instruction after throw, which will be deleted in LateEHPrepare pass
• Refactors WasmEHPrepare into two member functions
• Changes the semantics of eraseBBsAndChildren in LateEHPrepare pass to match that of WasmEHPrepare pass, which is newly added. Now eraseBBsAndChildren does not delete BBs with remaining predecessors.
• Fixes style nits, making static function names conform to clang-tidy
• Re-enables the test temporarily disabled by rL346840 && rL346845

[aheejin]

lib/CodeGen/WasmEHPrepare.cpp

236 ↗

(On Diff #174166)

This part is just factored out and has not changed.

lib/Target/WebAssembly/WebAssemblyLateEHPrepare.cpp

90 ↗

(On Diff #174166)

This now does not delete children with remaining predecessors because the purpose of this function was delete dead children. Predecessors of blocks in MBBs are removed before calling this function.

280 ↗

(On Diff #174166)

Now eraseBBsAndChildren does not delete children with remaining successors, so we remote the successor relationship here before calling the function

test/MC/WebAssembly/event-section.ll

3 ↗

(On Diff #174166)

-verify-machineinstrs is added to test/CodeGen/exception.ll instead.

[xbolva00]

Sorry for little offtopic at first.

WebAssembly folks, can you check this warning:

WebAssemblyDisassembler.cpp:125:11: warning: comparison is always false due to limited range of data type [-Wtype-limits]

if (Opc < 0)

GCC 8.2

[sbc100]

In D54571#1299575, @xbolva00 wrote:

Sorry for little offtopic at first.

WebAssembly folks, can you check this warning:

WebAssemblyDisassembler.cpp:125:11: warning: comparison is always false due to limited range of data type [-Wtype-limits]

if (Opc < 0)

GCC 8.2

Hmm, looks like that broke in https://reviews.llvm.org/D54138. @tlively ?

[tlively]

In D54571#1300167, @sbc100 wrote:

In D54571#1299575, @xbolva00 wrote:

Sorry for little offtopic at first.

WebAssembly folks, can you check this warning:

WebAssemblyDisassembler.cpp:125:11: warning: comparison is always false due to limited range of data type [-Wtype-limits]

if (Opc < 0)

GCC 8.2

Hmm, looks like that broke in https://reviews.llvm.org/D54138. @tlively ?

This should be fixed in rL346979.

[dschuff]

Otherwise LGTM

lib/Target/WebAssembly/WebAssemblyLateEHPrepare.cpp

90 ↗

(On Diff #174166)

The name and description for this function is now the same as eraseBBsAndChildren above but the implementation is different. The code looks like it does the same thing, any reason it can't be identical?

[aheejin]

lib/Target/WebAssembly/WebAssemblyLateEHPrepare.cpp

90 ↗

(On Diff #174166)

One is for LLVM IR (BasicBlock and Instruction) and the other is for the backend IR (MachineFunction and MachineInstr). And for the LLVM IR version I used DeleteDeadBlock utility method. (I don't think there's a similar utility method for the backend IR)

[dschuff]

lib/Target/WebAssembly/WebAssemblyLateEHPrepare.cpp

90 ↗

(On Diff #174166)

oh haha i totally missed that. Guess that means we have good abstractions or something ¯\_(ツ)_/¯

[aheejin]

• eraseBBsAndChildren -> eraseDeadBBsAndChildren to be clear

llvm/trunk/lib/CodeGen/WasmEHPrepare.cpp

class WasmEHPrepare : public FunctionPass {
   Type *LPadContextTy = nullptr; // type of 'struct _Unwind_LandingPadContext'
   GlobalVariable *LPadContextGV = nullptr; // __wasm_lpad_context
 
   // Field addresses of struct _Unwind_LandingPadContext
   Value *LPadIndexField = nullptr; // lpad_index field
   Value *LSDAField = nullptr;      // lsda field
   Value *SelectorField = nullptr;  // selector
 
+  Function *ThrowF = nullptr;           // wasm.throw() intrinsic
   Function *CatchF = nullptr;           // wasm.catch.extract() intrinsic
   Function *LPadIndexF = nullptr;       // wasm.landingpad.index() intrinsic
   Function *LSDAF = nullptr;            // wasm.lsda() intrinsic
   Function *GetExnF = nullptr;          // wasm.get.exception() intrinsic
   Function *GetSelectorF = nullptr;     // wasm.get.ehselector() intrinsic
   Function *CallPersonalityF = nullptr; // _Unwind_CallPersonality() wrapper
   Function *ClangCallTermF = nullptr;   // __clang_call_terminate() function
 
+  bool prepareEHPads(Function &F);
+  bool prepareThrows(Function &F);
+
   void prepareEHPad(BasicBlock *BB, unsigned Index);
   void prepareTerminateCleanupPad(BasicBlock *BB);
 
 public:
   static char ID; // Pass identification, replacement for typeid
 
   WasmEHPrepare() : FunctionPass(ID) {}
 
bool WasmEHPrepare::doInitialization(Module &M) {
   IRBuilder<> IRB(M.getContext());
   LPadContextTy = StructType::get(IRB.getInt32Ty(),   // lpad_index
                                   IRB.getInt8PtrTy(), // lsda
                                   IRB.getInt32Ty()    // selector
   );
   return false;
 }
 
+// Erase the specified BBs if the BB does not have any remaining predecessors,
+// and also all its dead children.
+template <typename Container>
+static void eraseDeadBBsAndChildren(const Container &BBs) {
+  SmallVector<BasicBlock *, 8> WL(BBs.begin(), BBs.end());
+  while (!WL.empty()) {
+    auto *BB = WL.pop_back_val();
+    if (pred_begin(BB) != pred_end(BB))
+      continue;
+    WL.append(succ_begin(BB), succ_end(BB));
+    DeleteDeadBlock(BB);
+  }
+}
+
 bool WasmEHPrepare::runOnFunction(Function &F) {
+  bool Changed = false;
+  Changed |= prepareThrows(F);
+  Changed |= prepareEHPads(F);
+  return Changed;
+}
+
+bool WasmEHPrepare::prepareThrows(Function &F) {
+  Module &M = *F.getParent();
+  IRBuilder<> IRB(F.getContext());
+  bool Changed = false;
+
+  // wasm.throw() intinsic, which will be lowered to wasm 'throw' instruction.
+  ThrowF = Intrinsic::getDeclaration(&M, Intrinsic::wasm_throw);
+
+  // Insert an unreachable instruction after a call to @llvm.wasm.throw and
+  // delete all following instructions within the BB, and delete all the dead
+  // children of the BB as well.
+  for (User *U : ThrowF->users()) {
+    // A call to @llvm.wasm.throw() is only generated from
+    // __builtin_wasm_throw() builtin call within libcxxabi, and cannot be an
+    // InvokeInst.
+    auto *ThrowI = cast<CallInst>(U);
+    if (ThrowI->getFunction() != &F)
+      continue;
+    Changed = true;
+    auto *BB = ThrowI->getParent();
+    SmallVector<BasicBlock *, 4> Succs(succ_begin(BB), succ_end(BB));
+    auto &InstList = BB->getInstList();
+    InstList.erase(std::next(BasicBlock::iterator(ThrowI)), InstList.end());
+    IRB.SetInsertPoint(BB);
+    IRB.CreateUnreachable();
+    eraseDeadBBsAndChildren(Succs);
+  }
+
+  return Changed;
+}
+
+bool WasmEHPrepare::prepareEHPads(Function &F) {
+  Module &M = *F.getParent();
+  IRBuilder<> IRB(F.getContext());
+
   SmallVector<BasicBlock *, 16> CatchPads;
   SmallVector<BasicBlock *, 16> CleanupPads;
   for (BasicBlock &BB : F) {
     if (!BB.isEHPad())
       continue;
     auto *Pad = BB.getFirstNonPHI();
     if (isa<CatchPadInst>(Pad))
       CatchPads.push_back(&BB);
     else if (isa<CleanupPadInst>(Pad))
       CleanupPads.push_back(&BB);
   }
 
   if (CatchPads.empty() && CleanupPads.empty())
     return false;
   assert(F.hasPersonalityFn() && "Personality function not found");
 
-  Module &M = *F.getParent();
-  IRBuilder<> IRB(F.getContext());
-
   // __wasm_lpad_context global variable
   LPadContextGV = cast<GlobalVariable>(
       M.getOrInsertGlobal("__wasm_lpad_context", LPadContextTy));
   LPadIndexField = IRB.CreateConstGEP2_32(LPadContextTy, LPadContextGV, 0, 0,
                                           "lpad_index_gep");
   LSDAField =
       IRB.CreateConstGEP2_32(LPadContextTy, LPadContextGV, 0, 1, "lsda_gep");
   SelectorField = IRB.CreateConstGEP2_32(LPadContextTy, LPadContextGV, 0, 2,

llvm/trunk/lib/Target/WebAssembly/WebAssemblyLateEHPrepare.cpp

 namespace {
 class WebAssemblyLateEHPrepare final : public MachineFunctionPass {
   StringRef getPassName() const override {
     return "WebAssembly Prepare Exception";
   }
 
   bool runOnMachineFunction(MachineFunction &MF) override;
 
+  bool removeUnnecessaryUnreachables(MachineFunction &MF);
   bool replaceFuncletReturns(MachineFunction &MF);
   bool hoistCatches(MachineFunction &MF);
   bool addCatchAlls(MachineFunction &MF);
   bool addRethrows(MachineFunction &MF);
   bool ensureSingleBBTermPads(MachineFunction &MF);
   bool mergeTerminatePads(MachineFunction &MF);
   bool addCatchAllTerminatePads(MachineFunction &MF);
 

 }
 
 // Returns the nearest EH pad that dominates this instruction. This does not use
 // dominator analysis; it just does BFS on its predecessors until arriving at an
 // EH pad. This assumes valid EH scopes so the first EH pad it arrives in all
 // possible search paths should be the same.
 // Returns nullptr in case it does not find any EH pad in the search, or finds
 // multiple different EH pads.
-static MachineBasicBlock *GetMatchingEHPad(MachineInstr *MI) {
+static MachineBasicBlock *getMatchingEHPad(MachineInstr *MI) {
   MachineFunction *MF = MI->getParent()->getParent();
   SmallVector<MachineBasicBlock *, 2> WL;
   SmallPtrSet<MachineBasicBlock *, 2> Visited;
   WL.push_back(MI->getParent());
   MachineBasicBlock *EHPad = nullptr;
   while (!WL.empty()) {
     MachineBasicBlock *MBB = WL.pop_back_val();
     if (Visited.count(MBB))
       continue;
     Visited.insert(MBB);
     if (MBB->isEHPad()) {
       if (EHPad && EHPad != MBB)
         return nullptr;
       EHPad = MBB;
       continue;
     }
     if (MBB == &MF->front())
       return nullptr;
     WL.append(MBB->pred_begin(), MBB->pred_end());
   }
   return EHPad;
 }
 
-// Erases the given BBs and all their children from the function. If other BBs
-// have the BB as a successor, the successor relationships will be deleted as
-// well.
+// Erase the specified BBs if the BB does not have any remaining predecessors,
+// and also all its dead children.
 template <typename Container>
-static void EraseBBsAndChildren(const Container &MBBs) {
+static void eraseDeadBBsAndChildren(const Container &MBBs) {
   SmallVector<MachineBasicBlock *, 8> WL(MBBs.begin(), MBBs.end());
   while (!WL.empty()) {
     MachineBasicBlock *MBB = WL.pop_back_val();
-    SmallVector<MachineBasicBlock *, 4> Preds(MBB->pred_begin(),
-                                              MBB->pred_end());
-    for (auto *Pred : Preds)
-      Pred->removeSuccessor(MBB);
+    if (!MBB->pred_empty())
+      continue;
     SmallVector<MachineBasicBlock *, 4> Succs(MBB->succ_begin(),
                                               MBB->succ_end());
     WL.append(MBB->succ_begin(), MBB->succ_end());
     for (auto *Succ : Succs)
       MBB->removeSuccessor(Succ);
     MBB->eraseFromParent();
   }
 }
 
 bool WebAssemblyLateEHPrepare::runOnMachineFunction(MachineFunction &MF) {
   if (MF.getTarget().getMCAsmInfo()->getExceptionHandlingType() !=
       ExceptionHandling::Wasm)
     return false;
 
   bool Changed = false;
+  Changed |= removeUnnecessaryUnreachables(MF);
   Changed |= addRethrows(MF);
   if (!MF.getFunction().hasPersonalityFn())
     return Changed;
   Changed |= replaceFuncletReturns(MF);
   Changed |= hoistCatches(MF);
   Changed |= addCatchAlls(MF);
   Changed |= ensureSingleBBTermPads(MF);
   Changed |= mergeTerminatePads(MF);
   Changed |= addCatchAllTerminatePads(MF);
   return Changed;
 }
 
+bool WebAssemblyLateEHPrepare::removeUnnecessaryUnreachables(
+    MachineFunction &MF) {
+  bool Changed = false;
+  for (auto &MBB : MF) {
+    for (auto &MI : MBB) {
+      if (!WebAssembly::isThrow(MI))
+        continue;
+      Changed = true;
+
+      // The instruction after the throw should be an unreachable or a branch to
+      // another BB that should eventually lead to an unreachable. Delete it
+      // because throw itself is a terminator, and also delete successors if
+      // any.
+      MBB.erase(std::next(MachineBasicBlock::iterator(MI)), MBB.end());
+      SmallVector<MachineBasicBlock *, 8> Succs(MBB.succ_begin(),
+                                                MBB.succ_end());
+      for (auto *Succ : Succs)
+        MBB.removeSuccessor(Succ);
+      eraseDeadBBsAndChildren(Succs);
+    }
+  }
+
+  return Changed;
+}
+
 bool WebAssemblyLateEHPrepare::replaceFuncletReturns(MachineFunction &MF) {
   bool Changed = false;
   const auto &TII = *MF.getSubtarget<WebAssemblySubtarget>().getInstrInfo();
   auto *EHInfo = MF.getWasmEHFuncInfo();
 
   for (auto &MBB : MF) {
     auto Pos = MBB.getFirstTerminator();
     if (Pos == MBB.end())
bool WebAssemblyLateEHPrepare::hoistCatches(MachineFunction &MF) {
   bool Changed = false;
   SmallVector<MachineInstr *, 16> Catches;
   for (auto &MBB : MF)
     for (auto &MI : MBB)
       if (WebAssembly::isCatch(MI))
         Catches.push_back(&MI);
 
   for (auto *Catch : Catches) {
-    MachineBasicBlock *EHPad = GetMatchingEHPad(Catch);
+    MachineBasicBlock *EHPad = getMatchingEHPad(Catch);
     assert(EHPad && "No matching EH pad for catch");
     if (EHPad->begin() == Catch)
       continue;
     Changed = true;
     EHPad->insert(EHPad->begin(), Catch->removeFromParent());
   }
   return Changed;
 }
for (auto &MI : MBB) {
       if (EHInfo->hasThrowUnwindDest(&MBB))
         Rethrow = BuildMI(MBB, InsertPt, MI.getDebugLoc(),
                           TII.get(WebAssembly::RETHROW))
                       .addMBB(EHInfo->getThrowUnwindDest(&MBB));
       else
         Rethrow = BuildMI(MBB, InsertPt, MI.getDebugLoc(),
                           TII.get(WebAssembly::RETHROW_TO_CALLER));
 
-      // Becasue __cxa_rethrow does not return, the instruction after the
+      // Because __cxa_rethrow does not return, the instruction after the
       // rethrow should be an unreachable or a branch to another BB that should
       // eventually lead to an unreachable. Delete it because rethrow itself is
       // a terminator, and also delete non-EH pad successors if any.
       MBB.erase(std::next(MachineBasicBlock::iterator(Rethrow)), MBB.end());
       SmallVector<MachineBasicBlock *, 8> NonPadSuccessors;
       for (auto *Succ : MBB.successors())
         if (!Succ->isEHPad())
           NonPadSuccessors.push_back(Succ);
-      EraseBBsAndChildren(NonPadSuccessors);
+      for (auto *Succ : NonPadSuccessors)
+        MBB.removeSuccessor(Succ);
+      eraseDeadBBsAndChildren(NonPadSuccessors);
     }
   return Changed;
 }
 
 // Terminate pads are an single-BB EH pad in the form of
 // termpad:
 //   %exn = catch 0
 //   call @__clang_call_terminate(%exn)
for (auto &MI : MBB)
         const MachineOperand &CalleeOp = MI.getOperand(0);
         if (CalleeOp.isGlobal() && CalleeOp.getGlobal()->getName() ==
                                        WebAssembly::ClangCallTerminateFn)
           ClangCallTerminateCalls.push_back(&MI);
       }
 
   bool Changed = false;
   for (auto *Call : ClangCallTerminateCalls) {
-    MachineBasicBlock *EHPad = GetMatchingEHPad(Call);
+    MachineBasicBlock *EHPad = getMatchingEHPad(Call);
     assert(EHPad && "No matching EH pad for catch");
 
     // If it is already the form we want, skip it
     if (Call->getParent() == EHPad &&
         Call->getNextNode()->getOpcode() == WebAssembly::UNREACHABLE)
       continue;
 
     // In case the __clang_call_terminate() call is not in its matching EH pad,
     // move the call to the end of EH pad and add an unreachable instruction
     // after that. Delete all successors and their children if any, because here
     // the program terminates.
     Changed = true;
     MachineInstr *Catch = &*EHPad->begin();
     // This runs after hoistCatches(), so catch instruction should be at the top
     assert(WebAssembly::isCatch(*Catch));
     // Takes the result register of the catch instruction as argument. There may
     // have been some other set_local/get_locals in between, but at this point
     // we don't care.
     Call->getOperand(1).setReg(Catch->getOperand(0).getReg());
     auto InsertPos = std::next(MachineBasicBlock::iterator(Catch));
     EHPad->insert(InsertPos, Call->removeFromParent());
     BuildMI(*EHPad, InsertPos, Call->getDebugLoc(),
             TII.get(WebAssembly::UNREACHABLE));
     EHPad->erase(InsertPos, EHPad->end());
-    EraseBBsAndChildren(EHPad->successors());
+    SmallVector<MachineBasicBlock *, 8> Succs(EHPad->succ_begin(),
+                                              EHPad->succ_end());
+    for (auto *Succ : Succs)
+      EHPad->removeSuccessor(Succ);
+    eraseDeadBBsAndChildren(Succs);
   }
   return Changed;
 }
 
 // In case there are multiple terminate pads, merge them into one for code size.
 // This runs after ensureSingleBBTermPads() and assumes every terminate pad is a
 // single BB.
 // In principle this violates EH scope relationship because it can merge

llvm/trunk/test/CodeGen/WebAssembly/exception.ll

 ; RUN: not llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt -wasm-keep-registers -exception-model=wasm
-; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt -wasm-keep-registers -exception-model=wasm -mattr=+exception-handling | FileCheck -allow-deprecated-dag-overlap %s
+; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt -wasm-keep-registers -exception-model=wasm -mattr=+exception-handling -verify-machineinstrs | FileCheck -allow-deprecated-dag-overlap %s
 ; RUN: llc < %s -disable-wasm-fallthrough-return-opt -wasm-keep-registers -exception-model=wasm -mattr=+exception-handling
 
 target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
 target triple = "wasm32-unknown-unknown"
 
 %struct.Cleanup = type { i8 }
 
 @_ZTIi = external constant i8*
 
 declare void @llvm.wasm.throw(i32, i8*)
 
 ; CHECK-LABEL: test_throw:
-; CHECK-NEXT: i32.const $push0=, 0
+; CHECK:      get_local $push0=, 0
 ; CHECK-NEXT: throw __cpp_exception@EVENT, $pop0
-define void @test_throw() {
-  call void @llvm.wasm.throw(i32 0, i8* null)
+; CHECK-NOT:  unreachable
+define void @test_throw(i8* %p) {
+  call void @llvm.wasm.throw(i32 0, i8* %p)
   ret void
 }
 
 ; CHECK-LABEL: test_catch_rethrow:
 ; CHECK:   get_global  $push{{.+}}=, __stack_pointer@GLOBAL
 ; CHECK:   try
 ; CHECK:   call      foo@FUNCTION
 ; CHECK:   i32.catch     $push{{.+}}=, 0

llvm/trunk/test/CodeGen/WebAssembly/wasmehprepare.ll

catch.start6:                                     ; preds = %catch.dispatch5
   call void @func(i32 %num.1) [ "funclet"(token %7) ]
   call void @__cxa_end_catch() [ "funclet"(token %7) ]
   catchret from %7 to label %try.cont10
 
 try.cont10:                                       ; preds = %invoke.cont3, %catch.start6
   ret void
 }
 
+; Tests if instructions after a call to @llvm.wasm.throw are deleted and the
+; BB's dead children are deleted.
+
+; CHECK-LABEL: @test6
+define i32 @test6(i1 %b, i8* %p) {
+entry:
+  br i1 %b, label %bb.true, label %bb.false
+
+; CHECK:      bb.true:
+; CHECK-NEXT:   call void @llvm.wasm.throw(i32 0, i8* %p)
+; CHECK-NEXT:   unreachable
+bb.true:                                          ; preds = %entry
+  call void @llvm.wasm.throw(i32 0, i8* %p)
+  br label %bb.true.0
+
+; CHECK-NOT:  bb.true.0
+bb.true.0:                                        ; preds = %bb.true
+  br label %merge
+
+; CHECK:      bb.false
+bb.false:                                         ; preds = %entry
+  br label %merge
+
+; CHECK:      merge
+merge:                                            ; preds = %bb.true.0, %bb.false
+  ret i32 0
+}
+
 declare void @foo()
 declare void @func(i32)
 declare %struct.Cleanup* @_ZN7CleanupD1Ev(%struct.Cleanup* returned)
 declare i32 @__gxx_wasm_personality_v0(...)
 declare i8* @llvm.wasm.get.exception(token)
 declare i32 @llvm.wasm.get.ehselector(token)
 declare i32 @llvm.eh.typeid.for(i8*)
+declare void @llvm.wasm.throw(i32, i8*)
 declare i8* @__cxa_begin_catch(i8*)
 declare void @__cxa_end_catch()
 declare void @__cxa_rethrow()
 declare void @__clang_call_terminate(i8*)
 
 ; CHECK-DAG: declare i8* @llvm.wasm.catch(i32)
 ; CHECK-DAG: declare void @llvm.wasm.landingpad.index(token, i32)
 ; CHECK-DAG: declare i8* @llvm.wasm.lsda()
 ; CHECK-DAG: declare i32 @_Unwind_CallPersonality(i8*)
-

llvm/trunk/test/MC/WebAssembly/event-section.ll

-; XFAIL: *
-; RUN: llc -filetype=obj -exception-model=wasm -mattr=+exception-handling -verify-machineinstrs %s -o - | obj2yaml | FileCheck %s
-; RUN: llc -filetype=obj -exception-model=wasm -mattr=+exception-handling -verify-machineinstrs %s -o - | llvm-readobj -s | FileCheck -check-prefix=SEC %s
+; RUN: llc -filetype=obj -exception-model=wasm -mattr=+exception-handling %s -o - | obj2yaml | FileCheck %s
+; RUN: llc -filetype=obj -exception-model=wasm -mattr=+exception-handling %s -o - | llvm-readobj -s | FileCheck -check-prefix=SEC %s
 
 target triple = "wasm32-unknown-unknown"
 
 declare void @llvm.wasm.throw(i32, i8*)
 
 define i32 @test_throw0(i8* %p) {
   call void @llvm.wasm.throw(i32 0, i8* %p)
   ret i32 0

 
 ; CHECK-NEXT:   - Type:            CODE
 ; CHECK-NEXT:     Relocations:
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_EVENT_INDEX_LEB
 ; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x00000006
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_EVENT_INDEX_LEB
 ; CHECK-NEXT:         Index:           1
-; CHECK-NEXT:         Offset:          0x00000013
+; CHECK-NEXT:         Offset:          0x00000011
 
 ; CHECK:        - Type:            CUSTOM
 ; CHECK-NEXT:     Name:            linking
 ; CHECK-NEXT:     Version:         1
 ; CHECK-NEXT:     SymbolTable:
 
 ; CHECK:            - Index:           1
 ; CHECK-NEXT:         Kind:            EVENT
 ; CHECK-NEXT:         Name:            __cpp_exception
 ; CHECK-NEXT:         Flags:           [ BINDING_WEAK ]
 ; CHECK-NEXT:         Event:           0
 
 ; SEC:          Type: EVENT (0xC)
 ; SEC-NEXT:     Size: 3
 ; SEC-NEXT:     Offset: 97