#include "Python.h"

#include "pycore_jit_unwind.h"

#include "pycore_lock.h"

#if defined(PY_HAVE_JIT_GDB_UNWIND)

# include "jit_unwind_info.h"

# if !JIT_UNWIND_INFO_SUPPORTED

# error "JIT unwind info was not generated for this target"

#if defined(PY_HAVE_PERF_TRAMPOLINE) \

|| defined(PY_HAVE_JIT_GDB_UNWIND) \

|| defined(PY_HAVE_JIT_GNU_BACKTRACE_UNWIND)

#if defined(PY_HAVE_JIT_GDB_UNWIND)

# include <elf.h>

#if defined(PY_HAVE_JIT_GNU_BACKTRACE_UNWIND)

void __register_frame(const void *);

void __deregister_frame(const void *);

#include <stdio.h>

#include <string.h>

#define DWRF_CIE_VERSION 1

enum {

DWRF_CFA_nop = 0x0, // No operation

DWRF_CFA_offset_extended = 0x5, // Extended offset instruction

DWRF_CFA_def_cfa = 0xc, // Define CFA rule

DWRF_CFA_def_cfa_register = 0xd, // Define CFA register

DWRF_CFA_def_cfa_offset = 0xe, // Define CFA offset

DWRF_CFA_offset_extended_sf = 0x11, // Extended signed offset

DWRF_CFA_advance_loc = 0x40, // Advance location counter

DWRF_CFA_offset = 0x80, // Simple offset instruction

#if defined(__aarch64__)

DWRF_CFA_AARCH64_negate_ra_state = 0x2d, // Toggle return address signing state

DWRF_CFA_restore = 0xc0 // Restore register

};

enum {

#ifdef __x86_64__

/* x86_64 register numbering (note: order is defined by x86_64 ABI) */

DWRF_REG_AX, // RAX

DWRF_REG_DX, // RDX

DWRF_REG_CX, // RCX

DWRF_REG_BX, // RBX

DWRF_REG_SI, // RSI

DWRF_REG_DI, // RDI

DWRF_REG_BP, // RBP

DWRF_REG_SP, // RSP

DWRF_REG_8, // R8

DWRF_REG_9, // R9

DWRF_REG_10, // R10

DWRF_REG_11, // R11

DWRF_REG_12, // R12

DWRF_REG_13, // R13

DWRF_REG_14, // R14

DWRF_REG_15, // R15

DWRF_REG_RA, // Return address (RIP)

#elif defined(__aarch64__) && defined(__AARCH64EL__) && !defined(__ILP32__)

/* AArch64 register numbering */

DWRF_REG_FP = 29, // Frame Pointer

DWRF_REG_RA = 30, // Link register (return address)

DWRF_REG_SP = 31, // Stack pointer

# error "Unsupported target architecture"

};

typedef struct ELFObjectContext {

} ELFObjectContext;

static uint32_t elfctx_append_string(ELFObjectContext* ctx, const char* str) {

uint8_t* p = ctx->p;

uint32_t ofs = (uint32_t)(p - ctx->startp);

/* Copy string including null terminator */

do {

*p++ = (uint8_t)*str;

} while (*str++);

ctx->p = p;

return ofs;

}

static void elfctx_append_sleb128(ELFObjectContext* ctx, int32_t v) {

uint8_t* p = ctx->p;

/* Encode 7 bits at a time, with continuation bit in MSB */

for (; (uint32_t)(v + 0x40) >= 0x80; v >>= 7) {

*p++ = (uint8_t)((v & 0x7f) | 0x80); // Set continuation bit

}

*p++ = (uint8_t)(v & 0x7f); // Final byte without continuation bit

ctx->p = p;

}

static void elfctx_append_uleb128(ELFObjectContext* ctx, uint32_t v) {

uint8_t* p = ctx->p;

/* Encode 7 bits at a time, with continuation bit in MSB */

for (; v >= 0x80; v >>= 7) {

*p++ = (char)((v & 0x7f) | 0x80); // Set continuation bit

}

*p++ = (char)v; // Final byte without continuation bit

ctx->p = p;

}

