mirror of
https://github.com/php/php-src.git
synced 2024-09-22 10:27:25 +00:00
524 lines
15 KiB
C
524 lines
15 KiB
C
/*
|
|
+----------------------------------------------------------------------+
|
|
| Zend JIT |
|
|
+----------------------------------------------------------------------+
|
|
| Copyright (c) The PHP Group |
|
|
+----------------------------------------------------------------------+
|
|
| This source file is subject to version 3.01 of the PHP license, |
|
|
| that is bundled with this package in the file LICENSE, and is |
|
|
| available through the world-wide-web at the following url: |
|
|
| https://www.php.net/license/3_01.txt |
|
|
| If you did not receive a copy of the PHP license and are unable to |
|
|
| obtain it through the world-wide-web, please send a note to |
|
|
| license@php.net so we can mail you a copy immediately. |
|
|
+----------------------------------------------------------------------+
|
|
| Authors: Dmitry Stogov <dmitry@php.net> |
|
|
| Xinchen Hui <laruence@php.net> |
|
|
+----------------------------------------------------------------------+
|
|
| Based on Mike Pall's implementation of GDB interface for LuaJIT. |
|
|
| LuaJIT -- a Just-In-Time Compiler for Lua. http://luajit.org/ |
|
|
+----------------------------------------------------------------------+
|
|
*/
|
|
|
|
|
|
#define HAVE_GDB
|
|
|
|
#include "zend_jit_gdb.h"
|
|
#include "zend_elf.h"
|
|
#include "zend_gdb.h"
|
|
|
|
/* DWARF definitions. */
|
|
#define DW_CIE_VERSION 1
|
|
|
|
/* CFA (Canonical frame address) */
|
|
enum {
|
|
DW_CFA_nop = 0x0,
|
|
DW_CFA_offset_extended = 0x5,
|
|
DW_CFA_def_cfa = 0xc,
|
|
DW_CFA_def_cfa_offset = 0xe,
|
|
DW_CFA_offset_extended_sf = 0x11,
|
|
DW_CFA_advance_loc = 0x40,
|
|
DW_CFA_offset = 0x80
|
|
};
|
|
|
|
enum {
|
|
DW_EH_PE_udata4 = 0x03,
|
|
DW_EH_PE_textrel = 0x20
|
|
};
|
|
|
|
enum {
|
|
DW_TAG_compile_unit = 0x11
|
|
};
|
|
|
|
enum {
|
|
DW_children_no = 0,
|
|
DW_children_yes = 1
|
|
};
|
|
|
|
enum {
|
|
DW_AT_name = 0x03,
|
|
DW_AT_stmt_list = 0x10,
|
|
DW_AT_low_pc = 0x11,
|
|
DW_AT_high_pc = 0x12
|
|
};
|
|
|
|
enum {
|
|
DW_FORM_addr = 0x01,
|
|
DW_FORM_data4 = 0x06,
|
|
DW_FORM_string = 0x08
|
|
};
|
|
|
|
enum {
|
|
DW_LNS_extended_op = 0,
|
|
DW_LNS_copy = 1,
|
|
DW_LNS_advance_pc = 2,
|
|
DW_LNS_advance_line = 3
|
|
};
|
|
|
|
enum {
|
|
DW_LNE_end_sequence = 1,
|
|
DW_LNE_set_address = 2
|
|
};
|
|
|
|
enum {
|
|
#if defined(__i386__)
|
|
DW_REG_AX, DW_REG_CX, DW_REG_DX, DW_REG_BX,
|
|
DW_REG_SP, DW_REG_BP, DW_REG_SI, DW_REG_DI,
|
|
DW_REG_RA,
|
|
#elif defined(__x86_64__)
|
|
/* Yes, the order is strange, but correct. */
|
|
DW_REG_AX, DW_REG_DX, DW_REG_CX, DW_REG_BX,
|
|
DW_REG_SI, DW_REG_DI, DW_REG_BP, DW_REG_SP,
|
|
DW_REG_8, DW_REG_9, DW_REG_10, DW_REG_11,
|
|
DW_REG_12, DW_REG_13, DW_REG_14, DW_REG_15,
|
|
DW_REG_RA,
|
|
#elif defined(__aarch64__)
|
|
DW_REG_SP = 31,
|
|
DW_REG_RA = 30,
|
|
DW_REG_X29 = 29,
|
|
#else
|
|
#error "Unsupported target architecture"
|
|
#endif
|
|
};
|
|
|
|
enum {
|
|
GDBJIT_SECT_NULL,
|
|
GDBJIT_SECT_text,
|
|
GDBJIT_SECT_eh_frame,
|
|
GDBJIT_SECT_shstrtab,
|
|
GDBJIT_SECT_strtab,
|
|
GDBJIT_SECT_symtab,
|
|
GDBJIT_SECT_debug_info,
|
|
GDBJIT_SECT_debug_abbrev,
|
|
GDBJIT_SECT_debug_line,
|
|
GDBJIT_SECT__MAX
|
|
};
|
|
|
|
enum {
|
|
GDBJIT_SYM_UNDEF,
|
|
GDBJIT_SYM_FILE,
|
|
GDBJIT_SYM_FUNC,
|
|
GDBJIT_SYM__MAX
|
|
};
|
|
|
|
typedef struct _zend_gdbjit_obj {
|
|
zend_elf_header hdr;
|
|
zend_elf_sectheader sect[GDBJIT_SECT__MAX];
|
|
zend_elf_symbol sym[GDBJIT_SYM__MAX];
|
|
uint8_t space[4096];
|
|
} zend_gdbjit_obj;
|
|
|
|
static const zend_elf_header zend_elfhdr_template = {
|
|
.emagic = { 0x7f, 'E', 'L', 'F' },
|
|
#ifdef ELF64
|
|
.eclass = 2,
|
|
#else
|
|
.eclass = 1,
|
|
#endif
|
|
#ifdef WORDS_BIGENDIAN
|
|
.eendian = 2,
|
|
#else
|
|
.eendian = 1,
|
|
#endif
|
|
.eversion = 1,
|
|
#if defined(Linux)
|
|
.eosabi = 0, /* Nope, it's not 3. ??? */
|
|
#elif defined(__FreeBSD__)
|
|
.eosabi = 9,
|
|
#elif defined(__OpenBSD__)
|
|
.eosabi = 12,
|
|
#elif defined(__NetBSD__)
|
|
.eosabi = 2,
|
|
#elif defined(__DragonFly__)
|
|
.eosabi = 0,
|
|
#elif (defined(__sun__) && defined(__svr4__))
|
|
.eosabi = 6,
|
|
#else
|
|
.eosabi = 0,
|
|
#endif
|
|
.eabiversion = 0,
|
|
.epad = { 0, 0, 0, 0, 0, 0, 0 },
|
|
.type = 1,
|
|
#if defined(__i386__)
|
|
.machine = 3,
|
|
#elif defined(__x86_64__)
|
|
.machine = 62,
|
|
#elif defined(__aarch64__)
|
|
.machine = 183,
|
|
#else
|
|
# error "Unsupported target architecture"
|
|
#endif
|
|
.version = 1,
|
|
.entry = 0,
|
|
.phofs = 0,
|
|
.shofs = offsetof(zend_gdbjit_obj, sect),
|
|
.flags = 0,
|
|
.ehsize = sizeof(zend_elf_header),
|
|
.phentsize = 0,
|
|
.phnum = 0,
|
|
.shentsize = sizeof(zend_elf_sectheader),
|
|
.shnum = GDBJIT_SECT__MAX,
|
|
.shstridx = GDBJIT_SECT_shstrtab
|
|
};
|
|
|
|
/* Context for generating the ELF object for the GDB JIT API. */
|
|
typedef struct _zend_gdbjit_ctx {
|
|
uint8_t *p; /* Pointer to next address in obj.space. */
|
|
uint8_t *startp; /* Pointer to start address in obj.space. */
|
|
uintptr_t mcaddr; /* Machine code address. */
|
|
uint32_t szmcode; /* Size of machine code. */
|
|
int32_t lineno; /* Starting line number. */
|
|
const char *name; /* JIT function name */
|
|
const char *filename; /* Starting file name. */
|
|
size_t objsize; /* Final size of ELF object. */
|
|
zend_gdbjit_obj obj; /* In-memory ELF object. */
|
|
} zend_gdbjit_ctx;
|
|
|
|
/* Add a zero-terminated string */
|
|
static uint32_t zend_gdbjit_strz(zend_gdbjit_ctx *ctx, const char *str)
|
|
{
|
|
uint8_t *p = ctx->p;
|
|
uint32_t ofs = (uint32_t)(p - ctx->startp);
|
|
do {
|
|
*p++ = (uint8_t)*str;
|
|
} while (*str++);
|
|
ctx->p = p;
|
|
return ofs;
|
|
}
|
|
|
|
/* Add a ULEB128 value */
|
|
static void zend_gdbjit_uleb128(zend_gdbjit_ctx *ctx, uint32_t v)
|
|
{
|
|
uint8_t *p = ctx->p;
|
|
for (; v >= 0x80; v >>= 7)
|
|
*p++ = (uint8_t)((v & 0x7f) | 0x80);
|
|
*p++ = (uint8_t)v;
|
|
ctx->p = p;
|
|
}
|
|
|
|
/* Add a SLEB128 value */
|
|
static void zend_gdbjit_sleb128(zend_gdbjit_ctx *ctx, int32_t v)
|
|
{
|
|
uint8_t *p = ctx->p;
|
|
for (; (uint32_t)(v+0x40) >= 0x80; v >>= 7)
|
|
*p++ = (uint8_t)((v & 0x7f) | 0x80);
|
|
*p++ = (uint8_t)(v & 0x7f);
|
|
ctx->p = p;
|
|
}
|
|
|
|
static void zend_gdbjit_secthdr(zend_gdbjit_ctx *ctx)
|
|
{
|
|
zend_elf_sectheader *sect;
|
|
|
|
*ctx->p++ = '\0';
|
|
|
|
#define SECTDEF(id, tp, al) \
|
|
sect = &ctx->obj.sect[GDBJIT_SECT_##id]; \
|
|
sect->name = zend_gdbjit_strz(ctx, "." #id); \
|
|
sect->type = ELFSECT_TYPE_##tp; \
|
|
sect->align = (al)
|
|
|
|
SECTDEF(text, NOBITS, 16);
|
|
sect->flags = ELFSECT_FLAGS_ALLOC|ELFSECT_FLAGS_EXEC;
|
|
sect->addr = ctx->mcaddr;
|
|
sect->ofs = 0;
|
|
sect->size = ctx->szmcode;
|
|
|
|
SECTDEF(eh_frame, PROGBITS, sizeof(uintptr_t));
|
|
sect->flags = ELFSECT_FLAGS_ALLOC;
|
|
|
|
SECTDEF(shstrtab, STRTAB, 1);
|
|
SECTDEF(strtab, STRTAB, 1);
|
|
|
|
SECTDEF(symtab, SYMTAB, sizeof(uintptr_t));
|
|
sect->ofs = offsetof(zend_gdbjit_obj, sym);
|
|
sect->size = sizeof(ctx->obj.sym);
|
|
sect->link = GDBJIT_SECT_strtab;
|
|
sect->entsize = sizeof(zend_elf_symbol);
|
|
sect->info = GDBJIT_SYM_FUNC;
|
|
|
|
SECTDEF(debug_info, PROGBITS, 1);
|
|
SECTDEF(debug_abbrev, PROGBITS, 1);
|
|
SECTDEF(debug_line, PROGBITS, 1);
|
|
|
|
#undef SECTDEF
|
|
}
|
|
|
|
static void zend_gdbjit_symtab(zend_gdbjit_ctx *ctx)
|
|
{
|
|
zend_elf_symbol *sym;
|
|
|
|
*ctx->p++ = '\0';
|
|
|
|
sym = &ctx->obj.sym[GDBJIT_SYM_FILE];
|
|
sym->name = zend_gdbjit_strz(ctx, "JIT code");
|
|
sym->sectidx = ELFSECT_IDX_ABS;
|
|
sym->info = ELFSYM_INFO(ELFSYM_BIND_LOCAL, ELFSYM_TYPE_FILE);
|
|
|
|
sym = &ctx->obj.sym[GDBJIT_SYM_FUNC];
|
|
sym->name = zend_gdbjit_strz(ctx, ctx->name);
|
|
sym->sectidx = GDBJIT_SECT_text;
|
|
sym->value = 0;
|
|
sym->size = ctx->szmcode;
|
|
sym->info = ELFSYM_INFO(ELFSYM_BIND_GLOBAL, ELFSYM_TYPE_FUNC);
|
|
}
|
|
|
|
typedef ZEND_SET_ALIGNED(1, uint16_t unaligned_uint16_t);
|
|
typedef ZEND_SET_ALIGNED(1, uint32_t unaligned_uint32_t);
|
|
typedef ZEND_SET_ALIGNED(1, uintptr_t unaligned_uintptr_t);
|
|
|
|
#define SECTALIGN(p, a) \
|
|
((p) = (uint8_t *)(((uintptr_t)(p) + ((a)-1)) & ~(uintptr_t)((a)-1)))
|
|
|
|
/* Shortcuts to generate DWARF structures. */
|
|
#define DB(x) (*p++ = (x))
|
|
#define DI8(x) (*(int8_t *)p = (x), p++)
|
|
#define DU16(x) (*(unaligned_uint16_t *)p = (x), p += 2)
|
|
#define DU32(x) (*(unaligned_uint32_t *)p = (x), p += 4)
|
|
#define DADDR(x) (*(unaligned_uintptr_t *)p = (x), p += sizeof(uintptr_t))
|
|
#define DUV(x) (ctx->p = p, zend_gdbjit_uleb128(ctx, (x)), p = ctx->p)
|
|
#define DSV(x) (ctx->p = p, zend_gdbjit_sleb128(ctx, (x)), p = ctx->p)
|
|
#define DSTR(str) (ctx->p = p, zend_gdbjit_strz(ctx, (str)), p = ctx->p)
|
|
#define DALIGNNOP(s) while ((uintptr_t)p & ((s)-1)) *p++ = DW_CFA_nop
|
|
#define DSECT(name, stmt) \
|
|
{ unaligned_uint32_t *szp_##name = (uint32_t *)p; p += 4; stmt \
|
|
*szp_##name = (uint32_t)((p-(uint8_t *)szp_##name)-4); }
|
|
|
|
static void zend_gdbjit_ehframe(zend_gdbjit_ctx *ctx, uint32_t sp_offset, uint32_t sp_adjustment)
|
|
{
|
|
uint8_t *p = ctx->p;
|
|
uint8_t *framep = p;
|
|
|
|
/* DWARF EH CIE (Common Information Entry) */
|
|
DSECT(CIE,
|
|
DU32(0); /* CIE ID. */
|
|
DB(DW_CIE_VERSION); /* Version */
|
|
DSTR("zR"); /* Augmentation String. */
|
|
DUV(1); /* Code alignment factor. */
|
|
DSV(-(int32_t)sizeof(uintptr_t)); /* Data alignment factor. */
|
|
DB(DW_REG_RA); /* Return address register. */
|
|
DB(1); DB(DW_EH_PE_textrel|DW_EH_PE_udata4); /* Augmentation data. */
|
|
#if defined(__x86_64__) || defined(i386)
|
|
DB(DW_CFA_def_cfa); DUV(DW_REG_SP); DUV(sizeof(uintptr_t));
|
|
DB(DW_CFA_offset|DW_REG_RA); DUV(1);
|
|
#elif defined(__aarch64__)
|
|
DB(DW_CFA_def_cfa); DUV(DW_REG_SP); DUV(0);
|
|
#endif
|
|
DALIGNNOP(sizeof(uintptr_t));
|
|
)
|
|
|
|
/* DWARF EH FDE (Frame Description Entry). */
|
|
DSECT(FDE,
|
|
DU32((uint32_t)(p-framep)); /* Offset to CIE Pointer. */
|
|
DU32(0); /* Machine code offset relative to .text. */
|
|
DU32(ctx->szmcode); /* Machine code length. */
|
|
DB(0); /* Augmentation data. */
|
|
DB(DW_CFA_def_cfa_offset); DUV(sp_offset);
|
|
#if defined(__aarch64__)
|
|
if (sp_offset) {
|
|
if (sp_adjustment && sp_adjustment < sp_offset) {
|
|
DB(DW_CFA_offset|DW_REG_X29); DUV(sp_adjustment / sizeof(uintptr_t));
|
|
DB(DW_CFA_offset|DW_REG_RA); DUV((sp_adjustment / sizeof(uintptr_t)) - 1);
|
|
} else {
|
|
DB(DW_CFA_offset|DW_REG_X29); DUV(sp_offset / sizeof(uintptr_t));
|
|
DB(DW_CFA_offset|DW_REG_RA); DUV((sp_offset / sizeof(uintptr_t)) - 1);
|
|
}
|
|
}
|
|
#endif
|
|
if (sp_adjustment && sp_adjustment > sp_offset) {
|
|
DB(DW_CFA_advance_loc|1); DB(DW_CFA_def_cfa_offset); DUV(sp_adjustment);
|
|
#if defined(__aarch64__)
|
|
if (!sp_offset) {
|
|
DB(DW_CFA_offset|DW_REG_X29); DUV(sp_adjustment / sizeof(uintptr_t));
|
|
DB(DW_CFA_offset|DW_REG_RA); DUV((sp_adjustment / sizeof(uintptr_t)) - 1);
|
|
}
|
|
#endif
|
|
}
|
|
DALIGNNOP(sizeof(uintptr_t));
|
|
)
|
|
|
|
ctx->p = p;
|
|
}
|
|
|
|
static void zend_gdbjit_debuginfo(zend_gdbjit_ctx *ctx)
|
|
{
|
|
uint8_t *p = ctx->p;
|
|
|
|
DSECT(info,
|
|
DU16(2); /* DWARF version. */
|
|
DU32(0); /* Abbrev offset. */
|
|
DB(sizeof(uintptr_t)); /* Pointer size. */
|
|
|
|
DUV(1); /* Abbrev #1: DW_TAG_compile_unit. */
|
|
DSTR(ctx->filename); /* DW_AT_name. */
|
|
DADDR(ctx->mcaddr); /* DW_AT_low_pc. */
|
|
DADDR(ctx->mcaddr + ctx->szmcode); /* DW_AT_high_pc. */
|
|
DU32(0); /* DW_AT_stmt_list. */
|
|
);
|
|
|
|
ctx->p = p;
|
|
}
|
|
|
|
static void zend_gdbjit_debugabbrev(zend_gdbjit_ctx *ctx)
|
|
{
|
|
uint8_t *p = ctx->p;
|
|
|
|
/* Abbrev #1: DW_TAG_compile_unit. */
|
|
DUV(1);
|
|
DUV(DW_TAG_compile_unit);
|
|
DB(DW_children_no);
|
|
DUV(DW_AT_name);
|
|
DUV(DW_FORM_string);
|
|
DUV(DW_AT_low_pc);
|
|
DUV(DW_FORM_addr);
|
|
DUV(DW_AT_high_pc);
|
|
DUV(DW_FORM_addr);
|
|
DUV(DW_AT_stmt_list);
|
|
DUV(DW_FORM_data4);
|
|
DB(0);
|
|
DB(0);
|
|
DB(0);
|
|
|
|
ctx->p = p;
|
|
}
|
|
|
|
#define DLNE(op, s) (DB(DW_LNS_extended_op), DUV(1+(s)), DB((op)))
|
|
|
|
static void zend_gdbjit_debugline(zend_gdbjit_ctx *ctx)
|
|
{
|
|
uint8_t *p = ctx->p;
|
|
|
|
DSECT(line,
|
|
DU16(2); /* DWARF version. */
|
|
DSECT(header,
|
|
DB(1); /* Minimum instruction length. */
|
|
DB(1); /* is_stmt. */
|
|
DI8(0); /* Line base for special opcodes. */
|
|
DB(2); /* Line range for special opcodes. */
|
|
DB(3+1); /* Opcode base at DW_LNS_advance_line+1. */
|
|
DB(0); DB(1); DB(1); /* Standard opcode lengths. */
|
|
/* Directory table. */
|
|
DB(0);
|
|
/* File name table. */
|
|
DSTR(ctx->filename); DUV(0); DUV(0); DUV(0);
|
|
DB(0);
|
|
);
|
|
DLNE(DW_LNE_set_address, sizeof(uintptr_t));
|
|
DADDR(ctx->mcaddr);
|
|
if (ctx->lineno) (DB(DW_LNS_advance_line), DSV(ctx->lineno-1));
|
|
DB(DW_LNS_copy);
|
|
DB(DW_LNS_advance_pc); DUV(ctx->szmcode);
|
|
DLNE(DW_LNE_end_sequence, 0);
|
|
);
|
|
|
|
ctx->p = p;
|
|
}
|
|
|
|
|
|
#undef DLNE
|
|
|
|
/* Undef shortcuts. */
|
|
#undef DB
|
|
#undef DI8
|
|
#undef DU16
|
|
#undef DU32
|
|
#undef DADDR
|
|
#undef DUV
|
|
#undef DSV
|
|
#undef DSTR
|
|
#undef DALIGNNOP
|
|
#undef DSECT
|
|
|
|
typedef void (*zend_gdbjit_initf) (zend_gdbjit_ctx *ctx);
|
|
|
|
static void zend_gdbjit_initsect(zend_gdbjit_ctx *ctx, int sect)
|
|
{
|
|
ctx->startp = ctx->p;
|
|
ctx->obj.sect[sect].ofs = (uintptr_t)((char *)ctx->p - (char *)&ctx->obj);
|
|
}
|
|
|
|
static void zend_gdbjit_initsect_done(zend_gdbjit_ctx *ctx, int sect)
|
|
{
|
|
ctx->obj.sect[sect].size = (uintptr_t)(ctx->p - ctx->startp);
|
|
}
|
|
|
|
static void zend_gdbjit_buildobj(zend_gdbjit_ctx *ctx, uint32_t sp_offset, uint32_t sp_adjustment)
|
|
{
|
|
zend_gdbjit_obj *obj = &ctx->obj;
|
|
|
|
/* Fill in ELF header and clear structures. */
|
|
memcpy(&obj->hdr, &zend_elfhdr_template, sizeof(zend_elf_header));
|
|
memset(&obj->sect, 0, sizeof(zend_elf_sectheader) * GDBJIT_SECT__MAX);
|
|
memset(&obj->sym, 0, sizeof(zend_elf_symbol) * GDBJIT_SYM__MAX);
|
|
|
|
/* Initialize sections. */
|
|
ctx->p = obj->space;
|
|
zend_gdbjit_initsect(ctx, GDBJIT_SECT_shstrtab); zend_gdbjit_secthdr(ctx); zend_gdbjit_initsect_done(ctx, GDBJIT_SECT_shstrtab);
|
|
zend_gdbjit_initsect(ctx, GDBJIT_SECT_strtab); zend_gdbjit_symtab(ctx); zend_gdbjit_initsect_done(ctx, GDBJIT_SECT_strtab);
|
|
zend_gdbjit_initsect(ctx, GDBJIT_SECT_debug_info); zend_gdbjit_debuginfo(ctx); zend_gdbjit_initsect_done(ctx, GDBJIT_SECT_debug_info);
|
|
zend_gdbjit_initsect(ctx, GDBJIT_SECT_debug_abbrev); zend_gdbjit_debugabbrev(ctx); zend_gdbjit_initsect_done(ctx, GDBJIT_SECT_debug_abbrev);
|
|
zend_gdbjit_initsect(ctx, GDBJIT_SECT_debug_line); zend_gdbjit_debugline(ctx); zend_gdbjit_initsect_done(ctx, GDBJIT_SECT_debug_line);
|
|
SECTALIGN(ctx->p, sizeof(uintptr_t));
|
|
zend_gdbjit_initsect(ctx, GDBJIT_SECT_eh_frame); zend_gdbjit_ehframe(ctx, sp_offset, sp_adjustment); zend_gdbjit_initsect_done(ctx, GDBJIT_SECT_eh_frame);
|
|
ctx->objsize = (size_t)((char *)ctx->p - (char *)obj);
|
|
|
|
ZEND_ASSERT(ctx->objsize < sizeof(zend_gdbjit_obj));
|
|
}
|
|
|
|
int zend_jit_gdb_register(const char *name,
|
|
const zend_op_array *op_array,
|
|
const void *start,
|
|
size_t size,
|
|
uint32_t sp_offset,
|
|
uint32_t sp_adjustment)
|
|
{
|
|
zend_gdbjit_ctx ctx;
|
|
|
|
ctx.mcaddr = (uintptr_t)start;
|
|
ctx.szmcode = (uint32_t)size;
|
|
ctx.name = name;
|
|
ctx.filename = op_array ? ZSTR_VAL(op_array->filename) : "unknown";
|
|
ctx.lineno = op_array ? op_array->line_start : 0;
|
|
|
|
zend_gdbjit_buildobj(&ctx, sp_offset, sp_adjustment);
|
|
|
|
return zend_gdb_register_code(&ctx.obj, ctx.objsize);
|
|
}
|
|
|
|
int zend_jit_gdb_unregister(void)
|
|
{
|
|
zend_gdb_unregister_all();
|
|
return 1;
|
|
}
|
|
|
|
void zend_jit_gdb_init(void)
|
|
{
|
|
#if 0
|
|
/* This might enable registration of all JIT-ed code, but unfortunately,
|
|
* in case of many functions, this takes enormous time. */
|
|
if (zend_gdb_present()) {
|
|
JIT_G(debug) |= ZEND_JIT_DEBUG_GDB;
|
|
}
|
|
#endif
|
|
}
|