[wasm][interpreter][eh] Add rethrow with immediate

When there are multiple nested catch blocks, the rethrow immediate
disambiguates which catch block to take the exception from. We
add a FixedArray to keep track of exceptions that are currently
in scope, and compute the mappings between rethrow/catch instructions
and the index to fetch/store the exception from/to in the FixedArray
during pre-processing.

R=clemensb@chromium.org

Bug: v8:8091
Change-Id: If55242c551f42262c790b5bf3f1543a003280623
Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/2695388
Commit-Queue: Thibaud Michaud <thibaudm@chromium.org>
Reviewed-by: Clemens Backes <clemensb@chromium.org>
Cr-Commit-Position: refs/heads/master@{#72768}

src/wasm/function-body-decoder-impl.h

@@ -2034,7 +2034,6 @@ class WasmDecoder : public Decoder {
       case kExprBrIf:
       case kExprBrTable:
       case kExprIf:
-      case kExprRethrow:
         return {1, 0};
       case kExprLocalGet:
       case kExprGlobalGet:
@@ -2072,6 +2071,7 @@ class WasmDecoder : public Decoder {
       case kExprTry:
       case kExprCatch:
       case kExprDelegate:
+      case kExprRethrow:
       case kExprNop:
       case kExprNopForTestingUnsupportedInLiftoff:
       case kExprReturn:

test/cctest/wasm/test-run-wasm-exceptions.cc

@@ -187,6 +187,41 @@ WASM_EXEC_TEST(TryDelegate) {
   }
 }
 
+WASM_EXEC_TEST(TryCatchRethrow) {
+  TestSignatures sigs;
+  EXPERIMENTAL_FLAG_SCOPE(eh);
+  WasmRunner<uint32_t, uint32_t> r(execution_tier);
+  uint32_t except1 = r.builder().AddException(sigs.v_v());
+  uint32_t except2 = r.builder().AddException(sigs.v_v());
+  constexpr uint32_t kResult0 = 23;
+  constexpr uint32_t kResult1 = 42;
+  constexpr uint32_t kUnreachable = 51;
+
+  // Build the main test function.
+  BUILD(r,
+        WASM_TRY_CATCH_CATCH_T(
+            kWasmI32,
+            WASM_TRY_CATCH_T(
+                kWasmI32, WASM_THROW(except2),
+                WASM_TRY_CATCH_T(
+                    kWasmI32, WASM_THROW(except1),
+                    WASM_STMTS(WASM_I32V(kUnreachable),
+                               WASM_IF_ELSE(WASM_I32_EQZ(WASM_LOCAL_GET(0)),
+                                            WASM_RETHROW(1), WASM_RETHROW(2))),
+                    except1),
+                except2),
+            except1, WASM_I32V(kResult0), except2, WASM_I32V(kResult1)));
+
+  if (execution_tier != TestExecutionTier::kInterpreter) {
+    // Need to call through JS to allow for creation of stack traces.
+    r.CheckCallViaJS(kResult0, 0);
+    r.CheckCallViaJS(kResult1, 1);
+  } else {
+    CHECK_EQ(kResult0, r.CallInterpreter(0));
+    CHECK_EQ(kResult1, r.CallInterpreter(1));
+  }
+}
+
 WASM_EXEC_TEST(TryDelegateToCaller) {
   TestSignatures sigs;
   EXPERIMENTAL_FLAG_SCOPE(eh);

test/common/wasm/wasm-interpreter.h

@@ -41,6 +41,7 @@ struct ControlTransferEntry {
 
 struct CatchControlTransferEntry : public ControlTransferEntry {
   int exception_index;
+  int target_control_index;
 };
 
 struct ControlTransferMap {

test/common/wasm/wasm-macro-gen.h

@@ -183,6 +183,10 @@
 #define WASM_TRY_CATCH_T(t, trystmt, catchstmt, except)                    \
   kExprTry, static_cast<byte>((t).value_type_code()), trystmt, kExprCatch, \
       except, catchstmt, kExprEnd
+#define WASM_TRY_CATCH_CATCH_T(t, trystmt, except1, catchstmt1, except2,   \
+                               catchstmt2)                                 \
+  kExprTry, static_cast<byte>((t).value_type_code()), trystmt, kExprCatch, \
+      except1, catchstmt1, kExprCatch, except2, catchstmt2, kExprEnd
 #define WASM_TRY_CATCH_R(t, trystmt, catchstmt) \
   kExprTry, WASM_REF_TYPE(t), trystmt, kExprCatch, catchstmt, kExprEnd
 #define WASM_TRY_CATCH_ALL_T(t, trystmt, catchstmt)                       \
@@ -468,6 +472,7 @@ inline WasmOpcode LoadStoreOpcodeOf(MachineType type, bool store) {
   index, val,                                                               \
       static_cast<byte>(v8::internal::wasm::LoadStoreOpcodeOf(type, true)), \
       alignment, ZERO_OFFSET
+#define WASM_RETHROW(index) kExprRethrow, static_cast<byte>(index)
 
 #define WASM_CALL_FUNCTION0(index) kExprCallFunction, static_cast<byte>(index)
 #define WASM_CALL_FUNCTION(index, ...) \