#define DWRF_U8(x) (*p++ = (x)) // Write unsigned 8-bit

#define DWRF_I8(x) (*(int8_t*)p = (x), p++) // Write signed 8-bit

#define DWRF_U16(x) (*(uint16_t*)p = (x), p += 2) // Write unsigned 16-bit

#define DWRF_U32(x) (*(uint32_t*)p = (x), p += 4) // Write unsigned 32-bit

#define DWRF_ADDR(x) (*(uintptr_t*)p = (x), p += sizeof(uintptr_t)) // Write address

#define DWRF_UV(x) (ctx->p = p, elfctx_append_uleb128(ctx, (x)), p = ctx->p) // Write ULEB128

#define DWRF_SV(x) (ctx->p = p, elfctx_append_sleb128(ctx, (x)), p = ctx->p) // Write SLEB128

#define DWRF_STR(str) (ctx->p = p, elfctx_append_string(ctx, (str)), p = ctx->p) // Write string

#define DWRF_ALIGNNOP(s) \

while ((uintptr_t)p & ((s)-1)) { \

*p++ = DWRF_CFA_nop; \

}

#define DWRF_SECTION(name, stmt) \

{ \

uint32_t* szp_##name = (uint32_t*)p; \

p += 4; \

stmt; \

*szp_##name = (uint32_t)((p - (uint8_t*)szp_##name) - 4); \

}

static void elf_init_ehframe_perf(ELFObjectContext* ctx);

#if defined(PY_HAVE_JIT_GDB_UNWIND)

static void elf_init_ehframe_gdb(ELFObjectContext* ctx);

static inline void elf_init_ehframe(ELFObjectContext* ctx, int absolute_addr) {

if (absolute_addr) {

#if defined(PY_HAVE_JIT_GDB_UNWIND)

elf_init_ehframe_gdb(ctx);

Py_UNREACHABLE();

}

else {

elf_init_ehframe_perf(ctx);

}

}

_PyJitUnwind_EhFrameSize(int absolute_addr)

{

/* The .eh_frame we emit is small and bounded; keep a generous buffer. */

uint8_t scratch[512];

_Static_assert(sizeof(scratch) >= 256,

"scratch buffer may be too small for elf_init_ehframe");

ELFObjectContext ctx;

ctx.code_size = 1;

ctx.code_addr = 0;

ctx.startp = ctx.p = scratch;

ctx.fde_p = NULL;

/* Generate once into scratch to learn the required size. */

elf_init_ehframe(&ctx, absolute_addr);

ptrdiff_t size = ctx.p - ctx.startp;

assert(size <= (ptrdiff_t)sizeof(scratch));

return (size_t)size;

}

_PyJitUnwind_BuildEhFrame(uint8_t *buffer, size_t buffer_size,

const void *code_addr, size_t code_size,

int absolute_addr)

{

if (buffer == NULL || code_addr == NULL || code_size == 0) {

return 0;

}

/* Generate the frame twice: once to size-check, once to write. */

size_t required = _PyJitUnwind_EhFrameSize(absolute_addr);

if (required == 0 || required > buffer_size) {

return 0;

}

ELFObjectContext ctx;

ctx.code_size = code_size;

ctx.code_addr = (uintptr_t)code_addr;

ctx.startp = ctx.p = buffer;

ctx.fde_p = NULL;

elf_init_ehframe(&ctx, absolute_addr);

size_t written = (size_t)(ctx.p - ctx.startp);

/* The frame size is independent of code_addr/code_size (fixed-width fields). */

assert(written == required);

return written;

}

