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 typedef CORE_ADDR jit_dbg_reader_data
;
385 /* The reader calls into this function to read data off the targets
388 static enum gdb_status
389 jit_target_read_impl (GDB_CORE_ADDR target_mem
, void *gdb_buf
, int len
)
391 int result
= target_read_memory ((CORE_ADDR
) target_mem
,
392 (gdb_byte
*) gdb_buf
, len
);
399 /* The reader calls into this function to create a new gdb_object
400 which it can then pass around to the other callbacks. Right now,
401 all that is required is allocating the memory. */
403 static struct gdb_object
*
404 jit_object_open_impl (struct gdb_symbol_callbacks
*cb
)
406 /* CB is not required right now, but sometime in the future we might
407 need a handle to it, and we'd like to do that without breaking
409 return new gdb_object
;
412 /* Readers call into this function to open a new gdb_symtab, which,
413 again, is passed around to other callbacks. */
415 static struct gdb_symtab
*
416 jit_symtab_open_impl (struct gdb_symbol_callbacks
*cb
,
417 struct gdb_object
*object
,
418 const char *file_name
)
420 /* CB stays unused. See comment in jit_object_open_impl. */
422 object
->symtabs
.emplace_front (file_name
);
423 return &object
->symtabs
.front ();
426 /* Called by readers to open a new gdb_block. This function also
427 inserts the new gdb_block in the correct place in the corresponding
430 static struct gdb_block
*
431 jit_block_open_impl (struct gdb_symbol_callbacks
*cb
,
432 struct gdb_symtab
*symtab
, struct gdb_block
*parent
,
433 GDB_CORE_ADDR begin
, GDB_CORE_ADDR end
, const char *name
)
435 /* Place the block at the beginning of the list, it will be sorted when the
436 symtab is finalized. */
437 symtab
->blocks
.emplace_front (parent
, begin
, end
, name
);
440 return &symtab
->blocks
.front ();
443 /* Readers call this to add a line mapping (from PC to line number) to
447 jit_symtab_line_mapping_add_impl (struct gdb_symbol_callbacks
*cb
,
448 struct gdb_symtab
*stab
, int nlines
,
449 struct gdb_line_mapping
*map
)
457 alloc_len
= sizeof (struct linetable
)
458 + (nlines
- 1) * sizeof (struct linetable_entry
);
459 stab
->linetable
.reset (XNEWVAR (struct linetable
, alloc_len
));
460 stab
->linetable
->nitems
= nlines
;
461 for (i
= 0; i
< nlines
; i
++)
463 stab
->linetable
->item
[i
].pc
= (CORE_ADDR
) map
[i
].pc
;
464 stab
->linetable
->item
[i
].line
= map
[i
].line
;
465 stab
->linetable
->item
[i
].is_stmt
= 1;
469 /* Called by readers to close a gdb_symtab. Does not need to do
470 anything as of now. */
473 jit_symtab_close_impl (struct gdb_symbol_callbacks
*cb
,
474 struct gdb_symtab
*stab
)
476 /* Right now nothing needs to be done here. We may need to do some
477 cleanup here in the future (again, without breaking the plugin
481 /* Transform STAB to a proper symtab, and add it it OBJFILE. */
484 finalize_symtab (struct gdb_symtab
*stab
, struct objfile
*objfile
)
486 struct compunit_symtab
*cust
;
487 size_t blockvector_size
;
488 CORE_ADDR begin
, end
;
489 struct blockvector
*bv
;
491 int actual_nblocks
= FIRST_LOCAL_BLOCK
+ stab
->nblocks
;
493 /* Sort the blocks in the order they should appear in the blockvector. */
494 stab
->blocks
.sort([] (const gdb_block
&a
, const gdb_block
&b
)
496 if (a
.begin
!= b
.begin
)
497 return a
.begin
< b
.begin
;
499 return a
.end
> b
.end
;
502 cust
= allocate_compunit_symtab (objfile
, stab
->file_name
.c_str ());
503 allocate_symtab (cust
, stab
->file_name
.c_str ());
504 add_compunit_symtab_to_objfile (cust
);
506 /* JIT compilers compile in memory. */
507 COMPUNIT_DIRNAME (cust
) = NULL
;
509 /* Copy over the linetable entry if one was provided. */
512 size_t size
= ((stab
->linetable
->nitems
- 1)
513 * sizeof (struct linetable_entry
)
514 + sizeof (struct linetable
));
515 SYMTAB_LINETABLE (COMPUNIT_FILETABS (cust
))
516 = (struct linetable
*) obstack_alloc (&objfile
->objfile_obstack
, size
);
517 memcpy (SYMTAB_LINETABLE (COMPUNIT_FILETABS (cust
)),
518 stab
->linetable
.get (), size
);
521 blockvector_size
= (sizeof (struct blockvector
)
522 + (actual_nblocks
- 1) * sizeof (struct block
*));
523 bv
= (struct blockvector
*) obstack_alloc (&objfile
->objfile_obstack
,
525 COMPUNIT_BLOCKVECTOR (cust
) = bv
;
527 /* At the end of this function, (begin, end) will contain the PC range this
528 entire blockvector spans. */
529 BLOCKVECTOR_MAP (bv
) = NULL
;
530 begin
= stab
->blocks
.front ().begin
;
531 end
= stab
->blocks
.front ().end
;
532 BLOCKVECTOR_NBLOCKS (bv
) = actual_nblocks
;
534 /* First run over all the gdb_block objects, creating a real block
535 object for each. Simultaneously, keep setting the real_block
537 int block_idx
= FIRST_LOCAL_BLOCK
;
538 for (gdb_block
&gdb_block_iter
: stab
->blocks
)
540 struct block
*new_block
= allocate_block (&objfile
->objfile_obstack
);
541 struct symbol
*block_name
= new (&objfile
->objfile_obstack
) symbol
;
542 struct type
*block_type
= arch_type (objfile
->arch (),
547 BLOCK_MULTIDICT (new_block
)
548 = mdict_create_linear (&objfile
->objfile_obstack
, NULL
);
549 /* The address range. */
550 BLOCK_START (new_block
) = (CORE_ADDR
) gdb_block_iter
.begin
;
551 BLOCK_END (new_block
) = (CORE_ADDR
) gdb_block_iter
.end
;
554 SYMBOL_DOMAIN (block_name
) = VAR_DOMAIN
;
555 SYMBOL_ACLASS_INDEX (block_name
) = LOC_BLOCK
;
556 symbol_set_symtab (block_name
, COMPUNIT_FILETABS (cust
));
557 SYMBOL_TYPE (block_name
) = lookup_function_type (block_type
);
558 SYMBOL_BLOCK_VALUE (block_name
) = new_block
;
560 block_name
->m_name
= obstack_strdup (&objfile
->objfile_obstack
,
561 gdb_block_iter
.name
.get ());
563 BLOCK_FUNCTION (new_block
) = block_name
;
565 BLOCKVECTOR_BLOCK (bv
, block_idx
) = new_block
;
566 if (begin
> BLOCK_START (new_block
))
567 begin
= BLOCK_START (new_block
);
568 if (end
< BLOCK_END (new_block
))
569 end
= BLOCK_END (new_block
);
571 gdb_block_iter
.real_block
= new_block
;
576 /* Now add the special blocks. */
577 struct block
*block_iter
= NULL
;
578 for (enum block_enum i
: { GLOBAL_BLOCK
, STATIC_BLOCK
})
580 struct block
*new_block
;
582 new_block
= (i
== GLOBAL_BLOCK
583 ? allocate_global_block (&objfile
->objfile_obstack
)
584 : allocate_block (&objfile
->objfile_obstack
));
585 BLOCK_MULTIDICT (new_block
)
586 = mdict_create_linear (&objfile
->objfile_obstack
, NULL
);
587 BLOCK_SUPERBLOCK (new_block
) = block_iter
;
588 block_iter
= new_block
;
590 BLOCK_START (new_block
) = (CORE_ADDR
) begin
;
591 BLOCK_END (new_block
) = (CORE_ADDR
) end
;
593 BLOCKVECTOR_BLOCK (bv
, i
) = new_block
;
595 if (i
== GLOBAL_BLOCK
)
596 set_block_compunit_symtab (new_block
, cust
);
599 /* Fill up the superblock fields for the real blocks, using the
600 real_block fields populated earlier. */
601 for (gdb_block
&gdb_block_iter
: stab
->blocks
)
603 if (gdb_block_iter
.parent
!= NULL
)
605 /* If the plugin specifically mentioned a parent block, we
607 BLOCK_SUPERBLOCK (gdb_block_iter
.real_block
) =
608 gdb_block_iter
.parent
->real_block
;
612 /* And if not, we set a default parent block. */
613 BLOCK_SUPERBLOCK (gdb_block_iter
.real_block
) =
614 BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
);
619 /* Called when closing a gdb_objfile. Converts OBJ to a proper
623 jit_object_close_impl (struct gdb_symbol_callbacks
*cb
,
624 struct gdb_object
*obj
)
626 struct objfile
*objfile
;
627 jit_dbg_reader_data
*priv_data
;
629 priv_data
= (jit_dbg_reader_data
*) cb
->priv_data
;
631 objfile
= objfile::make (nullptr, "<< JIT compiled code >>",
633 objfile
->per_bfd
->gdbarch
= target_gdbarch ();
635 for (gdb_symtab
&symtab
: obj
->symtabs
)
636 finalize_symtab (&symtab
, objfile
);
638 add_objfile_entry (objfile
, *priv_data
);
643 /* Try to read CODE_ENTRY using the loaded jit reader (if any).
644 ENTRY_ADDR is the address of the struct jit_code_entry in the
645 inferior address space. */
648 jit_reader_try_read_symtab (struct jit_code_entry
*code_entry
,
649 CORE_ADDR entry_addr
)
652 jit_dbg_reader_data priv_data
;
653 struct gdb_reader_funcs
*funcs
;
654 struct gdb_symbol_callbacks callbacks
=
656 jit_object_open_impl
,
657 jit_symtab_open_impl
,
659 jit_symtab_close_impl
,
660 jit_object_close_impl
,
662 jit_symtab_line_mapping_add_impl
,
663 jit_target_read_impl
,
668 priv_data
= entry_addr
;
670 if (!loaded_jit_reader
)
673 gdb::byte_vector
gdb_mem (code_entry
->symfile_size
);
678 if (target_read_memory (code_entry
->symfile_addr
, gdb_mem
.data (),
679 code_entry
->symfile_size
))
682 catch (const gdb_exception
&e
)
689 funcs
= loaded_jit_reader
->functions
;
690 if (funcs
->read (funcs
, &callbacks
, gdb_mem
.data (),
691 code_entry
->symfile_size
)
697 jit_debug_printf ("Could not read symtab using the loaded JIT reader.");
702 /* Try to read CODE_ENTRY using BFD. ENTRY_ADDR is the address of the
703 struct jit_code_entry in the inferior address space. */
706 jit_bfd_try_read_symtab (struct jit_code_entry
*code_entry
,
707 CORE_ADDR entry_addr
,
708 struct gdbarch
*gdbarch
)
710 struct bfd_section
*sec
;
711 struct objfile
*objfile
;
712 const struct bfd_arch_info
*b
;
714 jit_debug_printf ("symfile_addr = %s, symfile_size = %s",
715 paddress (gdbarch
, code_entry
->symfile_addr
),
716 pulongest (code_entry
->symfile_size
));
718 gdb_bfd_ref_ptr
nbfd (gdb_bfd_open_from_target_memory
719 (code_entry
->symfile_addr
, code_entry
->symfile_size
, gnutarget
));
722 fputs_unfiltered (_("Error opening JITed symbol file, ignoring it.\n"),
727 /* Check the format. NOTE: This initializes important data that GDB uses!
728 We would segfault later without this line. */
729 if (!bfd_check_format (nbfd
.get (), bfd_object
))
731 fprintf_unfiltered (gdb_stderr
, _("\
732 JITed symbol file is not an object file, ignoring it.\n"));
736 /* Check bfd arch. */
737 b
= gdbarch_bfd_arch_info (gdbarch
);
738 if (b
->compatible (b
, bfd_get_arch_info (nbfd
.get ())) != b
)
739 warning (_("JITed object file architecture %s is not compatible "
740 "with target architecture %s."),
741 bfd_get_arch_info (nbfd
.get ())->printable_name
,
744 /* Read the section address information out of the symbol file. Since the
745 file is generated by the JIT at runtime, it should all of the absolute
746 addresses that we care about. */
747 section_addr_info sai
;
748 for (sec
= nbfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
749 if ((bfd_section_flags (sec
) & (SEC_ALLOC
|SEC_LOAD
)) != 0)
751 /* We assume that these virtual addresses are absolute, and do not
752 treat them as offsets. */
753 sai
.emplace_back (bfd_section_vma (sec
),
754 bfd_section_name (sec
),
758 /* This call does not take ownership of SAI. */
759 objfile
= symbol_file_add_from_bfd (nbfd
.get (),
760 bfd_get_filename (nbfd
.get ()), 0,
762 OBJF_SHARED
| OBJF_NOT_FILENAME
, NULL
);
764 add_objfile_entry (objfile
, entry_addr
);
767 /* This function registers code associated with a JIT code entry. It uses the
768 pointer and size pair in the entry to read the symbol file from the remote
769 and then calls symbol_file_add_from_local_memory to add it as though it were
770 a symbol file added by the user. */
773 jit_register_code (struct gdbarch
*gdbarch
,
774 CORE_ADDR entry_addr
, struct jit_code_entry
*code_entry
)
778 jit_debug_printf ("symfile_addr = %s, symfile_size = %s",
779 paddress (gdbarch
, code_entry
->symfile_addr
),
780 pulongest (code_entry
->symfile_size
));
782 success
= jit_reader_try_read_symtab (code_entry
, entry_addr
);
785 jit_bfd_try_read_symtab (code_entry
, entry_addr
, gdbarch
);
788 /* Look up the objfile with this code entry address. */
790 static struct objfile
*
791 jit_find_objf_with_entry_addr (CORE_ADDR entry_addr
)
793 for (objfile
*objf
: current_program_space
->objfiles ())
795 if (objf
->jited_data
!= nullptr && objf
->jited_data
->addr
== entry_addr
)
802 /* This is called when a breakpoint is deleted. It updates the
803 inferior's cache, if needed. */
806 jit_breakpoint_deleted (struct breakpoint
*b
)
808 if (b
->type
!= bp_jit_event
)
811 for (bp_location
*iter
: b
->locations ())
813 for (objfile
*objf
: iter
->pspace
->objfiles ())
815 jiter_objfile_data
*jiter_data
= objf
->jiter_data
.get ();
817 if (jiter_data
!= nullptr
818 && jiter_data
->jit_breakpoint
== iter
->owner
)
820 jiter_data
->cached_code_address
= 0;
821 jiter_data
->jit_breakpoint
= nullptr;
827 /* (Re-)Initialize the jit breakpoints for JIT-producing objfiles in
831 jit_breakpoint_re_set_internal (struct gdbarch
*gdbarch
, program_space
*pspace
)
833 for (objfile
*the_objfile
: pspace
->objfiles ())
835 /* Skip separate debug objects. */
836 if (the_objfile
->separate_debug_objfile_backlink
!= nullptr)
839 if (the_objfile
->skip_jit_symbol_lookup
)
842 /* Lookup the registration symbol. If it is missing, then we
843 assume we are not attached to a JIT. */
844 bound_minimal_symbol reg_symbol
845 = lookup_minimal_symbol (jit_break_name
, nullptr, the_objfile
);
846 if (reg_symbol
.minsym
== NULL
847 || BMSYMBOL_VALUE_ADDRESS (reg_symbol
) == 0)
849 /* No need to repeat the lookup the next time. */
850 the_objfile
->skip_jit_symbol_lookup
= true;
854 bound_minimal_symbol desc_symbol
855 = lookup_minimal_symbol (jit_descriptor_name
, NULL
, the_objfile
);
856 if (desc_symbol
.minsym
== NULL
857 || BMSYMBOL_VALUE_ADDRESS (desc_symbol
) == 0)
859 /* No need to repeat the lookup the next time. */
860 the_objfile
->skip_jit_symbol_lookup
= true;
864 jiter_objfile_data
*objf_data
865 = get_jiter_objfile_data (the_objfile
);
866 objf_data
->register_code
= reg_symbol
.minsym
;
867 objf_data
->descriptor
= desc_symbol
.minsym
;
869 CORE_ADDR addr
= MSYMBOL_VALUE_ADDRESS (the_objfile
,
870 objf_data
->register_code
);
872 jit_debug_printf ("breakpoint_addr = %s", paddress (gdbarch
, addr
));
874 /* Check if we need to re-create the breakpoint. */
875 if (objf_data
->cached_code_address
== addr
)
878 /* Delete the old breakpoint. */
879 if (objf_data
->jit_breakpoint
!= nullptr)
880 delete_breakpoint (objf_data
->jit_breakpoint
);
882 /* Put a breakpoint in the registration symbol. */
883 objf_data
->cached_code_address
= addr
;
884 objf_data
->jit_breakpoint
= create_jit_event_breakpoint (gdbarch
, addr
);
888 /* The private data passed around in the frame unwind callback
891 struct jit_unwind_private
893 /* Cached register values. See jit_frame_sniffer to see how this
895 detached_regcache
*regcache
;
897 /* The frame being unwound. */
898 struct frame_info
*this_frame
;
901 /* Sets the value of a particular register in this frame. */
904 jit_unwind_reg_set_impl (struct gdb_unwind_callbacks
*cb
, int dwarf_regnum
,
905 struct gdb_reg_value
*value
)
907 struct jit_unwind_private
*priv
;
910 priv
= (struct jit_unwind_private
*) cb
->priv_data
;
912 gdb_reg
= gdbarch_dwarf2_reg_to_regnum (get_frame_arch (priv
->this_frame
),
916 jit_debug_printf ("Could not recognize DWARF regnum %d", dwarf_regnum
);
921 priv
->regcache
->raw_supply (gdb_reg
, value
->value
);
926 reg_value_free_impl (struct gdb_reg_value
*value
)
931 /* Get the value of register REGNUM in the previous frame. */
933 static struct gdb_reg_value
*
934 jit_unwind_reg_get_impl (struct gdb_unwind_callbacks
*cb
, int regnum
)
936 struct jit_unwind_private
*priv
;
937 struct gdb_reg_value
*value
;
939 struct gdbarch
*frame_arch
;
941 priv
= (struct jit_unwind_private
*) cb
->priv_data
;
942 frame_arch
= get_frame_arch (priv
->this_frame
);
944 gdb_reg
= gdbarch_dwarf2_reg_to_regnum (frame_arch
, regnum
);
945 size
= register_size (frame_arch
, gdb_reg
);
946 value
= ((struct gdb_reg_value
*)
947 xmalloc (sizeof (struct gdb_reg_value
) + size
- 1));
948 value
->defined
= deprecated_frame_register_read (priv
->this_frame
, gdb_reg
,
951 value
->free
= reg_value_free_impl
;
955 /* gdb_reg_value has a free function, which must be called on each
956 saved register value. */
959 jit_dealloc_cache (struct frame_info
*this_frame
, void *cache
)
961 struct jit_unwind_private
*priv_data
= (struct jit_unwind_private
*) cache
;
963 gdb_assert (priv_data
->regcache
!= NULL
);
964 delete priv_data
->regcache
;
968 /* The frame sniffer for the pseudo unwinder.
970 While this is nominally a frame sniffer, in the case where the JIT
971 reader actually recognizes the frame, it does a lot more work -- it
972 unwinds the frame and saves the corresponding register values in
973 the cache. jit_frame_prev_register simply returns the saved
977 jit_frame_sniffer (const struct frame_unwind
*self
,
978 struct frame_info
*this_frame
, void **cache
)
980 struct jit_unwind_private
*priv_data
;
981 struct gdb_unwind_callbacks callbacks
;
982 struct gdb_reader_funcs
*funcs
;
984 callbacks
.reg_get
= jit_unwind_reg_get_impl
;
985 callbacks
.reg_set
= jit_unwind_reg_set_impl
;
986 callbacks
.target_read
= jit_target_read_impl
;
988 if (loaded_jit_reader
== NULL
)
991 funcs
= loaded_jit_reader
->functions
;
993 gdb_assert (!*cache
);
995 *cache
= XCNEW (struct jit_unwind_private
);
996 priv_data
= (struct jit_unwind_private
*) *cache
;
997 /* Take a snapshot of current regcache. */
998 priv_data
->regcache
= new detached_regcache (get_frame_arch (this_frame
),
1000 priv_data
->this_frame
= this_frame
;
1002 callbacks
.priv_data
= priv_data
;
1004 /* Try to coax the provided unwinder to unwind the stack */
1005 if (funcs
->unwind (funcs
, &callbacks
) == GDB_SUCCESS
)
1007 jit_debug_printf ("Successfully unwound frame using JIT reader.");
1011 jit_debug_printf ("Could not unwind frame using JIT reader.");
1013 jit_dealloc_cache (this_frame
, *cache
);
1020 /* The frame_id function for the pseudo unwinder. Relays the call to
1021 the loaded plugin. */
1024 jit_frame_this_id (struct frame_info
*this_frame
, void **cache
,
1025 struct frame_id
*this_id
)
1027 struct jit_unwind_private priv
;
1028 struct gdb_frame_id frame_id
;
1029 struct gdb_reader_funcs
*funcs
;
1030 struct gdb_unwind_callbacks callbacks
;
1032 priv
.regcache
= NULL
;
1033 priv
.this_frame
= this_frame
;
1035 /* We don't expect the frame_id function to set any registers, so we
1036 set reg_set to NULL. */
1037 callbacks
.reg_get
= jit_unwind_reg_get_impl
;
1038 callbacks
.reg_set
= NULL
;
1039 callbacks
.target_read
= jit_target_read_impl
;
1040 callbacks
.priv_data
= &priv
;
1042 gdb_assert (loaded_jit_reader
);
1043 funcs
= loaded_jit_reader
->functions
;
1045 frame_id
= funcs
->get_frame_id (funcs
, &callbacks
);
1046 *this_id
= frame_id_build (frame_id
.stack_address
, frame_id
.code_address
);
1049 /* Pseudo unwinder function. Reads the previously fetched value for
1050 the register from the cache. */
1052 static struct value
*
1053 jit_frame_prev_register (struct frame_info
*this_frame
, void **cache
, int reg
)
1055 struct jit_unwind_private
*priv
= (struct jit_unwind_private
*) *cache
;
1056 struct gdbarch
*gdbarch
;
1059 return frame_unwind_got_optimized (this_frame
, reg
);
1061 gdbarch
= priv
->regcache
->arch ();
1062 gdb_byte
*buf
= (gdb_byte
*) alloca (register_size (gdbarch
, reg
));
1063 enum register_status status
= priv
->regcache
->cooked_read (reg
, buf
);
1065 if (status
== REG_VALID
)
1066 return frame_unwind_got_bytes (this_frame
, reg
, buf
);
1068 return frame_unwind_got_optimized (this_frame
, reg
);
1071 /* Relay everything back to the unwinder registered by the JIT debug
1074 static const struct frame_unwind jit_frame_unwind
=
1078 default_frame_unwind_stop_reason
,
1080 jit_frame_prev_register
,
1087 /* This is the information that is stored at jit_gdbarch_data for each
1090 struct jit_gdbarch_data_type
1092 /* Has the (pseudo) unwinder been prepended? */
1093 int unwinder_registered
;
1096 /* Check GDBARCH and prepend the pseudo JIT unwinder if needed. */
1099 jit_prepend_unwinder (struct gdbarch
*gdbarch
)
1101 struct jit_gdbarch_data_type
*data
;
1104 = (struct jit_gdbarch_data_type
*) gdbarch_data (gdbarch
, jit_gdbarch_data
);
1105 if (!data
->unwinder_registered
)
1107 frame_unwind_prepend_unwinder (gdbarch
, &jit_frame_unwind
);
1108 data
->unwinder_registered
= 1;
1112 /* Register any already created translations. */
1115 jit_inferior_init (inferior
*inf
)
1117 struct jit_descriptor descriptor
;
1118 struct jit_code_entry cur_entry
;
1119 CORE_ADDR cur_entry_addr
;
1120 struct gdbarch
*gdbarch
= inf
->gdbarch
;
1121 program_space
*pspace
= inf
->pspace
;
1123 jit_debug_printf ("called");
1125 jit_prepend_unwinder (gdbarch
);
1127 jit_breakpoint_re_set_internal (gdbarch
, pspace
);
1129 for (objfile
*jiter
: pspace
->objfiles ())
1131 if (jiter
->jiter_data
== nullptr)
1134 /* Read the descriptor so we can check the version number and load
1135 any already JITed functions. */
1136 if (!jit_read_descriptor (gdbarch
, &descriptor
, jiter
))
1139 /* Check that the version number agrees with that we support. */
1140 if (descriptor
.version
!= 1)
1142 fprintf_unfiltered (gdb_stderr
,
1143 _("Unsupported JIT protocol version %ld "
1144 "in descriptor (expected 1)\n"),
1145 (long) descriptor
.version
);
1149 /* If we've attached to a running program, we need to check the
1150 descriptor to register any functions that were already
1152 for (cur_entry_addr
= descriptor
.first_entry
;
1153 cur_entry_addr
!= 0;
1154 cur_entry_addr
= cur_entry
.next_entry
)
1156 jit_read_code_entry (gdbarch
, cur_entry_addr
, &cur_entry
);
1158 /* This hook may be called many times during setup, so make sure
1159 we don't add the same symbol file twice. */
1160 if (jit_find_objf_with_entry_addr (cur_entry_addr
) != NULL
)
1163 jit_register_code (gdbarch
, cur_entry_addr
, &cur_entry
);
1168 /* Looks for the descriptor and registration symbols and breakpoints
1169 the registration function. If it finds both, it registers all the
1170 already JITed code. If it has already found the symbols, then it
1171 doesn't try again. */
1174 jit_inferior_created_hook (inferior
*inf
)
1176 jit_inferior_init (inf
);
1179 /* Exported routine to call to re-set the jit breakpoints,
1180 e.g. when a program is rerun. */
1183 jit_breakpoint_re_set (void)
1185 jit_breakpoint_re_set_internal (target_gdbarch (), current_program_space
);
1188 /* This function cleans up any code entries left over when the
1189 inferior exits. We get left over code when the inferior exits
1190 without unregistering its code, for example when it crashes. */
1193 jit_inferior_exit_hook (struct inferior
*inf
)
1195 for (objfile
*objf
: current_program_space
->objfiles_safe ())
1197 if (objf
->jited_data
!= nullptr && objf
->jited_data
->addr
!= 0)
1203 jit_event_handler (gdbarch
*gdbarch
, objfile
*jiter
)
1205 struct jit_descriptor descriptor
;
1207 /* If we get a JIT breakpoint event for this objfile, it is necessarily a
1209 gdb_assert (jiter
->jiter_data
!= nullptr);
1211 /* Read the descriptor from remote memory. */
1212 if (!jit_read_descriptor (gdbarch
, &descriptor
, jiter
))
1214 CORE_ADDR entry_addr
= descriptor
.relevant_entry
;
1216 /* Do the corresponding action. */
1217 switch (descriptor
.action_flag
)
1224 jit_code_entry code_entry
;
1225 jit_read_code_entry (gdbarch
, entry_addr
, &code_entry
);
1226 jit_register_code (gdbarch
, entry_addr
, &code_entry
);
1230 case JIT_UNREGISTER
:
1232 objfile
*jited
= jit_find_objf_with_entry_addr (entry_addr
);
1233 if (jited
== nullptr)
1234 fprintf_unfiltered (gdb_stderr
,
1235 _("Unable to find JITed code "
1236 "entry at address: %s\n"),
1237 paddress (gdbarch
, entry_addr
));
1245 error (_("Unknown action_flag value in JIT descriptor!"));
1250 /* Initialize the jit_gdbarch_data slot with an instance of struct
1251 jit_gdbarch_data_type */
1254 jit_gdbarch_data_init (struct obstack
*obstack
)
1256 struct jit_gdbarch_data_type
*data
=
1257 XOBNEW (obstack
, struct jit_gdbarch_data_type
);
1259 data
->unwinder_registered
= 0;
1264 void _initialize_jit ();
1268 jit_reader_dir
= relocate_gdb_directory (JIT_READER_DIR
,
1269 JIT_READER_DIR_RELOCATABLE
);
1270 add_setshow_boolean_cmd ("jit", class_maintenance
, &jit_debug
,
1271 _("Set JIT debugging."),
1272 _("Show JIT debugging."),
1273 _("When set, JIT debugging is enabled."),
1276 &setdebuglist
, &showdebuglist
);
1278 add_cmd ("jit", class_maintenance
, maint_info_jit_cmd
,
1279 _("Print information about JIT-ed code objects."),
1280 &maintenanceinfolist
);
1282 gdb::observers::inferior_created
.attach (jit_inferior_created_hook
, "jit");
1283 gdb::observers::inferior_execd
.attach (jit_inferior_created_hook
, "jit");
1284 gdb::observers::inferior_exit
.attach (jit_inferior_exit_hook
, "jit");
1285 gdb::observers::breakpoint_deleted
.attach (jit_breakpoint_deleted
, "jit");
1287 jit_gdbarch_data
= gdbarch_data_register_pre_init (jit_gdbarch_data_init
);
1288 if (is_dl_available ())
1290 struct cmd_list_element
*c
;
1292 c
= add_com ("jit-reader-load", no_class
, jit_reader_load_command
, _("\
1293 Load FILE as debug info reader and unwinder for JIT compiled code.\n\
1294 Usage: jit-reader-load FILE\n\
1295 Try to load file FILE as a debug info reader (and unwinder) for\n\
1296 JIT compiled code. The file is loaded from " JIT_READER_DIR
",\n\
1297 relocated relative to the GDB executable if required."));
1298 set_cmd_completer (c
, filename_completer
);
1300 c
= add_com ("jit-reader-unload", no_class
,
1301 jit_reader_unload_command
, _("\
1302 Unload the currently loaded JIT debug info reader.\n\
1303 Usage: jit-reader-unload\n\n\
1304 Do \"help jit-reader-load\" for info on loading debug info readers."));
1305 set_cmd_completer (c
, noop_completer
);