lj_gdbjit.c (21787B)
1 /* 2 ** Client for the GDB JIT API. 3 ** Copyright (C) 2005-2016 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_buf.h" 18 #include "lj_strfmt.h" 19 #include "lj_jit.h" 20 #include "lj_dispatch.h" 21 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 26 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 ** ------------------------------------------------------------------------ 61 62 $ cat >x.lua 63 for outer=1,100 do 64 for inner=1,100 do end 65 end 66 ^D 67 68 $ luajit -jv x.lua 69 [TRACE 1 x.lua:2] 70 [TRACE 2 (1/3) x.lua:1 -> 1] 71 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 78 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. 102 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) 116 117 ** ------------------------------------------------------------------------ 118 */ 119 120 /* -- GDB JIT API --------------------------------------------------------- */ 121 122 /* GDB JIT actions. */ 123 enum { 124 GDBJIT_NOACTION = 0, 125 GDBJIT_REGISTER, 126 GDBJIT_UNREGISTER 127 }; 128 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; 136 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; 144 145 GDBJITdesc __jit_debug_descriptor = { 146 1, GDBJIT_NOACTION, NULL, NULL 147 }; 148 149 /* GDB sets a breakpoint at this function. */ 150 void LJ_NOINLINE __jit_debug_register_code() 151 { 152 __asm__ __volatile__(""); 153 }; 154 155 /* -- In-memory ELF object definitions ------------------------------------ */ 156 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; 180 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; 193 194 #define ELFSECT_IDX_ABS 0xfff1 195 196 enum { 197 ELFSECT_TYPE_PROGBITS = 1, 198 ELFSECT_TYPE_SYMTAB = 2, 199 ELFSECT_TYPE_STRTAB = 3, 200 ELFSECT_TYPE_NOBITS = 8 201 }; 202 203 #define ELFSECT_FLAGS_WRITE 1 204 #define ELFSECT_FLAGS_ALLOC 2 205 #define ELFSECT_FLAGS_EXEC 4 206 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; 224 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 }; 231 232 /* DWARF definitions. */ 233 #define DW_CIE_VERSION 1 234 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 }; 244 245 enum { 246 DW_EH_PE_udata4 = 3, 247 DW_EH_PE_textrel = 0x20 248 }; 249 250 enum { 251 DW_TAG_compile_unit = 0x11 252 }; 253 254 enum { 255 DW_children_no = 0, 256 DW_children_yes = 1 257 }; 258 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 }; 265 266 enum { 267 DW_FORM_addr = 0x01, 268 DW_FORM_data4 = 0x06, 269 DW_FORM_string = 0x08 270 }; 271 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 }; 278 279 enum { 280 DW_LNE_end_sequence = 1, 281 DW_LNE_set_address = 2 282 }; 283 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 }; 310 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 }; 324 325 enum { 326 GDBJIT_SYM_UNDEF, 327 GDBJIT_SYM_FILE, 328 GDBJIT_SYM_FUNC, 329 GDBJIT_SYM__MAX 330 }; 331 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; 339 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; 346 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 }; 396 397 /* -- In-memory ELF object generation ------------------------------------- */ 398 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; 413 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 } 425 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 } 432 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 } 442 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); } \ 456 457 /* Initialize ELF section headers. */ 458 static void LJ_FASTCALL gdbjit_secthdr(GDBJITctx *ctx) 459 { 460 ELFsectheader *sect; 461 462 *ctx->p++ = '\0'; /* Empty string at start of string table. */ 463 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) 469 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; 475 476 SECTDEF(eh_frame, PROGBITS, sizeof(uintptr_t)); 477 sect->flags = ELFSECT_FLAGS_ALLOC; 478 479 SECTDEF(shstrtab, STRTAB, 1); 480 SECTDEF(strtab, STRTAB, 1); 481 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; 488 489 SECTDEF(debug_info, PROGBITS, 1); 490 SECTDEF(debug_abbrev, PROGBITS, 1); 491 SECTDEF(debug_line, PROGBITS, 1); 492 493 #undef SECTDEF 494 } 495 496 /* Initialize symbol table. */ 497 static void LJ_FASTCALL gdbjit_symtab(GDBJITctx *ctx) 498 { 499 ELFsymbol *sym; 500 501 *ctx->p++ = '\0'; /* Empty string at start of string table. */ 502 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; 507 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 } 516 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; 522 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 ) 540 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(LJ_GC64 ? 10 : 9); 560 DB(DW_CFA_offset|DW_REG_12); DUV(LJ_GC64 ? 11 : 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 ) 592 593 ctx->p = p; 594 } 595 596 /* Initialize .debug_info section. */ 597 static void LJ_FASTCALL gdbjit_debuginfo(GDBJITctx *ctx) 598 { 599 uint8_t *p = ctx->p; 600 601 DSECT(info, 602 DU16(2); /* DWARF version. */ 603 DU32(0); /* Abbrev offset. */ 604 DB(sizeof(uintptr_t)); /* Pointer size. */ 605 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 ) 612 613 ctx->p = p; 614 } 615 616 /* Initialize .debug_abbrev section. */ 617 static void LJ_FASTCALL gdbjit_debugabbrev(GDBJITctx *ctx) 618 { 619 uint8_t *p = ctx->p; 620 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); 629 630 ctx->p = p; 631 } 632 633 #define DLNE(op, s) (DB(DW_LNS_extended_op), DUV(1+(s)), DB((op))) 634 635 /* Initialize .debug_line section. */ 636 static void LJ_FASTCALL gdbjit_debugline(GDBJITctx *ctx) 637 { 638 uint8_t *p = ctx->p; 639 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 ) 655 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 ) 664 665 ctx->p = p; 666 } 667 668 #undef DLNE 669 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 681 682 /* Type of a section initializer callback. */ 683 typedef void (LJ_FASTCALL *GDBJITinitf)(GDBJITctx *ctx); 684 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 } 693 694 #define SECTALIGN(p, a) \ 695 ((p) = (uint8_t *)(((uintptr_t)(p) + ((a)-1)) & ~(uintptr_t)((a)-1))) 696 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 } 717 718 #undef SECTALIGN 719 720 /* -- Interface to GDB JIT API -------------------------------------------- */ 721 722 static int gdbjit_lock; 723 724 static void gdbjit_lock_acquire() 725 { 726 while (__sync_lock_test_and_set(&gdbjit_lock, 1)) { 727 /* Just spin; futexes or pthreads aren't worth the portability cost. */ 728 } 729 } 730 731 static void gdbjit_lock_release() 732 { 733 __sync_lock_release(&gdbjit_lock); 734 } 735 736 /* Add new entry to GDB JIT symbol chain. */ 737 static void gdbjit_newentry(lua_State *L, GDBJITctx *ctx) 738 { 739 /* Allocate memory for GDB JIT entry and ELF object. */ 740 MSize sz = (MSize)(sizeof(GDBJITentryobj) - sizeof(GDBJITobj) + ctx->objsize); 741 GDBJITentryobj *eo = lj_mem_newt(L, sz, GDBJITentryobj); 742 memcpy(&eo->obj, &ctx->obj, ctx->objsize); /* Copy ELF object. */ 743 eo->sz = sz; 744 ctx->T->gdbjit_entry = (void *)eo; 745 /* Link new entry to chain and register it. */ 746 eo->entry.prev_entry = NULL; 747 gdbjit_lock_acquire(); 748 eo->entry.next_entry = __jit_debug_descriptor.first_entry; 749 if (eo->entry.next_entry) 750 eo->entry.next_entry->prev_entry = &eo->entry; 751 eo->entry.symfile_addr = (const char *)&eo->obj; 752 eo->entry.symfile_size = ctx->objsize; 753 __jit_debug_descriptor.first_entry = &eo->entry; 754 __jit_debug_descriptor.relevant_entry = &eo->entry; 755 __jit_debug_descriptor.action_flag = GDBJIT_REGISTER; 756 __jit_debug_register_code(); 757 gdbjit_lock_release(); 758 } 759 760 /* Add debug info for newly compiled trace and notify GDB. */ 761 void lj_gdbjit_addtrace(jit_State *J, GCtrace *T) 762 { 763 GDBJITctx ctx; 764 GCproto *pt = &gcref(T->startpt)->pt; 765 TraceNo parent = T->ir[REF_BASE].op1; 766 const BCIns *startpc = mref(T->startpc, const BCIns); 767 ctx.T = T; 768 ctx.mcaddr = (uintptr_t)T->mcode; 769 ctx.szmcode = T->szmcode; 770 ctx.spadjp = CFRAME_SIZE_JIT + 771 (MSize)(parent ? traceref(J, parent)->spadjust : 0); 772 ctx.spadj = CFRAME_SIZE_JIT + T->spadjust; 773 lua_assert(startpc >= proto_bc(pt) && startpc < proto_bc(pt) + pt->sizebc); 774 ctx.lineno = lj_debug_line(pt, proto_bcpos(pt, startpc)); 775 ctx.filename = proto_chunknamestr(pt); 776 if (*ctx.filename == '@' || *ctx.filename == '=') 777 ctx.filename++; 778 else 779 ctx.filename = "(string)"; 780 gdbjit_buildobj(&ctx); 781 gdbjit_newentry(J->L, &ctx); 782 } 783 784 /* Delete debug info for trace and notify GDB. */ 785 void lj_gdbjit_deltrace(jit_State *J, GCtrace *T) 786 { 787 GDBJITentryobj *eo = (GDBJITentryobj *)T->gdbjit_entry; 788 if (eo) { 789 gdbjit_lock_acquire(); 790 if (eo->entry.prev_entry) 791 eo->entry.prev_entry->next_entry = eo->entry.next_entry; 792 else 793 __jit_debug_descriptor.first_entry = eo->entry.next_entry; 794 if (eo->entry.next_entry) 795 eo->entry.next_entry->prev_entry = eo->entry.prev_entry; 796 __jit_debug_descriptor.relevant_entry = &eo->entry; 797 __jit_debug_descriptor.action_flag = GDBJIT_UNREGISTER; 798 __jit_debug_register_code(); 799 gdbjit_lock_release(); 800 lj_mem_free(J2G(J), eo, eo->sz); 801 } 802 } 803 804 #endif 805 #endif