static void elf_init_ehframe_perf(ELFObjectContext* ctx) {

int fde_ptr_enc = DWRF_EH_PE_pcrel | DWRF_EH_PE_sdata4;

uint8_t* p = ctx->p;

uint8_t* framep = p; // Remember start of frame data

/*

/*

DWRF_SECTION(CIE,

DWRF_U32(0); // CIE ID (0 indicates this is a CIE)

DWRF_U8(DWRF_CIE_VERSION); // CIE version (1)

DWRF_STR("zR"); // Augmentation string ("zR" = has LSDA)

#ifdef __x86_64__

DWRF_UV(1); // Code alignment factor (x86_64: 1 byte)

#elif defined(__aarch64__) && defined(__AARCH64EL__) && !defined(__ILP32__)

DWRF_UV(4); // Code alignment factor (AArch64: 4 bytes per instruction)

DWRF_SV(-(int64_t)sizeof(uintptr_t)); // Data alignment factor (negative)

DWRF_U8(DWRF_REG_RA); // Return address register number

DWRF_UV(1); // Augmentation data length

DWRF_U8(fde_ptr_enc); // FDE pointer encoding

/* Initial CFI instructions - describe default calling convention */

#ifdef __x86_64__

/* x86_64 initial CFI state */

DWRF_U8(DWRF_CFA_def_cfa); // Define CFA (Call Frame Address)

DWRF_UV(DWRF_REG_SP); // CFA = SP register

DWRF_UV(sizeof(uintptr_t)); // CFA = SP + pointer_size

DWRF_U8(DWRF_CFA_offset|DWRF_REG_RA); // Return address is saved

DWRF_UV(1); // At offset 1 from CFA

#elif defined(__aarch64__) && defined(__AARCH64EL__) && !defined(__ILP32__)

/* AArch64 initial CFI state */

DWRF_U8(DWRF_CFA_def_cfa); // Define CFA (Call Frame Address)

DWRF_UV(DWRF_REG_SP); // CFA = SP register

DWRF_UV(0); // CFA = SP + 0 (AArch64 starts with offset 0)

// No initial register saves in AArch64 CIE

DWRF_ALIGNNOP(sizeof(uintptr_t)); // Align to pointer boundary

)

/*

DWRF_SECTION(FDE,

DWRF_U32((uint32_t)(p - framep)); // Offset to CIE (backwards reference)

/*

ctx->fde_p = p; // Remember where PC offset field is located for later calculation

DWRF_U32(0); // Placeholder for PC-relative offset (calculated below)

DWRF_U32(ctx->code_size); // Address range covered by this FDE (code length)

DWRF_U8(0); // Augmentation data length (none)

/*

#ifdef __x86_64__

/* x86_64 calling convention unwinding rules */

# if defined(__CET__) && (__CET__ & 1)

DWRF_U8(DWRF_CFA_advance_loc | 4); // Advance past endbr64 (4 bytes)

DWRF_U8(DWRF_CFA_advance_loc | 1); // Advance past push %rbp (1 byte)

DWRF_U8(DWRF_CFA_def_cfa_offset); // def_cfa_offset 16

DWRF_UV(16); // New offset: SP + 16

DWRF_U8(DWRF_CFA_offset | DWRF_REG_BP); // offset r6 at cfa-16

DWRF_UV(2); // Offset factor: 2 * 8 = 16 bytes

DWRF_U8(DWRF_CFA_advance_loc | 3); // Advance past mov %rsp,%rbp (3 bytes)

DWRF_U8(DWRF_CFA_def_cfa_register); // def_cfa_register r6

DWRF_UV(DWRF_REG_BP); // Use base pointer register

DWRF_U8(DWRF_CFA_advance_loc | 3); // Advance past call *%rcx (2 bytes) + pop %rbp (1 byte) = 3

DWRF_U8(DWRF_CFA_def_cfa); // def_cfa r7 ofs 8

DWRF_UV(DWRF_REG_SP); // Use stack pointer register

DWRF_UV(8); // New offset: SP + 8

#elif defined(__aarch64__) && defined(__AARCH64EL__) && !defined(__ILP32__)

/* AArch64 calling convention unwinding rules */

#if defined(__ARM_FEATURE_PAC_DEFAULT) || \

