[WebAssembly] Add WebAssemblyException information analysis

[aheejin]

Summary

A WebAssemblyException object contains BBs that belong to a 'catch' part
of the try-catch-end structure. Because CFGSort requires all the BBs
within a catch part to be sorted together as it does for loops, this
pass calculates the nesting structure of catch part of exceptions in a
function. Now this assumes the use of Windows EH instructions.

[majnemer]

lib/Target/WebAssembly/WebAssemblyExceptionInfo.cpp

26–27

What happens if some BBs belong to two different catch blocks?

[aheejin]

WIP: Will add a unit test soon.

[aheejin]

lib/Target/WebAssembly/WebAssemblyExceptionInfo.cpp

26–27

Like loop nesting structure, catch block structure should form a nested structure, so a BB belongs to both catch1 and catch2, catch1 should contain catch2 or vice versa.

[aheejin]

To handle if-else structure as well, I will create WebAssemblySortingBlock or something that can calculate the nesting structure of all exceptions, loops and if-elses.

[majnemer]

lib/Target/WebAssembly/WebAssemblyExceptionInfo.cpp

26–27

This is not so in LLVM IR. For example:

define dso_local void @f() local_unnamed_addr #0 personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) {
  invoke void @x0()
          to label %5 unwind label %1

; <label>:1:                                      ; preds = %0
  %2 = landingpad { i8*, i32 }
          catch i8* null
  %3 = extractvalue { i8*, i32 } %2, 0
  %4 = tail call i8* @__cxa_begin_catch(i8* %3) #3
  br label %11

; <label>:5:                                      ; preds = %0
  invoke void @x1()
          to label %10 unwind label %6

; <label>:6:                                      ; preds = %5
  %7 = landingpad { i8*, i32 }
          catch i8* null
  %8 = extractvalue { i8*, i32 } %7, 0
  %9 = tail call i8* @__cxa_begin_catch(i8* %8) #3
  br label %11

; <label>:10:                                     ; preds = %5
  ret void

; <label>:11:                                     ; preds = %6, %1
  tail call void @abort() #4
  unreachable
}

declare dso_local void @x0() local_unnamed_addr #1

declare i32 @__gxx_personality_v0(...)

declare i8* @__cxa_begin_catch(i8*) local_unnamed_addr

declare dso_local void @x1() local_unnamed_addr #1

; Function Attrs: noreturn nounwind
declare dso_local void @abort() local_unnamed_addr #2

In this example, BB#11 belongs to two different catch blocks.

[aheejin]

lib/Target/WebAssembly/WebAssemblyExceptionInfo.cpp

26–27

An exception catch part is defined as a BB with catch instruction and all other BBs dominated by this BB.

In this case BB#11 is neither in the two catch blocks. Catch#1 contains BB#6 and BB#11, and Catch#2 contains BB#2 only.

[majnemer]

lib/Target/WebAssembly/WebAssemblyExceptionInfo.cpp

26–27

Why doesn't Catch#2 contain BB#11? The two catches are identical, they just jump to a shared common block after executing __cxa_begin_catch.

[aheejin]

lib/Target/WebAssembly/WebAssemblyExceptionInfo.cpp

26–27

What I meant by BB#11 belongs to neither of the catches was more about the real wasm code structure. Yes, it belongs to the catches semantically. But the wasm code will be like

(block
 (try
  ...
  catch
  ...
  br 1
 )
)
 ...
 (try
  ...
  catch
  ...
  br 1
 )
)
call @abort

This code is not specific to your code example; this is trying to show the simplest case that two catch blocks jump to the common code. This text format is called the folded text format in wasm, and the real wasm code does not have parentheses of course, but this format is easier to show scope information.

br is an unconditional branch instruction in wasm. The argument 1 means it breaks out of 2 scopes. (br 0 means it breaks out of 1 scope.) So br 1 within a try breaks out both the try scope and the outer block scope to get to the call @abort instruction.

So, unless you want to duplicate call @abort part, in should be located outside of the two catch blocks, and there should be a branch within each of the catches to jump to the shared code. An instance of WebAssemblyExceptionInfo represents BBs within a single catch in wasm code (try is not there yet, so just BBs starting from catch). This is the reason why it is defined as 'the landing pad BB and all other BBs dominated by it`.

[aheejin]

Updated the patch to use Windows EH instructions

[aheejin]

• Added getHeader method for CFGSort

[aheejin]

• Fixed triples to 'wasm32-unknown-unknown'

[aheejin]

• Add blocks() method for later use

[aheejin]

• Add more methods to make the interface consistent w/ Loop

[aheejin]

• clang-tidy

[aheejin]

• Group two terminate pads (catch and catch_all) together

[aheejin]

• clang-format

[majnemer]

lib/Target/WebAssembly/WebAssemblyExceptionInfo.cpp

61–73

Similar concern here.

80–91

Is it not possible for the MBB to branch to block which then calls std::terminate?

lib/Target/WebAssembly/WebAssemblyExceptionInfo.h

39–40

DeleteContainerPointers(SubExceptions);

Even better would be to use a std::vector<unique_ptr<WebAssemblyException>>

[aheejin]

lib/Target/WebAssembly/WebAssemblyExceptionInfo.cpp

80–91

Hmm, good point... I assumed a terminatepad would be always a single BB but it may not hold. Do you think I should DFS all descendants from here?

lib/Target/WebAssembly/WebAssemblyExceptionInfo.h

39–40

To change this to std::vector<unique_ptr<WebAssemblyException>>, should I RAII WebAssemblyException object at the first creation time and use std::move whenever I pass it to a function until I figure out which container to insert this?

[majnemer]

lib/Target/WebAssembly/WebAssemblyExceptionInfo.cpp

80–91

We handled problems like this one by using getFuncletMembership on the MachineFunction. This does a DFS to let you know which MBBs are part of which catch scopes. I think I'd find a way to reuse it for this.

[aheejin]

lib/Target/WebAssembly/WebAssemblyExceptionInfo.cpp

80–91

Hmm, no, I guess I shouldn't.. doing DFS from all catchpads or cleanuppads sounds like unnecessarily expensive. Should I search for a function call to __clang_call_terminate and search upward from there..?

[majnemer]

lib/Target/WebAssembly/WebAssemblyExceptionInfo.cpp

80–91

