[WebAssembly] Fix WasmEHInfo updating in LateEHPrepare

[aheejin]

Summary

When adding a 'br_on_exn' instruction, we transform code as follows:

• Before:

ehpad:

%exnref:except_ref = catch
%exn:i32 = extract_exception
...
call @foo()  // can throw

• After:

ehpad:

%exnref:except_ref = catch
br_on_exn %thenbb, $__cpp_exception, %exnref
br %elsebb

elsebb:

rethrow

thenbb:

%exn:i32 = extract_exception
...
call @foo()  // can throw

So if an ehpad ends with an instruction that can throw, there is a
ThrowUnwindDest mapping of <ehpad, otherbb>, which means if an
instruction in 'ehpad' throws it should go to 'otherbb'. In that case,
we should've updated it to <thenbb, otherbb>. This fixes the bug, and
also adds member functions to erase mappings in WasmEHFuncInfo.

It's hard to add a test for this because target-specific
MachineFunctionInfo is not serialized at the moment.

[aheejin]

I think we don't need the map of <throwbb, ehpad> after all now each bb can have at most one EH pad successor. This was not true in the first proposal implementation, but is in the new proposal.

include/llvm/CodeGen/WasmEHFuncInfo.h

void setThrowUnwindDest(const BasicBlock *BB, const BasicBlock *Dest) {
     ThrowUnwindMap[BB] = Dest;
   }
   bool hasEHPadUnwindDest(const BasicBlock *BB) const {
     return EHPadUnwindMap.count(BB);
   }
   bool hasThrowUnwindDest(const BasicBlock *BB) const {
     return ThrowUnwindMap.count(BB);
   }
+  void eraseEHPadUnwindDest(const BasicBlock *BB) {
+    EHPadUnwindMap.erase(BB);
+  }
+  void eraseThrowUnwindDest(const BasicBlock *BB) {
+    ThrowUnwindMap.erase(BB);
+  }
 
   MachineBasicBlock *getEHPadUnwindDest(MachineBasicBlock *MBB) const {
     return EHPadUnwindMap.lookup(MBB).get<MachineBasicBlock *>();
   }
   void setEHPadUnwindDest(MachineBasicBlock *MBB, MachineBasicBlock *Dest) {
     EHPadUnwindMap[MBB] = Dest;
   }
   MachineBasicBlock *getThrowUnwindDest(MachineBasicBlock *MBB) const {
     return ThrowUnwindMap.lookup(MBB).get<MachineBasicBlock *>();
   }
   void setThrowUnwindDest(MachineBasicBlock *MBB, MachineBasicBlock *Dest) {
     ThrowUnwindMap[MBB] = Dest;
   }
   bool hasEHPadUnwindDest(MachineBasicBlock *MBB) const {
     return EHPadUnwindMap.count(MBB);
   }
   bool hasThrowUnwindDest(MachineBasicBlock *MBB) const {
     return ThrowUnwindMap.count(MBB);
   }
+  void eraseEHPadUnwindDest(MachineBasicBlock *MBB) {
+    EHPadUnwindMap.erase(MBB);
+  }
+  void eraseThrowUnwindDest(MachineBasicBlock *MBB) {
+    ThrowUnwindMap.erase(MBB);
+  }
 };
 
 // Analyze the IR in the given function to build WasmEHFuncInfo.
 void calculateWasmEHInfo(const Function *F, WasmEHFuncInfo &EHInfo);
 
 } // namespace llvm
 
 #endif // LLVM_CODEGEN_WASMEHFUNCINFO_H

lib/Target/WebAssembly/WebAssemblyLateEHPrepare.cpp

for (auto *Extract : ExtractInstrs) {
     DebugLoc DL = Extract->getDebugLoc();
     const char *CPPExnSymbol = MF.createExternalSymbolName("__cpp_exception");
     BuildMI(EHPad, DL, TII.get(WebAssembly::BR_ON_EXN))
         .addMBB(ThenMBB)
         .addExternalSymbol(CPPExnSymbol, WebAssemblyII::MO_SYMBOL_EVENT)
         .addReg(ExnRefReg);
     BuildMI(EHPad, DL, TII.get(WebAssembly::BR)).addMBB(ElseMBB);
 
+    if (EHInfo->hasThrowUnwindDest(EHPad)) {
+      EHInfo->setThrowUnwindDest(ThenMBB, EHInfo->getThrowUnwindDest(EHPad));
+      EHInfo->eraseThrowUnwindDest(EHPad);
+    }
+
     // When this is a terminate pad with __clang_call_terminate() call, we don't
     // rethrow it anymore and call __clang_call_terminate() with a nullptr
     // argument, which will call std::terminate().
     //
     // - Before:
     // ehpad:
     //   %exnref:except_ref = catch
     //   %exn:i32 = extract_exception
if (TerminatePads.count(EHPad)) {
              "There is no __clang_call_terminate() function");
       BuildMI(ElseMBB, DL, TII.get(WebAssembly::CALL_VOID))
           .addGlobalAddress(ClangCallTerminateFn)
           .addImm(0);
       BuildMI(ElseMBB, DL, TII.get(WebAssembly::UNREACHABLE));
 
     } else {
       BuildMI(ElseMBB, DL, TII.get(WebAssembly::RETHROW));
-      if (EHInfo->hasEHPadUnwindDest(EHPad))
-        EHInfo->setThrowUnwindDest(ElseMBB, EHInfo->getEHPadUnwindDest(EHPad));
+      if (EHInfo->hasEHPadUnwindDest(EHPad)) {
+        auto *DestMBB = EHInfo->getEHPadUnwindDest(EHPad);
+        EHInfo->setThrowUnwindDest(ElseMBB, DestMBB);
+        ElseMBB->addSuccessor(DestMBB);
+      }
     }
   }
 
   return true;
 }
 
 // After the stack is unwound due to a thrown exception, the __stack_pointer
 // global can point to an invalid address. This inserts instructions that