Method OnTryTableExpr

src/interp/binary-reader-interp.cc:1670–1742

}

Result BinaryReaderInterp::OnTryTableExpr(Type sig_type,
                                          const CatchClauseVector& catches) {
  // we can just emit the catch handlers beforehand, so long as we skip over
  // them when entering the try.
  CHECK_RESULT(validator_.BeginTryTable(GetLocation(), sig_type));

  u32 exn_stack_height;
  CHECK_RESULT(
      validator_.GetCatchCount(label_stack_.size() - 1, &exn_stack_height));
  // NOTE: *NOT* GetLocalCount. we don't count the parameters, as they're not
  // part of the frame.
  u32 value_stack_height = validator_.type_stack_size() + local_count_;

  HandlerDesc desc =
      HandlerDesc{HandlerKind::Catch,        Istream::kInvalidOffset,
                  Istream::kInvalidOffset,   {},
                  {Istream::kInvalidOffset}, value_stack_height,
                  exn_stack_height};

  istream_.Emit(Opcode::Br);
  auto offset = istream_.EmitFixupU32();

  bool has_catch_all = false;
  for (const auto& raw_catch : catches) {
    TableCatch catch_;
    catch_.kind = raw_catch.kind;
    catch_.tag = Var(raw_catch.tag, GetLocation());
    catch_.target = Var(raw_catch.depth, GetLocation());
    CHECK_RESULT(validator_.OnTryTableCatch(GetLocation(), catch_));
    // stop emitting handlers after catch_all - but we must still validate the
    // handlers we don't emit
    if (has_catch_all) {
      continue;
    }
    if (catch_.IsCatchAll()) {
      has_catch_all = true;
      desc.catch_all_ref = catch_.IsRef();
      desc.catch_all_offset = istream_.end();
    } else {
      desc.catches.push_back(
          CatchDesc{raw_catch.tag, istream_.end(), catch_.IsRef()});
    }
    // we can't use GetBrDropKeepCount because we're not in a real block.
    SharedValidator::Label* vlabel;
    CHECK_RESULT(validator_.GetLabel(raw_catch.depth, &vlabel));
    // we keep the exception's results.
    // (this has already been validated, above)
    Index keep_count = vlabel->br_types().size();
    // we drop everything between the current block and the br target.
    // (we have already taken the TryTable block parameters into account, in
    // BeginTryTable)
    Index drop_count = validator_.type_stack_size() - vlabel->type_stack_limit;
    Index catch_drop_count;
    // we use the regular catch count
    CHECK_RESULT(validator_.GetCatchCount(raw_catch.depth, &catch_drop_count));
    // but increment, as we are semantically in a catch
    catch_drop_count++;
    EmitBr(raw_catch.depth, drop_count, keep_count, catch_drop_count);