1 /* Handle JIT code generation in the inferior for GDB, the GNU Debugger.
3 Copyright (C) 2009-2019 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
, char *target
)
141 struct target_buffer
*buffer
= XNEW (struct target_buffer
);
145 return gdb_bfd_openr_iovec ("<in-memory>", target
,
155 jit_reader (struct gdb_reader_funcs
*f
, gdb_dlhandle_up
&&h
)
156 : functions (f
), handle (std::move (h
))
162 functions
->destroy (functions
);
165 DISABLE_COPY_AND_ASSIGN (jit_reader
);
167 struct gdb_reader_funcs
*functions
;
168 gdb_dlhandle_up handle
;
171 /* One reader that has been loaded successfully, and can potentially be used to
174 static struct jit_reader
*loaded_jit_reader
= NULL
;
176 typedef struct gdb_reader_funcs
* (reader_init_fn_type
) (void);
177 static const char *reader_init_fn_sym
= "gdb_init_reader";
179 /* Try to load FILE_NAME as a JIT debug info reader. */
181 static struct jit_reader
*
182 jit_reader_load (const char *file_name
)
184 reader_init_fn_type
*init_fn
;
185 struct gdb_reader_funcs
*funcs
= NULL
;
188 fprintf_unfiltered (gdb_stdlog
, _("Opening shared object %s.\n"),
190 gdb_dlhandle_up so
= gdb_dlopen (file_name
);
192 init_fn
= (reader_init_fn_type
*) gdb_dlsym (so
, reader_init_fn_sym
);
194 error (_("Could not locate initialization function: %s."),
197 if (gdb_dlsym (so
, "plugin_is_GPL_compatible") == NULL
)
198 error (_("Reader not GPL compatible."));
201 if (funcs
->reader_version
!= GDB_READER_INTERFACE_VERSION
)
202 error (_("Reader version does not match GDB version."));
204 return new jit_reader (funcs
, std::move (so
));
207 /* Provides the jit-reader-load command. */
210 jit_reader_load_command (const char *args
, int from_tty
)
213 error (_("No reader name provided."));
214 gdb::unique_xmalloc_ptr
<char> file (tilde_expand (args
));
216 if (loaded_jit_reader
!= NULL
)
217 error (_("JIT reader already loaded. Run jit-reader-unload first."));
219 if (!IS_ABSOLUTE_PATH (file
.get ()))
220 file
.reset (xstrprintf ("%s%s%s", jit_reader_dir
.c_str (), SLASH_STRING
,
223 loaded_jit_reader
= jit_reader_load (file
.get ());
224 reinit_frame_cache ();
225 jit_inferior_created_hook ();
228 /* Provides the jit-reader-unload command. */
231 jit_reader_unload_command (const char *args
, int from_tty
)
233 if (!loaded_jit_reader
)
234 error (_("No JIT reader loaded."));
236 reinit_frame_cache ();
237 jit_inferior_exit_hook (current_inferior ());
239 delete loaded_jit_reader
;
240 loaded_jit_reader
= NULL
;
243 /* Per-program space structure recording which objfile has the JIT
246 struct jit_program_space_data
248 /* The objfile. This is NULL if no objfile holds the JIT
251 struct objfile
*objfile
= nullptr;
253 /* If this program space has __jit_debug_register_code, this is the
254 cached address from the minimal symbol. This is used to detect
255 relocations requiring the breakpoint to be re-created. */
257 CORE_ADDR cached_code_address
= 0;
259 /* This is the JIT event breakpoint, or NULL if it has not been
262 struct breakpoint
*jit_breakpoint
= nullptr;
265 static program_space_key
<jit_program_space_data
> jit_program_space_key
;
267 /* Per-objfile structure recording the addresses in the program space.
268 This object serves two purposes: for ordinary objfiles, it may
269 cache some symbols related to the JIT interface; and for
270 JIT-created objfiles, it holds some information about the
273 struct jit_objfile_data
275 /* Symbol for __jit_debug_register_code. */
276 struct minimal_symbol
*register_code
;
278 /* Symbol for __jit_debug_descriptor. */
279 struct minimal_symbol
*descriptor
;
281 /* Address of struct jit_code_entry in this objfile. This is only
282 non-zero for objfiles that represent code created by the JIT. */
286 /* Fetch the jit_objfile_data associated with OBJF. If no data exists
287 yet, make a new structure and attach it. */
289 static struct jit_objfile_data
*
290 get_jit_objfile_data (struct objfile
*objf
)
292 struct jit_objfile_data
*objf_data
;
294 objf_data
= (struct jit_objfile_data
*) objfile_data (objf
, jit_objfile_data
);
295 if (objf_data
== NULL
)
297 objf_data
= XCNEW (struct jit_objfile_data
);
298 set_objfile_data (objf
, jit_objfile_data
, objf_data
);
304 /* Remember OBJFILE has been created for struct jit_code_entry located
305 at inferior address ENTRY. */
308 add_objfile_entry (struct objfile
*objfile
, CORE_ADDR entry
)
310 struct jit_objfile_data
*objf_data
;
312 objf_data
= get_jit_objfile_data (objfile
);
313 objf_data
->addr
= entry
;
316 /* Return jit_program_space_data for current program space. Allocate
317 if not already present. */
319 static struct jit_program_space_data
*
320 get_jit_program_space_data ()
322 struct jit_program_space_data
*ps_data
;
324 ps_data
= jit_program_space_key
.get (current_program_space
);
326 ps_data
= jit_program_space_key
.emplace (current_program_space
);
330 /* Helper function for reading the global JIT descriptor from remote
331 memory. Returns 1 if all went well, 0 otherwise. */
334 jit_read_descriptor (struct gdbarch
*gdbarch
,
335 struct jit_descriptor
*descriptor
,
336 struct jit_program_space_data
*ps_data
)
339 struct type
*ptr_type
;
343 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
344 struct jit_objfile_data
*objf_data
;
346 if (ps_data
->objfile
== NULL
)
348 objf_data
= get_jit_objfile_data (ps_data
->objfile
);
349 if (objf_data
->descriptor
== NULL
)
353 fprintf_unfiltered (gdb_stdlog
,
354 "jit_read_descriptor, descriptor_addr = %s\n",
355 paddress (gdbarch
, MSYMBOL_VALUE_ADDRESS (ps_data
->objfile
,
356 objf_data
->descriptor
)));
358 /* Figure out how big the descriptor is on the remote and how to read it. */
359 ptr_type
= builtin_type (gdbarch
)->builtin_data_ptr
;
360 ptr_size
= TYPE_LENGTH (ptr_type
);
361 desc_size
= 8 + 2 * ptr_size
; /* Two 32-bit ints and two pointers. */
362 desc_buf
= (gdb_byte
*) alloca (desc_size
);
364 /* Read the descriptor. */
365 err
= target_read_memory (MSYMBOL_VALUE_ADDRESS (ps_data
->objfile
,
366 objf_data
->descriptor
),
367 desc_buf
, desc_size
);
370 printf_unfiltered (_("Unable to read JIT descriptor from "
375 /* Fix the endianness to match the host. */
376 descriptor
->version
= extract_unsigned_integer (&desc_buf
[0], 4, byte_order
);
377 descriptor
->action_flag
=
378 extract_unsigned_integer (&desc_buf
[4], 4, byte_order
);
379 descriptor
->relevant_entry
= extract_typed_address (&desc_buf
[8], ptr_type
);
380 descriptor
->first_entry
=
381 extract_typed_address (&desc_buf
[8 + ptr_size
], ptr_type
);
386 /* Helper function for reading a JITed code entry from remote memory. */
389 jit_read_code_entry (struct gdbarch
*gdbarch
,
390 CORE_ADDR code_addr
, struct jit_code_entry
*code_entry
)
393 struct type
*ptr_type
;
398 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
400 /* Figure out how big the entry is on the remote and how to read it. */
401 ptr_type
= builtin_type (gdbarch
)->builtin_data_ptr
;
402 ptr_size
= TYPE_LENGTH (ptr_type
);
404 /* Figure out where the uint64_t value will be. */
405 align_bytes
= type_align (builtin_type (gdbarch
)->builtin_uint64
);
407 off
= (off
+ (align_bytes
- 1)) & ~(align_bytes
- 1);
409 entry_size
= off
+ 8; /* Three pointers and one 64-bit int. */
410 entry_buf
= (gdb_byte
*) alloca (entry_size
);
412 /* Read the entry. */
413 err
= target_read_memory (code_addr
, entry_buf
, entry_size
);
415 error (_("Unable to read JIT code entry from remote memory!"));
417 /* Fix the endianness to match the host. */
418 ptr_type
= builtin_type (gdbarch
)->builtin_data_ptr
;
419 code_entry
->next_entry
= extract_typed_address (&entry_buf
[0], ptr_type
);
420 code_entry
->prev_entry
=
421 extract_typed_address (&entry_buf
[ptr_size
], ptr_type
);
422 code_entry
->symfile_addr
=
423 extract_typed_address (&entry_buf
[2 * ptr_size
], ptr_type
);
424 code_entry
->symfile_size
=
425 extract_unsigned_integer (&entry_buf
[off
], 8, byte_order
);
428 /* Proxy object for building a block. */
432 gdb_block (gdb_block
*parent
, CORE_ADDR begin
, CORE_ADDR end
,
437 name (name
!= nullptr ? xstrdup (name
) : nullptr)
440 /* gdb_blocks are linked into a tree structure. Next points to the
441 next node at the same depth as this block and parent to the
443 struct gdb_block
*next
= nullptr, *parent
;
445 /* Points to the "real" block that is being built out of this
446 instance. This block will be added to a blockvector, which will
447 then be added to a symtab. */
448 struct block
*real_block
= nullptr;
450 /* The first and last code address corresponding to this block. */
451 CORE_ADDR begin
, end
;
453 /* The name of this block (if any). If this is non-NULL, the
454 FUNCTION symbol symbol is set to this value. */
455 gdb::unique_xmalloc_ptr
<char> name
;
458 /* Proxy object for building a symtab. */
462 explicit gdb_symtab (const char *file_name
)
463 : file_name (file_name
!= nullptr ? file_name
: "")
468 gdb_block
*gdb_block_iter
, *gdb_block_iter_tmp
;
470 for ((gdb_block_iter
= this->blocks
,
471 gdb_block_iter_tmp
= gdb_block_iter
->next
);
473 gdb_block_iter
= gdb_block_iter_tmp
)
475 gdb_block_iter_tmp
= gdb_block_iter
->next
;
476 delete gdb_block_iter
;
480 /* The list of blocks in this symtab. These will eventually be
481 converted to real blocks. */
482 struct gdb_block
*blocks
= nullptr;
484 /* The number of blocks inserted. */
487 /* A mapping between line numbers to PC. */
488 gdb::unique_xmalloc_ptr
<struct linetable
> linetable
;
490 /* The source file for this symtab. */
491 std::string file_name
;
494 /* Proxy object for building an object. */
498 /* Symtabs of this object.
500 This is specifically a linked list, instead of, for example, a vector,
501 because the pointers are returned to the user's debug info reader. So
502 it's important that the objects don't change location during their
503 lifetime (which would happen with a vector of objects getting resized). */
504 std::forward_list
<gdb_symtab
> symtabs
;
507 /* The type of the `private' data passed around by the callback
510 typedef CORE_ADDR jit_dbg_reader_data
;
512 /* The reader calls into this function to read data off the targets
515 static enum gdb_status
516 jit_target_read_impl (GDB_CORE_ADDR target_mem
, void *gdb_buf
, int len
)
518 int result
= target_read_memory ((CORE_ADDR
) target_mem
,
519 (gdb_byte
*) gdb_buf
, len
);
526 /* The reader calls into this function to create a new gdb_object
527 which it can then pass around to the other callbacks. Right now,
528 all that is required is allocating the memory. */
530 static struct gdb_object
*
531 jit_object_open_impl (struct gdb_symbol_callbacks
*cb
)
533 /* CB is not required right now, but sometime in the future we might
534 need a handle to it, and we'd like to do that without breaking
536 return new gdb_object
;
539 /* Readers call into this function to open a new gdb_symtab, which,
540 again, is passed around to other callbacks. */
542 static struct gdb_symtab
*
543 jit_symtab_open_impl (struct gdb_symbol_callbacks
*cb
,
544 struct gdb_object
*object
,
545 const char *file_name
)
547 /* CB stays unused. See comment in jit_object_open_impl. */
549 object
->symtabs
.emplace_front (file_name
);
550 return &object
->symtabs
.front ();
553 /* Returns true if the block corresponding to old should be placed
554 before the block corresponding to new in the final blockvector. */
557 compare_block (const struct gdb_block
*const old
,
558 const struct gdb_block
*const newobj
)
562 if (old
->begin
< newobj
->begin
)
564 else if (old
->begin
== newobj
->begin
)
566 if (old
->end
> newobj
->end
)
575 /* Called by readers to open a new gdb_block. This function also
576 inserts the new gdb_block in the correct place in the corresponding
579 static struct gdb_block
*
580 jit_block_open_impl (struct gdb_symbol_callbacks
*cb
,
581 struct gdb_symtab
*symtab
, struct gdb_block
*parent
,
582 GDB_CORE_ADDR begin
, GDB_CORE_ADDR end
, const char *name
)
584 struct gdb_block
*block
= new gdb_block (parent
, begin
, end
, name
);
586 block
->next
= symtab
->blocks
;
588 /* Ensure that the blocks are inserted in the correct (reverse of
589 the order expected by blockvector). */
590 if (compare_block (symtab
->blocks
, block
))
592 symtab
->blocks
= block
;
596 struct gdb_block
*i
= symtab
->blocks
;
600 /* Guaranteed to terminate, since compare_block (NULL, _)
602 if (compare_block (i
->next
, block
))
604 block
->next
= i
->next
;
615 /* Readers call this to add a line mapping (from PC to line number) to
619 jit_symtab_line_mapping_add_impl (struct gdb_symbol_callbacks
*cb
,
620 struct gdb_symtab
*stab
, int nlines
,
621 struct gdb_line_mapping
*map
)
629 alloc_len
= sizeof (struct linetable
)
630 + (nlines
- 1) * sizeof (struct linetable_entry
);
631 stab
->linetable
.reset (XNEWVAR (struct linetable
, alloc_len
));
632 stab
->linetable
->nitems
= nlines
;
633 for (i
= 0; i
< nlines
; i
++)
635 stab
->linetable
->item
[i
].pc
= (CORE_ADDR
) map
[i
].pc
;
636 stab
->linetable
->item
[i
].line
= map
[i
].line
;
640 /* Called by readers to close a gdb_symtab. Does not need to do
641 anything as of now. */
644 jit_symtab_close_impl (struct gdb_symbol_callbacks
*cb
,
645 struct gdb_symtab
*stab
)
647 /* Right now nothing needs to be done here. We may need to do some
648 cleanup here in the future (again, without breaking the plugin
652 /* Transform STAB to a proper symtab, and add it it OBJFILE. */
655 finalize_symtab (struct gdb_symtab
*stab
, struct objfile
*objfile
)
657 struct compunit_symtab
*cust
;
658 struct gdb_block
*gdb_block_iter
;
659 struct block
*block_iter
;
660 int actual_nblocks
, i
;
661 size_t blockvector_size
;
662 CORE_ADDR begin
, end
;
663 struct blockvector
*bv
;
665 actual_nblocks
= FIRST_LOCAL_BLOCK
+ stab
->nblocks
;
667 cust
= allocate_compunit_symtab (objfile
, stab
->file_name
.c_str ());
668 allocate_symtab (cust
, stab
->file_name
.c_str ());
669 add_compunit_symtab_to_objfile (cust
);
671 /* JIT compilers compile in memory. */
672 COMPUNIT_DIRNAME (cust
) = NULL
;
674 /* Copy over the linetable entry if one was provided. */
677 size_t size
= ((stab
->linetable
->nitems
- 1)
678 * sizeof (struct linetable_entry
)
679 + sizeof (struct linetable
));
680 SYMTAB_LINETABLE (COMPUNIT_FILETABS (cust
))
681 = (struct linetable
*) obstack_alloc (&objfile
->objfile_obstack
, size
);
682 memcpy (SYMTAB_LINETABLE (COMPUNIT_FILETABS (cust
)),
683 stab
->linetable
.get (), size
);
686 blockvector_size
= (sizeof (struct blockvector
)
687 + (actual_nblocks
- 1) * sizeof (struct block
*));
688 bv
= (struct blockvector
*) obstack_alloc (&objfile
->objfile_obstack
,
690 COMPUNIT_BLOCKVECTOR (cust
) = bv
;
692 /* (begin, end) will contain the PC range this entire blockvector
694 BLOCKVECTOR_MAP (bv
) = NULL
;
695 begin
= stab
->blocks
->begin
;
696 end
= stab
->blocks
->end
;
697 BLOCKVECTOR_NBLOCKS (bv
) = actual_nblocks
;
699 /* First run over all the gdb_block objects, creating a real block
700 object for each. Simultaneously, keep setting the real_block
702 for (i
= (actual_nblocks
- 1), gdb_block_iter
= stab
->blocks
;
703 i
>= FIRST_LOCAL_BLOCK
;
704 i
--, gdb_block_iter
= gdb_block_iter
->next
)
706 struct block
*new_block
= allocate_block (&objfile
->objfile_obstack
);
707 struct symbol
*block_name
= allocate_symbol (objfile
);
708 struct type
*block_type
= arch_type (get_objfile_arch (objfile
),
713 BLOCK_MULTIDICT (new_block
)
714 = mdict_create_linear (&objfile
->objfile_obstack
, NULL
);
715 /* The address range. */
716 BLOCK_START (new_block
) = (CORE_ADDR
) gdb_block_iter
->begin
;
717 BLOCK_END (new_block
) = (CORE_ADDR
) gdb_block_iter
->end
;
720 SYMBOL_DOMAIN (block_name
) = VAR_DOMAIN
;
721 SYMBOL_ACLASS_INDEX (block_name
) = LOC_BLOCK
;
722 symbol_set_symtab (block_name
, COMPUNIT_FILETABS (cust
));
723 SYMBOL_TYPE (block_name
) = lookup_function_type (block_type
);
724 SYMBOL_BLOCK_VALUE (block_name
) = new_block
;
726 block_name
->name
= obstack_strdup (&objfile
->objfile_obstack
,
727 gdb_block_iter
->name
.get ());
729 BLOCK_FUNCTION (new_block
) = block_name
;
731 BLOCKVECTOR_BLOCK (bv
, i
) = new_block
;
732 if (begin
> BLOCK_START (new_block
))
733 begin
= BLOCK_START (new_block
);
734 if (end
< BLOCK_END (new_block
))
735 end
= BLOCK_END (new_block
);
737 gdb_block_iter
->real_block
= new_block
;
740 /* Now add the special blocks. */
742 for (i
= 0; i
< FIRST_LOCAL_BLOCK
; i
++)
744 struct block
*new_block
;
746 new_block
= (i
== GLOBAL_BLOCK
747 ? allocate_global_block (&objfile
->objfile_obstack
)
748 : allocate_block (&objfile
->objfile_obstack
));
749 BLOCK_MULTIDICT (new_block
)
750 = mdict_create_linear (&objfile
->objfile_obstack
, NULL
);
751 BLOCK_SUPERBLOCK (new_block
) = block_iter
;
752 block_iter
= new_block
;
754 BLOCK_START (new_block
) = (CORE_ADDR
) begin
;
755 BLOCK_END (new_block
) = (CORE_ADDR
) end
;
757 BLOCKVECTOR_BLOCK (bv
, i
) = new_block
;
759 if (i
== GLOBAL_BLOCK
)
760 set_block_compunit_symtab (new_block
, cust
);
763 /* Fill up the superblock fields for the real blocks, using the
764 real_block fields populated earlier. */
765 for (gdb_block_iter
= stab
->blocks
;
767 gdb_block_iter
= gdb_block_iter
->next
)
769 if (gdb_block_iter
->parent
!= NULL
)
771 /* If the plugin specifically mentioned a parent block, we
773 BLOCK_SUPERBLOCK (gdb_block_iter
->real_block
) =
774 gdb_block_iter
->parent
->real_block
;
778 /* And if not, we set a default parent block. */
779 BLOCK_SUPERBLOCK (gdb_block_iter
->real_block
) =
780 BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
);
785 /* Called when closing a gdb_objfile. Converts OBJ to a proper
789 jit_object_close_impl (struct gdb_symbol_callbacks
*cb
,
790 struct gdb_object
*obj
)
792 struct objfile
*objfile
;
793 jit_dbg_reader_data
*priv_data
;
795 priv_data
= (jit_dbg_reader_data
*) cb
->priv_data
;
797 objfile
= objfile::make (nullptr, "<< JIT compiled code >>",
799 objfile
->per_bfd
->gdbarch
= target_gdbarch ();
801 for (gdb_symtab
&symtab
: obj
->symtabs
)
802 finalize_symtab (&symtab
, objfile
);
804 add_objfile_entry (objfile
, *priv_data
);
809 /* Try to read CODE_ENTRY using the loaded jit reader (if any).
810 ENTRY_ADDR is the address of the struct jit_code_entry in the
811 inferior address space. */
814 jit_reader_try_read_symtab (struct jit_code_entry
*code_entry
,
815 CORE_ADDR entry_addr
)
818 jit_dbg_reader_data priv_data
;
819 struct gdb_reader_funcs
*funcs
;
820 struct gdb_symbol_callbacks callbacks
=
822 jit_object_open_impl
,
823 jit_symtab_open_impl
,
825 jit_symtab_close_impl
,
826 jit_object_close_impl
,
828 jit_symtab_line_mapping_add_impl
,
829 jit_target_read_impl
,
834 priv_data
= entry_addr
;
836 if (!loaded_jit_reader
)
839 gdb::byte_vector
gdb_mem (code_entry
->symfile_size
);
844 if (target_read_memory (code_entry
->symfile_addr
, gdb_mem
.data (),
845 code_entry
->symfile_size
))
848 catch (const gdb_exception
&e
)
855 funcs
= loaded_jit_reader
->functions
;
856 if (funcs
->read (funcs
, &callbacks
, gdb_mem
.data (),
857 code_entry
->symfile_size
)
862 if (jit_debug
&& status
== 0)
863 fprintf_unfiltered (gdb_stdlog
,
864 "Could not read symtab using the loaded JIT reader.\n");
868 /* Try to read CODE_ENTRY using BFD. ENTRY_ADDR is the address of the
869 struct jit_code_entry in the inferior address space. */
872 jit_bfd_try_read_symtab (struct jit_code_entry
*code_entry
,
873 CORE_ADDR entry_addr
,
874 struct gdbarch
*gdbarch
)
876 struct bfd_section
*sec
;
877 struct objfile
*objfile
;
878 const struct bfd_arch_info
*b
;
881 fprintf_unfiltered (gdb_stdlog
,
882 "jit_bfd_try_read_symtab, symfile_addr = %s, "
883 "symfile_size = %s\n",
884 paddress (gdbarch
, code_entry
->symfile_addr
),
885 pulongest (code_entry
->symfile_size
));
887 gdb_bfd_ref_ptr
nbfd (bfd_open_from_target_memory (code_entry
->symfile_addr
,
888 code_entry
->symfile_size
,
892 puts_unfiltered (_("Error opening JITed symbol file, ignoring it.\n"));
896 /* Check the format. NOTE: This initializes important data that GDB uses!
897 We would segfault later without this line. */
898 if (!bfd_check_format (nbfd
.get (), bfd_object
))
900 printf_unfiltered (_("\
901 JITed symbol file is not an object file, ignoring it.\n"));
905 /* Check bfd arch. */
906 b
= gdbarch_bfd_arch_info (gdbarch
);
907 if (b
->compatible (b
, bfd_get_arch_info (nbfd
.get ())) != b
)
908 warning (_("JITed object file architecture %s is not compatible "
909 "with target architecture %s."),
910 bfd_get_arch_info (nbfd
.get ())->printable_name
,
913 /* Read the section address information out of the symbol file. Since the
914 file is generated by the JIT at runtime, it should all of the absolute
915 addresses that we care about. */
916 section_addr_info sai
;
917 for (sec
= nbfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
918 if ((bfd_section_flags (sec
) & (SEC_ALLOC
|SEC_LOAD
)) != 0)
920 /* We assume that these virtual addresses are absolute, and do not
921 treat them as offsets. */
922 sai
.emplace_back (bfd_section_vma (sec
),
923 bfd_section_name (sec
),
927 /* This call does not take ownership of SAI. */
928 objfile
= symbol_file_add_from_bfd (nbfd
.get (),
929 bfd_get_filename (nbfd
.get ()), 0,
931 OBJF_SHARED
| OBJF_NOT_FILENAME
, NULL
);
933 add_objfile_entry (objfile
, entry_addr
);
936 /* This function registers code associated with a JIT code entry. It uses the
937 pointer and size pair in the entry to read the symbol file from the remote
938 and then calls symbol_file_add_from_local_memory to add it as though it were
939 a symbol file added by the user. */
942 jit_register_code (struct gdbarch
*gdbarch
,
943 CORE_ADDR entry_addr
, struct jit_code_entry
*code_entry
)
948 fprintf_unfiltered (gdb_stdlog
,
949 "jit_register_code, symfile_addr = %s, "
950 "symfile_size = %s\n",
951 paddress (gdbarch
, code_entry
->symfile_addr
),
952 pulongest (code_entry
->symfile_size
));
954 success
= jit_reader_try_read_symtab (code_entry
, entry_addr
);
957 jit_bfd_try_read_symtab (code_entry
, entry_addr
, gdbarch
);
960 /* Look up the objfile with this code entry address. */
962 static struct objfile
*
963 jit_find_objf_with_entry_addr (CORE_ADDR entry_addr
)
965 for (objfile
*objf
: current_program_space
->objfiles ())
967 struct jit_objfile_data
*objf_data
;
970 = (struct jit_objfile_data
*) objfile_data (objf
, jit_objfile_data
);
971 if (objf_data
!= NULL
&& objf_data
->addr
== entry_addr
)
977 /* This is called when a breakpoint is deleted. It updates the
978 inferior's cache, if needed. */
981 jit_breakpoint_deleted (struct breakpoint
*b
)
983 struct bp_location
*iter
;
985 if (b
->type
!= bp_jit_event
)
988 for (iter
= b
->loc
; iter
!= NULL
; iter
= iter
->next
)
990 struct jit_program_space_data
*ps_data
;
992 ps_data
= jit_program_space_key
.get (iter
->pspace
);
993 if (ps_data
!= NULL
&& ps_data
->jit_breakpoint
== iter
->owner
)
995 ps_data
->cached_code_address
= 0;
996 ps_data
->jit_breakpoint
= NULL
;
1001 /* (Re-)Initialize the jit breakpoint if necessary.
1002 Return 0 if the jit breakpoint has been successfully initialized. */
1005 jit_breakpoint_re_set_internal (struct gdbarch
*gdbarch
,
1006 struct jit_program_space_data
*ps_data
)
1008 struct bound_minimal_symbol reg_symbol
;
1009 struct bound_minimal_symbol desc_symbol
;
1010 struct jit_objfile_data
*objf_data
;
1013 if (ps_data
->objfile
== NULL
)
1015 /* Lookup the registration symbol. If it is missing, then we
1016 assume we are not attached to a JIT. */
1017 reg_symbol
= lookup_bound_minimal_symbol (jit_break_name
);
1018 if (reg_symbol
.minsym
== NULL
1019 || BMSYMBOL_VALUE_ADDRESS (reg_symbol
) == 0)
1022 desc_symbol
= lookup_minimal_symbol (jit_descriptor_name
, NULL
,
1023 reg_symbol
.objfile
);
1024 if (desc_symbol
.minsym
== NULL
1025 || BMSYMBOL_VALUE_ADDRESS (desc_symbol
) == 0)
1028 objf_data
= get_jit_objfile_data (reg_symbol
.objfile
);
1029 objf_data
->register_code
= reg_symbol
.minsym
;
1030 objf_data
->descriptor
= desc_symbol
.minsym
;
1032 ps_data
->objfile
= reg_symbol
.objfile
;
1035 objf_data
= get_jit_objfile_data (ps_data
->objfile
);
1037 addr
= MSYMBOL_VALUE_ADDRESS (ps_data
->objfile
, objf_data
->register_code
);
1040 fprintf_unfiltered (gdb_stdlog
,
1041 "jit_breakpoint_re_set_internal, "
1042 "breakpoint_addr = %s\n",
1043 paddress (gdbarch
, addr
));
1045 if (ps_data
->cached_code_address
== addr
)
1048 /* Delete the old breakpoint. */
1049 if (ps_data
->jit_breakpoint
!= NULL
)
1050 delete_breakpoint (ps_data
->jit_breakpoint
);
1052 /* Put a breakpoint in the registration symbol. */
1053 ps_data
->cached_code_address
= addr
;
1054 ps_data
->jit_breakpoint
= create_jit_event_breakpoint (gdbarch
, addr
);
1059 /* The private data passed around in the frame unwind callback
1062 struct jit_unwind_private
1064 /* Cached register values. See jit_frame_sniffer to see how this
1066 detached_regcache
*regcache
;
1068 /* The frame being unwound. */
1069 struct frame_info
*this_frame
;
1072 /* Sets the value of a particular register in this frame. */
1075 jit_unwind_reg_set_impl (struct gdb_unwind_callbacks
*cb
, int dwarf_regnum
,
1076 struct gdb_reg_value
*value
)
1078 struct jit_unwind_private
*priv
;
1081 priv
= (struct jit_unwind_private
*) cb
->priv_data
;
1083 gdb_reg
= gdbarch_dwarf2_reg_to_regnum (get_frame_arch (priv
->this_frame
),
1088 fprintf_unfiltered (gdb_stdlog
,
1089 _("Could not recognize DWARF regnum %d"),
1091 value
->free (value
);
1095 priv
->regcache
->raw_supply (gdb_reg
, value
->value
);
1096 value
->free (value
);
1100 reg_value_free_impl (struct gdb_reg_value
*value
)
1105 /* Get the value of register REGNUM in the previous frame. */
1107 static struct gdb_reg_value
*
1108 jit_unwind_reg_get_impl (struct gdb_unwind_callbacks
*cb
, int regnum
)
1110 struct jit_unwind_private
*priv
;
1111 struct gdb_reg_value
*value
;
1113 struct gdbarch
*frame_arch
;
1115 priv
= (struct jit_unwind_private
*) cb
->priv_data
;
1116 frame_arch
= get_frame_arch (priv
->this_frame
);
1118 gdb_reg
= gdbarch_dwarf2_reg_to_regnum (frame_arch
, regnum
);
1119 size
= register_size (frame_arch
, gdb_reg
);
1120 value
= ((struct gdb_reg_value
*)
1121 xmalloc (sizeof (struct gdb_reg_value
) + size
- 1));
1122 value
->defined
= deprecated_frame_register_read (priv
->this_frame
, gdb_reg
,
1125 value
->free
= reg_value_free_impl
;
1129 /* gdb_reg_value has a free function, which must be called on each
1130 saved register value. */
1133 jit_dealloc_cache (struct frame_info
*this_frame
, void *cache
)
1135 struct jit_unwind_private
*priv_data
= (struct jit_unwind_private
*) cache
;
1137 gdb_assert (priv_data
->regcache
!= NULL
);
1138 delete priv_data
->regcache
;
1142 /* The frame sniffer for the pseudo unwinder.
1144 While this is nominally a frame sniffer, in the case where the JIT
1145 reader actually recognizes the frame, it does a lot more work -- it
1146 unwinds the frame and saves the corresponding register values in
1147 the cache. jit_frame_prev_register simply returns the saved
1151 jit_frame_sniffer (const struct frame_unwind
*self
,
1152 struct frame_info
*this_frame
, void **cache
)
1154 struct jit_unwind_private
*priv_data
;
1155 struct gdb_unwind_callbacks callbacks
;
1156 struct gdb_reader_funcs
*funcs
;
1158 callbacks
.reg_get
= jit_unwind_reg_get_impl
;
1159 callbacks
.reg_set
= jit_unwind_reg_set_impl
;
1160 callbacks
.target_read
= jit_target_read_impl
;
1162 if (loaded_jit_reader
== NULL
)
1165 funcs
= loaded_jit_reader
->functions
;
1167 gdb_assert (!*cache
);
1169 *cache
= XCNEW (struct jit_unwind_private
);
1170 priv_data
= (struct jit_unwind_private
*) *cache
;
1171 /* Take a snapshot of current regcache. */
1172 priv_data
->regcache
= new detached_regcache (get_frame_arch (this_frame
),
1174 priv_data
->this_frame
= this_frame
;
1176 callbacks
.priv_data
= priv_data
;
1178 /* Try to coax the provided unwinder to unwind the stack */
1179 if (funcs
->unwind (funcs
, &callbacks
) == GDB_SUCCESS
)
1182 fprintf_unfiltered (gdb_stdlog
, _("Successfully unwound frame using "
1187 fprintf_unfiltered (gdb_stdlog
, _("Could not unwind frame using "
1190 jit_dealloc_cache (this_frame
, *cache
);
1197 /* The frame_id function for the pseudo unwinder. Relays the call to
1198 the loaded plugin. */
1201 jit_frame_this_id (struct frame_info
*this_frame
, void **cache
,
1202 struct frame_id
*this_id
)
1204 struct jit_unwind_private priv
;
1205 struct gdb_frame_id frame_id
;
1206 struct gdb_reader_funcs
*funcs
;
1207 struct gdb_unwind_callbacks callbacks
;
1209 priv
.regcache
= NULL
;
1210 priv
.this_frame
= this_frame
;
1212 /* We don't expect the frame_id function to set any registers, so we
1213 set reg_set to NULL. */
1214 callbacks
.reg_get
= jit_unwind_reg_get_impl
;
1215 callbacks
.reg_set
= NULL
;
1216 callbacks
.target_read
= jit_target_read_impl
;
1217 callbacks
.priv_data
= &priv
;
1219 gdb_assert (loaded_jit_reader
);
1220 funcs
= loaded_jit_reader
->functions
;
1222 frame_id
= funcs
->get_frame_id (funcs
, &callbacks
);
1223 *this_id
= frame_id_build (frame_id
.stack_address
, frame_id
.code_address
);
1226 /* Pseudo unwinder function. Reads the previously fetched value for
1227 the register from the cache. */
1229 static struct value
*
1230 jit_frame_prev_register (struct frame_info
*this_frame
, void **cache
, int reg
)
1232 struct jit_unwind_private
*priv
= (struct jit_unwind_private
*) *cache
;
1233 struct gdbarch
*gdbarch
;
1236 return frame_unwind_got_optimized (this_frame
, reg
);
1238 gdbarch
= priv
->regcache
->arch ();
1239 gdb_byte
*buf
= (gdb_byte
*) alloca (register_size (gdbarch
, reg
));
1240 enum register_status status
= priv
->regcache
->cooked_read (reg
, buf
);
1242 if (status
== REG_VALID
)
1243 return frame_unwind_got_bytes (this_frame
, reg
, buf
);
1245 return frame_unwind_got_optimized (this_frame
, reg
);
1248 /* Relay everything back to the unwinder registered by the JIT debug
1251 static const struct frame_unwind jit_frame_unwind
=
1254 default_frame_unwind_stop_reason
,
1256 jit_frame_prev_register
,
1263 /* This is the information that is stored at jit_gdbarch_data for each
1266 struct jit_gdbarch_data_type
1268 /* Has the (pseudo) unwinder been prepended? */
1269 int unwinder_registered
;
1272 /* Check GDBARCH and prepend the pseudo JIT unwinder if needed. */
1275 jit_prepend_unwinder (struct gdbarch
*gdbarch
)
1277 struct jit_gdbarch_data_type
*data
;
1280 = (struct jit_gdbarch_data_type
*) gdbarch_data (gdbarch
, jit_gdbarch_data
);
1281 if (!data
->unwinder_registered
)
1283 frame_unwind_prepend_unwinder (gdbarch
, &jit_frame_unwind
);
1284 data
->unwinder_registered
= 1;
1288 /* Register any already created translations. */
1291 jit_inferior_init (struct gdbarch
*gdbarch
)
1293 struct jit_descriptor descriptor
;
1294 struct jit_code_entry cur_entry
;
1295 struct jit_program_space_data
*ps_data
;
1296 CORE_ADDR cur_entry_addr
;
1299 fprintf_unfiltered (gdb_stdlog
, "jit_inferior_init\n");
1301 jit_prepend_unwinder (gdbarch
);
1303 ps_data
= get_jit_program_space_data ();
1304 if (jit_breakpoint_re_set_internal (gdbarch
, ps_data
) != 0)
1307 /* Read the descriptor so we can check the version number and load
1308 any already JITed functions. */
1309 if (!jit_read_descriptor (gdbarch
, &descriptor
, ps_data
))
1312 /* Check that the version number agrees with that we support. */
1313 if (descriptor
.version
!= 1)
1315 printf_unfiltered (_("Unsupported JIT protocol version %ld "
1316 "in descriptor (expected 1)\n"),
1317 (long) descriptor
.version
);
1321 /* If we've attached to a running program, we need to check the descriptor
1322 to register any functions that were already generated. */
1323 for (cur_entry_addr
= descriptor
.first_entry
;
1324 cur_entry_addr
!= 0;
1325 cur_entry_addr
= cur_entry
.next_entry
)
1327 jit_read_code_entry (gdbarch
, cur_entry_addr
, &cur_entry
);
1329 /* This hook may be called many times during setup, so make sure we don't
1330 add the same symbol file twice. */
1331 if (jit_find_objf_with_entry_addr (cur_entry_addr
) != NULL
)
1334 jit_register_code (gdbarch
, cur_entry_addr
, &cur_entry
);
1338 /* inferior_created observer. */
1341 jit_inferior_created (struct target_ops
*ops
, int from_tty
)
1343 jit_inferior_created_hook ();
1346 /* Exported routine to call when an inferior has been created. */
1349 jit_inferior_created_hook (void)
1351 jit_inferior_init (target_gdbarch ());
1354 /* Exported routine to call to re-set the jit breakpoints,
1355 e.g. when a program is rerun. */
1358 jit_breakpoint_re_set (void)
1360 jit_breakpoint_re_set_internal (target_gdbarch (),
1361 get_jit_program_space_data ());
1364 /* This function cleans up any code entries left over when the
1365 inferior exits. We get left over code when the inferior exits
1366 without unregistering its code, for example when it crashes. */
1369 jit_inferior_exit_hook (struct inferior
*inf
)
1371 for (objfile
*objf
: current_program_space
->objfiles_safe ())
1373 struct jit_objfile_data
*objf_data
1374 = (struct jit_objfile_data
*) objfile_data (objf
, jit_objfile_data
);
1376 if (objf_data
!= NULL
&& objf_data
->addr
!= 0)
1382 jit_event_handler (struct gdbarch
*gdbarch
)
1384 struct jit_descriptor descriptor
;
1385 struct jit_code_entry code_entry
;
1386 CORE_ADDR entry_addr
;
1387 struct objfile
*objf
;
1389 /* Read the descriptor from remote memory. */
1390 if (!jit_read_descriptor (gdbarch
, &descriptor
,
1391 get_jit_program_space_data ()))
1393 entry_addr
= descriptor
.relevant_entry
;
1395 /* Do the corresponding action. */
1396 switch (descriptor
.action_flag
)
1401 jit_read_code_entry (gdbarch
, entry_addr
, &code_entry
);
1402 jit_register_code (gdbarch
, entry_addr
, &code_entry
);
1404 case JIT_UNREGISTER
:
1405 objf
= jit_find_objf_with_entry_addr (entry_addr
);
1407 printf_unfiltered (_("Unable to find JITed code "
1408 "entry at address: %s\n"),
1409 paddress (gdbarch
, entry_addr
));
1415 error (_("Unknown action_flag value in JIT descriptor!"));
1420 /* Called to free the data allocated to the jit_program_space_data slot. */
1423 free_objfile_data (struct objfile
*objfile
, void *data
)
1425 struct jit_objfile_data
*objf_data
= (struct jit_objfile_data
*) data
;
1427 if (objf_data
->register_code
!= NULL
)
1429 struct jit_program_space_data
*ps_data
;
1431 ps_data
= jit_program_space_key
.get (objfile
->pspace
);
1432 if (ps_data
!= NULL
&& ps_data
->objfile
== objfile
)
1434 ps_data
->objfile
= NULL
;
1435 if (ps_data
->jit_breakpoint
!= NULL
)
1436 delete_breakpoint (ps_data
->jit_breakpoint
);
1437 ps_data
->cached_code_address
= 0;
1444 /* Initialize the jit_gdbarch_data slot with an instance of struct
1445 jit_gdbarch_data_type */
1448 jit_gdbarch_data_init (struct obstack
*obstack
)
1450 struct jit_gdbarch_data_type
*data
=
1451 XOBNEW (obstack
, struct jit_gdbarch_data_type
);
1453 data
->unwinder_registered
= 0;
1459 _initialize_jit (void)
1461 jit_reader_dir
= relocate_gdb_directory (JIT_READER_DIR
,
1462 JIT_READER_DIR_RELOCATABLE
);
1463 add_setshow_zuinteger_cmd ("jit", class_maintenance
, &jit_debug
,
1464 _("Set JIT debugging."),
1465 _("Show JIT debugging."),
1466 _("When non-zero, JIT debugging is enabled."),
1469 &setdebuglist
, &showdebuglist
);
1471 gdb::observers::inferior_created
.attach (jit_inferior_created
);
1472 gdb::observers::inferior_exit
.attach (jit_inferior_exit_hook
);
1473 gdb::observers::breakpoint_deleted
.attach (jit_breakpoint_deleted
);
1476 register_objfile_data_with_cleanup (NULL
, free_objfile_data
);
1477 jit_gdbarch_data
= gdbarch_data_register_pre_init (jit_gdbarch_data_init
);
1478 if (is_dl_available ())
1480 struct cmd_list_element
*c
;
1482 c
= add_com ("jit-reader-load", no_class
, jit_reader_load_command
, _("\
1483 Load FILE as debug info reader and unwinder for JIT compiled code.\n\
1484 Usage: jit-reader-load FILE\n\
1485 Try to load file FILE as a debug info reader (and unwinder) for\n\
1486 JIT compiled code. The file is loaded from " JIT_READER_DIR
",\n\
1487 relocated relative to the GDB executable if required."));
1488 set_cmd_completer (c
, filename_completer
);
1490 c
= add_com ("jit-reader-unload", no_class
,
1491 jit_reader_unload_command
, _("\
1492 Unload the currently loaded JIT debug info reader.\n\
1493 Usage: jit-reader-unload\n\n\
1494 Do \"help jit-reader-load\" for info on loading debug info readers."));
1495 set_cmd_completer (c
, noop_completer
);