GH-123391: Code generators: Track stack and locals in if statements.

Lib/test/test_generated_cases.py

@@ -60,7 +60,7 @@ def test_effect_sizes(self):
         stack.pop(y)
         stack.pop(x)
         for out in outputs:
-            stack.push(Local.local(out))
+            stack.push(Local.undefined(out))
         self.assertEqual(stack.base_offset.to_c(), "-1 - oparg - oparg*2")
         self.assertEqual(stack.top_offset.to_c(), "1 - oparg - oparg*2 + oparg*4")
 
@@ -281,6 +281,67 @@ def test_predictions(self):
     """
         self.run_cases_test(input, output)
 
+    def test_sync_sp(self):
+        input = """
+        inst(A, (arg -- res)) {
+            SYNC_SP();
+            escaping_call();
+            res = Py_None;
+        }
+        inst(B, (arg -- res)) {
+            res = Py_None;
+            SYNC_SP();
+            escaping_call();
+        }
+    """
+        output = """
+        TARGET(A) {
+            frame->instr_ptr = next_instr;
+            next_instr += 1;
+            INSTRUCTION_STATS(A);
+            _PyStackRef res;
+            stack_pointer += -1;
+            assert(WITHIN_STACK_BOUNDS());
+            escaping_call();
+            res = Py_None;
+            stack_pointer[0] = res;
+            stack_pointer += 1;
+            assert(WITHIN_STACK_BOUNDS());
+            DISPATCH();
+        }
+
+        TARGET(B) {
+            frame->instr_ptr = next_instr;
+            next_instr += 1;
+            INSTRUCTION_STATS(B);
+            _PyStackRef res;
+            res = Py_None;
+            stack_pointer += -1;
+            assert(WITHIN_STACK_BOUNDS());
+            escaping_call();
+            stack_pointer[0] = res;
+            stack_pointer += 1;
+            assert(WITHIN_STACK_BOUNDS());
+            DISPATCH();
+        }
+    """
+        self.run_cases_test(input, output)
+
+
+    def test_pep7_condition(self):
+        input = """
+        inst(OP, (arg1 -- out)) {
+            if (arg1)
+                out = 0;
+            else {
+                out = 1;
+            }
+        }
+        """
+        output = ""
+        with self.assertRaises(SyntaxError):
+            self.run_cases_test(input, output)
+
     def test_error_if_plain(self):
         input = """
         inst(OP, (--)) {
@@ -810,7 +871,7 @@ def test_deopt_and_exit(self):
         }
         """
         output = ""
-        with self.assertRaises(Exception):
+        with self.assertRaises(SyntaxError):
             self.run_cases_test(input, output)
 
     def test_array_of_one(self):
@@ -1000,8 +1061,6 @@ def test_flush(self):
             stack_pointer += 2;
             assert(WITHIN_STACK_BOUNDS());
             // SECOND
-            b = stack_pointer[-1];
-            a = stack_pointer[-2];
             {
                 use(a, b);
             }
@@ -1096,7 +1155,8 @@ def test_push_then_error(self):
                 b = 1;
                 if (cond) {
                     stack_pointer[0] = a;
-                    stack_pointer += 1;
+                    stack_pointer[1] = b;
+                    stack_pointer += 2;
                     assert(WITHIN_STACK_BOUNDS());
                     goto error;
                 }

Python/bytecodes.c

@@ -972,7 +972,9 @@ dummy_func(
             int err = _Py_call_instrumentation_arg(
                     tstate, PY_MONITORING_EVENT_PY_RETURN,
                     frame, this_instr, PyStackRef_AsPyObjectBorrow(val));
-            if (err) ERROR_NO_POP();
+            if (err) {
+                ERROR_NO_POP();
+            }
         }
 
         macro(INSTRUMENTED_RETURN_VALUE) =
@@ -1168,7 +1170,9 @@ dummy_func(
                     tstate, PY_MONITORING_EVENT_PY_YIELD,
                     frame, this_instr, PyStackRef_AsPyObjectBorrow(val));
             LOAD_SP();
-            if (err) ERROR_NO_POP();
+            if (err) {
+                ERROR_NO_POP();
+            }
             if (frame->instr_ptr != this_instr) {
                 next_instr = frame->instr_ptr;
                 DISPATCH();
@@ -1276,10 +1280,12 @@ dummy_func(
                 DECREF_INPUTS();
                 ERROR_IF(true, error);
             }
-            if (PyDict_CheckExact(ns))
+            if (PyDict_CheckExact(ns)) {
                 err = PyDict_SetItem(ns, name, PyStackRef_AsPyObjectBorrow(v));
-            else
+            }
+            else {
                 err = PyObject_SetItem(ns, name, PyStackRef_AsPyObjectBorrow(v));
+            }
             DECREF_INPUTS();
             ERROR_IF(err, error);
         }
@@ -1993,6 +1999,8 @@ dummy_func(
                 attr_o = PyObject_GetAttr(PyStackRef_AsPyObjectBorrow(owner), name);
                 DECREF_INPUTS();
                 ERROR_IF(attr_o == NULL, error);
+                /* We need to define self_or_null on all paths */
+                self_or_null = PyStackRef_NULL;
             }
             attr = PyStackRef_FromPyObjectSteal(attr_o);
         }
@@ -3206,10 +3214,10 @@ dummy_func(
         op(_MAYBE_EXPAND_METHOD, (callable, self_or_null, args[oparg] -- func, maybe_self, args[oparg])) {
             if (PyStackRef_TYPE(callable) == &PyMethod_Type && PyStackRef_IsNull(self_or_null)) {
                 PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable);
-                PyObject *self = ((PyMethodObject *)callable_o)->im_self;
-                maybe_self = PyStackRef_FromPyObjectNew(self);
                 PyObject *method = ((PyMethodObject *)callable_o)->im_func;
                 func = PyStackRef_FromPyObjectNew(method);
+                PyObject *self = ((PyMethodObject *)callable_o)->im_self;
+                maybe_self = PyStackRef_FromPyObjectNew(self);
                 /* Make sure that callable and all args are in memory */
                 args[-2] = func;
                 args[-1] = maybe_self;
@@ -4297,7 +4305,9 @@ dummy_func(
                 int err = _Py_call_instrumentation_2args(
                     tstate, PY_MONITORING_EVENT_CALL,
                     frame, this_instr, func, arg);
-                if (err) ERROR_NO_POP();
+                if (err) {
+                    ERROR_NO_POP();
+                }
                 result = PyStackRef_FromPyObjectSteal(PyObject_Call(func, callargs, kwargs));
 
                 if (!PyFunction_Check(func) && !PyMethod_Check(func)) {