gh-143820: ENTER_EXECUTOR can be inserted after BINARY_OP_INPLACE_ADD_UNICODE

Include/internal/pycore_code.h

@@ -529,7 +529,7 @@ typedef struct {
 
 PyAPI_FUNC(int) _Py_Instrument(PyCodeObject *co, PyInterpreterState *interp);
 
-extern _Py_CODEUNIT _Py_GetBaseCodeUnit(PyCodeObject *code, int offset);
+PyAPI_FUNC(_Py_CODEUNIT) _Py_GetBaseCodeUnit(PyCodeObject *code, int offset);
 
 extern int _PyInstruction_GetLength(PyCodeObject *code, int offset);
 

Lib/test/test_capi/test_opt.py

@@ -3792,6 +3792,67 @@ def __next__(self):
         """), PYTHON_JIT="1", PYTHON_JIT_STRESS="1")
         self.assertEqual(result[0].rc, 0, result)
 
+    def test_143820(self):
+        # https://github.com/python/cpython/issues/143358
+
+        result = script_helper.run_python_until_end('-c', textwrap.dedent(f"""
+        import sys
+        import random
+
+        int_v1 = 981679
+        int_v2 = -3791744241805517
+        any_v3 = 939.217
+
+        def f1(): int_v1 ^ int_v1
+
+        for i_f1 in range(300):
+            f1()
+
+        def f2():
+            class Int(int):
+                def __index__(self):...
+
+            inf = float('inf')
+            nzero = -0
+            zero = 0.0
+            dummy = 0
+            print('', file=sys.stderr)
+
+            def f_0_dc_6103(p): return p + 1
+            def f_1_dc_6103(p): return f_0_dc_6103(p) + 1
+            def f_2_dc_6103(p): return f_1_dc_6103(p) + 1
+            def f_3_dc_6103(p): return f_2_dc_6103(p) + 1
+            def f_4_dc_6103(p): return f_3_dc_6103(p) + 1
+            def f_5_dc_6103(p): return f_4_dc_6103(p) + 1
+            def f_6_dc_6103(p): return f_5_dc_6103(p) + 1
+            def f_7_dc_6103(p): return f_6_dc_6103(p) + 1
+            def f_8_dc_6103(p): return f_7_dc_6103(p) + 1
+            def f_9_dc_6103(p): return f_8_dc_6103(p) + 1
+
+            if inf == inf: dummy += 1
+            s = ''
+            try:
+                for _ in range(10):
+                    s += ''
+                s += 'y'
+            except Exception: pass
+            int_v1 ^ int_v1
+            int_v1 ^ int_v1
+            int_v1 ^ int_v1
+            int_v2 - int_v1
+            int_v2 - int_v1
+            int_v2 - int_v1
+            int_v2 - int_v1
+            int_v2 - int_v1
+            not any_v3
+            not any_v3
+            not any_v3
+
+        for i_f2 in range(300):
+            f2()
+        """), PYTHON_JIT="1", PYTHON_JIT_STRESS="1")
+        self.assertEqual(result[0].rc, 0, result)
+
 def global_identity(x):
     return x
 

Misc/NEWS.d/next/Core_and_Builtins/2026-01-15-22-18-19.gh-issue-143820.eRhozc.rst

@@ -0,0 +1 @@
+Fix a bug in JIT builds where executors can be inserted after certain super instructions.

Modules/_testinternalcapi/test_cases.c.h

@@ -416,8 +416,18 @@
                 assert(PyUnicode_CheckExact(PyStackRef_AsPyObjectBorrow(right)));
                 int next_oparg;
                 #if TIER_ONE
-                assert(next_instr->op.code == STORE_FAST);
                 next_oparg = next_instr->op.arg;
+                #if _Py_TIER2
+
+                if (next_instr->op.code == ENTER_EXECUTOR) {
+                    _PyExecutorObject *exec = _PyFrame_GetCode(frame)->co_executors->executors[next_oparg];
+                    next_oparg = exec->vm_data.oparg;
+                }
+                #endif
+                _PyFrame_SetStackPointer(frame, stack_pointer);
+                assert(_Py_GetBaseCodeUnit(_PyFrame_GetCode(frame),
+                                      next_instr - _PyFrame_GetBytecode(frame)).op.code == STORE_FAST);
+                stack_pointer = _PyFrame_GetStackPointer(frame);
                 #else
                 next_oparg = (int)CURRENT_OPERAND0_16();
                 #endif

Python/bytecodes.c

@@ -783,8 +783,17 @@ dummy_func(
 
             int next_oparg;
         #if TIER_ONE
-            assert(next_instr->op.code == STORE_FAST);
             next_oparg = next_instr->op.arg;
+#if _Py_TIER2
+            // In JIT builds, we might have inserted an executor after this instruction,
+            // which breaks this super instruction.
+            if (next_instr->op.code == ENTER_EXECUTOR) {
+                _PyExecutorObject *exec = _PyFrame_GetCode(frame)->co_executors->executors[next_oparg];
+                next_oparg = exec->vm_data.oparg;
+            }
+#endif
+            assert(_Py_GetBaseCodeUnit(_PyFrame_GetCode(frame),
+                next_instr - _PyFrame_GetBytecode(frame)).op.code == STORE_FAST);
         #else
             next_oparg = (int)CURRENT_OPERAND0_16();
         #endif