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 /* An unwinder is registered for every gdbarch. This key is used to
56 remember if the unwinder has been registered for a particular
59 static struct gdbarch_data
*jit_gdbarch_data
;
61 /* True if we want to see trace of jit level stuff. */
63 static bool jit_debug
= false;
65 /* Print a "jit" debug statement. */
67 #define jit_debug_printf(fmt, ...) \
68 debug_prefixed_printf_cond (jit_debug, "jit", fmt, ##__VA_ARGS__)
71 show_jit_debug (struct ui_file
*file
, int from_tty
,
72 struct cmd_list_element
*c
, const char *value
)
74 fprintf_filtered (file
, _("JIT debugging is %s.\n"), value
);
77 /* Implementation of the "maintenance info jit" command. */
80 maint_info_jit_cmd (const char *args
, int from_tty
)
82 inferior
*inf
= current_inferior ();
83 bool printed_header
= false;
85 /* Print a line for each JIT-ed objfile. */
86 for (objfile
*obj
: inf
->pspace
->objfiles ())
88 if (obj
->jited_data
== nullptr)
93 printf_filtered ("Base address of known JIT-ed objfiles:\n");
94 printed_header
= true;
97 printf_filtered (" %s\n", paddress (obj
->arch (), obj
->jited_data
->addr
));
103 jit_reader (struct gdb_reader_funcs
*f
, gdb_dlhandle_up
&&h
)
104 : functions (f
), handle (std::move (h
))
110 functions
->destroy (functions
);
113 DISABLE_COPY_AND_ASSIGN (jit_reader
);
115 struct gdb_reader_funcs
*functions
;
116 gdb_dlhandle_up handle
;
119 /* One reader that has been loaded successfully, and can potentially be used to
122 static struct jit_reader
*loaded_jit_reader
= NULL
;
124 typedef struct gdb_reader_funcs
* (reader_init_fn_type
) (void);
125 static const char reader_init_fn_sym
[] = "gdb_init_reader";
127 /* Try to load FILE_NAME as a JIT debug info reader. */
129 static struct jit_reader
*
130 jit_reader_load (const char *file_name
)
132 reader_init_fn_type
*init_fn
;
133 struct gdb_reader_funcs
*funcs
= NULL
;
135 jit_debug_printf ("Opening shared object %s", file_name
);
137 gdb_dlhandle_up so
= gdb_dlopen (file_name
);
139 init_fn
= (reader_init_fn_type
*) gdb_dlsym (so
, reader_init_fn_sym
);
141 error (_("Could not locate initialization function: %s."),
144 if (gdb_dlsym (so
, "plugin_is_GPL_compatible") == NULL
)
145 error (_("Reader not GPL compatible."));
148 if (funcs
->reader_version
!= GDB_READER_INTERFACE_VERSION
)
149 error (_("Reader version does not match GDB version."));
151 return new jit_reader (funcs
, std::move (so
));
154 /* Provides the jit-reader-load command. */
157 jit_reader_load_command (const char *args
, int from_tty
)
160 error (_("No reader name provided."));
161 gdb::unique_xmalloc_ptr
<char> file (tilde_expand (args
));
163 if (loaded_jit_reader
!= NULL
)
164 error (_("JIT reader already loaded. Run jit-reader-unload first."));
166 if (!IS_ABSOLUTE_PATH (file
.get ()))
167 file
= xstrprintf ("%s%s%s", jit_reader_dir
.c_str (),
168 SLASH_STRING
, file
.get ());
170 loaded_jit_reader
= jit_reader_load (file
.get ());
171 reinit_frame_cache ();
172 jit_inferior_created_hook (current_inferior ());
175 /* Provides the jit-reader-unload command. */
178 jit_reader_unload_command (const char *args
, int from_tty
)
180 if (!loaded_jit_reader
)
181 error (_("No JIT reader loaded."));
183 reinit_frame_cache ();
184 jit_inferior_exit_hook (current_inferior ());
186 delete loaded_jit_reader
;
187 loaded_jit_reader
= NULL
;
190 /* Destructor for jiter_objfile_data. */
192 jiter_objfile_data::~jiter_objfile_data ()
194 if (this->jit_breakpoint
!= nullptr)
195 delete_breakpoint (this->jit_breakpoint
);
198 /* Fetch the jiter_objfile_data associated with OBJF. If no data exists
199 yet, make a new structure and attach it. */
201 static jiter_objfile_data
*
202 get_jiter_objfile_data (objfile
*objf
)
204 if (objf
->jiter_data
== nullptr)
205 objf
->jiter_data
.reset (new jiter_objfile_data ());
207 return objf
->jiter_data
.get ();
210 /* Remember OBJFILE has been created for struct jit_code_entry located
211 at inferior address ENTRY. */
214 add_objfile_entry (struct objfile
*objfile
, CORE_ADDR entry
)
216 gdb_assert (objfile
->jited_data
== nullptr);
218 objfile
->jited_data
.reset (new jited_objfile_data (entry
));
221 /* Helper function for reading the global JIT descriptor from remote
222 memory. Returns true if all went well, false otherwise. */
225 jit_read_descriptor (gdbarch
*gdbarch
,
226 jit_descriptor
*descriptor
,
230 struct type
*ptr_type
;
234 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
236 gdb_assert (jiter
!= nullptr);
237 jiter_objfile_data
*objf_data
= jiter
->jiter_data
.get ();
238 gdb_assert (objf_data
!= nullptr);
240 CORE_ADDR addr
= MSYMBOL_VALUE_ADDRESS (jiter
, objf_data
->descriptor
);
242 jit_debug_printf ("descriptor_addr = %s", paddress (gdbarch
, addr
));
244 /* Figure out how big the descriptor is on the remote and how to read it. */
245 ptr_type
= builtin_type (gdbarch
)->builtin_data_ptr
;
246 ptr_size
= TYPE_LENGTH (ptr_type
);
247 desc_size
= 8 + 2 * ptr_size
; /* Two 32-bit ints and two pointers. */
248 desc_buf
= (gdb_byte
*) alloca (desc_size
);
250 /* Read the descriptor. */
251 err
= target_read_memory (addr
, desc_buf
, desc_size
);
254 fprintf_unfiltered (gdb_stderr
, _("Unable to read JIT descriptor from "
259 /* Fix the endianness to match the host. */
260 descriptor
->version
= extract_unsigned_integer (&desc_buf
[0], 4, byte_order
);
261 descriptor
->action_flag
=
262 extract_unsigned_integer (&desc_buf
[4], 4, byte_order
);
263 descriptor
->relevant_entry
= extract_typed_address (&desc_buf
[8], ptr_type
);
264 descriptor
->first_entry
=
265 extract_typed_address (&desc_buf
[8 + ptr_size
], ptr_type
);
270 /* Helper function for reading a JITed code entry from remote memory. */
273 jit_read_code_entry (struct gdbarch
*gdbarch
,
274 CORE_ADDR code_addr
, struct jit_code_entry
*code_entry
)
277 struct type
*ptr_type
;
282 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
284 /* Figure out how big the entry is on the remote and how to read it. */
285 ptr_type
= builtin_type (gdbarch
)->builtin_data_ptr
;
286 ptr_size
= TYPE_LENGTH (ptr_type
);
288 /* Figure out where the uint64_t value will be. */
289 align_bytes
= type_align (builtin_type (gdbarch
)->builtin_uint64
);
291 off
= (off
+ (align_bytes
- 1)) & ~(align_bytes
- 1);
293 entry_size
= off
+ 8; /* Three pointers and one 64-bit int. */
294 entry_buf
= (gdb_byte
*) alloca (entry_size
);
296 /* Read the entry. */
297 err
= target_read_memory (code_addr
, entry_buf
, entry_size
);
299 error (_("Unable to read JIT code entry from remote memory!"));
301 /* Fix the endianness to match the host. */
302 ptr_type
= builtin_type (gdbarch
)->builtin_data_ptr
;
303 code_entry
->next_entry
= extract_typed_address (&entry_buf
[0], ptr_type
);
304 code_entry
->prev_entry
=
305 extract_typed_address (&entry_buf
[ptr_size
], ptr_type
);
306 code_entry
->symfile_addr
=
307 extract_typed_address (&entry_buf
[2 * ptr_size
], ptr_type
);
308 code_entry
->symfile_size
=
309 extract_unsigned_integer (&entry_buf
[off
], 8, byte_order
);
312 /* Proxy object for building a block. */
316 gdb_block (gdb_block
*parent
, CORE_ADDR begin
, CORE_ADDR end
,
321 name (name
!= nullptr ? xstrdup (name
) : nullptr)
324 /* The parent of this block. */
325 struct gdb_block
*parent
;
327 /* Points to the "real" block that is being built out of this
328 instance. This block will be added to a blockvector, which will
329 then be added to a symtab. */
330 struct block
*real_block
= nullptr;
332 /* The first and last code address corresponding to this block. */
333 CORE_ADDR begin
, end
;
335 /* The name of this block (if any). If this is non-NULL, the
336 FUNCTION symbol symbol is set to this value. */
337 gdb::unique_xmalloc_ptr
<char> name
;
340 /* Proxy object for building a symtab. */
344 explicit gdb_symtab (const char *file_name
)
345 : file_name (file_name
!= nullptr ? file_name
: "")
348 /* The list of blocks in this symtab. These will eventually be
349 converted to real blocks.
351 This is specifically a linked list, instead of, for example, a vector,
352 because the pointers are returned to the user's debug info reader. So
353 it's important that the objects don't change location during their
354 lifetime (which would happen with a vector of objects getting resized). */
355 std::forward_list
<gdb_block
> blocks
;
357 /* The number of blocks inserted. */
360 /* A mapping between line numbers to PC. */
361 gdb::unique_xmalloc_ptr
<struct linetable
> linetable
;
363 /* The source file for this symtab. */
364 std::string file_name
;
367 /* Proxy object for building an object. */
371 /* Symtabs of this object.
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_symtab
> symtabs
;
380 /* The type of the `private' data passed around by the callback
383 struct jit_dbg_reader_data
385 /* Address of the jit_code_entry in the inferior's address space. */
386 CORE_ADDR entry_addr
;
388 /* The code entry, copied in our address space. */
389 const jit_code_entry
&entry
;
391 struct gdbarch
*gdbarch
;
394 /* The reader calls into this function to read data off the targets
397 static enum gdb_status
398 jit_target_read_impl (GDB_CORE_ADDR target_mem
, void *gdb_buf
, int len
)
400 int result
= target_read_memory ((CORE_ADDR
) target_mem
,
401 (gdb_byte
*) gdb_buf
, len
);
408 /* The reader calls into this function to create a new gdb_object
409 which it can then pass around to the other callbacks. Right now,
410 all that is required is allocating the memory. */
412 static struct gdb_object
*
413 jit_object_open_impl (struct gdb_symbol_callbacks
*cb
)
415 /* CB is not required right now, but sometime in the future we might
416 need a handle to it, and we'd like to do that without breaking
418 return new gdb_object
;
421 /* Readers call into this function to open a new gdb_symtab, which,
422 again, is passed around to other callbacks. */
424 static struct gdb_symtab
*
425 jit_symtab_open_impl (struct gdb_symbol_callbacks
*cb
,
426 struct gdb_object
*object
,
427 const char *file_name
)
429 /* CB stays unused. See comment in jit_object_open_impl. */
431 object
->symtabs
.emplace_front (file_name
);
432 return &object
->symtabs
.front ();
435 /* Called by readers to open a new gdb_block. This function also
436 inserts the new gdb_block in the correct place in the corresponding
439 static struct gdb_block
*
440 jit_block_open_impl (struct gdb_symbol_callbacks
*cb
,
441 struct gdb_symtab
*symtab
, struct gdb_block
*parent
,
442 GDB_CORE_ADDR begin
, GDB_CORE_ADDR end
, const char *name
)
444 /* Place the block at the beginning of the list, it will be sorted when the
445 symtab is finalized. */
446 symtab
->blocks
.emplace_front (parent
, begin
, end
, name
);
449 return &symtab
->blocks
.front ();
452 /* Readers call this to add a line mapping (from PC to line number) to
456 jit_symtab_line_mapping_add_impl (struct gdb_symbol_callbacks
*cb
,
457 struct gdb_symtab
*stab
, int nlines
,
458 struct gdb_line_mapping
*map
)
466 alloc_len
= sizeof (struct linetable
)
467 + (nlines
- 1) * sizeof (struct linetable_entry
);
468 stab
->linetable
.reset (XNEWVAR (struct linetable
, alloc_len
));
469 stab
->linetable
->nitems
= nlines
;
470 for (i
= 0; i
< nlines
; i
++)
472 stab
->linetable
->item
[i
].pc
= (CORE_ADDR
) map
[i
].pc
;
473 stab
->linetable
->item
[i
].line
= map
[i
].line
;
474 stab
->linetable
->item
[i
].is_stmt
= 1;
478 /* Called by readers to close a gdb_symtab. Does not need to do
479 anything as of now. */
482 jit_symtab_close_impl (struct gdb_symbol_callbacks
*cb
,
483 struct gdb_symtab
*stab
)
485 /* Right now nothing needs to be done here. We may need to do some
486 cleanup here in the future (again, without breaking the plugin
490 /* Transform STAB to a proper symtab, and add it it OBJFILE. */
493 finalize_symtab (struct gdb_symtab
*stab
, struct objfile
*objfile
)
495 struct compunit_symtab
*cust
;
496 size_t blockvector_size
;
497 CORE_ADDR begin
, end
;
498 struct blockvector
*bv
;
500 int actual_nblocks
= FIRST_LOCAL_BLOCK
+ stab
->nblocks
;
502 /* Sort the blocks in the order they should appear in the blockvector. */
503 stab
->blocks
.sort([] (const gdb_block
&a
, const gdb_block
&b
)
505 if (a
.begin
!= b
.begin
)
506 return a
.begin
< b
.begin
;
508 return a
.end
> b
.end
;
511 cust
= allocate_compunit_symtab (objfile
, stab
->file_name
.c_str ());
512 allocate_symtab (cust
, stab
->file_name
.c_str ());
513 add_compunit_symtab_to_objfile (cust
);
515 /* JIT compilers compile in memory. */
516 COMPUNIT_DIRNAME (cust
) = NULL
;
518 /* Copy over the linetable entry if one was provided. */
521 size_t size
= ((stab
->linetable
->nitems
- 1)
522 * sizeof (struct linetable_entry
)
523 + sizeof (struct linetable
));
524 SYMTAB_LINETABLE (COMPUNIT_FILETABS (cust
))
525 = (struct linetable
*) obstack_alloc (&objfile
->objfile_obstack
, size
);
526 memcpy (SYMTAB_LINETABLE (COMPUNIT_FILETABS (cust
)),
527 stab
->linetable
.get (), size
);
530 blockvector_size
= (sizeof (struct blockvector
)
531 + (actual_nblocks
- 1) * sizeof (struct block
*));
532 bv
= (struct blockvector
*) obstack_alloc (&objfile
->objfile_obstack
,
534 COMPUNIT_BLOCKVECTOR (cust
) = bv
;
536 /* At the end of this function, (begin, end) will contain the PC range this
537 entire blockvector spans. */
538 BLOCKVECTOR_MAP (bv
) = NULL
;
539 begin
= stab
->blocks
.front ().begin
;
540 end
= stab
->blocks
.front ().end
;
541 BLOCKVECTOR_NBLOCKS (bv
) = actual_nblocks
;
543 /* First run over all the gdb_block objects, creating a real block
544 object for each. Simultaneously, keep setting the real_block
546 int block_idx
= FIRST_LOCAL_BLOCK
;
547 for (gdb_block
&gdb_block_iter
: stab
->blocks
)
549 struct block
*new_block
= allocate_block (&objfile
->objfile_obstack
);
550 struct symbol
*block_name
= new (&objfile
->objfile_obstack
) symbol
;
551 struct type
*block_type
= arch_type (objfile
->arch (),
556 BLOCK_MULTIDICT (new_block
)
557 = mdict_create_linear (&objfile
->objfile_obstack
, NULL
);
558 /* The address range. */
559 BLOCK_START (new_block
) = (CORE_ADDR
) gdb_block_iter
.begin
;
560 BLOCK_END (new_block
) = (CORE_ADDR
) gdb_block_iter
.end
;
563 SYMBOL_DOMAIN (block_name
) = VAR_DOMAIN
;
564 SYMBOL_ACLASS_INDEX (block_name
) = LOC_BLOCK
;
565 symbol_set_symtab (block_name
, COMPUNIT_FILETABS (cust
));
566 SYMBOL_TYPE (block_name
) = lookup_function_type (block_type
);
567 SYMBOL_BLOCK_VALUE (block_name
) = new_block
;
569 block_name
->m_name
= obstack_strdup (&objfile
->objfile_obstack
,
570 gdb_block_iter
.name
.get ());
572 BLOCK_FUNCTION (new_block
) = block_name
;
574 BLOCKVECTOR_BLOCK (bv
, block_idx
) = new_block
;
575 if (begin
> BLOCK_START (new_block
))
576 begin
= BLOCK_START (new_block
);
577 if (end
< BLOCK_END (new_block
))
578 end
= BLOCK_END (new_block
);
580 gdb_block_iter
.real_block
= new_block
;
585 /* Now add the special blocks. */
586 struct block
*block_iter
= NULL
;
587 for (enum block_enum i
: { GLOBAL_BLOCK
, STATIC_BLOCK
})
589 struct block
*new_block
;
591 new_block
= (i
== GLOBAL_BLOCK
592 ? allocate_global_block (&objfile
->objfile_obstack
)
593 : allocate_block (&objfile
->objfile_obstack
));
594 BLOCK_MULTIDICT (new_block
)
595 = mdict_create_linear (&objfile
->objfile_obstack
, NULL
);
596 BLOCK_SUPERBLOCK (new_block
) = block_iter
;
597 block_iter
= new_block
;
599 BLOCK_START (new_block
) = (CORE_ADDR
) begin
;
600 BLOCK_END (new_block
) = (CORE_ADDR
) end
;
602 BLOCKVECTOR_BLOCK (bv
, i
) = new_block
;
604 if (i
== GLOBAL_BLOCK
)
605 set_block_compunit_symtab (new_block
, cust
);
608 /* Fill up the superblock fields for the real blocks, using the
609 real_block fields populated earlier. */
610 for (gdb_block
&gdb_block_iter
: stab
->blocks
)
612 if (gdb_block_iter
.parent
!= NULL
)
614 /* If the plugin specifically mentioned a parent block, we
616 BLOCK_SUPERBLOCK (gdb_block_iter
.real_block
) =
617 gdb_block_iter
.parent
->real_block
;
621 /* And if not, we set a default parent block. */
622 BLOCK_SUPERBLOCK (gdb_block_iter
.real_block
) =
623 BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
);
628 /* Called when closing a gdb_objfile. Converts OBJ to a proper
632 jit_object_close_impl (struct gdb_symbol_callbacks
*cb
,
633 struct gdb_object
*obj
)
635 jit_dbg_reader_data
*priv_data
= (jit_dbg_reader_data
*) cb
->priv_data
;
636 std::string objfile_name
637 = string_printf ("<< JIT compiled code at %s >>",
638 paddress (priv_data
->gdbarch
,
639 priv_data
->entry
.symfile_addr
));
641 objfile
*objfile
= objfile::make (nullptr, objfile_name
.c_str (),
643 objfile
->per_bfd
->gdbarch
= priv_data
->gdbarch
;
645 for (gdb_symtab
&symtab
: obj
->symtabs
)
646 finalize_symtab (&symtab
, objfile
);
648 add_objfile_entry (objfile
, priv_data
->entry_addr
);
653 /* Try to read CODE_ENTRY using the loaded jit reader (if any).
654 ENTRY_ADDR is the address of the struct jit_code_entry in the
655 inferior address space. */
658 jit_reader_try_read_symtab (gdbarch
*gdbarch
, jit_code_entry
*code_entry
,
659 CORE_ADDR entry_addr
)
662 jit_dbg_reader_data priv_data
668 struct gdb_reader_funcs
*funcs
;
669 struct gdb_symbol_callbacks callbacks
=
671 jit_object_open_impl
,
672 jit_symtab_open_impl
,
674 jit_symtab_close_impl
,
675 jit_object_close_impl
,
677 jit_symtab_line_mapping_add_impl
,
678 jit_target_read_impl
,
683 if (!loaded_jit_reader
)
686 gdb::byte_vector
gdb_mem (code_entry
->symfile_size
);
691 if (target_read_memory (code_entry
->symfile_addr
, gdb_mem
.data (),
692 code_entry
->symfile_size
))
695 catch (const gdb_exception
&e
)
702 funcs
= loaded_jit_reader
->functions
;
703 if (funcs
->read (funcs
, &callbacks
, gdb_mem
.data (),
704 code_entry
->symfile_size
)
710 jit_debug_printf ("Could not read symtab using the loaded JIT reader.");
715 /* Try to read CODE_ENTRY using BFD. ENTRY_ADDR is the address of the
716 struct jit_code_entry in the inferior address space. */
719 jit_bfd_try_read_symtab (struct jit_code_entry
*code_entry
,
720 CORE_ADDR entry_addr
,
721 struct gdbarch
*gdbarch
)
723 struct bfd_section
*sec
;
724 struct objfile
*objfile
;
725 const struct bfd_arch_info
*b
;
727 jit_debug_printf ("symfile_addr = %s, symfile_size = %s",
728 paddress (gdbarch
, code_entry
->symfile_addr
),
729 pulongest (code_entry
->symfile_size
));
731 gdb_bfd_ref_ptr
nbfd (gdb_bfd_open_from_target_memory
732 (code_entry
->symfile_addr
, code_entry
->symfile_size
, gnutarget
));
735 fputs_unfiltered (_("Error opening JITed symbol file, ignoring it.\n"),
740 /* Check the format. NOTE: This initializes important data that GDB uses!
741 We would segfault later without this line. */
742 if (!bfd_check_format (nbfd
.get (), bfd_object
))
744 fprintf_unfiltered (gdb_stderr
, _("\
745 JITed symbol file is not an object file, ignoring it.\n"));
749 /* Check bfd arch. */
750 b
= gdbarch_bfd_arch_info (gdbarch
);
751 if (b
->compatible (b
, bfd_get_arch_info (nbfd
.get ())) != b
)
752 warning (_("JITed object file architecture %s is not compatible "
753 "with target architecture %s."),
754 bfd_get_arch_info (nbfd
.get ())->printable_name
,
757 /* Read the section address information out of the symbol file. Since the
758 file is generated by the JIT at runtime, it should all of the absolute
759 addresses that we care about. */
760 section_addr_info sai
;
761 for (sec
= nbfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
762 if ((bfd_section_flags (sec
) & (SEC_ALLOC
|SEC_LOAD
)) != 0)
764 /* We assume that these virtual addresses are absolute, and do not
765 treat them as offsets. */
766 sai
.emplace_back (bfd_section_vma (sec
),
767 bfd_section_name (sec
),
771 /* This call does not take ownership of SAI. */
772 objfile
= symbol_file_add_from_bfd (nbfd
.get (),
773 bfd_get_filename (nbfd
.get ()), 0,
775 OBJF_SHARED
| OBJF_NOT_FILENAME
, NULL
);
777 add_objfile_entry (objfile
, entry_addr
);
780 /* This function registers code associated with a JIT code entry. It uses the
781 pointer and size pair in the entry to read the symbol file from the remote
782 and then calls symbol_file_add_from_local_memory to add it as though it were
783 a symbol file added by the user. */
786 jit_register_code (struct gdbarch
*gdbarch
,
787 CORE_ADDR entry_addr
, struct jit_code_entry
*code_entry
)
791 jit_debug_printf ("symfile_addr = %s, symfile_size = %s",
792 paddress (gdbarch
, code_entry
->symfile_addr
),
793 pulongest (code_entry
->symfile_size
));
795 success
= jit_reader_try_read_symtab (gdbarch
, code_entry
, entry_addr
);
798 jit_bfd_try_read_symtab (code_entry
, entry_addr
, gdbarch
);
801 /* Look up the objfile with this code entry address. */
803 static struct objfile
*
804 jit_find_objf_with_entry_addr (CORE_ADDR entry_addr
)
806 for (objfile
*objf
: current_program_space
->objfiles ())
808 if (objf
->jited_data
!= nullptr && objf
->jited_data
->addr
== entry_addr
)
815 /* This is called when a breakpoint is deleted. It updates the
816 inferior's cache, if needed. */
819 jit_breakpoint_deleted (struct breakpoint
*b
)
821 if (b
->type
!= bp_jit_event
)
824 for (bp_location
*iter
: b
->locations ())
826 for (objfile
*objf
: iter
->pspace
->objfiles ())
828 jiter_objfile_data
*jiter_data
= objf
->jiter_data
.get ();
830 if (jiter_data
!= nullptr
831 && jiter_data
->jit_breakpoint
== iter
->owner
)
833 jiter_data
->cached_code_address
= 0;
834 jiter_data
->jit_breakpoint
= nullptr;
840 /* (Re-)Initialize the jit breakpoints for JIT-producing objfiles in
844 jit_breakpoint_re_set_internal (struct gdbarch
*gdbarch
, program_space
*pspace
)
846 for (objfile
*the_objfile
: pspace
->objfiles ())
848 /* Skip separate debug objects. */
849 if (the_objfile
->separate_debug_objfile_backlink
!= nullptr)
852 if (the_objfile
->skip_jit_symbol_lookup
)
855 /* Lookup the registration symbol. If it is missing, then we
856 assume we are not attached to a JIT. */
857 bound_minimal_symbol reg_symbol
858 = lookup_minimal_symbol (jit_break_name
, nullptr, the_objfile
);
859 if (reg_symbol
.minsym
== NULL
860 || BMSYMBOL_VALUE_ADDRESS (reg_symbol
) == 0)
862 /* No need to repeat the lookup the next time. */
863 the_objfile
->skip_jit_symbol_lookup
= true;
867 bound_minimal_symbol desc_symbol
868 = lookup_minimal_symbol (jit_descriptor_name
, NULL
, the_objfile
);
869 if (desc_symbol
.minsym
== NULL
870 || BMSYMBOL_VALUE_ADDRESS (desc_symbol
) == 0)
872 /* No need to repeat the lookup the next time. */
873 the_objfile
->skip_jit_symbol_lookup
= true;
877 jiter_objfile_data
*objf_data
878 = get_jiter_objfile_data (the_objfile
);
879 objf_data
->register_code
= reg_symbol
.minsym
;
880 objf_data
->descriptor
= desc_symbol
.minsym
;
882 CORE_ADDR addr
= MSYMBOL_VALUE_ADDRESS (the_objfile
,
883 objf_data
->register_code
);
885 jit_debug_printf ("breakpoint_addr = %s", paddress (gdbarch
, addr
));
887 /* Check if we need to re-create the breakpoint. */
888 if (objf_data
->cached_code_address
== addr
)
891 /* Delete the old breakpoint. */
892 if (objf_data
->jit_breakpoint
!= nullptr)
893 delete_breakpoint (objf_data
->jit_breakpoint
);
895 /* Put a breakpoint in the registration symbol. */
896 objf_data
->cached_code_address
= addr
;
897 objf_data
->jit_breakpoint
= create_jit_event_breakpoint (gdbarch
, addr
);
901 /* The private data passed around in the frame unwind callback
904 struct jit_unwind_private
906 /* Cached register values. See jit_frame_sniffer to see how this
908 detached_regcache
*regcache
;
910 /* The frame being unwound. */
911 struct frame_info
*this_frame
;
914 /* Sets the value of a particular register in this frame. */
917 jit_unwind_reg_set_impl (struct gdb_unwind_callbacks
*cb
, int dwarf_regnum
,
918 struct gdb_reg_value
*value
)
920 struct jit_unwind_private
*priv
;
923 priv
= (struct jit_unwind_private
*) cb
->priv_data
;
925 gdb_reg
= gdbarch_dwarf2_reg_to_regnum (get_frame_arch (priv
->this_frame
),
929 jit_debug_printf ("Could not recognize DWARF regnum %d", dwarf_regnum
);
934 priv
->regcache
->raw_supply (gdb_reg
, value
->value
);
939 reg_value_free_impl (struct gdb_reg_value
*value
)
944 /* Get the value of register REGNUM in the previous frame. */
946 static struct gdb_reg_value
*
947 jit_unwind_reg_get_impl (struct gdb_unwind_callbacks
*cb
, int regnum
)
949 struct jit_unwind_private
*priv
;
950 struct gdb_reg_value
*value
;
952 struct gdbarch
*frame_arch
;
954 priv
= (struct jit_unwind_private
*) cb
->priv_data
;
955 frame_arch
= get_frame_arch (priv
->this_frame
);
957 gdb_reg
= gdbarch_dwarf2_reg_to_regnum (frame_arch
, regnum
);
958 size
= register_size (frame_arch
, gdb_reg
);
959 value
= ((struct gdb_reg_value
*)
960 xmalloc (sizeof (struct gdb_reg_value
) + size
- 1));
961 value
->defined
= deprecated_frame_register_read (priv
->this_frame
, gdb_reg
,
964 value
->free
= reg_value_free_impl
;
968 /* gdb_reg_value has a free function, which must be called on each
969 saved register value. */
972 jit_dealloc_cache (struct frame_info
*this_frame
, void *cache
)
974 struct jit_unwind_private
*priv_data
= (struct jit_unwind_private
*) cache
;
976 gdb_assert (priv_data
->regcache
!= NULL
);
977 delete priv_data
->regcache
;
981 /* The frame sniffer for the pseudo unwinder.
983 While this is nominally a frame sniffer, in the case where the JIT
984 reader actually recognizes the frame, it does a lot more work -- it
985 unwinds the frame and saves the corresponding register values in
986 the cache. jit_frame_prev_register simply returns the saved
990 jit_frame_sniffer (const struct frame_unwind
*self
,
991 struct frame_info
*this_frame
, void **cache
)
993 struct jit_unwind_private
*priv_data
;
994 struct gdb_unwind_callbacks callbacks
;
995 struct gdb_reader_funcs
*funcs
;
997 callbacks
.reg_get
= jit_unwind_reg_get_impl
;
998 callbacks
.reg_set
= jit_unwind_reg_set_impl
;
999 callbacks
.target_read
= jit_target_read_impl
;
1001 if (loaded_jit_reader
== NULL
)
1004 funcs
= loaded_jit_reader
->functions
;
1006 gdb_assert (!*cache
);
1008 *cache
= XCNEW (struct jit_unwind_private
);
1009 priv_data
= (struct jit_unwind_private
*) *cache
;
1010 /* Take a snapshot of current regcache. */
1011 priv_data
->regcache
= new detached_regcache (get_frame_arch (this_frame
),
1013 priv_data
->this_frame
= this_frame
;
1015 callbacks
.priv_data
= priv_data
;
1017 /* Try to coax the provided unwinder to unwind the stack */
1018 if (funcs
->unwind (funcs
, &callbacks
) == GDB_SUCCESS
)
1020 jit_debug_printf ("Successfully unwound frame using JIT reader.");
1024 jit_debug_printf ("Could not unwind frame using JIT reader.");
1026 jit_dealloc_cache (this_frame
, *cache
);
1033 /* The frame_id function for the pseudo unwinder. Relays the call to
1034 the loaded plugin. */
1037 jit_frame_this_id (struct frame_info
*this_frame
, void **cache
,
1038 struct frame_id
*this_id
)
1040 struct jit_unwind_private priv
;
1041 struct gdb_frame_id frame_id
;
1042 struct gdb_reader_funcs
*funcs
;
1043 struct gdb_unwind_callbacks callbacks
;
1045 priv
.regcache
= NULL
;
1046 priv
.this_frame
= this_frame
;
1048 /* We don't expect the frame_id function to set any registers, so we
1049 set reg_set to NULL. */
1050 callbacks
.reg_get
= jit_unwind_reg_get_impl
;
1051 callbacks
.reg_set
= NULL
;
1052 callbacks
.target_read
= jit_target_read_impl
;
1053 callbacks
.priv_data
= &priv
;
1055 gdb_assert (loaded_jit_reader
);
1056 funcs
= loaded_jit_reader
->functions
;
1058 frame_id
= funcs
->get_frame_id (funcs
, &callbacks
);
1059 *this_id
= frame_id_build (frame_id
.stack_address
, frame_id
.code_address
);
1062 /* Pseudo unwinder function. Reads the previously fetched value for
1063 the register from the cache. */
1065 static struct value
*
1066 jit_frame_prev_register (struct frame_info
*this_frame
, void **cache
, int reg
)
1068 struct jit_unwind_private
*priv
= (struct jit_unwind_private
*) *cache
;
1069 struct gdbarch
*gdbarch
;
1072 return frame_unwind_got_optimized (this_frame
, reg
);
1074 gdbarch
= priv
->regcache
->arch ();
1075 gdb_byte
*buf
= (gdb_byte
*) alloca (register_size (gdbarch
, reg
));
1076 enum register_status status
= priv
->regcache
->cooked_read (reg
, buf
);
1078 if (status
== REG_VALID
)
1079 return frame_unwind_got_bytes (this_frame
, reg
, buf
);
1081 return frame_unwind_got_optimized (this_frame
, reg
);
1084 /* Relay everything back to the unwinder registered by the JIT debug
1087 static const struct frame_unwind jit_frame_unwind
=
1091 default_frame_unwind_stop_reason
,
1093 jit_frame_prev_register
,
1100 /* This is the information that is stored at jit_gdbarch_data for each
1103 struct jit_gdbarch_data_type
1105 /* Has the (pseudo) unwinder been prepended? */
1106 int unwinder_registered
;
1109 /* Check GDBARCH and prepend the pseudo JIT unwinder if needed. */
1112 jit_prepend_unwinder (struct gdbarch
*gdbarch
)
1114 struct jit_gdbarch_data_type
*data
;
1117 = (struct jit_gdbarch_data_type
*) gdbarch_data (gdbarch
, jit_gdbarch_data
);
1118 if (!data
->unwinder_registered
)
1120 frame_unwind_prepend_unwinder (gdbarch
, &jit_frame_unwind
);
1121 data
->unwinder_registered
= 1;
1125 /* Register any already created translations. */
1128 jit_inferior_init (inferior
*inf
)
1130 struct jit_descriptor descriptor
;
1131 struct jit_code_entry cur_entry
;
1132 CORE_ADDR cur_entry_addr
;
1133 struct gdbarch
*gdbarch
= inf
->gdbarch
;
1134 program_space
*pspace
= inf
->pspace
;
1136 jit_debug_printf ("called");
1138 jit_prepend_unwinder (gdbarch
);
1140 jit_breakpoint_re_set_internal (gdbarch
, pspace
);
1142 for (objfile
*jiter
: pspace
->objfiles ())
1144 if (jiter
->jiter_data
== nullptr)
1147 /* Read the descriptor so we can check the version number and load
1148 any already JITed functions. */
1149 if (!jit_read_descriptor (gdbarch
, &descriptor
, jiter
))
1152 /* Check that the version number agrees with that we support. */
1153 if (descriptor
.version
!= 1)
1155 fprintf_unfiltered (gdb_stderr
,
1156 _("Unsupported JIT protocol version %ld "
1157 "in descriptor (expected 1)\n"),
1158 (long) descriptor
.version
);
1162 /* If we've attached to a running program, we need to check the
1163 descriptor to register any functions that were already
1165 for (cur_entry_addr
= descriptor
.first_entry
;
1166 cur_entry_addr
!= 0;
1167 cur_entry_addr
= cur_entry
.next_entry
)
1169 jit_read_code_entry (gdbarch
, cur_entry_addr
, &cur_entry
);
1171 /* This hook may be called many times during setup, so make sure
1172 we don't add the same symbol file twice. */
1173 if (jit_find_objf_with_entry_addr (cur_entry_addr
) != NULL
)
1176 jit_register_code (gdbarch
, cur_entry_addr
, &cur_entry
);
1181 /* Looks for the descriptor and registration symbols and breakpoints
1182 the registration function. If it finds both, it registers all the
1183 already JITed code. If it has already found the symbols, then it
1184 doesn't try again. */
1187 jit_inferior_created_hook (inferior
*inf
)
1189 jit_inferior_init (inf
);
1192 /* Exported routine to call to re-set the jit breakpoints,
1193 e.g. when a program is rerun. */
1196 jit_breakpoint_re_set (void)
1198 jit_breakpoint_re_set_internal (target_gdbarch (), current_program_space
);
1201 /* This function cleans up any code entries left over when the
1202 inferior exits. We get left over code when the inferior exits
1203 without unregistering its code, for example when it crashes. */
1206 jit_inferior_exit_hook (struct inferior
*inf
)
1208 for (objfile
*objf
: current_program_space
->objfiles_safe ())
1210 if (objf
->jited_data
!= nullptr && objf
->jited_data
->addr
!= 0)
1216 jit_event_handler (gdbarch
*gdbarch
, objfile
*jiter
)
1218 struct jit_descriptor descriptor
;
1220 /* If we get a JIT breakpoint event for this objfile, it is necessarily a
1222 gdb_assert (jiter
->jiter_data
!= nullptr);
1224 /* Read the descriptor from remote memory. */
1225 if (!jit_read_descriptor (gdbarch
, &descriptor
, jiter
))
1227 CORE_ADDR entry_addr
= descriptor
.relevant_entry
;
1229 /* Do the corresponding action. */
1230 switch (descriptor
.action_flag
)
1237 jit_code_entry code_entry
;
1238 jit_read_code_entry (gdbarch
, entry_addr
, &code_entry
);
1239 jit_register_code (gdbarch
, entry_addr
, &code_entry
);
1243 case JIT_UNREGISTER
:
1245 objfile
*jited
= jit_find_objf_with_entry_addr (entry_addr
);
1246 if (jited
== nullptr)
1247 fprintf_unfiltered (gdb_stderr
,
1248 _("Unable to find JITed code "
1249 "entry at address: %s\n"),
1250 paddress (gdbarch
, entry_addr
));
1258 error (_("Unknown action_flag value in JIT descriptor!"));
1263 /* Initialize the jit_gdbarch_data slot with an instance of struct
1264 jit_gdbarch_data_type */
1267 jit_gdbarch_data_init (struct obstack
*obstack
)
1269 struct jit_gdbarch_data_type
*data
=
1270 XOBNEW (obstack
, struct jit_gdbarch_data_type
);
1272 data
->unwinder_registered
= 0;
1277 void _initialize_jit ();
1281 jit_reader_dir
= relocate_gdb_directory (JIT_READER_DIR
,
1282 JIT_READER_DIR_RELOCATABLE
);
1283 add_setshow_boolean_cmd ("jit", class_maintenance
, &jit_debug
,
1284 _("Set JIT debugging."),
1285 _("Show JIT debugging."),
1286 _("When set, JIT debugging is enabled."),
1289 &setdebuglist
, &showdebuglist
);
1291 add_cmd ("jit", class_maintenance
, maint_info_jit_cmd
,
1292 _("Print information about JIT-ed code objects."),
1293 &maintenanceinfolist
);
1295 gdb::observers::inferior_created
.attach (jit_inferior_created_hook
, "jit");
1296 gdb::observers::inferior_execd
.attach (jit_inferior_created_hook
, "jit");
1297 gdb::observers::inferior_exit
.attach (jit_inferior_exit_hook
, "jit");
1298 gdb::observers::breakpoint_deleted
.attach (jit_breakpoint_deleted
, "jit");
1300 jit_gdbarch_data
= gdbarch_data_register_pre_init (jit_gdbarch_data_init
);
1301 if (is_dl_available ())
1303 struct cmd_list_element
*c
;
1305 c
= add_com ("jit-reader-load", no_class
, jit_reader_load_command
, _("\
1306 Load FILE as debug info reader and unwinder for JIT compiled code.\n\
1307 Usage: jit-reader-load FILE\n\
1308 Try to load file FILE as a debug info reader (and unwinder) for\n\
1309 JIT compiled code. The file is loaded from " JIT_READER_DIR
",\n\
1310 relocated relative to the GDB executable if required."));
1311 set_cmd_completer (c
, filename_completer
);
1313 c
= add_com ("jit-reader-unload", no_class
,
1314 jit_reader_unload_command
, _("\
1315 Unload the currently loaded JIT debug info reader.\n\
1316 Usage: jit-reader-unload\n\n\
1317 Do \"help jit-reader-load\" for info on loading debug info readers."));
1318 set_cmd_completer (c
, noop_completer
);