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