more cleanup

Author: Fidget-Spinner

Include/internal/pycore_code.h

@@ -323,6 +323,7 @@ PyAPI_FUNC(void) _Py_Specialize_ToBool(_PyStackRef value, _Py_CODEUNIT *instr);
 PyAPI_FUNC(void) _Py_Specialize_ContainsOp(_PyStackRef value, _Py_CODEUNIT *instr);
 PyAPI_FUNC(void) _Py_GatherStats_GetIter(_PyStackRef iterable);
 PyAPI_FUNC(void) _Py_Specialize_CallFunctionEx(_PyStackRef func_st, _Py_CODEUNIT *instr);
+PyAPI_FUNC(void) _Py_Specialize_Resume(_Py_CODEUNIT *instr, PyThreadState *tstate);
 
 // Utility functions for reading/writing 32/64-bit values in the inline caches.
 // Great care should be taken to ensure that these functions remain correct and

Include/internal/pycore_magic_number.h

@@ -305,7 +305,7 @@ PC/launcher.c must also be updated.
 
 */
 
-#define PYC_MAGIC_NUMBER 3662
+#define PYC_MAGIC_NUMBER 3663
 /* This is equivalent to converting PYC_MAGIC_NUMBER to 2 bytes
    (little-endian) and then appending b'\r\n'. */
 #define PYC_MAGIC_NUMBER_TOKEN \

Modules/_testinternalcapi/test_cases.c.h

