1 files changed, 92 insertions, 142 deletions
diff --git a/Python/optimizer_bytecodes.c b/Python/optimizer_bytecodes.c
index 928bc03382b..e5c982befb2 100644
--- a/Python/optimizer_bytecodes.c
+++ b/Python/optimizer_bytecodes.c
@@ -23,10 +23,10 @@ typedef struct _Py_UOpsAbstractFrame _Py_UOpsAbstractFrame;
 #define sym_matches_type _Py_uop_sym_matches_type
 #define sym_get_type _Py_uop_sym_get_type
 #define sym_has_type _Py_uop_sym_has_type
-#define sym_set_null _Py_uop_sym_set_null
-#define sym_set_non_null _Py_uop_sym_set_non_null
-#define sym_set_type _Py_uop_sym_set_type
-#define sym_set_const _Py_uop_sym_set_const
+#define sym_set_null(SYM) _Py_uop_sym_set_null(ctx, SYM)
+#define sym_set_non_null(SYM) _Py_uop_sym_set_non_null(ctx, SYM)
+#define sym_set_type(SYM, TYPE) _Py_uop_sym_set_type(ctx, SYM, TYPE)
+#define sym_set_const(SYM, CNST) _Py_uop_sym_set_const(ctx, SYM, CNST)
 #define sym_is_bottom _Py_uop_sym_is_bottom
 #define frame_new _Py_uop_frame_new
 #define frame_pop _Py_uop_frame_pop
@@ -73,7 +73,7 @@ dummy_func(void) {
         value = GETLOCAL(oparg);
         // We guarantee this will error - just bail and don't optimize it.
         if (sym_is_null(value)) {
-            goto out_of_space;
+            ctx->done = true;
         }
     }
 
@@ -83,8 +83,7 @@ dummy_func(void) {
 
     op(_LOAD_FAST_AND_CLEAR, (-- value)) {
         value = GETLOCAL(oparg);
-        _Py_UopsSymbol *temp;
-        OUT_OF_SPACE_IF_NULL(temp = sym_new_null(ctx));
+        _Py_UopsSymbol *temp = sym_new_null(ctx);
         GETLOCAL(oparg) = temp;
     }
 
@@ -94,9 +93,6 @@ dummy_func(void) {
 
     op(_PUSH_NULL, (-- res)) {
         res = sym_new_null(ctx);
-        if (res == NULL) {
-            goto out_of_space;
-        };
     }
 
     op(_GUARD_BOTH_INT, (left, right -- left, right)) {
@@ -113,12 +109,8 @@ dummy_func(void) {
                 REPLACE_OP(this_instr, _GUARD_NOS_INT, 0, 0);
             }
         }
-        if (!sym_set_type(left, &PyLong_Type)) {
-            goto hit_bottom;
-        }
-        if (!sym_set_type(right, &PyLong_Type)) {
-            goto hit_bottom;
-        }
+        sym_set_type(left, &PyLong_Type);
+        sym_set_type(right, &PyLong_Type);
     }
 
     op(_GUARD_BOTH_FLOAT, (left, right -- left, right)) {
@@ -135,12 +127,9 @@ dummy_func(void) {
                 REPLACE_OP(this_instr, _GUARD_NOS_FLOAT, 0, 0);
             }
         }
-        if (!sym_set_type(left, &PyFloat_Type)) {
-            goto hit_bottom;
-        }
-        if (!sym_set_type(right, &PyFloat_Type)) {
-            goto hit_bottom;
-        }
+
+        sym_set_type(left, &PyFloat_Type);
+        sym_set_type(right, &PyFloat_Type);
     }
 
     op(_GUARD_BOTH_UNICODE, (left, right -- left, right)) {
@@ -148,12 +137,8 @@ dummy_func(void) {
             sym_matches_type(right, &PyUnicode_Type)) {
             REPLACE_OP(this_instr, _NOP, 0 ,0);
         }
-        if (!sym_set_type(left, &PyUnicode_Type)) {
-            goto hit_bottom;
-        }
-        if (!sym_set_type(right, &PyUnicode_Type)) {
-            goto hit_bottom;
-        }
+        sym_set_type(left, &PyUnicode_Type);
+        sym_set_type(left, &PyUnicode_Type);
     }
 
     op(_BINARY_OP, (left, right -- res)) {
@@ -165,14 +150,14 @@ dummy_func(void) {
             if (oparg != NB_TRUE_DIVIDE && oparg != NB_INPLACE_TRUE_DIVIDE &&
                 ltype == &PyLong_Type && rtype == &PyLong_Type) {
                 /* If both inputs are ints and the op is not division the result is an int */
-                OUT_OF_SPACE_IF_NULL(res = sym_new_type(ctx, &PyLong_Type));
+                res = sym_new_type(ctx, &PyLong_Type);
             }
             else {
                 /* For any other op combining ints/floats the result is a float */
-                OUT_OF_SPACE_IF_NULL(res = sym_new_type(ctx, &PyFloat_Type));
+                res = sym_new_type(ctx, &PyFloat_Type);
             }
         }
-        OUT_OF_SPACE_IF_NULL(res = sym_new_unknown(ctx));
+        res = sym_new_unknown(ctx);
     }
 
     op(_BINARY_OP_ADD_INT, (left, right -- res)) {
@@ -188,12 +173,11 @@ dummy_func(void) {
             }
             res = sym_new_const(ctx, temp);
             Py_DECREF(temp);
-            OUT_OF_SPACE_IF_NULL(res);
             // TODO gh-115506:
             // replace opcode with constant propagated one and add tests!
         }
         else {
-            OUT_OF_SPACE_IF_NULL(res = sym_new_type(ctx, &PyLong_Type));
+            res = sym_new_type(ctx, &PyLong_Type);
         }
     }
 