(defined(__ARM_FEATURE_BTI_DEFAULT) && __ARM_FEATURE_BTI_DEFAULT == 1)

DWRF_U8(DWRF_CFA_advance_loc | 1); // Advance past SIGN_LR (4 bytes)

#if defined(__ARM_FEATURE_PAC_DEFAULT)

DWRF_U8(DWRF_CFA_AARCH64_negate_ra_state); // Saved LR is PAC-signed from here

DWRF_U8(DWRF_CFA_advance_loc | 1); // Advance by 1 instruction (4 bytes)

DWRF_U8(DWRF_CFA_def_cfa_offset); // CFA = SP + 16

DWRF_UV(16); // Stack pointer moved by 16 bytes

DWRF_U8(DWRF_CFA_offset | DWRF_REG_FP); // x29 (frame pointer) saved

DWRF_UV(2); // At CFA-16 (2 * 8 = 16 bytes from CFA)

DWRF_U8(DWRF_CFA_offset | DWRF_REG_RA); // x30 (link register) saved

DWRF_UV(1); // At CFA-8 (1 * 8 = 8 bytes from CFA)

DWRF_U8(DWRF_CFA_advance_loc | 3); // Advance by 3 instructions (12 bytes)

#if defined(__ARM_FEATURE_PAC_DEFAULT)

DWRF_U8(DWRF_CFA_AARCH64_negate_ra_state); // LR is authenticated, no longer PAC-signed

DWRF_U8(DWRF_CFA_def_cfa_register); // CFA = FP (x29) + 16

DWRF_UV(DWRF_REG_FP);

DWRF_U8(DWRF_CFA_restore | DWRF_REG_RA); // Restore x30 - NO DWRF_UV() after this!

DWRF_U8(DWRF_CFA_restore | DWRF_REG_FP); // Restore x29 - NO DWRF_UV() after this!

DWRF_U8(DWRF_CFA_def_cfa); // CFA = SP + 0 (stack restored)

DWRF_UV(DWRF_REG_SP);

DWRF_UV(0);

# error "Unsupported target architecture"

DWRF_ALIGNNOP(sizeof(uintptr_t)); // Align to pointer boundary

)

ctx->p = p; // Update context pointer to end of generated data

/* Calculate and update the PC-relative offset in the FDE

int32_t rounded_code_size =

(int32_t)_Py_SIZE_ROUND_UP(ctx->code_size, 8);

int32_t fde_offset_in_frame = (int32_t)(ctx->fde_p - framep);

*(int32_t *)ctx->fde_p = -(rounded_code_size + fde_offset_in_frame);

}

#if defined(PY_HAVE_JIT_GDB_UNWIND)

static void elf_init_ehframe_gdb(ELFObjectContext* ctx) {

int fde_ptr_enc = DWRF_EH_PE_absptr;

uint8_t* p = ctx->p;

uint8_t* framep = p;

DWRF_SECTION(CIE,

DWRF_U32(0); // CIE ID

DWRF_U8(DWRF_CIE_VERSION);

DWRF_STR("zR"); // aug data length + FDE ptr encoding follow

DWRF_UV(JIT_UNWIND_CODE_ALIGNMENT_FACTOR);

DWRF_SV(JIT_UNWIND_DATA_ALIGNMENT_FACTOR);

DWRF_U8(JIT_UNWIND_RA_REG);

DWRF_UV(1); // Augmentation data length

DWRF_U8(fde_ptr_enc); // FDE pointer encoding

/* Executor steady-state rule (our invariant, not the compiler's). */

DWRF_U8(DWRF_CFA_def_cfa);

DWRF_UV(JIT_UNWIND_CFA_REG);

DWRF_UV(JIT_UNWIND_CFA_OFFSET);

DWRF_U8(DWRF_CFA_offset | JIT_UNWIND_FP_REG);

DWRF_UV(JIT_UNWIND_FP_OFFSET);

DWRF_U8(DWRF_CFA_offset | JIT_UNWIND_RA_REG);

