1 /* Handle JIT code generation in the inferior for GDB, the GNU Debugger.
3 Copyright (C) 2009-2022 Free Software Foundation, Inc.
5 This file is part of GDB.
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.
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.
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/>. */
23 #include "jit-reader.h"
25 #include "breakpoint.h"
27 #include "dictionary.h"
28 #include "filenames.h"
29 #include "frame-unwind.h"
33 #include "observable.h"
39 #include "gdbsupport/gdb-dlfcn.h"
42 #include "readline/tilde.h"
43 #include "completer.h"
44 #include <forward_list>
46 static std::string jit_reader_dir
;
48 static const char jit_break_name
[] = "__jit_debug_register_code";
50 static const char jit_descriptor_name
[] = "__jit_debug_descriptor";
52 static void jit_inferior_created_hook (inferior
*inf
);
53 static void jit_inferior_exit_hook (struct inferior
*inf
);
55 /* True if we want to see trace of jit level stuff. */
57 static bool jit_debug
= false;
59 /* Print a "jit" debug statement. */
61 #define jit_debug_printf(fmt, ...) \
62 debug_prefixed_printf_cond (jit_debug, "jit", fmt, ##__VA_ARGS__)
65 show_jit_debug (struct ui_file
*file
, int from_tty
,
66 struct cmd_list_element
*c
, const char *value
)
68 gdb_printf (file
, _("JIT debugging is %s.\n"), value
);
71 /* Implementation of the "maintenance info jit" command. */
74 maint_info_jit_cmd (const char *args
, int from_tty
)
76 inferior
*inf
= current_inferior ();
77 bool printed_header
= false;
79 gdb::optional
<ui_out_emit_table
> table_emitter
;
81 /* Print a line for each JIT-ed objfile. */
82 for (objfile
*obj
: inf
->pspace
->objfiles ())
84 if (obj
->jited_data
== nullptr)
89 table_emitter
.emplace (current_uiout
, 3, -1, "jit-created-objfiles");
91 /* The +2 allows for the leading '0x', then one character for
93 int addr_width
= 2 + (gdbarch_ptr_bit (obj
->arch ()) / 4);
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 ();
106 printed_header
= true;
109 ui_out_emit_tuple
tuple_emitter (current_uiout
, "jit-objfile");
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");
123 jit_reader (struct gdb_reader_funcs
*f
, gdb_dlhandle_up
&&h
)
124 : functions (f
), handle (std::move (h
))
130 functions
->destroy (functions
);
133 DISABLE_COPY_AND_ASSIGN (jit_reader
);
135 struct gdb_reader_funcs
*functions
;
136 gdb_dlhandle_up handle
;
139 /* One reader that has been loaded successfully, and can potentially be used to
142 static struct jit_reader
*loaded_jit_reader
= NULL
;
144 typedef struct gdb_reader_funcs
* (reader_init_fn_type
) (void);
145 static const char reader_init_fn_sym
[] = "gdb_init_reader";
147 /* Try to load FILE_NAME as a JIT debug info reader. */
149 static struct jit_reader
*
150 jit_reader_load (const char *file_name
)
152 reader_init_fn_type
*init_fn
;
153 struct gdb_reader_funcs
*funcs
= NULL
;
155 jit_debug_printf ("Opening shared object %s", file_name
);
157 gdb_dlhandle_up so
= gdb_dlopen (file_name
);
159 init_fn
= (reader_init_fn_type
*) gdb_dlsym (so
, reader_init_fn_sym
);
161 error (_("Could not locate initialization function: %s."),
164 if (gdb_dlsym (so
, "plugin_is_GPL_compatible") == NULL
)
165 error (_("Reader not GPL compatible."));
168 if (funcs
->reader_version
!= GDB_READER_INTERFACE_VERSION
)
169 error (_("Reader version does not match GDB version."));
171 return new jit_reader (funcs
, std::move (so
));
174 /* Provides the jit-reader-load command. */
177 jit_reader_load_command (const char *args
, int from_tty
)
180 error (_("No reader name provided."));
181 gdb::unique_xmalloc_ptr
<char> file (tilde_expand (args
));
183 if (loaded_jit_reader
!= NULL
)
184 error (_("JIT reader already loaded. Run jit-reader-unload first."));
186 if (!IS_ABSOLUTE_PATH (file
.get ()))
187 file
= xstrprintf ("%s%s%s", jit_reader_dir
.c_str (),
188 SLASH_STRING
, file
.get ());
190 loaded_jit_reader
= jit_reader_load (file
.get ());
191 reinit_frame_cache ();
192 jit_inferior_created_hook (current_inferior ());
195 /* Provides the jit-reader-unload command. */
198 jit_reader_unload_command (const char *args
, int from_tty
)
200 if (!loaded_jit_reader
)
201 error (_("No JIT reader loaded."));
203 reinit_frame_cache ();
204 jit_inferior_exit_hook (current_inferior ());
206 delete loaded_jit_reader
;
207 loaded_jit_reader
= NULL
;
210 /* Destructor for jiter_objfile_data. */
212 jiter_objfile_data::~jiter_objfile_data ()
214 if (this->jit_breakpoint
!= nullptr)
215 delete_breakpoint (this->jit_breakpoint
);
218 /* Fetch the jiter_objfile_data associated with OBJF. If no data exists
219 yet, make a new structure and attach it. */
221 static jiter_objfile_data
*
222 get_jiter_objfile_data (objfile
*objf
)
224 if (objf
->jiter_data
== nullptr)
225 objf
->jiter_data
.reset (new jiter_objfile_data ());
227 return objf
->jiter_data
.get ();
230 /* Remember OBJFILE has been created for struct jit_code_entry located
231 at inferior address ENTRY. */
234 add_objfile_entry (struct objfile
*objfile
, CORE_ADDR entry
,
235 CORE_ADDR symfile_addr
, ULONGEST symfile_size
)
237 gdb_assert (objfile
->jited_data
== nullptr);
239 objfile
->jited_data
.reset (new jited_objfile_data (entry
, symfile_addr
,
243 /* Helper function for reading the global JIT descriptor from remote
244 memory. Returns true if all went well, false otherwise. */
247 jit_read_descriptor (gdbarch
*gdbarch
,
248 jit_descriptor
*descriptor
,
252 struct type
*ptr_type
;
256 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
258 gdb_assert (jiter
!= nullptr);
259 jiter_objfile_data
*objf_data
= jiter
->jiter_data
.get ();
260 gdb_assert (objf_data
!= nullptr);
262 CORE_ADDR addr
= objf_data
->descriptor
->value_address (jiter
);
264 jit_debug_printf ("descriptor_addr = %s", paddress (gdbarch
, addr
));
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
);
272 /* Read the descriptor. */
273 err
= target_read_memory (addr
, desc_buf
, desc_size
);
276 gdb_printf (gdb_stderr
, _("Unable to read JIT descriptor from "
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
);
292 /* Helper function for reading a JITed code entry from remote memory. */
295 jit_read_code_entry (struct gdbarch
*gdbarch
,
296 CORE_ADDR code_addr
, struct jit_code_entry
*code_entry
)
299 struct type
*ptr_type
;
304 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
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 ();
310 /* Figure out where the uint64_t value will be. */
311 align_bytes
= type_align (builtin_type (gdbarch
)->builtin_uint64
);
313 off
= (off
+ (align_bytes
- 1)) & ~(align_bytes
- 1);
315 entry_size
= off
+ 8; /* Three pointers and one 64-bit int. */
316 entry_buf
= (gdb_byte
*) alloca (entry_size
);
318 /* Read the entry. */
319 err
= target_read_memory (code_addr
, entry_buf
, entry_size
);
321 error (_("Unable to read JIT code entry from remote memory!"));
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
);
334 /* Proxy object for building a block. */
338 gdb_block (gdb_block
*parent
, CORE_ADDR begin
, CORE_ADDR end
,
343 name (name
!= nullptr ? xstrdup (name
) : nullptr)
346 /* The parent of this block. */
347 struct gdb_block
*parent
;
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;
354 /* The first and last code address corresponding to this block. */
355 CORE_ADDR begin
, end
;
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
;
362 /* Proxy object for building a symtab. */
366 explicit gdb_symtab (const char *file_name
)
367 : file_name (file_name
!= nullptr ? file_name
: "")
370 /* The list of blocks in this symtab. These will eventually be
371 converted to real blocks.
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
;
379 /* The number of blocks inserted. */
382 /* A mapping between line numbers to PC. */
383 gdb::unique_xmalloc_ptr
<struct linetable
> linetable
;
385 /* The source file for this symtab. */
386 std::string file_name
;
389 /* Proxy object for building an object. */
393 /* Symtabs of this object.
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
;
402 /* The type of the `private' data passed around by the callback
405 struct jit_dbg_reader_data
407 /* Address of the jit_code_entry in the inferior's address space. */
408 CORE_ADDR entry_addr
;
410 /* The code entry, copied in our address space. */
411 const jit_code_entry
&entry
;
413 struct gdbarch
*gdbarch
;
416 /* The reader calls into this function to read data off the targets
419 static enum gdb_status
420 jit_target_read_impl (GDB_CORE_ADDR target_mem
, void *gdb_buf
, int len
)
422 int result
= target_read_memory ((CORE_ADDR
) target_mem
,
423 (gdb_byte
*) gdb_buf
, len
);
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. */
434 static struct gdb_object
*
435 jit_object_open_impl (struct gdb_symbol_callbacks
*cb
)
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
440 return new gdb_object
;
443 /* Readers call into this function to open a new gdb_symtab, which,
444 again, is passed around to other callbacks. */
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
)
451 /* CB stays unused. See comment in jit_object_open_impl. */
453 object
->symtabs
.emplace_front (file_name
);
454 return &object
->symtabs
.front ();
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
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
)
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
);
471 return &symtab
->blocks
.front ();
474 /* Readers call this to add a line mapping (from PC to line number) to
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
)
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
++)
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;
500 /* Called by readers to close a gdb_symtab. Does not need to do
501 anything as of now. */
504 jit_symtab_close_impl (struct gdb_symbol_callbacks
*cb
,
505 struct gdb_symtab
*stab
)
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
512 /* Transform STAB to a proper symtab, and add it it OBJFILE. */
515 finalize_symtab (struct gdb_symtab
*stab
, struct objfile
*objfile
)
517 struct compunit_symtab
*cust
;
518 size_t blockvector_size
;
519 CORE_ADDR begin
, end
;
520 struct blockvector
*bv
;
522 int actual_nblocks
= FIRST_LOCAL_BLOCK
+ stab
->nblocks
;
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
)
527 if (a
.begin
!= b
.begin
)
528 return a
.begin
< b
.begin
;
530 return a
.end
> b
.end
;
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
);
537 /* JIT compilers compile in memory. */
538 cust
->set_dirname (nullptr);
540 /* Copy over the linetable entry if one was provided. */
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
);
551 blockvector_size
= (sizeof (struct blockvector
)
552 + (actual_nblocks
- 1) * sizeof (struct block
*));
553 bv
= (struct blockvector
*) obstack_alloc (&objfile
->objfile_obstack
,
555 cust
->set_blockvector (bv
);
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
);
564 /* First run over all the gdb_block objects, creating a real block
565 object for each. Simultaneously, keep setting the real_block
567 int block_idx
= FIRST_LOCAL_BLOCK
;
568 for (gdb_block
&gdb_block_iter
: stab
->blocks
)
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 (),
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
);
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
);
590 block_name
->m_name
= obstack_strdup (&objfile
->objfile_obstack
,
591 gdb_block_iter
.name
.get ());
593 new_block
->set_function (block_name
);
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 ();
601 gdb_block_iter
.real_block
= new_block
;
606 /* Now add the special blocks. */
607 struct block
*block_iter
= NULL
;
608 for (enum block_enum i
: { GLOBAL_BLOCK
, STATIC_BLOCK
})
610 struct block
*new_block
;
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
;
620 new_block
->set_start (begin
);
621 new_block
->set_end (end
);
623 bv
->set_block (i
, new_block
);
625 if (i
== GLOBAL_BLOCK
)
626 set_block_compunit_symtab (new_block
, cust
);
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
)
633 if (gdb_block_iter
.parent
!= NULL
)
635 /* If the plugin specifically mentioned a parent block, we
637 gdb_block_iter
.real_block
->set_superblock
638 (gdb_block_iter
.parent
->real_block
);
643 /* And if not, we set a default parent block. */
644 gdb_block_iter
.real_block
->set_superblock (bv
->static_block ());
649 /* Called when closing a gdb_objfile. Converts OBJ to a proper
653 jit_object_close_impl (struct gdb_symbol_callbacks
*cb
,
654 struct gdb_object
*obj
)
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
));
662 objfile
*objfile
= objfile::make (nullptr, objfile_name
.c_str (),
664 objfile
->per_bfd
->gdbarch
= priv_data
->gdbarch
;
666 for (gdb_symtab
&symtab
: obj
->symtabs
)
667 finalize_symtab (&symtab
, objfile
);
669 add_objfile_entry (objfile
, priv_data
->entry_addr
,
670 priv_data
->entry
.symfile_addr
,
671 priv_data
->entry
.symfile_size
);
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. */
681 jit_reader_try_read_symtab (gdbarch
*gdbarch
, jit_code_entry
*code_entry
,
682 CORE_ADDR entry_addr
)
685 jit_dbg_reader_data priv_data
691 struct gdb_reader_funcs
*funcs
;
692 struct gdb_symbol_callbacks callbacks
=
694 jit_object_open_impl
,
695 jit_symtab_open_impl
,
697 jit_symtab_close_impl
,
698 jit_object_close_impl
,
700 jit_symtab_line_mapping_add_impl
,
701 jit_target_read_impl
,
706 if (!loaded_jit_reader
)
709 gdb::byte_vector
gdb_mem (code_entry
->symfile_size
);
714 if (target_read_memory (code_entry
->symfile_addr
, gdb_mem
.data (),
715 code_entry
->symfile_size
))
718 catch (const gdb_exception
&e
)
725 funcs
= loaded_jit_reader
->functions
;
726 if (funcs
->read (funcs
, &callbacks
, gdb_mem
.data (),
727 code_entry
->symfile_size
)
733 jit_debug_printf ("Could not read symtab using the loaded JIT reader.");
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. */
742 jit_bfd_try_read_symtab (struct jit_code_entry
*code_entry
,
743 CORE_ADDR entry_addr
,
744 struct gdbarch
*gdbarch
)
746 struct bfd_section
*sec
;
747 struct objfile
*objfile
;
748 const struct bfd_arch_info
*b
;
750 jit_debug_printf ("symfile_addr = %s, symfile_size = %s",
751 paddress (gdbarch
, code_entry
->symfile_addr
),
752 pulongest (code_entry
->symfile_size
));
754 gdb_bfd_ref_ptr
nbfd (gdb_bfd_open_from_target_memory
755 (code_entry
->symfile_addr
, code_entry
->symfile_size
, gnutarget
));
758 gdb_puts (_("Error opening JITed symbol file, ignoring it.\n"),
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
))
767 gdb_printf (gdb_stderr
, _("\
768 JITed symbol file is not an object file, ignoring it.\n"));
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
,
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)
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
),
794 /* This call does not take ownership of SAI. */
795 objfile
= symbol_file_add_from_bfd (nbfd
,
796 bfd_get_filename (nbfd
.get ()), 0,
798 OBJF_SHARED
| OBJF_NOT_FILENAME
, NULL
);
800 add_objfile_entry (objfile
, entry_addr
, code_entry
->symfile_addr
,
801 code_entry
->symfile_size
);
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. */
810 jit_register_code (struct gdbarch
*gdbarch
,
811 CORE_ADDR entry_addr
, struct jit_code_entry
*code_entry
)
815 jit_debug_printf ("symfile_addr = %s, symfile_size = %s",
816 paddress (gdbarch
, code_entry
->symfile_addr
),
817 pulongest (code_entry
->symfile_size
));
819 success
= jit_reader_try_read_symtab (gdbarch
, code_entry
, entry_addr
);
822 jit_bfd_try_read_symtab (code_entry
, entry_addr
, gdbarch
);
825 /* Look up the objfile with this code entry address. */
827 static struct objfile
*
828 jit_find_objf_with_entry_addr (CORE_ADDR entry_addr
)
830 for (objfile
*objf
: current_program_space
->objfiles ())
832 if (objf
->jited_data
!= nullptr && objf
->jited_data
->addr
== entry_addr
)
839 /* This is called when a breakpoint is deleted. It updates the
840 inferior's cache, if needed. */
843 jit_breakpoint_deleted (struct breakpoint
*b
)
845 if (b
->type
!= bp_jit_event
)
848 for (bp_location
*iter
: b
->locations ())
850 for (objfile
*objf
: iter
->pspace
->objfiles ())
852 jiter_objfile_data
*jiter_data
= objf
->jiter_data
.get ();
854 if (jiter_data
!= nullptr
855 && jiter_data
->jit_breakpoint
== iter
->owner
)
857 jiter_data
->cached_code_address
= 0;
858 jiter_data
->jit_breakpoint
= nullptr;
864 /* (Re-)Initialize the jit breakpoints for JIT-producing objfiles in
868 jit_breakpoint_re_set_internal (struct gdbarch
*gdbarch
, program_space
*pspace
)
870 for (objfile
*the_objfile
: pspace
->objfiles ())
872 /* Skip separate debug objects. */
873 if (the_objfile
->separate_debug_objfile_backlink
!= nullptr)
876 if (the_objfile
->skip_jit_symbol_lookup
)
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)
886 /* No need to repeat the lookup the next time. */
887 the_objfile
->skip_jit_symbol_lookup
= true;
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)
896 /* No need to repeat the lookup the next time. */
897 the_objfile
->skip_jit_symbol_lookup
= true;
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
;
906 CORE_ADDR addr
= objf_data
->register_code
->value_address (the_objfile
);
907 jit_debug_printf ("breakpoint_addr = %s", paddress (gdbarch
, addr
));
909 /* Check if we need to re-create the breakpoint. */
910 if (objf_data
->cached_code_address
== addr
)
913 /* Delete the old breakpoint. */
914 if (objf_data
->jit_breakpoint
!= nullptr)
915 delete_breakpoint (objf_data
->jit_breakpoint
);
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
);
923 /* The private data passed around in the frame unwind callback
926 struct jit_unwind_private
928 /* Cached register values. See jit_frame_sniffer to see how this
930 std::unique_ptr
<detached_regcache
> regcache
;
932 /* The frame being unwound. */
933 frame_info_ptr this_frame
;
936 /* Sets the value of a particular register in this frame. */
939 jit_unwind_reg_set_impl (struct gdb_unwind_callbacks
*cb
, int dwarf_regnum
,
940 struct gdb_reg_value
*value
)
942 struct jit_unwind_private
*priv
;
945 priv
= (struct jit_unwind_private
*) cb
->priv_data
;
947 gdb_reg
= gdbarch_dwarf2_reg_to_regnum (get_frame_arch (priv
->this_frame
),
951 jit_debug_printf ("Could not recognize DWARF regnum %d", dwarf_regnum
);
956 priv
->regcache
->raw_supply (gdb_reg
, value
->value
);
961 reg_value_free_impl (struct gdb_reg_value
*value
)
966 /* Get the value of register REGNUM in the previous frame. */
968 static struct gdb_reg_value
*
969 jit_unwind_reg_get_impl (struct gdb_unwind_callbacks
*cb
, int regnum
)
971 struct jit_unwind_private
*priv
;
972 struct gdb_reg_value
*value
;
974 struct gdbarch
*frame_arch
;
976 priv
= (struct jit_unwind_private
*) cb
->priv_data
;
977 frame_arch
= get_frame_arch (priv
->this_frame
);
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
,
986 value
->free
= reg_value_free_impl
;
990 /* gdb_reg_value has a free function, which must be called on each
991 saved register value. */
994 jit_dealloc_cache (frame_info
*this_frame
, void *cache
)
996 struct jit_unwind_private
*priv_data
= (struct jit_unwind_private
*) cache
;
1000 /* The frame sniffer for the pseudo unwinder.
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
1009 jit_frame_sniffer (const struct frame_unwind
*self
,
1010 frame_info_ptr this_frame
, void **cache
)
1012 struct jit_unwind_private
*priv_data
;
1013 struct gdb_unwind_callbacks callbacks
;
1014 struct gdb_reader_funcs
*funcs
;
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
;
1020 if (loaded_jit_reader
== NULL
)
1023 funcs
= loaded_jit_reader
->functions
;
1025 gdb_assert (!*cache
);
1027 priv_data
= new struct jit_unwind_private
;
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
;
1034 callbacks
.priv_data
= priv_data
;
1036 /* Try to coax the provided unwinder to unwind the stack */
1037 if (funcs
->unwind (funcs
, &callbacks
) == GDB_SUCCESS
)
1039 jit_debug_printf ("Successfully unwound frame using JIT reader.");
1043 jit_debug_printf ("Could not unwind frame using JIT reader.");
1045 jit_dealloc_cache (this_frame
.get (), *cache
);
1052 /* The frame_id function for the pseudo unwinder. Relays the call to
1053 the loaded plugin. */
1056 jit_frame_this_id (frame_info_ptr this_frame
, void **cache
,
1057 struct frame_id
*this_id
)
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
;
1064 priv
.regcache
.reset ();
1065 priv
.this_frame
= this_frame
;
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
;
1074 gdb_assert (loaded_jit_reader
);
1075 funcs
= loaded_jit_reader
->functions
;
1077 frame_id
= funcs
->get_frame_id (funcs
, &callbacks
);
1078 *this_id
= frame_id_build (frame_id
.stack_address
, frame_id
.code_address
);
1081 /* Pseudo unwinder function. Reads the previously fetched value for
1082 the register from the cache. */
1084 static struct value
*
1085 jit_frame_prev_register (frame_info_ptr this_frame
, void **cache
, int reg
)
1087 struct jit_unwind_private
*priv
= (struct jit_unwind_private
*) *cache
;
1088 struct gdbarch
*gdbarch
;
1091 return frame_unwind_got_optimized (this_frame
, reg
);
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
);
1097 if (status
== REG_VALID
)
1098 return frame_unwind_got_bytes (this_frame
, reg
, buf
);
1100 return frame_unwind_got_optimized (this_frame
, reg
);
1103 /* Relay everything back to the unwinder registered by the JIT debug
1106 static const struct frame_unwind jit_frame_unwind
=
1110 default_frame_unwind_stop_reason
,
1112 jit_frame_prev_register
,
1119 /* This is the information that is stored at jit_gdbarch_data for each
1122 struct jit_gdbarch_data_type
1124 /* Has the (pseudo) unwinder been pretended? */
1125 int unwinder_registered
= 0;
1128 /* An unwinder is registered for every gdbarch. This key is used to
1129 remember if the unwinder has been registered for a particular
1132 static const registry
<gdbarch
>::key
<jit_gdbarch_data_type
> jit_gdbarch_data
;
1134 /* Check GDBARCH and prepend the pseudo JIT unwinder if needed. */
1137 jit_prepend_unwinder (struct gdbarch
*gdbarch
)
1139 struct jit_gdbarch_data_type
*data
= jit_gdbarch_data
.get (gdbarch
);
1140 if (data
== nullptr)
1141 data
= jit_gdbarch_data
.emplace (gdbarch
);
1143 if (!data
->unwinder_registered
)
1145 frame_unwind_prepend_unwinder (gdbarch
, &jit_frame_unwind
);
1146 data
->unwinder_registered
= 1;
1150 /* Register any already created translations. */
1153 jit_inferior_init (inferior
*inf
)
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
;
1161 jit_debug_printf ("called");
1163 jit_prepend_unwinder (gdbarch
);
1165 jit_breakpoint_re_set_internal (gdbarch
, pspace
);
1167 for (objfile
*jiter
: pspace
->objfiles ())
1169 if (jiter
->jiter_data
== nullptr)
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
))
1177 /* Check that the version number agrees with that we support. */
1178 if (descriptor
.version
!= 1)
1180 gdb_printf (gdb_stderr
,
1181 _("Unsupported JIT protocol version %ld "
1182 "in descriptor (expected 1)\n"),
1183 (long) descriptor
.version
);
1187 /* If we've attached to a running program, we need to check the
1188 descriptor to register any functions that were already
1190 for (cur_entry_addr
= descriptor
.first_entry
;
1191 cur_entry_addr
!= 0;
1192 cur_entry_addr
= cur_entry
.next_entry
)
1194 jit_read_code_entry (gdbarch
, cur_entry_addr
, &cur_entry
);
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
)
1201 jit_register_code (gdbarch
, cur_entry_addr
, &cur_entry
);
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. */
1212 jit_inferior_created_hook (inferior
*inf
)
1214 jit_inferior_init (inf
);
1217 /* Exported routine to call to re-set the jit breakpoints,
1218 e.g. when a program is rerun. */
1221 jit_breakpoint_re_set (void)
1223 jit_breakpoint_re_set_internal (target_gdbarch (), current_program_space
);
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. */
1231 jit_inferior_exit_hook (struct inferior
*inf
)
1233 for (objfile
*objf
: current_program_space
->objfiles_safe ())
1235 if (objf
->jited_data
!= nullptr && objf
->jited_data
->addr
!= 0)
1241 jit_event_handler (gdbarch
*gdbarch
, objfile
*jiter
)
1243 struct jit_descriptor descriptor
;
1245 /* If we get a JIT breakpoint event for this objfile, it is necessarily a
1247 gdb_assert (jiter
->jiter_data
!= nullptr);
1249 /* Read the descriptor from remote memory. */
1250 if (!jit_read_descriptor (gdbarch
, &descriptor
, jiter
))
1252 CORE_ADDR entry_addr
= descriptor
.relevant_entry
;
1254 /* Do the corresponding action. */
1255 switch (descriptor
.action_flag
)
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
);
1268 case JIT_UNREGISTER
:
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
));
1283 error (_("Unknown action_flag value in JIT descriptor!"));
1288 void _initialize_jit ();
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."),
1300 &setdebuglist
, &showdebuglist
);
1302 add_cmd ("jit", class_maintenance
, maint_info_jit_cmd
,
1303 _("Print information about JIT-ed code objects."),
1304 &maintenanceinfolist
);
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");
1311 if (is_dl_available ())
1313 struct cmd_list_element
*c
;
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
);
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
);