@@ -210,12 +194,11 @@ dummy_func(void) {
             }
             res = sym_new_const(ctx, temp);
             Py_DECREF(temp);
-            OUT_OF_SPACE_IF_NULL(res);
             // TODO gh-115506:
             // replace opcode with constant propagated one and add tests!
         }
         else {
-            OUT_OF_SPACE_IF_NULL(res = sym_new_type(ctx, &PyLong_Type));
+            res = sym_new_type(ctx, &PyLong_Type);
         }
     }
 
@@ -232,12 +215,11 @@ dummy_func(void) {
             }
             res = sym_new_const(ctx, temp);
             Py_DECREF(temp);
-            OUT_OF_SPACE_IF_NULL(res);
             // TODO gh-115506:
             // replace opcode with constant propagated one and add tests!
         }
         else {
-            OUT_OF_SPACE_IF_NULL(res = sym_new_type(ctx, &PyLong_Type));
+            res = sym_new_type(ctx, &PyLong_Type);
         }
     }
 
@@ -255,12 +237,11 @@ dummy_func(void) {
             }
             res = sym_new_const(ctx, temp);
             Py_DECREF(temp);
-            OUT_OF_SPACE_IF_NULL(res);
             // TODO gh-115506:
             // replace opcode with constant propagated one and update tests!
         }
         else {
-            OUT_OF_SPACE_IF_NULL(res = sym_new_type(ctx, &PyFloat_Type));
+            res = sym_new_type(ctx, &PyFloat_Type);
         }
     }
 
@@ -278,12 +259,11 @@ dummy_func(void) {
             }
             res = sym_new_const(ctx, temp);
             Py_DECREF(temp);
-            OUT_OF_SPACE_IF_NULL(res);
             // TODO gh-115506:
             // replace opcode with constant propagated one and update tests!
         }
         else {
-            OUT_OF_SPACE_IF_NULL(res = sym_new_type(ctx, &PyFloat_Type));
+            res = sym_new_type(ctx, &PyFloat_Type);
         }
     }
 
@@ -301,12 +281,11 @@ dummy_func(void) {
             }
             res = sym_new_const(ctx, temp);
             Py_DECREF(temp);
-            OUT_OF_SPACE_IF_NULL(res);
             // TODO gh-115506:
             // replace opcode with constant propagated one and update tests!
         }
         else {
-            OUT_OF_SPACE_IF_NULL(res = sym_new_type(ctx, &PyFloat_Type));
+            res = sym_new_type(ctx, &PyFloat_Type);
         }
     }
 
@@ -319,80 +298,50 @@ dummy_func(void) {
             }
             res = sym_new_const(ctx, temp);
             Py_DECREF(temp);
