One Level Up Top Level

src/lj_gdbjit.c - luajit-2.0-src

Global variables defined

Data types defined

Functions defined

Macros defined

Source code

  1. /*
  2. ** Client for the GDB JIT API.
  3. ** Copyright (C) 2005-2015 Mike Pall. See Copyright Notice in luajit.h
  4. */

  6. ‌#define lj_gdbjit_c
  7. ‌#define LUA_CORE

  9. #include "lj_obj.h"

  11. #if LJ_HASJIT

  13. #include "lj_gc.h"
  14. #include "lj_err.h"
  15. #include "lj_debug.h"
  16. #include "lj_frame.h"
  17. #include "lj_buf.h"
  18. #include "lj_strfmt.h"
  19. #include "lj_jit.h"
  20. #include "lj_dispatch.h"

  22. /* This is not compiled in by default.
  23. ** Enable with -DLUAJIT_USE_GDBJIT in the Makefile and recompile everything.
  24. */
  25. #ifdef LUAJIT_USE_GDBJIT

  27. /* The GDB JIT API allows JIT compilers to pass debug information about
  28. ** JIT-compiled code back to GDB. You need at least GDB 7.0 or higher
  29. ** to see it in action.
  30. **
  31. ** This is a passive API, so it works even when not running under GDB
  32. ** or when attaching to an already running process. Alas, this implies
  33. ** enabling it always has a non-negligible overhead -- do not use in
  34. ** release mode!
  35. **
  36. ** The LuaJIT GDB JIT client is rather minimal at the moment. It gives
  37. ** each trace a symbol name and adds a source location and frame unwind
  38. ** information. Obviously LuaJIT itself and any embedding C application
  39. ** should be compiled with debug symbols, too (see the Makefile).
  40. **
  41. ** Traces are named TRACE_1, TRACE_2, ... these correspond to the trace
  42. ** numbers from -jv or -jdump. Use "break TRACE_1" or "tbreak TRACE_1" etc.
  43. ** to set breakpoints on specific traces (even ahead of their creation).
  44. **
  45. ** The source location for each trace allows listing the corresponding
  46. ** source lines with the GDB command "list" (but only if the Lua source
  47. ** has been loaded from a file). Currently this is always set to the
  48. ** location where the trace has been started.
  49. **
  50. ** Frame unwind information can be inspected with the GDB command
  51. ** "info frame". This also allows proper backtraces across JIT-compiled
  52. ** code with the GDB command "bt".
  53. **
  54. ** You probably want to add the following settings to a .gdbinit file
  55. ** (or add them to ~/.gdbinit):
  56. **   set disassembly-flavor intel
  57. **   set breakpoint pending on
  58. **
  59. ** Here's a sample GDB session:
  60. ** ------------------------------------------------------------------------

  62. $ cat >x.lua
  63. for outer=1,100 do
  64.   for inner=1,100 do end
  65. end
  66. ^D

  68. $ luajit -jv x.lua
  69. [TRACE   1 x.lua:2]
  70. [TRACE   2 (1/3) x.lua:1 -> 1]

  72. $ gdb --quiet --args luajit x.lua
  73. (gdb) tbreak TRACE_1
  74. Function "TRACE_1" not defined.
  75. Temporary breakpoint 1 (TRACE_1) pending.
  76. (gdb) run
  77. Starting program: luajit x.lua

  79. Temporary breakpoint 1, TRACE_1 () at x.lua:2
  80. 2          for inner=1,100 do end
  81. (gdb) list
  82. 1        for outer=1,100 do
  83. 2          for inner=1,100 do end
  84. 3        end
  85. (gdb) bt
  86. #0  TRACE_1 () at x.lua:2
  87. #1  0x08053690 in lua_pcall [...]
  88. [...]
  89. #7  0x0806ff90 in main [...]
  90. (gdb) disass TRACE_1
  91. Dump of assembler code for function TRACE_1:
  92. 0xf7fd9fba <TRACE_1+0>:        mov    DWORD PTR ds:0xf7e0e2a0,0x1
  93. 0xf7fd9fc4 <TRACE_1+10>:        movsd  xmm7,QWORD PTR [edx+0x20]
  94. [...]
  95. 0xf7fd9ff8 <TRACE_1+62>:        jmp    0xf7fd2014
  96. End of assembler dump.
  97. (gdb) tbreak TRACE_2
  98. Function "TRACE_2" not defined.
  99. Temporary breakpoint 2 (TRACE_2) pending.
  100. (gdb) cont
  101. Continuing.

  103. Temporary breakpoint 2, TRACE_2 () at x.lua:1
  104. 1        for outer=1,100 do
  105. (gdb) info frame
  106. Stack level 0, frame at 0xffffd7c0:
  107. eip = 0xf7fd9f60 in TRACE_2 (x.lua:1); saved eip 0x8053690
  108. called by frame at 0xffffd7e0
  109. source language unknown.
  110. Arglist at 0xffffd78c, args:
  111. Locals at 0xffffd78c, Previous frame's sp is 0xffffd7c0
  112. Saved registers:
  113.   ebx at 0xffffd7ac, ebp at 0xffffd7b8, esi at 0xffffd7b0, edi at 0xffffd7b4,
  114.   eip at 0xffffd7bc
  115. (gdb)

  117. ** ------------------------------------------------------------------------
  118. */

  120. /* -- GDB JIT API --------------------------------------------------------- */

  122. /* GDB JIT actions. */
  123. enum {
  124.   GDBJIT_NOACTION = 0,
  125.   GDBJIT_REGISTER,
  126.   GDBJIT_UNREGISTER
  127. };

  129. /* GDB JIT entry. */
  130. ‌typedef struct GDBJITentry {
  131.   struct GDBJITentry *next_entry;
  132.   struct GDBJITentry *prev_entry;
  133.   const char *symfile_addr;
  134.   uint64_t symfile_size;
  135. ‌} GDBJITentry;

  137. /* GDB JIT descriptor. */
  138. ‌typedef struct GDBJITdesc {
  139.   uint32_t version;
  140.   uint32_t action_flag;
  141.   GDBJITentry *relevant_entry;
  142.   GDBJITentry *first_entry;
  143. ‌} GDBJITdesc;

  145. ‌GDBJITdesc __jit_debug_descriptor = {
  146.   1, GDBJIT_NOACTION, NULL, NULL
  147. };

  149. /* GDB sets a breakpoint at this function. */
  150. ‌void LJ_NOINLINE __jit_debug_register_code()
  151. {
  152.   __asm__ __volatile__("");
  153. };

  155. /* -- In-memory ELF object definitions ------------------------------------ */

  157. /* ELF definitions. */
  158. ‌typedef struct ELFheader {
  159.   uint8_t emagic[4];
  160.   uint8_t eclass;
  161.   uint8_t eendian;
  162.   uint8_t eversion;
  163.   uint8_t eosabi;
  164.   uint8_t eabiversion;
  165.   uint8_t epad[7];
  166.   uint16_t type;
  167.   uint16_t machine;
  168.   uint32_t version;
  169.   uintptr_t entry;
  170.   uintptr_t phofs;
  171.   uintptr_t shofs;
  172.   uint32_t flags;
  173.   uint16_t ehsize;
  174.   uint16_t phentsize;
  175.   uint16_t phnum;
  176.   uint16_t shentsize;
  177.   uint16_t shnum;
  178.   uint16_t shstridx;
  179. ‌} ELFheader;

  181. ‌typedef struct ELFsectheader {
  182.   uint32_t name;
  183.   uint32_t type;
  184.   uintptr_t flags;
  185.   uintptr_t addr;
  186.   uintptr_t ofs;
  187.   uintptr_t size;
  188.   uint32_t link;
  189.   uint32_t info;
  190.   uintptr_t align;
  191.   uintptr_t entsize;
  192. ‌} ELFsectheader;

  194. ‌#define ELFSECT_IDX_ABS                0xfff1

  196. enum {
  197.   ELFSECT_TYPE_PROGBITS = 1,
  198.   ELFSECT_TYPE_SYMTAB = 2,
  199.   ELFSECT_TYPE_STRTAB = 3,
  200.   ELFSECT_TYPE_NOBITS = 8
  201. };

  203. ‌#define ELFSECT_FLAGS_WRITE        1
  204. ‌#define ELFSECT_FLAGS_ALLOC        2
  205. ‌#define ELFSECT_FLAGS_EXEC        4

  207. ‌typedef struct ELFsymbol {
  208. #if LJ_64
  209.   uint32_t name;
  210.   uint8_t info;
  211.   uint8_t other;
  212.   uint16_t sectidx;
  213.   uintptr_t value;
  214.   uint64_t size;
  215. #else
  216.   uint32_t name;
  217.   uintptr_t value;
  218.   uint32_t size;
  219.   uint8_t info;
  220.   uint8_t other;
  221.   uint16_t sectidx;
  222. #endif
  223. ‌} ELFsymbol;

  225. enum {
  226.   ELFSYM_TYPE_FUNC = 2,
  227.   ELFSYM_TYPE_FILE = 4,
  228.   ELFSYM_BIND_LOCAL = 0 << 4,
  229.   ELFSYM_BIND_GLOBAL = 1 << 4,
  230. };

  232. /* DWARF definitions. */
  233. ‌#define DW_CIE_VERSION        1

  235. enum {
  236.   DW_CFA_nop = 0x0,
  237.   DW_CFA_offset_extended = 0x5,
  238.   DW_CFA_def_cfa = 0xc,
  239.   DW_CFA_def_cfa_offset = 0xe,
  240.   DW_CFA_offset_extended_sf = 0x11,
  241.   DW_CFA_advance_loc = 0x40,
  242.   DW_CFA_offset = 0x80
  243. };

  245. enum {
  246.   DW_EH_PE_udata4 = 3,
  247.   DW_EH_PE_textrel = 0x20
  248. };

  250. enum {
  251.   DW_TAG_compile_unit = 0x11
  252. };

  254. enum {
  255.   DW_children_no = 0,
  256.   DW_children_yes = 1
  257. };

  259. enum {
  260.   DW_AT_name = 0x03,
  261.   DW_AT_stmt_list = 0x10,
  262.   DW_AT_low_pc = 0x11,
  263.   DW_AT_high_pc = 0x12
  264. };

  266. enum {
  267.   DW_FORM_addr = 0x01,
  268.   DW_FORM_data4 = 0x06,
  269.   DW_FORM_string = 0x08
  270. };

  272. enum {
  273.   DW_LNS_extended_op = 0,
  274.   DW_LNS_copy = 1,
  275.   DW_LNS_advance_pc = 2,
  276.   DW_LNS_advance_line = 3
  277. };

  279. enum {
  280.   DW_LNE_end_sequence = 1,
  281.   DW_LNE_set_address = 2
  282. };

  284. enum {
  285. #if LJ_TARGET_X86
  286.   DW_REG_AX, DW_REG_CX, DW_REG_DX, DW_REG_BX,
  287.   DW_REG_SP, DW_REG_BP, DW_REG_SI, DW_REG_DI,
  288.   DW_REG_RA,
  289. #elif LJ_TARGET_X64
  290.   /* Yes, the order is strange, but correct. */
  291.   DW_REG_AX, DW_REG_DX, DW_REG_CX, DW_REG_BX,
  292.   DW_REG_SI, DW_REG_DI, DW_REG_BP, DW_REG_SP,
  293.   DW_REG_8, DW_REG_9, DW_REG_10, DW_REG_11,
  294.   DW_REG_12, DW_REG_13, DW_REG_14, DW_REG_15,
  295.   DW_REG_RA,
  296. #elif LJ_TARGET_ARM
  297.   DW_REG_SP = 13,
  298.   DW_REG_RA = 14,
  299. #elif LJ_TARGET_PPC
  300.   DW_REG_SP = 1,
  301.   DW_REG_RA = 65,
  302.   DW_REG_CR = 70,
  303. #elif LJ_TARGET_MIPS
  304.   DW_REG_SP = 29,
  305.   DW_REG_RA = 31,
  306. #else
  307. #error "Unsupported target architecture"
  308. #endif
  309. };

  311. /* Minimal list of sections for the in-memory ELF object. */
  312. enum {
  313.   GDBJIT_SECT_NULL,
  314.   GDBJIT_SECT_text,
  315.   GDBJIT_SECT_eh_frame,
  316.   GDBJIT_SECT_shstrtab,
  317.   GDBJIT_SECT_strtab,
  318.   GDBJIT_SECT_symtab,
  319.   GDBJIT_SECT_debug_info,
  320.   GDBJIT_SECT_debug_abbrev,
  321.   GDBJIT_SECT_debug_line,
  322.   GDBJIT_SECT__MAX
  323. };

  325. enum {
  326.   GDBJIT_SYM_UNDEF,
  327.   GDBJIT_SYM_FILE,
  328.   GDBJIT_SYM_FUNC,
  329.   GDBJIT_SYM__MAX
  330. };

  332. /* In-memory ELF object. */
  333. ‌typedef struct GDBJITobj {
  334.   ELFheader hdr;                        /* ELF header. */
  335.   ELFsectheader sect[GDBJIT_SECT__MAX];        /* ELF sections. */
  336.   ELFsymbol sym[GDBJIT_SYM__MAX];        /* ELF symbol table. */
  337.   uint8_t space[4096];                        /* Space for various section data. */
  338. ‌} GDBJITobj;

  340. /* Combined structure for GDB JIT entry and ELF object. */
  341. ‌typedef struct GDBJITentryobj {
  342.   GDBJITentry entry;
  343.   size_t sz;
  344.   GDBJITobj obj;
  345. ‌} GDBJITentryobj;

  347. /* Template for in-memory ELF header. */
  348. ‌static const ELFheader elfhdr_template = {
  349.   .emagic = { 0x7f, 'E', 'L', 'F' },
  350.   .eclass = LJ_64 ? 2 : 1,
  351.   .eendian = LJ_ENDIAN_SELECT(1, 2),
  352.   .eversion = 1,
  353. #if LJ_TARGET_LINUX
  354.   .eosabi = 0,  /* Nope, it's not 3. */
  355. #elif defined(__FreeBSD__)
  356.   .eosabi = 9,
  357. #elif defined(__NetBSD__)
  358.   .eosabi = 2,
  359. #elif defined(__OpenBSD__)
  360.   .eosabi = 12,
  361. #elif defined(__DragonFly__)
  362.   .eosabi = 0,
  363. #elif (defined(__sun__) && defined(__svr4__))
  364.   .eosabi = 6,
  365. #else
  366.   .eosabi = 0,
  367. #endif
  368.   .eabiversion = 0,
  369.   .epad = { 0, 0, 0, 0, 0, 0, 0 },
  370.   .type = 1,
  371. #if LJ_TARGET_X86
  372.   .machine = 3,
  373. #elif LJ_TARGET_X64
  374.   .machine = 62,
  375. #elif LJ_TARGET_ARM
  376.   .machine = 40,
  377. #elif LJ_TARGET_PPC
  378.   .machine = 20,
  379. #elif LJ_TARGET_MIPS
  380.   .machine = 8,
  381. #else
  382. #error "Unsupported target architecture"
  383. #endif
  384.   .version = 1,
  385.   .entry = 0,
  386.   .phofs = 0,
  387.   .shofs = offsetof(GDBJITobj, sect),
  388.   .flags = 0,
  389.   .ehsize = sizeof(ELFheader),
  390.   .phentsize = 0,
  391.   .phnum = 0,
  392.   .shentsize = sizeof(ELFsectheader),
  393.   .shnum = GDBJIT_SECT__MAX,
  394.   .shstridx = GDBJIT_SECT_shstrtab
  395. };

  397. /* -- In-memory ELF object generation ------------------------------------- */

  399. /* Context for generating the ELF object for the GDB JIT API. */
  400. ‌typedef struct GDBJITctx {
  401.   uint8_t *p;                /* Pointer to next address in obj.space. */
  402.   uint8_t *startp;        /* Pointer to start address in obj.space. */
  403.   GCtrace *T;                /* Generate symbols for this trace. */
  404.   uintptr_t mcaddr;        /* Machine code address. */
  405.   MSize szmcode;        /* Size of machine code. */
  406.   MSize spadjp;                /* Stack adjustment for parent trace or interpreter. */
  407.   MSize spadj;                /* Stack adjustment for trace itself. */
  408.   BCLine lineno;        /* Starting line number. */
  409.   const char *filename;        /* Starting file name. */
  410.   size_t objsize;        /* Final size of ELF object. */
  411.   GDBJITobj obj;        /* In-memory ELF object. */
  412. ‌} GDBJITctx;

  414. /* Add a zero-terminated string. */
  415. ‌static uint32_t gdbjit_strz(GDBJITctx *ctx, const char *str)
  416. {
  417.   uint8_t *p = ctx->p;
  418.   uint32_t ofs = (uint32_t)(p - ctx->startp);
  419.   do {
  420.     *p++ = (uint8_t)*str;
  421.   } while (*str++);
  422.   ctx->p = p;
  423.   return ofs;
  424. }

  426. /* Append a decimal number. */
  427. ‌static void gdbjit_catnum(GDBJITctx *ctx, uint32_t n)
  428. {
  429.   if (n >= 10) { uint32_t m = n / 10; n = n % 10; gdbjit_catnum(ctx, m); }
  430.   *ctx->p++ = '0' + n;
  431. }

  433. /* Add a SLEB128 value. */
  434. ‌static void gdbjit_sleb128(GDBJITctx *ctx, int32_t v)
  435. {
  436.   uint8_t *p = ctx->p;
  437.   for (; (uint32_t)(v+0x40) >= 0x80; v >>= 7)
  438.     *p++ = (uint8_t)((v & 0x7f) | 0x80);
  439.   *p++ = (uint8_t)(v & 0x7f);
  440.   ctx->p = p;
  441. }

  443. /* Shortcuts to generate DWARF structures. */
  444. ‌#define DB(x)                (*p++ = (x))
  445. ‌#define DI8(x)                (*(int8_t *)p = (x), p++)
  446. ‌#define DU16(x)                (*(uint16_t *)p = (x), p += 2)
  447. ‌#define DU32(x)                (*(uint32_t *)p = (x), p += 4)
  448. ‌#define DADDR(x)        (*(uintptr_t *)p = (x), p += sizeof(uintptr_t))
  449. ‌#define DUV(x)                (p = (uint8_t *)lj_strfmt_wuleb128((char *)p, (x)))
  450. ‌#define DSV(x)                (ctx->p = p, gdbjit_sleb128(ctx, (x)), p = ctx->p)
  451. ‌#define DSTR(str)        (ctx->p = p, gdbjit_strz(ctx, (str)), p = ctx->p)
  452. ‌#define DALIGNNOP(s)        while ((uintptr_t)p & ((s)-1)) *p++ = DW_CFA_nop
  453. ‌#define DSECT(name, stmt) \
  454.   { uint32_t *szp_##name = (uint32_t *)p; p += 4; stmt \
  455.     *szp_##name = (uint32_t)((p-(uint8_t *)szp_##name)-4); } \

  457. /* Initialize ELF section headers. */
  458. ‌static void LJ_FASTCALL gdbjit_secthdr(GDBJITctx *ctx)
  459. {
  460.   ELFsectheader *sect;

  462.   *ctx->p++ = '\0';  /* Empty string at start of string table. */

  464. ‌#define SECTDEF(id, tp, al) \
  465.   sect = &ctx->obj.sect[GDBJIT_SECT_##id]; \
  466.   sect->name = gdbjit_strz(ctx, "." #id); \
  467.   sect->type = ELFSECT_TYPE_##tp; \
  468.   sect->align = (al)

  470.   SECTDEF(text, NOBITS, 16);
  471.   sect->flags = ELFSECT_FLAGS_ALLOC|ELFSECT_FLAGS_EXEC;
  472.   sect->addr = ctx->mcaddr;
  473.   sect->ofs = 0;
  474.   sect->size = ctx->szmcode;

  476.   SECTDEF(eh_frame, PROGBITS, sizeof(uintptr_t));
  477.   sect->flags = ELFSECT_FLAGS_ALLOC;

  479.   SECTDEF(shstrtab, STRTAB, 1);
  480.   SECTDEF(strtab, STRTAB, 1);

  482.   SECTDEF(symtab, SYMTAB, sizeof(uintptr_t));
  483.   sect->ofs = offsetof(GDBJITobj, sym);
  484.   sect->size = sizeof(ctx->obj.sym);
  485.   sect->link = GDBJIT_SECT_strtab;
  486.   sect->entsize = sizeof(ELFsymbol);
  487.   sect->info = GDBJIT_SYM_FUNC;

  489.   SECTDEF(debug_info, PROGBITS, 1);
  490.   SECTDEF(debug_abbrev, PROGBITS, 1);
  491.   SECTDEF(debug_line, PROGBITS, 1);

  493. ‌#undef SECTDEF
  494. }

  496. /* Initialize symbol table. */
  497. ‌static void LJ_FASTCALL gdbjit_symtab(GDBJITctx *ctx)
  498. {
  499.   ELFsymbol *sym;

  501.   *ctx->p++ = '\0';  /* Empty string at start of string table. */

  503.   sym = &ctx->obj.sym[GDBJIT_SYM_FILE];
  504.   sym->name = gdbjit_strz(ctx, "JIT mcode");
  505.   sym->sectidx = ELFSECT_IDX_ABS;
  506.   sym->info = ELFSYM_TYPE_FILE|ELFSYM_BIND_LOCAL;

  508.   sym = &ctx->obj.sym[GDBJIT_SYM_FUNC];
  509.   sym->name = gdbjit_strz(ctx, "TRACE_"); ctx->p--;
  510.   gdbjit_catnum(ctx, ctx->T->traceno); *ctx->p++ = '\0';
  511.   sym->sectidx = GDBJIT_SECT_text;
  512.   sym->value = 0;
  513.   sym->size = ctx->szmcode;
  514.   sym->info = ELFSYM_TYPE_FUNC|ELFSYM_BIND_GLOBAL;
  515. }

  517. /* Initialize .eh_frame section. */
  518. ‌static void LJ_FASTCALL gdbjit_ehframe(GDBJITctx *ctx)
  519. {
  520.   uint8_t *p = ctx->p;
  521.   uint8_t *framep = p;

  523.   /* Emit DWARF EH CIE. */
  524.   DSECT(CIE,
  525.     DU32(0);                        /* Offset to CIE itself. */
  526.     DB(DW_CIE_VERSION);
  527.     DSTR("zR");                        /* Augmentation. */
  528.     DUV(1);                        /* Code alignment factor. */
  529.     DSV(-(int32_t)sizeof(uintptr_t));  /* Data alignment factor. */
  530.     DB(DW_REG_RA);                /* Return address register. */
  531.     DB(1); DB(DW_EH_PE_textrel|DW_EH_PE_udata4);  /* Augmentation data. */
  532.     DB(DW_CFA_def_cfa); DUV(DW_REG_SP); DUV(sizeof(uintptr_t));
  533. #if LJ_TARGET_PPC
  534.     DB(DW_CFA_offset_extended_sf); DB(DW_REG_RA); DSV(-1);
  535. #else
  536.     DB(DW_CFA_offset|DW_REG_RA); DUV(1);
  537. #endif
  538.     DALIGNNOP(sizeof(uintptr_t));
  539.   )

  541.   /* Emit DWARF EH FDE. */
  542.   DSECT(FDE,
  543.     DU32((uint32_t)(p-framep));        /* Offset to CIE. */
  544.     DU32(0);                        /* Machine code offset relative to .text. */
  545.     DU32(ctx->szmcode);                /* Machine code length. */
  546.     DB(0);                        /* Augmentation data. */
  547.     /* Registers saved in CFRAME. */
  548. #if LJ_TARGET_X86
  549.     DB(DW_CFA_offset|DW_REG_BP); DUV(2);
  550.     DB(DW_CFA_offset|DW_REG_DI); DUV(3);
  551.     DB(DW_CFA_offset|DW_REG_SI); DUV(4);
  552.     DB(DW_CFA_offset|DW_REG_BX); DUV(5);
  553. #elif LJ_TARGET_X64
  554.     DB(DW_CFA_offset|DW_REG_BP); DUV(2);
  555.     DB(DW_CFA_offset|DW_REG_BX); DUV(3);
  556.     DB(DW_CFA_offset|DW_REG_15); DUV(4);
  557.     DB(DW_CFA_offset|DW_REG_14); DUV(5);
  558.     /* Extra registers saved for JIT-compiled code. */
  559.     DB(DW_CFA_offset|DW_REG_13); DUV(9);
  560.     DB(DW_CFA_offset|DW_REG_12); DUV(10);
  561. #elif LJ_TARGET_ARM
  562.     {
  563.       int i;
  564.       for (i = 11; i >= 4; i--) { DB(DW_CFA_offset|i); DUV(2+(11-i)); }
  565.     }
  566. #elif LJ_TARGET_PPC
  567.     {
  568.       int i;
  569.       DB(DW_CFA_offset_extended); DB(DW_REG_CR); DUV(55);
  570.       for (i = 14; i <= 31; i++) {
  571.         DB(DW_CFA_offset|i); DUV(37+(31-i));
  572.         DB(DW_CFA_offset|32|i); DUV(2+2*(31-i));
  573.       }
  574.     }
  575. #elif LJ_TARGET_MIPS
  576.     {
  577.       int i;
  578.       DB(DW_CFA_offset|30); DUV(2);
  579.       for (i = 23; i >= 16; i--) { DB(DW_CFA_offset|i); DUV(26-i); }
  580.       for (i = 30; i >= 20; i -= 2) { DB(DW_CFA_offset|32|i); DUV(42-i); }
  581.     }
  582. #else
  583. #error "Unsupported target architecture"
  584. #endif
  585.     if (ctx->spadjp != ctx->spadj) {  /* Parent/interpreter stack frame size. */
  586.       DB(DW_CFA_def_cfa_offset); DUV(ctx->spadjp);
  587.       DB(DW_CFA_advance_loc|1);  /* Only an approximation. */
  588.     }
  589.     DB(DW_CFA_def_cfa_offset); DUV(ctx->spadj);  /* Trace stack frame size. */
  590.     DALIGNNOP(sizeof(uintptr_t));
  591.   )

  593.   ctx->p = p;
  594. }

  596. /* Initialize .debug_info section. */
  597. ‌static void LJ_FASTCALL gdbjit_debuginfo(GDBJITctx *ctx)
  598. {
  599.   uint8_t *p = ctx->p;

  601.   DSECT(info,
  602.     DU16(2);                        /* DWARF version. */
  603.     DU32(0);                        /* Abbrev offset. */
  604.     DB(sizeof(uintptr_t));        /* Pointer size. */

  606.     DUV(1);                        /* Abbrev #1: DW_TAG_compile_unit. */
  607.     DSTR(ctx->filename);        /* DW_AT_name. */
  608.     DADDR(ctx->mcaddr);                /* DW_AT_low_pc. */
  609.     DADDR(ctx->mcaddr + ctx->szmcode);  /* DW_AT_high_pc. */
  610.     DU32(0);                        /* DW_AT_stmt_list. */
  611.   )

  613.   ctx->p = p;
  614. }

  616. /* Initialize .debug_abbrev section. */
  617. ‌static void LJ_FASTCALL gdbjit_debugabbrev(GDBJITctx *ctx)
  618. {
  619.   uint8_t *p = ctx->p;

  621.   /* Abbrev #1: DW_TAG_compile_unit. */
  622.   DUV(1); DUV(DW_TAG_compile_unit);
  623.   DB(DW_children_no);
  624.   DUV(DW_AT_name);        DUV(DW_FORM_string);
  625.   DUV(DW_AT_low_pc);        DUV(DW_FORM_addr);
  626.   DUV(DW_AT_high_pc);        DUV(DW_FORM_addr);
  627.   DUV(DW_AT_stmt_list);        DUV(DW_FORM_data4);
  628.   DB(0); DB(0);

  630.   ctx->p = p;
  631. }

  633. ‌#define DLNE(op, s)        (DB(DW_LNS_extended_op), DUV(1+(s)), DB((op)))

  635. /* Initialize .debug_line section. */
  636. ‌static void LJ_FASTCALL gdbjit_debugline(GDBJITctx *ctx)
  637. {
  638.   uint8_t *p = ctx->p;

  640.   DSECT(line,
  641.     DU16(2);                        /* DWARF version. */
  642.     DSECT(header,
  643.       DB(1);                        /* Minimum instruction length. */
  644.       DB(1);                        /* is_stmt. */
  645.       DI8(0);                        /* Line base for special opcodes. */
  646.       DB(2);                        /* Line range for special opcodes. */
  647.       DB(3+1);                        /* Opcode base at DW_LNS_advance_line+1. */
  648.       DB(0); DB(1); DB(1);        /* Standard opcode lengths. */
  649.       /* Directory table. */
  650.       DB(0);
  651.       /* File name table. */
  652.       DSTR(ctx->filename); DUV(0); DUV(0); DUV(0);
  653.       DB(0);
  654.     )

  656.     DLNE(DW_LNE_set_address, sizeof(uintptr_t)); DADDR(ctx->mcaddr);
  657.     if (ctx->lineno) {
  658.       DB(DW_LNS_advance_line); DSV(ctx->lineno-1);
  659.     }
  660.     DB(DW_LNS_copy);
  661.     DB(DW_LNS_advance_pc); DUV(ctx->szmcode);
  662.     DLNE(DW_LNE_end_sequence, 0);
  663.   )

  665.   ctx->p = p;
  666. }

  668. ‌#undef DLNE

  670. /* Undef shortcuts. */
  671. ‌#undef DB
  672. ‌#undef DI8
  673. ‌#undef DU16
  674. ‌#undef DU32
  675. ‌#undef DADDR
  676. ‌#undef DUV
  677. ‌#undef DSV
  678. ‌#undef DSTR
  679. ‌#undef DALIGNNOP
  680. ‌#undef DSECT

  682. /* Type of a section initializer callback. */
  683. ‌typedef void (LJ_FASTCALL *GDBJITinitf)(GDBJITctx *ctx);

  685. /* Call section initializer and set the section offset and size. */
  686. ‌static void gdbjit_initsect(GDBJITctx *ctx, int sect, GDBJITinitf initf)
  687. {
  688.   ctx->startp = ctx->p;
  689.   ctx->obj.sect[sect].ofs = (uintptr_t)((char *)ctx->p - (char *)&ctx->obj);
  690.   initf(ctx);
  691.   ctx->obj.sect[sect].size = (uintptr_t)(ctx->p - ctx->startp);
  692. }

  694. ‌#define SECTALIGN(p, a) \
  695.   ((p) = (uint8_t *)(((uintptr_t)(p) + ((a)-1)) & ~(uintptr_t)((a)-1)))

  697. /* Build in-memory ELF object. */
  698. ‌static void gdbjit_buildobj(GDBJITctx *ctx)
  699. {
  700.   GDBJITobj *obj = &ctx->obj;
  701.   /* Fill in ELF header and clear structures. */
  702.   memcpy(&obj->hdr, &elfhdr_template, sizeof(ELFheader));
  703.   memset(&obj->sect, 0, sizeof(ELFsectheader)*GDBJIT_SECT__MAX);
  704.   memset(&obj->sym, 0, sizeof(ELFsymbol)*GDBJIT_SYM__MAX);
  705.   /* Initialize sections. */
  706.   ctx->p = obj->space;
  707.   gdbjit_initsect(ctx, GDBJIT_SECT_shstrtab, gdbjit_secthdr);
  708.   gdbjit_initsect(ctx, GDBJIT_SECT_strtab, gdbjit_symtab);
  709.   gdbjit_initsect(ctx, GDBJIT_SECT_debug_info, gdbjit_debuginfo);
  710.   gdbjit_initsect(ctx, GDBJIT_SECT_debug_abbrev, gdbjit_debugabbrev);
  711.   gdbjit_initsect(ctx, GDBJIT_SECT_debug_line, gdbjit_debugline);
  712.   SECTALIGN(ctx->p, sizeof(uintptr_t));
  713.   gdbjit_initsect(ctx, GDBJIT_SECT_eh_frame, gdbjit_ehframe);
  714.   ctx->objsize = (size_t)((char *)ctx->p - (char *)obj);
  715.   lua_assert(ctx->objsize < sizeof(GDBJITobj));
  716. }

  718. ‌#undef SECTALIGN

  720. /* -- Interface to GDB JIT API -------------------------------------------- */

  722. /* Add new entry to GDB JIT symbol chain. */
  723. ‌static void gdbjit_newentry(lua_State *L, GDBJITctx *ctx)
  724. {
  725.   /* Allocate memory for GDB JIT entry and ELF object. */
  726.   MSize sz = (MSize)(sizeof(GDBJITentryobj) - sizeof(GDBJITobj) + ctx->objsize);
  727.   GDBJITentryobj *eo = lj_mem_newt(L, sz, GDBJITentryobj);
  728.   memcpy(&eo->obj, &ctx->obj, ctx->objsize);  /* Copy ELF object. */
  729.   eo->sz = sz;
  730.   ctx->T->gdbjit_entry = (void *)eo;
  731.   /* Link new entry to chain and register it. */
  732.   eo->entry.prev_entry = NULL;
  733.   eo->entry.next_entry = __jit_debug_descriptor.first_entry;
  734.   if (eo->entry.next_entry)
  735.     eo->entry.next_entry->prev_entry = &eo->entry;
  736.   eo->entry.symfile_addr = (const char *)&eo->obj;
  737.   eo->entry.symfile_size = ctx->objsize;
  738.   __jit_debug_descriptor.first_entry = &eo->entry;
  739.   __jit_debug_descriptor.relevant_entry = &eo->entry;
  740.   __jit_debug_descriptor.action_flag = GDBJIT_REGISTER;
  741.   __jit_debug_register_code();
  742. }

  744. /* Add debug info for newly compiled trace and notify GDB. */
  745. ‌void lj_gdbjit_addtrace(jit_State *J, GCtrace *T)
  746. {
  747.   GDBJITctx ctx;
  748.   GCproto *pt = &gcref(T->startpt)->pt;
  749.   TraceNo parent = T->ir[REF_BASE].op1;
  750.   const BCIns *startpc = mref(T->startpc, const BCIns);
  751.   ctx.T = T;
  752.   ctx.mcaddr = (uintptr_t)T->mcode;
  753.   ctx.szmcode = T->szmcode;
  754.   ctx.spadjp = CFRAME_SIZE_JIT +
  755.                (MSize)(parent ? traceref(J, parent)->spadjust : 0);
  756.   ctx.spadj = CFRAME_SIZE_JIT + T->spadjust;
  757.   lua_assert(startpc >= proto_bc(pt) && startpc < proto_bc(pt) + pt->sizebc);
  758.   ctx.lineno = lj_debug_line(pt, proto_bcpos(pt, startpc));
  759.   ctx.filename = proto_chunknamestr(pt);
  760.   if (*ctx.filename == '@' || *ctx.filename == '=')
  761.     ctx.filename++;
  762.   else
  763.     ctx.filename = "(string)";
  764.   gdbjit_buildobj(&ctx);
  765.   gdbjit_newentry(J->L, &ctx);
  766. }

  768. /* Delete debug info for trace and notify GDB. */
  769. ‌void lj_gdbjit_deltrace(jit_State *J, GCtrace *T)
  770. {
  771.   GDBJITentryobj *eo = (GDBJITentryobj *)T->gdbjit_entry;
  772.   if (eo) {
  773.     if (eo->entry.prev_entry)
  774.       eo->entry.prev_entry->next_entry = eo->entry.next_entry;
  775.     else
  776.       __jit_debug_descriptor.first_entry = eo->entry.next_entry;
  777.     if (eo->entry.next_entry)
  778.       eo->entry.next_entry->prev_entry = eo->entry.prev_entry;
  779.     __jit_debug_descriptor.relevant_entry = &eo->entry;
  780.     __jit_debug_descriptor.action_flag = GDBJIT_UNREGISTER;
  781.     __jit_debug_register_code();
  782.     lj_mem_free(J2G(J), eo, eo->sz);
  783.   }
  784. }

  786. #endif
  787. #endif

One Level Up Top Level