@@ -3171,6 +3171,29 @@ dummy_func(
 #endif
         }
 
+        // Exact same as _PUSH_FRAME. But marks a frame as inlineable
+        // to the tier 2 redundancy eliminator.
+        // TODO: add support to pseudo for uops.
+        op(_PUSH_FRAME_INLINEABLE, (new_frame: _PyInterpreterFrame* -- unused if (0))) {
+            // Write it out explicitly because it's subtly different.
+            // Eventually this should be the only occurrence of this code.
+            assert(tstate->interp->eval_frame == NULL);
+            SYNC_SP();
+            _PyFrame_SetStackPointer(frame, stack_pointer);
+            new_frame->previous = frame;
+            CALL_STAT_INC(inlined_py_calls);
+            frame = tstate->current_frame = new_frame;
+            tstate->py_recursion_remaining--;
+            LOAD_SP();
+            LOAD_IP(0);
+#if LLTRACE && TIER_ONE
+            lltrace = maybe_lltrace_resume_frame(frame, &entry_frame, GLOBALS());
+            if (lltrace < 0) {
+                goto exit_unwind;
+            }
+#endif
+        }
+
         macro(CALL_BOUND_METHOD_EXACT_ARGS) =
             unused/1 + // Skip over the counter
             _CHECK_PEP_523 +
 
@@ -743,7 +743,7 @@ function_decide_inlineable(PyFunctionObject *func)
     if (func == NULL) {
         return 0;
     }
-    PyCodeObject *co = func->func_code;
+    PyCodeObject *co = (PyCodeObject *)func->func_code;
     if (co == NULL) {
         return 0;
     }
@@ -823,7 +823,9 @@ peephole_opt(_PyInterpreterFrame *frame, _PyUOpInstruction *buffer, int buffer_s
                     co = (PyCodeObject *)func->func_code;
                 }
                 frame_depth--;
-                function_decide_inlineable(func);
+                if (function_decide_inlineable(func)) {
+                    push_frame[frame_depth]->opcode = _PUSH_FRAME_INLINEABLE;
+                }
                 assert(frame_depth >= 1);
                 break;
             }
 
@@ -323,6 +323,17 @@ dummy_func(void) {
         new_frame->push_frame = this_instr;
     }
 
+    // This should be identical to _PUSH_FRAME!
+    op(_PUSH_FRAME_INLINEABLE, (new_frame: _Py_UOpsAbstractFrame * -- unused if (0))) {
+        SYNC_SP();
+        ctx->frame->stack_pointer = stack_pointer;
+        ctx->frame->after_call_stackentries = STACK_LEVEL();
+        ctx->frame = new_frame;
+        ctx->curr_frame_depth++;
+        stack_pointer = new_frame->stack_pointer;
+        new_frame->push_frame = this_instr;
+    }
+
     op(_SET_IP, (instr_ptr/4 --)) {
         ctx->frame->instr_ptr = (_PyUOpInstruction *)instr_ptr;
     }
Original file line number	Diff line number	Diff line change
`@@ -743,7 +743,7 @@ function_decide_inlineable(PyFunctionObject *func)`
`743`	`743`	`if (func == NULL) {`
`744`	`744`	`return 0;`
`745`	`745`	`}`
`746`		`- PyCodeObject *co = func->func_code;`
	`746`	`+ PyCodeObject co = (PyCodeObject )func->func_code;`
`747`	`747`	`if (co == NULL) {`
`748`	`748`	`return 0;`
`749`	`749`	`}`
`@@ -823,7 +823,9 @@ peephole_opt(_PyInterpreterFrame frame, _PyUOpInstruction buffer, int buffer_s`
`823`	`823`	`co = (PyCodeObject *)func->func_code;`
`824`	`824`	`}`
`825`	`825`	`frame_depth--;`
`826`		`- function_decide_inlineable(func);`
	`826`	`+ if (function_decide_inlineable(func)) {`
	`827`	`+ push_frame[frame_depth]->opcode = _PUSH_FRAME_INLINEABLE;`
	`828`	`+ }`
`827`	`829`	`assert(frame_depth >= 1);`
`828`	`830`	`break;`
`829`	`831`	`}`