;; NOTE: Assertions have been generated by update_lit_checks.py --all-items and should not be edited.
;; RUN: wasm-opt %s -all --translate-to-exnref -S -o - | filecheck %s
;; RUN: wasm-opt %s -all --translate-to-exnref -S -o %t
;; RUN: wasm-opt %t -all --optimize-level=3 --generate-stack-ir --optimize-stack-ir --print-stack-ir | filecheck %s --check-prefix STACKIR-OPT

(module
  ;; CHECK:      (type $0 (func (result i32 i64)))

  ;; CHECK:      (type $1 (func))

  ;; CHECK:      (type $2 (func (result i32)))

  ;; CHECK:      (type $3 (func (result i32 (ref exn))))

  ;; CHECK:      (type $4 (func (result i32 i64 (ref exn))))

  ;; CHECK:      (type $5 (func (param i32)))

  ;; CHECK:      (type $6 (func (param i32 i64)))

  ;; CHECK:      (tag $e-empty (type $1))
  ;; STACKIR-OPT:      (type $0 (func (result i32 i64)))

  ;; STACKIR-OPT:      (type $1 (func))

  ;; STACKIR-OPT:      (type $2 (func (result i32)))

  ;; STACKIR-OPT:      (type $3 (func (result i32 (ref exn))))

  ;; STACKIR-OPT:      (type $4 (func (result i32 i64 (ref exn))))

  ;; STACKIR-OPT:      (type $5 (func (param i32)))

  ;; STACKIR-OPT:      (type $6 (func (param i32 i64)))

  ;; STACKIR-OPT:      (tag $e-empty (type $1))
  (tag $e-empty)
  ;; CHECK:      (tag $e-i32 (type $5) (param i32))
  ;; STACKIR-OPT:      (tag $e-i32 (type $5) (param i32))
  (tag $e-i32 (param i32))
  ;; CHECK:      (tag $e-i32-i64 (type $6) (param i32 i64))
  ;; STACKIR-OPT:      (tag $e-i32-i64 (type $6) (param i32 i64))
  (tag $e-i32-i64 (param i32 i64))

  ;; CHECK:      (func $foo (type $1)
  ;; CHECK-NEXT: )
  ;; STACKIR-OPT:      (func $foo (type $1)
  ;; STACKIR-OPT-NEXT: )
  (func $foo)
  ;; CHECK:      (func $bar (type $1)
  ;; CHECK-NEXT: )
  ;; STACKIR-OPT:      (func $bar (type $1)
  ;; STACKIR-OPT-NEXT: )
  (func $bar)
  ;; CHECK:      (func $baz (type $1)
  ;; CHECK-NEXT: )
  ;; STACKIR-OPT:      (func $baz (type $1)
  ;; STACKIR-OPT-NEXT: )
  (func $baz)

  ;; ---------------------------------------------------------------------------
  ;; Basic tests for all combinations of try body's type (none, single, and
  ;; tuple) and the catch's tag type (none, single, and tuple) and with /
  ;; without rethrows

  ;; CHECK:      (func $try-none-tag-none (type $1)
  ;; CHECK-NEXT:  (block $outer0
  ;; CHECK-NEXT:   (block $catch_all2
  ;; CHECK-NEXT:    (block $catch1
  ;; CHECK-NEXT:     (try_table (catch $e-empty $catch1) (catch_all $catch_all2)
  ;; CHECK-NEXT:      (call $foo)
  ;; CHECK-NEXT:     )
  ;; CHECK-NEXT:     (br $outer0)
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:    (call $foo)
  ;; CHECK-NEXT:    (br $outer0)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:   (call $bar)
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  ;; STACKIR-OPT:      (func $try-none-tag-none (type $1)
  ;; STACKIR-OPT-NEXT:  block $outer0
  ;; STACKIR-OPT-NEXT:   block $catch_all2
  ;; STACKIR-OPT-NEXT:    block $catch1
  ;; STACKIR-OPT-NEXT:     try_table (catch $e-empty $catch1) (catch_all $catch_all2)
  ;; STACKIR-OPT-NEXT:      call $foo
  ;; STACKIR-OPT-NEXT:     end
  ;; STACKIR-OPT-NEXT:     br $outer0
  ;; STACKIR-OPT-NEXT:    end
  ;; STACKIR-OPT-NEXT:    call $foo
  ;; STACKIR-OPT-NEXT:    br $outer0
  ;; STACKIR-OPT-NEXT:   end
  ;; STACKIR-OPT-NEXT:   call $bar
  ;; STACKIR-OPT-NEXT:  end
  ;; STACKIR-OPT-NEXT: )
  (func $try-none-tag-none
    ;; try's type is none and catch's tag type is none
    (try $l0
      (do
        (call $foo)
      )
      (catch $e-empty ;; converted to catch
        (call $foo)
      )
      (catch_all      ;; converted to catch_all
        (call $bar)
      )
    )
  )

  ;; CHECK:      (func $try-none-tag-none-with-rethrow (type $1)
  ;; CHECK-NEXT:  (local $0 exnref)
  ;; CHECK-NEXT:  (block $outer0
  ;; CHECK-NEXT:   (local.set $0
  ;; CHECK-NEXT:    (block $catch_all2 (result (ref exn))
  ;; CHECK-NEXT:     (local.set $0
  ;; CHECK-NEXT:      (block $catch1 (result (ref exn))
  ;; CHECK-NEXT:       (try_table (catch_ref $e-empty $catch1) (catch_all_ref $catch_all2)
  ;; CHECK-NEXT:        (call $foo)
  ;; CHECK-NEXT:       )
  ;; CHECK-NEXT:       (br $outer0)
  ;; CHECK-NEXT:      )
  ;; CHECK-NEXT:     )
  ;; CHECK-NEXT:     (throw_ref
  ;; CHECK-NEXT:      (local.get $0)
  ;; CHECK-NEXT:     )
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:   (throw_ref
  ;; CHECK-NEXT:    (local.get $0)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  ;; STACKIR-OPT:      (func $try-none-tag-none-with-rethrow (type $1)
  ;; STACKIR-OPT-NEXT:  (local $0 exnref)
  ;; STACKIR-OPT-NEXT:  block $outer0
  ;; STACKIR-OPT-NEXT:   block $catch_all2 (result (ref exn))
  ;; STACKIR-OPT-NEXT:    block $catch1 (result (ref exn))
  ;; STACKIR-OPT-NEXT:     try_table (catch_ref $e-empty $catch1) (catch_all_ref $catch_all2)
  ;; STACKIR-OPT-NEXT:      call $foo
  ;; STACKIR-OPT-NEXT:     end
  ;; STACKIR-OPT-NEXT:     br $outer0
  ;; STACKIR-OPT-NEXT:    end
  ;; STACKIR-OPT-NEXT:    throw_ref
  ;; STACKIR-OPT-NEXT:   end
  ;; STACKIR-OPT-NEXT:   throw_ref
  ;; STACKIR-OPT-NEXT:  end
  ;; STACKIR-OPT-NEXT: )
  (func $try-none-tag-none-with-rethrow
    ;; try's type is none and catch's tag type is none, and there are rethrows
    (try $l0
      (do
        (call $foo)
      )
      (catch $e-empty ;; converted to catch_ref, because of rethrow
        (rethrow $l0)
      )
      (catch_all      ;; converted to catch_all_ref, because of rethrow
        (rethrow $l0)
      )
    )
  )

  ;; CHECK:      (func $try-none-tag-single (type $1)
  ;; CHECK-NEXT:  (local $0 i32)
  ;; CHECK-NEXT:  (block $outer0
  ;; CHECK-NEXT:   (block $catch_all2
  ;; CHECK-NEXT:    (local.set $0
  ;; CHECK-NEXT:     (block $catch1 (result i32)
  ;; CHECK-NEXT:      (try_table (catch $e-i32 $catch1) (catch_all $catch_all2)
  ;; CHECK-NEXT:       (call $foo)
  ;; CHECK-NEXT:      )
  ;; CHECK-NEXT:      (br $outer0)
  ;; CHECK-NEXT:     )
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:    (drop
  ;; CHECK-NEXT:     (local.get $0)
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:    (br $outer0)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:   (call $bar)
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  ;; STACKIR-OPT:      (func $try-none-tag-single (type $1)
  ;; STACKIR-OPT-NEXT:  (local $0 i32)
  ;; STACKIR-OPT-NEXT:  block $outer0
  ;; STACKIR-OPT-NEXT:   block $catch_all2
  ;; STACKIR-OPT-NEXT:    block $catch1 (result i32)
  ;; STACKIR-OPT-NEXT:     try_table (catch $e-i32 $catch1) (catch_all $catch_all2)
  ;; STACKIR-OPT-NEXT:      call $foo
  ;; STACKIR-OPT-NEXT:     end
  ;; STACKIR-OPT-NEXT:     br $outer0
  ;; STACKIR-OPT-NEXT:    end
  ;; STACKIR-OPT-NEXT:    drop
  ;; STACKIR-OPT-NEXT:    br $outer0
  ;; STACKIR-OPT-NEXT:   end
  ;; STACKIR-OPT-NEXT:   call $bar
  ;; STACKIR-OPT-NEXT:  end
  ;; STACKIR-OPT-NEXT: )
  (func $try-none-tag-single
    ;; try's type is none and catch's tag type is single
    (try $l0
      (do
        (call $foo)
      )
      (catch $e-i32
        (drop
          (pop i32)
        )
      )
      (catch_all
        (call $bar)
      )
    )
  )

  ;; CHECK:      (func $try-none-tag-single-with-rethrow (type $1)
  ;; CHECK-NEXT:  (local $0 exnref)
  ;; CHECK-NEXT:  (local $1 i32)
  ;; CHECK-NEXT:  (local $2 (tuple i32 (ref exn)))
  ;; CHECK-NEXT:  (block $outer0
  ;; CHECK-NEXT:   (local.set $0
  ;; CHECK-NEXT:    (block $catch_all2 (result (ref exn))
  ;; CHECK-NEXT:     (local.set $2
  ;; CHECK-NEXT:      (block $catch1 (type $3) (result i32 (ref exn))
  ;; CHECK-NEXT:       (try_table (catch_ref $e-i32 $catch1) (catch_all_ref $catch_all2)
  ;; CHECK-NEXT:        (call $foo)
  ;; CHECK-NEXT:       )
  ;; CHECK-NEXT:       (br $outer0)
  ;; CHECK-NEXT:      )
  ;; CHECK-NEXT:     )
  ;; CHECK-NEXT:     (local.set $1
  ;; CHECK-NEXT:      (tuple.extract 2 0
  ;; CHECK-NEXT:       (local.get $2)
  ;; CHECK-NEXT:      )
  ;; CHECK-NEXT:     )
  ;; CHECK-NEXT:     (local.set $0
  ;; CHECK-NEXT:      (tuple.extract 2 1
  ;; CHECK-NEXT:       (local.get $2)
  ;; CHECK-NEXT:      )
  ;; CHECK-NEXT:     )
  ;; CHECK-NEXT:     (block
  ;; CHECK-NEXT:      (drop
  ;; CHECK-NEXT:       (local.get $1)
  ;; CHECK-NEXT:      )
  ;; CHECK-NEXT:      (throw_ref
  ;; CHECK-NEXT:       (local.get $0)
  ;; CHECK-NEXT:      )
  ;; CHECK-NEXT:     )
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:   (throw_ref
  ;; CHECK-NEXT:    (local.get $0)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  ;; STACKIR-OPT:      (func $try-none-tag-single-with-rethrow (type $1)
  ;; STACKIR-OPT-NEXT:  (local $0 exnref)
  ;; STACKIR-OPT-NEXT:  (local $1 i32)
  ;; STACKIR-OPT-NEXT:  (local $2 (tuple i32 (ref exn)))
  ;; STACKIR-OPT-NEXT:  block $outer0
  ;; STACKIR-OPT-NEXT:   block $catch_all2 (result (ref exn))
  ;; STACKIR-OPT-NEXT:    block $catch1 (type $3) (result i32 (ref exn))
  ;; STACKIR-OPT-NEXT:     try_table (catch_ref $e-i32 $catch1) (catch_all_ref $catch_all2)
  ;; STACKIR-OPT-NEXT:      call $foo
  ;; STACKIR-OPT-NEXT:     end
  ;; STACKIR-OPT-NEXT:     br $outer0
  ;; STACKIR-OPT-NEXT:    end
  ;; STACKIR-OPT-NEXT:    local.set $2
  ;; STACKIR-OPT-NEXT:    local.get $2
  ;; STACKIR-OPT-NEXT:    tuple.extract 2 0
  ;; STACKIR-OPT-NEXT:    local.get $2
  ;; STACKIR-OPT-NEXT:    tuple.extract 2 1
  ;; STACKIR-OPT-NEXT:    local.set $0
  ;; STACKIR-OPT-NEXT:    drop
  ;; STACKIR-OPT-NEXT:    local.get $0
  ;; STACKIR-OPT-NEXT:    throw_ref
  ;; STACKIR-OPT-NEXT:   end
  ;; STACKIR-OPT-NEXT:   throw_ref
  ;; STACKIR-OPT-NEXT:  end
  ;; STACKIR-OPT-NEXT: )
  (func $try-none-tag-single-with-rethrow
    ;; try's type is none and catch's tag type is single, and there are rethrows
    (try $l0
      (do
        (call $foo)
      )
      (catch $e-i32
        (drop
          (pop i32)
        )
        (rethrow $l0)
      )
      (catch_all
        (rethrow $l0)
      )
    )
  )

  ;; CHECK:      (func $try-none-tag-tuple (type $1)
  ;; CHECK-NEXT:  (local $0 (tuple i32 i64))
  ;; CHECK-NEXT:  (block $outer0
  ;; CHECK-NEXT:   (block $catch_all2
  ;; CHECK-NEXT:    (local.set $0
  ;; CHECK-NEXT:     (block $catch1 (type $0) (result i32 i64)
  ;; CHECK-NEXT:      (try_table (catch $e-i32-i64 $catch1) (catch_all $catch_all2)
  ;; CHECK-NEXT:       (call $foo)
  ;; CHECK-NEXT:      )
  ;; CHECK-NEXT:      (br $outer0)
  ;; CHECK-NEXT:     )
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:    (tuple.drop 2
  ;; CHECK-NEXT:     (local.get $0)
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:    (br $outer0)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:   (call $bar)
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  ;; STACKIR-OPT:      (func $try-none-tag-tuple (type $1)
  ;; STACKIR-OPT-NEXT:  (local $0 (tuple i32 i64))
  ;; STACKIR-OPT-NEXT:  block $outer0
  ;; STACKIR-OPT-NEXT:   block $catch_all2
  ;; STACKIR-OPT-NEXT:    block $catch1 (type $0) (result i32 i64)
  ;; STACKIR-OPT-NEXT:     try_table (catch $e-i32-i64 $catch1) (catch_all $catch_all2)
  ;; STACKIR-OPT-NEXT:      call $foo
  ;; STACKIR-OPT-NEXT:     end
  ;; STACKIR-OPT-NEXT:     br $outer0
  ;; STACKIR-OPT-NEXT:    end
  ;; STACKIR-OPT-NEXT:    local.set $0
  ;; STACKIR-OPT-NEXT:    local.get $0
  ;; STACKIR-OPT-NEXT:    tuple.drop 2
  ;; STACKIR-OPT-NEXT:    br $outer0
  ;; STACKIR-OPT-NEXT:   end
  ;; STACKIR-OPT-NEXT:   call $bar
  ;; STACKIR-OPT-NEXT:  end
  ;; STACKIR-OPT-NEXT: )
  (func $try-none-tag-tuple
    ;; try's type is none and catch's tag type is tuple
    (try $l0
      (do
        (call $foo)
      )
      (catch $e-i32-i64
        (tuple.drop 2
          (pop (tuple i32 i64))
        )
      )
      (catch_all
        (call $bar)
      )
    )
  )

  ;; CHECK:      (func $try-none-tag-tuple-with-rethrow (type $1)
  ;; CHECK-NEXT:  (local $0 exnref)
  ;; CHECK-NEXT:  (local $1 (tuple i32 i64))
  ;; CHECK-NEXT:  (local $2 (tuple i32 i64 (ref exn)))
  ;; CHECK-NEXT:  (block $outer0
  ;; CHECK-NEXT:   (local.set $0
  ;; CHECK-NEXT:    (block $catch_all2 (result (ref exn))
  ;; CHECK-NEXT:     (local.set $2
  ;; CHECK-NEXT:      (block $catch1 (type $4) (result i32 i64 (ref exn))
  ;; CHECK-NEXT:       (try_table (catch_ref $e-i32-i64 $catch1) (catch_all_ref $catch_all2)
  ;; CHECK-NEXT:        (call $foo)
  ;; CHECK-NEXT:       )
  ;; CHECK-NEXT:       (br $outer0)
  ;; CHECK-NEXT:      )
  ;; CHECK-NEXT:     )
  ;; CHECK-NEXT:     (local.set $1
  ;; CHECK-NEXT:      (tuple.make 2
  ;; CHECK-NEXT:       (tuple.extract 3 0
  ;; CHECK-NEXT:        (local.get $2)
  ;; CHECK-NEXT:       )
  ;; CHECK-NEXT:       (tuple.extract 3 1
  ;; CHECK-NEXT:        (local.get $2)
  ;; CHECK-NEXT:       )
  ;; CHECK-NEXT:      )
  ;; CHECK-NEXT:     )
  ;; CHECK-NEXT:     (local.set $0
  ;; CHECK-NEXT:      (tuple.extract 3 2
  ;; CHECK-NEXT:       (local.get $2)
  ;; CHECK-NEXT:      )
  ;; CHECK-NEXT:     )
  ;; CHECK-NEXT:     (block
  ;; CHECK-NEXT:      (tuple.drop 2
  ;; CHECK-NEXT:       (local.get $1)
  ;; CHECK-NEXT:      )
  ;; CHECK-NEXT:      (throw_ref
  ;; CHECK-NEXT:       (local.get $0)
  ;; CHECK-NEXT:      )
  ;; CHECK-NEXT:     )
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:   (throw_ref
  ;; CHECK-NEXT:    (local.get $0)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  ;; STACKIR-OPT:      (func $try-none-tag-tuple-with-rethrow (type $1)
  ;; STACKIR-OPT-NEXT:  (local $0 exnref)
  ;; STACKIR-OPT-NEXT:  (local $1 (tuple i32 i64))
  ;; STACKIR-OPT-NEXT:  (local $2 (tuple i32 i64 (ref exn)))
  ;; STACKIR-OPT-NEXT:  block $outer0
  ;; STACKIR-OPT-NEXT:   block $catch_all2 (result (ref exn))
  ;; STACKIR-OPT-NEXT:    block $catch1 (type $4) (result i32 i64 (ref exn))
  ;; STACKIR-OPT-NEXT:     try_table (catch_ref $e-i32-i64 $catch1) (catch_all_ref $catch_all2)
  ;; STACKIR-OPT-NEXT:      call $foo
  ;; STACKIR-OPT-NEXT:     end
  ;; STACKIR-OPT-NEXT:     br $outer0
  ;; STACKIR-OPT-NEXT:    end
  ;; STACKIR-OPT-NEXT:    local.set $2
  ;; STACKIR-OPT-NEXT:    local.get $2
  ;; STACKIR-OPT-NEXT:    tuple.extract 3 0
  ;; STACKIR-OPT-NEXT:    local.get $2
  ;; STACKIR-OPT-NEXT:    tuple.extract 3 1
  ;; STACKIR-OPT-NEXT:    tuple.make 2
  ;; STACKIR-OPT-NEXT:    local.set $1
  ;; STACKIR-OPT-NEXT:    local.get $2
  ;; STACKIR-OPT-NEXT:    tuple.extract 3 2
  ;; STACKIR-OPT-NEXT:    local.get $1
  ;; STACKIR-OPT-NEXT:    tuple.drop 2
  ;; STACKIR-OPT-NEXT:    throw_ref
  ;; STACKIR-OPT-NEXT:   end
  ;; STACKIR-OPT-NEXT:   throw_ref
  ;; STACKIR-OPT-NEXT:  end
  ;; STACKIR-OPT-NEXT: )
  (func $try-none-tag-tuple-with-rethrow
    ;; try's type is none and catch's tag type is tuple, and there are rethrows
    (try $l0
      (do
        (call $foo)
      )
      (catch $e-i32-i64
        (tuple.drop 2
          (pop (tuple i32 i64))
        )
        (rethrow $l0)
      )
      (catch_all
        (rethrow $l0)
      )
    )
  )

  ;; CHECK:      (func $try-single-tag-none (type $2) (result i32)
  ;; CHECK-NEXT:  (block $outer0 (result i32)
  ;; CHECK-NEXT:   (block $catch_all2
  ;; CHECK-NEXT:    (block $catch1
  ;; CHECK-NEXT:     (br $outer0
  ;; CHECK-NEXT:      (try_table (result i32) (catch $e-empty $catch1) (catch_all $catch_all2)
  ;; CHECK-NEXT:       (call $foo)
  ;; CHECK-NEXT:       (i32.const 0)
  ;; CHECK-NEXT:      )
  ;; CHECK-NEXT:     )
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:    (br $outer0
  ;; CHECK-NEXT:     (i32.const 1)
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:   (i32.const 2)
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  ;; STACKIR-OPT:      (func $try-single-tag-none (type $2) (result i32)
  ;; STACKIR-OPT-NEXT:  block $outer0 (result i32)
  ;; STACKIR-OPT-NEXT:   block $catch_all2
  ;; STACKIR-OPT-NEXT:    block $catch1
  ;; STACKIR-OPT-NEXT:     try_table (result i32) (catch $e-empty $catch1) (catch_all $catch_all2)
  ;; STACKIR-OPT-NEXT:      call $foo
  ;; STACKIR-OPT-NEXT:      i32.const 0
  ;; STACKIR-OPT-NEXT:     end
  ;; STACKIR-OPT-NEXT:     br $outer0
  ;; STACKIR-OPT-NEXT:    end
  ;; STACKIR-OPT-NEXT:    i32.const 1
  ;; STACKIR-OPT-NEXT:    br $outer0
  ;; STACKIR-OPT-NEXT:   end
  ;; STACKIR-OPT-NEXT:   i32.const 2
  ;; STACKIR-OPT-NEXT:  end
  ;; STACKIR-OPT-NEXT: )
  (func $try-single-tag-none (result i32)
    ;; try's type is single and catch's tag type is none
    (try $l0 (result i32)
      (do
        (call $foo)
        (i32.const 0)
      )
      (catch $e-empty
        (i32.const 1)
      )
      (catch_all
        (i32.const 2)
      )
    )
  )

  ;; CHECK:      (func $try-single-tag-none-with-rethrow (type $2) (result i32)
  ;; CHECK-NEXT:  (local $0 exnref)
  ;; CHECK-NEXT:  (block $outer0 (result i32)
  ;; CHECK-NEXT:   (local.set $0
  ;; CHECK-NEXT:    (block $catch_all2 (result (ref exn))
  ;; CHECK-NEXT:     (local.set $0
  ;; CHECK-NEXT:      (block $catch1 (result (ref exn))
  ;; CHECK-NEXT:       (br $outer0
  ;; CHECK-NEXT:        (try_table (result i32) (catch_ref $e-empty $catch1) (catch_all_ref $catch_all2)
  ;; CHECK-NEXT:         (call $foo)
  ;; CHECK-NEXT:         (i32.const 0)
  ;; CHECK-NEXT:        )
  ;; CHECK-NEXT:       )
  ;; CHECK-NEXT:      )
  ;; CHECK-NEXT:     )
  ;; CHECK-NEXT:     (throw_ref
  ;; CHECK-NEXT:      (local.get $0)
  ;; CHECK-NEXT:     )
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:   (throw_ref
  ;; CHECK-NEXT:    (local.get $0)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  ;; STACKIR-OPT:      (func $try-single-tag-none-with-rethrow (type $2) (result i32)
  ;; STACKIR-OPT-NEXT:  (local $0 exnref)
  ;; STACKIR-OPT-NEXT:  block $outer0 (result i32)
  ;; STACKIR-OPT-NEXT:   block $catch_all2 (result (ref exn))
  ;; STACKIR-OPT-NEXT:    block $catch1 (result (ref exn))
  ;; STACKIR-OPT-NEXT:     try_table (result i32) (catch_ref $e-empty $catch1) (catch_all_ref $catch_all2)
  ;; STACKIR-OPT-NEXT:      call $foo
  ;; STACKIR-OPT-NEXT:      i32.const 0
  ;; STACKIR-OPT-NEXT:     end
  ;; STACKIR-OPT-NEXT:     br $outer0
  ;; STACKIR-OPT-NEXT:    end
  ;; STACKIR-OPT-NEXT:    throw_ref
  ;; STACKIR-OPT-NEXT:   end
  ;; STACKIR-OPT-NEXT:   throw_ref
  ;; STACKIR-OPT-NEXT:  end
  ;; STACKIR-OPT-NEXT: )
  (func $try-single-tag-none-with-rethrow (result i32)
    ;; try's type is single and catch's tag type is none, and there are rethrows
    (try $l0 (result i32)
      (do
        (call $foo)
        (i32.const 0)
      )
      (catch $e-empty
        (rethrow $l0)
      )
      (catch_all
        (rethrow $l0)
      )
    )
  )

  ;; CHECK:      (func $try-single-tag-single (type $2) (result i32)
  ;; CHECK-NEXT:  (local $0 i32)
  ;; CHECK-NEXT:  (block $outer0 (result i32)
  ;; CHECK-NEXT:   (block $catch_all2
  ;; CHECK-NEXT:    (local.set $0
  ;; CHECK-NEXT:     (block $catch1 (result i32)
  ;; CHECK-NEXT:      (br $outer0
  ;; CHECK-NEXT:       (try_table (result i32) (catch $e-i32 $catch1) (catch_all $catch_all2)
  ;; CHECK-NEXT:        (call $foo)
  ;; CHECK-NEXT:        (i32.const 0)
  ;; CHECK-NEXT:       )
  ;; CHECK-NEXT:      )
  ;; CHECK-NEXT:     )
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:    (br $outer0
  ;; CHECK-NEXT:     (local.get $0)
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:   (i32.const 2)
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  ;; STACKIR-OPT:      (func $try-single-tag-single (type $2) (result i32)
  ;; STACKIR-OPT-NEXT:  (local $0 i32)
  ;; STACKIR-OPT-NEXT:  block $outer0 (result i32)
  ;; STACKIR-OPT-NEXT:   block $catch_all2
  ;; STACKIR-OPT-NEXT:    block $catch1 (result i32)
  ;; STACKIR-OPT-NEXT:     try_table (result i32) (catch $e-i32 $catch1) (catch_all $catch_all2)
  ;; STACKIR-OPT-NEXT:      call $foo
  ;; STACKIR-OPT-NEXT:      i32.const 0
  ;; STACKIR-OPT-NEXT:     end
  ;; STACKIR-OPT-NEXT:     br $outer0
  ;; STACKIR-OPT-NEXT:    end
  ;; STACKIR-OPT-NEXT:    br $outer0
  ;; STACKIR-OPT-NEXT:   end
  ;; STACKIR-OPT-NEXT:   i32.const 2
  ;; STACKIR-OPT-NEXT:  end
  ;; STACKIR-OPT-NEXT: )
  (func $try-single-tag-single (result i32)
    ;; try's type is single and catch's tag type is single
    (try $l0 (result i32)
      (do
        (call $foo)
        (i32.const 0)
      )
      (catch $e-i32
        (pop i32)
      )
      (catch_all
        (i32.const 2)
      )
    )
  )

  ;; CHECK:      (func $try-single-tag-single-with-rethrow (type $2) (result i32)
  ;; CHECK-NEXT:  (local $0 exnref)
  ;; CHECK-NEXT:  (local $1 i32)
  ;; CHECK-NEXT:  (local $2 (tuple i32 (ref exn)))
  ;; CHECK-NEXT:  (block $outer0 (result i32)
  ;; CHECK-NEXT:   (local.set $0
  ;; CHECK-NEXT:    (block $catch_all2 (result (ref exn))
  ;; CHECK-NEXT:     (local.set $2
  ;; CHECK-NEXT:      (block $catch1 (type $3) (result i32 (ref exn))
  ;; CHECK-NEXT:       (br $outer0
  ;; CHECK-NEXT:        (try_table (result i32) (catch_ref $e-i32 $catch1) (catch_all_ref $catch_all2)
  ;; CHECK-NEXT:         (call $foo)
  ;; CHECK-NEXT:         (i32.const 0)
  ;; CHECK-NEXT:        )
  ;; CHECK-NEXT:       )
  ;; CHECK-NEXT:      )
  ;; CHECK-NEXT:     )
  ;; CHECK-NEXT:     (local.set $1
  ;; CHECK-NEXT:      (tuple.extract 2 0
  ;; CHECK-NEXT:       (local.get $2)
  ;; CHECK-NEXT:      )
  ;; CHECK-NEXT:     )
  ;; CHECK-NEXT:     (local.set $0
  ;; CHECK-NEXT:      (tuple.extract 2 1
  ;; CHECK-NEXT:       (local.get $2)
  ;; CHECK-NEXT:      )
  ;; CHECK-NEXT:     )
  ;; CHECK-NEXT:     (br $outer0
  ;; CHECK-NEXT:      (block (result i32)
  ;; CHECK-NEXT:       (drop
  ;; CHECK-NEXT:        (local.get $1)
  ;; CHECK-NEXT:       )
  ;; CHECK-NEXT:       (throw_ref
  ;; CHECK-NEXT:        (local.get $0)
  ;; CHECK-NEXT:       )
  ;; CHECK-NEXT:      )
  ;; CHECK-NEXT:     )
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:   (throw_ref
  ;; CHECK-NEXT:    (local.get $0)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  ;; STACKIR-OPT:      (func $try-single-tag-single-with-rethrow (type $2) (result i32)
  ;; STACKIR-OPT-NEXT:  (local $0 exnref)
  ;; STACKIR-OPT-NEXT:  (local $1 i32)
  ;; STACKIR-OPT-NEXT:  (local $2 (tuple i32 (ref exn)))
  ;; STACKIR-OPT-NEXT:  block $outer0 (result i32)
  ;; STACKIR-OPT-NEXT:   block $catch_all2 (result (ref exn))
  ;; STACKIR-OPT-NEXT:    block $catch1 (type $3) (result i32 (ref exn))
  ;; STACKIR-OPT-NEXT:     try_table (result i32) (catch_ref $e-i32 $catch1) (catch_all_ref $catch_all2)
  ;; STACKIR-OPT-NEXT:      call $foo
  ;; STACKIR-OPT-NEXT:      i32.const 0
  ;; STACKIR-OPT-NEXT:     end
  ;; STACKIR-OPT-NEXT:     br $outer0
  ;; STACKIR-OPT-NEXT:    end
  ;; STACKIR-OPT-NEXT:    local.set $2
  ;; STACKIR-OPT-NEXT:    local.get $2
  ;; STACKIR-OPT-NEXT:    tuple.extract 2 0
  ;; STACKIR-OPT-NEXT:    local.get $2
  ;; STACKIR-OPT-NEXT:    tuple.extract 2 1
  ;; STACKIR-OPT-NEXT:    local.set $0
  ;; STACKIR-OPT-NEXT:    drop
  ;; STACKIR-OPT-NEXT:    local.get $0
  ;; STACKIR-OPT-NEXT:    throw_ref
  ;; STACKIR-OPT-NEXT:   end
  ;; STACKIR-OPT-NEXT:   throw_ref
  ;; STACKIR-OPT-NEXT:  end
  ;; STACKIR-OPT-NEXT: )
  (func $try-single-tag-single-with-rethrow (result i32)
    ;; try's type is single and catch's tag type is single, and there are
    ;; rethrows
    (try $l0 (result i32)
      (do
        (call $foo)
        (i32.const 0)
      )
      (catch $e-i32
        (drop
          (pop i32)
        )
        (rethrow $l0)
      )
      (catch_all
        (rethrow $l0)
      )
    )
  )

  ;; CHECK:      (func $try-single-tag-tuple (type $2) (result i32)
  ;; CHECK-NEXT:  (local $0 (tuple i32 i64))
  ;; CHECK-NEXT:  (block $outer0 (result i32)
  ;; CHECK-NEXT:   (block $catch_all2
  ;; CHECK-NEXT:    (local.set $0
  ;; CHECK-NEXT:     (block $catch1 (type $0) (result i32 i64)
  ;; CHECK-NEXT:      (br $outer0
  ;; CHECK-NEXT:       (try_table (result i32) (catch $e-i32-i64 $catch1) (catch_all $catch_all2)
  ;; CHECK-NEXT:        (call $foo)
  ;; CHECK-NEXT:        (i32.const 0)
  ;; CHECK-NEXT:       )
  ;; CHECK-NEXT:      )
  ;; CHECK-NEXT:     )
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:    (br $outer0
  ;; CHECK-NEXT:     (block (result i32)
  ;; CHECK-NEXT:      (tuple.drop 2
  ;; CHECK-NEXT:       (local.get $0)
  ;; CHECK-NEXT:      )
  ;; CHECK-NEXT:      (i32.const 1)
  ;; CHECK-NEXT:     )
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:   (i32.const 2)
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  ;; STACKIR-OPT:      (func $try-single-tag-tuple (type $2) (result i32)
  ;; STACKIR-OPT-NEXT:  (local $0 (tuple i32 i64))
  ;; STACKIR-OPT-NEXT:  block $outer0 (result i32)
  ;; STACKIR-OPT-NEXT:   block $catch_all2
  ;; STACKIR-OPT-NEXT:    block $catch1 (type $0) (result i32 i64)
  ;; STACKIR-OPT-NEXT:     try_table (result i32) (catch $e-i32-i64 $catch1) (catch_all $catch_all2)
  ;; STACKIR-OPT-NEXT:      call $foo
  ;; STACKIR-OPT-NEXT:      i32.const 0
  ;; STACKIR-OPT-NEXT:     end
  ;; STACKIR-OPT-NEXT:     br $outer0
  ;; STACKIR-OPT-NEXT:    end
  ;; STACKIR-OPT-NEXT:    local.set $0
  ;; STACKIR-OPT-NEXT:    local.get $0
  ;; STACKIR-OPT-NEXT:    tuple.drop 2
  ;; STACKIR-OPT-NEXT:    i32.const 1
  ;; STACKIR-OPT-NEXT:    br $outer0
  ;; STACKIR-OPT-NEXT:   end
  ;; STACKIR-OPT-NEXT:   i32.const 2
  ;; STACKIR-OPT-NEXT:  end
  ;; STACKIR-OPT-NEXT: )
  (func $try-single-tag-tuple (result i32)
    ;; try's type is single and catch's tag type is tuple
    (try $l0 (result i32)
      (do
        (call $foo)
        (i32.const 0)
      )
      (catch $e-i32-i64
        (tuple.drop 2
          (pop (tuple i32 i64))
        )
        (i32.const 1)
      )
      (catch_all
        (i32.const 2)
      )
    )
  )

  ;; CHECK:      (func $try-single-tag-tuple-with-rethrow (type $2) (result i32)
  ;; CHECK-NEXT:  (local $0 exnref)
  ;; CHECK-NEXT:  (local $1 (tuple i32 i64))
  ;; CHECK-NEXT:  (local $2 (tuple i32 i64 (ref exn)))
  ;; CHECK-NEXT:  (block $outer0 (result i32)
  ;; CHECK-NEXT:   (local.set $0
  ;; CHECK-NEXT:    (block $catch_all2 (result (ref exn))
  ;; CHECK-NEXT:     (local.set $2
  ;; CHECK-NEXT:      (block $catch1 (type $4) (result i32 i64 (ref exn))
  ;; CHECK-NEXT:       (br $outer0
  ;; CHECK-NEXT:        (try_table (result i32) (catch_ref $e-i32-i64 $catch1) (catch_all_ref $catch_all2)
  ;; CHECK-NEXT:         (call $foo)
  ;; CHECK-NEXT:         (i32.const 0)
  ;; CHECK-NEXT:        )
  ;; CHECK-NEXT:       )
  ;; CHECK-NEXT:      )
  ;; CHECK-NEXT:     )
  ;; CHECK-NEXT:     (local.set $1
  ;; CHECK-NEXT:      (tuple.make 2
  ;; CHECK-NEXT:       (tuple.extract 3 0
  ;; CHECK-NEXT:        (local.get $2)
  ;; CHECK-NEXT:       )
  ;; CHECK-NEXT:       (tuple.extract 3 1
  ;; CHECK-NEXT:        (local.get $2)
  ;; CHECK-NEXT:       )
  ;; CHECK-NEXT:      )
  ;; CHECK-NEXT:     )
  ;; CHECK-NEXT:     (local.set $0
  ;; CHECK-NEXT:      (tuple.extract 3 2
  ;; CHECK-NEXT:       (local.get $2)
  ;; CHECK-NEXT:      )
  ;; CHECK-NEXT:     )
  ;; CHECK-NEXT:     (br $outer0
  ;; CHECK-NEXT:      (block (result i32)
  ;; CHECK-NEXT:       (tuple.drop 2
  ;; CHECK-NEXT:        (local.get $1)
  ;; CHECK-NEXT:       )
  ;; CHECK-NEXT:       (throw_ref
  ;; CHECK-NEXT:        (local.get $0)
  ;; CHECK-NEXT:       )
  ;; CHECK-NEXT:      )
  ;; CHECK-NEXT:     )
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:   (throw_ref
  ;; CHECK-NEXT:    (local.get $0)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  ;; STACKIR-OPT:      (func $try-single-tag-tuple-with-rethrow (type $2) (result i32)
  ;; STACKIR-OPT-NEXT:  (local $0 exnref)
  ;; STACKIR-OPT-NEXT:  (local $1 (tuple i32 i64))
  ;; STACKIR-OPT-NEXT:  (local $2 (tuple i32 i64 (ref exn)))
  ;; STACKIR-OPT-NEXT:  block $outer0 (result i32)
  ;; STACKIR-OPT-NEXT:   block $catch_all2 (result (ref exn))
  ;; STACKIR-OPT-NEXT:    block $catch1 (type $4) (result i32 i64 (ref exn))
  ;; STACKIR-OPT-NEXT:     try_table (result i32) (catch_ref $e-i32-i64 $catch1) (catch_all_ref $catch_all2)
  ;; STACKIR-OPT-NEXT:      call $foo
  ;; STACKIR-OPT-NEXT:      i32.const 0
  ;; STACKIR-OPT-NEXT:     end
  ;; STACKIR-OPT-NEXT:     br $outer0
  ;; STACKIR-OPT-NEXT:    end
  ;; STACKIR-OPT-NEXT:    local.set $2
  ;; STACKIR-OPT-NEXT:    local.get $2
  ;; STACKIR-OPT-NEXT:    tuple.extract 3 0
  ;; STACKIR-OPT-NEXT:    local.get $2
  ;; STACKIR-OPT-NEXT:    tuple.extract 3 1
  ;; STACKIR-OPT-NEXT:    tuple.make 2
  ;; STACKIR-OPT-NEXT:    local.set $1
  ;; STACKIR-OPT-NEXT:    local.get $2
  ;; STACKIR-OPT-NEXT:    tuple.extract 3 2
  ;; STACKIR-OPT-NEXT:    local.get $1
  ;; STACKIR-OPT-NEXT:    tuple.drop 2
  ;; STACKIR-OPT-NEXT:    throw_ref
  ;; STACKIR-OPT-NEXT:   end
  ;; STACKIR-OPT-NEXT:   throw_ref
  ;; STACKIR-OPT-NEXT:  end
  ;; STACKIR-OPT-NEXT: )
  (func $try-single-tag-tuple-with-rethrow (result i32)
    ;; try's type is single and catch's tag type is tuple, and there are
    ;; rethrows
    (try $l0 (result i32)
      (do
        (call $foo)
        (i32.const 0)
      )
      (catch $e-i32-i64
        (tuple.drop 2
          (pop (tuple i32 i64))
        )
        (rethrow $l0)
      )
      (catch_all
        (rethrow $l0)
      )
    )
  )

  ;; CHECK:      (func $try-tuple-tag-none (type $0) (result i32 i64)
  ;; CHECK-NEXT:  (block $outer0 (type $0) (result i32 i64)
  ;; CHECK-NEXT:   (block $catch_all2
  ;; CHECK-NEXT:    (block $catch1
  ;; CHECK-NEXT:     (br $outer0
  ;; CHECK-NEXT:      (try_table (type $0) (result i32 i64) (catch $e-empty $catch1) (catch_all $catch_all2)
  ;; CHECK-NEXT:       (call $foo)
  ;; CHECK-NEXT:       (tuple.make 2
  ;; CHECK-NEXT:        (i32.const 0)
  ;; CHECK-NEXT:        (i64.const 0)
  ;; CHECK-NEXT:       )
  ;; CHECK-NEXT:      )
  ;; CHECK-NEXT:     )
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:    (br $outer0
  ;; CHECK-NEXT:     (tuple.make 2
  ;; CHECK-NEXT:      (i32.const 1)
  ;; CHECK-NEXT:      (i64.const 1)
  ;; CHECK-NEXT:     )
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:   (tuple.make 2
  ;; CHECK-NEXT:    (i32.const 2)
  ;; CHECK-NEXT:    (i64.const 0)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  ;; STACKIR-OPT:      (func $try-tuple-tag-none (type $0) (result i32 i64)
  ;; STACKIR-OPT-NEXT:  block $outer0 (type $0) (result i32 i64)
  ;; STACKIR-OPT-NEXT:   block $catch_all2
  ;; STACKIR-OPT-NEXT:    block $catch1
  ;; STACKIR-OPT-NEXT:     try_table (type $0) (result i32 i64) (catch $e-empty $catch1) (catch_all $catch_all2)
  ;; STACKIR-OPT-NEXT:      call $foo
  ;; STACKIR-OPT-NEXT:      i32.const 0
  ;; STACKIR-OPT-NEXT:      i64.const 0
  ;; STACKIR-OPT-NEXT:      tuple.make 2
  ;; STACKIR-OPT-NEXT:     end
  ;; STACKIR-OPT-NEXT:     br $outer0
  ;; STACKIR-OPT-NEXT:    end
  ;; STACKIR-OPT-NEXT:    i32.const 1
  ;; STACKIR-OPT-NEXT:    i64.const 1
  ;; STACKIR-OPT-NEXT:    tuple.make 2
  ;; STACKIR-OPT-NEXT:    br $outer0
  ;; STACKIR-OPT-NEXT:   end
  ;; STACKIR-OPT-NEXT:   i32.const 2
  ;; STACKIR-OPT-NEXT:   i64.const 0
  ;; STACKIR-OPT-NEXT:   tuple.make 2
  ;; STACKIR-OPT-NEXT:  end
  ;; STACKIR-OPT-NEXT: )
  (func $try-tuple-tag-none (result i32 i64)
    ;; try's type is tuple and catch's tag type is none
    (try $l0 (result i32 i64)
      (do
        (call $foo)
        (tuple.make 2
          (i32.const 0)
          (i64.const 0)
        )
      )
      (catch $e-empty
        (tuple.make 2
          (i32.const 1)
          (i64.const 1)
        )
      )
      (catch_all
        (tuple.make 2
          (i32.const 2)
          (i64.const 0)
        )
      )
    )
  )

  ;; CHECK:      (func $try-tuple-tag-none-with-rethrow (type $0) (result i32 i64)
  ;; CHECK-NEXT:  (local $0 exnref)
  ;; CHECK-NEXT:  (block $outer0 (type $0) (result i32 i64)
  ;; CHECK-NEXT:   (local.set $0
  ;; CHECK-NEXT:    (block $catch_all2 (result (ref exn))
  ;; CHECK-NEXT:     (local.set $0
  ;; CHECK-NEXT:      (block $catch1 (result (ref exn))
  ;; CHECK-NEXT:       (br $outer0
  ;; CHECK-NEXT:        (try_table (type $0) (result i32 i64) (catch_ref $e-empty $catch1) (catch_all_ref $catch_all2)
  ;; CHECK-NEXT:         (call $foo)
  ;; CHECK-NEXT:         (tuple.make 2
  ;; CHECK-NEXT:          (i32.const 0)
  ;; CHECK-NEXT:          (i64.const 0)
  ;; CHECK-NEXT:         )
  ;; CHECK-NEXT:        )
  ;; CHECK-NEXT:       )
  ;; CHECK-NEXT:      )
  ;; CHECK-NEXT:     )
  ;; CHECK-NEXT:     (throw_ref
  ;; CHECK-NEXT:      (local.get $0)
  ;; CHECK-NEXT:     )
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:   (throw_ref
  ;; CHECK-NEXT:    (local.get $0)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  ;; STACKIR-OPT:      (func $try-tuple-tag-none-with-rethrow (type $0) (result i32 i64)
  ;; STACKIR-OPT-NEXT:  (local $0 exnref)
  ;; STACKIR-OPT-NEXT:  block $outer0 (type $0) (result i32 i64)
  ;; STACKIR-OPT-NEXT:   block $catch_all2 (result (ref exn))
  ;; STACKIR-OPT-NEXT:    block $catch1 (result (ref exn))
  ;; STACKIR-OPT-NEXT:     try_table (type $0) (result i32 i64) (catch_ref $e-empty $catch1) (catch_all_ref $catch_all2)
  ;; STACKIR-OPT-NEXT:      call $foo
  ;; STACKIR-OPT-NEXT:      i32.const 0
  ;; STACKIR-OPT-NEXT:      i64.const 0
  ;; STACKIR-OPT-NEXT:      tuple.make 2
  ;; STACKIR-OPT-NEXT:     end
  ;; STACKIR-OPT-NEXT:     br $outer0
  ;; STACKIR-OPT-NEXT:    end
  ;; STACKIR-OPT-NEXT:    throw_ref
  ;; STACKIR-OPT-NEXT:   end
  ;; STACKIR-OPT-NEXT:   throw_ref
  ;; STACKIR-OPT-NEXT:  end
  ;; STACKIR-OPT-NEXT: )
  (func $try-tuple-tag-none-with-rethrow (result i32 i64)
    ;; try's type is tuple and catch's tag type is none, and there are rethrows
    (try $l0 (result i32 i64)
      (do
        (call $foo)
        (tuple.make 2
          (i32.const 0)
          (i64.const 0)
        )
      )
      (catch $e-empty
        (rethrow $l0)
      )
      (catch_all
        (rethrow $l0)
      )
    )
  )

  ;; CHECK:      (func $try-tuple-tag-single (type $0) (result i32 i64)
  ;; CHECK-NEXT:  (local $0 i32)
  ;; CHECK-NEXT:  (block $outer0 (type $0) (result i32 i64)
  ;; CHECK-NEXT:   (block $catch_all2
  ;; CHECK-NEXT:    (local.set $0
  ;; CHECK-NEXT:     (block $catch1 (result i32)
  ;; CHECK-NEXT:      (br $outer0
  ;; CHECK-NEXT:       (try_table (type $0) (result i32 i64) (catch $e-i32 $catch1) (catch_all $catch_all2)
  ;; CHECK-NEXT:        (call $foo)
  ;; CHECK-NEXT:        (tuple.make 2
  ;; CHECK-NEXT:         (i32.const 0)
  ;; CHECK-NEXT:         (i64.const 0)
  ;; CHECK-NEXT:        )
  ;; CHECK-NEXT:       )
  ;; CHECK-NEXT:      )
  ;; CHECK-NEXT:     )
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:    (br $outer0
  ;; CHECK-NEXT:     (tuple.make 2
  ;; CHECK-NEXT:      (local.get $0)
  ;; CHECK-NEXT:      (i64.const 0)
  ;; CHECK-NEXT:     )
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:   (tuple.make 2
  ;; CHECK-NEXT:    (i32.const 2)
  ;; CHECK-NEXT:    (i64.const 2)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  ;; STACKIR-OPT:      (func $try-tuple-tag-single (type $0) (result i32 i64)
  ;; STACKIR-OPT-NEXT:  (local $0 i32)
  ;; STACKIR-OPT-NEXT:  block $outer0 (type $0) (result i32 i64)
  ;; STACKIR-OPT-NEXT:   block $catch_all2
  ;; STACKIR-OPT-NEXT:    block $catch1 (result i32)
  ;; STACKIR-OPT-NEXT:     try_table (type $0) (result i32 i64) (catch $e-i32 $catch1) (catch_all $catch_all2)
  ;; STACKIR-OPT-NEXT:      call $foo
  ;; STACKIR-OPT-NEXT:      i32.const 0
  ;; STACKIR-OPT-NEXT:      i64.const 0
  ;; STACKIR-OPT-NEXT:      tuple.make 2
  ;; STACKIR-OPT-NEXT:     end
  ;; STACKIR-OPT-NEXT:     br $outer0
  ;; STACKIR-OPT-NEXT:    end
  ;; STACKIR-OPT-NEXT:    i64.const 0
  ;; STACKIR-OPT-NEXT:    tuple.make 2
  ;; STACKIR-OPT-NEXT:    br $outer0
  ;; STACKIR-OPT-NEXT:   end
  ;; STACKIR-OPT-NEXT:   i32.const 2
  ;; STACKIR-OPT-NEXT:   i64.const 2
  ;; STACKIR-OPT-NEXT:   tuple.make 2
  ;; STACKIR-OPT-NEXT:  end
  ;; STACKIR-OPT-NEXT: )
  (func $try-tuple-tag-single (result i32 i64)
    ;; try's type is tuple and catch's tag type is single
    (try $l0 (result i32 i64)
      (do
        (call $foo)
        (tuple.make 2
          (i32.const 0)
          (i64.const 0)
        )
      )
      (catch $e-i32
        (tuple.make 2
          (pop i32)
          (i64.const 0)
        )
      )
      (catch_all
        (tuple.make 2
          (i32.const 2)
          (i64.const 2)
        )
      )
    )
  )

  ;; CHECK:      (func $try-tuple-tag-single-with-rethrow (type $0) (result i32 i64)
  ;; CHECK-NEXT:  (local $0 exnref)
  ;; CHECK-NEXT:  (local $1 i32)
  ;; CHECK-NEXT:  (local $2 (tuple i32 (ref exn)))
  ;; CHECK-NEXT:  (block $outer0 (type $0) (result i32 i64)
  ;; CHECK-NEXT:   (local.set $0
  ;; CHECK-NEXT:    (block $catch_all2 (result (ref exn))
  ;; CHECK-NEXT:     (local.set $2
  ;; CHECK-NEXT:      (block $catch1 (type $3) (result i32 (ref exn))
  ;; CHECK-NEXT:       (br $outer0
  ;; CHECK-NEXT:        (try_table (type $0) (result i32 i64) (catch_ref $e-i32 $catch1) (catch_all_ref $catch_all2)
  ;; CHECK-NEXT:         (call $foo)
  ;; CHECK-NEXT:         (tuple.make 2
  ;; CHECK-NEXT:          (i32.const 0)
  ;; CHECK-NEXT:          (i64.const 0)
  ;; CHECK-NEXT:         )
  ;; CHECK-NEXT:        )
  ;; CHECK-NEXT:       )
  ;; CHECK-NEXT:      )
  ;; CHECK-NEXT:     )
  ;; CHECK-NEXT:     (local.set $1
  ;; CHECK-NEXT:      (tuple.extract 2 0
  ;; CHECK-NEXT:       (local.get $2)
  ;; CHECK-NEXT:      )
  ;; CHECK-NEXT:     )
  ;; CHECK-NEXT:     (local.set $0
  ;; CHECK-NEXT:      (tuple.extract 2 1
  ;; CHECK-NEXT:       (local.get $2)
  ;; CHECK-NEXT:      )
  ;; CHECK-NEXT:     )
  ;; CHECK-NEXT:     (br $outer0
  ;; CHECK-NEXT:      (block (type $0) (result i32 i64)
  ;; CHECK-NEXT:       (drop
  ;; CHECK-NEXT:        (local.get $1)
  ;; CHECK-NEXT:       )
  ;; CHECK-NEXT:       (throw_ref
  ;; CHECK-NEXT:        (local.get $0)
  ;; CHECK-NEXT:       )
  ;; CHECK-NEXT:      )
  ;; CHECK-NEXT:     )
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:   (throw_ref
  ;; CHECK-NEXT:    (local.get $0)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  ;; STACKIR-OPT:      (func $try-tuple-tag-single-with-rethrow (type $0) (result i32 i64)
  ;; STACKIR-OPT-NEXT:  (local $0 exnref)
  ;; STACKIR-OPT-NEXT:  (local $1 i32)
  ;; STACKIR-OPT-NEXT:  (local $2 (tuple i32 (ref exn)))
  ;; STACKIR-OPT-NEXT:  block $outer0 (type $0) (result i32 i64)
  ;; STACKIR-OPT-NEXT:   block $catch_all2 (result (ref exn))
  ;; STACKIR-OPT-NEXT:    block $catch1 (type $3) (result i32 (ref exn))
  ;; STACKIR-OPT-NEXT:     try_table (type $0) (result i32 i64) (catch_ref $e-i32 $catch1) (catch_all_ref $catch_all2)
  ;; STACKIR-OPT-NEXT:      call $foo
  ;; STACKIR-OPT-NEXT:      i32.const 0
  ;; STACKIR-OPT-NEXT:      i64.const 0
  ;; STACKIR-OPT-NEXT:      tuple.make 2
  ;; STACKIR-OPT-NEXT:     end
  ;; STACKIR-OPT-NEXT:     br $outer0
  ;; STACKIR-OPT-NEXT:    end
  ;; STACKIR-OPT-NEXT:    local.set $2
  ;; STACKIR-OPT-NEXT:    local.get $2
  ;; STACKIR-OPT-NEXT:    tuple.extract 2 0
  ;; STACKIR-OPT-NEXT:    local.get $2
  ;; STACKIR-OPT-NEXT:    tuple.extract 2 1
  ;; STACKIR-OPT-NEXT:    local.set $0
  ;; STACKIR-OPT-NEXT:    drop
  ;; STACKIR-OPT-NEXT:    local.get $0
  ;; STACKIR-OPT-NEXT:    throw_ref
  ;; STACKIR-OPT-NEXT:   end
  ;; STACKIR-OPT-NEXT:   throw_ref
  ;; STACKIR-OPT-NEXT:  end
  ;; STACKIR-OPT-NEXT: )
  (func $try-tuple-tag-single-with-rethrow (result i32 i64)
    ;; try's type is tuple and catch's tag type is single, and there are
    ;; rethrows
    (try $l0 (result i32 i64)
      (do
        (call $foo)
        (tuple.make 2
          (i32.const 0)
          (i64.const 0)
        )
      )
      (catch $e-i32
        (drop
          (pop i32)
        )
        (rethrow $l0)
      )
      (catch_all
        (rethrow $l0)
      )
    )
  )

  ;; CHECK:      (func $try-tuple-tag-tuple (type $0) (result i32 i64)
  ;; CHECK-NEXT:  (local $0 (tuple i32 i64))
  ;; CHECK-NEXT:  (block $outer0 (type $0) (result i32 i64)
  ;; CHECK-NEXT:   (block $catch_all2
  ;; CHECK-NEXT:    (local.set $0
  ;; CHECK-NEXT:     (block $catch1 (type $0) (result i32 i64)
  ;; CHECK-NEXT:      (br $outer0
  ;; CHECK-NEXT:       (try_table (type $0) (result i32 i64) (catch $e-i32-i64 $catch1) (catch_all $catch_all2)
  ;; CHECK-NEXT:        (call $foo)
  ;; CHECK-NEXT:        (tuple.make 2
  ;; CHECK-NEXT:         (i32.const 0)
  ;; CHECK-NEXT:         (i64.const 0)
  ;; CHECK-NEXT:        )
  ;; CHECK-NEXT:       )
  ;; CHECK-NEXT:      )
  ;; CHECK-NEXT:     )
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:    (br $outer0
  ;; CHECK-NEXT:     (local.get $0)
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:   (tuple.make 2
  ;; CHECK-NEXT:    (i32.const 2)
  ;; CHECK-NEXT:    (i64.const 2)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  ;; STACKIR-OPT:      (func $try-tuple-tag-tuple (type $0) (result i32 i64)
  ;; STACKIR-OPT-NEXT:  (local $0 (tuple i32 i64))
  ;; STACKIR-OPT-NEXT:  block $outer0 (type $0) (result i32 i64)
  ;; STACKIR-OPT-NEXT:   block $catch_all2
  ;; STACKIR-OPT-NEXT:    block $catch1 (type $0) (result i32 i64)
  ;; STACKIR-OPT-NEXT:     try_table (type $0) (result i32 i64) (catch $e-i32-i64 $catch1) (catch_all $catch_all2)
  ;; STACKIR-OPT-NEXT:      call $foo
  ;; STACKIR-OPT-NEXT:      i32.const 0
  ;; STACKIR-OPT-NEXT:      i64.const 0
  ;; STACKIR-OPT-NEXT:      tuple.make 2
  ;; STACKIR-OPT-NEXT:     end
  ;; STACKIR-OPT-NEXT:     br $outer0
  ;; STACKIR-OPT-NEXT:    end
  ;; STACKIR-OPT-NEXT:    local.set $0
  ;; STACKIR-OPT-NEXT:    local.get $0
  ;; STACKIR-OPT-NEXT:    br $outer0
  ;; STACKIR-OPT-NEXT:   end
  ;; STACKIR-OPT-NEXT:   i32.const 2
  ;; STACKIR-OPT-NEXT:   i64.const 2
  ;; STACKIR-OPT-NEXT:   tuple.make 2
  ;; STACKIR-OPT-NEXT:  end
  ;; STACKIR-OPT-NEXT: )
  (func $try-tuple-tag-tuple (result i32 i64)
    ;; try's type is tuple and catch's tag type is tuple
    (try $l0 (result i32 i64)
      (do
        (call $foo)
        (tuple.make 2
          (i32.const 0)
          (i64.const 0)
        )
      )
      (catch $e-i32-i64
        (pop (tuple i32 i64))
      )
      (catch_all
        (tuple.make 2
          (i32.const 2)
          (i64.const 2)
        )
      )
    )
  )

  ;; CHECK:      (func $try-tuple-tag-tuple-with-rethrow (type $0) (result i32 i64)
  ;; CHECK-NEXT:  (local $0 exnref)
  ;; CHECK-NEXT:  (local $1 (tuple i32 i64))
  ;; CHECK-NEXT:  (local $2 (tuple i32 i64 (ref exn)))
  ;; CHECK-NEXT:  (block $outer0 (type $0) (result i32 i64)
  ;; CHECK-NEXT:   (local.set $0
  ;; CHECK-NEXT:    (block $catch_all2 (result (ref exn))
  ;; CHECK-NEXT:     (local.set $2
  ;; CHECK-NEXT:      (block $catch1 (type $4) (result i32 i64 (ref exn))
  ;; CHECK-NEXT:       (br $outer0
  ;; CHECK-NEXT:        (try_table (type $0) (result i32 i64) (catch_ref $e-i32-i64 $catch1) (catch_all_ref $catch_all2)
  ;; CHECK-NEXT:         (call $foo)
  ;; CHECK-NEXT:         (tuple.make 2
  ;; CHECK-NEXT:          (i32.const 0)
  ;; CHECK-NEXT:          (i64.const 0)
  ;; CHECK-NEXT:         )
  ;; CHECK-NEXT:        )
  ;; CHECK-NEXT:       )
  ;; CHECK-NEXT:      )
  ;; CHECK-NEXT:     )
  ;; CHECK-NEXT:     (local.set $1
  ;; CHECK-NEXT:      (tuple.make 2
  ;; CHECK-NEXT:       (tuple.extract 3 0
  ;; CHECK-NEXT:        (local.get $2)
  ;; CHECK-NEXT:       )
  ;; CHECK-NEXT:       (tuple.extract 3 1
  ;; CHECK-NEXT:        (local.get $2)
  ;; CHECK-NEXT:       )
  ;; CHECK-NEXT:      )
  ;; CHECK-NEXT:     )
  ;; CHECK-NEXT:     (local.set $0
  ;; CHECK-NEXT:      (tuple.extract 3 2
  ;; CHECK-NEXT:       (local.get $2)
  ;; CHECK-NEXT:      )
  ;; CHECK-NEXT:     )
  ;; CHECK-NEXT:     (br $outer0
  ;; CHECK-NEXT:      (block (type $0) (result i32 i64)
  ;; CHECK-NEXT:       (tuple.drop 2
  ;; CHECK-NEXT:        (local.get $1)
  ;; CHECK-NEXT:       )
  ;; CHECK-NEXT:       (throw_ref
  ;; CHECK-NEXT:        (local.get $0)
  ;; CHECK-NEXT:       )
  ;; CHECK-NEXT:      )
  ;; CHECK-NEXT:     )
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:   (throw_ref
  ;; CHECK-NEXT:    (local.get $0)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  ;; STACKIR-OPT:      (func $try-tuple-tag-tuple-with-rethrow (type $0) (result i32 i64)
  ;; STACKIR-OPT-NEXT:  (local $0 exnref)
  ;; STACKIR-OPT-NEXT:  (local $1 (tuple i32 i64))
  ;; STACKIR-OPT-NEXT:  (local $2 (tuple i32 i64 (ref exn)))
  ;; STACKIR-OPT-NEXT:  block $outer0 (type $0) (result i32 i64)
  ;; STACKIR-OPT-NEXT:   block $catch_all2 (result (ref exn))
  ;; STACKIR-OPT-NEXT:    block $catch1 (type $4) (result i32 i64 (ref exn))
  ;; STACKIR-OPT-NEXT:     try_table (type $0) (result i32 i64) (catch_ref $e-i32-i64 $catch1) (catch_all_ref $catch_all2)
  ;; STACKIR-OPT-NEXT:      call $foo
  ;; STACKIR-OPT-NEXT:      i32.const 0
  ;; STACKIR-OPT-NEXT:      i64.const 0
  ;; STACKIR-OPT-NEXT:      tuple.make 2
  ;; STACKIR-OPT-NEXT:     end
  ;; STACKIR-OPT-NEXT:     br $outer0
  ;; STACKIR-OPT-NEXT:    end
  ;; STACKIR-OPT-NEXT:    local.set $2
  ;; STACKIR-OPT-NEXT:    local.get $2
  ;; STACKIR-OPT-NEXT:    tuple.extract 3 0
  ;; STACKIR-OPT-NEXT:    local.get $2
  ;; STACKIR-OPT-NEXT:    tuple.extract 3 1
  ;; STACKIR-OPT-NEXT:    tuple.make 2
  ;; STACKIR-OPT-NEXT:    local.set $1
  ;; STACKIR-OPT-NEXT:    local.get $2
  ;; STACKIR-OPT-NEXT:    tuple.extract 3 2
  ;; STACKIR-OPT-NEXT:    local.get $1
  ;; STACKIR-OPT-NEXT:    tuple.drop 2
  ;; STACKIR-OPT-NEXT:    throw_ref
  ;; STACKIR-OPT-NEXT:   end
  ;; STACKIR-OPT-NEXT:   throw_ref
  ;; STACKIR-OPT-NEXT:  end
  ;; STACKIR-OPT-NEXT: )
  (func $try-tuple-tag-tuple-with-rethrow (result i32 i64)
    ;; try's type is tuple and catch's tag type is tuple, and there are
    ;; rethrows
    (try $l0 (result i32 i64)
      (do
        (call $foo)
        (tuple.make 2
          (i32.const 0)
          (i64.const 0)
        )
      )
      (catch $e-i32-i64
        (tuple.drop 2
          (pop (tuple i32 i64))
        )
        (rethrow $l0)
      )
      (catch_all
        (rethrow $l0)
      )
    )
  )

  ;; ---------------------------------------------------------------------------
  ;; More try-catch tests

  ;; CHECK:      (func $catchless-delegateless-try (type $1)
  ;; CHECK-NEXT:  (try_table
  ;; CHECK-NEXT:   (call $foo)
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  ;; STACKIR-OPT:      (func $catchless-delegateless-try (type $1)
  ;; STACKIR-OPT-NEXT:  try_table
  ;; STACKIR-OPT-NEXT:   call $foo
  ;; STACKIR-OPT-NEXT:  end
  ;; STACKIR-OPT-NEXT: )
  (func $catchless-delegateless-try
    (try
      (do
        (call $foo)
      )
    )
  )

  ;; CHECK:      (func $multiple-catches-and-catch_all (type $1)
  ;; CHECK-NEXT:  (local $0 exnref)
  ;; CHECK-NEXT:  (local $1 i32)
  ;; CHECK-NEXT:  (local $2 (tuple i32 i64))
  ;; CHECK-NEXT:  (local $3 (tuple i32 (ref exn)))
  ;; CHECK-NEXT:  (local $4 (tuple i32 i64 (ref exn)))
  ;; CHECK-NEXT:  (block $outer0
  ;; CHECK-NEXT:   (local.set $0
  ;; CHECK-NEXT:    (block $catch_all4 (result (ref exn))
  ;; CHECK-NEXT:     (local.set $4
  ;; CHECK-NEXT:      (block $catch3 (type $4) (result i32 i64 (ref exn))
  ;; CHECK-NEXT:       (local.set $3
  ;; CHECK-NEXT:        (block $catch2 (type $3) (result i32 (ref exn))
  ;; CHECK-NEXT:         (local.set $0
  ;; CHECK-NEXT:          (block $catch1 (result (ref exn))
  ;; CHECK-NEXT:           (try_table (catch_ref $e-empty $catch1) (catch_ref $e-i32 $catch2) (catch_ref $e-i32-i64 $catch3) (catch_all_ref $catch_all4)
  ;; CHECK-NEXT:            (call $foo)
  ;; CHECK-NEXT:           )
  ;; CHECK-NEXT:           (br $outer0)
  ;; CHECK-NEXT:          )
  ;; CHECK-NEXT:         )
  ;; CHECK-NEXT:         (throw_ref
  ;; CHECK-NEXT:          (local.get $0)
  ;; CHECK-NEXT:         )
  ;; CHECK-NEXT:        )
  ;; CHECK-NEXT:       )
  ;; CHECK-NEXT:       (local.set $1
  ;; CHECK-NEXT:        (tuple.extract 2 0
  ;; CHECK-NEXT:         (local.get $3)
  ;; CHECK-NEXT:        )
  ;; CHECK-NEXT:       )
  ;; CHECK-NEXT:       (local.set $0
  ;; CHECK-NEXT:        (tuple.extract 2 1
  ;; CHECK-NEXT:         (local.get $3)
  ;; CHECK-NEXT:        )
  ;; CHECK-NEXT:       )
  ;; CHECK-NEXT:       (block
  ;; CHECK-NEXT:        (drop
  ;; CHECK-NEXT:         (local.get $1)
  ;; CHECK-NEXT:        )
  ;; CHECK-NEXT:        (throw_ref
  ;; CHECK-NEXT:         (local.get $0)
  ;; CHECK-NEXT:        )
  ;; CHECK-NEXT:       )
  ;; CHECK-NEXT:      )
  ;; CHECK-NEXT:     )
  ;; CHECK-NEXT:     (local.set $2
  ;; CHECK-NEXT:      (tuple.make 2
  ;; CHECK-NEXT:       (tuple.extract 3 0
  ;; CHECK-NEXT:        (local.get $4)
  ;; CHECK-NEXT:       )
  ;; CHECK-NEXT:       (tuple.extract 3 1
  ;; CHECK-NEXT:        (local.get $4)
  ;; CHECK-NEXT:       )
  ;; CHECK-NEXT:      )
  ;; CHECK-NEXT:     )
  ;; CHECK-NEXT:     (local.set $0
  ;; CHECK-NEXT:      (tuple.extract 3 2
  ;; CHECK-NEXT:       (local.get $4)
  ;; CHECK-NEXT:      )
  ;; CHECK-NEXT:     )
  ;; CHECK-NEXT:     (block
  ;; CHECK-NEXT:      (tuple.drop 2
  ;; CHECK-NEXT:       (local.get $2)
  ;; CHECK-NEXT:      )
  ;; CHECK-NEXT:      (throw_ref
  ;; CHECK-NEXT:       (local.get $0)
  ;; CHECK-NEXT:      )
  ;; CHECK-NEXT:     )
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:   (throw_ref
  ;; CHECK-NEXT:    (local.get $0)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  ;; STACKIR-OPT:      (func $multiple-catches-and-catch_all (type $1)
  ;; STACKIR-OPT-NEXT:  (local $0 exnref)
  ;; STACKIR-OPT-NEXT:  (local $1 i32)
  ;; STACKIR-OPT-NEXT:  (local $2 (tuple i32 i64))
  ;; STACKIR-OPT-NEXT:  (local $3 (tuple i32 (ref exn)))
  ;; STACKIR-OPT-NEXT:  (local $4 (tuple i32 i64 (ref exn)))
  ;; STACKIR-OPT-NEXT:  block $outer0
  ;; STACKIR-OPT-NEXT:   block $catch_all4 (result (ref exn))
  ;; STACKIR-OPT-NEXT:    block $catch3 (type $4) (result i32 i64 (ref exn))
  ;; STACKIR-OPT-NEXT:     block $catch2 (type $3) (result i32 (ref exn))
  ;; STACKIR-OPT-NEXT:      block $catch1 (result (ref exn))
  ;; STACKIR-OPT-NEXT:       try_table (catch_ref $e-empty $catch1) (catch_ref $e-i32 $catch2) (catch_ref $e-i32-i64 $catch3) (catch_all_ref $catch_all4)
  ;; STACKIR-OPT-NEXT:        call $foo
  ;; STACKIR-OPT-NEXT:       end
  ;; STACKIR-OPT-NEXT:       br $outer0
  ;; STACKIR-OPT-NEXT:      end
  ;; STACKIR-OPT-NEXT:      throw_ref
  ;; STACKIR-OPT-NEXT:     end
  ;; STACKIR-OPT-NEXT:     local.set $3
  ;; STACKIR-OPT-NEXT:     local.get $3
  ;; STACKIR-OPT-NEXT:     tuple.extract 2 0
  ;; STACKIR-OPT-NEXT:     local.get $3
  ;; STACKIR-OPT-NEXT:     tuple.extract 2 1
  ;; STACKIR-OPT-NEXT:     local.set $0
  ;; STACKIR-OPT-NEXT:     drop
  ;; STACKIR-OPT-NEXT:     local.get $0
  ;; STACKIR-OPT-NEXT:     throw_ref
  ;; STACKIR-OPT-NEXT:    end
  ;; STACKIR-OPT-NEXT:    local.set $4
  ;; STACKIR-OPT-NEXT:    local.get $4
  ;; STACKIR-OPT-NEXT:    tuple.extract 3 0
  ;; STACKIR-OPT-NEXT:    local.get $4
  ;; STACKIR-OPT-NEXT:    tuple.extract 3 1
  ;; STACKIR-OPT-NEXT:    tuple.make 2
  ;; STACKIR-OPT-NEXT:    local.set $2
  ;; STACKIR-OPT-NEXT:    local.get $4
  ;; STACKIR-OPT-NEXT:    tuple.extract 3 2
  ;; STACKIR-OPT-NEXT:    local.get $2
  ;; STACKIR-OPT-NEXT:    tuple.drop 2
  ;; STACKIR-OPT-NEXT:    throw_ref
  ;; STACKIR-OPT-NEXT:   end
  ;; STACKIR-OPT-NEXT:   throw_ref
  ;; STACKIR-OPT-NEXT:  end
  ;; STACKIR-OPT-NEXT: )
  (func $multiple-catches-and-catch_all
    (try $l0
      (do
        (call $foo)
      )
      (catch $e-empty
        (rethrow $l0)
      )
      (catch $e-i32
        (drop
          (pop i32)
        )
        (rethrow $l0)
      )
      (catch $e-i32-i64
        (tuple.drop 2
          (pop (tuple i32 i64))
        )
        (rethrow $l0)
      )
      (catch_all
        (rethrow $l0)
      )
    )
  )

  ;; CHECK:      (func $nested-catch-rethrows (type $1)
  ;; CHECK-NEXT:  (local $0 exnref)
  ;; CHECK-NEXT:  (local $1 exnref)
  ;; CHECK-NEXT:  (block $outer3
  ;; CHECK-NEXT:   (local.set $0
  ;; CHECK-NEXT:    (block $catch_all4 (result (ref exn))
  ;; CHECK-NEXT:     (try_table (catch_all_ref $catch_all4)
  ;; CHECK-NEXT:      (call $foo)
  ;; CHECK-NEXT:     )
  ;; CHECK-NEXT:     (br $outer3)
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:   (block $outer0
  ;; CHECK-NEXT:    (local.set $1
  ;; CHECK-NEXT:     (block $catch2 (result (ref exn))
  ;; CHECK-NEXT:      (block $catch1
  ;; CHECK-NEXT:       (try_table (catch $e-empty $catch1) (catch_ref $e-empty $catch2)
  ;; CHECK-NEXT:        (call $foo)
  ;; CHECK-NEXT:       )
  ;; CHECK-NEXT:       (br $outer0)
  ;; CHECK-NEXT:      )
  ;; CHECK-NEXT:      (throw_ref
  ;; CHECK-NEXT:       (local.get $0)
  ;; CHECK-NEXT:      )
  ;; CHECK-NEXT:     )
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:    (throw_ref
  ;; CHECK-NEXT:     (local.get $1)
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  ;; STACKIR-OPT:      (func $nested-catch-rethrows (type $1)
  ;; STACKIR-OPT-NEXT:  (local $0 exnref)
  ;; STACKIR-OPT-NEXT:  (local $1 exnref)
  ;; STACKIR-OPT-NEXT:  block $outer3
  ;; STACKIR-OPT-NEXT:   block $catch_all4 (result (ref exn))
  ;; STACKIR-OPT-NEXT:    try_table (catch_all_ref $catch_all4)
  ;; STACKIR-OPT-NEXT:     call $foo
  ;; STACKIR-OPT-NEXT:    end
  ;; STACKIR-OPT-NEXT:    br $outer3
  ;; STACKIR-OPT-NEXT:   end
  ;; STACKIR-OPT-NEXT:   local.set $0
  ;; STACKIR-OPT-NEXT:   block $outer0
  ;; STACKIR-OPT-NEXT:    block $catch2 (result (ref exn))
  ;; STACKIR-OPT-NEXT:     block $catch1
  ;; STACKIR-OPT-NEXT:      try_table (catch $e-empty $catch1) (catch_ref $e-empty $catch2)
  ;; STACKIR-OPT-NEXT:       call $foo
  ;; STACKIR-OPT-NEXT:      end
  ;; STACKIR-OPT-NEXT:      br $outer0
  ;; STACKIR-OPT-NEXT:     end
  ;; STACKIR-OPT-NEXT:     local.get $0
  ;; STACKIR-OPT-NEXT:     throw_ref
  ;; STACKIR-OPT-NEXT:    end
  ;; STACKIR-OPT-NEXT:    throw_ref
  ;; STACKIR-OPT-NEXT:   end
  ;; STACKIR-OPT-NEXT:  end
  ;; STACKIR-OPT-NEXT: )
  (func $nested-catch-rethrows
    (try $l0
      (do
        (call $foo)
      )
      (catch_all
        (try $l1
          (do
            (call $foo)
          )
          ;; This catch will be converted to a 'catch' clause in a try_table,
          ;; because the rethrow in this catch body does not refer to the
          ;; current try
          (catch $e-empty
            (rethrow $l0)
          )
          ;; This catch will be converted to a 'catch_ref' clause in a
          ;; try_table, because the rethrow in this catch body refers to the
          ;; current try
          (catch $e-empty
            (rethrow $l1)
          )
        )
      )
    )
  )

  ;; ---------------------------------------------------------------------------
  ;; try-delegate tests

  ;; CHECK:      (func $delegate-target-outer-try-none (type $1)
  ;; CHECK-NEXT:  (block $outer1
  ;; CHECK-NEXT:   (block $catch_all2
  ;; CHECK-NEXT:    (try_table (catch_all $catch_all2)
  ;; CHECK-NEXT:     (throw_ref
  ;; CHECK-NEXT:      (block $l00 (result exnref)
  ;; CHECK-NEXT:       (call $foo)
  ;; CHECK-NEXT:       (try_table (catch_all_ref $l00)
  ;; CHECK-NEXT:        (call $bar)
  ;; CHECK-NEXT:       )
  ;; CHECK-NEXT:       (call $baz)
  ;; CHECK-NEXT:       (br $outer1)
  ;; CHECK-NEXT:      )
  ;; CHECK-NEXT:     )
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:   (block
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  ;; STACKIR-OPT:      (func $delegate-target-outer-try-none (type $1)
  ;; STACKIR-OPT-NEXT:  block $outer1
  ;; STACKIR-OPT-NEXT:   block $catch_all2
  ;; STACKIR-OPT-NEXT:    try_table (catch_all $catch_all2)
  ;; STACKIR-OPT-NEXT:     block $l00 (result exnref)
  ;; STACKIR-OPT-NEXT:      call $foo
  ;; STACKIR-OPT-NEXT:      try_table (catch_all_ref $l00)
  ;; STACKIR-OPT-NEXT:       call $bar
  ;; STACKIR-OPT-NEXT:      end
  ;; STACKIR-OPT-NEXT:      call $baz
  ;; STACKIR-OPT-NEXT:      br $outer1
  ;; STACKIR-OPT-NEXT:     end
  ;; STACKIR-OPT-NEXT:     throw_ref
  ;; STACKIR-OPT-NEXT:    end
  ;; STACKIR-OPT-NEXT:    unreachable
  ;; STACKIR-OPT-NEXT:   end
  ;; STACKIR-OPT-NEXT:  end
  ;; STACKIR-OPT-NEXT: )
  (func $delegate-target-outer-try-none
    ;; An inner try-delegate targets an outer try whose type is none
    (try $l0
      (do
        (call $foo)
        (try
          (do
            (call $bar)
          )
          (delegate $l0)
        )
        (call $baz)
      )
      (catch_all)
    )
  )

  ;; CHECK:      (func $multiple-delegates-target-outer-try-none (type $1)
  ;; CHECK-NEXT:  (block $outer1
  ;; CHECK-NEXT:   (block $catch_all2
  ;; CHECK-NEXT:    (try_table (catch_all $catch_all2)
  ;; CHECK-NEXT:     (throw_ref
  ;; CHECK-NEXT:      (block $l00 (result exnref)
  ;; CHECK-NEXT:       (call $foo)
  ;; CHECK-NEXT:       (try_table (catch_all_ref $l00)
  ;; CHECK-NEXT:        (call $bar)
  ;; CHECK-NEXT:       )
  ;; CHECK-NEXT:       (try_table (catch_all_ref $l00)
  ;; CHECK-NEXT:        (call $bar)
  ;; CHECK-NEXT:       )
  ;; CHECK-NEXT:       (call $baz)
  ;; CHECK-NEXT:       (br $outer1)
  ;; CHECK-NEXT:      )
  ;; CHECK-NEXT:     )
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:   (block
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  ;; STACKIR-OPT:      (func $multiple-delegates-target-outer-try-none (type $1)
  ;; STACKIR-OPT-NEXT:  block $outer1
  ;; STACKIR-OPT-NEXT:   block $catch_all2
  ;; STACKIR-OPT-NEXT:    try_table (catch_all $catch_all2)
  ;; STACKIR-OPT-NEXT:     block $l00 (result exnref)
  ;; STACKIR-OPT-NEXT:      call $foo
  ;; STACKIR-OPT-NEXT:      try_table (catch_all_ref $l00)
  ;; STACKIR-OPT-NEXT:       call $bar
  ;; STACKIR-OPT-NEXT:      end
  ;; STACKIR-OPT-NEXT:      try_table (catch_all_ref $l00)
  ;; STACKIR-OPT-NEXT:       call $bar
  ;; STACKIR-OPT-NEXT:      end
  ;; STACKIR-OPT-NEXT:      call $baz
  ;; STACKIR-OPT-NEXT:      br $outer1
  ;; STACKIR-OPT-NEXT:     end
  ;; STACKIR-OPT-NEXT:     throw_ref
  ;; STACKIR-OPT-NEXT:    end
  ;; STACKIR-OPT-NEXT:    unreachable
  ;; STACKIR-OPT-NEXT:   end
  ;; STACKIR-OPT-NEXT:  end
  ;; STACKIR-OPT-NEXT: )
  (func $multiple-delegates-target-outer-try-none
    ;; Multiple inner try-delegates target an outer try whose type is none
    (try $l0
      (do
        (call $foo)
        (try
          (do
            (call $bar)
          )
          (delegate $l0)
        )
        (try
          (do
            (call $bar)
          )
          (delegate $l0)
        )
        (call $baz)
      )
      (catch_all)
    )
  )

  ;; CHECK:      (func $delegate-target-outer-try-concrete (type $2) (result i32)
  ;; CHECK-NEXT:  (block $outer1 (result i32)
  ;; CHECK-NEXT:   (block $catch_all2
  ;; CHECK-NEXT:    (br $outer1
  ;; CHECK-NEXT:     (try_table (result i32) (catch_all $catch_all2)
  ;; CHECK-NEXT:      (throw_ref
  ;; CHECK-NEXT:       (block $l00 (result exnref)
  ;; CHECK-NEXT:        (br $outer1
  ;; CHECK-NEXT:         (block (result i32)
  ;; CHECK-NEXT:          (call $foo)
  ;; CHECK-NEXT:          (try_table (result i32) (catch_all_ref $l00)
  ;; CHECK-NEXT:           (call $bar)
  ;; CHECK-NEXT:           (i32.const 0)
  ;; CHECK-NEXT:          )
  ;; CHECK-NEXT:         )
  ;; CHECK-NEXT:        )
  ;; CHECK-NEXT:       )
  ;; CHECK-NEXT:      )
  ;; CHECK-NEXT:     )
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:   (i32.const 1)
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  ;; STACKIR-OPT:      (func $delegate-target-outer-try-concrete (type $2) (result i32)
  ;; STACKIR-OPT-NEXT:  block $outer1 (result i32)
  ;; STACKIR-OPT-NEXT:   block $catch_all2
  ;; STACKIR-OPT-NEXT:    try_table (result i32) (catch_all $catch_all2)
  ;; STACKIR-OPT-NEXT:     block $l00 (result exnref)
  ;; STACKIR-OPT-NEXT:      call $foo
  ;; STACKIR-OPT-NEXT:      try_table (result i32) (catch_all_ref $l00)
  ;; STACKIR-OPT-NEXT:       call $bar
  ;; STACKIR-OPT-NEXT:       i32.const 0
  ;; STACKIR-OPT-NEXT:      end
  ;; STACKIR-OPT-NEXT:      br $outer1
  ;; STACKIR-OPT-NEXT:     end
  ;; STACKIR-OPT-NEXT:     throw_ref
  ;; STACKIR-OPT-NEXT:    end
  ;; STACKIR-OPT-NEXT:    br $outer1
  ;; STACKIR-OPT-NEXT:   end
  ;; STACKIR-OPT-NEXT:   i32.const 1
  ;; STACKIR-OPT-NEXT:  end
  ;; STACKIR-OPT-NEXT: )
  (func $delegate-target-outer-try-concrete (result i32)
    ;; An inner try-delegate targets an outer try whose type is concrete
    (try $l0 (result i32)
      (do
        (call $foo)
        (try (result i32)
          (do
            (call $bar)
            (i32.const 0)
          )
          (delegate $l0)
        )
      )
      (catch_all
        (i32.const 1)
      )
    )
  )

  ;; CHECK:      (func $deletate-target-outer-try-unreachable (type $1)
  ;; CHECK-NEXT:  (try_table
  ;; CHECK-NEXT:   (throw_ref
  ;; CHECK-NEXT:    (block $l00 (result exnref)
  ;; CHECK-NEXT:     (try_table (catch_all_ref $l00)
  ;; CHECK-NEXT:      (call $foo)
  ;; CHECK-NEXT:     )
  ;; CHECK-NEXT:     (return)
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  ;; STACKIR-OPT:      (func $deletate-target-outer-try-unreachable (type $1)
  ;; STACKIR-OPT-NEXT:  try_table
  ;; STACKIR-OPT-NEXT:   block $l00 (result exnref)
  ;; STACKIR-OPT-NEXT:    try_table (catch_all_ref $l00)
  ;; STACKIR-OPT-NEXT:     call $foo
  ;; STACKIR-OPT-NEXT:    end
  ;; STACKIR-OPT-NEXT:    return
  ;; STACKIR-OPT-NEXT:   end
  ;; STACKIR-OPT-NEXT:   throw_ref
  ;; STACKIR-OPT-NEXT:  end
  ;; STACKIR-OPT-NEXT:  unreachable
  ;; STACKIR-OPT-NEXT: )
  (func $deletate-target-outer-try-unreachable
    ;; An inner try-delegate targets an outer try whose body type is unreachable
    ;; (due to a return). In this case we don't need an additional 'br' to an
    ;; outer block.
    (try $l0
      (do
        (try
          (do
            (call $foo)
          )
          (delegate $l0)
        )
        (return)
      )
    )
  )

  ;; CHECK:      (func $delegate-target-caller-none (type $1)
  ;; CHECK-NEXT:  (throw_ref
  ;; CHECK-NEXT:   (block $__binaryen_delegate_caller_target0 (result exnref)
  ;; CHECK-NEXT:    (call $foo)
  ;; CHECK-NEXT:    (try_table (catch_all_ref $__binaryen_delegate_caller_target0)
  ;; CHECK-NEXT:     (call $bar)
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:    (call $baz)
  ;; CHECK-NEXT:    (return)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  ;; STACKIR-OPT:      (func $delegate-target-caller-none (type $1)
  ;; STACKIR-OPT-NEXT:  block $__binaryen_delegate_caller_target0 (result exnref)
  ;; STACKIR-OPT-NEXT:   call $foo
  ;; STACKIR-OPT-NEXT:   try_table (catch_all_ref $__binaryen_delegate_caller_target0)
  ;; STACKIR-OPT-NEXT:    call $bar
  ;; STACKIR-OPT-NEXT:   end
  ;; STACKIR-OPT-NEXT:   call $baz
  ;; STACKIR-OPT-NEXT:   return
  ;; STACKIR-OPT-NEXT:  end
  ;; STACKIR-OPT-NEXT:  throw_ref
  ;; STACKIR-OPT-NEXT: )
  (func $delegate-target-caller-none
    ;; A try-delegate targets the caller whose type is none
    (call $foo)
    (try
      (do
        (call $bar)
      )
      (delegate 0)
    )
    (call $baz)
  )

  ;; CHECK:      (func $multiple-delegates-target-caller-none (type $1)
  ;; CHECK-NEXT:  (throw_ref
  ;; CHECK-NEXT:   (block $__binaryen_delegate_caller_target0 (result exnref)
  ;; CHECK-NEXT:    (call $foo)
  ;; CHECK-NEXT:    (try_table (catch_all_ref $__binaryen_delegate_caller_target0)
  ;; CHECK-NEXT:     (call $bar)
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:    (try_table (catch_all_ref $__binaryen_delegate_caller_target0)
  ;; CHECK-NEXT:     (call $bar)
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:    (call $baz)
  ;; CHECK-NEXT:    (return)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  ;; STACKIR-OPT:      (func $multiple-delegates-target-caller-none (type $1)
  ;; STACKIR-OPT-NEXT:  block $__binaryen_delegate_caller_target0 (result exnref)
  ;; STACKIR-OPT-NEXT:   call $foo
  ;; STACKIR-OPT-NEXT:   try_table (catch_all_ref $__binaryen_delegate_caller_target0)
  ;; STACKIR-OPT-NEXT:    call $bar
  ;; STACKIR-OPT-NEXT:   end
  ;; STACKIR-OPT-NEXT:   try_table (catch_all_ref $__binaryen_delegate_caller_target0)
  ;; STACKIR-OPT-NEXT:    call $bar
  ;; STACKIR-OPT-NEXT:   end
  ;; STACKIR-OPT-NEXT:   call $baz
  ;; STACKIR-OPT-NEXT:   return
  ;; STACKIR-OPT-NEXT:  end
  ;; STACKIR-OPT-NEXT:  throw_ref
  ;; STACKIR-OPT-NEXT: )
  (func $multiple-delegates-target-caller-none
    ;; Multiple try-delegates target the caller whose type is none
    (call $foo)
    (try
      (do
        (call $bar)
      )
      (delegate 0)
    )
    (try
      (do
        (call $bar)
      )
      (delegate 0)
    )
    (call $baz)
  )

  ;; CHECK:      (func $delegate-target-caller-concrete (type $2) (result i32)
  ;; CHECK-NEXT:  (throw_ref
  ;; CHECK-NEXT:   (block $__binaryen_delegate_caller_target0 (result exnref)
  ;; CHECK-NEXT:    (return
  ;; CHECK-NEXT:     (block (result i32)
  ;; CHECK-NEXT:      (call $foo)
  ;; CHECK-NEXT:      (try_table (result i32) (catch_all_ref $__binaryen_delegate_caller_target0)
  ;; CHECK-NEXT:       (call $bar)
  ;; CHECK-NEXT:       (i32.const 0)
  ;; CHECK-NEXT:      )
  ;; CHECK-NEXT:     )
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  ;; STACKIR-OPT:      (func $delegate-target-caller-concrete (type $2) (result i32)
  ;; STACKIR-OPT-NEXT:  block $__binaryen_delegate_caller_target0 (result exnref)
  ;; STACKIR-OPT-NEXT:   call $foo
  ;; STACKIR-OPT-NEXT:   try_table (result i32) (catch_all_ref $__binaryen_delegate_caller_target0)
  ;; STACKIR-OPT-NEXT:    call $bar
  ;; STACKIR-OPT-NEXT:    i32.const 0
  ;; STACKIR-OPT-NEXT:   end
  ;; STACKIR-OPT-NEXT:   return
  ;; STACKIR-OPT-NEXT:  end
  ;; STACKIR-OPT-NEXT:  throw_ref
  ;; STACKIR-OPT-NEXT: )
  (func $delegate-target-caller-concrete (result i32)
    ;; A try-delegate targets the caller whose type is concrete
    (call $foo)
    (try (result i32)
      (do
        (call $bar)
        (i32.const 0)
      )
      (delegate 0)
    )
  )

  ;; CHECK:      (func $delegate-nested-more (type $1)
  ;; CHECK-NEXT:  (block $outer3
  ;; CHECK-NEXT:   (block $catch_all4
  ;; CHECK-NEXT:    (try_table (catch_all $catch_all4)
  ;; CHECK-NEXT:     (throw_ref
  ;; CHECK-NEXT:      (block $l00 (result exnref)
  ;; CHECK-NEXT:       (block $outer1
  ;; CHECK-NEXT:        (block $catch_all2
  ;; CHECK-NEXT:         (try_table (catch_all $catch_all2)
  ;; CHECK-NEXT:          (try_table (catch_all_ref $l00)
  ;; CHECK-NEXT:           (call $foo)
  ;; CHECK-NEXT:          )
  ;; CHECK-NEXT:         )
  ;; CHECK-NEXT:         (br $outer1)
  ;; CHECK-NEXT:        )
  ;; CHECK-NEXT:        (block
  ;; CHECK-NEXT:        )
  ;; CHECK-NEXT:       )
  ;; CHECK-NEXT:       (br $outer3)
  ;; CHECK-NEXT:      )
  ;; CHECK-NEXT:     )
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:   (block
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  ;; STACKIR-OPT:      (func $delegate-nested-more (type $1)
  ;; STACKIR-OPT-NEXT:  block $outer3
  ;; STACKIR-OPT-NEXT:   block $catch_all4
  ;; STACKIR-OPT-NEXT:    try_table (catch_all $catch_all4)
  ;; STACKIR-OPT-NEXT:     block $l00 (result exnref)
  ;; STACKIR-OPT-NEXT:      block $outer1
  ;; STACKIR-OPT-NEXT:       block $catch_all2
  ;; STACKIR-OPT-NEXT:        try_table (catch_all $catch_all2)
  ;; STACKIR-OPT-NEXT:         try_table (catch_all_ref $l00)
  ;; STACKIR-OPT-NEXT:          call $foo
  ;; STACKIR-OPT-NEXT:         end
  ;; STACKIR-OPT-NEXT:        end
  ;; STACKIR-OPT-NEXT:        br $outer1
  ;; STACKIR-OPT-NEXT:       end
  ;; STACKIR-OPT-NEXT:      end
  ;; STACKIR-OPT-NEXT:      br $outer3
  ;; STACKIR-OPT-NEXT:     end
  ;; STACKIR-OPT-NEXT:     throw_ref
  ;; STACKIR-OPT-NEXT:    end
  ;; STACKIR-OPT-NEXT:    unreachable
  ;; STACKIR-OPT-NEXT:   end
  ;; STACKIR-OPT-NEXT:  end
  ;; STACKIR-OPT-NEXT: )
  (func $delegate-nested-more
    (try $l0
      (do
        (try
          (do
            (try
              (do
                (call $foo)
              )
              (delegate $l0)
            )
          )
          (catch_all)
        )
      )
      (catch_all)
    )
  )

  ;; CHECK:      (func $delegate-target-outer-try-delegate (type $1)
  ;; CHECK-NEXT:  (throw_ref
  ;; CHECK-NEXT:   (block $__binaryen_delegate_caller_target0 (result exnref)
  ;; CHECK-NEXT:    (block $outer2
  ;; CHECK-NEXT:     (try_table (catch_all_ref $__binaryen_delegate_caller_target0)
  ;; CHECK-NEXT:      (throw_ref
  ;; CHECK-NEXT:       (block $l01 (result exnref)
  ;; CHECK-NEXT:        (try_table (catch_all_ref $l01)
  ;; CHECK-NEXT:         (call $foo)
  ;; CHECK-NEXT:        )
  ;; CHECK-NEXT:        (br $outer2)
  ;; CHECK-NEXT:       )
  ;; CHECK-NEXT:      )
  ;; CHECK-NEXT:     )
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:    (return)
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  ;; STACKIR-OPT:      (func $delegate-target-outer-try-delegate (type $1)
  ;; STACKIR-OPT-NEXT:  block $__binaryen_delegate_caller_target0 (result exnref)
  ;; STACKIR-OPT-NEXT:   block $outer2
  ;; STACKIR-OPT-NEXT:    try_table (catch_all_ref $__binaryen_delegate_caller_target0)
  ;; STACKIR-OPT-NEXT:     block $l01 (result exnref)
  ;; STACKIR-OPT-NEXT:      try_table (catch_all_ref $l01)
  ;; STACKIR-OPT-NEXT:       call $foo
  ;; STACKIR-OPT-NEXT:      end
  ;; STACKIR-OPT-NEXT:      br $outer2
  ;; STACKIR-OPT-NEXT:     end
  ;; STACKIR-OPT-NEXT:     throw_ref
  ;; STACKIR-OPT-NEXT:    end
  ;; STACKIR-OPT-NEXT:    unreachable
  ;; STACKIR-OPT-NEXT:   end
  ;; STACKIR-OPT-NEXT:   return
  ;; STACKIR-OPT-NEXT:  end
  ;; STACKIR-OPT-NEXT:  throw_ref
  ;; STACKIR-OPT-NEXT: )
  (func $delegate-target-outer-try-delegate
    ;; An inner try-delegate targets an outer try-delegate that targets the
    ;; caller
    (try $l0
      (do
        (try
          (do
            (call $foo)
          )
          (delegate $l0)
        )
      )
      (delegate 0)
    )
  )

  ;; CHECK:      (func $delegate-target-outer-try-delegate-concrete (type $2) (result i32)
  ;; CHECK-NEXT:  (throw_ref
  ;; CHECK-NEXT:   (block $__binaryen_delegate_caller_target0 (result exnref)
  ;; CHECK-NEXT:    (return
  ;; CHECK-NEXT:     (block $outer2 (result i32)
  ;; CHECK-NEXT:      (try_table (catch_all_ref $__binaryen_delegate_caller_target0)
  ;; CHECK-NEXT:       (throw_ref
  ;; CHECK-NEXT:        (block $l01 (result exnref)
  ;; CHECK-NEXT:         (br $outer2
  ;; CHECK-NEXT:          (try_table (result i32) (catch_all_ref $l01)
  ;; CHECK-NEXT:           (call $foo)
  ;; CHECK-NEXT:           (i32.const 0)
  ;; CHECK-NEXT:          )
  ;; CHECK-NEXT:         )
  ;; CHECK-NEXT:        )
  ;; CHECK-NEXT:       )
  ;; CHECK-NEXT:      )
  ;; CHECK-NEXT:     )
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  ;; STACKIR-OPT:      (func $delegate-target-outer-try-delegate-concrete (type $2) (result i32)
  ;; STACKIR-OPT-NEXT:  block $__binaryen_delegate_caller_target0 (result exnref)
  ;; STACKIR-OPT-NEXT:   block $outer2 (result i32)
  ;; STACKIR-OPT-NEXT:    try_table (catch_all_ref $__binaryen_delegate_caller_target0)
  ;; STACKIR-OPT-NEXT:     block $l01 (result exnref)
  ;; STACKIR-OPT-NEXT:      try_table (result i32) (catch_all_ref $l01)
  ;; STACKIR-OPT-NEXT:       call $foo
  ;; STACKIR-OPT-NEXT:       i32.const 0
  ;; STACKIR-OPT-NEXT:      end
  ;; STACKIR-OPT-NEXT:      br $outer2
  ;; STACKIR-OPT-NEXT:     end
  ;; STACKIR-OPT-NEXT:     throw_ref
  ;; STACKIR-OPT-NEXT:    end
  ;; STACKIR-OPT-NEXT:    unreachable
  ;; STACKIR-OPT-NEXT:   end
  ;; STACKIR-OPT-NEXT:   return
  ;; STACKIR-OPT-NEXT:  end
  ;; STACKIR-OPT-NEXT:  throw_ref
  ;; STACKIR-OPT-NEXT: )
  (func $delegate-target-outer-try-delegate-concrete (result i32)
    ;; An inner try-delegate targets an outer try-delegate that targets the
    ;; caller, where the type of the try-delegates and the caller is concrete
    (try $l0 (result i32)
      (do
        (try (result i32)
          (do
            (call $foo)
            (i32.const 0)
          )
          (delegate $l0)
        )
      )
      (delegate 0)
    )
  )

  ;; CHECK:      (func $throw_ref-in-resultless-block (type $2) (result i32)
  ;; CHECK-NEXT:  (throw_ref
  ;; CHECK-NEXT:   (block $__binaryen_delegate_caller_target0 (result exnref)
  ;; CHECK-NEXT:    (return
  ;; CHECK-NEXT:     (block
  ;; CHECK-NEXT:      (try_table (catch_all_ref $__binaryen_delegate_caller_target0)
  ;; CHECK-NEXT:       (call $foo)
  ;; CHECK-NEXT:      )
  ;; CHECK-NEXT:      (unreachable)
  ;; CHECK-NEXT:     )
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  ;; STACKIR-OPT:      (func $throw_ref-in-resultless-block (type $2) (result i32)
  ;; STACKIR-OPT-NEXT:  block $__binaryen_delegate_caller_target0 (result exnref)
  ;; STACKIR-OPT-NEXT:   try_table (catch_all_ref $__binaryen_delegate_caller_target0)
  ;; STACKIR-OPT-NEXT:    call $foo
  ;; STACKIR-OPT-NEXT:   end
  ;; STACKIR-OPT-NEXT:   unreachable
  ;; STACKIR-OPT-NEXT:  end
  ;; STACKIR-OPT-NEXT:  throw_ref
  ;; STACKIR-OPT-NEXT: )
  (func $throw_ref-in-resultless-block (result i32)
    ;; When the function return type is concrete, try-delegate that targets the
    ;; caller is translated to
    ;; (throw_ref
    ;;   (block $__binaryen_delegate_caller_target (result exnref)
    ;;     (return
    ;;       function body
    ;;     )
    ;;   )
    ;; )
    ;; We should do that even if the function body's type is not concrete.
    (block ;; This block doesn't have concrete result type
      (try
        (do
          (call $foo)
        )
        (delegate 1)
      )
      (unreachable)
    )
  )

  ;; CHECK:      (func $try-delegate-within-catchless-try (type $1)
  ;; CHECK-NEXT:  (block $outer1
  ;; CHECK-NEXT:   (try_table
  ;; CHECK-NEXT:    (throw_ref
  ;; CHECK-NEXT:     (block $l00 (result exnref)
  ;; CHECK-NEXT:      (try_table (catch_all_ref $l00)
  ;; CHECK-NEXT:       (call $foo)
  ;; CHECK-NEXT:      )
  ;; CHECK-NEXT:      (br $outer1)
  ;; CHECK-NEXT:     )
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  ;; STACKIR-OPT:      (func $try-delegate-within-catchless-try (type $1)
  ;; STACKIR-OPT-NEXT:  block $outer1
  ;; STACKIR-OPT-NEXT:   try_table
  ;; STACKIR-OPT-NEXT:    block $l00 (result exnref)
  ;; STACKIR-OPT-NEXT:     try_table (catch_all_ref $l00)
  ;; STACKIR-OPT-NEXT:      call $foo
  ;; STACKIR-OPT-NEXT:     end
  ;; STACKIR-OPT-NEXT:     br $outer1
  ;; STACKIR-OPT-NEXT:    end
  ;; STACKIR-OPT-NEXT:    throw_ref
  ;; STACKIR-OPT-NEXT:   end
  ;; STACKIR-OPT-NEXT:   unreachable
  ;; STACKIR-OPT-NEXT:  end
  ;; STACKIR-OPT-NEXT: )
  (func $try-delegate-within-catchless-try
    (try $l0
      (do
        (try
          (do
            (call $foo)
          )
          (delegate $l0)
        )
      )
    )
  )

  ;; CHECK:      (func $try-catch-rethrow-with-inner-delegate (type $1)
  ;; CHECK-NEXT:  (local $0 exnref)
  ;; CHECK-NEXT:  (block $outer2
  ;; CHECK-NEXT:   (local.set $0
  ;; CHECK-NEXT:    (block $catch3 (result (ref exn))
  ;; CHECK-NEXT:     (try_table (catch_ref $e-empty $catch3)
  ;; CHECK-NEXT:      (call $foo)
  ;; CHECK-NEXT:     )
  ;; CHECK-NEXT:     (br $outer2)
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:   (block
  ;; CHECK-NEXT:    (block $outer1
  ;; CHECK-NEXT:     (try_table
  ;; CHECK-NEXT:      (throw_ref
  ;; CHECK-NEXT:       (block $l10 (result exnref)
  ;; CHECK-NEXT:        (try_table (catch_all_ref $l10)
  ;; CHECK-NEXT:         (call $foo)
  ;; CHECK-NEXT:        )
  ;; CHECK-NEXT:        (br $outer1)
  ;; CHECK-NEXT:       )
  ;; CHECK-NEXT:      )
  ;; CHECK-NEXT:     )
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:    (throw_ref
  ;; CHECK-NEXT:     (local.get $0)
  ;; CHECK-NEXT:    )
  ;; CHECK-NEXT:   )
  ;; CHECK-NEXT:  )
  ;; CHECK-NEXT: )
  ;; STACKIR-OPT:      (func $try-catch-rethrow-with-inner-delegate (type $1)
  ;; STACKIR-OPT-NEXT:  (local $0 exnref)
  ;; STACKIR-OPT-NEXT:  block $outer2
  ;; STACKIR-OPT-NEXT:   block $catch3 (result (ref exn))
  ;; STACKIR-OPT-NEXT:    try_table (catch_ref $e-empty $catch3)
  ;; STACKIR-OPT-NEXT:     call $foo
  ;; STACKIR-OPT-NEXT:    end
  ;; STACKIR-OPT-NEXT:    br $outer2
  ;; STACKIR-OPT-NEXT:   end
  ;; STACKIR-OPT-NEXT:   block $outer1
  ;; STACKIR-OPT-NEXT:    try_table
  ;; STACKIR-OPT-NEXT:     block $l10 (result exnref)
  ;; STACKIR-OPT-NEXT:      try_table (catch_all_ref $l10)
  ;; STACKIR-OPT-NEXT:       call $foo
  ;; STACKIR-OPT-NEXT:      end
  ;; STACKIR-OPT-NEXT:      br $outer1
  ;; STACKIR-OPT-NEXT:     end
  ;; STACKIR-OPT-NEXT:     throw_ref
  ;; STACKIR-OPT-NEXT:    end
  ;; STACKIR-OPT-NEXT:    unreachable
  ;; STACKIR-OPT-NEXT:   end
  ;; STACKIR-OPT-NEXT:   throw_ref
  ;; STACKIR-OPT-NEXT:  end
  ;; STACKIR-OPT-NEXT: )
  (func $try-catch-rethrow-with-inner-delegate
    (try $l0
      (do
        (call $foo)
      )
      (catch $e-empty
        (try $l1
          (do
            (try
              (do
                (call $foo)
              )
              (delegate $l1)
            )
          )
        )
        (rethrow $l0)
      )
    )
  )
)