1 /* Handle JIT code generation in the inferior for GDB, the GNU Debugger. 2 3 Copyright (C) 2009-2023 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 "observable.h" 34 #include "objfiles.h" 35 #include "regcache.h" 36 #include "symfile.h" 37 #include "symtab.h" 38 #include "target.h" 39 #include "gdbsupport/gdb-dlfcn.h" 40 #include <sys/stat.h> 41 #include "gdb_bfd.h" 42 #include "readline/tilde.h" 43 #include "completer.h" 44 #include <forward_list> 45 46 static std::string jit_reader_dir; 47 48 static const char jit_break_name[] = "__jit_debug_register_code"; 49 50 static const char jit_descriptor_name[] = "__jit_debug_descriptor"; 51 52 static void jit_inferior_created_hook (inferior *inf); 53 static void jit_inferior_exit_hook (struct inferior *inf); 54 55 /* True if we want to see trace of jit level stuff. */ 56 57 static bool jit_debug = false; 58 59 /* Print a "jit" debug statement. */ 60 61 #define jit_debug_printf(fmt, ...) \ 62 debug_prefixed_printf_cond (jit_debug, "jit", fmt, ##__VA_ARGS__) 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 gdb_printf (file, _("JIT debugging is %s.\n"), value); 69 } 70 71 /* Implementation of the "maintenance info jit" command. */ 72 73 static void 74 maint_info_jit_cmd (const char *args, int from_tty) 75 { 76 inferior *inf = current_inferior (); 77 bool printed_header = false; 78 79 gdb::optional<ui_out_emit_table> table_emitter; 80 81 /* Print a line for each JIT-ed objfile. */ 82 for (objfile *obj : inf->pspace->objfiles ()) 83 { 84 if (obj->jited_data == nullptr) 85 continue; 86 87 if (!printed_header) 88 { 89 table_emitter.emplace (current_uiout, 3, -1, "jit-created-objfiles"); 90 91 /* The +2 allows for the leading '0x', then one character for 92 every 4-bits. */ 93 int addr_width = 2 + (gdbarch_ptr_bit (obj->arch ()) / 4); 94 95 /* The std::max here selects between the width of an address (as 96 a string) and the width of the column header string. */ 97 current_uiout->table_header (std::max (addr_width, 22), ui_left, 98 "jit_code_entry-address", 99 "jit_code_entry address"); 100 current_uiout->table_header (std::max (addr_width, 15), ui_left, 101 "symfile-address", "symfile address"); 102 current_uiout->table_header (20, ui_left, 103 "symfile-size", "symfile size"); 104 current_uiout->table_body (); 105 106 printed_header = true; 107 } 108 109 ui_out_emit_tuple tuple_emitter (current_uiout, "jit-objfile"); 110 111 current_uiout->field_core_addr ("jit_code_entry-address", obj->arch (), 112 obj->jited_data->addr); 113 current_uiout->field_core_addr ("symfile-address", obj->arch (), 114 obj->jited_data->symfile_addr); 115 current_uiout->field_unsigned ("symfile-size", 116 obj->jited_data->symfile_size); 117 current_uiout->text ("\n"); 118 } 119 } 120 121 struct jit_reader 122 { 123 jit_reader (struct gdb_reader_funcs *f, gdb_dlhandle_up &&h) 124 : functions (f), handle (std::move (h)) 125 { 126 } 127 128 ~jit_reader () 129 { 130 functions->destroy (functions); 131 } 132 133 DISABLE_COPY_AND_ASSIGN (jit_reader); 134 135 struct gdb_reader_funcs *functions; 136 gdb_dlhandle_up handle; 137 }; 138 139 /* One reader that has been loaded successfully, and can potentially be used to 140 parse debug info. */ 141 142 static struct jit_reader *loaded_jit_reader = NULL; 143 144 typedef struct gdb_reader_funcs * (reader_init_fn_type) (void); 145 static const char reader_init_fn_sym[] = "gdb_init_reader"; 146 147 /* Try to load FILE_NAME as a JIT debug info reader. */ 148 149 static struct jit_reader * 150 jit_reader_load (const char *file_name) 151 { 152 reader_init_fn_type *init_fn; 153 struct gdb_reader_funcs *funcs = NULL; 154 155 jit_debug_printf ("Opening shared object %s", file_name); 156 157 gdb_dlhandle_up so = gdb_dlopen (file_name); 158 159 init_fn = (reader_init_fn_type *) 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 return new jit_reader (funcs, std::move (so)); 172 } 173 174 /* Provides the jit-reader-load command. */ 175 176 static void 177 jit_reader_load_command (const char *args, int from_tty) 178 { 179 if (args == NULL) 180 error (_("No reader name provided.")); 181 gdb::unique_xmalloc_ptr<char> file (tilde_expand (args)); 182 183 if (loaded_jit_reader != NULL) 184 error (_("JIT reader already loaded. Run jit-reader-unload first.")); 185 186 if (!IS_ABSOLUTE_PATH (file.get ())) 187 file = xstrprintf ("%s%s%s", jit_reader_dir.c_str (), 188 SLASH_STRING, file.get ()); 189 190 loaded_jit_reader = jit_reader_load (file.get ()); 191 reinit_frame_cache (); 192 jit_inferior_created_hook (current_inferior ()); 193 } 194 195 /* Provides the jit-reader-unload command. */ 196 197 static void 198 jit_reader_unload_command (const char *args, int from_tty) 199 { 200 if (!loaded_jit_reader) 201 error (_("No JIT reader loaded.")); 202 203 reinit_frame_cache (); 204 jit_inferior_exit_hook (current_inferior ()); 205 206 delete loaded_jit_reader; 207 loaded_jit_reader = NULL; 208 } 209 210 /* Destructor for jiter_objfile_data. */ 211 212 jiter_objfile_data::~jiter_objfile_data () 213 { 214 if (this->jit_breakpoint != nullptr) 215 delete_breakpoint (this->jit_breakpoint); 216 } 217 218 /* Fetch the jiter_objfile_data associated with OBJF. If no data exists 219 yet, make a new structure and attach it. */ 220 221 static jiter_objfile_data * 222 get_jiter_objfile_data (objfile *objf) 223 { 224 if (objf->jiter_data == nullptr) 225 objf->jiter_data.reset (new jiter_objfile_data ()); 226 227 return objf->jiter_data.get (); 228 } 229 230 /* Remember OBJFILE has been created for struct jit_code_entry located 231 at inferior address ENTRY. */ 232 233 static void 234 add_objfile_entry (struct objfile *objfile, CORE_ADDR entry, 235 CORE_ADDR symfile_addr, ULONGEST symfile_size) 236 { 237 gdb_assert (objfile->jited_data == nullptr); 238 239 objfile->jited_data.reset (new jited_objfile_data (entry, symfile_addr, 240 symfile_size)); 241 } 242 243 /* Helper function for reading the global JIT descriptor from remote 244 memory. Returns true if all went well, false otherwise. */ 245 246 static bool 247 jit_read_descriptor (gdbarch *gdbarch, 248 jit_descriptor *descriptor, 249 objfile *jiter) 250 { 251 int err; 252 struct type *ptr_type; 253 int ptr_size; 254 int desc_size; 255 gdb_byte *desc_buf; 256 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); 257 258 gdb_assert (jiter != nullptr); 259 jiter_objfile_data *objf_data = jiter->jiter_data.get (); 260 gdb_assert (objf_data != nullptr); 261 262 CORE_ADDR addr = objf_data->descriptor->value_address (jiter); 263 264 jit_debug_printf ("descriptor_addr = %s", paddress (gdbarch, addr)); 265 266 /* Figure out how big the descriptor is on the remote and how to read it. */ 267 ptr_type = builtin_type (gdbarch)->builtin_data_ptr; 268 ptr_size = ptr_type->length (); 269 desc_size = 8 + 2 * ptr_size; /* Two 32-bit ints and two pointers. */ 270 desc_buf = (gdb_byte *) alloca (desc_size); 271 272 /* Read the descriptor. */ 273 err = target_read_memory (addr, desc_buf, desc_size); 274 if (err) 275 { 276 gdb_printf (gdb_stderr, _("Unable to read JIT descriptor from " 277 "remote memory\n")); 278 return false; 279 } 280 281 /* Fix the endianness to match the host. */ 282 descriptor->version = extract_unsigned_integer (&desc_buf[0], 4, byte_order); 283 descriptor->action_flag = 284 extract_unsigned_integer (&desc_buf[4], 4, byte_order); 285 descriptor->relevant_entry = extract_typed_address (&desc_buf[8], ptr_type); 286 descriptor->first_entry = 287 extract_typed_address (&desc_buf[8 + ptr_size], ptr_type); 288 289 return true; 290 } 291 292 /* Helper function for reading a JITed code entry from remote memory. */ 293 294 static void 295 jit_read_code_entry (struct gdbarch *gdbarch, 296 CORE_ADDR code_addr, struct jit_code_entry *code_entry) 297 { 298 int err, off; 299 struct type *ptr_type; 300 int ptr_size; 301 int entry_size; 302 int align_bytes; 303 gdb_byte *entry_buf; 304 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); 305 306 /* Figure out how big the entry is on the remote and how to read it. */ 307 ptr_type = builtin_type (gdbarch)->builtin_data_ptr; 308 ptr_size = ptr_type->length (); 309 310 /* Figure out where the uint64_t value will be. */ 311 align_bytes = type_align (builtin_type (gdbarch)->builtin_uint64); 312 off = 3 * ptr_size; 313 off = (off + (align_bytes - 1)) & ~(align_bytes - 1); 314 315 entry_size = off + 8; /* Three pointers and one 64-bit int. */ 316 entry_buf = (gdb_byte *) alloca (entry_size); 317 318 /* Read the entry. */ 319 err = target_read_memory (code_addr, entry_buf, entry_size); 320 if (err) 321 error (_("Unable to read JIT code entry from remote memory!")); 322 323 /* Fix the endianness to match the host. */ 324 ptr_type = builtin_type (gdbarch)->builtin_data_ptr; 325 code_entry->next_entry = extract_typed_address (&entry_buf[0], ptr_type); 326 code_entry->prev_entry = 327 extract_typed_address (&entry_buf[ptr_size], ptr_type); 328 code_entry->symfile_addr = 329 extract_typed_address (&entry_buf[2 * ptr_size], ptr_type); 330 code_entry->symfile_size = 331 extract_unsigned_integer (&entry_buf[off], 8, byte_order); 332 } 333 334 /* Proxy object for building a block. */ 335 336 struct gdb_block 337 { 338 gdb_block (gdb_block *parent, CORE_ADDR begin, CORE_ADDR end, 339 const char *name) 340 : parent (parent), 341 begin (begin), 342 end (end), 343 name (name != nullptr ? xstrdup (name) : nullptr) 344 {} 345 346 /* The parent of this block. */ 347 struct gdb_block *parent; 348 349 /* Points to the "real" block that is being built out of this 350 instance. This block will be added to a blockvector, which will 351 then be added to a symtab. */ 352 struct block *real_block = nullptr; 353 354 /* The first and last code address corresponding to this block. */ 355 CORE_ADDR begin, end; 356 357 /* The name of this block (if any). If this is non-NULL, the 358 FUNCTION symbol symbol is set to this value. */ 359 gdb::unique_xmalloc_ptr<char> name; 360 }; 361 362 /* Proxy object for building a symtab. */ 363 364 struct gdb_symtab 365 { 366 explicit gdb_symtab (const char *file_name) 367 : file_name (file_name != nullptr ? file_name : "") 368 {} 369 370 /* The list of blocks in this symtab. These will eventually be 371 converted to real blocks. 372 373 This is specifically a linked list, instead of, for example, a vector, 374 because the pointers are returned to the user's debug info reader. So 375 it's important that the objects don't change location during their 376 lifetime (which would happen with a vector of objects getting resized). */ 377 std::forward_list<gdb_block> blocks; 378 379 /* The number of blocks inserted. */ 380 int nblocks = 0; 381 382 /* A mapping between line numbers to PC. */ 383 gdb::unique_xmalloc_ptr<struct linetable> linetable; 384 385 /* The source file for this symtab. */ 386 std::string file_name; 387 }; 388 389 /* Proxy object for building an object. */ 390 391 struct gdb_object 392 { 393 /* Symtabs of this object. 394 395 This is specifically a linked list, instead of, for example, a vector, 396 because the pointers are returned to the user's debug info reader. So 397 it's important that the objects don't change location during their 398 lifetime (which would happen with a vector of objects getting resized). */ 399 std::forward_list<gdb_symtab> symtabs; 400 }; 401 402 /* The type of the `private' data passed around by the callback 403 functions. */ 404 405 struct jit_dbg_reader_data 406 { 407 /* Address of the jit_code_entry in the inferior's address space. */ 408 CORE_ADDR entry_addr; 409 410 /* The code entry, copied in our address space. */ 411 const jit_code_entry &entry; 412 413 struct gdbarch *gdbarch; 414 }; 415 416 /* The reader calls into this function to read data off the targets 417 address space. */ 418 419 static enum gdb_status 420 jit_target_read_impl (GDB_CORE_ADDR target_mem, void *gdb_buf, int len) 421 { 422 int result = target_read_memory ((CORE_ADDR) target_mem, 423 (gdb_byte *) gdb_buf, len); 424 if (result == 0) 425 return GDB_SUCCESS; 426 else 427 return GDB_FAIL; 428 } 429 430 /* The reader calls into this function to create a new gdb_object 431 which it can then pass around to the other callbacks. Right now, 432 all that is required is allocating the memory. */ 433 434 static struct gdb_object * 435 jit_object_open_impl (struct gdb_symbol_callbacks *cb) 436 { 437 /* CB is not required right now, but sometime in the future we might 438 need a handle to it, and we'd like to do that without breaking 439 the ABI. */ 440 return new gdb_object; 441 } 442 443 /* Readers call into this function to open a new gdb_symtab, which, 444 again, is passed around to other callbacks. */ 445 446 static struct gdb_symtab * 447 jit_symtab_open_impl (struct gdb_symbol_callbacks *cb, 448 struct gdb_object *object, 449 const char *file_name) 450 { 451 /* CB stays unused. See comment in jit_object_open_impl. */ 452 453 object->symtabs.emplace_front (file_name); 454 return &object->symtabs.front (); 455 } 456 457 /* Called by readers to open a new gdb_block. This function also 458 inserts the new gdb_block in the correct place in the corresponding 459 gdb_symtab. */ 460 461 static struct gdb_block * 462 jit_block_open_impl (struct gdb_symbol_callbacks *cb, 463 struct gdb_symtab *symtab, struct gdb_block *parent, 464 GDB_CORE_ADDR begin, GDB_CORE_ADDR end, const char *name) 465 { 466 /* Place the block at the beginning of the list, it will be sorted when the 467 symtab is finalized. */ 468 symtab->blocks.emplace_front (parent, begin, end, name); 469 symtab->nblocks++; 470 471 return &symtab->blocks.front (); 472 } 473 474 /* Readers call this to add a line mapping (from PC to line number) to 475 a gdb_symtab. */ 476 477 static void 478 jit_symtab_line_mapping_add_impl (struct gdb_symbol_callbacks *cb, 479 struct gdb_symtab *stab, int nlines, 480 struct gdb_line_mapping *map) 481 { 482 int i; 483 int alloc_len; 484 485 if (nlines < 1) 486 return; 487 488 alloc_len = sizeof (struct linetable) 489 + (nlines - 1) * sizeof (struct linetable_entry); 490 stab->linetable.reset (XNEWVAR (struct linetable, alloc_len)); 491 stab->linetable->nitems = nlines; 492 for (i = 0; i < nlines; i++) 493 { 494 stab->linetable->item[i].pc = (CORE_ADDR) map[i].pc; 495 stab->linetable->item[i].line = map[i].line; 496 stab->linetable->item[i].is_stmt = 1; 497 } 498 } 499 500 /* Called by readers to close a gdb_symtab. Does not need to do 501 anything as of now. */ 502 503 static void 504 jit_symtab_close_impl (struct gdb_symbol_callbacks *cb, 505 struct gdb_symtab *stab) 506 { 507 /* Right now nothing needs to be done here. We may need to do some 508 cleanup here in the future (again, without breaking the plugin 509 ABI). */ 510 } 511 512 /* Transform STAB to a proper symtab, and add it it OBJFILE. */ 513 514 static void 515 finalize_symtab (struct gdb_symtab *stab, struct objfile *objfile) 516 { 517 struct compunit_symtab *cust; 518 size_t blockvector_size; 519 CORE_ADDR begin, end; 520 struct blockvector *bv; 521 522 int actual_nblocks = FIRST_LOCAL_BLOCK + stab->nblocks; 523 524 /* Sort the blocks in the order they should appear in the blockvector. */ 525 stab->blocks.sort([] (const gdb_block &a, const gdb_block &b) 526 { 527 if (a.begin != b.begin) 528 return a.begin < b.begin; 529 530 return a.end > b.end; 531 }); 532 533 cust = allocate_compunit_symtab (objfile, stab->file_name.c_str ()); 534 symtab *filetab = allocate_symtab (cust, stab->file_name.c_str ()); 535 add_compunit_symtab_to_objfile (cust); 536 537 /* JIT compilers compile in memory. */ 538 cust->set_dirname (nullptr); 539 540 /* Copy over the linetable entry if one was provided. */ 541 if (stab->linetable) 542 { 543 size_t size = ((stab->linetable->nitems - 1) 544 * sizeof (struct linetable_entry) 545 + sizeof (struct linetable)); 546 filetab->set_linetable ((struct linetable *) 547 obstack_alloc (&objfile->objfile_obstack, size)); 548 memcpy (filetab->linetable (), stab->linetable.get (), size); 549 } 550 551 blockvector_size = (sizeof (struct blockvector) 552 + (actual_nblocks - 1) * sizeof (struct block *)); 553 bv = (struct blockvector *) obstack_alloc (&objfile->objfile_obstack, 554 blockvector_size); 555 cust->set_blockvector (bv); 556 557 /* At the end of this function, (begin, end) will contain the PC range this 558 entire blockvector spans. */ 559 bv->set_map (nullptr); 560 begin = stab->blocks.front ().begin; 561 end = stab->blocks.front ().end; 562 bv->set_num_blocks (actual_nblocks); 563 564 /* First run over all the gdb_block objects, creating a real block 565 object for each. Simultaneously, keep setting the real_block 566 fields. */ 567 int block_idx = FIRST_LOCAL_BLOCK; 568 for (gdb_block &gdb_block_iter : stab->blocks) 569 { 570 struct block *new_block = allocate_block (&objfile->objfile_obstack); 571 struct symbol *block_name = new (&objfile->objfile_obstack) symbol; 572 struct type *block_type = arch_type (objfile->arch (), 573 TYPE_CODE_VOID, 574 TARGET_CHAR_BIT, 575 "void"); 576 577 new_block->set_multidict 578 (mdict_create_linear (&objfile->objfile_obstack, NULL)); 579 /* The address range. */ 580 new_block->set_start (gdb_block_iter.begin); 581 new_block->set_end (gdb_block_iter.end); 582 583 /* The name. */ 584 block_name->set_domain (VAR_DOMAIN); 585 block_name->set_aclass_index (LOC_BLOCK); 586 block_name->set_symtab (filetab); 587 block_name->set_type (lookup_function_type (block_type)); 588 block_name->set_value_block (new_block); 589 590 block_name->m_name = obstack_strdup (&objfile->objfile_obstack, 591 gdb_block_iter.name.get ()); 592 593 new_block->set_function (block_name); 594 595 bv->set_block (block_idx, new_block); 596 if (begin > new_block->start ()) 597 begin = new_block->start (); 598 if (end < new_block->end ()) 599 end = new_block->end (); 600 601 gdb_block_iter.real_block = new_block; 602 603 block_idx++; 604 } 605 606 /* Now add the special blocks. */ 607 struct block *block_iter = NULL; 608 for (enum block_enum i : { GLOBAL_BLOCK, STATIC_BLOCK }) 609 { 610 struct block *new_block; 611 612 new_block = (i == GLOBAL_BLOCK 613 ? allocate_global_block (&objfile->objfile_obstack) 614 : allocate_block (&objfile->objfile_obstack)); 615 new_block->set_multidict 616 (mdict_create_linear (&objfile->objfile_obstack, NULL)); 617 new_block->set_superblock (block_iter); 618 block_iter = new_block; 619 620 new_block->set_start (begin); 621 new_block->set_end (end); 622 623 bv->set_block (i, new_block); 624 625 if (i == GLOBAL_BLOCK) 626 set_block_compunit_symtab (new_block, cust); 627 } 628 629 /* Fill up the superblock fields for the real blocks, using the 630 real_block fields populated earlier. */ 631 for (gdb_block &gdb_block_iter : stab->blocks) 632 { 633 if (gdb_block_iter.parent != NULL) 634 { 635 /* If the plugin specifically mentioned a parent block, we 636 use that. */ 637 gdb_block_iter.real_block->set_superblock 638 (gdb_block_iter.parent->real_block); 639 640 } 641 else 642 { 643 /* And if not, we set a default parent block. */ 644 gdb_block_iter.real_block->set_superblock (bv->static_block ()); 645 } 646 } 647 } 648 649 /* Called when closing a gdb_objfile. Converts OBJ to a proper 650 objfile. */ 651 652 static void 653 jit_object_close_impl (struct gdb_symbol_callbacks *cb, 654 struct gdb_object *obj) 655 { 656 jit_dbg_reader_data *priv_data = (jit_dbg_reader_data *) cb->priv_data; 657 std::string objfile_name 658 = string_printf ("<< JIT compiled code at %s >>", 659 paddress (priv_data->gdbarch, 660 priv_data->entry.symfile_addr)); 661 662 objfile *objfile = objfile::make (nullptr, objfile_name.c_str (), 663 OBJF_NOT_FILENAME); 664 objfile->per_bfd->gdbarch = priv_data->gdbarch; 665 666 for (gdb_symtab &symtab : obj->symtabs) 667 finalize_symtab (&symtab, objfile); 668 669 add_objfile_entry (objfile, priv_data->entry_addr, 670 priv_data->entry.symfile_addr, 671 priv_data->entry.symfile_size); 672 673 delete obj; 674 } 675 676 /* Try to read CODE_ENTRY using the loaded jit reader (if any). 677 ENTRY_ADDR is the address of the struct jit_code_entry in the 678 inferior address space. */ 679 680 static int 681 jit_reader_try_read_symtab (gdbarch *gdbarch, jit_code_entry *code_entry, 682 CORE_ADDR entry_addr) 683 { 684 int status; 685 jit_dbg_reader_data priv_data 686 { 687 entry_addr, 688 *code_entry, 689 gdbarch 690 }; 691 struct gdb_reader_funcs *funcs; 692 struct gdb_symbol_callbacks callbacks = 693 { 694 jit_object_open_impl, 695 jit_symtab_open_impl, 696 jit_block_open_impl, 697 jit_symtab_close_impl, 698 jit_object_close_impl, 699 700 jit_symtab_line_mapping_add_impl, 701 jit_target_read_impl, 702 703 &priv_data 704 }; 705 706 if (!loaded_jit_reader) 707 return 0; 708 709 gdb::byte_vector gdb_mem (code_entry->symfile_size); 710 711 status = 1; 712 try 713 { 714 if (target_read_memory (code_entry->symfile_addr, gdb_mem.data (), 715 code_entry->symfile_size)) 716 status = 0; 717 } 718 catch (const gdb_exception &e) 719 { 720 status = 0; 721 } 722 723 if (status) 724 { 725 funcs = loaded_jit_reader->functions; 726 if (funcs->read (funcs, &callbacks, gdb_mem.data (), 727 code_entry->symfile_size) 728 != GDB_SUCCESS) 729 status = 0; 730 } 731 732 if (status == 0) 733 jit_debug_printf ("Could not read symtab using the loaded JIT reader."); 734 735 return status; 736 } 737 738 /* Try to read CODE_ENTRY using BFD. ENTRY_ADDR is the address of the 739 struct jit_code_entry in the inferior address space. */ 740 741 static void 742 jit_bfd_try_read_symtab (struct jit_code_entry *code_entry, 743 CORE_ADDR entry_addr, 744 struct gdbarch *gdbarch) 745 { 746 struct bfd_section *sec; 747 struct objfile *objfile; 748 const struct bfd_arch_info *b; 749 750 jit_debug_printf ("symfile_addr = %s, symfile_size = %s", 751 paddress (gdbarch, code_entry->symfile_addr), 752 pulongest (code_entry->symfile_size)); 753 754 gdb_bfd_ref_ptr nbfd (gdb_bfd_open_from_target_memory 755 (code_entry->symfile_addr, code_entry->symfile_size, gnutarget)); 756 if (nbfd == NULL) 757 { 758 gdb_puts (_("Error opening JITed symbol file, ignoring it.\n"), 759 gdb_stderr); 760 return; 761 } 762 763 /* Check the format. NOTE: This initializes important data that GDB uses! 764 We would segfault later without this line. */ 765 if (!bfd_check_format (nbfd.get (), bfd_object)) 766 { 767 gdb_printf (gdb_stderr, _("\ 768 JITed symbol file is not an object file, ignoring it.\n")); 769 return; 770 } 771 772 /* Check bfd arch. */ 773 b = gdbarch_bfd_arch_info (gdbarch); 774 if (b->compatible (b, bfd_get_arch_info (nbfd.get ())) != b) 775 warning (_("JITed object file architecture %s is not compatible " 776 "with target architecture %s."), 777 bfd_get_arch_info (nbfd.get ())->printable_name, 778 b->printable_name); 779 780 /* Read the section address information out of the symbol file. Since the 781 file is generated by the JIT at runtime, it should all of the absolute 782 addresses that we care about. */ 783 section_addr_info sai; 784 for (sec = nbfd->sections; sec != NULL; sec = sec->next) 785 if ((bfd_section_flags (sec) & (SEC_ALLOC|SEC_LOAD)) != 0) 786 { 787 /* We assume that these virtual addresses are absolute, and do not 788 treat them as offsets. */ 789 sai.emplace_back (bfd_section_vma (sec), 790 bfd_section_name (sec), 791 sec->index); 792 } 793 794 /* This call does not take ownership of SAI. */ 795 objfile = symbol_file_add_from_bfd (nbfd, 796 bfd_get_filename (nbfd.get ()), 0, 797 &sai, 798 OBJF_SHARED | OBJF_NOT_FILENAME, NULL); 799 800 add_objfile_entry (objfile, entry_addr, code_entry->symfile_addr, 801 code_entry->symfile_size); 802 } 803 804 /* This function registers code associated with a JIT code entry. It uses the 805 pointer and size pair in the entry to read the symbol file from the remote 806 and then calls symbol_file_add_from_local_memory to add it as though it were 807 a symbol file added by the user. */ 808 809 static void 810 jit_register_code (struct gdbarch *gdbarch, 811 CORE_ADDR entry_addr, struct jit_code_entry *code_entry) 812 { 813 int success; 814 815 jit_debug_printf ("symfile_addr = %s, symfile_size = %s", 816 paddress (gdbarch, code_entry->symfile_addr), 817 pulongest (code_entry->symfile_size)); 818 819 success = jit_reader_try_read_symtab (gdbarch, code_entry, entry_addr); 820 821 if (!success) 822 jit_bfd_try_read_symtab (code_entry, entry_addr, gdbarch); 823 } 824 825 /* Look up the objfile with this code entry address. */ 826 827 static struct objfile * 828 jit_find_objf_with_entry_addr (CORE_ADDR entry_addr) 829 { 830 for (objfile *objf : current_program_space->objfiles ()) 831 { 832 if (objf->jited_data != nullptr && objf->jited_data->addr == entry_addr) 833 return objf; 834 } 835 836 return NULL; 837 } 838 839 /* This is called when a breakpoint is deleted. It updates the 840 inferior's cache, if needed. */ 841 842 static void 843 jit_breakpoint_deleted (struct breakpoint *b) 844 { 845 if (b->type != bp_jit_event) 846 return; 847 848 for (bp_location *iter : b->locations ()) 849 { 850 for (objfile *objf : iter->pspace->objfiles ()) 851 { 852 jiter_objfile_data *jiter_data = objf->jiter_data.get (); 853 854 if (jiter_data != nullptr 855 && jiter_data->jit_breakpoint == iter->owner) 856 { 857 jiter_data->cached_code_address = 0; 858 jiter_data->jit_breakpoint = nullptr; 859 } 860 } 861 } 862 } 863 864 /* (Re-)Initialize the jit breakpoints for JIT-producing objfiles in 865 PSPACE. */ 866 867 static void 868 jit_breakpoint_re_set_internal (struct gdbarch *gdbarch, program_space *pspace) 869 { 870 for (objfile *the_objfile : pspace->objfiles ()) 871 { 872 /* Skip separate debug objects. */ 873 if (the_objfile->separate_debug_objfile_backlink != nullptr) 874 continue; 875 876 if (the_objfile->skip_jit_symbol_lookup) 877 continue; 878 879 /* Lookup the registration symbol. If it is missing, then we 880 assume we are not attached to a JIT. */ 881 bound_minimal_symbol reg_symbol 882 = lookup_minimal_symbol (jit_break_name, nullptr, the_objfile); 883 if (reg_symbol.minsym == NULL 884 || reg_symbol.value_address () == 0) 885 { 886 /* No need to repeat the lookup the next time. */ 887 the_objfile->skip_jit_symbol_lookup = true; 888 continue; 889 } 890 891 bound_minimal_symbol desc_symbol 892 = lookup_minimal_symbol (jit_descriptor_name, NULL, the_objfile); 893 if (desc_symbol.minsym == NULL 894 || desc_symbol.value_address () == 0) 895 { 896 /* No need to repeat the lookup the next time. */ 897 the_objfile->skip_jit_symbol_lookup = true; 898 continue; 899 } 900 901 jiter_objfile_data *objf_data 902 = get_jiter_objfile_data (the_objfile); 903 objf_data->register_code = reg_symbol.minsym; 904 objf_data->descriptor = desc_symbol.minsym; 905 906 CORE_ADDR addr = objf_data->register_code->value_address (the_objfile); 907 jit_debug_printf ("breakpoint_addr = %s", paddress (gdbarch, addr)); 908 909 /* Check if we need to re-create the breakpoint. */ 910 if (objf_data->cached_code_address == addr) 911 continue; 912 913 /* Delete the old breakpoint. */ 914 if (objf_data->jit_breakpoint != nullptr) 915 delete_breakpoint (objf_data->jit_breakpoint); 916 917 /* Put a breakpoint in the registration symbol. */ 918 objf_data->cached_code_address = addr; 919 objf_data->jit_breakpoint = create_jit_event_breakpoint (gdbarch, addr); 920 } 921 } 922 923 /* The private data passed around in the frame unwind callback 924 functions. */ 925 926 struct jit_unwind_private 927 { 928 /* Cached register values. See jit_frame_sniffer to see how this 929 works. */ 930 std::unique_ptr<detached_regcache> regcache; 931 932 /* The frame being unwound. */ 933 frame_info_ptr this_frame; 934 }; 935 936 /* Sets the value of a particular register in this frame. */ 937 938 static void 939 jit_unwind_reg_set_impl (struct gdb_unwind_callbacks *cb, int dwarf_regnum, 940 struct gdb_reg_value *value) 941 { 942 struct jit_unwind_private *priv; 943 int gdb_reg; 944 945 priv = (struct jit_unwind_private *) cb->priv_data; 946 947 gdb_reg = gdbarch_dwarf2_reg_to_regnum (get_frame_arch (priv->this_frame), 948 dwarf_regnum); 949 if (gdb_reg == -1) 950 { 951 jit_debug_printf ("Could not recognize DWARF regnum %d", dwarf_regnum); 952 value->free (value); 953 return; 954 } 955 956 priv->regcache->raw_supply (gdb_reg, value->value); 957 value->free (value); 958 } 959 960 static void 961 reg_value_free_impl (struct gdb_reg_value *value) 962 { 963 xfree (value); 964 } 965 966 /* Get the value of register REGNUM in the previous frame. */ 967 968 static struct gdb_reg_value * 969 jit_unwind_reg_get_impl (struct gdb_unwind_callbacks *cb, int regnum) 970 { 971 struct jit_unwind_private *priv; 972 struct gdb_reg_value *value; 973 int gdb_reg, size; 974 struct gdbarch *frame_arch; 975 976 priv = (struct jit_unwind_private *) cb->priv_data; 977 frame_arch = get_frame_arch (priv->this_frame); 978 979 gdb_reg = gdbarch_dwarf2_reg_to_regnum (frame_arch, regnum); 980 size = register_size (frame_arch, gdb_reg); 981 value = ((struct gdb_reg_value *) 982 xmalloc (sizeof (struct gdb_reg_value) + size - 1)); 983 value->defined = deprecated_frame_register_read (priv->this_frame, gdb_reg, 984 value->value); 985 value->size = size; 986 value->free = reg_value_free_impl; 987 return value; 988 } 989 990 /* gdb_reg_value has a free function, which must be called on each 991 saved register value. */ 992 993 static void 994 jit_dealloc_cache (frame_info *this_frame, void *cache) 995 { 996 struct jit_unwind_private *priv_data = (struct jit_unwind_private *) cache; 997 delete priv_data; 998 } 999 1000 /* The frame sniffer for the pseudo unwinder. 1001 1002 While this is nominally a frame sniffer, in the case where the JIT 1003 reader actually recognizes the frame, it does a lot more work -- it 1004 unwinds the frame and saves the corresponding register values in 1005 the cache. jit_frame_prev_register simply returns the saved 1006 register values. */ 1007 1008 static int 1009 jit_frame_sniffer (const struct frame_unwind *self, 1010 frame_info_ptr this_frame, void **cache) 1011 { 1012 struct jit_unwind_private *priv_data; 1013 struct gdb_unwind_callbacks callbacks; 1014 struct gdb_reader_funcs *funcs; 1015 1016 callbacks.reg_get = jit_unwind_reg_get_impl; 1017 callbacks.reg_set = jit_unwind_reg_set_impl; 1018 callbacks.target_read = jit_target_read_impl; 1019 1020 if (loaded_jit_reader == NULL) 1021 return 0; 1022 1023 funcs = loaded_jit_reader->functions; 1024 1025 gdb_assert (!*cache); 1026 1027 priv_data = new struct jit_unwind_private; 1028 *cache = priv_data; 1029 /* Take a snapshot of current regcache. */ 1030 priv_data->regcache.reset 1031 (new detached_regcache (get_frame_arch (this_frame), true)); 1032 priv_data->this_frame = this_frame; 1033 1034 callbacks.priv_data = priv_data; 1035 1036 /* Try to coax the provided unwinder to unwind the stack */ 1037 if (funcs->unwind (funcs, &callbacks) == GDB_SUCCESS) 1038 { 1039 jit_debug_printf ("Successfully unwound frame using JIT reader."); 1040 return 1; 1041 } 1042 1043 jit_debug_printf ("Could not unwind frame using JIT reader."); 1044 1045 jit_dealloc_cache (this_frame.get (), *cache); 1046 *cache = NULL; 1047 1048 return 0; 1049 } 1050 1051 1052 /* The frame_id function for the pseudo unwinder. Relays the call to 1053 the loaded plugin. */ 1054 1055 static void 1056 jit_frame_this_id (frame_info_ptr this_frame, void **cache, 1057 struct frame_id *this_id) 1058 { 1059 struct jit_unwind_private priv; 1060 struct gdb_frame_id frame_id; 1061 struct gdb_reader_funcs *funcs; 1062 struct gdb_unwind_callbacks callbacks; 1063 1064 priv.regcache.reset (); 1065 priv.this_frame = this_frame; 1066 1067 /* We don't expect the frame_id function to set any registers, so we 1068 set reg_set to NULL. */ 1069 callbacks.reg_get = jit_unwind_reg_get_impl; 1070 callbacks.reg_set = NULL; 1071 callbacks.target_read = jit_target_read_impl; 1072 callbacks.priv_data = &priv; 1073 1074 gdb_assert (loaded_jit_reader); 1075 funcs = loaded_jit_reader->functions; 1076 1077 frame_id = funcs->get_frame_id (funcs, &callbacks); 1078 *this_id = frame_id_build (frame_id.stack_address, frame_id.code_address); 1079 } 1080 1081 /* Pseudo unwinder function. Reads the previously fetched value for 1082 the register from the cache. */ 1083 1084 static struct value * 1085 jit_frame_prev_register (frame_info_ptr this_frame, void **cache, int reg) 1086 { 1087 struct jit_unwind_private *priv = (struct jit_unwind_private *) *cache; 1088 struct gdbarch *gdbarch; 1089 1090 if (priv == NULL) 1091 return frame_unwind_got_optimized (this_frame, reg); 1092 1093 gdbarch = priv->regcache->arch (); 1094 gdb_byte *buf = (gdb_byte *) alloca (register_size (gdbarch, reg)); 1095 enum register_status status = priv->regcache->cooked_read (reg, buf); 1096 1097 if (status == REG_VALID) 1098 return frame_unwind_got_bytes (this_frame, reg, buf); 1099 else 1100 return frame_unwind_got_optimized (this_frame, reg); 1101 } 1102 1103 /* Relay everything back to the unwinder registered by the JIT debug 1104 info reader.*/ 1105 1106 static const struct frame_unwind jit_frame_unwind = 1107 { 1108 "jit", 1109 NORMAL_FRAME, 1110 default_frame_unwind_stop_reason, 1111 jit_frame_this_id, 1112 jit_frame_prev_register, 1113 NULL, 1114 jit_frame_sniffer, 1115 jit_dealloc_cache 1116 }; 1117 1118 1119 /* This is the information that is stored at jit_gdbarch_data for each 1120 architecture. */ 1121 1122 struct jit_gdbarch_data_type 1123 { 1124 /* Has the (pseudo) unwinder been pretended? */ 1125 int unwinder_registered = 0; 1126 }; 1127 1128 /* An unwinder is registered for every gdbarch. This key is used to 1129 remember if the unwinder has been registered for a particular 1130 gdbarch. */ 1131 1132 static const registry<gdbarch>::key<jit_gdbarch_data_type> jit_gdbarch_data; 1133 1134 /* Check GDBARCH and prepend the pseudo JIT unwinder if needed. */ 1135 1136 static void 1137 jit_prepend_unwinder (struct gdbarch *gdbarch) 1138 { 1139 struct jit_gdbarch_data_type *data = jit_gdbarch_data.get (gdbarch); 1140 if (data == nullptr) 1141 data = jit_gdbarch_data.emplace (gdbarch); 1142 1143 if (!data->unwinder_registered) 1144 { 1145 frame_unwind_prepend_unwinder (gdbarch, &jit_frame_unwind); 1146 data->unwinder_registered = 1; 1147 } 1148 } 1149 1150 /* Register any already created translations. */ 1151 1152 static void 1153 jit_inferior_init (inferior *inf) 1154 { 1155 struct jit_descriptor descriptor; 1156 struct jit_code_entry cur_entry; 1157 CORE_ADDR cur_entry_addr; 1158 struct gdbarch *gdbarch = inf->gdbarch; 1159 program_space *pspace = inf->pspace; 1160 1161 jit_debug_printf ("called"); 1162 1163 jit_prepend_unwinder (gdbarch); 1164 1165 jit_breakpoint_re_set_internal (gdbarch, pspace); 1166 1167 for (objfile *jiter : pspace->objfiles ()) 1168 { 1169 if (jiter->jiter_data == nullptr) 1170 continue; 1171 1172 /* Read the descriptor so we can check the version number and load 1173 any already JITed functions. */ 1174 if (!jit_read_descriptor (gdbarch, &descriptor, jiter)) 1175 continue; 1176 1177 /* Check that the version number agrees with that we support. */ 1178 if (descriptor.version != 1) 1179 { 1180 gdb_printf (gdb_stderr, 1181 _("Unsupported JIT protocol version %ld " 1182 "in descriptor (expected 1)\n"), 1183 (long) descriptor.version); 1184 continue; 1185 } 1186 1187 /* If we've attached to a running program, we need to check the 1188 descriptor to register any functions that were already 1189 generated. */ 1190 for (cur_entry_addr = descriptor.first_entry; 1191 cur_entry_addr != 0; 1192 cur_entry_addr = cur_entry.next_entry) 1193 { 1194 jit_read_code_entry (gdbarch, cur_entry_addr, &cur_entry); 1195 1196 /* This hook may be called many times during setup, so make sure 1197 we don't add the same symbol file twice. */ 1198 if (jit_find_objf_with_entry_addr (cur_entry_addr) != NULL) 1199 continue; 1200 1201 jit_register_code (gdbarch, cur_entry_addr, &cur_entry); 1202 } 1203 } 1204 } 1205 1206 /* Looks for the descriptor and registration symbols and breakpoints 1207 the registration function. If it finds both, it registers all the 1208 already JITed code. If it has already found the symbols, then it 1209 doesn't try again. */ 1210 1211 static void 1212 jit_inferior_created_hook (inferior *inf) 1213 { 1214 jit_inferior_init (inf); 1215 } 1216 1217 /* Exported routine to call to re-set the jit breakpoints, 1218 e.g. when a program is rerun. */ 1219 1220 void 1221 jit_breakpoint_re_set (void) 1222 { 1223 jit_breakpoint_re_set_internal (target_gdbarch (), current_program_space); 1224 } 1225 1226 /* This function cleans up any code entries left over when the 1227 inferior exits. We get left over code when the inferior exits 1228 without unregistering its code, for example when it crashes. */ 1229 1230 static void 1231 jit_inferior_exit_hook (struct inferior *inf) 1232 { 1233 for (objfile *objf : current_program_space->objfiles_safe ()) 1234 { 1235 if (objf->jited_data != nullptr && objf->jited_data->addr != 0) 1236 objf->unlink (); 1237 } 1238 } 1239 1240 void 1241 jit_event_handler (gdbarch *gdbarch, objfile *jiter) 1242 { 1243 struct jit_descriptor descriptor; 1244 1245 /* If we get a JIT breakpoint event for this objfile, it is necessarily a 1246 JITer. */ 1247 gdb_assert (jiter->jiter_data != nullptr); 1248 1249 /* Read the descriptor from remote memory. */ 1250 if (!jit_read_descriptor (gdbarch, &descriptor, jiter)) 1251 return; 1252 CORE_ADDR entry_addr = descriptor.relevant_entry; 1253 1254 /* Do the corresponding action. */ 1255 switch (descriptor.action_flag) 1256 { 1257 case JIT_NOACTION: 1258 break; 1259 1260 case JIT_REGISTER: 1261 { 1262 jit_code_entry code_entry; 1263 jit_read_code_entry (gdbarch, entry_addr, &code_entry); 1264 jit_register_code (gdbarch, entry_addr, &code_entry); 1265 break; 1266 } 1267 1268 case JIT_UNREGISTER: 1269 { 1270 objfile *jited = jit_find_objf_with_entry_addr (entry_addr); 1271 if (jited == nullptr) 1272 gdb_printf (gdb_stderr, 1273 _("Unable to find JITed code " 1274 "entry at address: %s\n"), 1275 paddress (gdbarch, entry_addr)); 1276 else 1277 jited->unlink (); 1278 1279 break; 1280 } 1281 1282 default: 1283 error (_("Unknown action_flag value in JIT descriptor!")); 1284 break; 1285 } 1286 } 1287 1288 void _initialize_jit (); 1289 void 1290 _initialize_jit () 1291 { 1292 jit_reader_dir = relocate_gdb_directory (JIT_READER_DIR, 1293 JIT_READER_DIR_RELOCATABLE); 1294 add_setshow_boolean_cmd ("jit", class_maintenance, &jit_debug, 1295 _("Set JIT debugging."), 1296 _("Show JIT debugging."), 1297 _("When set, JIT debugging is enabled."), 1298 NULL, 1299 show_jit_debug, 1300 &setdebuglist, &showdebuglist); 1301 1302 add_cmd ("jit", class_maintenance, maint_info_jit_cmd, 1303 _("Print information about JIT-ed code objects."), 1304 &maintenanceinfolist); 1305 1306 gdb::observers::inferior_created.attach (jit_inferior_created_hook, "jit"); 1307 gdb::observers::inferior_execd.attach (jit_inferior_created_hook, "jit"); 1308 gdb::observers::inferior_exit.attach (jit_inferior_exit_hook, "jit"); 1309 gdb::observers::breakpoint_deleted.attach (jit_breakpoint_deleted, "jit"); 1310 1311 if (is_dl_available ()) 1312 { 1313 struct cmd_list_element *c; 1314 1315 c = add_com ("jit-reader-load", no_class, jit_reader_load_command, _("\ 1316 Load FILE as debug info reader and unwinder for JIT compiled code.\n\ 1317 Usage: jit-reader-load FILE\n\ 1318 Try to load file FILE as a debug info reader (and unwinder) for\n\ 1319 JIT compiled code. The file is loaded from " JIT_READER_DIR ",\n\ 1320 relocated relative to the GDB executable if required.")); 1321 set_cmd_completer (c, filename_completer); 1322 1323 c = add_com ("jit-reader-unload", no_class, 1324 jit_reader_unload_command, _("\ 1325 Unload the currently loaded JIT debug info reader.\n\ 1326 Usage: jit-reader-unload\n\n\ 1327 Do \"help jit-reader-load\" for info on loading debug info readers.")); 1328 set_cmd_completer (c, noop_completer); 1329 } 1330 } 1331