Address Pablo's feedback

Author: diegorusso

Doc/c-api/perfmaps.rst

@@ -31,7 +31,7 @@ Note that holding an :term:`attached thread state` is not required for these API
    or ``-2`` on failure to create a lock. Check ``errno`` for more information
    about the cause of a failure.
 
-.. c:function:: int PyUnstable_WritePerfMapEntry(const void *code_addr, unsigned int code_size, const char *entry_name)
+.. c:function:: int PyUnstable_WritePerfMapEntry(const void *code_addr, size_t code_size, const char *entry_name)
 
    Write one single entry to the ``/tmp/perf-$pid.map`` file. This function is
    thread safe. Here is what an example entry looks like::

Include/cpython/ceval.h

@@ -38,7 +38,7 @@ typedef struct {
 PyAPI_FUNC(int) PyUnstable_PerfMapState_Init(void);
 PyAPI_FUNC(int) PyUnstable_WritePerfMapEntry(
     const void *code_addr,
-    unsigned int code_size,
+    size_t code_size,
     const char *entry_name);
 PyAPI_FUNC(void) PyUnstable_PerfMapState_Fini(void);
 PyAPI_FUNC(int) PyUnstable_CopyPerfMapFile(const char* parent_filename);

Include/internal/pycore_jit_unwind.h

@@ -1,10 +1,39 @@
-#ifndef Py_CORE_JIT_UNWIND_H
-#define Py_CORE_JIT_UNWIND_H
+#ifndef Py_INTERNAL_JIT_UNWIND_H
+#define Py_INTERNAL_JIT_UNWIND_H
 
-#ifdef PY_HAVE_PERF_TRAMPOLINE
+#ifndef Py_BUILD_CORE
+#  error "this header requires Py_BUILD_CORE define"
+#endif
+
+#if defined(PY_HAVE_PERF_TRAMPOLINE) || (defined(__linux__) && defined(__ELF__))
 
 #include <stddef.h>
 
+/* DWARF exception-handling pointer encodings shared by JIT unwind users. */
+enum {
+    DWRF_EH_PE_absptr = 0x00,
+    DWRF_EH_PE_omit = 0xff,
+
+    /* Data type encodings */
+    DWRF_EH_PE_uleb128 = 0x01,
+    DWRF_EH_PE_udata2 = 0x02,
+    DWRF_EH_PE_udata4 = 0x03,
+    DWRF_EH_PE_udata8 = 0x04,
+    DWRF_EH_PE_sleb128 = 0x09,
+    DWRF_EH_PE_sdata2 = 0x0a,
+    DWRF_EH_PE_sdata4 = 0x0b,
+    DWRF_EH_PE_sdata8 = 0x0c,
+    DWRF_EH_PE_signed = 0x08,
+
+    /* Reference type encodings */
+    DWRF_EH_PE_pcrel = 0x10,
+    DWRF_EH_PE_textrel = 0x20,
+    DWRF_EH_PE_datarel = 0x30,
+    DWRF_EH_PE_funcrel = 0x40,
+    DWRF_EH_PE_aligned = 0x50,
+    DWRF_EH_PE_indirect = 0x80
+};
+
 /* Return the size of the generated .eh_frame data for the given encoding. */
 size_t _PyJitUnwind_EhFrameSize(int absolute_addr);
 
@@ -18,13 +47,13 @@ size_t _PyJitUnwind_BuildEhFrame(uint8_t *buffer, size_t buffer_size,
                                  const void *code_addr, size_t code_size,
                                  int absolute_addr);
 
-void _PyJitUnwind_GdbRegisterCode(const void *code_addr,
+void *_PyJitUnwind_GdbRegisterCode(const void *code_addr,
                                   size_t code_size,
                                   const char *entry,
                                   const char *filename);
 
-void _PyJitUnwind_GdbUnregisterCode(const void *code_addr);
+void _PyJitUnwind_GdbUnregisterCode(void *handle);
 
-#endif  // PY_HAVE_PERF_TRAMPOLINE
+#endif  // defined(PY_HAVE_PERF_TRAMPOLINE) || (defined(__linux__) && defined(__ELF__))
 
-#endif  // Py_CORE_JIT_UNWIND_H
+#endif  // Py_INTERNAL_JIT_UNWIND_H

Include/internal/pycore_optimizer.h

@@ -151,6 +151,7 @@ typedef struct _PyExecutorObject {
     uint32_t code_size;
     size_t jit_size;
     void *jit_code;
+    void *jit_gdb_handle;
     _PyExitData exits[1];
 } _PyExecutorObject;
 

Lib/test/test_perfmaps.py

@@ -1,4 +1,5 @@
 import os
+import sys
 import sysconfig
 import unittest
 
@@ -17,11 +18,25 @@ def supports_trampoline_profiling():
     raise unittest.SkipTest("perf trampoline profiling not supported")
 
 class TestPerfMapWriting(unittest.TestCase):
+    def tearDown(self):
+        perf_map_state_teardown()
+
     def test_write_perf_map_entry(self):
         self.assertEqual(write_perf_map_entry(0x1234, 5678, "entry1"), 0)
         self.assertEqual(write_perf_map_entry(0x2345, 6789, "entry2"), 0)
         with open(f"/tmp/perf-{os.getpid()}.map") as f:
             perf_file_contents = f.read()
             self.assertIn("1234 162e entry1", perf_file_contents)
             self.assertIn("2345 1a85 entry2", perf_file_contents)
-        perf_map_state_teardown()
+
+    @unittest.skipIf(sys.maxsize <= 2**32, "requires size_t wider than unsigned int")
+    def test_write_perf_map_entry_large_size(self):
+        code_addr = 0x3456
+        code_size = 1 << 33
+        entry_name = "entry_big"
+
+        self.assertEqual(write_perf_map_entry(code_addr, code_size, entry_name), 0)
+        with open(f"/tmp/perf-{os.getpid()}.map") as f:
+            perf_file_contents = f.read()
+            self.assertIn(f"{code_addr:x} {code_size:x} {entry_name}",
+                          perf_file_contents)

Modules/_testinternalcapi.c

@@ -1210,17 +1210,23 @@ write_perf_map_entry(PyObject *self, PyObject *args)
 {
     PyObject *code_addr_v;
     const void *code_addr;
+    PyObject *code_size_s;
     size_t code_size;
     const char *entry_name;
 
-    if (!PyArg_ParseTuple(args, "OIs", &code_addr_v, &code_size, &entry_name))
+    if (!PyArg_ParseTuple(args, "OOs", &code_addr_v, &code_size_s, &entry_name))
         return NULL;
     code_addr = PyLong_AsVoidPtr(code_addr_v);
     if (code_addr == NULL) {
         return NULL;
     }
 
-    int ret = PyUnstable_WritePerfMapEntry(code_addr, (unsigned int)code_size, entry_name);
+    code_size = PyLong_AsSize_t(code_size_s);
+    if (code_size == (size_t)-1 && PyErr_Occurred()) {
+        return NULL;
+    }
+
+    int ret = PyUnstable_WritePerfMapEntry(code_addr, code_size, entry_name);
     if (ret < 0) {
         PyErr_SetFromErrno(PyExc_OSError);
         return NULL;

Python/jit.c

@@ -61,7 +61,7 @@ jit_error(const char *message)
     PyErr_Format(PyExc_RuntimeWarning, "JIT %s (%d)", message, hint);
 }
 
-static void
+static void *
 jit_record_code(const void *code_addr, size_t code_size,
                 const char *entry, const char *filename)
 {
@@ -71,19 +71,24 @@ jit_record_code(const void *code_addr, size_t code_size,
     if (callbacks.write_state == _Py_perfmap_jit_callbacks.write_state) {
         _PyPerfJit_WriteNamedCode(
             code_addr, code_size, entry, filename);
-        return;
+        return NULL;
     }
-    _PyJitUnwind_GdbRegisterCode(
+#endif
+
+#if defined(__linux__) && defined(__ELF__)
+    return _PyJitUnwind_GdbRegisterCode(
         code_addr, code_size, entry, filename);
 #else
     (void)code_addr;
     (void)code_size;
     (void)entry;
     (void)filename;
+    return NULL;
 #endif
 }
 
 static size_t _Py_jit_shim_size = 0;
+static void *_Py_jit_shim_gdb_handle = NULL;
 
 static int
 address_in_executor_array(_PyExecutorObject **ptrs, size_t count, uintptr_t addr)
@@ -754,7 +759,7 @@ _PyJIT_Compile(_PyExecutorObject *executor, const _PyUOpInstruction trace[], siz
     }
     executor->jit_code = memory;
     executor->jit_size = total_size;
-    jit_record_code(memory,
+    executor->jit_gdb_handle = jit_record_code(memory,
                     code_size + state.trampolines.size,
                     "jit_entry",
                     "<jit>");
@@ -808,10 +813,10 @@ compile_shim(void)
         return NULL;
     }
     _Py_jit_shim_size = total_size;
-    jit_record_code(memory,
-                    code_size + state.trampolines.size,
-                    "jit_entry",
-                    "<jit>");
+    _Py_jit_shim_gdb_handle = jit_record_code(memory,
+                                              code_size + state.trampolines.size,
+                                              "jit_entry",
+                                              "<jit>");
     return (_PyJitEntryFuncPtr)memory;
 }
 
@@ -843,8 +848,11 @@ _PyJIT_Free(_PyExecutorObject *executor)
     if (memory) {
         executor->jit_code = NULL;
         executor->jit_size = 0;
-#ifdef PY_HAVE_PERF_TRAMPOLINE
-        _PyJitUnwind_GdbUnregisterCode(memory);
+#if defined(__linux__) && defined(__ELF__)
+        if (executor->jit_gdb_handle != NULL) {
+            _PyJitUnwind_GdbUnregisterCode(executor->jit_gdb_handle);
+            executor->jit_gdb_handle = NULL;
+        }
 #endif
         if (jit_free(memory, size)) {
             PyErr_FormatUnraisable("Exception ignored while "
@@ -863,8 +871,11 @@ _PyJIT_Fini(void)
     if (size) {
         _Py_jit_entry = _Py_LazyJitShim;
         _Py_jit_shim_size = 0;
-#ifdef PY_HAVE_PERF_TRAMPOLINE
-        _PyJitUnwind_GdbUnregisterCode(memory);
+#if defined(__linux__) && defined(__ELF__)
+        if (_Py_jit_shim_gdb_handle != NULL) {
+            _PyJitUnwind_GdbUnregisterCode(_Py_jit_shim_gdb_handle);
+            _Py_jit_shim_gdb_handle = NULL;
+        }
 #endif
         if (jit_free(memory, size)) {
             PyErr_FormatUnraisable("Exception ignored while "