@@ -173,18 +173,7 @@ dummy_func(
         }
 
         specializing op(_SPECIALIZE_RESUME, (counter/1 --)) {
-#if ENABLE_SPECIALIZATION_FT
-    #if _Py_TIER2
-            if (ADAPTIVE_COUNTER_TRIGGERS(counter)) {
-                next_instr = this_instr;
-                _Py_Specialize_Resume(next_instr, tstate);
-                DISPATCH_SAME_OPARG();
-            }
-            ADVANCE_ADAPTIVE_COUNTER(this_instr[1].counter);
-    #else
             _Py_Specialize_Resume(next_instr, tstate);
-    #endif
-#endif  /* ENABLE_SPECIALIZATION_FT */
         }
 
         tier1 op(_MAYBE_INSTRUMENT, (--)) {
@@ -3131,15 +3120,16 @@ dummy_func(
             _Py_BackoffCounter counter = this_instr[1].counter;
             if (!IS_JIT_TRACING() &&
                 (backoff_counter_triggers(counter) &&
-                this_instr->op.code == JUMP_BACKWARD_JIT) &&
+                (this_instr->op.code == JUMP_BACKWARD_JIT || is_resume)) &&
                 next_instr->op.code != ENTER_EXECUTOR) {
                 /* Back up over EXTENDED_ARGs so executor is inserted at the correct place */
                 _Py_CODEUNIT *insert_exec_at = this_instr;
                 while (oparg > 255) {
                     oparg >>= 8;
                     insert_exec_at--;
                 }
-                int succ = _PyJit_TryInitializeTracing(tstate, frame, this_instr, insert_exec_at, next_instr, stack_pointer, 0, NULL, oparg, NULL);
+                int succ = _PyJit_TryInitializeTracing(tstate, frame, this_instr, insert_exec_at,
+                    is_resume ? insert_exec_at : next_instr, stack_pointer, 0, NULL, oparg, NULL);
                 if (succ) {
                     ENTER_TRACING();
                 }
@@ -3192,7 +3182,7 @@ dummy_func(
             #ifdef _Py_TIER2
             if (IS_JIT_TRACING()) {
                 next_instr = this_instr;
-                goto consider_stop_tracing;
+                goto stop_tracing;
             }
             PyCodeObject *code = _PyFrame_GetCode(frame);
             _PyExecutorObject *executor = code->co_executors->executors[oparg & 255];
@@ -6029,25 +6019,10 @@ dummy_func(
 #endif
         }
 
-        label(consider_stop_tracing) {
+        label(stop_tracing) {
 #if _Py_TIER2
             assert(IS_JIT_TRACING());
             int opcode = next_instr->op.code;
-            PyCodeObject *code = _PyFrame_GetCode(frame);
-            _PyExecutorObject *executor = code->co_executors->executors[oparg & 255];
-            int orig_opcode = executor->vm_data.opcode;
-            // Not backwards jump, trace over it to form a longer trace.
-            if (orig_opcode == RESUME_CHECK_JIT || orig_opcode == RESUME) {
-                assert(executor->vm_data.index == INSTR_OFFSET());
-                assert(executor->vm_data.code == code);
-                assert(executor->vm_data.valid);
-                oparg = (oparg & ~255) | executor->vm_data.oparg;
-                opcode = orig_opcode;
-                if (_PyOpcode_Caches[_PyOpcode_Deopt[opcode]]) {
-                    PAUSE_ADAPTIVE_COUNTER(next_instr[1].counter);
-                }
-                DISPATCH_GOTO_NON_TRACING();
-            }
             _PyJit_translate_single_bytecode_to_trace(tstate, frame, NULL, _EXIT_TRACE);
             LEAVE_TRACING();
             int err = stop_tracing_and_jit(tstate, frame);

Modules/_testinternalcapi/test_targets.h

@@ -579,8 +579,9 @@ add_to_trace(
 
 
 static int
-opcode_is_terminator(int opcode)
+is_terminator(const _PyUOpInstruction *uop)
 {
+    int opcode = _PyUop_Uncached[uop->opcode];
     return (
         opcode == _EXIT_TRACE ||
         opcode == _DEOPT ||
@@ -589,14 +590,6 @@ opcode_is_terminator(int opcode)
     );
 }
 
-static int
-is_terminator(const _PyUOpInstruction *uop)
-{
-    int opcode = uop->opcode;
-    int base_opcode = _PyUop_Uncached[uop->opcode];
-    return opcode_is_terminator(opcode) || opcode_is_terminator(base_opcode);
-}
-
 /* Returns 1 on success (added to trace), 0 on trace end.
  */
 // gh-142543: inlining this function causes stack overflows
@@ -633,7 +626,6 @@ _PyJit_translate_single_bytecode_to_trace(
     // We must point to the first EXTENDED_ARG when deopting.
     int oparg = tracer->prev_state.instr_oparg;
     int opcode = this_instr->op.code;
-
     int rewind_oparg = oparg;
     while (rewind_oparg > 255) {
         rewind_oparg >>= 8;
@@ -1218,8 +1210,7 @@ prepare_for_execution(_PyUOpInstruction *buffer, int length)
             int exit_depth = get_cached_entries_for_side_exit(inst);
             assert(_PyUop_Caching[base_exit_op].entries[exit_depth].opcode > 0);
             int16_t exit_op = _PyUop_Caching[base_exit_op].entries[exit_depth].opcode;
-            bool is_control_flow = (base_opcode == _GUARD_IS_FALSE_POP || base_opcode == _GUARD_IS_TRUE_POP ||
-                base_opcode == _GUARD_IS_NONE_POP || base_opcode == _GUARD_IS_NOT_NONE_POP || is_for_iter_test[base_opcode]);
+            bool is_control_flow = (base_opcode == _GUARD_IS_FALSE_POP || base_opcode == _GUARD_IS_TRUE_POP || is_for_iter_test[base_opcode]);
             if (jump_target != current_jump_target || current_exit_op != exit_op) {
                 make_exit(&buffer[next_spare], exit_op, jump_target, is_control_flow);
                 current_exit_op = exit_op;

Python/bytecodes.c

@@ -1366,7 +1366,7 @@ init_interp_main(PyThreadState *tstate)
     // This is also needed when the JIT is enabled
 #ifdef _Py_TIER2
     if (is_main_interp) {
-        int enabled = 1;
+        int enabled = 0;
 #if _Py_TIER2 & 2
         enabled = 0;
 #endif

Python/generated_cases.c.h

@@ -2796,7 +2796,7 @@ _Py_Specialize_Resume(_Py_CODEUNIT *instr, PyThreadState *tstate)
     if (tstate->tracing == 0 && instr->op.code == RESUME) {
         if (tstate->interp->jit) {
             specialize(instr, RESUME_CHECK_JIT);
-            set_counter((_Py_BackoffCounter *)instr + 1, trigger_backoff_counter());
+            set_counter((_Py_BackoffCounter *)instr + 1, initial_resume_backoff_counter());
             return;
         }
         specialize(instr, RESUME_CHECK);