DWRF_UV(JIT_UNWIND_RA_OFFSET);

DWRF_ALIGNNOP(sizeof(uintptr_t));

)

DWRF_SECTION(FDE,

DWRF_U32((uint32_t)(p - framep)); // Offset to CIE (backwards reference)

DWRF_ADDR(ctx->code_addr); // Absolute code start

DWRF_ADDR((uintptr_t)ctx->code_size); // Code range covered

DWRF_U8(0); // Augmentation data length (none)

DWRF_ALIGNNOP(sizeof(uintptr_t));

)

ctx->p = p;

}

#if defined(PY_HAVE_JIT_GDB_UNWIND)

enum {

JIT_NOACTION = 0,

JIT_REGISTER_FN = 1,

JIT_UNREGISTER_FN = 2,

};

struct jit_code_entry {

};

struct jit_descriptor {

};

PyMutex _Py_jit_debug_mutex = {0};

Py_EXPORTED_SYMBOL volatile struct jit_descriptor __jit_debug_descriptor = {

1, JIT_NOACTION, NULL, NULL

};

Py_EXPORTED_SYMBOL void __attribute__((noinline))

__jit_debug_register_code(void)

{

/* Keep this call visible to debuggers and not optimized away. */

(void)__jit_debug_descriptor.action_flag;

#if defined(__GNUC__) || defined(__clang__)

__asm__ __volatile__("" ::: "memory");

}

static uint16_t

gdb_jit_machine_id(void)

{

/* Map the current target to ELF e_machine; return 0 to skip registration. */

#if defined(__x86_64__) || defined(_M_X64)

return EM_X86_64;

#elif defined(__aarch64__) && !defined(__ILP32__)

return EM_AARCH64;

return 0;

}

static struct jit_code_entry *

gdb_jit_register_code(

)

