Kenjin tier2 inliner redux pristine

Include/internal/pycore_frame.h

@@ -65,6 +65,7 @@ typedef struct _PyInterpreterFrame {
     _Py_CODEUNIT *instr_ptr; /* Instruction currently executing (or about to begin) */
     int stacktop;  /* Offset of TOS from localsplus  */
     uint16_t return_offset;  /* Only relevant during a function call */
+    uint16_t tier2_extra_size; /* How many extra entries is at the end of localsplus for tier 2 inlining */
     char owner;
     /* Locals and stack */
     PyObject *localsplus[1];
@@ -131,6 +132,7 @@ _PyFrame_Initialize(
     frame->instr_ptr = _PyCode_CODE(code);
     frame->return_offset = 0;
     frame->owner = FRAME_OWNED_BY_THREAD;
+    frame->tier2_extra_size = 0;
 
     for (int i = null_locals_from; i < code->co_nlocalsplus; i++) {
         frame->localsplus[i] = NULL;
@@ -258,6 +260,36 @@ _PyThreadState_PushFrame(PyThreadState *tstate, size_t size);
 
 void _PyThreadState_PopFrame(PyThreadState *tstate, _PyInterpreterFrame *frame);
 
+
+/* Converts frame for tier 2.
+ * Adds stack space at the end of the current frame for Tier 2 execution.
+ * The frame that is being expanded MUST be the current executing frame, and
+ * it must be at the top of the datastack.
+ * */
+static inline int
+_PyFrame_ConvertToTier2(PyThreadState *tstate, _PyInterpreterFrame *frame,
+                        int localsplus_grow)
+{
+    assert(localsplus_grow > 0);
+    // Already grown previously
+    if (frame->tier2_extra_size >= localsplus_grow) {
+        return 0;
+    }
+    if (frame->owner != FRAME_OWNED_BY_THREAD) {
+        return 1;
+    }
+    localsplus_grow -= frame->tier2_extra_size;
+    if (!_PyThreadState_HasStackSpace(tstate, localsplus_grow)) {
+        return 1;
+    }
+    assert(_PyThreadState_HasStackSpace(tstate, localsplus_grow));
+    assert(tstate->current_frame == frame);
+    tstate->datastack_top += localsplus_grow;
+    assert(tstate->datastack_top < tstate->datastack_limit);
+    frame->tier2_extra_size += localsplus_grow;
+    return 0;
+}
+
 /* Pushes a frame without checking for space.
  * Must be guarded by _PyThreadState_HasStackSpace()
  * Consumes reference to func. */

Include/internal/pycore_optimizer.h

@@ -53,6 +53,13 @@ struct _Py_UOpsAbstractFrame {
     _Py_UopsSymbol **stack_pointer;
     _Py_UopsSymbol **stack;
     _Py_UopsSymbol **locals;
+
+    // Reflects the real localsplus that will be used in the VM.
+    // This may differ from locals if the frame is inlined.
+    // For an inlined frame, the inlinee shares the same localsplus
+    // as the inliner.
+    _Py_UopsSymbol **real_localsplus;
+    bool is_inlineable;
 };
 
 typedef struct _Py_UOpsAbstractFrame _Py_UOpsAbstractFrame;
@@ -109,6 +116,7 @@ extern _Py_UOpsAbstractFrame *_Py_uop_frame_new(
     _Py_UopsSymbol **localsplus_start,
     int n_locals_already_filled,
     int curr_stackentries);
+extern _Py_UOpsAbstractFrame *_Py_uop_prev_frame(_Py_UOpsContext *ctx);
 extern int _Py_uop_frame_pop(_Py_UOpsContext *ctx);
 
 PyAPI_FUNC(PyObject *) _Py_uop_symbols_test(PyObject *self, PyObject *ignored);