-            OUT_OF_SPACE_IF_NULL(res);
         }
         else {
-            OUT_OF_SPACE_IF_NULL(res = sym_new_type(ctx, &PyUnicode_Type));
+            res = sym_new_type(ctx, &PyUnicode_Type);
         }
     }
 
     op(_TO_BOOL, (value -- res)) {
-        if (optimize_to_bool(this_instr, ctx, value, &res)) {
-            OUT_OF_SPACE_IF_NULL(res);
-        }
-        else {
+        if (!optimize_to_bool(this_instr, ctx, value, &res)) {
             res = sym_new_type(ctx, &PyBool_Type);
-            OUT_OF_SPACE_IF_NULL(res);
         }
     }
 
     op(_TO_BOOL_BOOL, (value -- res)) {
-        if (optimize_to_bool(this_instr, ctx, value, &res)) {
-            OUT_OF_SPACE_IF_NULL(res);
-        }
-        else {
-            if(!sym_set_type(value, &PyBool_Type)) {
-                goto hit_bottom;
-            }
+        if (!optimize_to_bool(this_instr, ctx, value, &res)) {
+            sym_set_type(value, &PyBool_Type);
             res = value;
         }
     }
 
     op(_TO_BOOL_INT, (value -- res)) {
-        if (optimize_to_bool(this_instr, ctx, value, &res)) {
-            OUT_OF_SPACE_IF_NULL(res);
-        }
-        else {
-            if(!sym_set_type(value, &PyLong_Type)) {
-                goto hit_bottom;
-            }
-            OUT_OF_SPACE_IF_NULL(res = sym_new_type(ctx, &PyBool_Type));
+        if (!optimize_to_bool(this_instr, ctx, value, &res)) {
+            sym_set_type(value, &PyLong_Type);
+            res = sym_new_type(ctx, &PyBool_Type);
         }
     }
 
     op(_TO_BOOL_LIST, (value -- res)) {
-        if (optimize_to_bool(this_instr, ctx, value, &res)) {
-            OUT_OF_SPACE_IF_NULL(res);
-        }
-        else {
-            if(!sym_set_type(value, &PyList_Type)) {
-                goto hit_bottom;
-            }
-            OUT_OF_SPACE_IF_NULL(res = sym_new_type(ctx, &PyBool_Type));
+        if (!optimize_to_bool(this_instr, ctx, value, &res)) {
+            sym_set_type(value, &PyList_Type);
+            res = sym_new_type(ctx, &PyBool_Type);
         }
     }
 
     op(_TO_BOOL_NONE, (value -- res)) {
-        if (optimize_to_bool(this_instr, ctx, value, &res)) {
-            OUT_OF_SPACE_IF_NULL(res);
-        }
-        else {
-            if (!sym_set_const(value, Py_None)) {
-                goto hit_bottom;
-            }
-            OUT_OF_SPACE_IF_NULL(res = sym_new_const(ctx, Py_False));
+        if (!optimize_to_bool(this_instr, ctx, value, &res)) {
+            sym_set_const(value, Py_None);
+            res = sym_new_const(ctx, Py_False);
         }
     }
 
     op(_TO_BOOL_STR, (value -- res)) {
-        if (optimize_to_bool(this_instr, ctx, value, &res)) {
-            OUT_OF_SPACE_IF_NULL(res);
-        }
-        else {
-            OUT_OF_SPACE_IF_NULL(res = sym_new_type(ctx, &PyBool_Type));
-            if(!sym_set_type(value, &PyUnicode_Type)) {
-                goto hit_bottom;
-            }
+        if (!optimize_to_bool(this_instr, ctx, value, &res)) {
+            res = sym_new_type(ctx, &PyBool_Type);
+            sym_set_type(value, &PyUnicode_Type);
         }
     }
 
@@ -400,66 +349,66 @@ dummy_func(void) {
         (void)left;
         (void)right;
         if (oparg & 16) {
-            OUT_OF_SPACE_IF_NULL(res = sym_new_type(ctx, &PyBool_Type));
+            res = sym_new_type(ctx, &PyBool_Type);
         }
         else {
-            OUT_OF_SPACE_IF_NULL(res = _Py_uop_sym_new_not_null(ctx));
+            res = _Py_uop_sym_new_not_null(ctx);
         }
     }
 
     op(_COMPARE_OP_INT, (left, right -- res)) {
         (void)left;
         (void)right;
-        OUT_OF_SPACE_IF_NULL(res = sym_new_type(ctx, &PyBool_Type));
+        res = sym_new_type(ctx, &PyBool_Type);
     }
 
     op(_COMPARE_OP_FLOAT, (left, right -- res)) {
         (void)left;
         (void)right;
-        OUT_OF_SPACE_IF_NULL(res = sym_new_type(ctx, &PyBool_Type));
+        res = sym_new_type(ctx, &PyBool_Type);
     }
 
     op(_COMPARE_OP_STR, (left, right -- res)) {
         (void)left;
         (void)right;
-        OUT_OF_SPACE_IF_NULL(res = sym_new_type(ctx, &PyBool_Type));
+        res = sym_new_type(ctx, &PyBool_Type);
     }
 
     op(_IS_OP, (left, right -- res)) {
         (void)left;
         (void)right;
-        OUT_OF_SPACE_IF_NULL(res = sym_new_type(ctx, &PyBool_Type));
+        res = sym_new_type(ctx, &PyBool_Type);
     }
 
     op(_CONTAINS_OP, (left, right -- res)) {
         (void)left;
         (void)right;
-        OUT_OF_SPACE_IF_NULL(res = sym_new_type(ctx, &PyBool_Type));
+        res = sym_new_type(ctx, &PyBool_Type);
     }
 
     op(_LOAD_CONST, (-- value)) {
         PyObject *val = PyTuple_GET_ITEM(co->co_consts, this_instr->oparg);
         int opcode = _Py_IsImmortal(val) ? _LOAD_CONST_INLINE_BORROW : _LOAD_CONST_INLINE;
         REPLACE_OP(this_instr, opcode, 0, (uintptr_t)val);
-        OUT_OF_SPACE_IF_NULL(value = sym_new_const(ctx, val));
+        value = sym_new_const(ctx, val);
     }
 
     op(_LOAD_CONST_INLINE, (ptr/4 -- value)) {
-        OUT_OF_SPACE_IF_NULL(value = sym_new_const(ctx, ptr));
+        value = sym_new_const(ctx, ptr);
     }
 
     op(_LOAD_CONST_INLINE_BORROW, (ptr/4 -- value)) {
-        OUT_OF_SPACE_IF_NULL(value = sym_new_const(ctx, ptr));
+        value = sym_new_const(ctx, ptr);
     }
 
     op(_LOAD_CONST_INLINE_WITH_NULL, (ptr/4 -- value, null)) {
-        OUT_OF_SPACE_IF_NULL(value = sym_new_const(ctx, ptr));
-        OUT_OF_SPACE_IF_NULL(null = sym_new_null(ctx));
+        value = sym_new_const(ctx, ptr);
+        null = sym_new_null(ctx);
     }
 
     op(_LOAD_CONST_INLINE_BORROW_WITH_NULL, (ptr/4 -- value, null)) {
-        OUT_OF_SPACE_IF_NULL(value = sym_new_const(ctx, ptr));
-        OUT_OF_SPACE_IF_NULL(null = sym_new_null(ctx));
+        value = sym_new_const(ctx, ptr);
+        null = sym_new_null(ctx);
     }
 
     op(_COPY, (bottom, unused[oparg-1] -- bottom, unused[oparg-1], top)) {
@@ -472,7 +421,8 @@ dummy_func(void) {
     }
 
     op(_LOAD_ATTR_INSTANCE_VALUE, (index/1, owner -- attr, null if (oparg & 1))) {
-        _LOAD_ATTR_NOT_NULL
+        attr = sym_new_not_null(ctx);
+        null = sym_new_null(ctx);
         (void)index;
         (void)owner;
     }
@@ -496,15 +446,15 @@ dummy_func(void) {
 
     op(_LOAD_ATTR, (owner -- attr, self_or_null if (oparg & 1))) {
         (void)owner;
-        OUT_OF_SPACE_IF_NULL(attr = sym_new_not_null(ctx));
+        attr = sym_new_not_null(ctx);
         if (oparg & 1) {
-            OUT_OF_SPACE_IF_NULL(self_or_null = sym_new_unknown(ctx));
+            self_or_null = sym_new_unknown(ctx);
         }
     }
 
     op(_LOAD_ATTR_MODULE, (index/1, owner -- attr, null if (oparg & 1))) {
         (void)index;
-        OUT_OF_SPACE_IF_NULL(null = sym_new_null(ctx));
+        null = sym_new_null(ctx);
         attr = NULL;
         if (this_instr[-1].opcode == _NOP) {
             // Preceding _CHECK_ATTR_MODULE was removed: mod is const and dict is watched.
@@ -515,72 +465,69 @@ dummy_func(void) {
             PyObject *res = convert_global_to_const(this_instr, dict);
             if (res != NULL) {
                 this_instr[-1].opcode = _POP_TOP;
-                OUT_OF_SPACE_IF_NULL(attr = sym_new_const(ctx, res));
+                attr = sym_new_const(ctx, res);
             }
         }
         if (attr == NULL) {
             /* No conversion made. We don't know what `attr` is. */
-            OUT_OF_SPACE_IF_NULL(attr = sym_new_not_null(ctx));
+            attr = sym_new_not_null(ctx);
         }
     }
 
     op(_LOAD_ATTR_WITH_HINT, (hint/1, owner -- attr, null if (oparg & 1))) {
-        _LOAD_ATTR_NOT_NULL
+        attr = sym_new_not_null(ctx);
+        null = sym_new_null(ctx);
         (void)hint;
         (void)owner;
     }
 
     op(_LOAD_ATTR_SLOT, (index/1, owner -- attr, null if (oparg & 1))) {
-        _LOAD_ATTR_NOT_NULL
+        attr = sym_new_not_null(ctx);
+        null = sym_new_null(ctx);
         (void)index;
         (void)owner;
     }
 
     op(_LOAD_ATTR_CLASS, (descr/4, owner -- attr, null if (oparg & 1))) {
-        _LOAD_ATTR_NOT_NULL
+        attr = sym_new_not_null(ctx);
+        null = sym_new_null(ctx);
         (void)descr;
         (void)owner;
     }
 
     op(_LOAD_ATTR_METHOD_WITH_VALUES, (descr/4, owner -- attr, self if (1))) {
         (void)descr;
-        OUT_OF_SPACE_IF_NULL(attr = sym_new_not_null(ctx));
+        attr = sym_new_not_null(ctx);
         self = owner;
     }
 
     op(_LOAD_ATTR_METHOD_NO_DICT, (descr/4, owner -- attr, self if (1))) {
         (void)descr;
-        OUT_OF_SPACE_IF_NULL(attr = sym_new_not_null(ctx));
+        attr = sym_new_not_null(ctx);
         self = owner;
     }
 
     op(_LOAD_ATTR_METHOD_LAZY_DICT, (descr/4, owner -- attr, self if (1))) {
         (void)descr;
-        OUT_OF_SPACE_IF_NULL(attr = sym_new_not_null(ctx));
+        attr = sym_new_not_null(ctx);
         self = owner;
     }
 
     op(_INIT_CALL_BOUND_METHOD_EXACT_ARGS, (callable, unused, unused[oparg] -- func, self, unused[oparg])) {
         (void)callable;
-        OUT_OF_SPACE_IF_NULL(func = sym_new_not_null(ctx));
-        OUT_OF_SPACE_IF_NULL(self = sym_new_not_null(ctx));
+        func = sym_new_not_null(ctx);
+        self = sym_new_not_null(ctx);
     }
 
     op(_CHECK_FUNCTION_EXACT_ARGS, (func_version/2, callable, self_or_null, unused[oparg] -- callable, self_or_null, unused[oparg])) {
-        if (!sym_set_type(callable, &PyFunction_Type)) {
-            goto hit_bottom;
-        }
+        sym_set_type(callable, &PyFunction_Type);
         (void)self_or_null;
         (void)func_version;
     }
 
     op(_CHECK_CALL_BOUND_METHOD_EXACT_ARGS, (callable, null, unused[oparg] -- callable, null, unused[oparg])) {
-        if (!sym_set_null(null)) {
-            goto hit_bottom;
-        }
-        if (!sym_set_type(callable, &PyMethod_Type)) {
-            goto hit_bottom;
-        }
+        sym_set_null(null);
+        sym_set_type(callable, &PyMethod_Type);
     }
 
     op(_INIT_CALL_PY_EXACT_ARGS, (callable, self_or_null, args[oparg] -- new_frame: _Py_UOpsAbstractFrame *)) {
@@ -602,7 +549,8 @@ dummy_func(void) {
             if (func == NULL) {
                 DPRINTF(3, "\n");
                 DPRINTF(1, "Missing function\n");
-                goto done;
+                ctx->done = true;
+                break;
             }
             co = (PyCodeObject *)func->func_code;
             DPRINTF(3, "code=%p ", co);
@@ -625,8 +573,7 @@ dummy_func(void) {
             localsplus_start = args;
             n_locals_already_filled = argcount;
         }
-        OUT_OF_SPACE_IF_NULL(new_frame =
-                             frame_new(ctx, co, localsplus_start, n_locals_already_filled, 0));
+        new_frame = frame_new(ctx, co, localsplus_start, n_locals_already_filled, 0);
     }
 
     op(_PY_FRAME_GENERAL, (callable, self_or_null, args[oparg] -- new_frame: _Py_UOpsAbstractFrame *)) {
@@ -635,7 +582,8 @@ dummy_func(void) {
         (void)self_or_null;
         (void)args;
         first_valid_check_stack = NULL;
-        goto done;
+        new_frame = NULL;
+        ctx->done = true;
     }
 
     op(_POP_FRAME, (retval -- res)) {
@@ -656,7 +604,7 @@ dummy_func(void) {
         co = get_code(this_instr);
         if (co == NULL) {
             // might be impossible, but bailing is still safe
-            goto done;
+            ctx->done = true;
         }
     }
 
@@ -665,7 +613,7 @@ dummy_func(void) {
         ctx->frame->stack_pointer = stack_pointer;
         frame_pop(ctx);
         stack_pointer = ctx->frame->stack_pointer;
-        OUT_OF_SPACE_IF_NULL(res = sym_new_unknown(ctx));
+        res = sym_new_unknown(ctx);
 
         /* Stack space handling */
         assert(corresponding_check_stack == NULL);
@@ -678,17 +626,17 @@ dummy_func(void) {
         co = get_code(this_instr);
         if (co == NULL) {
             // might be impossible, but bailing is still safe
-            goto done;
+            ctx->done = true;
         }
     }
 
     op(_YIELD_VALUE, (unused -- res)) {
-        OUT_OF_SPACE_IF_NULL(res = sym_new_unknown(ctx));
+        res = sym_new_unknown(ctx);
     }
 
     op(_FOR_ITER_GEN_FRAME, ( -- )) {
         /* We are about to hit the end of the trace */
-        goto done;
+        ctx->done = true;
     }
 
     op(_CHECK_STACK_SPACE, ( --)) {
@@ -712,7 +660,8 @@ dummy_func(void) {
         co = get_code(this_instr);
         if (co == NULL) {
             // should be about to _EXIT_TRACE anyway
-            goto done;
+            ctx->done = true;
+            break;
         }
 
         /* Stack space handling */
@@ -721,7 +670,8 @@ dummy_func(void) {
         curr_space += framesize;
         if (curr_space < 0 || curr_space > INT32_MAX) {
             // won't fit in signed 32-bit int
-            goto done;
+            ctx->done = true;
+            break;
         }
         max_space = curr_space > max_space ? curr_space : max_space;
         if (first_valid_check_stack == NULL) {
@@ -738,7 +688,7 @@ dummy_func(void) {
         /* This has to be done manually */
         (void)seq;
         for (int i = 0; i < oparg; i++) {
-            OUT_OF_SPACE_IF_NULL(values[i] = sym_new_unknown(ctx));
+            values[i] = sym_new_unknown(ctx);
         }
     }
 
@@ -747,12 +697,12 @@ dummy_func(void) {
         (void)seq;
         int totalargs = (oparg & 0xFF) + (oparg >> 8) + 1;
         for (int i = 0; i < totalargs; i++) {
-            OUT_OF_SPACE_IF_NULL(values[i] = sym_new_unknown(ctx));
+            values[i] = sym_new_unknown(ctx);
         }
     }
 
     op(_ITER_NEXT_RANGE, (iter -- iter, next)) {
-       OUT_OF_SPACE_IF_NULL(next = sym_new_type(ctx, &PyLong_Type));
+       next = sym_new_type(ctx, &PyLong_Type);
        (void)iter;
     }
 
@@ -805,11 +755,11 @@ dummy_func(void) {
     }
 
     op(_JUMP_TO_TOP, (--)) {
-        goto done;
+        ctx->done = true;
     }
 
     op(_EXIT_TRACE, (--)) {
-        goto done;
+        ctx->done = true;
     }