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 char *const jit_break_name
= "__jit_debug_register_code";
50 static const char *const jit_descriptor_name
= "__jit_debug_descriptor";
52 static void jit_inferior_init (struct gdbarch
*gdbarch
);
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 /* Non-zero if we want to see trace of jit level stuff. */
63 static unsigned int jit_debug
= 0;
66 show_jit_debug (struct ui_file
*file
, int from_tty
,
67 struct cmd_list_element
*c
, const char *value
)
69 fprintf_filtered (file
, _("JIT debugging is %s.\n"), value
);
78 /* Opening the file is a no-op. */
81 mem_bfd_iovec_open (struct bfd
*abfd
, void *open_closure
)
86 /* Closing the file is just freeing the base/size pair on our side. */
89 mem_bfd_iovec_close (struct bfd
*abfd
, void *stream
)
93 /* Zero means success. */
97 /* For reading the file, we just need to pass through to target_read_memory and
98 fix up the arguments and return values. */
101 mem_bfd_iovec_pread (struct bfd
*abfd
, void *stream
, void *buf
,
102 file_ptr nbytes
, file_ptr offset
)
105 struct target_buffer
*buffer
= (struct target_buffer
*) stream
;
107 /* If this read will read all of the file, limit it to just the rest. */
108 if (offset
+ nbytes
> buffer
->size
)
109 nbytes
= buffer
->size
- offset
;
111 /* If there are no more bytes left, we've reached EOF. */
115 err
= target_read_memory (buffer
->base
+ offset
, (gdb_byte
*) buf
, nbytes
);
122 /* For statting the file, we only support the st_size attribute. */
125 mem_bfd_iovec_stat (struct bfd
*abfd
, void *stream
, struct stat
*sb
)
127 struct target_buffer
*buffer
= (struct target_buffer
*) stream
;
129 memset (sb
, 0, sizeof (struct stat
));
130 sb
->st_size
= buffer
->size
;
134 /* Open a BFD from the target's memory. */
136 static gdb_bfd_ref_ptr
137 bfd_open_from_target_memory (CORE_ADDR addr
, ULONGEST size
,
140 struct target_buffer
*buffer
= XNEW (struct target_buffer
);
144 return gdb_bfd_openr_iovec ("<in-memory>", target
,
154 jit_reader (struct gdb_reader_funcs
*f
, gdb_dlhandle_up
&&h
)
155 : functions (f
), handle (std::move (h
))
161 functions
->destroy (functions
);
164 DISABLE_COPY_AND_ASSIGN (jit_reader
);
166 struct gdb_reader_funcs
*functions
;
167 gdb_dlhandle_up handle
;
170 /* One reader that has been loaded successfully, and can potentially be used to
173 static struct jit_reader
*loaded_jit_reader
= NULL
;
175 typedef struct gdb_reader_funcs
* (reader_init_fn_type
) (void);
176 static const char *reader_init_fn_sym
= "gdb_init_reader";
178 /* Try to load FILE_NAME as a JIT debug info reader. */
180 static struct jit_reader
*
181 jit_reader_load (const char *file_name
)
183 reader_init_fn_type
*init_fn
;
184 struct gdb_reader_funcs
*funcs
= NULL
;
187 fprintf_unfiltered (gdb_stdlog
, _("Opening shared object %s.\n"),
189 gdb_dlhandle_up so
= gdb_dlopen (file_name
);
191 init_fn
= (reader_init_fn_type
*) gdb_dlsym (so
, reader_init_fn_sym
);
193 error (_("Could not locate initialization function: %s."),
196 if (gdb_dlsym (so
, "plugin_is_GPL_compatible") == NULL
)
197 error (_("Reader not GPL compatible."));
200 if (funcs
->reader_version
!= GDB_READER_INTERFACE_VERSION
)
201 error (_("Reader version does not match GDB version."));
203 return new jit_reader (funcs
, std::move (so
));
206 /* Provides the jit-reader-load command. */
209 jit_reader_load_command (const char *args
, int from_tty
)
212 error (_("No reader name provided."));
213 gdb::unique_xmalloc_ptr
<char> file (tilde_expand (args
));
215 if (loaded_jit_reader
!= NULL
)
216 error (_("JIT reader already loaded. Run jit-reader-unload first."));
218 if (!IS_ABSOLUTE_PATH (file
.get ()))
219 file
.reset (xstrprintf ("%s%s%s", jit_reader_dir
.c_str (), SLASH_STRING
,
222 loaded_jit_reader
= jit_reader_load (file
.get ());
223 reinit_frame_cache ();
224 jit_inferior_created_hook ();
227 /* Provides the jit-reader-unload command. */
230 jit_reader_unload_command (const char *args
, int from_tty
)
232 if (!loaded_jit_reader
)
233 error (_("No JIT reader loaded."));
235 reinit_frame_cache ();
236 jit_inferior_exit_hook (current_inferior ());
238 delete loaded_jit_reader
;
239 loaded_jit_reader
= NULL
;
242 /* Per-program space structure recording which objfile has the JIT
245 struct jit_program_space_data
247 /* The objfile. This is NULL if no objfile holds the JIT
250 struct objfile
*objfile
= nullptr;
252 /* If this program space has __jit_debug_register_code, this is the
253 cached address from the minimal symbol. This is used to detect
254 relocations requiring the breakpoint to be re-created. */
256 CORE_ADDR cached_code_address
= 0;
258 /* This is the JIT event breakpoint, or NULL if it has not been
261 struct breakpoint
*jit_breakpoint
= nullptr;
264 static program_space_key
<jit_program_space_data
> jit_program_space_key
;
266 /* Destructor for jit_objfile_data. */
268 jit_objfile_data::~jit_objfile_data ()
270 /* Free the data allocated in the jit_program_space_data slot. */
271 if (this->register_code
!= NULL
)
273 struct jit_program_space_data
*ps_data
;
275 ps_data
= jit_program_space_key
.get (this->objfile
->pspace
);
276 if (ps_data
!= NULL
&& ps_data
->objfile
== this->objfile
)
278 ps_data
->objfile
= NULL
;
279 if (ps_data
->jit_breakpoint
!= NULL
)
280 delete_breakpoint (ps_data
->jit_breakpoint
);
281 ps_data
->cached_code_address
= 0;
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 if (objf
->jit_data
== nullptr)
293 objf
->jit_data
.reset (new jit_objfile_data (objf
));
295 return objf
->jit_data
.get ();
298 /* Remember OBJFILE has been created for struct jit_code_entry located
299 at inferior address ENTRY. */
302 add_objfile_entry (struct objfile
*objfile
, CORE_ADDR entry
)
304 struct jit_objfile_data
*objf_data
;
306 objf_data
= get_jit_objfile_data (objfile
);
307 objf_data
->addr
= entry
;
310 /* Return jit_program_space_data for current program space. Allocate
311 if not already present. */
313 static struct jit_program_space_data
*
314 get_jit_program_space_data ()
316 struct jit_program_space_data
*ps_data
;
318 ps_data
= jit_program_space_key
.get (current_program_space
);
320 ps_data
= jit_program_space_key
.emplace (current_program_space
);
324 /* Helper function for reading the global JIT descriptor from remote
325 memory. Returns true if all went well, false otherwise. */
328 jit_read_descriptor (gdbarch
*gdbarch
,
329 jit_descriptor
*descriptor
,
333 struct type
*ptr_type
;
337 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
338 struct jit_objfile_data
*objf_data
;
340 gdb_assert (jiter
!= nullptr);
341 objf_data
= get_jit_objfile_data (jiter
);
343 if (objf_data
->descriptor
== NULL
)
347 fprintf_unfiltered (gdb_stdlog
,
348 "jit_read_descriptor, descriptor_addr = %s\n",
349 paddress (gdbarch
, MSYMBOL_VALUE_ADDRESS (jiter
,
350 objf_data
->descriptor
)));
352 /* Figure out how big the descriptor is on the remote and how to read it. */
353 ptr_type
= builtin_type (gdbarch
)->builtin_data_ptr
;
354 ptr_size
= TYPE_LENGTH (ptr_type
);
355 desc_size
= 8 + 2 * ptr_size
; /* Two 32-bit ints and two pointers. */
356 desc_buf
= (gdb_byte
*) alloca (desc_size
);
358 /* Read the descriptor. */
359 err
= target_read_memory (MSYMBOL_VALUE_ADDRESS (jiter
,
360 objf_data
->descriptor
),
361 desc_buf
, desc_size
);
364 printf_unfiltered (_("Unable to read JIT descriptor from "
369 /* Fix the endianness to match the host. */
370 descriptor
->version
= extract_unsigned_integer (&desc_buf
[0], 4, byte_order
);
371 descriptor
->action_flag
=
372 extract_unsigned_integer (&desc_buf
[4], 4, byte_order
);
373 descriptor
->relevant_entry
= extract_typed_address (&desc_buf
[8], ptr_type
);
374 descriptor
->first_entry
=
375 extract_typed_address (&desc_buf
[8 + ptr_size
], ptr_type
);
380 /* Helper function for reading a JITed code entry from remote memory. */
383 jit_read_code_entry (struct gdbarch
*gdbarch
,
384 CORE_ADDR code_addr
, struct jit_code_entry
*code_entry
)
387 struct type
*ptr_type
;
392 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
394 /* Figure out how big the entry is on the remote and how to read it. */
395 ptr_type
= builtin_type (gdbarch
)->builtin_data_ptr
;
396 ptr_size
= TYPE_LENGTH (ptr_type
);
398 /* Figure out where the uint64_t value will be. */
399 align_bytes
= type_align (builtin_type (gdbarch
)->builtin_uint64
);
401 off
= (off
+ (align_bytes
- 1)) & ~(align_bytes
- 1);
403 entry_size
= off
+ 8; /* Three pointers and one 64-bit int. */
404 entry_buf
= (gdb_byte
*) alloca (entry_size
);
406 /* Read the entry. */
407 err
= target_read_memory (code_addr
, entry_buf
, entry_size
);
409 error (_("Unable to read JIT code entry from remote memory!"));
411 /* Fix the endianness to match the host. */
412 ptr_type
= builtin_type (gdbarch
)->builtin_data_ptr
;
413 code_entry
->next_entry
= extract_typed_address (&entry_buf
[0], ptr_type
);
414 code_entry
->prev_entry
=
415 extract_typed_address (&entry_buf
[ptr_size
], ptr_type
);
416 code_entry
->symfile_addr
=
417 extract_typed_address (&entry_buf
[2 * ptr_size
], ptr_type
);
418 code_entry
->symfile_size
=
419 extract_unsigned_integer (&entry_buf
[off
], 8, byte_order
);
422 /* Proxy object for building a block. */
426 gdb_block (gdb_block
*parent
, CORE_ADDR begin
, CORE_ADDR end
,
431 name (name
!= nullptr ? xstrdup (name
) : nullptr)
434 /* The parent of this block. */
435 struct gdb_block
*parent
;
437 /* Points to the "real" block that is being built out of this
438 instance. This block will be added to a blockvector, which will
439 then be added to a symtab. */
440 struct block
*real_block
= nullptr;
442 /* The first and last code address corresponding to this block. */
443 CORE_ADDR begin
, end
;
445 /* The name of this block (if any). If this is non-NULL, the
446 FUNCTION symbol symbol is set to this value. */
447 gdb::unique_xmalloc_ptr
<char> name
;
450 /* Proxy object for building a symtab. */
454 explicit gdb_symtab (const char *file_name
)
455 : file_name (file_name
!= nullptr ? file_name
: "")
458 /* The list of blocks in this symtab. These will eventually be
459 converted to real blocks.
461 This is specifically a linked list, instead of, for example, a vector,
462 because the pointers are returned to the user's debug info reader. So
463 it's important that the objects don't change location during their
464 lifetime (which would happen with a vector of objects getting resized). */
465 std::forward_list
<gdb_block
> blocks
;
467 /* The number of blocks inserted. */
470 /* A mapping between line numbers to PC. */
471 gdb::unique_xmalloc_ptr
<struct linetable
> linetable
;
473 /* The source file for this symtab. */
474 std::string file_name
;
477 /* Proxy object for building an object. */
481 /* Symtabs of this object.
483 This is specifically a linked list, instead of, for example, a vector,
484 because the pointers are returned to the user's debug info reader. So
485 it's important that the objects don't change location during their
486 lifetime (which would happen with a vector of objects getting resized). */
487 std::forward_list
<gdb_symtab
> symtabs
;
490 /* The type of the `private' data passed around by the callback
493 typedef CORE_ADDR jit_dbg_reader_data
;
495 /* The reader calls into this function to read data off the targets
498 static enum gdb_status
499 jit_target_read_impl (GDB_CORE_ADDR target_mem
, void *gdb_buf
, int len
)
501 int result
= target_read_memory ((CORE_ADDR
) target_mem
,
502 (gdb_byte
*) gdb_buf
, len
);
509 /* The reader calls into this function to create a new gdb_object
510 which it can then pass around to the other callbacks. Right now,
511 all that is required is allocating the memory. */
513 static struct gdb_object
*
514 jit_object_open_impl (struct gdb_symbol_callbacks
*cb
)
516 /* CB is not required right now, but sometime in the future we might
517 need a handle to it, and we'd like to do that without breaking
519 return new gdb_object
;
522 /* Readers call into this function to open a new gdb_symtab, which,
523 again, is passed around to other callbacks. */
525 static struct gdb_symtab
*
526 jit_symtab_open_impl (struct gdb_symbol_callbacks
*cb
,
527 struct gdb_object
*object
,
528 const char *file_name
)
530 /* CB stays unused. See comment in jit_object_open_impl. */
532 object
->symtabs
.emplace_front (file_name
);
533 return &object
->symtabs
.front ();
536 /* Called by readers to open a new gdb_block. This function also
537 inserts the new gdb_block in the correct place in the corresponding
540 static struct gdb_block
*
541 jit_block_open_impl (struct gdb_symbol_callbacks
*cb
,
542 struct gdb_symtab
*symtab
, struct gdb_block
*parent
,
543 GDB_CORE_ADDR begin
, GDB_CORE_ADDR end
, const char *name
)
545 /* Place the block at the beginning of the list, it will be sorted when the
546 symtab is finalized. */
547 symtab
->blocks
.emplace_front (parent
, begin
, end
, name
);
550 return &symtab
->blocks
.front ();
553 /* Readers call this to add a line mapping (from PC to line number) to
557 jit_symtab_line_mapping_add_impl (struct gdb_symbol_callbacks
*cb
,
558 struct gdb_symtab
*stab
, int nlines
,
559 struct gdb_line_mapping
*map
)
567 alloc_len
= sizeof (struct linetable
)
568 + (nlines
- 1) * sizeof (struct linetable_entry
);
569 stab
->linetable
.reset (XNEWVAR (struct linetable
, alloc_len
));
570 stab
->linetable
->nitems
= nlines
;
571 for (i
= 0; i
< nlines
; i
++)
573 stab
->linetable
->item
[i
].pc
= (CORE_ADDR
) map
[i
].pc
;
574 stab
->linetable
->item
[i
].line
= map
[i
].line
;
575 stab
->linetable
->item
[i
].is_stmt
= 1;
579 /* Called by readers to close a gdb_symtab. Does not need to do
580 anything as of now. */
583 jit_symtab_close_impl (struct gdb_symbol_callbacks
*cb
,
584 struct gdb_symtab
*stab
)
586 /* Right now nothing needs to be done here. We may need to do some
587 cleanup here in the future (again, without breaking the plugin
591 /* Transform STAB to a proper symtab, and add it it OBJFILE. */
594 finalize_symtab (struct gdb_symtab
*stab
, struct objfile
*objfile
)
596 struct compunit_symtab
*cust
;
597 size_t blockvector_size
;
598 CORE_ADDR begin
, end
;
599 struct blockvector
*bv
;
601 int actual_nblocks
= FIRST_LOCAL_BLOCK
+ stab
->nblocks
;
603 /* Sort the blocks in the order they should appear in the blockvector. */
604 stab
->blocks
.sort([] (const gdb_block
&a
, const gdb_block
&b
)
606 if (a
.begin
!= b
.begin
)
607 return a
.begin
< b
.begin
;
609 return a
.end
> b
.end
;
612 cust
= allocate_compunit_symtab (objfile
, stab
->file_name
.c_str ());
613 allocate_symtab (cust
, stab
->file_name
.c_str ());
614 add_compunit_symtab_to_objfile (cust
);
616 /* JIT compilers compile in memory. */
617 COMPUNIT_DIRNAME (cust
) = NULL
;
619 /* Copy over the linetable entry if one was provided. */
622 size_t size
= ((stab
->linetable
->nitems
- 1)
623 * sizeof (struct linetable_entry
)
624 + sizeof (struct linetable
));
625 SYMTAB_LINETABLE (COMPUNIT_FILETABS (cust
))
626 = (struct linetable
*) obstack_alloc (&objfile
->objfile_obstack
, size
);
627 memcpy (SYMTAB_LINETABLE (COMPUNIT_FILETABS (cust
)),
628 stab
->linetable
.get (), size
);
631 blockvector_size
= (sizeof (struct blockvector
)
632 + (actual_nblocks
- 1) * sizeof (struct block
*));
633 bv
= (struct blockvector
*) obstack_alloc (&objfile
->objfile_obstack
,
635 COMPUNIT_BLOCKVECTOR (cust
) = bv
;
637 /* At the end of this function, (begin, end) will contain the PC range this
638 entire blockvector spans. */
639 BLOCKVECTOR_MAP (bv
) = NULL
;
640 begin
= stab
->blocks
.front ().begin
;
641 end
= stab
->blocks
.front ().end
;
642 BLOCKVECTOR_NBLOCKS (bv
) = actual_nblocks
;
644 /* First run over all the gdb_block objects, creating a real block
645 object for each. Simultaneously, keep setting the real_block
647 int block_idx
= FIRST_LOCAL_BLOCK
;
648 for (gdb_block
&gdb_block_iter
: stab
->blocks
)
650 struct block
*new_block
= allocate_block (&objfile
->objfile_obstack
);
651 struct symbol
*block_name
= new (&objfile
->objfile_obstack
) symbol
;
652 struct type
*block_type
= arch_type (objfile
->arch (),
657 BLOCK_MULTIDICT (new_block
)
658 = mdict_create_linear (&objfile
->objfile_obstack
, NULL
);
659 /* The address range. */
660 BLOCK_START (new_block
) = (CORE_ADDR
) gdb_block_iter
.begin
;
661 BLOCK_END (new_block
) = (CORE_ADDR
) gdb_block_iter
.end
;
664 SYMBOL_DOMAIN (block_name
) = VAR_DOMAIN
;
665 SYMBOL_ACLASS_INDEX (block_name
) = LOC_BLOCK
;
666 symbol_set_symtab (block_name
, COMPUNIT_FILETABS (cust
));
667 SYMBOL_TYPE (block_name
) = lookup_function_type (block_type
);
668 SYMBOL_BLOCK_VALUE (block_name
) = new_block
;
670 block_name
->m_name
= obstack_strdup (&objfile
->objfile_obstack
,
671 gdb_block_iter
.name
.get ());
673 BLOCK_FUNCTION (new_block
) = block_name
;
675 BLOCKVECTOR_BLOCK (bv
, block_idx
) = new_block
;
676 if (begin
> BLOCK_START (new_block
))
677 begin
= BLOCK_START (new_block
);
678 if (end
< BLOCK_END (new_block
))
679 end
= BLOCK_END (new_block
);
681 gdb_block_iter
.real_block
= new_block
;
686 /* Now add the special blocks. */
687 struct block
*block_iter
= NULL
;
688 for (enum block_enum i
: { GLOBAL_BLOCK
, STATIC_BLOCK
})
690 struct block
*new_block
;
692 new_block
= (i
== GLOBAL_BLOCK
693 ? allocate_global_block (&objfile
->objfile_obstack
)
694 : allocate_block (&objfile
->objfile_obstack
));
695 BLOCK_MULTIDICT (new_block
)
696 = mdict_create_linear (&objfile
->objfile_obstack
, NULL
);
697 BLOCK_SUPERBLOCK (new_block
) = block_iter
;
698 block_iter
= new_block
;
700 BLOCK_START (new_block
) = (CORE_ADDR
) begin
;
701 BLOCK_END (new_block
) = (CORE_ADDR
) end
;
703 BLOCKVECTOR_BLOCK (bv
, i
) = new_block
;
705 if (i
== GLOBAL_BLOCK
)
706 set_block_compunit_symtab (new_block
, cust
);
709 /* Fill up the superblock fields for the real blocks, using the
710 real_block fields populated earlier. */
711 for (gdb_block
&gdb_block_iter
: stab
->blocks
)
713 if (gdb_block_iter
.parent
!= NULL
)
715 /* If the plugin specifically mentioned a parent block, we
717 BLOCK_SUPERBLOCK (gdb_block_iter
.real_block
) =
718 gdb_block_iter
.parent
->real_block
;
722 /* And if not, we set a default parent block. */
723 BLOCK_SUPERBLOCK (gdb_block_iter
.real_block
) =
724 BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
);
729 /* Called when closing a gdb_objfile. Converts OBJ to a proper
733 jit_object_close_impl (struct gdb_symbol_callbacks
*cb
,
734 struct gdb_object
*obj
)
736 struct objfile
*objfile
;
737 jit_dbg_reader_data
*priv_data
;
739 priv_data
= (jit_dbg_reader_data
*) cb
->priv_data
;
741 objfile
= objfile::make (nullptr, "<< JIT compiled code >>",
743 objfile
->per_bfd
->gdbarch
= target_gdbarch ();
745 for (gdb_symtab
&symtab
: obj
->symtabs
)
746 finalize_symtab (&symtab
, objfile
);
748 add_objfile_entry (objfile
, *priv_data
);
753 /* Try to read CODE_ENTRY using the loaded jit reader (if any).
754 ENTRY_ADDR is the address of the struct jit_code_entry in the
755 inferior address space. */
758 jit_reader_try_read_symtab (struct jit_code_entry
*code_entry
,
759 CORE_ADDR entry_addr
)
762 jit_dbg_reader_data priv_data
;
763 struct gdb_reader_funcs
*funcs
;
764 struct gdb_symbol_callbacks callbacks
=
766 jit_object_open_impl
,
767 jit_symtab_open_impl
,
769 jit_symtab_close_impl
,
770 jit_object_close_impl
,
772 jit_symtab_line_mapping_add_impl
,
773 jit_target_read_impl
,
778 priv_data
= entry_addr
;
780 if (!loaded_jit_reader
)
783 gdb::byte_vector
gdb_mem (code_entry
->symfile_size
);
788 if (target_read_memory (code_entry
->symfile_addr
, gdb_mem
.data (),
789 code_entry
->symfile_size
))
792 catch (const gdb_exception
&e
)
799 funcs
= loaded_jit_reader
->functions
;
800 if (funcs
->read (funcs
, &callbacks
, gdb_mem
.data (),
801 code_entry
->symfile_size
)
806 if (jit_debug
&& status
== 0)
807 fprintf_unfiltered (gdb_stdlog
,
808 "Could not read symtab using the loaded JIT reader.\n");
812 /* Try to read CODE_ENTRY using BFD. ENTRY_ADDR is the address of the
813 struct jit_code_entry in the inferior address space. */
816 jit_bfd_try_read_symtab (struct jit_code_entry
*code_entry
,
817 CORE_ADDR entry_addr
,
818 struct gdbarch
*gdbarch
)
820 struct bfd_section
*sec
;
821 struct objfile
*objfile
;
822 const struct bfd_arch_info
*b
;
825 fprintf_unfiltered (gdb_stdlog
,
826 "jit_bfd_try_read_symtab, symfile_addr = %s, "
827 "symfile_size = %s\n",
828 paddress (gdbarch
, code_entry
->symfile_addr
),
829 pulongest (code_entry
->symfile_size
));
831 gdb_bfd_ref_ptr
nbfd (bfd_open_from_target_memory (code_entry
->symfile_addr
,
832 code_entry
->symfile_size
,
836 puts_unfiltered (_("Error opening JITed symbol file, ignoring it.\n"));
840 /* Check the format. NOTE: This initializes important data that GDB uses!
841 We would segfault later without this line. */
842 if (!bfd_check_format (nbfd
.get (), bfd_object
))
844 printf_unfiltered (_("\
845 JITed symbol file is not an object file, ignoring it.\n"));
849 /* Check bfd arch. */
850 b
= gdbarch_bfd_arch_info (gdbarch
);
851 if (b
->compatible (b
, bfd_get_arch_info (nbfd
.get ())) != b
)
852 warning (_("JITed object file architecture %s is not compatible "
853 "with target architecture %s."),
854 bfd_get_arch_info (nbfd
.get ())->printable_name
,
857 /* Read the section address information out of the symbol file. Since the
858 file is generated by the JIT at runtime, it should all of the absolute
859 addresses that we care about. */
860 section_addr_info sai
;
861 for (sec
= nbfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
862 if ((bfd_section_flags (sec
) & (SEC_ALLOC
|SEC_LOAD
)) != 0)
864 /* We assume that these virtual addresses are absolute, and do not
865 treat them as offsets. */
866 sai
.emplace_back (bfd_section_vma (sec
),
867 bfd_section_name (sec
),
871 /* This call does not take ownership of SAI. */
872 objfile
= symbol_file_add_from_bfd (nbfd
.get (),
873 bfd_get_filename (nbfd
.get ()), 0,
875 OBJF_SHARED
| OBJF_NOT_FILENAME
, NULL
);
877 add_objfile_entry (objfile
, entry_addr
);
880 /* This function registers code associated with a JIT code entry. It uses the
881 pointer and size pair in the entry to read the symbol file from the remote
882 and then calls symbol_file_add_from_local_memory to add it as though it were
883 a symbol file added by the user. */
886 jit_register_code (struct gdbarch
*gdbarch
,
887 CORE_ADDR entry_addr
, struct jit_code_entry
*code_entry
)
892 fprintf_unfiltered (gdb_stdlog
,
893 "jit_register_code, symfile_addr = %s, "
894 "symfile_size = %s\n",
895 paddress (gdbarch
, code_entry
->symfile_addr
),
896 pulongest (code_entry
->symfile_size
));
898 success
= jit_reader_try_read_symtab (code_entry
, entry_addr
);
901 jit_bfd_try_read_symtab (code_entry
, entry_addr
, gdbarch
);
904 /* Look up the objfile with this code entry address. */
906 static struct objfile
*
907 jit_find_objf_with_entry_addr (CORE_ADDR entry_addr
)
909 for (objfile
*objf
: current_program_space
->objfiles ())
911 if (objf
->jit_data
!= nullptr && objf
->jit_data
->addr
== entry_addr
)
918 /* This is called when a breakpoint is deleted. It updates the
919 inferior's cache, if needed. */
922 jit_breakpoint_deleted (struct breakpoint
*b
)
924 struct bp_location
*iter
;
926 if (b
->type
!= bp_jit_event
)
929 for (iter
= b
->loc
; iter
!= NULL
; iter
= iter
->next
)
931 struct jit_program_space_data
*ps_data
;
933 ps_data
= jit_program_space_key
.get (iter
->pspace
);
934 if (ps_data
!= NULL
&& ps_data
->jit_breakpoint
== iter
->owner
)
936 ps_data
->cached_code_address
= 0;
937 ps_data
->jit_breakpoint
= NULL
;
942 /* (Re-)Initialize the jit breakpoint if necessary.
943 Return true if the jit breakpoint has been successfully initialized. */
946 jit_breakpoint_re_set_internal (struct gdbarch
*gdbarch
,
947 struct jit_program_space_data
*ps_data
)
949 struct bound_minimal_symbol reg_symbol
;
950 struct bound_minimal_symbol desc_symbol
;
951 struct jit_objfile_data
*objf_data
;
954 if (ps_data
->objfile
== NULL
)
956 /* Lookup the registration symbol. If it is missing, then we
957 assume we are not attached to a JIT. */
958 reg_symbol
= lookup_bound_minimal_symbol (jit_break_name
);
959 if (reg_symbol
.minsym
== NULL
960 || BMSYMBOL_VALUE_ADDRESS (reg_symbol
) == 0)
963 desc_symbol
= lookup_minimal_symbol (jit_descriptor_name
, NULL
,
965 if (desc_symbol
.minsym
== NULL
966 || BMSYMBOL_VALUE_ADDRESS (desc_symbol
) == 0)
969 objf_data
= get_jit_objfile_data (reg_symbol
.objfile
);
970 objf_data
->register_code
= reg_symbol
.minsym
;
971 objf_data
->descriptor
= desc_symbol
.minsym
;
973 ps_data
->objfile
= reg_symbol
.objfile
;
976 objf_data
= get_jit_objfile_data (ps_data
->objfile
);
978 addr
= MSYMBOL_VALUE_ADDRESS (ps_data
->objfile
, objf_data
->register_code
);
981 fprintf_unfiltered (gdb_stdlog
,
982 "jit_breakpoint_re_set_internal, "
983 "breakpoint_addr = %s\n",
984 paddress (gdbarch
, addr
));
986 if (ps_data
->cached_code_address
== addr
)
989 /* Delete the old breakpoint. */
990 if (ps_data
->jit_breakpoint
!= NULL
)
991 delete_breakpoint (ps_data
->jit_breakpoint
);
993 /* Put a breakpoint in the registration symbol. */
994 ps_data
->cached_code_address
= addr
;
995 ps_data
->jit_breakpoint
= create_jit_event_breakpoint (gdbarch
, addr
);
1000 /* The private data passed around in the frame unwind callback
1003 struct jit_unwind_private
1005 /* Cached register values. See jit_frame_sniffer to see how this
1007 detached_regcache
*regcache
;
1009 /* The frame being unwound. */
1010 struct frame_info
*this_frame
;
1013 /* Sets the value of a particular register in this frame. */
1016 jit_unwind_reg_set_impl (struct gdb_unwind_callbacks
*cb
, int dwarf_regnum
,
1017 struct gdb_reg_value
*value
)
1019 struct jit_unwind_private
*priv
;
1022 priv
= (struct jit_unwind_private
*) cb
->priv_data
;
1024 gdb_reg
= gdbarch_dwarf2_reg_to_regnum (get_frame_arch (priv
->this_frame
),
1029 fprintf_unfiltered (gdb_stdlog
,
1030 _("Could not recognize DWARF regnum %d"),
1032 value
->free (value
);
1036 priv
->regcache
->raw_supply (gdb_reg
, value
->value
);
1037 value
->free (value
);
1041 reg_value_free_impl (struct gdb_reg_value
*value
)
1046 /* Get the value of register REGNUM in the previous frame. */
1048 static struct gdb_reg_value
*
1049 jit_unwind_reg_get_impl (struct gdb_unwind_callbacks
*cb
, int regnum
)
1051 struct jit_unwind_private
*priv
;
1052 struct gdb_reg_value
*value
;
1054 struct gdbarch
*frame_arch
;
1056 priv
= (struct jit_unwind_private
*) cb
->priv_data
;
1057 frame_arch
= get_frame_arch (priv
->this_frame
);
1059 gdb_reg
= gdbarch_dwarf2_reg_to_regnum (frame_arch
, regnum
);
1060 size
= register_size (frame_arch
, gdb_reg
);
1061 value
= ((struct gdb_reg_value
*)
1062 xmalloc (sizeof (struct gdb_reg_value
) + size
- 1));
1063 value
->defined
= deprecated_frame_register_read (priv
->this_frame
, gdb_reg
,
1066 value
->free
= reg_value_free_impl
;
1070 /* gdb_reg_value has a free function, which must be called on each
1071 saved register value. */
1074 jit_dealloc_cache (struct frame_info
*this_frame
, void *cache
)
1076 struct jit_unwind_private
*priv_data
= (struct jit_unwind_private
*) cache
;
1078 gdb_assert (priv_data
->regcache
!= NULL
);
1079 delete priv_data
->regcache
;
1083 /* The frame sniffer for the pseudo unwinder.
1085 While this is nominally a frame sniffer, in the case where the JIT
1086 reader actually recognizes the frame, it does a lot more work -- it
1087 unwinds the frame and saves the corresponding register values in
1088 the cache. jit_frame_prev_register simply returns the saved
1092 jit_frame_sniffer (const struct frame_unwind
*self
,
1093 struct frame_info
*this_frame
, void **cache
)
1095 struct jit_unwind_private
*priv_data
;
1096 struct gdb_unwind_callbacks callbacks
;
1097 struct gdb_reader_funcs
*funcs
;
1099 callbacks
.reg_get
= jit_unwind_reg_get_impl
;
1100 callbacks
.reg_set
= jit_unwind_reg_set_impl
;
1101 callbacks
.target_read
= jit_target_read_impl
;
1103 if (loaded_jit_reader
== NULL
)
1106 funcs
= loaded_jit_reader
->functions
;
1108 gdb_assert (!*cache
);
1110 *cache
= XCNEW (struct jit_unwind_private
);
1111 priv_data
= (struct jit_unwind_private
*) *cache
;
1112 /* Take a snapshot of current regcache. */
1113 priv_data
->regcache
= new detached_regcache (get_frame_arch (this_frame
),
1115 priv_data
->this_frame
= this_frame
;
1117 callbacks
.priv_data
= priv_data
;
1119 /* Try to coax the provided unwinder to unwind the stack */
1120 if (funcs
->unwind (funcs
, &callbacks
) == GDB_SUCCESS
)
1123 fprintf_unfiltered (gdb_stdlog
, _("Successfully unwound frame using "
1128 fprintf_unfiltered (gdb_stdlog
, _("Could not unwind frame using "
1131 jit_dealloc_cache (this_frame
, *cache
);
1138 /* The frame_id function for the pseudo unwinder. Relays the call to
1139 the loaded plugin. */
1142 jit_frame_this_id (struct frame_info
*this_frame
, void **cache
,
1143 struct frame_id
*this_id
)
1145 struct jit_unwind_private priv
;
1146 struct gdb_frame_id frame_id
;
1147 struct gdb_reader_funcs
*funcs
;
1148 struct gdb_unwind_callbacks callbacks
;
1150 priv
.regcache
= NULL
;
1151 priv
.this_frame
= this_frame
;
1153 /* We don't expect the frame_id function to set any registers, so we
1154 set reg_set to NULL. */
1155 callbacks
.reg_get
= jit_unwind_reg_get_impl
;
1156 callbacks
.reg_set
= NULL
;
1157 callbacks
.target_read
= jit_target_read_impl
;
1158 callbacks
.priv_data
= &priv
;
1160 gdb_assert (loaded_jit_reader
);
1161 funcs
= loaded_jit_reader
->functions
;
1163 frame_id
= funcs
->get_frame_id (funcs
, &callbacks
);
1164 *this_id
= frame_id_build (frame_id
.stack_address
, frame_id
.code_address
);
1167 /* Pseudo unwinder function. Reads the previously fetched value for
1168 the register from the cache. */
1170 static struct value
*
1171 jit_frame_prev_register (struct frame_info
*this_frame
, void **cache
, int reg
)
1173 struct jit_unwind_private
*priv
= (struct jit_unwind_private
*) *cache
;
1174 struct gdbarch
*gdbarch
;
1177 return frame_unwind_got_optimized (this_frame
, reg
);
1179 gdbarch
= priv
->regcache
->arch ();
1180 gdb_byte
*buf
= (gdb_byte
*) alloca (register_size (gdbarch
, reg
));
1181 enum register_status status
= priv
->regcache
->cooked_read (reg
, buf
);
1183 if (status
== REG_VALID
)
1184 return frame_unwind_got_bytes (this_frame
, reg
, buf
);
1186 return frame_unwind_got_optimized (this_frame
, reg
);
1189 /* Relay everything back to the unwinder registered by the JIT debug
1192 static const struct frame_unwind jit_frame_unwind
=
1195 default_frame_unwind_stop_reason
,
1197 jit_frame_prev_register
,
1204 /* This is the information that is stored at jit_gdbarch_data for each
1207 struct jit_gdbarch_data_type
1209 /* Has the (pseudo) unwinder been prepended? */
1210 int unwinder_registered
;
1213 /* Check GDBARCH and prepend the pseudo JIT unwinder if needed. */
1216 jit_prepend_unwinder (struct gdbarch
*gdbarch
)
1218 struct jit_gdbarch_data_type
*data
;
1221 = (struct jit_gdbarch_data_type
*) gdbarch_data (gdbarch
, jit_gdbarch_data
);
1222 if (!data
->unwinder_registered
)
1224 frame_unwind_prepend_unwinder (gdbarch
, &jit_frame_unwind
);
1225 data
->unwinder_registered
= 1;
1229 /* Register any already created translations. */
1232 jit_inferior_init (struct gdbarch
*gdbarch
)
1234 struct jit_descriptor descriptor
;
1235 struct jit_code_entry cur_entry
;
1236 struct jit_program_space_data
*ps_data
;
1237 CORE_ADDR cur_entry_addr
;
1240 fprintf_unfiltered (gdb_stdlog
, "jit_inferior_init\n");
1242 jit_prepend_unwinder (gdbarch
);
1244 ps_data
= get_jit_program_space_data ();
1245 if (!jit_breakpoint_re_set_internal (gdbarch
, ps_data
))
1248 /* There must be a JITer registered, otherwise we would exit early
1250 objfile
*jiter
= ps_data
->objfile
;
1252 /* Read the descriptor so we can check the version number and load
1253 any already JITed functions. */
1254 if (!jit_read_descriptor (gdbarch
, &descriptor
, jiter
))
1257 /* Check that the version number agrees with that we support. */
1258 if (descriptor
.version
!= 1)
1260 printf_unfiltered (_("Unsupported JIT protocol version %ld "
1261 "in descriptor (expected 1)\n"),
1262 (long) descriptor
.version
);
1266 /* If we've attached to a running program, we need to check the descriptor
1267 to register any functions that were already generated. */
1268 for (cur_entry_addr
= descriptor
.first_entry
;
1269 cur_entry_addr
!= 0;
1270 cur_entry_addr
= cur_entry
.next_entry
)
1272 jit_read_code_entry (gdbarch
, cur_entry_addr
, &cur_entry
);
1274 /* This hook may be called many times during setup, so make sure we don't
1275 add the same symbol file twice. */
1276 if (jit_find_objf_with_entry_addr (cur_entry_addr
) != NULL
)
1279 jit_register_code (gdbarch
, cur_entry_addr
, &cur_entry
);
1283 /* inferior_created observer. */
1286 jit_inferior_created (struct target_ops
*ops
, int from_tty
)
1288 jit_inferior_created_hook ();
1291 /* Exported routine to call when an inferior has been created. */
1294 jit_inferior_created_hook (void)
1296 jit_inferior_init (target_gdbarch ());
1299 /* Exported routine to call to re-set the jit breakpoints,
1300 e.g. when a program is rerun. */
1303 jit_breakpoint_re_set (void)
1305 jit_breakpoint_re_set_internal (target_gdbarch (),
1306 get_jit_program_space_data ());
1309 /* This function cleans up any code entries left over when the
1310 inferior exits. We get left over code when the inferior exits
1311 without unregistering its code, for example when it crashes. */
1314 jit_inferior_exit_hook (struct inferior
*inf
)
1316 for (objfile
*objf
: current_program_space
->objfiles_safe ())
1318 if (objf
->jit_data
!= nullptr && objf
->jit_data
->addr
!= 0)
1324 jit_event_handler (gdbarch
*gdbarch
, objfile
*jiter
)
1326 struct jit_descriptor descriptor
;
1327 struct jit_code_entry code_entry
;
1328 CORE_ADDR entry_addr
;
1329 struct objfile
*objf
;
1331 /* Read the descriptor from remote memory. */
1332 if (!jit_read_descriptor (gdbarch
, &descriptor
, jiter
))
1334 entry_addr
= descriptor
.relevant_entry
;
1336 /* Do the corresponding action. */
1337 switch (descriptor
.action_flag
)
1342 jit_read_code_entry (gdbarch
, entry_addr
, &code_entry
);
1343 jit_register_code (gdbarch
, entry_addr
, &code_entry
);
1345 case JIT_UNREGISTER
:
1346 objf
= jit_find_objf_with_entry_addr (entry_addr
);
1348 printf_unfiltered (_("Unable to find JITed code "
1349 "entry at address: %s\n"),
1350 paddress (gdbarch
, entry_addr
));
1356 error (_("Unknown action_flag value in JIT descriptor!"));
1361 /* Initialize the jit_gdbarch_data slot with an instance of struct
1362 jit_gdbarch_data_type */
1365 jit_gdbarch_data_init (struct obstack
*obstack
)
1367 struct jit_gdbarch_data_type
*data
=
1368 XOBNEW (obstack
, struct jit_gdbarch_data_type
);
1370 data
->unwinder_registered
= 0;
1375 void _initialize_jit ();
1379 jit_reader_dir
= relocate_gdb_directory (JIT_READER_DIR
,
1380 JIT_READER_DIR_RELOCATABLE
);
1381 add_setshow_zuinteger_cmd ("jit", class_maintenance
, &jit_debug
,
1382 _("Set JIT debugging."),
1383 _("Show JIT debugging."),
1384 _("When non-zero, JIT debugging is enabled."),
1387 &setdebuglist
, &showdebuglist
);
1389 gdb::observers::inferior_created
.attach (jit_inferior_created
);
1390 gdb::observers::inferior_exit
.attach (jit_inferior_exit_hook
);
1391 gdb::observers::breakpoint_deleted
.attach (jit_breakpoint_deleted
);
1393 jit_gdbarch_data
= gdbarch_data_register_pre_init (jit_gdbarch_data_init
);
1394 if (is_dl_available ())
1396 struct cmd_list_element
*c
;
1398 c
= add_com ("jit-reader-load", no_class
, jit_reader_load_command
, _("\
1399 Load FILE as debug info reader and unwinder for JIT compiled code.\n\
1400 Usage: jit-reader-load FILE\n\
1401 Try to load file FILE as a debug info reader (and unwinder) for\n\
1402 JIT compiled code. The file is loaded from " JIT_READER_DIR
",\n\
1403 relocated relative to the GDB executable if required."));
1404 set_cmd_completer (c
, filename_completer
);
1406 c
= add_com ("jit-reader-unload", no_class
,
1407 jit_reader_unload_command
, _("\
1408 Unload the currently loaded JIT debug info reader.\n\
1409 Usage: jit-reader-unload\n\n\
1410 Do \"help jit-reader-load\" for info on loading debug info readers."));
1411 set_cmd_completer (c
, noop_completer
);