IIRC, getFuncletMembership is O(# MBBs) which is no worse than the fundamental amount of work you are doing here. It shouldn't be a considerable amount of overhead.

[aheejin]

lib/Target/WebAssembly/WebAssemblyExceptionInfo.cpp

80–91

Oh, I added the last comment before seeing your new comments about getFuncletMembership, sorry.

You mean, I can replace the whole analysis (not only terminate pad thing) with getFuncletMembership? Or are you talking only about this terminatepad detection?

If you meant the former, I actually thought about not doing this DFS myself but just use the result from getFuncletMembership, but I couldn't find a way to create parent-child relationship between exception objects with getFuncletMembership. That function just returns a map of <BB, funclet number>, which does not say anything about whether a funclet is included in another funclet or is a top-level funclet. Can I reconstruct that information using getFuncletMembership?

And by the way I changed the function name to getEHScopeMembership in D47005 after you accepted it, per @dschuff's request. PTAL if it looks OK.

[aheejin]

lib/Target/WebAssembly/WebAssemblyExceptionInfo.cpp

80–91

Oh, maybe I can just search for a call to __clang_call_terminate() and figure out which WebAssemblyException object it belongs to, and search for BBs that are contained in that exception object...

[majnemer]

lib/Target/WebAssembly/WebAssemblyExceptionInfo.cpp

80–91

Wouldn't finding the other BBs be equivalent to inverting the map given by getEHScopeMembership?

lib/Target/WebAssembly/WebAssemblyExceptionInfo.h

39–40

Yes, I think that makes sense.

[aheejin]

lib/Target/WebAssembly/WebAssemblyExceptionInfo.cpp

80–91

As I said above, can I reconstruct LoopInfo-like parent-child relationship with getFuncletMembership?

[aheejin]

lib/Target/WebAssembly/WebAssemblyExceptionInfo.h

39–40

Come to think of it, this can be complicated. WebAssemblyException object is created in recalculate, which calls discoverAndMapException. Within discoverAndMapException, if a given exception is found to be a subexception of some other exception, it is inserted into a SubExceptions vector in the parent exception. If not, it is not inserted into anywhere in discoverAndMapException, but it is inserted into WebAssemblyExceptionInfo::TopLevelExceptions after returning from discoverAndMapException. So the code should look something like

void WebAssembly::discoverAndMapException(std::unique_ptr<WebAssemblyException> WE) {
  ...
  if (WE is a subexception of a parent exception P)
    add WE to P.SubExceptions;
  ...
}

void addTopLeveException(std::unique_ptr<WebAssemblyException> WE);

void WebAssemblyExceptinInfo::recalculate() {
  ...
  std::unique_ptr<WebAssemblyException> o(args);
  for (...) {
    auto *WE = new WeAssemblyException(EHPad);
    discoverAndMapException(std::move(WE), MDT);
    ...
  }
  ...
  if (top level exception)
    addTopLevelException(std::move(WE));
  ...
}

But the problem is, once we move the object to discoverAndMapException, we can't dereference it or move it again after returning from it. So it is complicated because

1. Where you create an object and insert it to a container are different
2. There are multiple places and multiple containers in which an object can be inserted.

I think DeleteContainerPointers(SubExceptions); is a simple and sane solution. What do you think?

[majnemer]

lib/Target/WebAssembly/WebAssemblyExceptionInfo.cpp

80–91

I don't think you can do it with getEHScopeMembership, it just tells you which MBBs are in the same EH scope... However, testing if something is a top-level scope should be possible I think. You should be able to go from the MBB which starts the scope back to the llvm::BasicBlock and inspect its pad to see if it has a parent.

lib/Target/WebAssembly/WebAssemblyExceptionInfo.h

39–40

SGTM

[aheejin]

• Use DeleteContainerPointers

lib/Target/WebAssembly/WebAssemblyExceptionInfo.cpp

80–91

Actually we should reconsider the terminatepad-related transformations that happen in WebAssemblyExceptionPrepare pass, before this pass runs. WebAssemblyExceptionPrepare is not WasmEHPrepare that runs before instruction selection; it is a MachineFunctionPass that runs before we run WebAssemblyExceptionInfo. WebAssemblyExceptionInfo is in D46803 and I added you as a reviewer there just now. I'll continue this discussion there.

[aheejin]

• One more use of DeleteContainerPointers

[aheejin]

Updated exception grouping algorithm: now it simply gather all the BBs
dominated by an EH pad, rather than stopping at catchret/cleanupret/unreachable.
CFGStackify seems to work either way, and this makes things simpler:

1. We don't need to store frontier BBs ourselves and be able to just use existing MachineDominanceFrontier
2. We can replace catchret/cleanupret earlier in ExceptionPrepare, so we need a single pass rather than two passes.

[aheejin]

• Rebase: now using utility functions in WebAssemblyUtilities.cpp

[dschuff]

Looks pretty reasonable otherwise. I like the MIR unittest 👌

lib/Target/WebAssembly/WebAssemblyExceptionInfo.cpp

15

Ah, this is the explanation I was looking for before. I would put it (at least the part that describes the class) in the header where the class is defined.

19

I would reverse it and say something like "A WebAssemblyException represents/contains/consists of these blocks/this region"

lib/Target/WebAssembly/WebAssemblyExceptionInfo.h

28

Per our discussion on the previous CL, a big comment here explaining what this class represents, and how it is used.

[aheejin]

• Address comments

[aheejin]

@majnemer I inserted a routine to ensure a terminate pad should be a single BB in this previous pass (D46803). Do you have any other concerns here?

lib/Target/WebAssembly/CMakeLists.txt

 
 add_llvm_target(WebAssemblyCodeGen
   WebAssemblyArgumentMove.cpp
   WebAssemblyAsmPrinter.cpp
   WebAssemblyCallIndirectFixup.cpp
   WebAssemblyCFGStackify.cpp
   WebAssemblyCFGSort.cpp
   WebAssemblyExceptionPrepare.cpp
+  WebAssemblyExceptionInfo.cpp
   WebAssemblyExplicitLocals.cpp
   WebAssemblyFastISel.cpp
   WebAssemblyFixIrreducibleControlFlow.cpp
   WebAssemblyFixFunctionBitcasts.cpp
   WebAssemblyFrameLowering.cpp
   WebAssemblyISelDAGToDAG.cpp
   WebAssemblyISelLowering.cpp
   WebAssemblyInstrInfo.cpp

lib/Target/WebAssembly/WebAssembly.h

 void initializeWebAssemblyPrepareForLiveIntervalsPass(PassRegistry &);
 void initializeWebAssemblyOptimizeLiveIntervalsPass(PassRegistry &);
 void initializeWebAssemblyStoreResultsPass(PassRegistry &);
 void initializeWebAssemblyRegStackifyPass(PassRegistry &);
 void initializeWebAssemblyRegColoringPass(PassRegistry &);
 void initializeWebAssemblyExplicitLocalsPass(PassRegistry &);
 void initializeWebAssemblyFixIrreducibleControlFlowPass(PassRegistry &);
 void initializeWebAssemblyExceptionPreparePass(PassRegistry &);
+void initializeWebAssemblyExceptionInfoPass(PassRegistry &);
 void initializeWebAssemblyCFGSortPass(PassRegistry &);
 void initializeWebAssemblyReplaceFuncletReturnsPass(PassRegistry &);
 void initializeWebAssemblyCFGStackifyPass(PassRegistry &);
 void initializeWebAssemblyLowerBrUnlessPass(PassRegistry &);
 void initializeWebAssemblyRegNumberingPass(PassRegistry &);
 void initializeWebAssemblyPeepholePass(PassRegistry &);
 void initializeWebAssemblyCallIndirectFixupPass(PassRegistry &);
 
 } // end namespace llvm
 
 #endif

lib/Target/WebAssembly/WebAssemblyExceptionInfo.h

+//= WebAssemblyExceptionInfo.h - WebAssembly Exception Info -*- C++ -*-==//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+///
+/// \file
+/// \brief This file implements WebAssemblyException information analysis.
+///
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_LIB_TARGET_WEBASSEMBLY_WEBASSEMBLYEXCEPTIONINFO_H
+#define LLVM_LIB_TARGET_WEBASSEMBLY_WEBASSEMBLYEXCEPTIONINFO_H
+
+#include "WebAssembly.h"
+#include "llvm/ADT/SetVector.h"
+#include "llvm/CodeGen/MachineFunctionPass.h"
+
+namespace llvm {
+
+class MachineDominatorTree;
+
+class WebAssemblyException {
+  MachineBasicBlock *EHPad = nullptr;
+
+  WebAssemblyException *ParentException = nullptr;
+  std::vector<WebAssemblyException *> SubExceptions;
+  std::vector<MachineBasicBlock *> Blocks;
+  SmallPtrSet<const MachineBasicBlock *, 8> BlockSet;
+  SetVector<MachineBasicBlock *> Frontiers;
+
+public:
+  WebAssemblyException(MachineBasicBlock *EHPad) : EHPad(EHPad) {}
+  ~WebAssemblyException() { DeleteContainerPointers(SubExceptions); }
+  WebAssemblyException(const WebAssemblyException &) = delete;
+  const WebAssemblyException &operator=(const WebAssemblyException &) = delete;
+
+  MachineBasicBlock *getEHPad() const { return EHPad; }
+  MachineBasicBlock *getHeader() const { return EHPad; }
+  WebAssemblyException *getParentException() const { return ParentException; }
+  void setParentException(WebAssemblyException *WE) { ParentException = WE; }
+
+  bool contains(const WebAssemblyException *WE) const {
+    if (WE == this)
+      return true;
+    if (!WE)
+      return false;
+    return contains(WE->getParentException());
+  }
+  bool contains(const MachineBasicBlock *MBB) const {
+    return BlockSet.count(MBB);
+  }
+
+  void addBlock(MachineBasicBlock *MBB) {
+    Blocks.push_back(MBB);
+    BlockSet.insert(MBB);
+  }
+  ArrayRef<MachineBasicBlock *> getBlocks() const { return Blocks; }
+  using block_iterator = typename ArrayRef<MachineBasicBlock *>::const_iterator;
+  block_iterator block_begin() const { return getBlocks().begin(); }
+  block_iterator block_end() const { return getBlocks().end(); }
+  inline iterator_range<block_iterator> blocks() const {
+    return make_range(block_begin(), block_end());
+  }
+  unsigned getNumBlocks() const { return Blocks.size(); }
+  std::vector<MachineBasicBlock *> &getBlocksVector() { return Blocks; }
+
+  void addFrontier(MachineBasicBlock *MBB) { Frontiers.insert(MBB); }
+  const SetVector<MachineBasicBlock *> &getFrontiers() const {
+    return Frontiers;
+  }
+
+  const std::vector<WebAssemblyException *> &getSubExceptions() const {
+    return SubExceptions;
+  }
+  std::vector<WebAssemblyException *> &getSubExceptions() {
+    return SubExceptions;
+  }
+  void addSubException(WebAssemblyException *E) { SubExceptions.push_back(E); }
+  using iterator = typename std::vector<WebAssemblyException *>::const_iterator;
+  iterator begin() const { return SubExceptions.begin(); }
+  iterator end() const { return SubExceptions.end(); }
+
+  void reserveBlocks(unsigned Size) { Blocks.reserve(Size); }
+  void reverseBlock(unsigned From = 0) {
+    std::reverse(Blocks.begin() + From, Blocks.end());
+  }
+
+  // Return the nesting level. An outermost one has depth 1.
+  unsigned getExceptionDepth() const {
+    unsigned D = 1;
+    for (const WebAssemblyException *CurException = ParentException;
+         CurException; CurException = CurException->ParentException)
+      ++D;
+    return D;
+  }
+
+  void print(raw_ostream &OS, unsigned Depth = 0) const;
+  void dump() const;
+};
+
+raw_ostream &operator<<(raw_ostream &OS, const WebAssemblyException &WE);
+
+class WebAssemblyExceptionInfo final : public MachineFunctionPass {
+  // Mapping of basic blocks to the innermost exception they occur in
+  DenseMap<const MachineBasicBlock *, WebAssemblyException *> BBMap;
+  std::vector<WebAssemblyException *> TopLevelExceptions;
+
+  void discoverAndMapException(WebAssemblyException *WE,
+                               const MachineDominatorTree &MDT);
+  WebAssemblyException *getOutermostException(MachineBasicBlock *MBB) const;
+
+public:
+  static char ID;
+  WebAssemblyExceptionInfo() : MachineFunctionPass(ID) {
+    initializeWebAssemblyExceptionInfoPass(*PassRegistry::getPassRegistry());
+  }
+  ~WebAssemblyExceptionInfo() override { releaseMemory(); }
+  WebAssemblyExceptionInfo(const WebAssemblyExceptionInfo &) = delete;
+  WebAssemblyExceptionInfo &
+  operator=(const WebAssemblyExceptionInfo &) = delete;
+
+  bool runOnMachineFunction(MachineFunction &) override;
+  void releaseMemory() override;
+  void recalculate(MachineDominatorTree &MDT);
+  void getAnalysisUsage(AnalysisUsage &AU) const override;
+
+  bool empty() const { return TopLevelExceptions.empty(); }
+
+  // Return the innermost exception that MBB lives in. If the block is not in an
+  // exception, null is returned.
+  WebAssemblyException *getExceptionFor(const MachineBasicBlock *MBB) const {
+    return BBMap.lookup(MBB);
+  }
+
+  void changeExceptionFor(MachineBasicBlock *MBB, WebAssemblyException *WE) {
+    if (!WE) {
+      BBMap.erase(MBB);
+      return;
+    }
+    BBMap[MBB] = WE;
+  }
+
+  void addTopLevelException(WebAssemblyException *WE) {
+    assert(!WE->getParentException() && "Not a top level exception!");
+    TopLevelExceptions.push_back(WE);
+  }
+
+  void print(raw_ostream &OS, const Module *M = nullptr) const override;
+};
+
+} // end namespace llvm
+
+#endif

lib/Target/WebAssembly/WebAssemblyExceptionInfo.cpp

+//===--- WebAssemblyExceptionInfo.cpp - Exception Infomation --------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+///
+/// \file
+/// \brief This file implements WebAssemblyException information analysis.
+///
+///
+/// WebAssembly instructions for exception handling are structured as follows:
+///   try
+///     instructions*
+///   catch             ----|
+///     instructions*       | -> This part consists of WebAssemblyException
+///   end               ----|
+//
+/// A WebAssemblyException object contains BBs that belong to a 'catch' part of
+/// the try-catch-end structure to be created later. 'try' and 'end' markers
+/// are not present at this stage and will be generated in CFGStackify pass.
+/// Because CFGSort requires all the BBs within a catch part to be sorted
+/// together as it does for loops, this pass calculates the nesting structure of
+/// catch part of exceptions in a function.
+///
+/// An exception catch part begins with an EH pad and ends with a block when one
+/// of these conditions is met:
+/// 1. a block that ends with a 'catchret' instruction
+/// 2. a block that ends with a 'cleanupret' instruction
+/// 3. a block that ends with a 'unreachable' instruction
+/// 4. a block that is not dominated by the EH pad
+///
+//===----------------------------------------------------------------------===//
+
+#include "WebAssemblyExceptionInfo.h"
+#include "MCTargetDesc/WebAssemblyMCTargetDesc.h"
+#include "llvm/ADT/PostOrderIterator.h"
+#include "llvm/CodeGen/MachineDominators.h"
+
+using namespace llvm;
+
+#define DEBUG_TYPE "wasm-exception-info"
+
+static const char *const ClangCallTerminate = "__clang_call_terminate";
+static const char *const StdTerminate = "_ZSt9terminatev";
+
+char WebAssemblyExceptionInfo::ID = 0;
+
+INITIALIZE_PASS_BEGIN(WebAssemblyExceptionInfo, DEBUG_TYPE,
+                      "WebAssembly Exception Information", true, true)
+INITIALIZE_PASS_DEPENDENCY(MachineDominatorTree)
+INITIALIZE_PASS_END(WebAssemblyExceptionInfo, DEBUG_TYPE,
+                    "WebAssembly Exception Information", true, true)
+
+static bool isCatchTerminatePad(const MachineBasicBlock *MBB) {
+  assert(MBB->isEHPad());
+  bool SeenCatch = false;
+  for (auto &MI : *MBB) {
+    if (MI.getOpcode() == WebAssembly::CATCH_I32 ||
+        MI.getOpcode() == WebAssembly::CATCH_I64) {
+      SeenCatch = true;
+      continue;
+    }
+    if (SeenCatch && MI.isCall()) {
+      const MachineOperand &CalleeOp = MI.getOperand(0);
+      if (CalleeOp.isGlobal() &&
+          CalleeOp.getGlobal()->getName() == ClangCallTerminate)
+        return true;
+    }
+  }
+  return false;
+}
+
+static bool isCatchAllTerminatePad(const MachineBasicBlock *MBB) {
+  assert(MBB->isEHPad());
+  bool SeenCatchAll = false;
+  for (auto &MI : *MBB) {
+    if (MI.getOpcode() == WebAssembly::CATCH_ALL) {
+      SeenCatchAll = true;
+      continue;
+    }
+    if (SeenCatchAll && MI.isCall()) {
+      const MachineOperand &CalleeOp = MI.getOperand(0);
+      if (CalleeOp.isGlobal() &&
+          CalleeOp.getGlobal()->getName() == StdTerminate)
+        return true;
+    }
+  }
+  return false;
+}
+
+bool WebAssemblyExceptionInfo::runOnMachineFunction(MachineFunction &F) {
+  releaseMemory();
+  auto &MDT = getAnalysis<MachineDominatorTree>();
+  recalculate(MDT);
+  return false;
+}
+
+void WebAssemblyExceptionInfo::recalculate(MachineDominatorTree &MDT) {
+  // Postorder traversal of the dominator tree.
+  SmallVector<WebAssemblyException *, 8> Exceptions;
+  for (auto DomNode : post_order(&MDT)) {
+    MachineBasicBlock *EHPad = DomNode->getBlock();
+    if (!EHPad->isEHPad())
+      continue;
+    // We group catch & catch-all terminate pads together, so skip the second
+    // one
+    if (isCatchAllTerminatePad(EHPad))
+      continue;
+    auto *WE = new WebAssemblyException(EHPad);
+    discoverAndMapException(WE, MDT);
+    Exceptions.push_back(WE);
+  }
+
+  // Add BBs to exceptions
+  for (auto DomNode : post_order(&MDT)) {
+    MachineBasicBlock *MBB = DomNode->getBlock();
+    WebAssemblyException *WE = getExceptionFor(MBB);
+    for (; WE; WE = WE->getParentException())
+      WE->addBlock(MBB);
+  }
+
+  // Add subexceptions to exceptions
+  for (auto *WE : Exceptions) {
+    if (WE->getParentException())
+      WE->getParentException()->getSubExceptions().push_back(WE);
+    else
+      addTopLevelException(WE);
+  }
+
+  // For convenience, Blocks and SubExceptions are inserted in postorder.
+  // Reverse the lists.
+  for (auto *WE : Exceptions) {
+    WE->reverseBlock();
+    std::reverse(WE->getSubExceptions().begin(), WE->getSubExceptions().end());
+  }
+}
+
+void WebAssemblyExceptionInfo::releaseMemory() {
+  BBMap.clear();
+  for (auto *WE : TopLevelExceptions)
+    delete WE;
+  TopLevelExceptions.clear();
+}
+
+void WebAssemblyExceptionInfo::getAnalysisUsage(AnalysisUsage &AU) const {
+  AU.setPreservesAll();
+  AU.addRequired<MachineDominatorTree>();
+  MachineFunctionPass::getAnalysisUsage(AU);
+}
+
+void WebAssemblyExceptionInfo::discoverAndMapException(
+    WebAssemblyException *WE, const MachineDominatorTree &MDT) {
+  unsigned NumBlocks = 0;
+  unsigned NumSubExceptions = 0;
+
+  // Map blocks that belong to a catchpad / cleanuppad
+  MachineBasicBlock *EHPad = WE->getEHPad();
+
+  // We group catch & catch-all terminate pads together within an exception
+  if (isCatchTerminatePad(EHPad)) {
+    assert(EHPad->succ_size() == 1 &&
+           "Catch terminate pad has more than one successors");
+    changeExceptionFor(EHPad, WE);
+    changeExceptionFor(*(EHPad->succ_begin()), WE);
+    return;
+  }
+
+  SmallVector<MachineBasicBlock *, 8> WL;
+  WL.push_back(EHPad);
+  while (!WL.empty()) {
+    MachineBasicBlock *MBB = WL.pop_back_val();
+
+    // Find its outermost discovered exception. If this is a discovered block,
+    // check if it is already discovered to be a subexception of this exception.
+    WebAssemblyException *SubE = getOutermostException(MBB);
+    if (SubE) {
+      if (SubE != WE) {
+        // Discover a subexception of this exception.
+        SubE->setParentException(WE);
+        ++NumSubExceptions;
+        NumBlocks += SubE->getBlocksVector().capacity();
+        // All blocks that belong to this subexception have been already
+        // discovered. Skip all of them.
+        for (auto *Frontier : SubE->getFrontiers())
+          if (MDT.dominates(EHPad, Frontier))
+            WL.push_back(Frontier);
+      }
+      continue;
+    }
+
+    // This is an undiscovered block. Map it to the current exception.
+    changeExceptionFor(MBB, WE);
+    ++NumBlocks;
+
+    // catchret, cleanupret, and unreachable instructions mark the end border of
+    // an exception.
+    if (MBB->getFirstTerminator() != MBB->end()) {
+      switch (MBB->getFirstTerminator()->getOpcode()) {
+      case WebAssembly::CATCHRET:
+      case WebAssembly::CLEANUPRET:
+      case WebAssembly::UNREACHABLE:
+        for (auto *Succ : MBB->successors())
+          WE->addFrontier(Succ);
+        continue;
+      }
+    }
+
+    // Add successors dominated by the current BB to the worklist.
+    for (auto *Succ : MBB->successors())
+      if (MDT.dominates(EHPad, Succ))
+        WL.push_back(Succ);
+      else
+        WE->addFrontier(Succ);
+  }
+
+  WE->getSubExceptions().reserve(NumSubExceptions);
+  WE->reserveBlocks(NumBlocks);
+}
+
+WebAssemblyException *
+WebAssemblyExceptionInfo::getOutermostException(MachineBasicBlock *MBB) const {
+  WebAssemblyException *WE = getExceptionFor(MBB);
+  if (WE) {
+    while (WebAssemblyException *Parent = WE->getParentException())
+      WE = Parent;
+  }
+  return WE;
+}
+
+void WebAssemblyException::print(raw_ostream &OS, unsigned Depth) const {
+  OS.indent(Depth * 2) << "Exception at depth " << getExceptionDepth()
+                       << " containing: ";
+
+  for (unsigned I = 0; I < getBlocks().size(); ++I) {
+    MachineBasicBlock *MBB = getBlocks()[I];
+    if (I)
+      OS << ", ";
+    OS << "%bb." << MBB->getNumber();
+    if (const auto *BB = MBB->getBasicBlock())
+      if (BB->hasName())
+        OS << "." << BB->getName();
+
+    if (getEHPad() == MBB)
+      OS << " (landing-pad)";
+  }
+  OS << "\n";
+
+  for (auto &SubE : SubExceptions)
+    SubE->print(OS, Depth + 2);
+}
+
+#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
+LLVM_DUMP_METHOD void WebAssemblyException::dump() const { print(dbgs()); }
+#endif
+
+raw_ostream &operator<<(raw_ostream &OS, const WebAssemblyException &WE) {
+  WE.print(OS);
+  return OS;
+}
+
+void WebAssemblyExceptionInfo::print(raw_ostream &OS, const Module *) const {
+  for (auto *WE : TopLevelExceptions)
+    WE->print(OS);
+}

lib/Target/WebAssembly/WebAssemblyTargetMachine.cpp

extern "C" void LLVMInitializeWebAssemblyTarget() {
   initializeWebAssemblyPrepareForLiveIntervalsPass(PR);
   initializeWebAssemblyOptimizeLiveIntervalsPass(PR);
   initializeWebAssemblyStoreResultsPass(PR);
   initializeWebAssemblyRegStackifyPass(PR);
   initializeWebAssemblyRegColoringPass(PR);
   initializeWebAssemblyExplicitLocalsPass(PR);
   initializeWebAssemblyFixIrreducibleControlFlowPass(PR);
   initializeWebAssemblyExceptionPreparePass(PR);
+  initializeWebAssemblyExceptionInfoPass(PR);
   initializeWebAssemblyCFGSortPass(PR);
   initializeWebAssemblyReplaceFuncletReturnsPass(PR);
   initializeWebAssemblyCFGStackifyPass(PR);
   initializeWebAssemblyLowerBrUnlessPass(PR);
   initializeWebAssemblyRegNumberingPass(PR);
   initializeWebAssemblyPeepholePass(PR);
   initializeWebAssemblyCallIndirectFixupPass(PR);
 }

unittests/Target/WebAssembly/CMakeLists.txt

+include_directories(
+  ${CMAKE_SOURCE_DIR}/lib/Target/WebAssembly
+  ${CMAKE_BINARY_DIR}/lib/Target/WebAssembly
+  )
+
+set(LLVM_LINK_COMPONENTS
+  CodeGen
+  Core
+  MC
+  MIRParser
+  WebAssemblyCodeGen
+  WebAssemblyDesc
+  WebAssemblyInfo
+  )
+
+add_llvm_unittest(WebAssemblyTests
+  WebAssemblyExceptionInfoTest.cpp
+  )

unittests/Target/WebAssembly/WebAssemblyExceptionInfoTest.cpp

+//=== WebAssemblyExceptionInfoTest.cpp - WebAssebmlyExceptionInfo unit tests =//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "WebAssemblyExceptionInfo.h"
+#include "llvm/CodeGen/MIRParser/MIRParser.h"
+#include "llvm/CodeGen/MachineDominators.h"
+#include "llvm/CodeGen/MachineModuleInfo.h"
+#include "llvm/Support/SourceMgr.h"
+#include "llvm/Support/TargetRegistry.h"
+#include "llvm/Support/TargetSelect.h"
+#include "llvm/Target/TargetMachine.h"
+#include "gtest/gtest.h"
+
+using namespace llvm;
+
+namespace {
+
+std::unique_ptr<TargetMachine> createTargetMachine() {
+  auto TT(Triple::normalize("wasm32-unknown-unknown"));
+  std::string CPU("");
+  std::string FS("");
+
+  LLVMInitializeWebAssemblyTargetInfo();
+  LLVMInitializeWebAssemblyTarget();
+  LLVMInitializeWebAssemblyTargetMC();
+
+  std::string Error;
+  const Target *TheTarget = TargetRegistry::lookupTarget(TT, Error);
+  assert(TheTarget);
+
+  return std::unique_ptr<TargetMachine>(TheTarget->createTargetMachine(
+      TT, CPU, FS, TargetOptions(), None, None, CodeGenOpt::Default));
+}
+
+std::unique_ptr<Module> parseMIR(LLVMContext &Context,
+                                 std::unique_ptr<MIRParser> &MIR,
+                                 const TargetMachine &TM, StringRef MIRCode,
+                                 const char *FuncName, MachineModuleInfo &MMI) {
+  SMDiagnostic Diagnostic;
+  std::unique_ptr<MemoryBuffer> MBuffer = MemoryBuffer::getMemBuffer(MIRCode);
+  MIR = createMIRParser(std::move(MBuffer), Context);
+  if (!MIR)
+    return nullptr;
+
+  std::unique_ptr<Module> M = MIR->parseIRModule();
+  if (!M)
+    return nullptr;
+
+  M->setDataLayout(TM.createDataLayout());
+
+  if (MIR->parseMachineFunctions(*M, MMI))
+    return nullptr;
+
+  return M;
+}
+
+} // namespace
+
+TEST(WebAssemblyExceptionInfoTest, TEST0) {
+  std::unique_ptr<TargetMachine> TM = createTargetMachine();
+  ASSERT_TRUE(TM);
+
+  StringRef MIRString = R"MIR(
+--- |
+  target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
+  target triple = "wasm32-unknown-unknown"
+
+  declare i32 @__gxx_wasm_personality_v0(...)
+
+  define hidden void @test0() personality i8* bitcast (i32 (...)* @__gxx_wasm_personality_v0 to i8*) {
+    unreachable
+  }
+
+...
+---
+name: test0
+liveins:
+  - { reg: '$arguments' }
+  - { reg: '$value_stack' }
+body: |
+  bb.0:
+    successors: %bb.1, %bb.2
+    liveins: $arguments, $value_stack
+    BR %bb.1, implicit-def dead $arguments
+
+  bb.1:
+  ; predecessors: %bb.0
+    successors: %bb.7
+    liveins: $value_stack
+    BR %bb.7, implicit-def $arguments
+
+  bb.2 (landing-pad):
+  ; predecessors: %bb.0
+    successors: %bb.3, %bb.9
+    liveins: $value_stack
+    CATCH_ALL implicit-def $arguments
+    CLEANUPRET implicit-def dead $arguments
+
+  bb.3 (landing-pad):
+  ; predecessors: %bb.2
+    successors: %bb.4, %bb.6
+    liveins: $value_stack
+    CATCH_ALL implicit-def $arguments
+    BR_IF %bb.4, %58:i32, implicit-def $arguments, implicit-def $value_stack, implicit $value_stack
+    BR %bb.6, implicit-def $arguments
+
+  bb.4:
+  ; predecessors: %bb.3
+    successors: %bb.5, %bb.8
+    liveins: $value_stack
+    BR %bb.5, implicit-def dead $arguments
+
+  bb.5:
+  ; predecessors: %bb.4
+    successors: %bb.7
+    liveins: $value_stack
+    CATCHRET %bb.7, %bb.0, implicit-def dead $arguments
+
+  bb.6:
+  ; predecessors: %bb.3
+    successors: %bb.10, %bb.9
+    liveins: $value_stack
+    BR %bb.10, implicit-def dead $arguments
+
+  bb.7:
+  ; predecessors: %bb.5, %bb.1
+    liveins: $value_stack
+    RETURN_VOID implicit-def $arguments
+
+  bb.8 (landing-pad):
+  ; predecessors: %bb.4
+    successors: %bb.9
+    liveins: $value_stack
+    CATCH_ALL implicit-def $arguments
+    CLEANUPRET implicit-def dead $arguments
+
+  bb.9 (landing-pad):
+  ; predecessors: %bb.2, %bb.6, %bb.8
+    liveins: $value_stack
+    CATCH_ALL implicit-def $arguments
+    CLEANUPRET implicit-def dead $arguments
+
+  bb.10:
+  ; predecessors: %bb.6
+    liveins: $value_stack
+    UNREACHABLE implicit-def $arguments
+)MIR";
+
+  LLVMContext Context;
+  std::unique_ptr<MIRParser> MIR;
+  MachineModuleInfo MMI(TM.get());
+  std::unique_ptr<Module> M =
+      parseMIR(Context, MIR, *TM, MIRString, "test0", MMI);
+  ASSERT_TRUE(M);
+
+  Function *F = M->getFunction("test0");
+  auto *MF = MMI.getMachineFunction(*F);
+  ASSERT_TRUE(MF);
+
+  WebAssemblyExceptionInfo WEI;
+  MachineDominatorTree MDT;
+  MDT.runOnMachineFunction(*MF);
+  WEI.recalculate(MDT);
+
+  // Exception info structure:
+  // |- bb3 (ehpad), bb4, bb6, bb8, bb10
+  //   |- bb8 (ehpad)
+  // |- bb2 (ehpad)
+  // |- bb9 (ehpad)
+
+  auto *MBB3 = MF->getBlockNumbered(3);
+  auto *WE0 = WEI.getExceptionFor(MBB3);
+  ASSERT_TRUE(WE0);
+  EXPECT_EQ(WE0->getEHPad(), MBB3);
+  EXPECT_EQ(WE0->getParentException(), nullptr);
+  EXPECT_EQ(WE0->getExceptionDepth(), (unsigned)1);
+
+  auto *MBB4 = MF->getBlockNumbered(4);
+  WE0 = WEI.getExceptionFor(MBB4);
+  ASSERT_TRUE(WE0);
+  EXPECT_EQ(WE0->getEHPad(), MBB3);
+
+  auto *MBB5 = MF->getBlockNumbered(5);
+  WE0 = WEI.getExceptionFor(MBB5);
+  ASSERT_TRUE(WE0);
+  EXPECT_EQ(WE0->getEHPad(), MBB3);
+
+  auto *MBB6 = MF->getBlockNumbered(6);
+  WE0 = WEI.getExceptionFor(MBB6);
+  ASSERT_TRUE(WE0);
+  EXPECT_EQ(WE0->getEHPad(), MBB3);
+
+  auto *MBB10 = MF->getBlockNumbered(10);
+  WE0 = WEI.getExceptionFor(MBB10);
+  ASSERT_TRUE(WE0);
+  EXPECT_EQ(WE0->getEHPad(), MBB3);
+
+  auto *MBB8 = MF->getBlockNumbered(8);
+  auto *WE0_0 = WEI.getExceptionFor(MBB8);
+  ASSERT_TRUE(WE0_0);
+  EXPECT_EQ(WE0_0->getEHPad(), MBB8);
+  EXPECT_EQ(WE0_0->getParentException(), WE0);
+  EXPECT_EQ(WE0_0->getExceptionDepth(), (unsigned)2);
+
+  auto *MBB2 = MF->getBlockNumbered(2);
+  auto *WE1 = WEI.getExceptionFor(MBB2);
+  ASSERT_TRUE(WE1);
+  EXPECT_EQ(WE1->getEHPad(), MBB2);
+  EXPECT_EQ(WE1->getParentException(), nullptr);
+  EXPECT_EQ(WE1->getExceptionDepth(), (unsigned)1);
+
+  auto *MBB9 = MF->getBlockNumbered(3);
+  auto *WE2 = WEI.getExceptionFor(MBB9);
+  ASSERT_TRUE(WE2);
+  EXPECT_EQ(WE2->getEHPad(), MBB9);
+  EXPECT_EQ(WE2->getParentException(), nullptr);
+  EXPECT_EQ(WE2->getExceptionDepth(), (unsigned)1);
+}
+
+TEST(WebAssemblyExceptionInfoTest, TEST1) {
+  std::unique_ptr<TargetMachine> TM = createTargetMachine();
+  ASSERT_TRUE(TM);
+
+  StringRef MIRString = R"MIR(
+--- |
+  target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
+  target triple = "wasm32-unknown-unknown"
+
+  declare i32 @__gxx_wasm_personality_v0(...)
+
+  define hidden void @test1() personality i8* bitcast (i32 (...)* @__gxx_wasm_personality_v0 to i8*) {
+    unreachable
+  }
+
+...
+---
+name: test1
+liveins:
+  - { reg: '$arguments' }
+  - { reg: '$value_stack' }
+body: |
+  bb.0:
+    successors: %bb.9, %bb.1
+    liveins: $arguments, $value_stack
+    BR %bb.9, implicit-def dead $arguments
+
+  bb.1 (landing-pad):
+  ; predecessors: %bb.0
+    successors: %bb.2, %bb.8
+    liveins: $value_stack
+    %52:i32 = CATCH_I32 0, implicit-def dead $arguments
+    BR_IF %bb.2, %32:i32, implicit-def $arguments, implicit-def $value_stack, implicit $value_stack
+    BR %bb.8, implicit-def $arguments
+
+  bb.2:
+  ; predecessors: %bb.1
+    successors: %bb.7, %bb.3, %bb.11
+    liveins: $value_stack
+    BR %bb.7, implicit-def dead $arguments
+
+  bb.3 (landing-pad):
+  ; predecessors: %bb.2
+    successors: %bb.4, %bb.6
+    liveins: $value_stack
+    CATCH_ALL implicit-def $arguments
+    BR_IF %bb.4, %43:i32, implicit-def $arguments, implicit-def $value_stack, implicit $value_stack
+    BR %bb.6, implicit-def $arguments
+
+  bb.4:
+  ; predecessors: %bb.3
+    successors: %bb.5, %bb.10
+    liveins: $value_stack
+    BR %bb.5, implicit-def dead $arguments
+
+  bb.5:
+  ; predecessors: %bb.4
+    successors: %bb.7(0x80000000); %bb.7(200.00%)
+    liveins: $value_stack
+    CATCHRET %bb.7, %bb.1, implicit-def dead $arguments
+
+  bb.6:
+  ; predecessors: %bb.3
+    successors: %bb.12, %bb.11
+    liveins: $value_stack
+    BR %bb.12, implicit-def dead $arguments
+
+  bb.7:
+  ; predecessors: %bb.2, %bb.5
+    successors: %bb.9(0x80000000); %bb.9(200.00%)
+    liveins: $value_stack
+    CATCHRET %bb.9, %bb.0, implicit-def dead $arguments
+
+  bb.8:
+  ; predecessors: %bb.1
+    liveins: $value_stack
+    UNREACHABLE implicit-def $arguments
+
+  bb.9:
+  ; predecessors: %bb.0, %bb.7
+    liveins: $value_stack
+    RETURN_VOID implicit-def $arguments
+
+  bb.10 (landing-pad):
+  ; predecessors: %bb.4
+    successors: %bb.11
+    liveins: $value_stack
+    CATCH_ALL implicit-def $arguments
+    CLEANUPRET implicit-def dead $arguments
+
+  bb.11 (landing-pad):
+  ; predecessors: %bb.2, %bb.6, %bb.10
+    liveins: $value_stack
+    CATCH_ALL implicit-def $arguments
+    CLEANUPRET implicit-def dead $arguments
+
+  bb.12:
+  ; predecessors: %bb.6
+    liveins: $value_stack
+    UNREACHABLE implicit-def $arguments
+)MIR";
+
+  LLVMContext Context;
+  std::unique_ptr<MIRParser> MIR;
+  MachineModuleInfo MMI(TM.get());
+  std::unique_ptr<Module> M =
+      parseMIR(Context, MIR, *TM, MIRString, "test1", MMI);
+  ASSERT_TRUE(M);
+
+  Function *F = M->getFunction("test1");
+  auto *MF = MMI.getMachineFunction(*F);
+  ASSERT_TRUE(MF);
+
+  WebAssemblyExceptionInfo WEI;
+  MachineDominatorTree MDT;
+  MDT.runOnMachineFunction(*MF);
+  WEI.recalculate(MDT);
+
+  // Exception info structure:
+  // |- bb1 (ehpad), bb2, bb3, bb4, bb5, bb6, bb7, bb8, bb10, bb11, bb12
+  //   |- bb3 (ehpad), bb4, bb5, bb6, bb10, bb12
+  //     |- bb10 (ehpad)
+  //   |- bb11 (ehpad)
+
+  auto *MBB1 = MF->getBlockNumbered(1);
+  auto *WE0 = WEI.getExceptionFor(MBB1);
+  ASSERT_TRUE(WE0);
+  EXPECT_EQ(WE0->getEHPad(), MBB1);
+  EXPECT_EQ(WE0->getParentException(), nullptr);
+  EXPECT_EQ(WE0->getExceptionDepth(), (unsigned)1);
+
+  auto *MBB2 = MF->getBlockNumbered(2);
+  WE0 = WEI.getExceptionFor(MBB2);
+  ASSERT_TRUE(WE0);
+  EXPECT_EQ(WE0->getEHPad(), MBB1);
+
+  auto *MBB7 = MF->getBlockNumbered(7);
+  WE0 = WEI.getExceptionFor(MBB7);
+  ASSERT_TRUE(WE0);
+  EXPECT_EQ(WE0->getEHPad(), MBB1);
+
+  auto *MBB8 = MF->getBlockNumbered(8);
+  WE0 = WEI.getExceptionFor(MBB8);
+  ASSERT_TRUE(WE0);
+  EXPECT_EQ(WE0->getEHPad(), MBB1);
+
+  auto *MBB3 = MF->getBlockNumbered(3);
+  auto *WE0_0 = WEI.getExceptionFor(MBB3);
+  ASSERT_TRUE(WE0_0);
+  EXPECT_EQ(WE0_0->getEHPad(), MBB3);
+  EXPECT_EQ(WE0_0->getParentException(), WE0);
+  EXPECT_EQ(WE0_0->getExceptionDepth(), (unsigned)2);
+
+  auto *MBB4 = MF->getBlockNumbered(4);
+  WE0_0 = WEI.getExceptionFor(MBB4);
+  ASSERT_TRUE(WE0_0);
+  EXPECT_EQ(WE0_0->getEHPad(), MBB3);
+
+  auto *MBB5 = MF->getBlockNumbered(5);
+  WE0_0 = WEI.getExceptionFor(MBB5);
+  ASSERT_TRUE(WE0_0);
+  EXPECT_EQ(WE0_0->getEHPad(), MBB3);
+
+  auto *MBB6 = MF->getBlockNumbered(6);
+  WE0_0 = WEI.getExceptionFor(MBB6);
+  ASSERT_TRUE(WE0_0);
+  EXPECT_EQ(WE0_0->getEHPad(), MBB3);
+
+  auto *MBB12 = MF->getBlockNumbered(12);
+  WE0_0 = WEI.getExceptionFor(MBB12);
+  ASSERT_TRUE(WE0_0);
+  EXPECT_EQ(WE0_0->getEHPad(), MBB3);
+
+  auto *MBB10 = MF->getBlockNumbered(10);
+  auto *WE0_0_0 = WEI.getExceptionFor(MBB10);
+  ASSERT_TRUE(WE0_0_0);
+  EXPECT_EQ(WE0_0_0->getEHPad(), MBB10);
+  EXPECT_EQ(WE0_0_0->getParentException(), WE0_0);
+  EXPECT_EQ(WE0_0_0->getExceptionDepth(), (unsigned)3);
+
+  auto *MBB11 = MF->getBlockNumbered(11);
+  auto *WE0_1 = WEI.getExceptionFor(MBB11);
+  ASSERT_TRUE(WE0_1);
+  EXPECT_EQ(WE0_1->getEHPad(), MBB11);
+  EXPECT_EQ(WE0_1->getParentException(), WE0);
+  EXPECT_EQ(WE0_1->getExceptionDepth(), (unsigned)2);
+}
+
+// Terminate pad test
+TEST(WebAssemblyExceptionInfoTest, TEST2) {
+  std::unique_ptr<TargetMachine> TM = createTargetMachine();
+  ASSERT_TRUE(TM);
+
+  StringRef MIRString = R"MIR(
+--- |
+  target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
+  target triple = "wasm32-unknown-unknown"
+
+  declare i32 @__gxx_wasm_personality_v0(...)
+  declare void @_ZSt9terminatev()
+  declare void @__clang_call_terminate(i8*)
+
+  define hidden void @test2() personality i8* bitcast (i32 (...)* @__gxx_wasm_personality_v0 to i8*) {
+    unreachable
+  }
+
+...
+---
+name: test2
+liveins:
+  - { reg: '$arguments' }
+  - { reg: '$value_stack' }
+body: |
+  bb.0:
+    successors: %bb.3, %bb.1
+    BR %bb.3, implicit-def dead $arguments
+
+  bb.1 (landing-pad):
+  ; predecessors: %bb.0
+    successors: %bb.2, %bb.4
+    %3:i32 = CATCH_I32 0, implicit-def dead $arguments
+    BR %bb.2, implicit-def dead $arguments
+
+  bb.2:
+  ; predecessors: %bb.1
+    successors: %bb.3(0x80000000); %bb.3(200.00%)
+    CATCHRET %bb.3, %bb.0, implicit-def dead $arguments
+
+  bb.3:
+  ; predecessors: %bb.0, %bb.2
+    RETURN_VOID implicit-def $arguments
+
+  bb.4 (landing-pad):
+  ; predecessors: %bb.1
+    successors: %bb.5, %bb.6
+    CATCH_ALL implicit-def $arguments
+    BR %bb.5, implicit-def dead $arguments
+
+  bb.5:
+  ; predecessors: %bb.4
+    CLEANUPRET implicit-def dead $arguments
+
+  bb.6 (landing-pad):
+  ; predecessors: %bb.4
+    successors: %bb.7(0x80000000); %bb.7(200.00%)
+    %6:i32 = CATCH_I32 0, implicit-def dead $arguments
+    CALL_VOID @__clang_call_terminate, %7:i32, implicit-def $arguments
+    UNREACHABLE implicit-def $arguments
+
+  bb.7 (landing-pad):
+  ; predecessors: %bb.6
+    CATCH_ALL implicit-def $arguments
+    CALL_VOID @_ZSt9terminatev, implicit-def $arguments
+    UNREACHABLE implicit-def $arguments
+)MIR";
+
+  LLVMContext Context;
+  std::unique_ptr<MIRParser> MIR;
+  MachineModuleInfo MMI(TM.get());
+  std::unique_ptr<Module> M =
+      parseMIR(Context, MIR, *TM, MIRString, "test2", MMI);
+  ASSERT_TRUE(M);
+
+  Function *F = M->getFunction("test2");
+  auto *MF = MMI.getMachineFunction(*F);
+  ASSERT_TRUE(MF);
+
+  WebAssemblyExceptionInfo WEI;
+  MachineDominatorTree MDT;
+  MDT.runOnMachineFunction(*MF);
+  WEI.recalculate(MDT);
+
+  // Exception info structure:
+  // |- bb1 (ehpad), bb2, bb4, bb5, bb6, bb7
+  //   |- bb4 (ehpad), bb5, bb6, bb7
+  //     |- bb6 (ehpad), bb7
+  //
+  // Here, bb6 is a terminate pad with a 'catch' instruction, and bb7 is a
+  // terminate pad with a 'catch_all' instruction, In this case we put bb6 and
+  // bb7 into one exception.
+
+  auto *MBB1 = MF->getBlockNumbered(1);
+  auto *WE0 = WEI.getExceptionFor(MBB1);
+  ASSERT_TRUE(WE0);
+  EXPECT_EQ(WE0->getEHPad(), MBB1);
+  EXPECT_EQ(WE0->getParentException(), nullptr);
+  EXPECT_EQ(WE0->getExceptionDepth(), (unsigned)1);
+
+  auto *MBB2 = MF->getBlockNumbered(2);
+  WE0 = WEI.getExceptionFor(MBB2);
+  ASSERT_TRUE(WE0);
+  EXPECT_EQ(WE0->getEHPad(), MBB1);
+
+  auto *MBB4 = MF->getBlockNumbered(4);
+  auto *WE0_0 = WEI.getExceptionFor(MBB4);
+  ASSERT_TRUE(WE0_0);
+  EXPECT_EQ(WE0_0->getEHPad(), MBB4);
+  EXPECT_EQ(WE0_0->getParentException(), WE0);
+  EXPECT_EQ(WE0_0->getExceptionDepth(), (unsigned)2);
+
+  auto *MBB5 = MF->getBlockNumbered(5);
+  WE0_0 = WEI.getExceptionFor(MBB5);
+  ASSERT_TRUE(WE0_0);
+  EXPECT_EQ(WE0_0->getEHPad(), MBB4);
+
+  auto *MBB6 = MF->getBlockNumbered(6);
+  auto *WE0_0_0 = WEI.getExceptionFor(MBB6);
+  ASSERT_TRUE(WE0_0_0);
+  EXPECT_EQ(WE0_0_0->getEHPad(), MBB6);
+  EXPECT_EQ(WE0_0_0->getParentException(), WE0_0);
+  EXPECT_EQ(WE0_0_0->getExceptionDepth(), (unsigned)3);
+
+  auto *MBB7 = MF->getBlockNumbered(7);
+  WE0_0_0 = WEI.getExceptionFor(MBB7);
+  ASSERT_TRUE(WE0_0_0);
+  EXPECT_EQ(WE0_0_0->getEHPad(), MBB6);
+}