1 /* Handle JIT code generation in the inferior for GDB, the GNU Debugger. 2 3 Copyright (C) 2009-2012 Free Software Foundation, Inc. 4 5 This file is part of GDB. 6 7 This program is free software; you can redistribute it and/or modify 8 it under the terms of the GNU General Public License as published by 9 the Free Software Foundation; either version 3 of the License, or 10 (at your option) any later version. 11 12 This program is distributed in the hope that it will be useful, 13 but WITHOUT ANY WARRANTY; without even the implied warranty of 14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 GNU General Public License for more details. 16 17 You should have received a copy of the GNU General Public License 18 along with this program. If not, see <http://www.gnu.org/licenses/>. */ 19 20 #include "defs.h" 21 22 #include "jit.h" 23 #include "jit-reader.h" 24 #include "block.h" 25 #include "breakpoint.h" 26 #include "command.h" 27 #include "dictionary.h" 28 #include "frame-unwind.h" 29 #include "gdbcmd.h" 30 #include "gdbcore.h" 31 #include "inferior.h" 32 #include "observer.h" 33 #include "objfiles.h" 34 #include "regcache.h" 35 #include "symfile.h" 36 #include "symtab.h" 37 #include "target.h" 38 #include "gdb-dlfcn.h" 39 #include "gdb_stat.h" 40 #include "exceptions.h" 41 42 static const char *jit_reader_dir = NULL; 43 44 static const struct objfile_data *jit_objfile_data; 45 46 static const char *const jit_break_name = "__jit_debug_register_code"; 47 48 static const char *const jit_descriptor_name = "__jit_debug_descriptor"; 49 50 static const struct inferior_data *jit_inferior_data = NULL; 51 52 static void jit_inferior_init (struct gdbarch *gdbarch); 53 54 /* An unwinder is registered for every gdbarch. This key is used to 55 remember if the unwinder has been registered for a particular 56 gdbarch. */ 57 58 static struct gdbarch_data *jit_gdbarch_data; 59 60 /* Non-zero if we want to see trace of jit level stuff. */ 61 62 static int jit_debug = 0; 63 64 static void 65 show_jit_debug (struct ui_file *file, int from_tty, 66 struct cmd_list_element *c, const char *value) 67 { 68 fprintf_filtered (file, _("JIT debugging is %s.\n"), value); 69 } 70 71 struct target_buffer 72 { 73 CORE_ADDR base; 74 ULONGEST size; 75 }; 76 77 /* Openning the file is a no-op. */ 78 79 static void * 80 mem_bfd_iovec_open (struct bfd *abfd, void *open_closure) 81 { 82 return open_closure; 83 } 84 85 /* Closing the file is just freeing the base/size pair on our side. */ 86 87 static int 88 mem_bfd_iovec_close (struct bfd *abfd, void *stream) 89 { 90 xfree (stream); 91 return 1; 92 } 93 94 /* For reading the file, we just need to pass through to target_read_memory and 95 fix up the arguments and return values. */ 96 97 static file_ptr 98 mem_bfd_iovec_pread (struct bfd *abfd, void *stream, void *buf, 99 file_ptr nbytes, file_ptr offset) 100 { 101 int err; 102 struct target_buffer *buffer = (struct target_buffer *) stream; 103 104 /* If this read will read all of the file, limit it to just the rest. */ 105 if (offset + nbytes > buffer->size) 106 nbytes = buffer->size - offset; 107 108 /* If there are no more bytes left, we've reached EOF. */ 109 if (nbytes == 0) 110 return 0; 111 112 err = target_read_memory (buffer->base + offset, (gdb_byte *) buf, nbytes); 113 if (err) 114 return -1; 115 116 return nbytes; 117 } 118 119 /* For statting the file, we only support the st_size attribute. */ 120 121 static int 122 mem_bfd_iovec_stat (struct bfd *abfd, void *stream, struct stat *sb) 123 { 124 struct target_buffer *buffer = (struct target_buffer*) stream; 125 126 sb->st_size = buffer->size; 127 return 0; 128 } 129 130 /* One reader that has been loaded successfully, and can potentially be used to 131 parse debug info. */ 132 133 static struct jit_reader 134 { 135 struct gdb_reader_funcs *functions; 136 void *handle; 137 } *loaded_jit_reader = NULL; 138 139 typedef struct gdb_reader_funcs * (reader_init_fn_type) (void); 140 static const char *reader_init_fn_sym = "gdb_init_reader"; 141 142 /* Try to load FILE_NAME as a JIT debug info reader. */ 143 144 static struct jit_reader * 145 jit_reader_load (const char *file_name) 146 { 147 void *so; 148 reader_init_fn_type *init_fn; 149 struct jit_reader *new_reader = NULL; 150 struct gdb_reader_funcs *funcs = NULL; 151 struct cleanup *old_cleanups; 152 153 if (jit_debug) 154 fprintf_unfiltered (gdb_stdlog, _("Opening shared object %s.\n"), 155 file_name); 156 so = gdb_dlopen (file_name); 157 old_cleanups = make_cleanup_dlclose (so); 158 159 init_fn = gdb_dlsym (so, reader_init_fn_sym); 160 if (!init_fn) 161 error (_("Could not locate initialization function: %s."), 162 reader_init_fn_sym); 163 164 if (gdb_dlsym (so, "plugin_is_GPL_compatible") == NULL) 165 error (_("Reader not GPL compatible.")); 166 167 funcs = init_fn (); 168 if (funcs->reader_version != GDB_READER_INTERFACE_VERSION) 169 error (_("Reader version does not match GDB version.")); 170 171 new_reader = XZALLOC (struct jit_reader); 172 new_reader->functions = funcs; 173 new_reader->handle = so; 174 175 discard_cleanups (old_cleanups); 176 return new_reader; 177 } 178 179 /* Provides the jit-reader-load command. */ 180 181 static void 182 jit_reader_load_command (char *args, int from_tty) 183 { 184 char *so_name; 185 int len; 186 struct cleanup *prev_cleanup; 187 188 if (args == NULL) 189 error (_("No reader name provided.")); 190 191 if (loaded_jit_reader != NULL) 192 error (_("JIT reader already loaded. Run jit-reader-unload first.")); 193 194 so_name = xstrprintf ("%s/%s", jit_reader_dir, args); 195 prev_cleanup = make_cleanup (xfree, so_name); 196 197 loaded_jit_reader = jit_reader_load (so_name); 198 do_cleanups (prev_cleanup); 199 } 200 201 /* Provides the jit-reader-unload command. */ 202 203 static void 204 jit_reader_unload_command (char *args, int from_tty) 205 { 206 if (!loaded_jit_reader) 207 error (_("No JIT reader loaded.")); 208 209 loaded_jit_reader->functions->destroy (loaded_jit_reader->functions); 210 211 gdb_dlclose (loaded_jit_reader->handle); 212 xfree (loaded_jit_reader); 213 loaded_jit_reader = NULL; 214 } 215 216 /* Open a BFD from the target's memory. */ 217 218 static struct bfd * 219 bfd_open_from_target_memory (CORE_ADDR addr, ULONGEST size, char *target) 220 { 221 const char *filename = xstrdup ("<in-memory>"); 222 struct target_buffer *buffer = xmalloc (sizeof (struct target_buffer)); 223 224 buffer->base = addr; 225 buffer->size = size; 226 return bfd_openr_iovec (filename, target, 227 mem_bfd_iovec_open, 228 buffer, 229 mem_bfd_iovec_pread, 230 mem_bfd_iovec_close, 231 mem_bfd_iovec_stat); 232 } 233 234 /* Per-inferior structure recording the addresses in the inferior. */ 235 236 struct jit_inferior_data 237 { 238 CORE_ADDR breakpoint_addr; /* &__jit_debug_register_code() */ 239 CORE_ADDR descriptor_addr; /* &__jit_debug_descriptor */ 240 }; 241 242 /* Remember OBJFILE has been created for struct jit_code_entry located 243 at inferior address ENTRY. */ 244 245 static void 246 add_objfile_entry (struct objfile *objfile, CORE_ADDR entry) 247 { 248 CORE_ADDR *entry_addr_ptr; 249 250 entry_addr_ptr = xmalloc (sizeof (CORE_ADDR)); 251 *entry_addr_ptr = entry; 252 set_objfile_data (objfile, jit_objfile_data, entry_addr_ptr); 253 } 254 255 /* Return jit_inferior_data for current inferior. Allocate if not already 256 present. */ 257 258 static struct jit_inferior_data * 259 get_jit_inferior_data (void) 260 { 261 struct inferior *inf; 262 struct jit_inferior_data *inf_data; 263 264 inf = current_inferior (); 265 inf_data = inferior_data (inf, jit_inferior_data); 266 if (inf_data == NULL) 267 { 268 inf_data = XZALLOC (struct jit_inferior_data); 269 set_inferior_data (inf, jit_inferior_data, inf_data); 270 } 271 272 return inf_data; 273 } 274 275 static void 276 jit_inferior_data_cleanup (struct inferior *inf, void *arg) 277 { 278 xfree (arg); 279 } 280 281 /* Helper function for reading the global JIT descriptor from remote 282 memory. */ 283 284 static void 285 jit_read_descriptor (struct gdbarch *gdbarch, 286 struct jit_descriptor *descriptor, 287 CORE_ADDR descriptor_addr) 288 { 289 int err; 290 struct type *ptr_type; 291 int ptr_size; 292 int desc_size; 293 gdb_byte *desc_buf; 294 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); 295 296 /* Figure out how big the descriptor is on the remote and how to read it. */ 297 ptr_type = builtin_type (gdbarch)->builtin_data_ptr; 298 ptr_size = TYPE_LENGTH (ptr_type); 299 desc_size = 8 + 2 * ptr_size; /* Two 32-bit ints and two pointers. */ 300 desc_buf = alloca (desc_size); 301 302 /* Read the descriptor. */ 303 err = target_read_memory (descriptor_addr, desc_buf, desc_size); 304 if (err) 305 error (_("Unable to read JIT descriptor from remote memory!")); 306 307 /* Fix the endianness to match the host. */ 308 descriptor->version = extract_unsigned_integer (&desc_buf[0], 4, byte_order); 309 descriptor->action_flag = 310 extract_unsigned_integer (&desc_buf[4], 4, byte_order); 311 descriptor->relevant_entry = extract_typed_address (&desc_buf[8], ptr_type); 312 descriptor->first_entry = 313 extract_typed_address (&desc_buf[8 + ptr_size], ptr_type); 314 } 315 316 /* Helper function for reading a JITed code entry from remote memory. */ 317 318 static void 319 jit_read_code_entry (struct gdbarch *gdbarch, 320 CORE_ADDR code_addr, struct jit_code_entry *code_entry) 321 { 322 int err, off; 323 struct type *ptr_type; 324 int ptr_size; 325 int entry_size; 326 int align_bytes; 327 gdb_byte *entry_buf; 328 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); 329 330 /* Figure out how big the entry is on the remote and how to read it. */ 331 ptr_type = builtin_type (gdbarch)->builtin_data_ptr; 332 ptr_size = TYPE_LENGTH (ptr_type); 333 entry_size = 3 * ptr_size + 8; /* Three pointers and one 64-bit int. */ 334 entry_buf = alloca (entry_size); 335 336 /* Read the entry. */ 337 err = target_read_memory (code_addr, entry_buf, entry_size); 338 if (err) 339 error (_("Unable to read JIT code entry from remote memory!")); 340 341 /* Fix the endianness to match the host. */ 342 ptr_type = builtin_type (gdbarch)->builtin_data_ptr; 343 code_entry->next_entry = extract_typed_address (&entry_buf[0], ptr_type); 344 code_entry->prev_entry = 345 extract_typed_address (&entry_buf[ptr_size], ptr_type); 346 code_entry->symfile_addr = 347 extract_typed_address (&entry_buf[2 * ptr_size], ptr_type); 348 349 align_bytes = gdbarch_long_long_align_bit (gdbarch) / 8; 350 off = 3 * ptr_size; 351 off = (off + (align_bytes - 1)) & ~(align_bytes - 1); 352 353 code_entry->symfile_size = 354 extract_unsigned_integer (&entry_buf[off], 8, byte_order); 355 } 356 357 /* Proxy object for building a block. */ 358 359 struct gdb_block 360 { 361 /* gdb_blocks are linked into a tree structure. Next points to the 362 next node at the same depth as this block and parent to the 363 parent gdb_block. */ 364 struct gdb_block *next, *parent; 365 366 /* Points to the "real" block that is being built out of this 367 instance. This block will be added to a blockvector, which will 368 then be added to a symtab. */ 369 struct block *real_block; 370 371 /* The first and last code address corresponding to this block. */ 372 CORE_ADDR begin, end; 373 374 /* The name of this block (if any). If this is non-NULL, the 375 FUNCTION symbol symbol is set to this value. */ 376 const char *name; 377 }; 378 379 /* Proxy object for building a symtab. */ 380 381 struct gdb_symtab 382 { 383 /* The list of blocks in this symtab. These will eventually be 384 converted to real blocks. */ 385 struct gdb_block *blocks; 386 387 /* The number of blocks inserted. */ 388 int nblocks; 389 390 /* A mapping between line numbers to PC. */ 391 struct linetable *linetable; 392 393 /* The source file for this symtab. */ 394 const char *file_name; 395 struct gdb_symtab *next; 396 }; 397 398 /* Proxy object for building an object. */ 399 400 struct gdb_object 401 { 402 struct gdb_symtab *symtabs; 403 }; 404 405 /* The type of the `private' data passed around by the callback 406 functions. */ 407 408 typedef CORE_ADDR jit_dbg_reader_data; 409 410 /* The reader calls into this function to read data off the targets 411 address space. */ 412 413 static enum gdb_status 414 jit_target_read_impl (GDB_CORE_ADDR target_mem, void *gdb_buf, int len) 415 { 416 int result = target_read_memory ((CORE_ADDR) target_mem, gdb_buf, len); 417 if (result == 0) 418 return GDB_SUCCESS; 419 else 420 return GDB_FAIL; 421 } 422 423 /* The reader calls into this function to create a new gdb_object 424 which it can then pass around to the other callbacks. Right now, 425 all that is required is allocating the memory. */ 426 427 static struct gdb_object * 428 jit_object_open_impl (struct gdb_symbol_callbacks *cb) 429 { 430 /* CB is not required right now, but sometime in the future we might 431 need a handle to it, and we'd like to do that without breaking 432 the ABI. */ 433 return XZALLOC (struct gdb_object); 434 } 435 436 /* Readers call into this function to open a new gdb_symtab, which, 437 again, is passed around to other callbacks. */ 438 439 static struct gdb_symtab * 440 jit_symtab_open_impl (struct gdb_symbol_callbacks *cb, 441 struct gdb_object *object, 442 const char *file_name) 443 { 444 struct gdb_symtab *ret; 445 446 /* CB stays unused. See comment in jit_object_open_impl. */ 447 448 ret = XZALLOC (struct gdb_symtab); 449 ret->file_name = file_name ? xstrdup (file_name) : xstrdup (""); 450 ret->next = object->symtabs; 451 object->symtabs = ret; 452 return ret; 453 } 454 455 /* Returns true if the block corresponding to old should be placed 456 before the block corresponding to new in the final blockvector. */ 457 458 static int 459 compare_block (const struct gdb_block *const old, 460 const struct gdb_block *const new) 461 { 462 if (old == NULL) 463 return 1; 464 if (old->begin < new->begin) 465 return 1; 466 else if (old->begin == new->begin) 467 { 468 if (old->end > new->end) 469 return 1; 470 else 471 return 0; 472 } 473 else 474 return 0; 475 } 476 477 /* Called by readers to open a new gdb_block. This function also 478 inserts the new gdb_block in the correct place in the corresponding 479 gdb_symtab. */ 480 481 static struct gdb_block * 482 jit_block_open_impl (struct gdb_symbol_callbacks *cb, 483 struct gdb_symtab *symtab, struct gdb_block *parent, 484 GDB_CORE_ADDR begin, GDB_CORE_ADDR end, const char *name) 485 { 486 struct gdb_block *block = XZALLOC (struct gdb_block); 487 488 block->next = symtab->blocks; 489 block->begin = (CORE_ADDR) begin; 490 block->end = (CORE_ADDR) end; 491 block->name = name ? xstrdup (name) : NULL; 492 block->parent = parent; 493 494 /* Ensure that the blocks are inserted in the correct (reverse of 495 the order expected by blockvector). */ 496 if (compare_block (symtab->blocks, block)) 497 { 498 symtab->blocks = block; 499 } 500 else 501 { 502 struct gdb_block *i = symtab->blocks; 503 504 for (;; i = i->next) 505 { 506 /* Guaranteed to terminate, since compare_block (NULL, _) 507 returns 1. */ 508 if (compare_block (i->next, block)) 509 { 510 block->next = i->next; 511 i->next = block; 512 break; 513 } 514 } 515 } 516 symtab->nblocks++; 517 518 return block; 519 } 520 521 /* Readers call this to add a line mapping (from PC to line number) to 522 a gdb_symtab. */ 523 524 static void 525 jit_symtab_line_mapping_add_impl (struct gdb_symbol_callbacks *cb, 526 struct gdb_symtab *stab, int nlines, 527 struct gdb_line_mapping *map) 528 { 529 int i; 530 531 if (nlines < 1) 532 return; 533 534 stab->linetable = xmalloc (sizeof (struct linetable) 535 + (nlines - 1) * sizeof (struct linetable_entry)); 536 stab->linetable->nitems = nlines; 537 for (i = 0; i < nlines; i++) 538 { 539 stab->linetable->item[i].pc = (CORE_ADDR) map[i].pc; 540 stab->linetable->item[i].line = map[i].line; 541 } 542 } 543 544 /* Called by readers to close a gdb_symtab. Does not need to do 545 anything as of now. */ 546 547 static void 548 jit_symtab_close_impl (struct gdb_symbol_callbacks *cb, 549 struct gdb_symtab *stab) 550 { 551 /* Right now nothing needs to be done here. We may need to do some 552 cleanup here in the future (again, without breaking the plugin 553 ABI). */ 554 } 555 556 /* Transform STAB to a proper symtab, and add it it OBJFILE. */ 557 558 static void 559 finalize_symtab (struct gdb_symtab *stab, struct objfile *objfile) 560 { 561 struct symtab *symtab; 562 struct gdb_block *gdb_block_iter, *gdb_block_iter_tmp; 563 struct block *block_iter; 564 int actual_nblocks, i, blockvector_size; 565 CORE_ADDR begin, end; 566 567 actual_nblocks = FIRST_LOCAL_BLOCK + stab->nblocks; 568 569 symtab = allocate_symtab (stab->file_name, objfile); 570 /* JIT compilers compile in memory. */ 571 symtab->dirname = NULL; 572 573 /* Copy over the linetable entry if one was provided. */ 574 if (stab->linetable) 575 { 576 int size = ((stab->linetable->nitems - 1) 577 * sizeof (struct linetable_entry) 578 + sizeof (struct linetable)); 579 LINETABLE (symtab) = obstack_alloc (&objfile->objfile_obstack, size); 580 memcpy (LINETABLE (symtab), stab->linetable, size); 581 } 582 else 583 { 584 LINETABLE (symtab) = NULL; 585 } 586 587 blockvector_size = (sizeof (struct blockvector) 588 + (actual_nblocks - 1) * sizeof (struct block *)); 589 symtab->blockvector = obstack_alloc (&objfile->objfile_obstack, 590 blockvector_size); 591 592 /* (begin, end) will contain the PC range this entire blockvector 593 spans. */ 594 symtab->primary = 1; 595 BLOCKVECTOR_MAP (symtab->blockvector) = NULL; 596 begin = stab->blocks->begin; 597 end = stab->blocks->end; 598 BLOCKVECTOR_NBLOCKS (symtab->blockvector) = actual_nblocks; 599 600 /* First run over all the gdb_block objects, creating a real block 601 object for each. Simultaneously, keep setting the real_block 602 fields. */ 603 for (i = (actual_nblocks - 1), gdb_block_iter = stab->blocks; 604 i >= FIRST_LOCAL_BLOCK; 605 i--, gdb_block_iter = gdb_block_iter->next) 606 { 607 struct block *new_block = allocate_block (&objfile->objfile_obstack); 608 struct symbol *block_name = obstack_alloc (&objfile->objfile_obstack, 609 sizeof (struct symbol)); 610 611 BLOCK_DICT (new_block) = dict_create_linear (&objfile->objfile_obstack, 612 NULL); 613 /* The address range. */ 614 BLOCK_START (new_block) = (CORE_ADDR) gdb_block_iter->begin; 615 BLOCK_END (new_block) = (CORE_ADDR) gdb_block_iter->end; 616 617 /* The name. */ 618 memset (block_name, 0, sizeof (struct symbol)); 619 SYMBOL_DOMAIN (block_name) = VAR_DOMAIN; 620 SYMBOL_CLASS (block_name) = LOC_BLOCK; 621 SYMBOL_SYMTAB (block_name) = symtab; 622 SYMBOL_BLOCK_VALUE (block_name) = new_block; 623 624 block_name->ginfo.name = obsavestring (gdb_block_iter->name, 625 strlen (gdb_block_iter->name), 626 &objfile->objfile_obstack); 627 628 BLOCK_FUNCTION (new_block) = block_name; 629 630 BLOCKVECTOR_BLOCK (symtab->blockvector, i) = new_block; 631 if (begin > BLOCK_START (new_block)) 632 begin = BLOCK_START (new_block); 633 if (end < BLOCK_END (new_block)) 634 end = BLOCK_END (new_block); 635 636 gdb_block_iter->real_block = new_block; 637 } 638 639 /* Now add the special blocks. */ 640 block_iter = NULL; 641 for (i = 0; i < FIRST_LOCAL_BLOCK; i++) 642 { 643 struct block *new_block = allocate_block (&objfile->objfile_obstack); 644 BLOCK_DICT (new_block) = dict_create_linear (&objfile->objfile_obstack, 645 NULL); 646 BLOCK_SUPERBLOCK (new_block) = block_iter; 647 block_iter = new_block; 648 649 BLOCK_START (new_block) = (CORE_ADDR) begin; 650 BLOCK_END (new_block) = (CORE_ADDR) end; 651 652 BLOCKVECTOR_BLOCK (symtab->blockvector, i) = new_block; 653 } 654 655 /* Fill up the superblock fields for the real blocks, using the 656 real_block fields populated earlier. */ 657 for (gdb_block_iter = stab->blocks; 658 gdb_block_iter; 659 gdb_block_iter = gdb_block_iter->next) 660 { 661 if (gdb_block_iter->parent != NULL) 662 BLOCK_SUPERBLOCK (gdb_block_iter->real_block) = 663 gdb_block_iter->parent->real_block; 664 } 665 666 /* Free memory. */ 667 gdb_block_iter = stab->blocks; 668 669 for (gdb_block_iter = stab->blocks, gdb_block_iter_tmp = gdb_block_iter->next; 670 gdb_block_iter; 671 gdb_block_iter = gdb_block_iter_tmp) 672 { 673 xfree ((void *) gdb_block_iter->name); 674 xfree (gdb_block_iter); 675 } 676 xfree (stab->linetable); 677 xfree ((char *) stab->file_name); 678 xfree (stab); 679 } 680 681 /* Called when closing a gdb_objfile. Converts OBJ to a proper 682 objfile. */ 683 684 static void 685 jit_object_close_impl (struct gdb_symbol_callbacks *cb, 686 struct gdb_object *obj) 687 { 688 struct gdb_symtab *i, *j; 689 struct objfile *objfile; 690 jit_dbg_reader_data *priv_data; 691 692 priv_data = cb->priv_data; 693 694 objfile = allocate_objfile (NULL, 0); 695 objfile->gdbarch = target_gdbarch; 696 697 objfile->msymbols = obstack_alloc (&objfile->objfile_obstack, 698 sizeof (struct minimal_symbol)); 699 memset (objfile->msymbols, 0, sizeof (struct minimal_symbol)); 700 701 xfree (objfile->name); 702 objfile->name = xstrdup ("<< JIT compiled code >>"); 703 704 j = NULL; 705 for (i = obj->symtabs; i; i = j) 706 { 707 j = i->next; 708 finalize_symtab (i, objfile); 709 } 710 add_objfile_entry (objfile, *priv_data); 711 xfree (obj); 712 } 713 714 /* Try to read CODE_ENTRY using the loaded jit reader (if any). 715 ENTRY_ADDR is the address of the struct jit_code_entry in the 716 inferior address space. */ 717 718 static int 719 jit_reader_try_read_symtab (struct jit_code_entry *code_entry, 720 CORE_ADDR entry_addr) 721 { 722 void *gdb_mem; 723 int status; 724 struct jit_dbg_reader *i; 725 jit_dbg_reader_data priv_data; 726 struct gdb_reader_funcs *funcs; 727 volatile struct gdb_exception e; 728 struct gdb_symbol_callbacks callbacks = 729 { 730 jit_object_open_impl, 731 jit_symtab_open_impl, 732 jit_block_open_impl, 733 jit_symtab_close_impl, 734 jit_object_close_impl, 735 736 jit_symtab_line_mapping_add_impl, 737 jit_target_read_impl, 738 739 &priv_data 740 }; 741 742 priv_data = entry_addr; 743 744 if (!loaded_jit_reader) 745 return 0; 746 747 gdb_mem = xmalloc (code_entry->symfile_size); 748 749 status = 1; 750 TRY_CATCH (e, RETURN_MASK_ALL) 751 if (target_read_memory (code_entry->symfile_addr, gdb_mem, 752 code_entry->symfile_size)) 753 status = 0; 754 if (e.reason < 0) 755 status = 0; 756 757 if (status) 758 { 759 funcs = loaded_jit_reader->functions; 760 if (funcs->read (funcs, &callbacks, gdb_mem, code_entry->symfile_size) 761 != GDB_SUCCESS) 762 status = 0; 763 } 764 765 xfree (gdb_mem); 766 if (jit_debug && status == 0) 767 fprintf_unfiltered (gdb_stdlog, 768 "Could not read symtab using the loaded JIT reader.\n"); 769 return status; 770 } 771 772 /* Try to read CODE_ENTRY using BFD. ENTRY_ADDR is the address of the 773 struct jit_code_entry in the inferior address space. */ 774 775 static void 776 jit_bfd_try_read_symtab (struct jit_code_entry *code_entry, 777 CORE_ADDR entry_addr, 778 struct gdbarch *gdbarch) 779 { 780 bfd *nbfd; 781 struct section_addr_info *sai; 782 struct bfd_section *sec; 783 struct objfile *objfile; 784 struct cleanup *old_cleanups; 785 int i; 786 const struct bfd_arch_info *b; 787 788 if (jit_debug) 789 fprintf_unfiltered (gdb_stdlog, 790 "jit_register_code, symfile_addr = %s, " 791 "symfile_size = %s\n", 792 paddress (gdbarch, code_entry->symfile_addr), 793 pulongest (code_entry->symfile_size)); 794 795 nbfd = bfd_open_from_target_memory (code_entry->symfile_addr, 796 code_entry->symfile_size, gnutarget); 797 if (nbfd == NULL) 798 { 799 puts_unfiltered (_("Error opening JITed symbol file, ignoring it.\n")); 800 return; 801 } 802 803 /* Check the format. NOTE: This initializes important data that GDB uses! 804 We would segfault later without this line. */ 805 if (!bfd_check_format (nbfd, bfd_object)) 806 { 807 printf_unfiltered (_("\ 808 JITed symbol file is not an object file, ignoring it.\n")); 809 bfd_close (nbfd); 810 return; 811 } 812 813 /* Check bfd arch. */ 814 b = gdbarch_bfd_arch_info (gdbarch); 815 if (b->compatible (b, bfd_get_arch_info (nbfd)) != b) 816 warning (_("JITed object file architecture %s is not compatible " 817 "with target architecture %s."), bfd_get_arch_info 818 (nbfd)->printable_name, b->printable_name); 819 820 /* Read the section address information out of the symbol file. Since the 821 file is generated by the JIT at runtime, it should all of the absolute 822 addresses that we care about. */ 823 sai = alloc_section_addr_info (bfd_count_sections (nbfd)); 824 old_cleanups = make_cleanup_free_section_addr_info (sai); 825 i = 0; 826 for (sec = nbfd->sections; sec != NULL; sec = sec->next) 827 if ((bfd_get_section_flags (nbfd, sec) & (SEC_ALLOC|SEC_LOAD)) != 0) 828 { 829 /* We assume that these virtual addresses are absolute, and do not 830 treat them as offsets. */ 831 sai->other[i].addr = bfd_get_section_vma (nbfd, sec); 832 sai->other[i].name = xstrdup (bfd_get_section_name (nbfd, sec)); 833 sai->other[i].sectindex = sec->index; 834 ++i; 835 } 836 837 /* This call takes ownership of NBFD. It does not take ownership of SAI. */ 838 objfile = symbol_file_add_from_bfd (nbfd, 0, sai, OBJF_SHARED, NULL); 839 840 do_cleanups (old_cleanups); 841 add_objfile_entry (objfile, entry_addr); 842 } 843 844 /* This function registers code associated with a JIT code entry. It uses the 845 pointer and size pair in the entry to read the symbol file from the remote 846 and then calls symbol_file_add_from_local_memory to add it as though it were 847 a symbol file added by the user. */ 848 849 static void 850 jit_register_code (struct gdbarch *gdbarch, 851 CORE_ADDR entry_addr, struct jit_code_entry *code_entry) 852 { 853 int i, success; 854 const struct bfd_arch_info *b; 855 struct jit_inferior_data *inf_data = get_jit_inferior_data (); 856 857 if (jit_debug) 858 fprintf_unfiltered (gdb_stdlog, 859 "jit_register_code, symfile_addr = %s, " 860 "symfile_size = %s\n", 861 paddress (gdbarch, code_entry->symfile_addr), 862 pulongest (code_entry->symfile_size)); 863 864 success = jit_reader_try_read_symtab (code_entry, entry_addr); 865 866 if (!success) 867 jit_bfd_try_read_symtab (code_entry, entry_addr, gdbarch); 868 } 869 870 /* This function unregisters JITed code and frees the corresponding 871 objfile. */ 872 873 static void 874 jit_unregister_code (struct objfile *objfile) 875 { 876 free_objfile (objfile); 877 } 878 879 /* Look up the objfile with this code entry address. */ 880 881 static struct objfile * 882 jit_find_objf_with_entry_addr (CORE_ADDR entry_addr) 883 { 884 struct objfile *objf; 885 CORE_ADDR *objf_entry_addr; 886 887 ALL_OBJFILES (objf) 888 { 889 objf_entry_addr = (CORE_ADDR *) objfile_data (objf, jit_objfile_data); 890 if (objf_entry_addr != NULL && *objf_entry_addr == entry_addr) 891 return objf; 892 } 893 return NULL; 894 } 895 896 /* (Re-)Initialize the jit breakpoint if necessary. 897 Return 0 on success. */ 898 899 static int 900 jit_breakpoint_re_set_internal (struct gdbarch *gdbarch, 901 struct jit_inferior_data *inf_data) 902 { 903 if (inf_data->breakpoint_addr == 0) 904 { 905 struct minimal_symbol *reg_symbol; 906 907 /* Lookup the registration symbol. If it is missing, then we assume 908 we are not attached to a JIT. */ 909 reg_symbol = lookup_minimal_symbol (jit_break_name, NULL, NULL); 910 if (reg_symbol == NULL) 911 return 1; 912 inf_data->breakpoint_addr = SYMBOL_VALUE_ADDRESS (reg_symbol); 913 if (inf_data->breakpoint_addr == 0) 914 return 2; 915 916 /* If we have not read the jit descriptor yet (e.g. because the JITer 917 itself is in a shared library which just got loaded), do so now. */ 918 if (inf_data->descriptor_addr == 0) 919 jit_inferior_init (gdbarch); 920 } 921 else 922 return 0; 923 924 if (jit_debug) 925 fprintf_unfiltered (gdb_stdlog, 926 "jit_breakpoint_re_set_internal, " 927 "breakpoint_addr = %s\n", 928 paddress (gdbarch, inf_data->breakpoint_addr)); 929 930 /* Put a breakpoint in the registration symbol. */ 931 create_jit_event_breakpoint (gdbarch, inf_data->breakpoint_addr); 932 933 return 0; 934 } 935 936 /* The private data passed around in the frame unwind callback 937 functions. */ 938 939 struct jit_unwind_private 940 { 941 /* Cached register values. See jit_frame_sniffer to see how this 942 works. */ 943 struct gdb_reg_value **registers; 944 945 /* The frame being unwound. */ 946 struct frame_info *this_frame; 947 }; 948 949 /* Sets the value of a particular register in this frame. */ 950 951 static void 952 jit_unwind_reg_set_impl (struct gdb_unwind_callbacks *cb, int dwarf_regnum, 953 struct gdb_reg_value *value) 954 { 955 struct jit_unwind_private *priv; 956 int gdb_reg; 957 958 priv = cb->priv_data; 959 960 gdb_reg = gdbarch_dwarf2_reg_to_regnum (get_frame_arch (priv->this_frame), 961 dwarf_regnum); 962 if (gdb_reg == -1) 963 { 964 if (jit_debug) 965 fprintf_unfiltered (gdb_stdlog, 966 _("Could not recognize DWARF regnum %d"), 967 dwarf_regnum); 968 return; 969 } 970 971 gdb_assert (priv->registers); 972 priv->registers[gdb_reg] = value; 973 } 974 975 static void 976 reg_value_free_impl (struct gdb_reg_value *value) 977 { 978 xfree (value); 979 } 980 981 /* Get the value of register REGNUM in the previous frame. */ 982 983 static struct gdb_reg_value * 984 jit_unwind_reg_get_impl (struct gdb_unwind_callbacks *cb, int regnum) 985 { 986 struct jit_unwind_private *priv; 987 struct gdb_reg_value *value; 988 int gdb_reg, size; 989 struct gdbarch *frame_arch; 990 991 priv = cb->priv_data; 992 frame_arch = get_frame_arch (priv->this_frame); 993 994 gdb_reg = gdbarch_dwarf2_reg_to_regnum (frame_arch, regnum); 995 size = register_size (frame_arch, gdb_reg); 996 value = xmalloc (sizeof (struct gdb_reg_value) + size - 1); 997 value->defined = frame_register_read (priv->this_frame, gdb_reg, 998 value->value); 999 value->size = size; 1000 value->free = reg_value_free_impl; 1001 return value; 1002 } 1003 1004 /* gdb_reg_value has a free function, which must be called on each 1005 saved register value. */ 1006 1007 static void 1008 jit_dealloc_cache (struct frame_info *this_frame, void *cache) 1009 { 1010 struct jit_unwind_private *priv_data = cache; 1011 struct gdbarch *frame_arch; 1012 int i; 1013 1014 gdb_assert (priv_data->registers); 1015 frame_arch = get_frame_arch (priv_data->this_frame); 1016 1017 for (i = 0; i < gdbarch_num_regs (frame_arch); i++) 1018 if (priv_data->registers[i] && priv_data->registers[i]->free) 1019 priv_data->registers[i]->free (priv_data->registers[i]); 1020 1021 xfree (priv_data->registers); 1022 xfree (priv_data); 1023 } 1024 1025 /* The frame sniffer for the pseudo unwinder. 1026 1027 While this is nominally a frame sniffer, in the case where the JIT 1028 reader actually recognizes the frame, it does a lot more work -- it 1029 unwinds the frame and saves the corresponding register values in 1030 the cache. jit_frame_prev_register simply returns the saved 1031 register values. */ 1032 1033 static int 1034 jit_frame_sniffer (const struct frame_unwind *self, 1035 struct frame_info *this_frame, void **cache) 1036 { 1037 struct jit_inferior_data *inf_data; 1038 struct jit_unwind_private *priv_data; 1039 struct jit_dbg_reader *iter; 1040 struct gdb_unwind_callbacks callbacks; 1041 struct gdb_reader_funcs *funcs; 1042 1043 inf_data = get_jit_inferior_data (); 1044 1045 callbacks.reg_get = jit_unwind_reg_get_impl; 1046 callbacks.reg_set = jit_unwind_reg_set_impl; 1047 callbacks.target_read = jit_target_read_impl; 1048 1049 if (loaded_jit_reader == NULL) 1050 return 0; 1051 1052 funcs = loaded_jit_reader->functions; 1053 1054 gdb_assert (!*cache); 1055 1056 *cache = XZALLOC (struct jit_unwind_private); 1057 priv_data = *cache; 1058 priv_data->registers = 1059 XCALLOC (gdbarch_num_regs (get_frame_arch (this_frame)), 1060 struct gdb_reg_value *); 1061 priv_data->this_frame = this_frame; 1062 1063 callbacks.priv_data = priv_data; 1064 1065 /* Try to coax the provided unwinder to unwind the stack */ 1066 if (funcs->unwind (funcs, &callbacks) == GDB_SUCCESS) 1067 { 1068 if (jit_debug) 1069 fprintf_unfiltered (gdb_stdlog, _("Successfully unwound frame using " 1070 "JIT reader.\n")); 1071 return 1; 1072 } 1073 if (jit_debug) 1074 fprintf_unfiltered (gdb_stdlog, _("Could not unwind frame using " 1075 "JIT reader.\n")); 1076 1077 jit_dealloc_cache (this_frame, *cache); 1078 *cache = NULL; 1079 1080 return 0; 1081 } 1082 1083 1084 /* The frame_id function for the pseudo unwinder. Relays the call to 1085 the loaded plugin. */ 1086 1087 static void 1088 jit_frame_this_id (struct frame_info *this_frame, void **cache, 1089 struct frame_id *this_id) 1090 { 1091 struct jit_unwind_private private; 1092 struct gdb_frame_id frame_id; 1093 struct gdb_reader_funcs *funcs; 1094 struct gdb_unwind_callbacks callbacks; 1095 1096 private.registers = NULL; 1097 private.this_frame = this_frame; 1098 1099 /* We don't expect the frame_id function to set any registers, so we 1100 set reg_set to NULL. */ 1101 callbacks.reg_get = jit_unwind_reg_get_impl; 1102 callbacks.reg_set = NULL; 1103 callbacks.target_read = jit_target_read_impl; 1104 callbacks.priv_data = &private; 1105 1106 gdb_assert (loaded_jit_reader); 1107 funcs = loaded_jit_reader->functions; 1108 1109 frame_id = funcs->get_frame_id (funcs, &callbacks); 1110 *this_id = frame_id_build (frame_id.stack_address, frame_id.code_address); 1111 } 1112 1113 /* Pseudo unwinder function. Reads the previously fetched value for 1114 the register from the cache. */ 1115 1116 static struct value * 1117 jit_frame_prev_register (struct frame_info *this_frame, void **cache, int reg) 1118 { 1119 struct jit_unwind_private *priv = *cache; 1120 struct gdb_reg_value *value; 1121 1122 if (priv == NULL) 1123 return frame_unwind_got_optimized (this_frame, reg); 1124 1125 gdb_assert (priv->registers); 1126 value = priv->registers[reg]; 1127 if (value && value->defined) 1128 return frame_unwind_got_bytes (this_frame, reg, value->value); 1129 else 1130 return frame_unwind_got_optimized (this_frame, reg); 1131 } 1132 1133 /* Relay everything back to the unwinder registered by the JIT debug 1134 info reader.*/ 1135 1136 static const struct frame_unwind jit_frame_unwind = 1137 { 1138 NORMAL_FRAME, 1139 default_frame_unwind_stop_reason, 1140 jit_frame_this_id, 1141 jit_frame_prev_register, 1142 NULL, 1143 jit_frame_sniffer, 1144 jit_dealloc_cache 1145 }; 1146 1147 1148 /* This is the information that is stored at jit_gdbarch_data for each 1149 architecture. */ 1150 1151 struct jit_gdbarch_data_type 1152 { 1153 /* Has the (pseudo) unwinder been prepended? */ 1154 int unwinder_registered; 1155 }; 1156 1157 /* Check GDBARCH and prepend the pseudo JIT unwinder if needed. */ 1158 1159 static void 1160 jit_prepend_unwinder (struct gdbarch *gdbarch) 1161 { 1162 struct jit_gdbarch_data_type *data; 1163 1164 data = gdbarch_data (gdbarch, jit_gdbarch_data); 1165 if (!data->unwinder_registered) 1166 { 1167 frame_unwind_prepend_unwinder (gdbarch, &jit_frame_unwind); 1168 data->unwinder_registered = 1; 1169 } 1170 } 1171 1172 /* Register any already created translations. */ 1173 1174 static void 1175 jit_inferior_init (struct gdbarch *gdbarch) 1176 { 1177 struct jit_descriptor descriptor; 1178 struct jit_code_entry cur_entry; 1179 struct jit_inferior_data *inf_data; 1180 CORE_ADDR cur_entry_addr; 1181 1182 if (jit_debug) 1183 fprintf_unfiltered (gdb_stdlog, "jit_inferior_init\n"); 1184 1185 jit_prepend_unwinder (gdbarch); 1186 1187 inf_data = get_jit_inferior_data (); 1188 if (jit_breakpoint_re_set_internal (gdbarch, inf_data) != 0) 1189 return; 1190 1191 if (inf_data->descriptor_addr == 0) 1192 { 1193 struct minimal_symbol *desc_symbol; 1194 1195 /* Lookup the descriptor symbol and cache the addr. If it is 1196 missing, we assume we are not attached to a JIT and return early. */ 1197 desc_symbol = lookup_minimal_symbol (jit_descriptor_name, NULL, NULL); 1198 if (desc_symbol == NULL) 1199 return; 1200 1201 inf_data->descriptor_addr = SYMBOL_VALUE_ADDRESS (desc_symbol); 1202 if (inf_data->descriptor_addr == 0) 1203 return; 1204 } 1205 1206 if (jit_debug) 1207 fprintf_unfiltered (gdb_stdlog, 1208 "jit_inferior_init, descriptor_addr = %s\n", 1209 paddress (gdbarch, inf_data->descriptor_addr)); 1210 1211 /* Read the descriptor so we can check the version number and load 1212 any already JITed functions. */ 1213 jit_read_descriptor (gdbarch, &descriptor, inf_data->descriptor_addr); 1214 1215 /* Check that the version number agrees with that we support. */ 1216 if (descriptor.version != 1) 1217 error (_("Unsupported JIT protocol version in descriptor!")); 1218 1219 /* If we've attached to a running program, we need to check the descriptor 1220 to register any functions that were already generated. */ 1221 for (cur_entry_addr = descriptor.first_entry; 1222 cur_entry_addr != 0; 1223 cur_entry_addr = cur_entry.next_entry) 1224 { 1225 jit_read_code_entry (gdbarch, cur_entry_addr, &cur_entry); 1226 1227 /* This hook may be called many times during setup, so make sure we don't 1228 add the same symbol file twice. */ 1229 if (jit_find_objf_with_entry_addr (cur_entry_addr) != NULL) 1230 continue; 1231 1232 jit_register_code (gdbarch, cur_entry_addr, &cur_entry); 1233 } 1234 } 1235 1236 /* Exported routine to call when an inferior has been created. */ 1237 1238 void 1239 jit_inferior_created_hook (void) 1240 { 1241 jit_inferior_init (target_gdbarch); 1242 } 1243 1244 /* Exported routine to call to re-set the jit breakpoints, 1245 e.g. when a program is rerun. */ 1246 1247 void 1248 jit_breakpoint_re_set (void) 1249 { 1250 jit_breakpoint_re_set_internal (target_gdbarch, 1251 get_jit_inferior_data ()); 1252 } 1253 1254 /* Reset inferior_data, so sybols will be looked up again, and jit_breakpoint 1255 will be reset. */ 1256 1257 static void 1258 jit_reset_inferior_data_and_breakpoints (void) 1259 { 1260 struct jit_inferior_data *inf_data; 1261 1262 /* Force jit_inferior_init to re-lookup of jit symbol addresses. */ 1263 inf_data = get_jit_inferior_data (); 1264 inf_data->breakpoint_addr = 0; 1265 inf_data->descriptor_addr = 0; 1266 1267 /* Remove any existing JIT breakpoint(s). */ 1268 remove_jit_event_breakpoints (); 1269 1270 jit_inferior_init (target_gdbarch); 1271 } 1272 1273 /* Wrapper to match the observer function pointer prototype. */ 1274 1275 static void 1276 jit_inferior_created_observer (struct target_ops *objfile, int from_tty) 1277 { 1278 jit_reset_inferior_data_and_breakpoints (); 1279 } 1280 1281 /* This function cleans up any code entries left over when the 1282 inferior exits. We get left over code when the inferior exits 1283 without unregistering its code, for example when it crashes. */ 1284 1285 static void 1286 jit_inferior_exit_hook (struct inferior *inf) 1287 { 1288 struct objfile *objf; 1289 struct objfile *temp; 1290 1291 ALL_OBJFILES_SAFE (objf, temp) 1292 if (objfile_data (objf, jit_objfile_data) != NULL) 1293 jit_unregister_code (objf); 1294 } 1295 1296 static void 1297 jit_executable_changed_observer (void) 1298 { 1299 jit_reset_inferior_data_and_breakpoints (); 1300 } 1301 1302 void 1303 jit_event_handler (struct gdbarch *gdbarch) 1304 { 1305 struct jit_descriptor descriptor; 1306 struct jit_code_entry code_entry; 1307 CORE_ADDR entry_addr; 1308 struct objfile *objf; 1309 1310 /* Read the descriptor from remote memory. */ 1311 jit_read_descriptor (gdbarch, &descriptor, 1312 get_jit_inferior_data ()->descriptor_addr); 1313 entry_addr = descriptor.relevant_entry; 1314 1315 /* Do the corresponding action. */ 1316 switch (descriptor.action_flag) 1317 { 1318 case JIT_NOACTION: 1319 break; 1320 case JIT_REGISTER: 1321 jit_read_code_entry (gdbarch, entry_addr, &code_entry); 1322 jit_register_code (gdbarch, entry_addr, &code_entry); 1323 break; 1324 case JIT_UNREGISTER: 1325 objf = jit_find_objf_with_entry_addr (entry_addr); 1326 if (objf == NULL) 1327 printf_unfiltered (_("Unable to find JITed code " 1328 "entry at address: %s\n"), 1329 paddress (gdbarch, entry_addr)); 1330 else 1331 jit_unregister_code (objf); 1332 1333 break; 1334 default: 1335 error (_("Unknown action_flag value in JIT descriptor!")); 1336 break; 1337 } 1338 } 1339 1340 /* Called to free the data allocated to the jit_inferior_data slot. */ 1341 1342 static void 1343 free_objfile_data (struct objfile *objfile, void *data) 1344 { 1345 xfree (data); 1346 } 1347 1348 /* Initialize the jit_gdbarch_data slot with an instance of struct 1349 jit_gdbarch_data_type */ 1350 1351 static void * 1352 jit_gdbarch_data_init (struct obstack *obstack) 1353 { 1354 struct jit_gdbarch_data_type *data; 1355 1356 data = obstack_alloc (obstack, sizeof (struct jit_gdbarch_data_type)); 1357 data->unwinder_registered = 0; 1358 return data; 1359 } 1360 1361 /* Provide a prototype to silence -Wmissing-prototypes. */ 1362 1363 extern void _initialize_jit (void); 1364 1365 void 1366 _initialize_jit (void) 1367 { 1368 jit_reader_dir = relocate_gdb_directory (JIT_READER_DIR, 1369 JIT_READER_DIR_RELOCATABLE); 1370 add_setshow_zinteger_cmd ("jit", class_maintenance, &jit_debug, 1371 _("Set JIT debugging."), 1372 _("Show JIT debugging."), 1373 _("When non-zero, JIT debugging is enabled."), 1374 NULL, 1375 show_jit_debug, 1376 &setdebuglist, &showdebuglist); 1377 1378 observer_attach_inferior_created (jit_inferior_created_observer); 1379 observer_attach_inferior_exit (jit_inferior_exit_hook); 1380 observer_attach_executable_changed (jit_executable_changed_observer); 1381 jit_objfile_data = 1382 register_objfile_data_with_cleanup (NULL, free_objfile_data); 1383 jit_inferior_data = 1384 register_inferior_data_with_cleanup (jit_inferior_data_cleanup); 1385 jit_gdbarch_data = gdbarch_data_register_pre_init (jit_gdbarch_data_init); 1386 if (is_dl_available ()) 1387 { 1388 add_com ("jit-reader-load", no_class, jit_reader_load_command, _("\ 1389 Load FILE as debug info reader and unwinder for JIT compiled code.\n\ 1390 Usage: jit-reader-load FILE\n\ 1391 Try to load file FILE as a debug info reader (and unwinder) for\n\ 1392 JIT compiled code. The file is loaded from " JIT_READER_DIR ",\n\ 1393 relocated relative to the GDB executable if required.")); 1394 add_com ("jit-reader-unload", no_class, jit_reader_unload_command, _("\ 1395 Unload the currently loaded JIT debug info reader.\n\ 1396 Usage: jit-reader-unload FILE\n\n\ 1397 Do \"help jit-reader-load\" for info on loading debug info readers.")); 1398 } 1399 } 1400