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 symtab
*filetab
= allocate_symtab (cust
, stab
->file_name
.c_str ());
513 add_compunit_symtab_to_objfile (cust
);
515 /* JIT compilers compile in memory. */
516 cust
->set_dirname (nullptr);
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 filetab
->set_linetable ((struct linetable
*)
525 obstack_alloc (&objfile
->objfile_obstack
, size
));
526 memcpy (filetab
->linetable (), stab
->linetable
.get (), size
);
529 blockvector_size
= (sizeof (struct blockvector
)
530 + (actual_nblocks
- 1) * sizeof (struct block
*));
531 bv
= (struct blockvector
*) obstack_alloc (&objfile
->objfile_obstack
,
533 cust
->set_blockvector (bv
);
535 /* At the end of this function, (begin, end) will contain the PC range this
536 entire blockvector spans. */
537 BLOCKVECTOR_MAP (bv
) = NULL
;
538 begin
= stab
->blocks
.front ().begin
;
539 end
= stab
->blocks
.front ().end
;
540 BLOCKVECTOR_NBLOCKS (bv
) = actual_nblocks
;
542 /* First run over all the gdb_block objects, creating a real block
543 object for each. Simultaneously, keep setting the real_block
545 int block_idx
= FIRST_LOCAL_BLOCK
;
546 for (gdb_block
&gdb_block_iter
: stab
->blocks
)
548 struct block
*new_block
= allocate_block (&objfile
->objfile_obstack
);
549 struct symbol
*block_name
= new (&objfile
->objfile_obstack
) symbol
;
550 struct type
*block_type
= arch_type (objfile
->arch (),
555 BLOCK_MULTIDICT (new_block
)
556 = mdict_create_linear (&objfile
->objfile_obstack
, NULL
);
557 /* The address range. */
558 BLOCK_START (new_block
) = (CORE_ADDR
) gdb_block_iter
.begin
;
559 BLOCK_END (new_block
) = (CORE_ADDR
) gdb_block_iter
.end
;
562 block_name
->set_domain (VAR_DOMAIN
);
563 block_name
->set_aclass_index (LOC_BLOCK
);
564 symbol_set_symtab (block_name
, filetab
);
565 block_name
->set_type (lookup_function_type (block_type
));
566 SYMBOL_BLOCK_VALUE (block_name
) = new_block
;
568 block_name
->m_name
= obstack_strdup (&objfile
->objfile_obstack
,
569 gdb_block_iter
.name
.get ());
571 BLOCK_FUNCTION (new_block
) = block_name
;
573 BLOCKVECTOR_BLOCK (bv
, block_idx
) = new_block
;
574 if (begin
> BLOCK_START (new_block
))
575 begin
= BLOCK_START (new_block
);
576 if (end
< BLOCK_END (new_block
))
577 end
= BLOCK_END (new_block
);
579 gdb_block_iter
.real_block
= new_block
;
584 /* Now add the special blocks. */
585 struct block
*block_iter
= NULL
;
586 for (enum block_enum i
: { GLOBAL_BLOCK
, STATIC_BLOCK
})
588 struct block
*new_block
;
590 new_block
= (i
== GLOBAL_BLOCK
591 ? allocate_global_block (&objfile
->objfile_obstack
)
592 : allocate_block (&objfile
->objfile_obstack
));
593 BLOCK_MULTIDICT (new_block
)
594 = mdict_create_linear (&objfile
->objfile_obstack
, NULL
);
595 BLOCK_SUPERBLOCK (new_block
) = block_iter
;
596 block_iter
= new_block
;
598 BLOCK_START (new_block
) = (CORE_ADDR
) begin
;
599 BLOCK_END (new_block
) = (CORE_ADDR
) end
;
601 BLOCKVECTOR_BLOCK (bv
, i
) = new_block
;
603 if (i
== GLOBAL_BLOCK
)
604 set_block_compunit_symtab (new_block
, cust
);
607 /* Fill up the superblock fields for the real blocks, using the
608 real_block fields populated earlier. */
609 for (gdb_block
&gdb_block_iter
: stab
->blocks
)
611 if (gdb_block_iter
.parent
!= NULL
)
613 /* If the plugin specifically mentioned a parent block, we
615 BLOCK_SUPERBLOCK (gdb_block_iter
.real_block
) =
616 gdb_block_iter
.parent
->real_block
;
620 /* And if not, we set a default parent block. */
621 BLOCK_SUPERBLOCK (gdb_block_iter
.real_block
) =
622 BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
);
627 /* Called when closing a gdb_objfile. Converts OBJ to a proper
631 jit_object_close_impl (struct gdb_symbol_callbacks
*cb
,
632 struct gdb_object
*obj
)
634 jit_dbg_reader_data
*priv_data
= (jit_dbg_reader_data
*) cb
->priv_data
;
635 std::string objfile_name
636 = string_printf ("<< JIT compiled code at %s >>",
637 paddress (priv_data
->gdbarch
,
638 priv_data
->entry
.symfile_addr
));
640 objfile
*objfile
= objfile::make (nullptr, objfile_name
.c_str (),
642 objfile
->per_bfd
->gdbarch
= priv_data
->gdbarch
;
644 for (gdb_symtab
&symtab
: obj
->symtabs
)
645 finalize_symtab (&symtab
, objfile
);
647 add_objfile_entry (objfile
, priv_data
->entry_addr
);
652 /* Try to read CODE_ENTRY using the loaded jit reader (if any).
653 ENTRY_ADDR is the address of the struct jit_code_entry in the
654 inferior address space. */
657 jit_reader_try_read_symtab (gdbarch
*gdbarch
, jit_code_entry
*code_entry
,
658 CORE_ADDR entry_addr
)
661 jit_dbg_reader_data priv_data
667 struct gdb_reader_funcs
*funcs
;
668 struct gdb_symbol_callbacks callbacks
=
670 jit_object_open_impl
,
671 jit_symtab_open_impl
,
673 jit_symtab_close_impl
,
674 jit_object_close_impl
,
676 jit_symtab_line_mapping_add_impl
,
677 jit_target_read_impl
,
682 if (!loaded_jit_reader
)
685 gdb::byte_vector
gdb_mem (code_entry
->symfile_size
);
690 if (target_read_memory (code_entry
->symfile_addr
, gdb_mem
.data (),
691 code_entry
->symfile_size
))
694 catch (const gdb_exception
&e
)
701 funcs
= loaded_jit_reader
->functions
;
702 if (funcs
->read (funcs
, &callbacks
, gdb_mem
.data (),
703 code_entry
->symfile_size
)
709 jit_debug_printf ("Could not read symtab using the loaded JIT reader.");
714 /* Try to read CODE_ENTRY using BFD. ENTRY_ADDR is the address of the
715 struct jit_code_entry in the inferior address space. */
718 jit_bfd_try_read_symtab (struct jit_code_entry
*code_entry
,
719 CORE_ADDR entry_addr
,
720 struct gdbarch
*gdbarch
)
722 struct bfd_section
*sec
;
723 struct objfile
*objfile
;
724 const struct bfd_arch_info
*b
;
726 jit_debug_printf ("symfile_addr = %s, symfile_size = %s",
727 paddress (gdbarch
, code_entry
->symfile_addr
),
728 pulongest (code_entry
->symfile_size
));
730 gdb_bfd_ref_ptr
nbfd (gdb_bfd_open_from_target_memory
731 (code_entry
->symfile_addr
, code_entry
->symfile_size
, gnutarget
));
734 fputs_unfiltered (_("Error opening JITed symbol file, ignoring it.\n"),
739 /* Check the format. NOTE: This initializes important data that GDB uses!
740 We would segfault later without this line. */
741 if (!bfd_check_format (nbfd
.get (), bfd_object
))
743 fprintf_unfiltered (gdb_stderr
, _("\
744 JITed symbol file is not an object file, ignoring it.\n"));
748 /* Check bfd arch. */
749 b
= gdbarch_bfd_arch_info (gdbarch
);
750 if (b
->compatible (b
, bfd_get_arch_info (nbfd
.get ())) != b
)
751 warning (_("JITed object file architecture %s is not compatible "
752 "with target architecture %s."),
753 bfd_get_arch_info (nbfd
.get ())->printable_name
,
756 /* Read the section address information out of the symbol file. Since the
757 file is generated by the JIT at runtime, it should all of the absolute
758 addresses that we care about. */
759 section_addr_info sai
;
760 for (sec
= nbfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
761 if ((bfd_section_flags (sec
) & (SEC_ALLOC
|SEC_LOAD
)) != 0)
763 /* We assume that these virtual addresses are absolute, and do not
764 treat them as offsets. */
765 sai
.emplace_back (bfd_section_vma (sec
),
766 bfd_section_name (sec
),
770 /* This call does not take ownership of SAI. */
771 objfile
= symbol_file_add_from_bfd (nbfd
.get (),
772 bfd_get_filename (nbfd
.get ()), 0,
774 OBJF_SHARED
| OBJF_NOT_FILENAME
, NULL
);
776 add_objfile_entry (objfile
, entry_addr
);
779 /* This function registers code associated with a JIT code entry. It uses the
780 pointer and size pair in the entry to read the symbol file from the remote
781 and then calls symbol_file_add_from_local_memory to add it as though it were
782 a symbol file added by the user. */
785 jit_register_code (struct gdbarch
*gdbarch
,
786 CORE_ADDR entry_addr
, struct jit_code_entry
*code_entry
)
790 jit_debug_printf ("symfile_addr = %s, symfile_size = %s",
791 paddress (gdbarch
, code_entry
->symfile_addr
),
792 pulongest (code_entry
->symfile_size
));
794 success
= jit_reader_try_read_symtab (gdbarch
, code_entry
, entry_addr
);
797 jit_bfd_try_read_symtab (code_entry
, entry_addr
, gdbarch
);
800 /* Look up the objfile with this code entry address. */
802 static struct objfile
*
803 jit_find_objf_with_entry_addr (CORE_ADDR entry_addr
)
805 for (objfile
*objf
: current_program_space
->objfiles ())
807 if (objf
->jited_data
!= nullptr && objf
->jited_data
->addr
== entry_addr
)
814 /* This is called when a breakpoint is deleted. It updates the
815 inferior's cache, if needed. */
818 jit_breakpoint_deleted (struct breakpoint
*b
)
820 if (b
->type
!= bp_jit_event
)
823 for (bp_location
*iter
: b
->locations ())
825 for (objfile
*objf
: iter
->pspace
->objfiles ())
827 jiter_objfile_data
*jiter_data
= objf
->jiter_data
.get ();
829 if (jiter_data
!= nullptr
830 && jiter_data
->jit_breakpoint
== iter
->owner
)
832 jiter_data
->cached_code_address
= 0;
833 jiter_data
->jit_breakpoint
= nullptr;
839 /* (Re-)Initialize the jit breakpoints for JIT-producing objfiles in
843 jit_breakpoint_re_set_internal (struct gdbarch
*gdbarch
, program_space
*pspace
)
845 for (objfile
*the_objfile
: pspace
->objfiles ())
847 /* Skip separate debug objects. */
848 if (the_objfile
->separate_debug_objfile_backlink
!= nullptr)
851 if (the_objfile
->skip_jit_symbol_lookup
)
854 /* Lookup the registration symbol. If it is missing, then we
855 assume we are not attached to a JIT. */
856 bound_minimal_symbol reg_symbol
857 = lookup_minimal_symbol (jit_break_name
, nullptr, the_objfile
);
858 if (reg_symbol
.minsym
== NULL
859 || BMSYMBOL_VALUE_ADDRESS (reg_symbol
) == 0)
861 /* No need to repeat the lookup the next time. */
862 the_objfile
->skip_jit_symbol_lookup
= true;
866 bound_minimal_symbol desc_symbol
867 = lookup_minimal_symbol (jit_descriptor_name
, NULL
, the_objfile
);
868 if (desc_symbol
.minsym
== NULL
869 || BMSYMBOL_VALUE_ADDRESS (desc_symbol
) == 0)
871 /* No need to repeat the lookup the next time. */
872 the_objfile
->skip_jit_symbol_lookup
= true;
876 jiter_objfile_data
*objf_data
877 = get_jiter_objfile_data (the_objfile
);
878 objf_data
->register_code
= reg_symbol
.minsym
;
879 objf_data
->descriptor
= desc_symbol
.minsym
;
881 CORE_ADDR addr
= MSYMBOL_VALUE_ADDRESS (the_objfile
,
882 objf_data
->register_code
);
884 jit_debug_printf ("breakpoint_addr = %s", paddress (gdbarch
, addr
));
886 /* Check if we need to re-create the breakpoint. */
887 if (objf_data
->cached_code_address
== addr
)
890 /* Delete the old breakpoint. */
891 if (objf_data
->jit_breakpoint
!= nullptr)
892 delete_breakpoint (objf_data
->jit_breakpoint
);
894 /* Put a breakpoint in the registration symbol. */
895 objf_data
->cached_code_address
= addr
;
896 objf_data
->jit_breakpoint
= create_jit_event_breakpoint (gdbarch
, addr
);
900 /* The private data passed around in the frame unwind callback
903 struct jit_unwind_private
905 /* Cached register values. See jit_frame_sniffer to see how this
907 detached_regcache
*regcache
;
909 /* The frame being unwound. */
910 struct frame_info
*this_frame
;
913 /* Sets the value of a particular register in this frame. */
916 jit_unwind_reg_set_impl (struct gdb_unwind_callbacks
*cb
, int dwarf_regnum
,
917 struct gdb_reg_value
*value
)
919 struct jit_unwind_private
*priv
;
922 priv
= (struct jit_unwind_private
*) cb
->priv_data
;
924 gdb_reg
= gdbarch_dwarf2_reg_to_regnum (get_frame_arch (priv
->this_frame
),
928 jit_debug_printf ("Could not recognize DWARF regnum %d", dwarf_regnum
);
933 priv
->regcache
->raw_supply (gdb_reg
, value
->value
);
938 reg_value_free_impl (struct gdb_reg_value
*value
)
943 /* Get the value of register REGNUM in the previous frame. */
945 static struct gdb_reg_value
*
946 jit_unwind_reg_get_impl (struct gdb_unwind_callbacks
*cb
, int regnum
)
948 struct jit_unwind_private
*priv
;
949 struct gdb_reg_value
*value
;
951 struct gdbarch
*frame_arch
;
953 priv
= (struct jit_unwind_private
*) cb
->priv_data
;
954 frame_arch
= get_frame_arch (priv
->this_frame
);
956 gdb_reg
= gdbarch_dwarf2_reg_to_regnum (frame_arch
, regnum
);
957 size
= register_size (frame_arch
, gdb_reg
);
958 value
= ((struct gdb_reg_value
*)
959 xmalloc (sizeof (struct gdb_reg_value
) + size
- 1));
960 value
->defined
= deprecated_frame_register_read (priv
->this_frame
, gdb_reg
,
963 value
->free
= reg_value_free_impl
;
967 /* gdb_reg_value has a free function, which must be called on each
968 saved register value. */
971 jit_dealloc_cache (struct frame_info
*this_frame
, void *cache
)
973 struct jit_unwind_private
*priv_data
= (struct jit_unwind_private
*) cache
;
975 gdb_assert (priv_data
->regcache
!= NULL
);
976 delete priv_data
->regcache
;
980 /* The frame sniffer for the pseudo unwinder.
982 While this is nominally a frame sniffer, in the case where the JIT
983 reader actually recognizes the frame, it does a lot more work -- it
984 unwinds the frame and saves the corresponding register values in
985 the cache. jit_frame_prev_register simply returns the saved
989 jit_frame_sniffer (const struct frame_unwind
*self
,
990 struct frame_info
*this_frame
, void **cache
)
992 struct jit_unwind_private
*priv_data
;
993 struct gdb_unwind_callbacks callbacks
;
994 struct gdb_reader_funcs
*funcs
;
996 callbacks
.reg_get
= jit_unwind_reg_get_impl
;
997 callbacks
.reg_set
= jit_unwind_reg_set_impl
;
998 callbacks
.target_read
= jit_target_read_impl
;
1000 if (loaded_jit_reader
== NULL
)
1003 funcs
= loaded_jit_reader
->functions
;
1005 gdb_assert (!*cache
);
1007 *cache
= XCNEW (struct jit_unwind_private
);
1008 priv_data
= (struct jit_unwind_private
*) *cache
;
1009 /* Take a snapshot of current regcache. */
1010 priv_data
->regcache
= new detached_regcache (get_frame_arch (this_frame
),
1012 priv_data
->this_frame
= this_frame
;
1014 callbacks
.priv_data
= priv_data
;
1016 /* Try to coax the provided unwinder to unwind the stack */
1017 if (funcs
->unwind (funcs
, &callbacks
) == GDB_SUCCESS
)
1019 jit_debug_printf ("Successfully unwound frame using JIT reader.");
1023 jit_debug_printf ("Could not unwind frame using JIT reader.");
1025 jit_dealloc_cache (this_frame
, *cache
);
1032 /* The frame_id function for the pseudo unwinder. Relays the call to
1033 the loaded plugin. */
1036 jit_frame_this_id (struct frame_info
*this_frame
, void **cache
,
1037 struct frame_id
*this_id
)
1039 struct jit_unwind_private priv
;
1040 struct gdb_frame_id frame_id
;
1041 struct gdb_reader_funcs
*funcs
;
1042 struct gdb_unwind_callbacks callbacks
;
1044 priv
.regcache
= NULL
;
1045 priv
.this_frame
= this_frame
;
1047 /* We don't expect the frame_id function to set any registers, so we
1048 set reg_set to NULL. */
1049 callbacks
.reg_get
= jit_unwind_reg_get_impl
;
1050 callbacks
.reg_set
= NULL
;
1051 callbacks
.target_read
= jit_target_read_impl
;
1052 callbacks
.priv_data
= &priv
;
1054 gdb_assert (loaded_jit_reader
);
1055 funcs
= loaded_jit_reader
->functions
;
1057 frame_id
= funcs
->get_frame_id (funcs
, &callbacks
);
1058 *this_id
= frame_id_build (frame_id
.stack_address
, frame_id
.code_address
);
1061 /* Pseudo unwinder function. Reads the previously fetched value for
1062 the register from the cache. */
1064 static struct value
*
1065 jit_frame_prev_register (struct frame_info
*this_frame
, void **cache
, int reg
)
1067 struct jit_unwind_private
*priv
= (struct jit_unwind_private
*) *cache
;
1068 struct gdbarch
*gdbarch
;
1071 return frame_unwind_got_optimized (this_frame
, reg
);
1073 gdbarch
= priv
->regcache
->arch ();
1074 gdb_byte
*buf
= (gdb_byte
*) alloca (register_size (gdbarch
, reg
));
1075 enum register_status status
= priv
->regcache
->cooked_read (reg
, buf
);
1077 if (status
== REG_VALID
)
1078 return frame_unwind_got_bytes (this_frame
, reg
, buf
);
1080 return frame_unwind_got_optimized (this_frame
, reg
);
1083 /* Relay everything back to the unwinder registered by the JIT debug
1086 static const struct frame_unwind jit_frame_unwind
=
1090 default_frame_unwind_stop_reason
,
1092 jit_frame_prev_register
,
1099 /* This is the information that is stored at jit_gdbarch_data for each
1102 struct jit_gdbarch_data_type
1104 /* Has the (pseudo) unwinder been prepended? */
1105 int unwinder_registered
;
1108 /* Check GDBARCH and prepend the pseudo JIT unwinder if needed. */
1111 jit_prepend_unwinder (struct gdbarch
*gdbarch
)
1113 struct jit_gdbarch_data_type
*data
;
1116 = (struct jit_gdbarch_data_type
*) gdbarch_data (gdbarch
, jit_gdbarch_data
);
1117 if (!data
->unwinder_registered
)
1119 frame_unwind_prepend_unwinder (gdbarch
, &jit_frame_unwind
);
1120 data
->unwinder_registered
= 1;
1124 /* Register any already created translations. */
1127 jit_inferior_init (inferior
*inf
)
1129 struct jit_descriptor descriptor
;
1130 struct jit_code_entry cur_entry
;
1131 CORE_ADDR cur_entry_addr
;
1132 struct gdbarch
*gdbarch
= inf
->gdbarch
;
1133 program_space
*pspace
= inf
->pspace
;
1135 jit_debug_printf ("called");
1137 jit_prepend_unwinder (gdbarch
);
1139 jit_breakpoint_re_set_internal (gdbarch
, pspace
);
1141 for (objfile
*jiter
: pspace
->objfiles ())
1143 if (jiter
->jiter_data
== nullptr)
1146 /* Read the descriptor so we can check the version number and load
1147 any already JITed functions. */
1148 if (!jit_read_descriptor (gdbarch
, &descriptor
, jiter
))
1151 /* Check that the version number agrees with that we support. */
1152 if (descriptor
.version
!= 1)
1154 fprintf_unfiltered (gdb_stderr
,
1155 _("Unsupported JIT protocol version %ld "
1156 "in descriptor (expected 1)\n"),
1157 (long) descriptor
.version
);
1161 /* If we've attached to a running program, we need to check the
1162 descriptor to register any functions that were already
1164 for (cur_entry_addr
= descriptor
.first_entry
;
1165 cur_entry_addr
!= 0;
1166 cur_entry_addr
= cur_entry
.next_entry
)
1168 jit_read_code_entry (gdbarch
, cur_entry_addr
, &cur_entry
);
1170 /* This hook may be called many times during setup, so make sure
1171 we don't add the same symbol file twice. */
1172 if (jit_find_objf_with_entry_addr (cur_entry_addr
) != NULL
)
1175 jit_register_code (gdbarch
, cur_entry_addr
, &cur_entry
);
1180 /* Looks for the descriptor and registration symbols and breakpoints
1181 the registration function. If it finds both, it registers all the
1182 already JITed code. If it has already found the symbols, then it
1183 doesn't try again. */
1186 jit_inferior_created_hook (inferior
*inf
)
1188 jit_inferior_init (inf
);
1191 /* Exported routine to call to re-set the jit breakpoints,
1192 e.g. when a program is rerun. */
1195 jit_breakpoint_re_set (void)
1197 jit_breakpoint_re_set_internal (target_gdbarch (), current_program_space
);
1200 /* This function cleans up any code entries left over when the
1201 inferior exits. We get left over code when the inferior exits
1202 without unregistering its code, for example when it crashes. */
1205 jit_inferior_exit_hook (struct inferior
*inf
)
1207 for (objfile
*objf
: current_program_space
->objfiles_safe ())
1209 if (objf
->jited_data
!= nullptr && objf
->jited_data
->addr
!= 0)
1215 jit_event_handler (gdbarch
*gdbarch
, objfile
*jiter
)
1217 struct jit_descriptor descriptor
;
1219 /* If we get a JIT breakpoint event for this objfile, it is necessarily a
1221 gdb_assert (jiter
->jiter_data
!= nullptr);
1223 /* Read the descriptor from remote memory. */
1224 if (!jit_read_descriptor (gdbarch
, &descriptor
, jiter
))
1226 CORE_ADDR entry_addr
= descriptor
.relevant_entry
;
1228 /* Do the corresponding action. */
1229 switch (descriptor
.action_flag
)
1236 jit_code_entry code_entry
;
1237 jit_read_code_entry (gdbarch
, entry_addr
, &code_entry
);
1238 jit_register_code (gdbarch
, entry_addr
, &code_entry
);
1242 case JIT_UNREGISTER
:
1244 objfile
*jited
= jit_find_objf_with_entry_addr (entry_addr
);
1245 if (jited
== nullptr)
1246 fprintf_unfiltered (gdb_stderr
,
1247 _("Unable to find JITed code "
1248 "entry at address: %s\n"),
1249 paddress (gdbarch
, entry_addr
));
1257 error (_("Unknown action_flag value in JIT descriptor!"));
1262 /* Initialize the jit_gdbarch_data slot with an instance of struct
1263 jit_gdbarch_data_type */
1266 jit_gdbarch_data_init (struct obstack
*obstack
)
1268 struct jit_gdbarch_data_type
*data
=
1269 XOBNEW (obstack
, struct jit_gdbarch_data_type
);
1271 data
->unwinder_registered
= 0;
1276 void _initialize_jit ();
1280 jit_reader_dir
= relocate_gdb_directory (JIT_READER_DIR
,
1281 JIT_READER_DIR_RELOCATABLE
);
1282 add_setshow_boolean_cmd ("jit", class_maintenance
, &jit_debug
,
1283 _("Set JIT debugging."),
1284 _("Show JIT debugging."),
1285 _("When set, JIT debugging is enabled."),
1288 &setdebuglist
, &showdebuglist
);
1290 add_cmd ("jit", class_maintenance
, maint_info_jit_cmd
,
1291 _("Print information about JIT-ed code objects."),
1292 &maintenanceinfolist
);
1294 gdb::observers::inferior_created
.attach (jit_inferior_created_hook
, "jit");
1295 gdb::observers::inferior_execd
.attach (jit_inferior_created_hook
, "jit");
1296 gdb::observers::inferior_exit
.attach (jit_inferior_exit_hook
, "jit");
1297 gdb::observers::breakpoint_deleted
.attach (jit_breakpoint_deleted
, "jit");
1299 jit_gdbarch_data
= gdbarch_data_register_pre_init (jit_gdbarch_data_init
);
1300 if (is_dl_available ())
1302 struct cmd_list_element
*c
;
1304 c
= add_com ("jit-reader-load", no_class
, jit_reader_load_command
, _("\
1305 Load FILE as debug info reader and unwinder for JIT compiled code.\n\
1306 Usage: jit-reader-load FILE\n\
1307 Try to load file FILE as a debug info reader (and unwinder) for\n\
1308 JIT compiled code. The file is loaded from " JIT_READER_DIR
",\n\
1309 relocated relative to the GDB executable if required."));
1310 set_cmd_completer (c
, filename_completer
);
1312 c
= add_com ("jit-reader-unload", no_class
,
1313 jit_reader_unload_command
, _("\
1314 Unload the currently loaded JIT debug info reader.\n\
1315 Usage: jit-reader-unload\n\n\
1316 Do \"help jit-reader-load\" for info on loading debug info readers."));
1317 set_cmd_completer (c
, noop_completer
);