Get rid of recursion in tvm continuations

SpyCheese · SpyCheese · commit b5734d2e30b9 · 2024-09-20T15:16:27.000+03:00
diff --git a/crypto/vm/continuation.cpp b/crypto/vm/continuation.cpp
@@ -27,8 +27,8 @@
 
 namespace vm {
 
-int Continuation::jump_w(VmState* st) & {
-  return static_cast<const Continuation*>(this)->jump(st);
+td::Ref<Continuation> Continuation::jump_w(VmState* st, int& exitcode) & {
+  return static_cast<const Continuation*>(this)->jump(st, exitcode);
 }
 
 bool Continuation::has_c0() const {
@@ -286,15 +286,16 @@ std::string QuitCont::type() const {
   return "vmc_quit";
 }
 
-int ExcQuitCont::jump(VmState* st) const & {
+td::Ref<Continuation> ExcQuitCont::jump(VmState* st, int& exitcode) const& {
   int n = 0;
   try {
     n = st->get_stack().pop_smallint_range(0xffff);
   } catch (const VmError& vme) {
     n = vme.get_errno();
   }
   VM_LOG(st) << "default exception handler, terminating vm with exit code " << n;
-  return ~n;
+  exitcode = ~n;
+  return {};
 }
 
 std::string ExcQuitCont::type() const {
@@ -311,16 +312,16 @@ Ref<ExcQuitCont> ExcQuitCont::deserialize(CellSlice& cs, int mode) {
   return cs.fetch_ulong(4) == 9 ? Ref<ExcQuitCont>{true} : Ref<ExcQuitCont>{};
 }
 
-int PushIntCont::jump(VmState* st) const & {
+td::Ref<Continuation> PushIntCont::jump(VmState* st, int& exitcode) const& {
   VM_LOG(st) << "execute implicit PUSH " << push_val << " (slow)";
   st->get_stack().push_smallint(push_val);
-  return st->jump(next);
+  return next;
 }
 
-int PushIntCont::jump_w(VmState* st) & {
+td::Ref<Continuation> PushIntCont::jump_w(VmState* st, int& exitcode) & {
   VM_LOG(st) << "execute implicit PUSH " << push_val;
   st->get_stack().push_smallint(push_val);
-  return st->jump(std::move(next));
+  return std::move(next);
 }
 
 std::string PushIntCont::type() const {
@@ -345,20 +346,20 @@ Ref<PushIntCont> PushIntCont::deserialize(CellSlice& cs, int mode) {
   }
 }
 
-int ArgContExt::jump(VmState* st) const & {
+td::Ref<Continuation> ArgContExt::jump(VmState* st, int& exitcode) const& {
   st->adjust_cr(data.save);
   if (data.cp != -1) {
     st->force_cp(data.cp);
   }
-  return ext->jump(st);
+  return ext;
 }
 
-int ArgContExt::jump_w(VmState* st) & {
+td::Ref<Continuation> ArgContExt::jump_w(VmState* st, int& exitcode) & {
   st->adjust_cr(std::move(data.save));
   if (data.cp != -1) {
     st->force_cp(data.cp);
   }
-  return st->jump_to(std::move(ext));
+  return std::move(ext);
 }
 
 bool ArgContExt::serialize(CellBuilder& cb) const {
@@ -382,32 +383,32 @@ std::string ArgContExt::type() const {
   return "vmc_envelope";
 }
 
-int RepeatCont::jump(VmState* st) const & {
+td::Ref<Continuation> RepeatCont::jump(VmState* st, int& exitcode) const& {
   VM_LOG(st) << "repeat " << count << " more times (slow)\n";
   if (count <= 0) {
-    return st->jump(after);
+    return after;
   }
   if (body->has_c0()) {
-    return st->jump(body);
+    return body;
   }
   st->set_c0(Ref<RepeatCont>{true, body, after, count - 1});
-  return st->jump(body);
+  return body;
 }
 
-int RepeatCont::jump_w(VmState* st) & {
+td::Ref<Continuation> RepeatCont::jump_w(VmState* st, int& exitcode) & {
   VM_LOG(st) << "repeat " << count << " more times\n";
   if (count <= 0) {
     body.clear();
-    return st->jump(std::move(after));
+    return std::move(after);
   }
   if (body->has_c0()) {
     after.clear();
-    return st->jump(std::move(body));
+    return std::move(body);
   }
   // optimization: since this is unique, reuse *this instead of creating new object
   --count;
   st->set_c0(Ref<RepeatCont>{this});
-  return st->jump(body);
+  return body;
 }
 
 bool RepeatCont::serialize(CellBuilder& cb) const {
@@ -443,21 +444,21 @@ int VmState::repeat(Ref<Continuation> body, Ref<Continuation> after, long long c
   }
 }
 
-int AgainCont::jump(VmState* st) const & {
+td::Ref<Continuation> AgainCont::jump(VmState* st, int& exitcode) const& {
   VM_LOG(st) << "again an infinite loop iteration (slow)\n";
   if (!body->has_c0()) {
     st->set_c0(Ref<AgainCont>{this});
   }
-  return st->jump(body);
+  return body;
 }
 
-int AgainCont::jump_w(VmState* st) & {
+td::Ref<Continuation> AgainCont::jump_w(VmState* st, int& exitcode) & {
   VM_LOG(st) << "again an infinite loop iteration\n";
   if (!body->has_c0()) {
     st->set_c0(Ref<AgainCont>{this});
-    return st->jump(body);
+    return body;
   } else {
-    return st->jump(std::move(body));
+    return std::move(body);
   }
 }
 
@@ -485,31 +486,31 @@ int VmState::again(Ref<Continuation> body) {
   return jump(Ref<AgainCont>{true, std::move(body)});
 }
 
-int UntilCont::jump(VmState* st) const & {
+td::Ref<Continuation> UntilCont::jump(VmState* st, int& exitcode) const& {
   VM_LOG(st) << "until loop body end (slow)\n";
   if (st->get_stack().pop_bool()) {
     VM_LOG(st) << "until loop terminated\n";
-    return st->jump(after);
+    return after;
   }
   if (!body->has_c0()) {
     st->set_c0(Ref<UntilCont>{this});
   }
-  return st->jump(body);
+  return body;
 }
 
-int UntilCont::jump_w(VmState* st) & {
+td::Ref<Continuation> UntilCont::jump_w(VmState* st, int& exitcode) & {
   VM_LOG(st) << "until loop body end\n";
   if (st->get_stack().pop_bool()) {
     VM_LOG(st) << "until loop terminated\n";
     body.clear();
-    return st->jump(std::move(after));
+    return std::move(after);
   }
   if (!body->has_c0()) {
     st->set_c0(Ref<UntilCont>{this});
-    return st->jump(body);
+    return body;
   } else {
     after.clear();
-    return st->jump(std::move(body));
+    return std::move(body);
   }
 }
 
@@ -541,54 +542,54 @@ int VmState::until(Ref<Continuation> body, Ref<Continuation> after) {
   return jump(std::move(body));
 }
 
-int WhileCont::jump(VmState* st) const & {
+td::Ref<Continuation> WhileCont::jump(VmState* st, int& exitcode) const& {
   if (chkcond) {
     VM_LOG(st) << "while loop condition end (slow)\n";
     if (!st->get_stack().pop_bool()) {
       VM_LOG(st) << "while loop terminated\n";
-      return st->jump(after);
+      return after;
     }
     if (!body->has_c0()) {
       st->set_c0(Ref<WhileCont>{true, cond, body, after, false});
     }
-    return st->jump(body);
+    return body;
   } else {
     VM_LOG(st) << "while loop body end (slow)\n";
     if (!cond->has_c0()) {
       st->set_c0(Ref<WhileCont>{true, cond, body, after, true});
     }
-    return st->jump(cond);
+    return cond;
   }
 }
 
-int WhileCont::jump_w(VmState* st) & {
+td::Ref<Continuation> WhileCont::jump_w(VmState* st, int& exitcode) & {
   if (chkcond) {
     VM_LOG(st) << "while loop condition end\n";
     if (!st->get_stack().pop_bool()) {
       VM_LOG(st) << "while loop terminated\n";
       cond.clear();
       body.clear();
-      return st->jump(std::move(after));
+      return std::move(after);
     }
     if (!body->has_c0()) {
       chkcond = false;  // re-use current object since we hold the unique pointer to it
       st->set_c0(Ref<WhileCont>{this});
-      return st->jump(body);
+      return body;
     } else {
       cond.clear();
       after.clear();
-      return st->jump(std::move(body));
+      return std::move(body);
     }
   } else {
     VM_LOG(st) << "while loop body end\n";
     if (!cond->has_c0()) {
       chkcond = true;  // re-use current object
       st->set_c0(Ref<WhileCont>{this});
-      return st->jump(cond);
+      return cond;
     } else {
       body.clear();
       after.clear();
-      return st->jump(std::move(cond));
+      return std::move(cond);
     }
   }
 }
@@ -627,16 +628,16 @@ int VmState::loop_while(Ref<Continuation> cond, Ref<Continuation> body, Ref<Cont
   return jump(std::move(cond));
 }
 
-int OrdCont::jump(VmState* st) const & {
+td::Ref<Continuation> OrdCont::jump(VmState* st, int& exitcode) const& {
   st->adjust_cr(data.save);
   st->set_code(code, data.cp);
-  return 0;
+  return {};
 }
 
-int OrdCont::jump_w(VmState* st) & {
+td::Ref<Continuation> OrdCont::jump_w(VmState* st, int& exitcode) & {
   st->adjust_cr(std::move(data.save));
   st->set_code(std::move(code), data.cp);
-  return 0;
+  return {};
 }
 
 bool OrdCont::serialize(CellBuilder& cb) const {
diff --git a/crypto/vm/continuation.h b/crypto/vm/continuation.h
@@ -161,8 +161,8 @@ struct ControlData {
 
 class Continuation : public td::CntObject {
  public:
-  virtual int jump(VmState* st) const & = 0;
-  virtual int jump_w(VmState* st) &;
+  virtual td::Ref<Continuation> jump(VmState* st, int& exitcode) const& = 0;
+  virtual td::Ref<Continuation> jump_w(VmState* st, int& exitcode) &;
   virtual ControlData* get_cdata() {
     return 0;
   }
@@ -203,8 +203,9 @@ class QuitCont : public Continuation {
   QuitCont(int _code = 0) : exit_code(_code) {
   }
   ~QuitCont() override = default;
-  int jump(VmState* st) const & override {
-    return ~exit_code;
+  td::Ref<Continuation> jump(VmState* st, int& exitcode) const& override {
+    exitcode = ~exit_code;
+    return {};
   }
   bool serialize(CellBuilder& cb) const override;
   static Ref<QuitCont> deserialize(CellSlice& cs, int mode = 0);
@@ -215,7 +216,7 @@ class ExcQuitCont : public Continuation {
  public:
   ExcQuitCont() = default;
   ~ExcQuitCont() override = default;
-  int jump(VmState* st) const & override;
+  td::Ref<Continuation> jump(VmState* st, int& exitcode) const& override;
   bool serialize(CellBuilder& cb) const override;
   static Ref<ExcQuitCont> deserialize(CellSlice& cs, int mode = 0);
   std::string type() const override;
@@ -229,8 +230,8 @@ class PushIntCont : public Continuation {
   PushIntCont(int val, Ref<Continuation> _next) : push_val(val), next(_next) {
   }
   ~PushIntCont() override = default;
-  int jump(VmState* st) const & override;
-  int jump_w(VmState* st) & override;
+  td::Ref<Continuation> jump(VmState* st, int& exitcode) const& override;
+  td::Ref<Continuation> jump_w(VmState* st, int& exitcode) & override;
   bool serialize(CellBuilder& cb) const override;
   static Ref<PushIntCont> deserialize(CellSlice& cs, int mode = 0);
   std::string type() const override;
@@ -245,8 +246,8 @@ class RepeatCont : public Continuation {
       : body(std::move(_body)), after(std::move(_after)), count(_count) {
   }
   ~RepeatCont() override = default;
-  int jump(VmState* st) const & override;
-  int jump_w(VmState* st) & override;
+  td::Ref<Continuation> jump(VmState* st, int& exitcode) const& override;
+  td::Ref<Continuation> jump_w(VmState* st, int& exitcode) & override;
   bool serialize(CellBuilder& cb) const override;
   static Ref<RepeatCont> deserialize(CellSlice& cs, int mode = 0);
   std::string type() const override;
@@ -259,8 +260,8 @@ class AgainCont : public Continuation {
   AgainCont(Ref<Continuation> _body) : body(std::move(_body)) {
   }
   ~AgainCont() override = default;
-  int jump(VmState* st) const & override;
-  int jump_w(VmState* st) & override;
+  td::Ref<Continuation> jump(VmState* st, int& exitcode) const& override;
+  td::Ref<Continuation> jump_w(VmState* st, int& exitcode) & override;
   bool serialize(CellBuilder& cb) const override;
   static Ref<AgainCont> deserialize(CellSlice& cs, int mode = 0);
   std::string type() const override;
@@ -273,8 +274,8 @@ class UntilCont : public Continuation {
   UntilCont(Ref<Continuation> _body, Ref<Continuation> _after) : body(std::move(_body)), after(std::move(_after)) {
   }
   ~UntilCont() override = default;
-  int jump(VmState* st) const & override;
-  int jump_w(VmState* st) & override;
+  td::Ref<Continuation> jump(VmState* st, int& exitcode) const& override;
+  td::Ref<Continuation> jump_w(VmState* st, int& exitcode) & override;
   bool serialize(CellBuilder& cb) const override;
   static Ref<UntilCont> deserialize(CellSlice& cs, int mode = 0);
   std::string type() const override;
@@ -289,8 +290,8 @@ class WhileCont : public Continuation {
       : cond(std::move(_cond)), body(std::move(_body)), after(std::move(_after)), chkcond(_chk) {
   }
   ~WhileCont() override = default;
-  int jump(VmState* st) const & override;
-  int jump_w(VmState* st) & override;
+  td::Ref<Continuation> jump(VmState* st, int& exitcode) const& override;
+  td::Ref<Continuation> jump_w(VmState* st, int& exitcode) & override;
   bool serialize(CellBuilder& cb) const override;
   static Ref<WhileCont> deserialize(CellSlice& cs, int mode = 0);
   std::string type() const override;
@@ -312,8 +313,8 @@ class ArgContExt : public Continuation {
   ArgContExt(const ArgContExt&) = default;
   ArgContExt(ArgContExt&&) = default;
   ~ArgContExt() override = default;
-  int jump(VmState* st) const & override;
-  int jump_w(VmState* st) & override;
+  td::Ref<Continuation> jump(VmState* st, int& exitcode) const& override;
+  td::Ref<Continuation> jump_w(VmState* st, int& exitcode) & override;
   ControlData* get_cdata() override {
     return &data;
   }
@@ -354,8 +355,8 @@ class OrdCont : public Continuation {
   td::CntObject* make_copy() const override {
     return new OrdCont{*this};
   }
-  int jump(VmState* st) const & override;
-  int jump_w(VmState* st) & override;
+  td::Ref<Continuation> jump(VmState* st, int& exitcode) const& override;
+  td::Ref<Continuation> jump_w(VmState* st, int& exitcode) & override;
 
   ControlData* get_cdata() override {
     return &data;
diff --git a/crypto/vm/vm.h b/crypto/vm/vm.h
@@ -370,7 +370,11 @@ class VmState final : public VmStateInterface {
     throw VmFatal{};
   }
   int jump_to(Ref<Continuation> cont) {
-    return cont->is_unique() ? cont.unique_write().jump_w(this) : cont->jump(this);
+    int res = 0;
+    while (cont.not_null()) {
+      cont = cont->is_unique() ? cont.unique_write().jump_w(this, res) : cont->jump(this, res);
+    }
+    return res;
   }
   static Ref<CellSlice> convert_code_cell(Ref<Cell> code_cell);
   bool try_commit();

Original file line number	Diff line number	Diff line change
`@@ -27,8 +27,8 @@`
`27`	`27`
`28`	`28`	`namespace vm {`
`29`	`29`
`30`		`-int Continuation::jump_w(VmState* st) & {`
`31`		`- return static_cast<const Continuation*>(this)->jump(st);`
	`30`	`+td::Ref<Continuation> Continuation::jump_w(VmState* st, int& exitcode) & {`
	`31`	`+ return static_cast<const Continuation*>(this)->jump(st, exitcode);`
`32`	`32`	`}`
`33`	`33`
`34`	`34`	`bool Continuation::has_c0() const {`
`@@ -286,15 +286,16 @@ std::string QuitCont::type() const {`
`286`	`286`	`return "vmc_quit";`
`287`	`287`	`}`
`288`	`288`
`289`		`-int ExcQuitCont::jump(VmState* st) const & {`
	`289`	`+td::Ref<Continuation> ExcQuitCont::jump(VmState* st, int& exitcode) const& {`
`290`	`290`	`int n = 0;`
`291`	`291`	`try {`
`292`	`292`	`n = st->get_stack().pop_smallint_range(0xffff);`
`293`	`293`	`} catch (const VmError& vme) {`
`294`	`294`	`n = vme.get_errno();`
`295`	`295`	`}`
`296`	`296`	`VM_LOG(st) << "default exception handler, terminating vm with exit code " << n;`
`297`		`- return ~n;`
	`297`	`+ exitcode = ~n;`
	`298`	`+ return {};`
`298`	`299`	`}`
`299`	`300`
`300`	`301`	`std::string ExcQuitCont::type() const {`
`@@ -311,16 +312,16 @@ Ref<ExcQuitCont> ExcQuitCont::deserialize(CellSlice& cs, int mode) {`
`311`	`312`	`return cs.fetch_ulong(4) == 9 ? Ref<ExcQuitCont>{true} : Ref<ExcQuitCont>{};`
`312`	`313`	`}`
`313`	`314`
`314`		`-int PushIntCont::jump(VmState* st) const & {`
	`315`	`+td::Ref<Continuation> PushIntCont::jump(VmState* st, int& exitcode) const& {`
`315`	`316`	`VM_LOG(st) << "execute implicit PUSH " << push_val << " (slow)";`
`316`	`317`	`st->get_stack().push_smallint(push_val);`
`317`		`- return st->jump(next);`
	`318`	`+ return next;`
`318`	`319`	`}`
`319`	`320`
`320`		`-int PushIntCont::jump_w(VmState* st) & {`
	`321`	`+td::Ref<Continuation> PushIntCont::jump_w(VmState* st, int& exitcode) & {`
`321`	`322`	`VM_LOG(st) << "execute implicit PUSH " << push_val;`
`322`	`323`	`st->get_stack().push_smallint(push_val);`
`323`		`- return st->jump(std::move(next));`
	`324`	`+ return std::move(next);`
`324`	`325`	`}`
`325`	`326`
`326`	`327`	`std::string PushIntCont::type() const {`
`@@ -345,20 +346,20 @@ Ref<PushIntCont> PushIntCont::deserialize(CellSlice& cs, int mode) {`
`345`	`346`	`}`
`346`	`347`	`}`
`347`	`348`
`348`		`-int ArgContExt::jump(VmState* st) const & {`
	`349`	`+td::Ref<Continuation> ArgContExt::jump(VmState* st, int& exitcode) const& {`
`349`	`350`	`st->adjust_cr(data.save);`
`350`	`351`	`if (data.cp != -1) {`
`351`	`352`	`st->force_cp(data.cp);`
`352`	`353`	`}`
`353`		`- return ext->jump(st);`
	`354`	`+ return ext;`
`354`	`355`	`}`
`355`	`356`
`356`		`-int ArgContExt::jump_w(VmState* st) & {`
	`357`	`+td::Ref<Continuation> ArgContExt::jump_w(VmState* st, int& exitcode) & {`
`357`	`358`	`st->adjust_cr(std::move(data.save));`
`358`	`359`	`if (data.cp != -1) {`
`359`	`360`	`st->force_cp(data.cp);`
`360`	`361`	`}`
`361`		`- return st->jump_to(std::move(ext));`
	`362`	`+ return std::move(ext);`
`362`	`363`	`}`
`363`	`364`
`364`	`365`	`bool ArgContExt::serialize(CellBuilder& cb) const {`
`@@ -382,32 +383,32 @@ std::string ArgContExt::type() const {`
`382`	`383`	`return "vmc_envelope";`
`383`	`384`	`}`
`384`	`385`
`385`		`-int RepeatCont::jump(VmState* st) const & {`
	`386`	`+td::Ref<Continuation> RepeatCont::jump(VmState* st, int& exitcode) const& {`
`386`	`387`	`VM_LOG(st) << "repeat " << count << " more times (slow)\n";`
`387`	`388`	`if (count <= 0) {`
`388`		`- return st->jump(after);`
	`389`	`+ return after;`
`389`	`390`	`}`
`390`	`391`	`if (body->has_c0()) {`
`391`		`- return st->jump(body);`
	`392`	`+ return body;`
`392`	`393`	`}`
`393`	`394`	`st->set_c0(Ref<RepeatCont>{true, body, after, count - 1});`
`394`		`- return st->jump(body);`
	`395`	`+ return body;`
`395`	`396`	`}`
`396`	`397`
`397`		`-int RepeatCont::jump_w(VmState* st) & {`
	`398`	`+td::Ref<Continuation> RepeatCont::jump_w(VmState* st, int& exitcode) & {`
`398`	`399`	`VM_LOG(st) << "repeat " << count << " more times\n";`
`399`	`400`	`if (count <= 0) {`
`400`	`401`	`body.clear();`
`401`		`- return st->jump(std::move(after));`
	`402`	`+ return std::move(after);`
`402`	`403`	`}`
`403`	`404`	`if (body->has_c0()) {`
`404`	`405`	`after.clear();`
`405`		`- return st->jump(std::move(body));`
	`406`	`+ return std::move(body);`
`406`	`407`	`}`
`407`	`408`	`// optimization: since this is unique, reuse *this instead of creating new object`
`408`	`409`	`--count;`
`409`	`410`	`st->set_c0(Ref<RepeatCont>{this});`
`410`		`- return st->jump(body);`
	`411`	`+ return body;`
`411`	`412`	`}`
`412`	`413`
`413`	`414`	`bool RepeatCont::serialize(CellBuilder& cb) const {`
`@@ -443,21 +444,21 @@ int VmState::repeat(Ref<Continuation> body, Ref<Continuation> after, long long c`
`443`	`444`	`}`
`444`	`445`	`}`
`445`	`446`
`446`		`-int AgainCont::jump(VmState* st) const & {`
	`447`	`+td::Ref<Continuation> AgainCont::jump(VmState* st, int& exitcode) const& {`
`447`	`448`	`VM_LOG(st) << "again an infinite loop iteration (slow)\n";`
`448`	`449`	`if (!body->has_c0()) {`
`449`	`450`	`st->set_c0(Ref<AgainCont>{this});`
`450`	`451`	`}`
`451`		`- return st->jump(body);`
	`452`	`+ return body;`
`452`	`453`	`}`
`453`	`454`
`454`		`-int AgainCont::jump_w(VmState* st) & {`
	`455`	`+td::Ref<Continuation> AgainCont::jump_w(VmState* st, int& exitcode) & {`
`455`	`456`	`VM_LOG(st) << "again an infinite loop iteration\n";`
`456`	`457`	`if (!body->has_c0()) {`
`457`	`458`	`st->set_c0(Ref<AgainCont>{this});`
`458`		`- return st->jump(body);`
	`459`	`+ return body;`
`459`	`460`	`} else {`
`460`		`- return st->jump(std::move(body));`
	`461`	`+ return std::move(body);`
`461`	`462`	`}`
`462`	`463`	`}`
`463`	`464`
`@@ -485,31 +486,31 @@ int VmState::again(Ref<Continuation> body) {`
`485`	`486`	`return jump(Ref<AgainCont>{true, std::move(body)});`
`486`	`487`	`}`
`487`	`488`
`488`		`-int UntilCont::jump(VmState* st) const & {`
	`489`	`+td::Ref<Continuation> UntilCont::jump(VmState* st, int& exitcode) const& {`
`489`	`490`	`VM_LOG(st) << "until loop body end (slow)\n";`
`490`	`491`	`if (st->get_stack().pop_bool()) {`
`491`	`492`	`VM_LOG(st) << "until loop terminated\n";`
`492`		`- return st->jump(after);`
	`493`	`+ return after;`
`493`	`494`	`}`
`494`	`495`	`if (!body->has_c0()) {`
`495`	`496`	`st->set_c0(Ref<UntilCont>{this});`
`496`	`497`	`}`
`497`		`- return st->jump(body);`
	`498`	`+ return body;`
`498`	`499`	`}`
`499`	`500`
`500`		`-int UntilCont::jump_w(VmState* st) & {`
	`501`	`+td::Ref<Continuation> UntilCont::jump_w(VmState* st, int& exitcode) & {`
`501`	`502`	`VM_LOG(st) << "until loop body end\n";`
`502`	`503`	`if (st->get_stack().pop_bool()) {`
`503`	`504`	`VM_LOG(st) << "until loop terminated\n";`
`504`	`505`	`body.clear();`
`505`		`- return st->jump(std::move(after));`
	`506`	`+ return std::move(after);`
`506`	`507`	`}`
`507`	`508`	`if (!body->has_c0()) {`
`508`	`509`	`st->set_c0(Ref<UntilCont>{this});`
`509`		`- return st->jump(body);`
	`510`	`+ return body;`
`510`	`511`	`} else {`
`511`	`512`	`after.clear();`
`512`		`- return st->jump(std::move(body));`
	`513`	`+ return std::move(body);`
`513`	`514`	`}`
`514`	`515`	`}`
`515`	`516`
`@@ -541,54 +542,54 @@ int VmState::until(Ref<Continuation> body, Ref<Continuation> after) {`
`541`	`542`	`return jump(std::move(body));`
`542`	`543`	`}`
`543`	`544`
`544`		`-int WhileCont::jump(VmState* st) const & {`
	`545`	`+td::Ref<Continuation> WhileCont::jump(VmState* st, int& exitcode) const& {`
`545`	`546`	`if (chkcond) {`
`546`	`547`	`VM_LOG(st) << "while loop condition end (slow)\n";`
`547`	`548`	`if (!st->get_stack().pop_bool()) {`
`548`	`549`	`VM_LOG(st) << "while loop terminated\n";`
`549`		`- return st->jump(after);`
	`550`	`+ return after;`
`550`	`551`	`}`
`551`	`552`	`if (!body->has_c0()) {`
`552`	`553`	`st->set_c0(Ref<WhileCont>{true, cond, body, after, false});`
`553`	`554`	`}`
`554`		`- return st->jump(body);`
	`555`	`+ return body;`
`555`	`556`	`} else {`
`556`	`557`	`VM_LOG(st) << "while loop body end (slow)\n";`
`557`	`558`	`if (!cond->has_c0()) {`
`558`	`559`	`st->set_c0(Ref<WhileCont>{true, cond, body, after, true});`
`559`	`560`	`}`
`560`		`- return st->jump(cond);`
	`561`	`+ return cond;`
`561`	`562`	`}`
`562`	`563`	`}`
`563`	`564`
`564`		`-int WhileCont::jump_w(VmState* st) & {`
	`565`	`+td::Ref<Continuation> WhileCont::jump_w(VmState* st, int& exitcode) & {`
`565`	`566`	`if (chkcond) {`
`566`	`567`	`VM_LOG(st) << "while loop condition end\n";`
`567`	`568`	`if (!st->get_stack().pop_bool()) {`
`568`	`569`	`VM_LOG(st) << "while loop terminated\n";`
`569`	`570`	`cond.clear();`
`570`	`571`	`body.clear();`
`571`		`- return st->jump(std::move(after));`
	`572`	`+ return std::move(after);`
`572`	`573`	`}`
`573`	`574`	`if (!body->has_c0()) {`
`574`	`575`	`chkcond = false; // re-use current object since we hold the unique pointer to it`
`575`	`576`	`st->set_c0(Ref<WhileCont>{this});`
`576`		`- return st->jump(body);`
	`577`	`+ return body;`
`577`	`578`	`} else {`
`578`	`579`	`cond.clear();`
`579`	`580`	`after.clear();`
`580`		`- return st->jump(std::move(body));`
	`581`	`+ return std::move(body);`
`581`	`582`	`}`
`582`	`583`	`} else {`
`583`	`584`	`VM_LOG(st) << "while loop body end\n";`
`584`	`585`	`if (!cond->has_c0()) {`
`585`	`586`	`chkcond = true; // re-use current object`
`586`	`587`	`st->set_c0(Ref<WhileCont>{this});`
`587`		`- return st->jump(cond);`
	`588`	`+ return cond;`
`588`	`589`	`} else {`
`589`	`590`	`body.clear();`
`590`	`591`	`after.clear();`
`591`		`- return st->jump(std::move(cond));`
	`592`	`+ return std::move(cond);`
`592`	`593`	`}`
`593`	`594`	`}`
`594`	`595`	`}`
`@@ -627,16 +628,16 @@ int VmState::loop_while(Ref<Continuation> cond, Ref<Continuation> body, Ref<Cont`
`627`	`628`	`return jump(std::move(cond));`
`628`	`629`	`}`
`629`	`630`
`630`		`-int OrdCont::jump(VmState* st) const & {`
	`631`	`+td::Ref<Continuation> OrdCont::jump(VmState* st, int& exitcode) const& {`
`631`	`632`	`st->adjust_cr(data.save);`
`632`	`633`	`st->set_code(code, data.cp);`
`633`		`- return 0;`
	`634`	`+ return {};`
`634`	`635`	`}`
`635`	`636`
`636`		`-int OrdCont::jump_w(VmState* st) & {`
	`637`	`+td::Ref<Continuation> OrdCont::jump_w(VmState* st, int& exitcode) & {`
`637`	`638`	`st->adjust_cr(std::move(data.save));`
`638`	`639`	`st->set_code(std::move(code), data.cp);`
`639`		`- return 0;`
	`640`	`+ return {};`
`640`	`641`	`}`
`641`	`642`
`642`	`643`	`bool OrdCont::serialize(CellBuilder& cb) const {`
Original file line number	Diff line number	Diff line change
`@@ -370,7 +370,11 @@ class VmState final : public VmStateInterface {`
`370`	`370`	`throw VmFatal{};`
`371`	`371`	`}`
`372`	`372`	`int jump_to(Ref<Continuation> cont) {`
`373`		`- return cont->is_unique() ? cont.unique_write().jump_w(this) : cont->jump(this);`
	`373`	`+ int res = 0;`
	`374`	`+ while (cont.not_null()) {`
	`375`	`+ cont = cont->is_unique() ? cont.unique_write().jump_w(this, res) : cont->jump(this, res);`
	`376`	`+ }`
	`377`	`+ return res;`
`374`	`378`	`}`
`375`	`379`	`static Ref<CellSlice> convert_code_cell(Ref<Cell> code_cell);`
`376`	`380`	`bool try_commit();`