Add deopt and error_if, and tests

Author: Fidget-Spinner

Lib/test/test_generated_cases.py

@@ -2263,7 +2263,95 @@ def test_pure_uop_body_copied_in(self):
         """
         self.run_cases_test(input, input2, output)
 
-    def test_pure_uop_body_copied_in_complex(self):
+    def test_pure_uop_body_copied_in_deopt(self):
+        # Note: any non-escaping call works.
+        # In this case, we use PyStackRef_IsNone.
+        input = """
+        pure op(OP, (foo -- res)) {
+            DEOPT_IF(PyStackRef_IsNull(foo));
+            res = foo;
+        }
+        """
+        input2 = """
+        op(OP, (foo -- res)) {
+            REPLACE_OPCODE_IF_EVALUATES_PURE(foo);
+            res = foo;
+        }
+        """
+        output = """
+        case OP: {
+            JitOptSymbol *foo;
+            JitOptSymbol *res;
+            foo = stack_pointer[-1];
+            if (
+                sym_is_safe_const(ctx, foo)
+            ) {
+                JitOptSymbol *foo_sym = foo;
+                _PyStackRef foo = sym_get_const_as_stackref(ctx, foo_sym);
+                _PyStackRef res_stackref;
+                /* Start of uop copied from bytecodes for constant evaluation */
+                if (PyStackRef_IsNull(foo)) {
+                    ctx->done = true;
+                    break;
+                }
+                res_stackref = foo;
+                /* End of uop copied from bytecodes for constant evaluation */
+                res = sym_new_const_steal(ctx, PyStackRef_AsPyObjectSteal(res_stackref));
+                stack_pointer[-1] = res;
+                break;
+            }
+            res = foo;
+            stack_pointer[-1] = res;
+            break;
+        }
+        """
+        self.run_cases_test(input, input2, output)
+
+    def test_pure_uop_body_copied_in_error_if(self):
+        # Note: any non-escaping call works.
+        # In this case, we use PyStackRef_IsNone.
+        input = """
+        pure op(OP, (foo -- res)) {
+            ERROR_IF(PyStackRef_IsNull(foo));
+            res = foo;
+        }
+        """
+        input2 = """
+        op(OP, (foo -- res)) {
+            REPLACE_OPCODE_IF_EVALUATES_PURE(foo);
+            res = foo;
+        }
+        """
+        output = """
+        case OP: {
+            JitOptSymbol *foo;
+            JitOptSymbol *res;
+            foo = stack_pointer[-1];
+            if (
+                sym_is_safe_const(ctx, foo)
+            ) {
+                JitOptSymbol *foo_sym = foo;
+                _PyStackRef foo = sym_get_const_as_stackref(ctx, foo_sym);
+                _PyStackRef res_stackref;
+                /* Start of uop copied from bytecodes for constant evaluation */
+                if (PyStackRef_IsNull(foo)) {
+                    goto error;
+                }
+                res_stackref = foo;
+                /* End of uop copied from bytecodes for constant evaluation */
+                res = sym_new_const_steal(ctx, PyStackRef_AsPyObjectSteal(res_stackref));
+                stack_pointer[-1] = res;
+                break;
+            }
+            res = foo;
+            stack_pointer[-1] = res;
+            break;
+        }
+        """
+        self.run_cases_test(input, input2, output)
+
+
+    def test_replace_opcode_uop_body_copied_in_complex(self):
         input = """
         pure op(OP, (foo -- res)) {
             if (foo) {
@@ -2310,7 +2398,7 @@ def test_pure_uop_body_copied_in_complex(self):
         """
         self.run_cases_test(input, input2, output)
 
-    def test_pure_uop_reject_array_effects(self):
+    def test_replace_opocode_uop_reject_array_effects(self):
         input = """
         pure op(OP, (foo[2] -- res)) {
             if (foo) {

Python/optimizer_analysis.c

@@ -536,7 +536,6 @@ optimize_uops(
     }
     return trace_len;
 
-pop_2_error:
 error:
     DPRINTF(3, "\n");
     DPRINTF(1, "Encountered error in abstract interpreter\n");

Python/optimizer_bytecodes.c

@@ -222,14 +222,17 @@ dummy_func(void) {
     }
 
     op(_BINARY_OP_ADD_INT, (left, right -- res)) {
+        REPLACE_OPCODE_IF_EVALUATES_PURE(left, right);
         res = sym_new_type(ctx, &PyLong_Type);
     }
 
     op(_BINARY_OP_SUBTRACT_INT, (left, right -- res)) {
+        REPLACE_OPCODE_IF_EVALUATES_PURE(left, right);
         res = sym_new_type(ctx, &PyLong_Type);
     }
 
     op(_BINARY_OP_MULTIPLY_INT, (left, right -- res)) {
+        REPLACE_OPCODE_IF_EVALUATES_PURE(left, right);
         res = sym_new_type(ctx, &PyLong_Type);
     }
 

Python/optimizer_cases.c.h

@@ -139,30 +139,6 @@ def __init__(self, out: CWriter, labels: dict[str, Label]):
         self.out = out
         self.labels = labels
 
-    def emit_to_with_replacement(
-        self,
-        out: CWriter,
-        tkn_iter: TokenIterator,
-        end: str,
-        uop: CodeSection,
-        storage: Storage,
-        inst: Instruction | None
-    ) -> Token:
-        parens = 0
-        for tkn in tkn_iter:
-            if tkn.kind == end and parens == 0:
-                return tkn
-            if tkn.kind == "LPAREN":
-                parens += 1
-            if tkn.kind == "RPAREN":
-                parens -= 1
-            if tkn.text in self._replacers:
-                self._replacers[tkn.text](tkn, tkn_iter, uop, storage, inst)
-            else:
-                out.emit(tkn)
-        raise analysis_error(f"Expecting {end}. Reached end of file", tkn)
-
-
     def dispatch(
         self,
         tkn: Token,
@@ -190,7 +166,7 @@ def deopt_if(
         lparen = next(tkn_iter)
         assert lparen.kind == "LPAREN"
         first_tkn = tkn_iter.peek()
-        self.emit_to_with_replacement(self.out, tkn_iter, "RPAREN", uop, storage, inst)
+        emit_to(self.out, tkn_iter, "RPAREN")
         self.emit(") {\n")
         next(tkn_iter)  # Semi colon
         assert inst is not None
@@ -230,7 +206,7 @@ def error_if(
         else:
             self.out.emit_at("if ", tkn)
             self.emit(lparen)
-            self.emit_to_with_replacement(self.out, tkn_iter, "RPAREN", uop, storage, inst)
+            emit_to(self.out, tkn_iter, "RPAREN")
             self.out.emit(") {\n")
         next(tkn_iter)  # Semi colon
         storage.clear_inputs("at ERROR_IF")