Remove recursion in binary writer

[Harrm]

Make WriteExpr non-recursive, since recursion there overflows stack.

[turuslan]

Other possible implementations (for reference):

• c++20 co_await
• manual

---

You made good optimization by moving (BinaryWriter, Func) from Coro{BinaryWriter, Func, ...}.resume() to Coro{...}.resume(BinaryWriter, Func).
Your coroutines only work with single BinaryWriter and Func instance, so they can be removed from Coro frame.

[turuslan]

Suggested change

	void WriteExpr(const Func* func, const Expr* expr);
	std::optional<StateVar> WriteExprImpl(const Func* func, const Expr* expr);
	void WriteExprList(const Func* func, const ExprList& exprs);
	void WriteExpr(Deque &stack, const Func* func, const Expr* expr);
	void WriteExprList(Deque &stack, const Func* func, const ExprList& exprs);
	void WriteExprListImpl(const Func* func, const ExprList& exprs);

[turuslan]

(WriteInitExpr | WriteFunc) -> WriteExprList -> (WriteExpr | WriteExprList)*

Suggested change

	void BinaryWriter::WriteExpr(const Func* func, const Expr* top_expr) {
	std::list<StateVar> stack;
	auto write_expr = [&stack, func, this](const Expr* expr) {
	auto opt_state = WriteExprImpl(func, expr);
	if (opt_state.has_value()) {
	auto& state = *opt_state;
	stack.push_back(state);
	}
	};
	write_expr(top_expr);
	while (!stack.empty()) {
	State* state =
	&std::visit([](auto& state) -> State& { return state; }, stack.back());
	auto expr = state->advance(*this, func);
	if (expr) {
	write_expr(expr.value());
	} else {
	stack.pop_back();
	}
	}
	void BinaryWriter::WriteExprListImpl(const Func* func, const ExprList& exprs) {
	std::deque<StateVar> stack;
	WriteExprList(stack, func, exprs);
	while (not stack.empty()) {
	auto expr = std::visit([&](auto& state) { return state.advance(*this, func); }, stack.back());
	if (expr) {
	WriteExpr(stack, expr.value());
	} else {
	stack.pop_back();
	}
	}

[turuslan]

Another possible implementation may use stack<queue<variant<Opcode, ExprList *, U32Leb128>>>,
rewriting like

queue = stack.push([])
queue.push(if.then) // co_await, waits for recursion
if (if.else)
  queue.push(opcode.else) // after co_await, enqueue
  queue.push(if.else)
queue.push(opcode.end)
return // unwind

[turuslan]

Suggested change

	bool in_catch = false;
	size_t current_catch = 0;
	bool setCatch(size_t i) {
	i_catch = i;
	if (i >= expr->catches.size()) {
	return;
	}
	current_expr = expr->catches[i].exprs.begin();
	}
	std::optional<size_t> i_catch;

[turuslan]

Suggested change

	if (!in_catch) {
	if (current_expr != expr->block.exprs.end()) {
	auto res = &*current_expr;
	current_expr++;
	return res;
	} else {
	switch (expr->kind) {
	case TryKind::Catch:
	in_catch = true;
	break;
	case TryKind::Delegate:
	WriteOpcode(writer.stream_, Opcode::Delegate);
	WriteU32Leb128(writer.stream_,
	writer.GetLabelVarDepth(&expr->delegate_target),
	"delegate depth");
	return std::nullopt;
	case TryKind::Plain:
	WriteOpcode(writer.stream_, Opcode::End);
	return std::nullopt;
	}
	}
	}
	// deliberately no else
	if (in_catch) {
	if (current_catch < expr->catches.size()) {
	auto& catch_block = expr->catches[current_catch];
	if (current_expr != catch_block.exprs.end()) {
	if (current_expr == catch_block.exprs.begin()) {
	if (catch_block.IsCatchAll()) {
	WriteOpcode(writer.stream_, Opcode::CatchAll);
	} else {
	WriteOpcode(writer.stream_, Opcode::Catch);
	WriteU32Leb128(writer.stream_,
	writer.GetTagVarDepth(&catch_block.var),
	"catch tag");
	}
	}
	auto res = &*current_expr;
	current_expr++;
	return res;
	} else {
	do {
	current_catch++;
	} while (current_catch < expr->catches.size() &&
	expr->catches[current_catch].exprs.empty());
	if (current_catch < expr->catches.size()) {
	auto& catch_block = expr->catches[current_catch];
	current_expr = catch_block.exprs.begin();
	auto res = &*current_expr;
	current_expr++;
	return res;
	} else {
	WriteOpcode(writer.stream_, Opcode::End);
	return std::nullopt;
	}
	}
	} else {
	WriteOpcode(writer.stream_, Opcode::End);
	return std::nullopt;
	}
	}
	WABT_UNREACHABLE;
	if (not i_catch) {
	if (current_expr != expr->block.exprs.end()) {
	return next();
	}
	switch (expr->kind) {
	case TryKind::Catch:
	break;
	case TryKind::Delegate:
	WriteOpcode(writer.stream_, Opcode::Delegate);
	WriteU32Leb128(writer.stream_,
	writer.GetLabelVarDepth(&expr->delegate_target),
	"delegate depth");
	return std::nullopt;
	case TryKind::Plain:
	WriteOpcode(writer.stream_, Opcode::End);
	return std::nullopt;
	}
	setCatch(0);
	}
	while (true) {
	if (*i_catch >= expr->catches.size()) {
	WriteOpcode(writer.stream_, Opcode::End);
	return std::nullopt;
	}
	auto& catch_block = expr->catches[*i_catch];
	if (current_expr == catch_block.exprs.begin()) {
	if (catch_block.IsCatchAll()) {
	WriteOpcode(writer.stream_, Opcode::CatchAll);
	} else {
	WriteOpcode(writer.stream_, Opcode::Catch);
	WriteU32Leb128(writer.stream_,
	writer.GetTagVarDepth(&catch_block.var),
	"catch tag");
	}
	}
	if (current_expr != catch_block.exprs.end()) {
	return next();
	}
	setCatch(*i_catch + 1);
	}