Method throwException

lib/executor/helper.cpp:265–307

}

Expect<void> Executor::throwException(
    Runtime::StackManager &StackMgr, Runtime::Instance::TagInstance &TagInst,
    AST::InstrView::iterator &PC,
    const Runtime::Instance::ExceptionInstance *ExnInst) noexcept {
  StackMgr.removeInactiveHandler(PC);
  auto AssocValSize = TagInst.getTagType().getAssocValSize();
  while (true) {
    // Pop the top handler.
    auto Handler = StackMgr.popTopHandler(AssocValSize);
    if (!Handler.has_value()) {
      break;
    }
    // Checking through the catch clause.
    for (const auto &C : Handler->CatchClause) {
      if (!C.IsAll && getTagInstByIdx(StackMgr, C.TagIndex) != &TagInst) {
        // Specific-tag clauses require tag-address equivalence; skip the
        // ones that do not match.
        continue;
      }
      if (C.IsRef) {
        // Allocate the exception instance lazily on the first catch_ref;
        // reuse the one passed in by throw_ref to preserve exnref identity.
        const Runtime::Instance::ExceptionInstance *Inst = ExnInst;
        if (Inst == nullptr) {
          auto Payload = StackMgr.getTopSpan(AssocValSize);
          std::vector<ValVariant> Vec(Payload.begin(), Payload.end());
          auto *ModInst = const_cast<Runtime::Instance::ModuleInstance *>(
              StackMgr.getModule());
          Inst = ModInst->newException(&TagInst, std::move(Vec));
        }
        StackMgr.push(
            RefVariant(ValType(TypeCode::Ref, TypeCode::ExnRef), Inst));
      }
      // When an exception is caught, move the PC to the try block and branch to
      // the label.

      PC = Handler->Try;
      return branchToLabel(StackMgr, C.Jump, PC);
    }
  }
  spdlog::error(ErrCode::Value::UncaughtException);
  return Unexpect(ErrCode::Value::UncaughtException);
}

Expect<void>
Executor::checkOffsetOverflow(const Runtime::Instance::MemoryInstance &MemInst,