{

/*

if (code_addr == NULL || code_size == 0 || symname == NULL) {

return NULL;

}

const uint16_t machine = gdb_jit_machine_id();

if (machine == 0) {

return NULL;

}

enum {

SH_NULL = 0,

SH_TEXT,

SH_EH_FRAME,

SH_SHSTRTAB,

SH_STRTAB,

SH_SYMTAB,

SH_NUM,

};

static const char shstrtab[] =

"\0.text\0.eh_frame\0.shstrtab\0.strtab\0.symtab";

_Static_assert(sizeof(shstrtab) ==

1 + sizeof(".text") + sizeof(".eh_frame") +

sizeof(".shstrtab") + sizeof(".strtab") + sizeof(".symtab"),

"shstrtab size mismatch");

const size_t shstrtab_size = sizeof(shstrtab);

const size_t sh_text = 1;

const size_t sh_eh_frame = sh_text + sizeof(".text");

const size_t sh_shstrtab = sh_eh_frame + sizeof(".eh_frame");

const size_t sh_strtab = sh_shstrtab + sizeof(".shstrtab");

const size_t sh_symtab = sh_strtab + sizeof(".strtab");

const size_t text_size = code_size;

const size_t text_padded = _Py_SIZE_ROUND_UP(text_size, 8);

const size_t strtab_size = 1 + strlen(symname) + 1;

const size_t symtab_size = 3 * sizeof(Elf64_Sym);

size_t offset = sizeof(Elf64_Ehdr);

offset = _Py_SIZE_ROUND_UP(offset, 16);

const size_t text_off = offset;

const size_t eh_off = text_off + text_padded;

offset = eh_off + eh_frame_size;

const size_t shstr_off = offset;

offset += shstrtab_size;

const size_t str_off = offset;

offset += strtab_size;

/* Elf64_Sym requires 8-byte alignment for st_value/st_size. */

offset = _Py_SIZE_ROUND_UP(offset, 8);

const size_t sym_off = offset;

offset += symtab_size;

offset = _Py_SIZE_ROUND_UP(offset, sizeof(Elf64_Shdr));

const size_t sh_off = offset;

const size_t shnum = SH_NUM;

const size_t total_size = sh_off + shnum * sizeof(Elf64_Shdr);

uint8_t *buf = (uint8_t *)PyMem_RawMalloc(total_size);

if (buf == NULL) {

return NULL;

}

memset(buf, 0, total_size);

Elf64_Ehdr *ehdr = (Elf64_Ehdr *)buf;

memcpy(ehdr->e_ident, ELFMAG, SELFMAG);

ehdr->e_ident[EI_CLASS] = ELFCLASS64;

ehdr->e_ident[EI_DATA] = ELFDATA2LSB;

ehdr->e_ident[EI_VERSION] = EV_CURRENT;

ehdr->e_ident[EI_OSABI] = ELFOSABI_NONE;

ehdr->e_type = ET_DYN;

ehdr->e_machine = machine;

ehdr->e_version = EV_CURRENT;

ehdr->e_entry = 0;

ehdr->e_phoff = 0;

ehdr->e_shoff = sh_off;

ehdr->e_ehsize = sizeof(Elf64_Ehdr);

ehdr->e_shentsize = sizeof(Elf64_Shdr);

ehdr->e_shnum = shnum;

ehdr->e_shstrndx = SH_SHSTRTAB;

memcpy(buf + text_off, code_addr, text_size);

memcpy(buf + eh_off, eh_frame, eh_frame_size);

char *shstr = (char *)(buf + shstr_off);

memcpy(shstr, shstrtab, shstrtab_size);

char *strtab = (char *)(buf + str_off);

strtab[0] = '\0';

memcpy(strtab + 1, symname, strlen(symname));

strtab[strtab_size - 1] = '\0';

Elf64_Sym *syms = (Elf64_Sym *)(buf + sym_off);

memset(syms, 0, symtab_size);

/* Section symbol for .text (local) */

syms[1].st_info = ELF64_ST_INFO(STB_LOCAL, STT_SECTION);

syms[1].st_shndx = 1;

/* Function symbol */

syms[2].st_name = 1;

syms[2].st_info = ELF64_ST_INFO(STB_GLOBAL, STT_FUNC);

syms[2].st_other = STV_DEFAULT;

syms[2].st_shndx = 1;

/* For ET_DYN/ET_EXEC, st_value is the absolute virtual address. */

syms[2].st_value = (Elf64_Addr)(uintptr_t)code_addr;

syms[2].st_size = code_size;

Elf64_Shdr *shdrs = (Elf64_Shdr *)(buf + sh_off);

memset(shdrs, 0, shnum * sizeof(Elf64_Shdr));

shdrs[SH_TEXT].sh_name = sh_text;

shdrs[SH_TEXT].sh_type = SHT_PROGBITS;

shdrs[SH_TEXT].sh_flags = SHF_ALLOC | SHF_EXECINSTR;

shdrs[SH_TEXT].sh_addr = (Elf64_Addr)(uintptr_t)code_addr;

shdrs[SH_TEXT].sh_offset = text_off;

shdrs[SH_TEXT].sh_size = text_size;

shdrs[SH_TEXT].sh_addralign = 16;

shdrs[SH_EH_FRAME].sh_name = sh_eh_frame;

shdrs[SH_EH_FRAME].sh_type = SHT_PROGBITS;

shdrs[SH_EH_FRAME].sh_flags = SHF_ALLOC;

shdrs[SH_EH_FRAME].sh_addr =

(Elf64_Addr)((uintptr_t)code_addr + text_padded);

shdrs[SH_EH_FRAME].sh_offset = eh_off;

shdrs[SH_EH_FRAME].sh_size = eh_frame_size;

shdrs[SH_EH_FRAME].sh_addralign = 8;

shdrs[SH_SHSTRTAB].sh_name = sh_shstrtab;

shdrs[SH_SHSTRTAB].sh_type = SHT_STRTAB;

shdrs[SH_SHSTRTAB].sh_offset = shstr_off;

shdrs[SH_SHSTRTAB].sh_size = shstrtab_size;

shdrs[SH_SHSTRTAB].sh_addralign = 1;

shdrs[SH_STRTAB].sh_name = sh_strtab;

shdrs[SH_STRTAB].sh_type = SHT_STRTAB;

shdrs[SH_STRTAB].sh_offset = str_off;

shdrs[SH_STRTAB].sh_size = strtab_size;

shdrs[SH_STRTAB].sh_addralign = 1;

shdrs[SH_SYMTAB].sh_name = sh_symtab;

shdrs[SH_SYMTAB].sh_type = SHT_SYMTAB;

shdrs[SH_SYMTAB].sh_offset = sym_off;

shdrs[SH_SYMTAB].sh_size = symtab_size;

shdrs[SH_SYMTAB].sh_link = SH_STRTAB;

shdrs[SH_SYMTAB].sh_info = 2;

shdrs[SH_SYMTAB].sh_addralign = 8;

shdrs[SH_SYMTAB].sh_entsize = sizeof(Elf64_Sym);

struct jit_code_entry *entry = PyMem_RawMalloc(sizeof(*entry));

if (entry == NULL) {

PyMem_RawFree(buf);

return NULL;

}

entry->symfile_addr = (const char *)buf;

entry->symfile_size = total_size;

entry->code_addr = code_addr;

PyMutex_Lock(&_Py_jit_debug_mutex);

entry->prev = NULL;

entry->next = __jit_debug_descriptor.first_entry;

if (entry->next != NULL) {

entry->next->prev = entry;

}

__jit_debug_descriptor.first_entry = entry;

__jit_debug_descriptor.relevant_entry = entry;

__jit_debug_descriptor.action_flag = JIT_REGISTER_FN;

__jit_debug_register_code();

__jit_debug_descriptor.action_flag = JIT_NOACTION;

__jit_debug_descriptor.relevant_entry = NULL;

PyMutex_Unlock(&_Py_jit_debug_mutex);

return entry;

}

