src/lj_gdbjit.c

   1 /*
   2 ** Client for the GDB JIT API.
   3 ** Copyright (C) 2005-2011 Mike Pall. See Copyright Notice in luajit.h
   4 */
   5
   6 #define lj_gdbjit_c
   7 #define LUA_CORE
   8
   9 #include "lj_obj.h"
  10
  11 #if LJ_HASJIT
  12
  13 #include "lj_gc.h"
  14 #include "lj_err.h"
  15 #include "lj_debug.h"
  16 #include "lj_frame.h"
  17 #include "lj_jit.h"
  18 #include "lj_dispatch.h"
  19
  20 /* This is not compiled in by default.
  21 ** Enable with -DLUAJIT_USE_GDBJIT in the Makefile and recompile everything.
  22 */
  23 #ifdef LUAJIT_USE_GDBJIT
  24
  25 /* The GDB JIT API allows JIT compilers to pass debug information about
  26 ** JIT-compiled code back to GDB. You need at least GDB 7.0 or higher
  27 ** to see it in action.
  28 **
  29 ** This is a passive API, so it works even when not running under GDB
  30 ** or when attaching to an already running process. Alas, this implies
  31 ** enabling it always has a non-negligible overhead -- do not use in
  32 ** release mode!
  33 **
  34 ** The LuaJIT GDB JIT client is rather minimal at the moment. It gives
  35 ** each trace a symbol name and adds a source location and frame unwind
  36 ** information. Obviously LuaJIT itself and any embedding C application
  37 ** should be compiled with debug symbols, too (see the Makefile).
  38 **
  39 ** Traces are named TRACE_1, TRACE_2, ... these correspond to the trace
  40 ** numbers from -jv or -jdump. Use "break TRACE_1" or "tbreak TRACE_1" etc.
  41 ** to set breakpoints on specific traces (even ahead of their creation).
  42 **
  43 ** The source location for each trace allows listing the corresponding
  44 ** source lines with the GDB command "list" (but only if the Lua source
  45 ** has been loaded from a file). Currently this is always set to the
  46 ** location where the trace has been started.
  47 **
  48 ** Frame unwind information can be inspected with the GDB command
  49 ** "info frame". This also allows proper backtraces across JIT-compiled
  50 ** code with the GDB command "bt".
  51 **
  52 ** You probably want to add the following settings to a .gdbinit file
  53 ** (or add them to ~/.gdbinit):
  54 **   set disassembly-flavor intel
  55 **   set breakpoint pending on
  56 **
  57 ** Here's a sample GDB session:
  58 ** ------------------------------------------------------------------------
  59
  60 $ cat >x.lua
  61 for outer=1,100 do
  62   for inner=1,100 do end
  63 end
  64 ^D
  65
  66 $ luajit -jv x.lua
  67 [TRACE   1 x.lua:2]
  68 [TRACE   2 (1/3) x.lua:1 -> 1]
  69
  70 $ gdb --quiet --args luajit x.lua
  71 (gdb) tbreak TRACE_1
  72 Function "TRACE_1" not defined.
  73 Temporary breakpoint 1 (TRACE_1) pending.
  74 (gdb) run
  75 Starting program: luajit x.lua
  76
  77 Temporary breakpoint 1, TRACE_1 () at x.lua:2
  78 2         for inner=1,100 do end
  79 (gdb) list
  80 1       for outer=1,100 do
  81 2         for inner=1,100 do end
  82 3       end
  83 (gdb) bt
  84 #0  TRACE_1 () at x.lua:2
  85 #1  0x08053690 in lua_pcall [...]
  86 [...]
  87 #7  0x0806ff90 in main [...]
  88 (gdb) disass TRACE_1
  89 Dump of assembler code for function TRACE_1:
  90 0xf7fd9fba <TRACE_1+0>: mov    DWORD PTR ds:0xf7e0e2a0,0x1
  91 0xf7fd9fc4 <TRACE_1+10>:        movsd  xmm7,QWORD PTR [edx+0x20]
  92 [...]
  93 0xf7fd9ff8 <TRACE_1+62>:        jmp    0xf7fd2014
  94 End of assembler dump.
  95 (gdb) tbreak TRACE_2
  96 Function "TRACE_2" not defined.
  97 Temporary breakpoint 2 (TRACE_2) pending.
  98 (gdb) cont
  99 Continuing.
 100
 101 Temporary breakpoint 2, TRACE_2 () at x.lua:1
 102 1       for outer=1,100 do
 103 (gdb) info frame
 104 Stack level 0, frame at 0xffffd7c0:
 105  eip = 0xf7fd9f60 in TRACE_2 (x.lua:1); saved eip 0x8053690
 106  called by frame at 0xffffd7e0
 107  source language unknown.
 108  Arglist at 0xffffd78c, args:
 109  Locals at 0xffffd78c, Previous frame's sp is 0xffffd7c0
 110  Saved registers:
 111   ebx at 0xffffd7ac, ebp at 0xffffd7b8, esi at 0xffffd7b0, edi at 0xffffd7b4,
 112   eip at 0xffffd7bc
 113 (gdb)
 114
 115 ** ------------------------------------------------------------------------
 116 */
 117
 118 /* -- GDB JIT API --------------------------------------------------------- */
 119
 120 /* GDB JIT actions. */
 121 enum {
 122   GDBJIT_NOACTION = 0,
 123   GDBJIT_REGISTER,
 124   GDBJIT_UNREGISTER
 125 };
 126
 127 /* GDB JIT entry. */
 128 typedef struct GDBJITentry {
 129   struct GDBJITentry *next_entry;
 130   struct GDBJITentry *prev_entry;
 131   const char *symfile_addr;
 132   uint64_t symfile_size;
 133 } GDBJITentry;
 134
 135 /* GDB JIT descriptor. */
 136 typedef struct GDBJITdesc {
 137   uint32_t version;
 138   uint32_t action_flag;
 139   GDBJITentry *relevant_entry;
 140   GDBJITentry *first_entry;
 141 } GDBJITdesc;
 142
 143 GDBJITdesc __jit_debug_descriptor = {
 144   1, GDBJIT_NOACTION, NULL, NULL
 145 };
 146
 147 /* GDB sets a breakpoint at this function. */
 148 void LJ_NOINLINE __jit_debug_register_code()
 149 {
 150   __asm__ __volatile__("");
 151 };
 152
 153 /* -- In-memory ELF object definitions ------------------------------------ */
 154
 155 /* ELF definitions. */
 156 typedef struct ELFheader {
 157   uint8_t emagic[4];
 158   uint8_t eclass;
 159   uint8_t eendian;
 160   uint8_t eversion;
 161   uint8_t eosabi;
 162   uint8_t eabiversion;
 163   uint8_t epad[7];
 164   uint16_t type;
 165   uint16_t machine;
 166   uint32_t version;
 167   uintptr_t entry;
 168   uintptr_t phofs;
 169   uintptr_t shofs;
 170   uint32_t flags;
 171   uint16_t ehsize;
 172   uint16_t phentsize;
 173   uint16_t phnum;
 174   uint16_t shentsize;
 175   uint16_t shnum;
 176   uint16_t shstridx;
 177 } ELFheader;
 178
 179 typedef struct ELFsectheader {
 180   uint32_t name;
 181   uint32_t type;
 182   uintptr_t flags;
 183   uintptr_t addr;
 184   uintptr_t ofs;
 185   uintptr_t size;
 186   uint32_t link;
 187   uint32_t info;
 188   uintptr_t align;
 189   uintptr_t entsize;
 190 } ELFsectheader;
 191
 192 #define ELFSECT_IDX_ABS         0xfff1
 193
 194 enum {
 195   ELFSECT_TYPE_PROGBITS = 1,
 196   ELFSECT_TYPE_SYMTAB = 2,
 197   ELFSECT_TYPE_STRTAB = 3,
 198   ELFSECT_TYPE_NOBITS = 8
 199 };
 200
 201 #define ELFSECT_FLAGS_WRITE     1
 202 #define ELFSECT_FLAGS_ALLOC     2
 203 #define ELFSECT_FLAGS_EXEC      4
 204
 205 typedef struct ELFsymbol {
 206 #if LJ_64
 207   uint32_t name;
 208   uint8_t info;
 209   uint8_t other;
 210   uint16_t sectidx;
 211   uintptr_t value;
 212   uint64_t size;
 213 #else
 214   uint32_t name;
 215   uintptr_t value;
 216   uint32_t size;
 217   uint8_t info;
 218   uint8_t other;
 219   uint16_t sectidx;
 220 #endif
 221 } ELFsymbol;
 222
 223 enum {
 224   ELFSYM_TYPE_FUNC = 2,
 225   ELFSYM_TYPE_FILE = 4,
 226   ELFSYM_BIND_LOCAL = 0 << 4,
 227   ELFSYM_BIND_GLOBAL = 1 << 4,
 228 };
 229
 230 /* DWARF definitions. */
 231 #define DW_CIE_VERSION  1
 232
 233 enum {
 234   DW_CFA_nop = 0x0,
 235   DW_CFA_def_cfa = 0xc,
 236   DW_CFA_def_cfa_offset = 0xe,
 237   DW_CFA_advance_loc = 0x40,
 238   DW_CFA_offset = 0x80
 239 };
 240
 241 enum {
 242   DW_EH_PE_udata4 = 3,
 243   DW_EH_PE_textrel = 0x20
 244 };
 245
 246 enum {
 247   DW_TAG_compile_unit = 0x11
 248 };
 249
 250 enum {
 251   DW_children_no = 0,
 252   DW_children_yes = 1
 253 };
 254
 255 enum {
 256   DW_AT_name = 0x03,
 257   DW_AT_stmt_list = 0x10,
 258   DW_AT_low_pc = 0x11,
 259   DW_AT_high_pc = 0x12
 260 };
 261
 262 enum {
 263   DW_FORM_addr = 0x01,
 264   DW_FORM_data4 = 0x06,
 265   DW_FORM_string = 0x08
 266 };
 267
 268 enum {
 269   DW_LNS_extended_op = 0,
 270   DW_LNS_copy = 1,
 271   DW_LNS_advance_pc = 2,
 272   DW_LNS_advance_line = 3
 273 };
 274
 275 enum {
 276   DW_LNE_end_sequence = 1,
 277   DW_LNE_set_address = 2
 278 };
 279
 280 enum {
 281 #if LJ_TARGET_X86
 282   DW_REG_AX, DW_REG_CX, DW_REG_DX, DW_REG_BX,
 283   DW_REG_SP, DW_REG_BP, DW_REG_SI, DW_REG_DI,
 284   DW_REG_RA,
 285 #elif LJ_TARGET_X64
 286   /* Yes, the order is strange, but correct. */
 287   DW_REG_AX, DW_REG_DX, DW_REG_CX, DW_REG_BX,
 288   DW_REG_SI, DW_REG_DI, DW_REG_BP, DW_REG_SP,
 289   DW_REG_8, DW_REG_9, DW_REG_10, DW_REG_11,
 290   DW_REG_12, DW_REG_13, DW_REG_14, DW_REG_15,
 291   DW_REG_RA,
 292 #elif LJ_TARGET_ARM
 293   DW_REG_SP = 13,
 294   DW_REG_RA = 14,
 295 #else
 296 #error "Unsupported target architecture"
 297 #endif
 298 };
 299
 300 /* Minimal list of sections for the in-memory ELF object. */
 301 enum {
 302   GDBJIT_SECT_NULL,
 303   GDBJIT_SECT_text,
 304   GDBJIT_SECT_eh_frame,
 305   GDBJIT_SECT_shstrtab,
 306   GDBJIT_SECT_strtab,
 307   GDBJIT_SECT_symtab,
 308   GDBJIT_SECT_debug_info,
 309   GDBJIT_SECT_debug_abbrev,
 310   GDBJIT_SECT_debug_line,
 311   GDBJIT_SECT__MAX
 312 };
 313
 314 enum {
 315   GDBJIT_SYM_UNDEF,
 316   GDBJIT_SYM_FILE,
 317   GDBJIT_SYM_FUNC,
 318   GDBJIT_SYM__MAX
 319 };
 320
 321 /* In-memory ELF object. */
 322 typedef struct GDBJITobj {
 323   ELFheader hdr;                        /* ELF header. */
 324   ELFsectheader sect[GDBJIT_SECT__MAX]; /* ELF sections. */
 325   ELFsymbol sym[GDBJIT_SYM__MAX];       /* ELF symbol table. */
 326   uint8_t space[4096];                  /* Space for various section data. */
 327 } GDBJITobj;
 328
 329 /* Combined structure for GDB JIT entry and ELF object. */
 330 typedef struct GDBJITentryobj {
 331   GDBJITentry entry;
 332   size_t sz;
 333   GDBJITobj obj;
 334 } GDBJITentryobj;
 335
 336 /* Template for in-memory ELF header. */
 337 static const ELFheader elfhdr_template = {
 338   .emagic = { 0x7f, 'E', 'L', 'F' },
 339   .eclass = LJ_64 ? 2 : 1,
 340   .eendian = LJ_ENDIAN_SELECT(1, 2),
 341   .eversion = 1,
 342 #if LJ_TARGET_LINUX
 343   .eosabi = 0,  /* Nope, it's not 3. */
 344 #elif defined(__FreeBSD__)
 345   .eosabi = 9,
 346 #elif defined(__NetBSD__)
 347   .eosabi = 2,
 348 #elif defined(__OpenBSD__)
 349   .eosabi = 12,
 350 #elif (defined(__sun__) && defined(__svr4__)) || defined(__solaris__)
 351   .eosabi = 6,
 352 #else
 353   .eosabi = 0,
 354 #endif
 355   .eabiversion = 0,
 356   .epad = { 0, 0, 0, 0, 0, 0, 0 },
 357   .type = 1,
 358 #if LJ_TARGET_X86
 359   .machine = 3,
 360 #elif LJ_TARGET_X64
 361   .machine = 62,
 362 #elif LJ_TARGET_ARM
 363   .machine = 40,
 364 #else
 365 #error "Unsupported target architecture"
 366 #endif
 367   .version = 1,
 368   .entry = 0,
 369   .phofs = 0,
 370   .shofs = offsetof(GDBJITobj, sect),
 371   .flags = 0,
 372   .ehsize = sizeof(ELFheader),
 373   .phentsize = 0,
 374   .phnum = 0,
 375   .shentsize = sizeof(ELFsectheader),
 376   .shnum = GDBJIT_SECT__MAX,
 377   .shstridx = GDBJIT_SECT_shstrtab
 378 };
 379
 380 /* -- In-memory ELF object generation ------------------------------------- */
 381
 382 /* Context for generating the ELF object for the GDB JIT API. */
 383 typedef struct GDBJITctx {
 384   uint8_t *p;           /* Pointer to next address in obj.space. */
 385   uint8_t *startp;      /* Pointer to start address in obj.space. */
 386   GCtrace *T;           /* Generate symbols for this trace. */
 387   uintptr_t mcaddr;     /* Machine code address. */
 388   MSize szmcode;        /* Size of machine code. */
 389   MSize spadjp;         /* Stack adjustment for parent trace or interpreter. */
 390   MSize spadj;          /* Stack adjustment for trace itself. */
 391   BCLine lineno;        /* Starting line number. */
 392   const char *filename; /* Starting file name. */
 393   size_t objsize;       /* Final size of ELF object. */
 394   GDBJITobj obj;        /* In-memory ELF object. */
 395 } GDBJITctx;
 396
 397 /* Add a zero-terminated string. */
 398 static uint32_t gdbjit_strz(GDBJITctx *ctx, const char *str)
 399 {
 400   uint8_t *p = ctx->p;
 401   uint32_t ofs = (uint32_t)(p - ctx->startp);
 402   do {
 403     *p++ = (uint8_t)*str;
 404   } while (*str++);
 405   ctx->p = p;
 406   return ofs;
 407 }
 408
 409 /* Append a decimal number. */
 410 static void gdbjit_catnum(GDBJITctx *ctx, uint32_t n)
 411 {
 412   if (n >= 10) { uint32_t m = n / 10; n = n % 10; gdbjit_catnum(ctx, m); }
 413   *ctx->p++ = '0' + n;
 414 }
 415
 416 /* Add a ULEB128 value. */
 417 static void gdbjit_uleb128(GDBJITctx *ctx, uint32_t v)
 418 {
 419   uint8_t *p = ctx->p;
 420   for (; v >= 0x80; v >>= 7)
 421     *p++ = (uint8_t)((v & 0x7f) | 0x80);
 422   *p++ = (uint8_t)v;
 423   ctx->p = p;
 424 }
 425
 426 /* Add a SLEB128 value. */
 427 static void gdbjit_sleb128(GDBJITctx *ctx, int32_t v)
 428 {
 429   uint8_t *p = ctx->p;
 430   for (; (uint32_t)(v+0x40) >= 0x80; v >>= 7)
 431     *p++ = (uint8_t)((v & 0x7f) | 0x80);
 432   *p++ = (uint8_t)(v & 0x7f);
 433   ctx->p = p;
 434 }
 435
 436 /* Shortcuts to generate DWARF structures. */
 437 #define DB(x)           (*p++ = (x))
 438 #define DI8(x)          (*(int8_t *)p = (x), p++)
 439 #define DU16(x)         (*(uint16_t *)p = (x), p += 2)
 440 #define DU32(x)         (*(uint32_t *)p = (x), p += 4)
 441 #define DADDR(x)        (*(uintptr_t *)p = (x), p += sizeof(uintptr_t))
 442 #define DUV(x)          (ctx->p = p, gdbjit_uleb128(ctx, (x)), p = ctx->p)
 443 #define DSV(x)          (ctx->p = p, gdbjit_sleb128(ctx, (x)), p = ctx->p)
 444 #define DSTR(str)       (ctx->p = p, gdbjit_strz(ctx, (str)), p = ctx->p)
 445 #define DALIGNNOP(s)    while ((uintptr_t)p & ((s)-1)) *p++ = DW_CFA_nop
 446 #define DSECT(name, stmt) \
 447   { uint32_t *szp_##name = (uint32_t *)p; p += 4; stmt \
 448     *szp_##name = (uint32_t)((p-(uint8_t *)szp_##name)-4); } \
 449
 450 /* Initialize ELF section headers. */
 451 static void LJ_FASTCALL gdbjit_secthdr(GDBJITctx *ctx)
 452 {
 453   ELFsectheader *sect;
 454
 455   *ctx->p++ = '\0';  /* Empty string at start of string table. */
 456
 457 #define SECTDEF(id, tp, al) \
 458   sect = &ctx->obj.sect[GDBJIT_SECT_##id]; \
 459   sect->name = gdbjit_strz(ctx, "." #id); \
 460   sect->type = ELFSECT_TYPE_##tp; \
 461   sect->align = (al)
 462
 463   SECTDEF(text, NOBITS, 16);
 464   sect->flags = ELFSECT_FLAGS_ALLOC|ELFSECT_FLAGS_EXEC;
 465   sect->addr = ctx->mcaddr;
 466   sect->ofs = 0;
 467   sect->size = ctx->szmcode;
 468
 469   SECTDEF(eh_frame, PROGBITS, sizeof(uintptr_t));
 470   sect->flags = ELFSECT_FLAGS_ALLOC;
 471
 472   SECTDEF(shstrtab, STRTAB, 1);
 473   SECTDEF(strtab, STRTAB, 1);
 474
 475   SECTDEF(symtab, SYMTAB, sizeof(uintptr_t));
 476   sect->ofs = offsetof(GDBJITobj, sym);
 477   sect->size = sizeof(ctx->obj.sym);
 478   sect->link = GDBJIT_SECT_strtab;
 479   sect->entsize = sizeof(ELFsymbol);
 480   sect->info = GDBJIT_SYM_FUNC;
 481
 482   SECTDEF(debug_info, PROGBITS, 1);
 483   SECTDEF(debug_abbrev, PROGBITS, 1);
 484   SECTDEF(debug_line, PROGBITS, 1);
 485
 486 #undef SECTDEF
 487 }
 488
 489 /* Initialize symbol table. */
 490 static void LJ_FASTCALL gdbjit_symtab(GDBJITctx *ctx)
 491 {
 492   ELFsymbol *sym;
 493
 494   *ctx->p++ = '\0';  /* Empty string at start of string table. */
 495
 496   sym = &ctx->obj.sym[GDBJIT_SYM_FILE];
 497   sym->name = gdbjit_strz(ctx, "JIT mcode");
 498   sym->sectidx = ELFSECT_IDX_ABS;
 499   sym->info = ELFSYM_TYPE_FILE|ELFSYM_BIND_LOCAL;
 500
 501   sym = &ctx->obj.sym[GDBJIT_SYM_FUNC];
 502   sym->name = gdbjit_strz(ctx, "TRACE_"); ctx->p--;
 503   gdbjit_catnum(ctx, ctx->T->traceno); *ctx->p++ = '\0';
 504   sym->sectidx = GDBJIT_SECT_text;
 505   sym->value = 0;
 506   sym->size = ctx->szmcode;
 507   sym->info = ELFSYM_TYPE_FUNC|ELFSYM_BIND_GLOBAL;
 508 }
 509
 510 /* Initialize .eh_frame section. */
 511 static void LJ_FASTCALL gdbjit_ehframe(GDBJITctx *ctx)
 512 {
 513   uint8_t *p = ctx->p;
 514   uint8_t *framep = p;
 515
 516   /* Emit DWARF EH CIE. */
 517   DSECT(CIE,
 518     DU32(0);                    /* Offset to CIE itself. */
 519     DB(DW_CIE_VERSION);
 520     DSTR("zR");                 /* Augmentation. */
 521     DUV(1);                     /* Code alignment factor. */
 522     DSV(-(int32_t)sizeof(uintptr_t));  /* Data alignment factor. */
 523     DB(DW_REG_RA);              /* Return address register. */
 524     DB(1); DB(DW_EH_PE_textrel|DW_EH_PE_udata4);  /* Augmentation data. */
 525     DB(DW_CFA_def_cfa); DUV(DW_REG_SP); DUV(sizeof(uintptr_t));
 526     DB(DW_CFA_offset|DW_REG_RA); DUV(1);
 527     DALIGNNOP(sizeof(uintptr_t));
 528   )
 529
 530   /* Emit DWARF EH FDE. */
 531   DSECT(FDE,
 532     DU32((uint32_t)(p-framep)); /* Offset to CIE. */
 533     DU32(0);                    /* Machine code offset relative to .text. */
 534     DU32(ctx->szmcode);         /* Machine code length. */
 535     DB(0);                      /* Augmentation data. */
 536     /* Registers saved in CFRAME. */
 537 #if LJ_TARGET_X86
 538     DB(DW_CFA_offset|DW_REG_BP); DUV(2);
 539     DB(DW_CFA_offset|DW_REG_DI); DUV(3);
 540     DB(DW_CFA_offset|DW_REG_SI); DUV(4);
 541     DB(DW_CFA_offset|DW_REG_BX); DUV(5);
 542 #elif LJ_TARGET_X64
 543     DB(DW_CFA_offset|DW_REG_BP); DUV(2);
 544     DB(DW_CFA_offset|DW_REG_BX); DUV(3);
 545     DB(DW_CFA_offset|DW_REG_15); DUV(4);
 546     DB(DW_CFA_offset|DW_REG_14); DUV(5);
 547     /* Extra registers saved for JIT-compiled code. */
 548     DB(DW_CFA_offset|DW_REG_13); DUV(9);
 549     DB(DW_CFA_offset|DW_REG_12); DUV(10);
 550 #elif LJ_TARGET_ARM
 551     {
 552       int i;
 553       for (i = 11; i >= 4; i--) {  /* R4-R11. */
 554         DB(DW_CFA_offset|i); DUV(2+(11-i));
 555       }
 556     }
 557 #else
 558 #error "Unsupported target architecture"
 559 #endif
 560     if (ctx->spadjp != ctx->spadj) {  /* Parent/interpreter stack frame size. */
 561       DB(DW_CFA_def_cfa_offset); DUV(ctx->spadjp);
 562       DB(DW_CFA_advance_loc|1);  /* Only an approximation. */
 563     }
 564     DB(DW_CFA_def_cfa_offset); DUV(ctx->spadj);  /* Trace stack frame size. */
 565     DALIGNNOP(sizeof(uintptr_t));
 566   )
 567
 568   ctx->p = p;
 569 }
 570
 571 /* Initialize .debug_info section. */
 572 static void LJ_FASTCALL gdbjit_debuginfo(GDBJITctx *ctx)
 573 {
 574   uint8_t *p = ctx->p;
 575
 576   DSECT(info,
 577     DU16(2);                    /* DWARF version. */
 578     DU32(0);                    /* Abbrev offset. */
 579     DB(sizeof(uintptr_t));      /* Pointer size. */
 580
 581     DUV(1);                     /* Abbrev #1: DW_TAG_compile_unit. */
 582     DSTR(ctx->filename);        /* DW_AT_name. */
 583     DADDR(ctx->mcaddr);         /* DW_AT_low_pc. */
 584     DADDR(ctx->mcaddr + ctx->szmcode);  /* DW_AT_high_pc. */
 585     DU32(0);                    /* DW_AT_stmt_list. */
 586   )
 587
 588   ctx->p = p;
 589 }
 590
 591 /* Initialize .debug_abbrev section. */
 592 static void LJ_FASTCALL gdbjit_debugabbrev(GDBJITctx *ctx)
 593 {
 594   uint8_t *p = ctx->p;
 595
 596   /* Abbrev #1: DW_TAG_compile_unit. */
 597   DUV(1); DUV(DW_TAG_compile_unit);
 598   DB(DW_children_no);
 599   DUV(DW_AT_name);      DUV(DW_FORM_string);
 600   DUV(DW_AT_low_pc);    DUV(DW_FORM_addr);
 601   DUV(DW_AT_high_pc);   DUV(DW_FORM_addr);
 602   DUV(DW_AT_stmt_list); DUV(DW_FORM_data4);
 603   DB(0); DB(0);
 604
 605   ctx->p = p;
 606 }
 607
 608 #define DLNE(op, s)     (DB(DW_LNS_extended_op), DUV(1+(s)), DB((op)))
 609
 610 /* Initialize .debug_line section. */
 611 static void LJ_FASTCALL gdbjit_debugline(GDBJITctx *ctx)
 612 {
 613   uint8_t *p = ctx->p;
 614
 615   DSECT(line,
 616     DU16(2);                    /* DWARF version. */
 617     DSECT(header,
 618       DB(1);                    /* Minimum instruction length. */
 619       DB(1);                    /* is_stmt. */
 620       DI8(0);                   /* Line base for special opcodes. */
 621       DB(2);                    /* Line range for special opcodes. */
 622       DB(3+1);                  /* Opcode base at DW_LNS_advance_line+1. */
 623       DB(0); DB(1); DB(1);      /* Standard opcode lengths. */
 624       /* Directory table. */
 625       DB(0);
 626       /* File name table. */
 627       DSTR(ctx->filename); DUV(0); DUV(0); DUV(0);
 628       DB(0);
 629     )
 630
 631     DLNE(DW_LNE_set_address, sizeof(uintptr_t)); DADDR(ctx->mcaddr);
 632     if (ctx->lineno) {
 633       DB(DW_LNS_advance_line); DSV(ctx->lineno-1);
 634     }
 635     DB(DW_LNS_copy);
 636     DB(DW_LNS_advance_pc); DUV(ctx->szmcode);
 637     DLNE(DW_LNE_end_sequence, 0);
 638   )
 639
 640   ctx->p = p;
 641 }
 642
 643 #undef DLNE
 644
 645 /* Undef shortcuts. */
 646 #undef DB
 647 #undef DI8
 648 #undef DU16
 649 #undef DU32
 650 #undef DADDR
 651 #undef DUV
 652 #undef DSV
 653 #undef DSTR
 654 #undef DALIGNNOP
 655 #undef DSECT
 656
 657 /* Type of a section initializer callback. */
 658 typedef void (LJ_FASTCALL *GDBJITinitf)(GDBJITctx *ctx);
 659
 660 /* Call section initializer and set the section offset and size. */
 661 static void gdbjit_initsect(GDBJITctx *ctx, int sect, GDBJITinitf initf)
 662 {
 663   ctx->startp = ctx->p;
 664   ctx->obj.sect[sect].ofs = (uintptr_t)((char *)ctx->p - (char *)&ctx->obj);
 665   initf(ctx);
 666   ctx->obj.sect[sect].size = (uintptr_t)(ctx->p - ctx->startp);
 667 }
 668
 669 #define SECTALIGN(p, a) \
 670   ((p) = (uint8_t *)(((uintptr_t)(p) + ((a)-1)) & ~(uintptr_t)((a)-1)))
 671
 672 /* Build in-memory ELF object. */
 673 static void gdbjit_buildobj(GDBJITctx *ctx)
 674 {
 675   GDBJITobj *obj = &ctx->obj;
 676   /* Fill in ELF header and clear structures. */
 677   memcpy(&obj->hdr, &elfhdr_template, sizeof(ELFheader));
 678   memset(&obj->sect, 0, sizeof(ELFsectheader)*GDBJIT_SECT__MAX);
 679   memset(&obj->sym, 0, sizeof(ELFsymbol)*GDBJIT_SYM__MAX);
 680   /* Initialize sections. */
 681   ctx->p = obj->space;
 682   gdbjit_initsect(ctx, GDBJIT_SECT_shstrtab, gdbjit_secthdr);
 683   gdbjit_initsect(ctx, GDBJIT_SECT_strtab, gdbjit_symtab);
 684   gdbjit_initsect(ctx, GDBJIT_SECT_debug_info, gdbjit_debuginfo);
 685   gdbjit_initsect(ctx, GDBJIT_SECT_debug_abbrev, gdbjit_debugabbrev);
 686   gdbjit_initsect(ctx, GDBJIT_SECT_debug_line, gdbjit_debugline);
 687   SECTALIGN(ctx->p, sizeof(uintptr_t));
 688   gdbjit_initsect(ctx, GDBJIT_SECT_eh_frame, gdbjit_ehframe);
 689   ctx->objsize = (size_t)((char *)ctx->p - (char *)obj);
 690   lua_assert(ctx->objsize < sizeof(GDBJITobj));
 691 }
 692
 693 #undef SECTALIGN
 694
 695 /* -- Interface to GDB JIT API -------------------------------------------- */
 696
 697 /* Add new entry to GDB JIT symbol chain. */
 698 static void gdbjit_newentry(lua_State *L, GDBJITctx *ctx)
 699 {
 700   /* Allocate memory for GDB JIT entry and ELF object. */
 701   MSize sz = (MSize)(sizeof(GDBJITentryobj) - sizeof(GDBJITobj) + ctx->objsize);
 702   GDBJITentryobj *eo = lj_mem_newt(L, sz, GDBJITentryobj);
 703   memcpy(&eo->obj, &ctx->obj, ctx->objsize);  /* Copy ELF object. */
 704   eo->sz = sz;
 705   ctx->T->gdbjit_entry = (void *)eo;
 706   /* Link new entry to chain and register it. */
 707   eo->entry.prev_entry = NULL;
 708   eo->entry.next_entry = __jit_debug_descriptor.first_entry;
 709   if (eo->entry.next_entry)
 710     eo->entry.next_entry->prev_entry = &eo->entry;
 711   eo->entry.symfile_addr = (const char *)&eo->obj;
 712   eo->entry.symfile_size = ctx->objsize;
 713   __jit_debug_descriptor.first_entry = &eo->entry;
 714   __jit_debug_descriptor.relevant_entry = &eo->entry;
 715   __jit_debug_descriptor.action_flag = GDBJIT_REGISTER;
 716   __jit_debug_register_code();
 717 }
 718
 719 /* Add debug info for newly compiled trace and notify GDB. */
 720 void lj_gdbjit_addtrace(jit_State *J, GCtrace *T)
 721 {
 722   GDBJITctx ctx;
 723   GCproto *pt = &gcref(T->startpt)->pt;
 724   TraceNo parent = T->ir[REF_BASE].op1;
 725   const BCIns *startpc = mref(T->startpc, const BCIns);
 726   ctx.T = T;
 727   ctx.mcaddr = (uintptr_t)T->mcode;
 728   ctx.szmcode = T->szmcode;
 729   ctx.spadjp = CFRAME_SIZE_JIT +
 730                (MSize)(parent ? traceref(J, parent)->spadjust : 0);
 731   ctx.spadj = CFRAME_SIZE_JIT + T->spadjust;
 732   lua_assert(startpc >= proto_bc(pt) && startpc < proto_bc(pt) + pt->sizebc);
 733   ctx.lineno = lj_debug_line(pt, proto_bcpos(pt, startpc));
 734   ctx.filename = proto_chunknamestr(pt);
 735   if (*ctx.filename == '@' || *ctx.filename == '=')
 736     ctx.filename++;
 737   else
 738     ctx.filename = "(string)";
 739   gdbjit_buildobj(&ctx);
 740   gdbjit_newentry(J->L, &ctx);
 741 }
 742
 743 /* Delete debug info for trace and notify GDB. */
 744 void lj_gdbjit_deltrace(jit_State *J, GCtrace *T)
 745 {
 746   GDBJITentryobj *eo = (GDBJITentryobj *)T->gdbjit_entry;
 747   if (eo) {
 748     if (eo->entry.prev_entry)
 749       eo->entry.prev_entry->next_entry = eo->entry.next_entry;
 750     else
 751       __jit_debug_descriptor.first_entry = eo->entry.next_entry;
 752     if (eo->entry.next_entry)
 753       eo->entry.next_entry->prev_entry = eo->entry.prev_entry;
 754     __jit_debug_descriptor.relevant_entry = &eo->entry;
 755     __jit_debug_descriptor.action_flag = GDBJIT_UNREGISTER;
 756     __jit_debug_register_code();
 757     lj_mem_free(J2G(J), eo, eo->sz);
 758   }
 759 }
 760
 761 #endif
 762 #endif