add workaround

Author: kumaraditya303

Include/internal/pycore_ceval.h

@@ -444,6 +444,13 @@ _Py_BuiltinCallFastWithKeywords_StackRefSteal(
     _PyStackRef *arguments,
     int total_args);
 
+PyAPI_FUNC(PyObject *)
+_PyCallMethodDescriptorO_StackRef(
+    _PyStackRef callable,
+    PyCFunction cfunc,
+    _PyStackRef self_stackref,
+    _PyStackRef arg_stackref);
+
 PyAPI_FUNC(PyObject *)
 _PyCallMethodDescriptorFast_StackRefSteal(
     _PyStackRef callable,

Modules/_testinternalcapi/test_cases.c.h

@@ -4756,14 +4756,14 @@ dummy_func(
             }
             // CPython promises to check all non-vectorcall function calls.
             EXIT_IF(_Py_ReachedRecursionLimit(tstate));
-            _PyStackRef arg_stackref = arguments[1];
-            _PyStackRef self_stackref = arguments[0];
             STAT_INC(CALL, hit);
             PyCFunction cfunc = method->d_method->ml_meth;
-            PyObject *res_o = _PyCFunction_TrampolineCall(cfunc,
-                                  PyStackRef_AsPyObjectBorrow(self_stackref),
-                                  PyStackRef_AsPyObjectBorrow(arg_stackref));
-            _Py_LeaveRecursiveCallTstate(tstate);
+            PyObject *res_o = _PyCallMethodDescriptorO_StackRef(
+                callable,
+                cfunc,
+                arguments[0],
+                arguments[1]
+            );
             assert((res_o != NULL) ^ (_PyErr_Occurred(tstate) != NULL));
             if (res_o == NULL) {
                 ERROR_NO_POP();
@@ -4779,11 +4779,12 @@ dummy_func(
             assert(oparg == 2);
             EXIT_IF(_Py_ReachedRecursionLimit(tstate));
             STAT_INC(CALL, hit);
-            PyObject *res_o = _PyCFunction_TrampolineCall(
-                                  (PyCFunction)cfunc,
-                                  PyStackRef_AsPyObjectBorrow(args[0]),
-                                  PyStackRef_AsPyObjectBorrow(args[1]));
-            _Py_LeaveRecursiveCallTstate(tstate);
+            PyObject *res_o = _PyCallMethodDescriptorO_StackRef(
+                callable,
+                (PyCFunction)cfunc,
+                args[0],
+                args[1]
+            );
             assert((res_o != NULL) ^ (_PyErr_Occurred(tstate) != NULL));
             if (res_o == NULL) {
                 ERROR_NO_POP();

Python/bytecodes.c

@@ -871,6 +871,22 @@ _Py_BuiltinCallFastWithKeywords_StackRefSteal(
     return res;
 }
 
+PyObject *
+_PyCallMethodDescriptorO_StackRef(
+    _PyStackRef callable,
+    PyCFunction cfunc,
+    _PyStackRef self_stackref,
+    _PyStackRef arg_stackref)
+{
+    PyObject *self = PyStackRef_AsPyObjectBorrow(self_stackref);
+    PyObject *arg = PyStackRef_AsPyObjectBorrow(arg_stackref);
+
+    PyObject *res = _PyCFunction_TrampolineCall(cfunc, self, arg);
+    _Py_LeaveRecursiveCallTstate(_PyThreadState_GET());
+    assert((res != NULL) ^ (PyErr_Occurred() != NULL));
+    return res;
+}
+
 PyObject *
 _PyCallMethodDescriptorFast_StackRefSteal(
     _PyStackRef callable,

Python/ceval.c

@@ -554,9 +554,7 @@ patch_x86_64_32rx(unsigned char *location, uint64_t value)
 
 void patch_got_symbol(jit_state *state, int ordinal);
 void patch_aarch64_trampoline(unsigned char *location, int ordinal, jit_state *state);
-void patch_aarch64_trampoline_addr(unsigned char *location, int ordinal, uint64_t value, jit_state *state);
 void patch_x86_64_trampoline(unsigned char *location, int ordinal, jit_state *state);
-void patch_x86_64_trampoline_addr(unsigned char *location, int ordinal, uint64_t value, jit_state *state);
 
 #include "jit_stencils.h"
 
@@ -587,27 +585,28 @@ patch_got_symbol(jit_state *state, int ordinal)
 void
 patch_aarch64_trampoline(unsigned char *location, int ordinal, jit_state *state)
 {
-    uint64_t value = (uintptr_t)symbols_map[ordinal];
-    patch_aarch64_trampoline_addr(location, ordinal, value, state);
-}
 
-// Generate and patch AArch64 trampolines for dynamic addresses (e.g. operands).
-// Unlike patch_aarch64_trampoline, the target address is passed directly rather
-// than looked up from symbols_map. The ordinal is used to allocate a trampoline slot.
-void
-patch_aarch64_trampoline_addr(unsigned char *location, int ordinal, uint64_t value, jit_state *state)
-{
-    int64_t range = (int64_t)value - (int64_t)(uintptr_t)location;
+    uint64_t value = (uintptr_t)symbols_map[ordinal];
+    int64_t range = value - (uintptr_t)location;
 
+    // If we are in range of 28 signed bits, we patch the instruction with
+    // the address of the symbol.
     if (range >= -(1 << 27) && range < (1 << 27)) {
-        patch_aarch64_26r(location, value);
+        patch_aarch64_26r(location, (uintptr_t)value);
         return;
     }
 
+    // Out of range - need a trampoline
     uint32_t *p = (uint32_t *)get_symbol_slot(ordinal, &state->trampolines, TRAMPOLINE_SIZE);
 
-    p[0] = 0x58000048; // ldr x8, 8
-    p[1] = 0xD61F0100; // br x8
+    /* Generate the trampoline
+       0: 58000048      ldr     x8, 8
+       4: d61f0100      br      x8
+       8: 00000000      // The next two words contain the 64-bit address to jump to.
+       c: 00000000
+    */
+    p[0] = 0x58000048;
+    p[1] = 0xD61F0100;
     p[2] = value & 0xffffffff;
     p[3] = value >> 32;
 
@@ -619,13 +618,7 @@ void
 patch_x86_64_trampoline(unsigned char *location, int ordinal, jit_state *state)
 {
     uint64_t value = (uintptr_t)symbols_map[ordinal];
-    patch_x86_64_trampoline_addr(location, ordinal, value, state);
-}
-
-void
-patch_x86_64_trampoline_addr(unsigned char *location, int ordinal, uint64_t value, jit_state *state)
-{
-    int64_t range = (int64_t)value - 4 - (int64_t)(uintptr_t)location;
+    int64_t range = (int64_t)value - 4 - (int64_t)location;
 
     // If we are in range of 32 signed bits, we can patch directly
     if (range >= -(1LL << 31) && range < (1LL << 31)) {

Python/executor_cases.c.h

@@ -296,33 +296,6 @@ def process_relocations(self, known_symbols: dict[str, int]) -> None:
                 self._trampolines.add(ordinal)
                 hole.addend = ordinal
                 hole.symbol = None
-            # aarch64 trampolines for operand-based call targets (e.g. inlined cfunc)
-            elif hole.kind in {
-                "R_AARCH64_CALL26",
-                "R_AARCH64_JUMP26",
-                "ARM64_RELOC_BRANCH26",
-            } and hole.value in {HoleValue.OPERAND0, HoleValue.OPERAND1}:
-                value_expr = _HOLE_EXPRS[hole.value]
-                ordinal = len(known_symbols)
-                synth_name = f"_JIT_TRAMPOLINE_{hole.value.name}_{ordinal}"
-                known_symbols[synth_name] = ordinal
-                self._trampolines.add(ordinal)
-                hole.func = "patch_aarch64_trampoline_addr"
-                hole.need_state = True
-                hole.custom_value = f"{ordinal}, {value_expr}"
-            # x86_64 trampolines for operand-based call targets (e.g. inlined cfunc)
-            elif (
-                hole.kind in {"R_X86_64_PLT32", "X86_64_RELOC_BRANCH"}
-                and hole.value in {HoleValue.OPERAND0, HoleValue.OPERAND1}
-            ):
-                value_expr = _HOLE_EXPRS[hole.value]
-                ordinal = len(known_symbols)
-                synth_name = f"_JIT_TRAMPOLINE_{hole.value.name}_{ordinal}"
-                known_symbols[synth_name] = ordinal
-                self._trampolines.add(ordinal)
-                hole.func = "patch_x86_64_trampoline_addr"
-                hole.need_state = True
-                hole.custom_value = f"{ordinal}, {value_expr}"
             # x86_64 Darwin trampolines for external symbols
             elif (
                 hole.kind == "X86_64_RELOC_BRANCH"

Python/generated_cases.c.h

@@ -35,10 +35,7 @@ def _dump_footer(
     yield f"static const void * const symbols_map[{max(len(symbols), 1)}] = {{"
     if symbols:
         for symbol, ordinal in symbols.items():
-            if symbol.startswith("_JIT_TRAMPOLINE_"):
-                yield f"    [{ordinal}] = 0,"
-            else:
-                yield f"    [{ordinal}] = &{symbol},"
+            yield f"    [{ordinal}] = &{symbol},"
     else:
         yield "    0"
     yield "};"