#endif // defined(PY_HAVE_JIT_GDB_UNWIND)

void *

_PyJitUnwind_GdbRegisterCode(const void *code_addr,

size_t code_size,

const char *entry,

const char *filename)

{

#if defined(PY_HAVE_JIT_GDB_UNWIND)

/* GDB expects a stable symbol name and absolute addresses in .eh_frame. */

if (entry == NULL) {

entry = "";

}

if (filename == NULL) {

filename = "";

}

size_t name_size = snprintf(NULL, 0, "py::%s:%s", entry, filename) + 1;

char *name = (char *)PyMem_RawMalloc(name_size);

if (name == NULL) {

return NULL;

}

snprintf(name, name_size, "py::%s:%s", entry, filename);

uint8_t buffer[1024];

size_t eh_frame_size = _PyJitUnwind_BuildEhFrame(

buffer, sizeof(buffer), code_addr, code_size, 1);

if (eh_frame_size == 0) {

PyMem_RawFree(name);

return NULL;

}

void *handle = gdb_jit_register_code(code_addr, code_size, name,

buffer, eh_frame_size);

PyMem_RawFree(name);

return handle;

(void)code_addr;

(void)code_size;

(void)entry;

(void)filename;

return NULL;

}

_PyJitUnwind_GdbUnregisterCode(void *handle)

{

#if defined(PY_HAVE_JIT_GDB_UNWIND)

struct jit_code_entry *entry = (struct jit_code_entry *)handle;

if (entry == NULL) {

return;

}

PyMutex_Lock(&_Py_jit_debug_mutex);

if (entry->prev != NULL) {

entry->prev->next = entry->next;

}

else {

__jit_debug_descriptor.first_entry = entry->next;

}

if (entry->next != NULL) {

entry->next->prev = entry->prev;

}

__jit_debug_descriptor.relevant_entry = entry;

__jit_debug_descriptor.action_flag = JIT_UNREGISTER_FN;

__jit_debug_register_code();

__jit_debug_descriptor.action_flag = JIT_NOACTION;

__jit_debug_descriptor.relevant_entry = NULL;