1 /* Handle JIT code generation in the inferior for GDB, the GNU Debugger.
3 Copyright (C) 2009-2020 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 struct objfile_data
*jit_objfile_data
;
50 static const char *const jit_break_name
= "__jit_debug_register_code";
52 static const char *const jit_descriptor_name
= "__jit_debug_descriptor";
54 static void jit_inferior_init (struct gdbarch
*gdbarch
);
55 static void jit_inferior_exit_hook (struct inferior
*inf
);
57 /* An unwinder is registered for every gdbarch. This key is used to
58 remember if the unwinder has been registered for a particular
61 static struct gdbarch_data
*jit_gdbarch_data
;
63 /* Non-zero if we want to see trace of jit level stuff. */
65 static unsigned int jit_debug
= 0;
68 show_jit_debug (struct ui_file
*file
, int from_tty
,
69 struct cmd_list_element
*c
, const char *value
)
71 fprintf_filtered (file
, _("JIT debugging is %s.\n"), value
);
80 /* Opening the file is a no-op. */
83 mem_bfd_iovec_open (struct bfd
*abfd
, void *open_closure
)
88 /* Closing the file is just freeing the base/size pair on our side. */
91 mem_bfd_iovec_close (struct bfd
*abfd
, void *stream
)
95 /* Zero means success. */
99 /* For reading the file, we just need to pass through to target_read_memory and
100 fix up the arguments and return values. */
103 mem_bfd_iovec_pread (struct bfd
*abfd
, void *stream
, void *buf
,
104 file_ptr nbytes
, file_ptr offset
)
107 struct target_buffer
*buffer
= (struct target_buffer
*) stream
;
109 /* If this read will read all of the file, limit it to just the rest. */
110 if (offset
+ nbytes
> buffer
->size
)
111 nbytes
= buffer
->size
- offset
;
113 /* If there are no more bytes left, we've reached EOF. */
117 err
= target_read_memory (buffer
->base
+ offset
, (gdb_byte
*) buf
, nbytes
);
124 /* For statting the file, we only support the st_size attribute. */
127 mem_bfd_iovec_stat (struct bfd
*abfd
, void *stream
, struct stat
*sb
)
129 struct target_buffer
*buffer
= (struct target_buffer
*) stream
;
131 memset (sb
, 0, sizeof (struct stat
));
132 sb
->st_size
= buffer
->size
;
136 /* Open a BFD from the target's memory. */
138 static gdb_bfd_ref_ptr
139 bfd_open_from_target_memory (CORE_ADDR addr
, ULONGEST size
,
142 struct target_buffer
*buffer
= XNEW (struct target_buffer
);
146 return gdb_bfd_openr_iovec ("<in-memory>", target
,
156 jit_reader (struct gdb_reader_funcs
*f
, gdb_dlhandle_up
&&h
)
157 : functions (f
), handle (std::move (h
))
163 functions
->destroy (functions
);
166 DISABLE_COPY_AND_ASSIGN (jit_reader
);
168 struct gdb_reader_funcs
*functions
;
169 gdb_dlhandle_up handle
;
172 /* One reader that has been loaded successfully, and can potentially be used to
175 static struct jit_reader
*loaded_jit_reader
= NULL
;
177 typedef struct gdb_reader_funcs
* (reader_init_fn_type
) (void);
178 static const char *reader_init_fn_sym
= "gdb_init_reader";
180 /* Try to load FILE_NAME as a JIT debug info reader. */
182 static struct jit_reader
*
183 jit_reader_load (const char *file_name
)
185 reader_init_fn_type
*init_fn
;
186 struct gdb_reader_funcs
*funcs
= NULL
;
189 fprintf_unfiltered (gdb_stdlog
, _("Opening shared object %s.\n"),
191 gdb_dlhandle_up so
= gdb_dlopen (file_name
);
193 init_fn
= (reader_init_fn_type
*) gdb_dlsym (so
, reader_init_fn_sym
);
195 error (_("Could not locate initialization function: %s."),
198 if (gdb_dlsym (so
, "plugin_is_GPL_compatible") == NULL
)
199 error (_("Reader not GPL compatible."));
202 if (funcs
->reader_version
!= GDB_READER_INTERFACE_VERSION
)
203 error (_("Reader version does not match GDB version."));
205 return new jit_reader (funcs
, std::move (so
));
208 /* Provides the jit-reader-load command. */
211 jit_reader_load_command (const char *args
, int from_tty
)
214 error (_("No reader name provided."));
215 gdb::unique_xmalloc_ptr
<char> file (tilde_expand (args
));
217 if (loaded_jit_reader
!= NULL
)
218 error (_("JIT reader already loaded. Run jit-reader-unload first."));
220 if (!IS_ABSOLUTE_PATH (file
.get ()))
221 file
.reset (xstrprintf ("%s%s%s", jit_reader_dir
.c_str (), SLASH_STRING
,
224 loaded_jit_reader
= jit_reader_load (file
.get ());
225 reinit_frame_cache ();
226 jit_inferior_created_hook ();
229 /* Provides the jit-reader-unload command. */
232 jit_reader_unload_command (const char *args
, int from_tty
)
234 if (!loaded_jit_reader
)
235 error (_("No JIT reader loaded."));
237 reinit_frame_cache ();
238 jit_inferior_exit_hook (current_inferior ());
240 delete loaded_jit_reader
;
241 loaded_jit_reader
= NULL
;
244 /* Per-program space structure recording which objfile has the JIT
247 struct jit_program_space_data
249 /* The objfile. This is NULL if no objfile holds the JIT
252 struct objfile
*objfile
= nullptr;
254 /* If this program space has __jit_debug_register_code, this is the
255 cached address from the minimal symbol. This is used to detect
256 relocations requiring the breakpoint to be re-created. */
258 CORE_ADDR cached_code_address
= 0;
260 /* This is the JIT event breakpoint, or NULL if it has not been
263 struct breakpoint
*jit_breakpoint
= nullptr;
266 static program_space_key
<jit_program_space_data
> jit_program_space_key
;
268 /* Per-objfile structure recording the addresses in the program space.
269 This object serves two purposes: for ordinary objfiles, it may
270 cache some symbols related to the JIT interface; and for
271 JIT-created objfiles, it holds some information about the
274 struct jit_objfile_data
276 /* Symbol for __jit_debug_register_code. */
277 struct minimal_symbol
*register_code
;
279 /* Symbol for __jit_debug_descriptor. */
280 struct minimal_symbol
*descriptor
;
282 /* Address of struct jit_code_entry in this objfile. This is only
283 non-zero for objfiles that represent code created by the JIT. */
287 /* Fetch the jit_objfile_data associated with OBJF. If no data exists
288 yet, make a new structure and attach it. */
290 static struct jit_objfile_data
*
291 get_jit_objfile_data (struct objfile
*objf
)
293 struct jit_objfile_data
*objf_data
;
295 objf_data
= (struct jit_objfile_data
*) objfile_data (objf
, jit_objfile_data
);
296 if (objf_data
== NULL
)
298 objf_data
= XCNEW (struct jit_objfile_data
);
299 set_objfile_data (objf
, jit_objfile_data
, objf_data
);
305 /* Remember OBJFILE has been created for struct jit_code_entry located
306 at inferior address ENTRY. */
309 add_objfile_entry (struct objfile
*objfile
, CORE_ADDR entry
)
311 struct jit_objfile_data
*objf_data
;
313 objf_data
= get_jit_objfile_data (objfile
);
314 objf_data
->addr
= entry
;
317 /* Return jit_program_space_data for current program space. Allocate
318 if not already present. */
320 static struct jit_program_space_data
*
321 get_jit_program_space_data ()
323 struct jit_program_space_data
*ps_data
;
325 ps_data
= jit_program_space_key
.get (current_program_space
);
327 ps_data
= jit_program_space_key
.emplace (current_program_space
);
331 /* Helper function for reading the global JIT descriptor from remote
332 memory. Returns 1 if all went well, 0 otherwise. */
335 jit_read_descriptor (struct gdbarch
*gdbarch
,
336 struct jit_descriptor
*descriptor
,
337 struct jit_program_space_data
*ps_data
)
340 struct type
*ptr_type
;
344 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
345 struct jit_objfile_data
*objf_data
;
347 if (ps_data
->objfile
== NULL
)
349 objf_data
= get_jit_objfile_data (ps_data
->objfile
);
350 if (objf_data
->descriptor
== NULL
)
354 fprintf_unfiltered (gdb_stdlog
,
355 "jit_read_descriptor, descriptor_addr = %s\n",
356 paddress (gdbarch
, MSYMBOL_VALUE_ADDRESS (ps_data
->objfile
,
357 objf_data
->descriptor
)));
359 /* Figure out how big the descriptor is on the remote and how to read it. */
360 ptr_type
= builtin_type (gdbarch
)->builtin_data_ptr
;
361 ptr_size
= TYPE_LENGTH (ptr_type
);
362 desc_size
= 8 + 2 * ptr_size
; /* Two 32-bit ints and two pointers. */
363 desc_buf
= (gdb_byte
*) alloca (desc_size
);
365 /* Read the descriptor. */
366 err
= target_read_memory (MSYMBOL_VALUE_ADDRESS (ps_data
->objfile
,
367 objf_data
->descriptor
),
368 desc_buf
, desc_size
);
371 printf_unfiltered (_("Unable to read JIT descriptor from "
376 /* Fix the endianness to match the host. */
377 descriptor
->version
= extract_unsigned_integer (&desc_buf
[0], 4, byte_order
);
378 descriptor
->action_flag
=
379 extract_unsigned_integer (&desc_buf
[4], 4, byte_order
);
380 descriptor
->relevant_entry
= extract_typed_address (&desc_buf
[8], ptr_type
);
381 descriptor
->first_entry
=
382 extract_typed_address (&desc_buf
[8 + ptr_size
], ptr_type
);
387 /* Helper function for reading a JITed code entry from remote memory. */
390 jit_read_code_entry (struct gdbarch
*gdbarch
,
391 CORE_ADDR code_addr
, struct jit_code_entry
*code_entry
)
394 struct type
*ptr_type
;
399 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
401 /* Figure out how big the entry is on the remote and how to read it. */
402 ptr_type
= builtin_type (gdbarch
)->builtin_data_ptr
;
403 ptr_size
= TYPE_LENGTH (ptr_type
);
405 /* Figure out where the uint64_t value will be. */
406 align_bytes
= type_align (builtin_type (gdbarch
)->builtin_uint64
);
408 off
= (off
+ (align_bytes
- 1)) & ~(align_bytes
- 1);
410 entry_size
= off
+ 8; /* Three pointers and one 64-bit int. */
411 entry_buf
= (gdb_byte
*) alloca (entry_size
);
413 /* Read the entry. */
414 err
= target_read_memory (code_addr
, entry_buf
, entry_size
);
416 error (_("Unable to read JIT code entry from remote memory!"));
418 /* Fix the endianness to match the host. */
419 ptr_type
= builtin_type (gdbarch
)->builtin_data_ptr
;
420 code_entry
->next_entry
= extract_typed_address (&entry_buf
[0], ptr_type
);
421 code_entry
->prev_entry
=
422 extract_typed_address (&entry_buf
[ptr_size
], ptr_type
);
423 code_entry
->symfile_addr
=
424 extract_typed_address (&entry_buf
[2 * ptr_size
], ptr_type
);
425 code_entry
->symfile_size
=
426 extract_unsigned_integer (&entry_buf
[off
], 8, byte_order
);
429 /* Proxy object for building a block. */
433 gdb_block (gdb_block
*parent
, CORE_ADDR begin
, CORE_ADDR end
,
438 name (name
!= nullptr ? xstrdup (name
) : nullptr)
441 /* The parent of this block. */
442 struct gdb_block
*parent
;
444 /* Points to the "real" block that is being built out of this
445 instance. This block will be added to a blockvector, which will
446 then be added to a symtab. */
447 struct block
*real_block
= nullptr;
449 /* The first and last code address corresponding to this block. */
450 CORE_ADDR begin
, end
;
452 /* The name of this block (if any). If this is non-NULL, the
453 FUNCTION symbol symbol is set to this value. */
454 gdb::unique_xmalloc_ptr
<char> name
;
457 /* Proxy object for building a symtab. */
461 explicit gdb_symtab (const char *file_name
)
462 : file_name (file_name
!= nullptr ? file_name
: "")
465 /* The list of blocks in this symtab. These will eventually be
466 converted to real blocks.
468 This is specifically a linked list, instead of, for example, a vector,
469 because the pointers are returned to the user's debug info reader. So
470 it's important that the objects don't change location during their
471 lifetime (which would happen with a vector of objects getting resized). */
472 std::forward_list
<gdb_block
> blocks
;
474 /* The number of blocks inserted. */
477 /* A mapping between line numbers to PC. */
478 gdb::unique_xmalloc_ptr
<struct linetable
> linetable
;
480 /* The source file for this symtab. */
481 std::string file_name
;
484 /* Proxy object for building an object. */
488 /* Symtabs of this object.
490 This is specifically a linked list, instead of, for example, a vector,
491 because the pointers are returned to the user's debug info reader. So
492 it's important that the objects don't change location during their
493 lifetime (which would happen with a vector of objects getting resized). */
494 std::forward_list
<gdb_symtab
> symtabs
;
497 /* The type of the `private' data passed around by the callback
500 typedef CORE_ADDR jit_dbg_reader_data
;
502 /* The reader calls into this function to read data off the targets
505 static enum gdb_status
506 jit_target_read_impl (GDB_CORE_ADDR target_mem
, void *gdb_buf
, int len
)
508 int result
= target_read_memory ((CORE_ADDR
) target_mem
,
509 (gdb_byte
*) gdb_buf
, len
);
516 /* The reader calls into this function to create a new gdb_object
517 which it can then pass around to the other callbacks. Right now,
518 all that is required is allocating the memory. */
520 static struct gdb_object
*
521 jit_object_open_impl (struct gdb_symbol_callbacks
*cb
)
523 /* CB is not required right now, but sometime in the future we might
524 need a handle to it, and we'd like to do that without breaking
526 return new gdb_object
;
529 /* Readers call into this function to open a new gdb_symtab, which,
530 again, is passed around to other callbacks. */
532 static struct gdb_symtab
*
533 jit_symtab_open_impl (struct gdb_symbol_callbacks
*cb
,
534 struct gdb_object
*object
,
535 const char *file_name
)
537 /* CB stays unused. See comment in jit_object_open_impl. */
539 object
->symtabs
.emplace_front (file_name
);
540 return &object
->symtabs
.front ();
543 /* Called by readers to open a new gdb_block. This function also
544 inserts the new gdb_block in the correct place in the corresponding
547 static struct gdb_block
*
548 jit_block_open_impl (struct gdb_symbol_callbacks
*cb
,
549 struct gdb_symtab
*symtab
, struct gdb_block
*parent
,
550 GDB_CORE_ADDR begin
, GDB_CORE_ADDR end
, const char *name
)
552 /* Place the block at the beginning of the list, it will be sorted when the
553 symtab is finalized. */
554 symtab
->blocks
.emplace_front (parent
, begin
, end
, name
);
557 return &symtab
->blocks
.front ();
560 /* Readers call this to add a line mapping (from PC to line number) to
564 jit_symtab_line_mapping_add_impl (struct gdb_symbol_callbacks
*cb
,
565 struct gdb_symtab
*stab
, int nlines
,
566 struct gdb_line_mapping
*map
)
574 alloc_len
= sizeof (struct linetable
)
575 + (nlines
- 1) * sizeof (struct linetable_entry
);
576 stab
->linetable
.reset (XNEWVAR (struct linetable
, alloc_len
));
577 stab
->linetable
->nitems
= nlines
;
578 for (i
= 0; i
< nlines
; i
++)
580 stab
->linetable
->item
[i
].pc
= (CORE_ADDR
) map
[i
].pc
;
581 stab
->linetable
->item
[i
].line
= map
[i
].line
;
582 stab
->linetable
->item
[i
].is_stmt
= 1;
586 /* Called by readers to close a gdb_symtab. Does not need to do
587 anything as of now. */
590 jit_symtab_close_impl (struct gdb_symbol_callbacks
*cb
,
591 struct gdb_symtab
*stab
)
593 /* Right now nothing needs to be done here. We may need to do some
594 cleanup here in the future (again, without breaking the plugin
598 /* Transform STAB to a proper symtab, and add it it OBJFILE. */
601 finalize_symtab (struct gdb_symtab
*stab
, struct objfile
*objfile
)
603 struct compunit_symtab
*cust
;
604 size_t blockvector_size
;
605 CORE_ADDR begin
, end
;
606 struct blockvector
*bv
;
608 int actual_nblocks
= FIRST_LOCAL_BLOCK
+ stab
->nblocks
;
610 /* Sort the blocks in the order they should appear in the blockvector. */
611 stab
->blocks
.sort([] (const gdb_block
&a
, const gdb_block
&b
)
613 if (a
.begin
!= b
.begin
)
614 return a
.begin
< b
.begin
;
616 return a
.end
> b
.end
;
619 cust
= allocate_compunit_symtab (objfile
, stab
->file_name
.c_str ());
620 allocate_symtab (cust
, stab
->file_name
.c_str ());
621 add_compunit_symtab_to_objfile (cust
);
623 /* JIT compilers compile in memory. */
624 COMPUNIT_DIRNAME (cust
) = NULL
;
626 /* Copy over the linetable entry if one was provided. */
629 size_t size
= ((stab
->linetable
->nitems
- 1)
630 * sizeof (struct linetable_entry
)
631 + sizeof (struct linetable
));
632 SYMTAB_LINETABLE (COMPUNIT_FILETABS (cust
))
633 = (struct linetable
*) obstack_alloc (&objfile
->objfile_obstack
, size
);
634 memcpy (SYMTAB_LINETABLE (COMPUNIT_FILETABS (cust
)),
635 stab
->linetable
.get (), size
);
638 blockvector_size
= (sizeof (struct blockvector
)
639 + (actual_nblocks
- 1) * sizeof (struct block
*));
640 bv
= (struct blockvector
*) obstack_alloc (&objfile
->objfile_obstack
,
642 COMPUNIT_BLOCKVECTOR (cust
) = bv
;
644 /* At the end of this function, (begin, end) will contain the PC range this
645 entire blockvector spans. */
646 BLOCKVECTOR_MAP (bv
) = NULL
;
647 begin
= stab
->blocks
.front ().begin
;
648 end
= stab
->blocks
.front ().end
;
649 BLOCKVECTOR_NBLOCKS (bv
) = actual_nblocks
;
651 /* First run over all the gdb_block objects, creating a real block
652 object for each. Simultaneously, keep setting the real_block
654 int block_idx
= FIRST_LOCAL_BLOCK
;
655 for (gdb_block
&gdb_block_iter
: stab
->blocks
)
657 struct block
*new_block
= allocate_block (&objfile
->objfile_obstack
);
658 struct symbol
*block_name
= new (&objfile
->objfile_obstack
) symbol
;
659 struct type
*block_type
= arch_type (objfile
->arch (),
664 BLOCK_MULTIDICT (new_block
)
665 = mdict_create_linear (&objfile
->objfile_obstack
, NULL
);
666 /* The address range. */
667 BLOCK_START (new_block
) = (CORE_ADDR
) gdb_block_iter
.begin
;
668 BLOCK_END (new_block
) = (CORE_ADDR
) gdb_block_iter
.end
;
671 SYMBOL_DOMAIN (block_name
) = VAR_DOMAIN
;
672 SYMBOL_ACLASS_INDEX (block_name
) = LOC_BLOCK
;
673 symbol_set_symtab (block_name
, COMPUNIT_FILETABS (cust
));
674 SYMBOL_TYPE (block_name
) = lookup_function_type (block_type
);
675 SYMBOL_BLOCK_VALUE (block_name
) = new_block
;
677 block_name
->m_name
= obstack_strdup (&objfile
->objfile_obstack
,
678 gdb_block_iter
.name
.get ());
680 BLOCK_FUNCTION (new_block
) = block_name
;
682 BLOCKVECTOR_BLOCK (bv
, block_idx
) = new_block
;
683 if (begin
> BLOCK_START (new_block
))
684 begin
= BLOCK_START (new_block
);
685 if (end
< BLOCK_END (new_block
))
686 end
= BLOCK_END (new_block
);
688 gdb_block_iter
.real_block
= new_block
;
693 /* Now add the special blocks. */
694 struct block
*block_iter
= NULL
;
695 for (enum block_enum i
: { GLOBAL_BLOCK
, STATIC_BLOCK
})
697 struct block
*new_block
;
699 new_block
= (i
== GLOBAL_BLOCK
700 ? allocate_global_block (&objfile
->objfile_obstack
)
701 : allocate_block (&objfile
->objfile_obstack
));
702 BLOCK_MULTIDICT (new_block
)
703 = mdict_create_linear (&objfile
->objfile_obstack
, NULL
);
704 BLOCK_SUPERBLOCK (new_block
) = block_iter
;
705 block_iter
= new_block
;
707 BLOCK_START (new_block
) = (CORE_ADDR
) begin
;
708 BLOCK_END (new_block
) = (CORE_ADDR
) end
;
710 BLOCKVECTOR_BLOCK (bv
, i
) = new_block
;
712 if (i
== GLOBAL_BLOCK
)
713 set_block_compunit_symtab (new_block
, cust
);
716 /* Fill up the superblock fields for the real blocks, using the
717 real_block fields populated earlier. */
718 for (gdb_block
&gdb_block_iter
: stab
->blocks
)
720 if (gdb_block_iter
.parent
!= NULL
)
722 /* If the plugin specifically mentioned a parent block, we
724 BLOCK_SUPERBLOCK (gdb_block_iter
.real_block
) =
725 gdb_block_iter
.parent
->real_block
;
729 /* And if not, we set a default parent block. */
730 BLOCK_SUPERBLOCK (gdb_block_iter
.real_block
) =
731 BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
);
736 /* Called when closing a gdb_objfile. Converts OBJ to a proper
740 jit_object_close_impl (struct gdb_symbol_callbacks
*cb
,
741 struct gdb_object
*obj
)
743 struct objfile
*objfile
;
744 jit_dbg_reader_data
*priv_data
;
746 priv_data
= (jit_dbg_reader_data
*) cb
->priv_data
;
748 objfile
= objfile::make (nullptr, "<< JIT compiled code >>",
750 objfile
->per_bfd
->gdbarch
= target_gdbarch ();
752 for (gdb_symtab
&symtab
: obj
->symtabs
)
753 finalize_symtab (&symtab
, objfile
);
755 add_objfile_entry (objfile
, *priv_data
);
760 /* Try to read CODE_ENTRY using the loaded jit reader (if any).
761 ENTRY_ADDR is the address of the struct jit_code_entry in the
762 inferior address space. */
765 jit_reader_try_read_symtab (struct jit_code_entry
*code_entry
,
766 CORE_ADDR entry_addr
)
769 jit_dbg_reader_data priv_data
;
770 struct gdb_reader_funcs
*funcs
;
771 struct gdb_symbol_callbacks callbacks
=
773 jit_object_open_impl
,
774 jit_symtab_open_impl
,
776 jit_symtab_close_impl
,
777 jit_object_close_impl
,
779 jit_symtab_line_mapping_add_impl
,
780 jit_target_read_impl
,
785 priv_data
= entry_addr
;
787 if (!loaded_jit_reader
)
790 gdb::byte_vector
gdb_mem (code_entry
->symfile_size
);
795 if (target_read_memory (code_entry
->symfile_addr
, gdb_mem
.data (),
796 code_entry
->symfile_size
))
799 catch (const gdb_exception
&e
)
806 funcs
= loaded_jit_reader
->functions
;
807 if (funcs
->read (funcs
, &callbacks
, gdb_mem
.data (),
808 code_entry
->symfile_size
)
813 if (jit_debug
&& status
== 0)
814 fprintf_unfiltered (gdb_stdlog
,
815 "Could not read symtab using the loaded JIT reader.\n");
819 /* Try to read CODE_ENTRY using BFD. ENTRY_ADDR is the address of the
820 struct jit_code_entry in the inferior address space. */
823 jit_bfd_try_read_symtab (struct jit_code_entry
*code_entry
,
824 CORE_ADDR entry_addr
,
825 struct gdbarch
*gdbarch
)
827 struct bfd_section
*sec
;
828 struct objfile
*objfile
;
829 const struct bfd_arch_info
*b
;
832 fprintf_unfiltered (gdb_stdlog
,
833 "jit_bfd_try_read_symtab, symfile_addr = %s, "
834 "symfile_size = %s\n",
835 paddress (gdbarch
, code_entry
->symfile_addr
),
836 pulongest (code_entry
->symfile_size
));
838 gdb_bfd_ref_ptr
nbfd (bfd_open_from_target_memory (code_entry
->symfile_addr
,
839 code_entry
->symfile_size
,
843 puts_unfiltered (_("Error opening JITed symbol file, ignoring it.\n"));
847 /* Check the format. NOTE: This initializes important data that GDB uses!
848 We would segfault later without this line. */
849 if (!bfd_check_format (nbfd
.get (), bfd_object
))
851 printf_unfiltered (_("\
852 JITed symbol file is not an object file, ignoring it.\n"));
856 /* Check bfd arch. */
857 b
= gdbarch_bfd_arch_info (gdbarch
);
858 if (b
->compatible (b
, bfd_get_arch_info (nbfd
.get ())) != b
)
859 warning (_("JITed object file architecture %s is not compatible "
860 "with target architecture %s."),
861 bfd_get_arch_info (nbfd
.get ())->printable_name
,
864 /* Read the section address information out of the symbol file. Since the
865 file is generated by the JIT at runtime, it should all of the absolute
866 addresses that we care about. */
867 section_addr_info sai
;
868 for (sec
= nbfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
869 if ((bfd_section_flags (sec
) & (SEC_ALLOC
|SEC_LOAD
)) != 0)
871 /* We assume that these virtual addresses are absolute, and do not
872 treat them as offsets. */
873 sai
.emplace_back (bfd_section_vma (sec
),
874 bfd_section_name (sec
),
878 /* This call does not take ownership of SAI. */
879 objfile
= symbol_file_add_from_bfd (nbfd
.get (),
880 bfd_get_filename (nbfd
.get ()), 0,
882 OBJF_SHARED
| OBJF_NOT_FILENAME
, NULL
);
884 add_objfile_entry (objfile
, entry_addr
);
887 /* This function registers code associated with a JIT code entry. It uses the
888 pointer and size pair in the entry to read the symbol file from the remote
889 and then calls symbol_file_add_from_local_memory to add it as though it were
890 a symbol file added by the user. */
893 jit_register_code (struct gdbarch
*gdbarch
,
894 CORE_ADDR entry_addr
, struct jit_code_entry
*code_entry
)
899 fprintf_unfiltered (gdb_stdlog
,
900 "jit_register_code, symfile_addr = %s, "
901 "symfile_size = %s\n",
902 paddress (gdbarch
, code_entry
->symfile_addr
),
903 pulongest (code_entry
->symfile_size
));
905 success
= jit_reader_try_read_symtab (code_entry
, entry_addr
);
908 jit_bfd_try_read_symtab (code_entry
, entry_addr
, gdbarch
);
911 /* Look up the objfile with this code entry address. */
913 static struct objfile
*
914 jit_find_objf_with_entry_addr (CORE_ADDR entry_addr
)
916 for (objfile
*objf
: current_program_space
->objfiles ())
918 struct jit_objfile_data
*objf_data
;
921 = (struct jit_objfile_data
*) objfile_data (objf
, jit_objfile_data
);
922 if (objf_data
!= NULL
&& objf_data
->addr
== entry_addr
)
928 /* This is called when a breakpoint is deleted. It updates the
929 inferior's cache, if needed. */
932 jit_breakpoint_deleted (struct breakpoint
*b
)
934 struct bp_location
*iter
;
936 if (b
->type
!= bp_jit_event
)
939 for (iter
= b
->loc
; iter
!= NULL
; iter
= iter
->next
)
941 struct jit_program_space_data
*ps_data
;
943 ps_data
= jit_program_space_key
.get (iter
->pspace
);
944 if (ps_data
!= NULL
&& ps_data
->jit_breakpoint
== iter
->owner
)
946 ps_data
->cached_code_address
= 0;
947 ps_data
->jit_breakpoint
= NULL
;
952 /* (Re-)Initialize the jit breakpoint if necessary.
953 Return 0 if the jit breakpoint has been successfully initialized. */
956 jit_breakpoint_re_set_internal (struct gdbarch
*gdbarch
,
957 struct jit_program_space_data
*ps_data
)
959 struct bound_minimal_symbol reg_symbol
;
960 struct bound_minimal_symbol desc_symbol
;
961 struct jit_objfile_data
*objf_data
;
964 if (ps_data
->objfile
== NULL
)
966 /* Lookup the registration symbol. If it is missing, then we
967 assume we are not attached to a JIT. */
968 reg_symbol
= lookup_bound_minimal_symbol (jit_break_name
);
969 if (reg_symbol
.minsym
== NULL
970 || BMSYMBOL_VALUE_ADDRESS (reg_symbol
) == 0)
973 desc_symbol
= lookup_minimal_symbol (jit_descriptor_name
, NULL
,
975 if (desc_symbol
.minsym
== NULL
976 || BMSYMBOL_VALUE_ADDRESS (desc_symbol
) == 0)
979 objf_data
= get_jit_objfile_data (reg_symbol
.objfile
);
980 objf_data
->register_code
= reg_symbol
.minsym
;
981 objf_data
->descriptor
= desc_symbol
.minsym
;
983 ps_data
->objfile
= reg_symbol
.objfile
;
986 objf_data
= get_jit_objfile_data (ps_data
->objfile
);
988 addr
= MSYMBOL_VALUE_ADDRESS (ps_data
->objfile
, objf_data
->register_code
);
991 fprintf_unfiltered (gdb_stdlog
,
992 "jit_breakpoint_re_set_internal, "
993 "breakpoint_addr = %s\n",
994 paddress (gdbarch
, addr
));
996 if (ps_data
->cached_code_address
== addr
)
999 /* Delete the old breakpoint. */
1000 if (ps_data
->jit_breakpoint
!= NULL
)
1001 delete_breakpoint (ps_data
->jit_breakpoint
);
1003 /* Put a breakpoint in the registration symbol. */
1004 ps_data
->cached_code_address
= addr
;
1005 ps_data
->jit_breakpoint
= create_jit_event_breakpoint (gdbarch
, addr
);
1010 /* The private data passed around in the frame unwind callback
1013 struct jit_unwind_private
1015 /* Cached register values. See jit_frame_sniffer to see how this
1017 detached_regcache
*regcache
;
1019 /* The frame being unwound. */
1020 struct frame_info
*this_frame
;
1023 /* Sets the value of a particular register in this frame. */
1026 jit_unwind_reg_set_impl (struct gdb_unwind_callbacks
*cb
, int dwarf_regnum
,
1027 struct gdb_reg_value
*value
)
1029 struct jit_unwind_private
*priv
;
1032 priv
= (struct jit_unwind_private
*) cb
->priv_data
;
1034 gdb_reg
= gdbarch_dwarf2_reg_to_regnum (get_frame_arch (priv
->this_frame
),
1039 fprintf_unfiltered (gdb_stdlog
,
1040 _("Could not recognize DWARF regnum %d"),
1042 value
->free (value
);
1046 priv
->regcache
->raw_supply (gdb_reg
, value
->value
);
1047 value
->free (value
);
1051 reg_value_free_impl (struct gdb_reg_value
*value
)
1056 /* Get the value of register REGNUM in the previous frame. */
1058 static struct gdb_reg_value
*
1059 jit_unwind_reg_get_impl (struct gdb_unwind_callbacks
*cb
, int regnum
)
1061 struct jit_unwind_private
*priv
;
1062 struct gdb_reg_value
*value
;
1064 struct gdbarch
*frame_arch
;
1066 priv
= (struct jit_unwind_private
*) cb
->priv_data
;
1067 frame_arch
= get_frame_arch (priv
->this_frame
);
1069 gdb_reg
= gdbarch_dwarf2_reg_to_regnum (frame_arch
, regnum
);
1070 size
= register_size (frame_arch
, gdb_reg
);
1071 value
= ((struct gdb_reg_value
*)
1072 xmalloc (sizeof (struct gdb_reg_value
) + size
- 1));
1073 value
->defined
= deprecated_frame_register_read (priv
->this_frame
, gdb_reg
,
1076 value
->free
= reg_value_free_impl
;
1080 /* gdb_reg_value has a free function, which must be called on each
1081 saved register value. */
1084 jit_dealloc_cache (struct frame_info
*this_frame
, void *cache
)
1086 struct jit_unwind_private
*priv_data
= (struct jit_unwind_private
*) cache
;
1088 gdb_assert (priv_data
->regcache
!= NULL
);
1089 delete priv_data
->regcache
;
1093 /* The frame sniffer for the pseudo unwinder.
1095 While this is nominally a frame sniffer, in the case where the JIT
1096 reader actually recognizes the frame, it does a lot more work -- it
1097 unwinds the frame and saves the corresponding register values in
1098 the cache. jit_frame_prev_register simply returns the saved
1102 jit_frame_sniffer (const struct frame_unwind
*self
,
1103 struct frame_info
*this_frame
, void **cache
)
1105 struct jit_unwind_private
*priv_data
;
1106 struct gdb_unwind_callbacks callbacks
;
1107 struct gdb_reader_funcs
*funcs
;
1109 callbacks
.reg_get
= jit_unwind_reg_get_impl
;
1110 callbacks
.reg_set
= jit_unwind_reg_set_impl
;
1111 callbacks
.target_read
= jit_target_read_impl
;
1113 if (loaded_jit_reader
== NULL
)
1116 funcs
= loaded_jit_reader
->functions
;
1118 gdb_assert (!*cache
);
1120 *cache
= XCNEW (struct jit_unwind_private
);
1121 priv_data
= (struct jit_unwind_private
*) *cache
;
1122 /* Take a snapshot of current regcache. */
1123 priv_data
->regcache
= new detached_regcache (get_frame_arch (this_frame
),
1125 priv_data
->this_frame
= this_frame
;
1127 callbacks
.priv_data
= priv_data
;
1129 /* Try to coax the provided unwinder to unwind the stack */
1130 if (funcs
->unwind (funcs
, &callbacks
) == GDB_SUCCESS
)
1133 fprintf_unfiltered (gdb_stdlog
, _("Successfully unwound frame using "
1138 fprintf_unfiltered (gdb_stdlog
, _("Could not unwind frame using "
1141 jit_dealloc_cache (this_frame
, *cache
);
1148 /* The frame_id function for the pseudo unwinder. Relays the call to
1149 the loaded plugin. */
1152 jit_frame_this_id (struct frame_info
*this_frame
, void **cache
,
1153 struct frame_id
*this_id
)
1155 struct jit_unwind_private priv
;
1156 struct gdb_frame_id frame_id
;
1157 struct gdb_reader_funcs
*funcs
;
1158 struct gdb_unwind_callbacks callbacks
;
1160 priv
.regcache
= NULL
;
1161 priv
.this_frame
= this_frame
;
1163 /* We don't expect the frame_id function to set any registers, so we
1164 set reg_set to NULL. */
1165 callbacks
.reg_get
= jit_unwind_reg_get_impl
;
1166 callbacks
.reg_set
= NULL
;
1167 callbacks
.target_read
= jit_target_read_impl
;
1168 callbacks
.priv_data
= &priv
;
1170 gdb_assert (loaded_jit_reader
);
1171 funcs
= loaded_jit_reader
->functions
;
1173 frame_id
= funcs
->get_frame_id (funcs
, &callbacks
);
1174 *this_id
= frame_id_build (frame_id
.stack_address
, frame_id
.code_address
);
1177 /* Pseudo unwinder function. Reads the previously fetched value for
1178 the register from the cache. */
1180 static struct value
*
1181 jit_frame_prev_register (struct frame_info
*this_frame
, void **cache
, int reg
)
1183 struct jit_unwind_private
*priv
= (struct jit_unwind_private
*) *cache
;
1184 struct gdbarch
*gdbarch
;
1187 return frame_unwind_got_optimized (this_frame
, reg
);
1189 gdbarch
= priv
->regcache
->arch ();
1190 gdb_byte
*buf
= (gdb_byte
*) alloca (register_size (gdbarch
, reg
));
1191 enum register_status status
= priv
->regcache
->cooked_read (reg
, buf
);
1193 if (status
== REG_VALID
)
1194 return frame_unwind_got_bytes (this_frame
, reg
, buf
);
1196 return frame_unwind_got_optimized (this_frame
, reg
);
1199 /* Relay everything back to the unwinder registered by the JIT debug
1202 static const struct frame_unwind jit_frame_unwind
=
1205 default_frame_unwind_stop_reason
,
1207 jit_frame_prev_register
,
1214 /* This is the information that is stored at jit_gdbarch_data for each
1217 struct jit_gdbarch_data_type
1219 /* Has the (pseudo) unwinder been prepended? */
1220 int unwinder_registered
;
1223 /* Check GDBARCH and prepend the pseudo JIT unwinder if needed. */
1226 jit_prepend_unwinder (struct gdbarch
*gdbarch
)
1228 struct jit_gdbarch_data_type
*data
;
1231 = (struct jit_gdbarch_data_type
*) gdbarch_data (gdbarch
, jit_gdbarch_data
);
1232 if (!data
->unwinder_registered
)
1234 frame_unwind_prepend_unwinder (gdbarch
, &jit_frame_unwind
);
1235 data
->unwinder_registered
= 1;
1239 /* Register any already created translations. */
1242 jit_inferior_init (struct gdbarch
*gdbarch
)
1244 struct jit_descriptor descriptor
;
1245 struct jit_code_entry cur_entry
;
1246 struct jit_program_space_data
*ps_data
;
1247 CORE_ADDR cur_entry_addr
;
1250 fprintf_unfiltered (gdb_stdlog
, "jit_inferior_init\n");
1252 jit_prepend_unwinder (gdbarch
);
1254 ps_data
= get_jit_program_space_data ();
1255 if (jit_breakpoint_re_set_internal (gdbarch
, ps_data
) != 0)
1258 /* Read the descriptor so we can check the version number and load
1259 any already JITed functions. */
1260 if (!jit_read_descriptor (gdbarch
, &descriptor
, ps_data
))
1263 /* Check that the version number agrees with that we support. */
1264 if (descriptor
.version
!= 1)
1266 printf_unfiltered (_("Unsupported JIT protocol version %ld "
1267 "in descriptor (expected 1)\n"),
1268 (long) descriptor
.version
);
1272 /* If we've attached to a running program, we need to check the descriptor
1273 to register any functions that were already generated. */
1274 for (cur_entry_addr
= descriptor
.first_entry
;
1275 cur_entry_addr
!= 0;
1276 cur_entry_addr
= cur_entry
.next_entry
)
1278 jit_read_code_entry (gdbarch
, cur_entry_addr
, &cur_entry
);
1280 /* This hook may be called many times during setup, so make sure we don't
1281 add the same symbol file twice. */
1282 if (jit_find_objf_with_entry_addr (cur_entry_addr
) != NULL
)
1285 jit_register_code (gdbarch
, cur_entry_addr
, &cur_entry
);
1289 /* inferior_created observer. */
1292 jit_inferior_created (struct target_ops
*ops
, int from_tty
)
1294 jit_inferior_created_hook ();
1297 /* Exported routine to call when an inferior has been created. */
1300 jit_inferior_created_hook (void)
1302 jit_inferior_init (target_gdbarch ());
1305 /* Exported routine to call to re-set the jit breakpoints,
1306 e.g. when a program is rerun. */
1309 jit_breakpoint_re_set (void)
1311 jit_breakpoint_re_set_internal (target_gdbarch (),
1312 get_jit_program_space_data ());
1315 /* This function cleans up any code entries left over when the
1316 inferior exits. We get left over code when the inferior exits
1317 without unregistering its code, for example when it crashes. */
1320 jit_inferior_exit_hook (struct inferior
*inf
)
1322 for (objfile
*objf
: current_program_space
->objfiles_safe ())
1324 struct jit_objfile_data
*objf_data
1325 = (struct jit_objfile_data
*) objfile_data (objf
, jit_objfile_data
);
1327 if (objf_data
!= NULL
&& objf_data
->addr
!= 0)
1333 jit_event_handler (struct gdbarch
*gdbarch
)
1335 struct jit_descriptor descriptor
;
1336 struct jit_code_entry code_entry
;
1337 CORE_ADDR entry_addr
;
1338 struct objfile
*objf
;
1340 /* Read the descriptor from remote memory. */
1341 if (!jit_read_descriptor (gdbarch
, &descriptor
,
1342 get_jit_program_space_data ()))
1344 entry_addr
= descriptor
.relevant_entry
;
1346 /* Do the corresponding action. */
1347 switch (descriptor
.action_flag
)
1352 jit_read_code_entry (gdbarch
, entry_addr
, &code_entry
);
1353 jit_register_code (gdbarch
, entry_addr
, &code_entry
);
1355 case JIT_UNREGISTER
:
1356 objf
= jit_find_objf_with_entry_addr (entry_addr
);
1358 printf_unfiltered (_("Unable to find JITed code "
1359 "entry at address: %s\n"),
1360 paddress (gdbarch
, entry_addr
));
1366 error (_("Unknown action_flag value in JIT descriptor!"));
1371 /* Called to free the data allocated to the jit_program_space_data slot. */
1374 free_objfile_data (struct objfile
*objfile
, void *data
)
1376 struct jit_objfile_data
*objf_data
= (struct jit_objfile_data
*) data
;
1378 if (objf_data
->register_code
!= NULL
)
1380 struct jit_program_space_data
*ps_data
;
1382 ps_data
= jit_program_space_key
.get (objfile
->pspace
);
1383 if (ps_data
!= NULL
&& ps_data
->objfile
== objfile
)
1385 ps_data
->objfile
= NULL
;
1386 if (ps_data
->jit_breakpoint
!= NULL
)
1387 delete_breakpoint (ps_data
->jit_breakpoint
);
1388 ps_data
->cached_code_address
= 0;
1395 /* Initialize the jit_gdbarch_data slot with an instance of struct
1396 jit_gdbarch_data_type */
1399 jit_gdbarch_data_init (struct obstack
*obstack
)
1401 struct jit_gdbarch_data_type
*data
=
1402 XOBNEW (obstack
, struct jit_gdbarch_data_type
);
1404 data
->unwinder_registered
= 0;
1409 void _initialize_jit ();
1413 jit_reader_dir
= relocate_gdb_directory (JIT_READER_DIR
,
1414 JIT_READER_DIR_RELOCATABLE
);
1415 add_setshow_zuinteger_cmd ("jit", class_maintenance
, &jit_debug
,
1416 _("Set JIT debugging."),
1417 _("Show JIT debugging."),
1418 _("When non-zero, JIT debugging is enabled."),
1421 &setdebuglist
, &showdebuglist
);
1423 gdb::observers::inferior_created
.attach (jit_inferior_created
);
1424 gdb::observers::inferior_exit
.attach (jit_inferior_exit_hook
);
1425 gdb::observers::breakpoint_deleted
.attach (jit_breakpoint_deleted
);
1428 register_objfile_data_with_cleanup (NULL
, free_objfile_data
);
1429 jit_gdbarch_data
= gdbarch_data_register_pre_init (jit_gdbarch_data_init
);
1430 if (is_dl_available ())
1432 struct cmd_list_element
*c
;
1434 c
= add_com ("jit-reader-load", no_class
, jit_reader_load_command
, _("\
1435 Load FILE as debug info reader and unwinder for JIT compiled code.\n\
1436 Usage: jit-reader-load FILE\n\
1437 Try to load file FILE as a debug info reader (and unwinder) for\n\
1438 JIT compiled code. The file is loaded from " JIT_READER_DIR
",\n\
1439 relocated relative to the GDB executable if required."));
1440 set_cmd_completer (c
, filename_completer
);
1442 c
= add_com ("jit-reader-unload", no_class
,
1443 jit_reader_unload_command
, _("\
1444 Unload the currently loaded JIT debug info reader.\n\
1445 Usage: jit-reader-unload\n\n\
1446 Do \"help jit-reader-load\" for info on loading debug info readers."));
1447 set_cmd_completer (c
, noop_completer
);