massive refactoring 2

Author: Fidget-Spinner

Include/internal/pycore_interp_structs.h

@@ -768,18 +768,20 @@ typedef struct _PyJitTracerState {
         _Py_CODEUNIT *close_loop_instr;
         _Py_CODEUNIT *jump_backward_instr;
     } initial_state;
-    bool dependencies_still_valid;
-    bool prev_instr_is_super;
-    int code_max_size;
-    int code_curr_size;
-    int prev_instr_oparg;
-    int prev_instr_stacklevel;
-    int specialize_counter;
     _PyUOpInstruction *code_buffer;
-    _Py_CODEUNIT *prev_instr;
-    PyCodeObject *prev_instr_code; // Strong
-    _PyInterpreterFrame *prev_instr_frame;
-    _PyBloomFilter dependencies;
+    struct {
+        bool dependencies_still_valid;
+        bool instr_is_super;
+        int code_max_size;
+        int code_curr_size;
+        int instr_oparg;
+        int instr_stacklevel;
+        int specialize_counter;
+        _Py_CODEUNIT *instr;
+        PyCodeObject *instr_code; // Strong
+        _PyInterpreterFrame *instr_frame;
+        _PyBloomFilter dependencies;
+    } prev_state;;
 } _PyJitTracerState;
 
 /* PyInterpreterState holds the global state for one of the runtime's

Python/bytecodes.c

@@ -5673,24 +5673,24 @@ dummy_func(
             }
             // Super instructions. Instruction deopted. There's a mismatch in what the stack expects
             // in the optimizer. So we have to reflect in the trace correctly.
-            if ((tstate->interp->jit_state.prev_instr->op.code == CALL_LIST_APPEND &&
+            if ((tstate->interp->jit_state.prev_state.instr->op.code == CALL_LIST_APPEND &&
                 opcode == POP_TOP) ||
-                (tstate->interp->jit_state.prev_instr->op.code == BINARY_OP_INPLACE_ADD_UNICODE &&
+                (tstate->interp->jit_state.prev_state.instr->op.code == BINARY_OP_INPLACE_ADD_UNICODE &&
                 opcode == STORE_FAST)) {
-                tstate->interp->jit_state.prev_instr_is_super = true;
+                tstate->interp->jit_state.prev_state.instr_is_super = true;
             }
             else {
-                tstate->interp->jit_state.prev_instr = next_instr;
+                tstate->interp->jit_state.prev_state.instr = next_instr;
             }
-            tstate->interp->jit_state.specialize_counter = 0;
+            tstate->interp->jit_state.prev_state.specialize_counter = 0;
             PyCodeObject *prev_code = (PyCodeObject *)Py_NewRef(PyStackRef_AsPyObjectBorrow(frame->f_executable));
-            if (tstate->interp->jit_state.prev_instr_code != prev_code) {
-                Py_SETREF(tstate->interp->jit_state.prev_instr_code, prev_code);
+            if (tstate->interp->jit_state.prev_state.instr_code != prev_code) {
+                Py_SETREF(tstate->interp->jit_state.prev_state.instr_code, prev_code);
             }
 
-            tstate->interp->jit_state.prev_instr_frame = frame;
-            tstate->interp->jit_state.prev_instr_oparg = oparg;
-            tstate->interp->jit_state.prev_instr_stacklevel = PyStackRef_IsNone(frame->f_executable) ? 2 : STACK_LEVEL();
+            tstate->interp->jit_state.prev_state.instr_frame = frame;
+            tstate->interp->jit_state.prev_state.instr_oparg = oparg;
+            tstate->interp->jit_state.prev_state.instr_stacklevel = PyStackRef_IsNone(frame->f_executable) ? 2 : STACK_LEVEL();
             DISPATCH_GOTO_NON_TRACING();
 #else
             Py_FatalError("JIT label executed in non-jit build.");

Python/ceval.c

@@ -1017,7 +1017,7 @@ bail_tracing_and_jit(PyThreadState *tstate, _PyInterpreterFrame *frame)
         // to be valid to access.
         if (err <= 0) {
             // Some opcodes will forever be unchanged. Don't ever bother specializing for them ever again.
-            if (tstate->interp->jit_state.prev_instr->op.code == INTERPRETER_EXIT) {
+            if (tstate->interp->jit_state.prev_state.instr->op.code == INTERPRETER_EXIT) {
                 exit->temperature = initial_unreachable_backoff_counter();
             }
             else {

Python/ceval_macros.h

@@ -134,7 +134,7 @@
 
 #if (_Py_TAIL_CALL_INTERP || USE_COMPUTED_GOTOS) && _Py_TIER2
 #  define IS_JIT_TRACING() (DISPATCH_TABLE_VAR == TRACING_DISPATCH_TABLE)
-#  define IS_JIT_TRACING_MAKING_PROGRESS() (IS_JIT_TRACING() && tstate->interp->jit_state.specialize_counter < MAX_SPECIALIZATION_TRIES)
+#  define IS_JIT_TRACING_MAKING_PROGRESS() (IS_JIT_TRACING() && tstate->interp->jit_state.prev_state.specialize_counter < MAX_SPECIALIZATION_TRIES)
 #  define ENTER_TRACING() \
     DISPATCH_TABLE_VAR = TRACING_DISPATCH_TABLE;
 #  define LEAVE_TRACING() \
@@ -402,7 +402,7 @@ do {                                                   \
         JUMP_TO_LABEL(error);                          \
     }                                                  \
     if (keep_tracing_bit) { \
-        assert(tstate->interp->jit_state.code_curr_size == 2 || tstate->interp->jit_state.code_curr_size == 3); \
+        assert(tstate->interp->jit_state.prev_state.code_curr_size == 2); \
         ENTER_TRACING(); \
         DISPATCH_NON_TRACING(); \
     } \