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 /* Destructor for jiter_objfile_data. */
244 jiter_objfile_data::~jiter_objfile_data ()
246 if (this->jit_breakpoint
!= nullptr)
247 delete_breakpoint (this->jit_breakpoint
);
250 /* Fetch the jiter_objfile_data associated with OBJF. If no data exists
251 yet, make a new structure and attach it. */
253 static jiter_objfile_data
*
254 get_jiter_objfile_data (objfile
*objf
)
256 if (objf
->jiter_data
== nullptr)
257 objf
->jiter_data
.reset (new jiter_objfile_data ());
259 return objf
->jiter_data
.get ();
262 /* Remember OBJFILE has been created for struct jit_code_entry located
263 at inferior address ENTRY. */
266 add_objfile_entry (struct objfile
*objfile
, CORE_ADDR entry
)
268 gdb_assert (objfile
->jited_data
== nullptr);
270 objfile
->jited_data
.reset (new jited_objfile_data (entry
));
273 /* Helper function for reading the global JIT descriptor from remote
274 memory. Returns true if all went well, false otherwise. */
277 jit_read_descriptor (gdbarch
*gdbarch
,
278 jit_descriptor
*descriptor
,
282 struct type
*ptr_type
;
286 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
288 gdb_assert (jiter
!= nullptr);
289 jiter_objfile_data
*objf_data
= jiter
->jiter_data
.get ();
290 gdb_assert (objf_data
!= nullptr);
292 CORE_ADDR addr
= MSYMBOL_VALUE_ADDRESS (jiter
, objf_data
->descriptor
);
295 fprintf_unfiltered (gdb_stdlog
,
296 "jit_read_descriptor, descriptor_addr = %s\n",
297 paddress (gdbarch
, addr
));
299 /* Figure out how big the descriptor is on the remote and how to read it. */
300 ptr_type
= builtin_type (gdbarch
)->builtin_data_ptr
;
301 ptr_size
= TYPE_LENGTH (ptr_type
);
302 desc_size
= 8 + 2 * ptr_size
; /* Two 32-bit ints and two pointers. */
303 desc_buf
= (gdb_byte
*) alloca (desc_size
);
305 /* Read the descriptor. */
306 err
= target_read_memory (addr
, desc_buf
, desc_size
);
309 printf_unfiltered (_("Unable to read JIT descriptor from "
314 /* Fix the endianness to match the host. */
315 descriptor
->version
= extract_unsigned_integer (&desc_buf
[0], 4, byte_order
);
316 descriptor
->action_flag
=
317 extract_unsigned_integer (&desc_buf
[4], 4, byte_order
);
318 descriptor
->relevant_entry
= extract_typed_address (&desc_buf
[8], ptr_type
);
319 descriptor
->first_entry
=
320 extract_typed_address (&desc_buf
[8 + ptr_size
], ptr_type
);
325 /* Helper function for reading a JITed code entry from remote memory. */
328 jit_read_code_entry (struct gdbarch
*gdbarch
,
329 CORE_ADDR code_addr
, struct jit_code_entry
*code_entry
)
332 struct type
*ptr_type
;
337 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
339 /* Figure out how big the entry is on the remote and how to read it. */
340 ptr_type
= builtin_type (gdbarch
)->builtin_data_ptr
;
341 ptr_size
= TYPE_LENGTH (ptr_type
);
343 /* Figure out where the uint64_t value will be. */
344 align_bytes
= type_align (builtin_type (gdbarch
)->builtin_uint64
);
346 off
= (off
+ (align_bytes
- 1)) & ~(align_bytes
- 1);
348 entry_size
= off
+ 8; /* Three pointers and one 64-bit int. */
349 entry_buf
= (gdb_byte
*) alloca (entry_size
);
351 /* Read the entry. */
352 err
= target_read_memory (code_addr
, entry_buf
, entry_size
);
354 error (_("Unable to read JIT code entry from remote memory!"));
356 /* Fix the endianness to match the host. */
357 ptr_type
= builtin_type (gdbarch
)->builtin_data_ptr
;
358 code_entry
->next_entry
= extract_typed_address (&entry_buf
[0], ptr_type
);
359 code_entry
->prev_entry
=
360 extract_typed_address (&entry_buf
[ptr_size
], ptr_type
);
361 code_entry
->symfile_addr
=
362 extract_typed_address (&entry_buf
[2 * ptr_size
], ptr_type
);
363 code_entry
->symfile_size
=
364 extract_unsigned_integer (&entry_buf
[off
], 8, byte_order
);
367 /* Proxy object for building a block. */
371 gdb_block (gdb_block
*parent
, CORE_ADDR begin
, CORE_ADDR end
,
376 name (name
!= nullptr ? xstrdup (name
) : nullptr)
379 /* The parent of this block. */
380 struct gdb_block
*parent
;
382 /* Points to the "real" block that is being built out of this
383 instance. This block will be added to a blockvector, which will
384 then be added to a symtab. */
385 struct block
*real_block
= nullptr;
387 /* The first and last code address corresponding to this block. */
388 CORE_ADDR begin
, end
;
390 /* The name of this block (if any). If this is non-NULL, the
391 FUNCTION symbol symbol is set to this value. */
392 gdb::unique_xmalloc_ptr
<char> name
;
395 /* Proxy object for building a symtab. */
399 explicit gdb_symtab (const char *file_name
)
400 : file_name (file_name
!= nullptr ? file_name
: "")
403 /* The list of blocks in this symtab. These will eventually be
404 converted to real blocks.
406 This is specifically a linked list, instead of, for example, a vector,
407 because the pointers are returned to the user's debug info reader. So
408 it's important that the objects don't change location during their
409 lifetime (which would happen with a vector of objects getting resized). */
410 std::forward_list
<gdb_block
> blocks
;
412 /* The number of blocks inserted. */
415 /* A mapping between line numbers to PC. */
416 gdb::unique_xmalloc_ptr
<struct linetable
> linetable
;
418 /* The source file for this symtab. */
419 std::string file_name
;
422 /* Proxy object for building an object. */
426 /* Symtabs of this object.
428 This is specifically a linked list, instead of, for example, a vector,
429 because the pointers are returned to the user's debug info reader. So
430 it's important that the objects don't change location during their
431 lifetime (which would happen with a vector of objects getting resized). */
432 std::forward_list
<gdb_symtab
> symtabs
;
435 /* The type of the `private' data passed around by the callback
438 typedef CORE_ADDR jit_dbg_reader_data
;
440 /* The reader calls into this function to read data off the targets
443 static enum gdb_status
444 jit_target_read_impl (GDB_CORE_ADDR target_mem
, void *gdb_buf
, int len
)
446 int result
= target_read_memory ((CORE_ADDR
) target_mem
,
447 (gdb_byte
*) gdb_buf
, len
);
454 /* The reader calls into this function to create a new gdb_object
455 which it can then pass around to the other callbacks. Right now,
456 all that is required is allocating the memory. */
458 static struct gdb_object
*
459 jit_object_open_impl (struct gdb_symbol_callbacks
*cb
)
461 /* CB is not required right now, but sometime in the future we might
462 need a handle to it, and we'd like to do that without breaking
464 return new gdb_object
;
467 /* Readers call into this function to open a new gdb_symtab, which,
468 again, is passed around to other callbacks. */
470 static struct gdb_symtab
*
471 jit_symtab_open_impl (struct gdb_symbol_callbacks
*cb
,
472 struct gdb_object
*object
,
473 const char *file_name
)
475 /* CB stays unused. See comment in jit_object_open_impl. */
477 object
->symtabs
.emplace_front (file_name
);
478 return &object
->symtabs
.front ();
481 /* Called by readers to open a new gdb_block. This function also
482 inserts the new gdb_block in the correct place in the corresponding
485 static struct gdb_block
*
486 jit_block_open_impl (struct gdb_symbol_callbacks
*cb
,
487 struct gdb_symtab
*symtab
, struct gdb_block
*parent
,
488 GDB_CORE_ADDR begin
, GDB_CORE_ADDR end
, const char *name
)
490 /* Place the block at the beginning of the list, it will be sorted when the
491 symtab is finalized. */
492 symtab
->blocks
.emplace_front (parent
, begin
, end
, name
);
495 return &symtab
->blocks
.front ();
498 /* Readers call this to add a line mapping (from PC to line number) to
502 jit_symtab_line_mapping_add_impl (struct gdb_symbol_callbacks
*cb
,
503 struct gdb_symtab
*stab
, int nlines
,
504 struct gdb_line_mapping
*map
)
512 alloc_len
= sizeof (struct linetable
)
513 + (nlines
- 1) * sizeof (struct linetable_entry
);
514 stab
->linetable
.reset (XNEWVAR (struct linetable
, alloc_len
));
515 stab
->linetable
->nitems
= nlines
;
516 for (i
= 0; i
< nlines
; i
++)
518 stab
->linetable
->item
[i
].pc
= (CORE_ADDR
) map
[i
].pc
;
519 stab
->linetable
->item
[i
].line
= map
[i
].line
;
520 stab
->linetable
->item
[i
].is_stmt
= 1;
524 /* Called by readers to close a gdb_symtab. Does not need to do
525 anything as of now. */
528 jit_symtab_close_impl (struct gdb_symbol_callbacks
*cb
,
529 struct gdb_symtab
*stab
)
531 /* Right now nothing needs to be done here. We may need to do some
532 cleanup here in the future (again, without breaking the plugin
536 /* Transform STAB to a proper symtab, and add it it OBJFILE. */
539 finalize_symtab (struct gdb_symtab
*stab
, struct objfile
*objfile
)
541 struct compunit_symtab
*cust
;
542 size_t blockvector_size
;
543 CORE_ADDR begin
, end
;
544 struct blockvector
*bv
;
546 int actual_nblocks
= FIRST_LOCAL_BLOCK
+ stab
->nblocks
;
548 /* Sort the blocks in the order they should appear in the blockvector. */
549 stab
->blocks
.sort([] (const gdb_block
&a
, const gdb_block
&b
)
551 if (a
.begin
!= b
.begin
)
552 return a
.begin
< b
.begin
;
554 return a
.end
> b
.end
;
557 cust
= allocate_compunit_symtab (objfile
, stab
->file_name
.c_str ());
558 allocate_symtab (cust
, stab
->file_name
.c_str ());
559 add_compunit_symtab_to_objfile (cust
);
561 /* JIT compilers compile in memory. */
562 COMPUNIT_DIRNAME (cust
) = NULL
;
564 /* Copy over the linetable entry if one was provided. */
567 size_t size
= ((stab
->linetable
->nitems
- 1)
568 * sizeof (struct linetable_entry
)
569 + sizeof (struct linetable
));
570 SYMTAB_LINETABLE (COMPUNIT_FILETABS (cust
))
571 = (struct linetable
*) obstack_alloc (&objfile
->objfile_obstack
, size
);
572 memcpy (SYMTAB_LINETABLE (COMPUNIT_FILETABS (cust
)),
573 stab
->linetable
.get (), size
);
576 blockvector_size
= (sizeof (struct blockvector
)
577 + (actual_nblocks
- 1) * sizeof (struct block
*));
578 bv
= (struct blockvector
*) obstack_alloc (&objfile
->objfile_obstack
,
580 COMPUNIT_BLOCKVECTOR (cust
) = bv
;
582 /* At the end of this function, (begin, end) will contain the PC range this
583 entire blockvector spans. */
584 BLOCKVECTOR_MAP (bv
) = NULL
;
585 begin
= stab
->blocks
.front ().begin
;
586 end
= stab
->blocks
.front ().end
;
587 BLOCKVECTOR_NBLOCKS (bv
) = actual_nblocks
;
589 /* First run over all the gdb_block objects, creating a real block
590 object for each. Simultaneously, keep setting the real_block
592 int block_idx
= FIRST_LOCAL_BLOCK
;
593 for (gdb_block
&gdb_block_iter
: stab
->blocks
)
595 struct block
*new_block
= allocate_block (&objfile
->objfile_obstack
);
596 struct symbol
*block_name
= new (&objfile
->objfile_obstack
) symbol
;
597 struct type
*block_type
= arch_type (objfile
->arch (),
602 BLOCK_MULTIDICT (new_block
)
603 = mdict_create_linear (&objfile
->objfile_obstack
, NULL
);
604 /* The address range. */
605 BLOCK_START (new_block
) = (CORE_ADDR
) gdb_block_iter
.begin
;
606 BLOCK_END (new_block
) = (CORE_ADDR
) gdb_block_iter
.end
;
609 SYMBOL_DOMAIN (block_name
) = VAR_DOMAIN
;
610 SYMBOL_ACLASS_INDEX (block_name
) = LOC_BLOCK
;
611 symbol_set_symtab (block_name
, COMPUNIT_FILETABS (cust
));
612 SYMBOL_TYPE (block_name
) = lookup_function_type (block_type
);
613 SYMBOL_BLOCK_VALUE (block_name
) = new_block
;
615 block_name
->m_name
= obstack_strdup (&objfile
->objfile_obstack
,
616 gdb_block_iter
.name
.get ());
618 BLOCK_FUNCTION (new_block
) = block_name
;
620 BLOCKVECTOR_BLOCK (bv
, block_idx
) = new_block
;
621 if (begin
> BLOCK_START (new_block
))
622 begin
= BLOCK_START (new_block
);
623 if (end
< BLOCK_END (new_block
))
624 end
= BLOCK_END (new_block
);
626 gdb_block_iter
.real_block
= new_block
;
631 /* Now add the special blocks. */
632 struct block
*block_iter
= NULL
;
633 for (enum block_enum i
: { GLOBAL_BLOCK
, STATIC_BLOCK
})
635 struct block
*new_block
;
637 new_block
= (i
== GLOBAL_BLOCK
638 ? allocate_global_block (&objfile
->objfile_obstack
)
639 : allocate_block (&objfile
->objfile_obstack
));
640 BLOCK_MULTIDICT (new_block
)
641 = mdict_create_linear (&objfile
->objfile_obstack
, NULL
);
642 BLOCK_SUPERBLOCK (new_block
) = block_iter
;
643 block_iter
= new_block
;
645 BLOCK_START (new_block
) = (CORE_ADDR
) begin
;
646 BLOCK_END (new_block
) = (CORE_ADDR
) end
;
648 BLOCKVECTOR_BLOCK (bv
, i
) = new_block
;
650 if (i
== GLOBAL_BLOCK
)
651 set_block_compunit_symtab (new_block
, cust
);
654 /* Fill up the superblock fields for the real blocks, using the
655 real_block fields populated earlier. */
656 for (gdb_block
&gdb_block_iter
: stab
->blocks
)
658 if (gdb_block_iter
.parent
!= NULL
)
660 /* If the plugin specifically mentioned a parent block, we
662 BLOCK_SUPERBLOCK (gdb_block_iter
.real_block
) =
663 gdb_block_iter
.parent
->real_block
;
667 /* And if not, we set a default parent block. */
668 BLOCK_SUPERBLOCK (gdb_block_iter
.real_block
) =
669 BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
);
674 /* Called when closing a gdb_objfile. Converts OBJ to a proper
678 jit_object_close_impl (struct gdb_symbol_callbacks
*cb
,
679 struct gdb_object
*obj
)
681 struct objfile
*objfile
;
682 jit_dbg_reader_data
*priv_data
;
684 priv_data
= (jit_dbg_reader_data
*) cb
->priv_data
;
686 objfile
= objfile::make (nullptr, "<< JIT compiled code >>",
688 objfile
->per_bfd
->gdbarch
= target_gdbarch ();
690 for (gdb_symtab
&symtab
: obj
->symtabs
)
691 finalize_symtab (&symtab
, objfile
);
693 add_objfile_entry (objfile
, *priv_data
);
698 /* Try to read CODE_ENTRY using the loaded jit reader (if any).
699 ENTRY_ADDR is the address of the struct jit_code_entry in the
700 inferior address space. */
703 jit_reader_try_read_symtab (struct jit_code_entry
*code_entry
,
704 CORE_ADDR entry_addr
)
707 jit_dbg_reader_data priv_data
;
708 struct gdb_reader_funcs
*funcs
;
709 struct gdb_symbol_callbacks callbacks
=
711 jit_object_open_impl
,
712 jit_symtab_open_impl
,
714 jit_symtab_close_impl
,
715 jit_object_close_impl
,
717 jit_symtab_line_mapping_add_impl
,
718 jit_target_read_impl
,
723 priv_data
= entry_addr
;
725 if (!loaded_jit_reader
)
728 gdb::byte_vector
gdb_mem (code_entry
->symfile_size
);
733 if (target_read_memory (code_entry
->symfile_addr
, gdb_mem
.data (),
734 code_entry
->symfile_size
))
737 catch (const gdb_exception
&e
)
744 funcs
= loaded_jit_reader
->functions
;
745 if (funcs
->read (funcs
, &callbacks
, gdb_mem
.data (),
746 code_entry
->symfile_size
)
751 if (jit_debug
&& status
== 0)
752 fprintf_unfiltered (gdb_stdlog
,
753 "Could not read symtab using the loaded JIT reader.\n");
757 /* Try to read CODE_ENTRY using BFD. ENTRY_ADDR is the address of the
758 struct jit_code_entry in the inferior address space. */
761 jit_bfd_try_read_symtab (struct jit_code_entry
*code_entry
,
762 CORE_ADDR entry_addr
,
763 struct gdbarch
*gdbarch
)
765 struct bfd_section
*sec
;
766 struct objfile
*objfile
;
767 const struct bfd_arch_info
*b
;
770 fprintf_unfiltered (gdb_stdlog
,
771 "jit_bfd_try_read_symtab, symfile_addr = %s, "
772 "symfile_size = %s\n",
773 paddress (gdbarch
, code_entry
->symfile_addr
),
774 pulongest (code_entry
->symfile_size
));
776 gdb_bfd_ref_ptr
nbfd (bfd_open_from_target_memory (code_entry
->symfile_addr
,
777 code_entry
->symfile_size
,
781 puts_unfiltered (_("Error opening JITed symbol file, ignoring it.\n"));
785 /* Check the format. NOTE: This initializes important data that GDB uses!
786 We would segfault later without this line. */
787 if (!bfd_check_format (nbfd
.get (), bfd_object
))
789 printf_unfiltered (_("\
790 JITed symbol file is not an object file, ignoring it.\n"));
794 /* Check bfd arch. */
795 b
= gdbarch_bfd_arch_info (gdbarch
);
796 if (b
->compatible (b
, bfd_get_arch_info (nbfd
.get ())) != b
)
797 warning (_("JITed object file architecture %s is not compatible "
798 "with target architecture %s."),
799 bfd_get_arch_info (nbfd
.get ())->printable_name
,
802 /* Read the section address information out of the symbol file. Since the
803 file is generated by the JIT at runtime, it should all of the absolute
804 addresses that we care about. */
805 section_addr_info sai
;
806 for (sec
= nbfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
807 if ((bfd_section_flags (sec
) & (SEC_ALLOC
|SEC_LOAD
)) != 0)
809 /* We assume that these virtual addresses are absolute, and do not
810 treat them as offsets. */
811 sai
.emplace_back (bfd_section_vma (sec
),
812 bfd_section_name (sec
),
816 /* This call does not take ownership of SAI. */
817 objfile
= symbol_file_add_from_bfd (nbfd
.get (),
818 bfd_get_filename (nbfd
.get ()), 0,
820 OBJF_SHARED
| OBJF_NOT_FILENAME
, NULL
);
822 add_objfile_entry (objfile
, entry_addr
);
825 /* This function registers code associated with a JIT code entry. It uses the
826 pointer and size pair in the entry to read the symbol file from the remote
827 and then calls symbol_file_add_from_local_memory to add it as though it were
828 a symbol file added by the user. */
831 jit_register_code (struct gdbarch
*gdbarch
,
832 CORE_ADDR entry_addr
, struct jit_code_entry
*code_entry
)
837 fprintf_unfiltered (gdb_stdlog
,
838 "jit_register_code, symfile_addr = %s, "
839 "symfile_size = %s\n",
840 paddress (gdbarch
, code_entry
->symfile_addr
),
841 pulongest (code_entry
->symfile_size
));
843 success
= jit_reader_try_read_symtab (code_entry
, entry_addr
);
846 jit_bfd_try_read_symtab (code_entry
, entry_addr
, gdbarch
);
849 /* Look up the objfile with this code entry address. */
851 static struct objfile
*
852 jit_find_objf_with_entry_addr (CORE_ADDR entry_addr
)
854 for (objfile
*objf
: current_program_space
->objfiles ())
856 if (objf
->jited_data
!= nullptr && objf
->jited_data
->addr
== entry_addr
)
863 /* This is called when a breakpoint is deleted. It updates the
864 inferior's cache, if needed. */
867 jit_breakpoint_deleted (struct breakpoint
*b
)
869 if (b
->type
!= bp_jit_event
)
872 for (bp_location
*iter
= b
->loc
; iter
!= nullptr; iter
= iter
->next
)
874 for (objfile
*objf
: iter
->pspace
->objfiles ())
876 jiter_objfile_data
*jiter_data
= objf
->jiter_data
.get ();
878 if (jiter_data
!= nullptr
879 && jiter_data
->jit_breakpoint
== iter
->owner
)
881 jiter_data
->cached_code_address
= 0;
882 jiter_data
->jit_breakpoint
= nullptr;
888 /* (Re-)Initialize the jit breakpoints for JIT-producing objfiles in
892 jit_breakpoint_re_set_internal (struct gdbarch
*gdbarch
, program_space
*pspace
)
894 for (objfile
*the_objfile
: pspace
->objfiles ())
896 /* Lookup the registration symbol. If it is missing, then we
897 assume we are not attached to a JIT. */
898 bound_minimal_symbol reg_symbol
899 = lookup_minimal_symbol (jit_break_name
, nullptr, the_objfile
);
900 if (reg_symbol
.minsym
== NULL
901 || BMSYMBOL_VALUE_ADDRESS (reg_symbol
) == 0)
904 bound_minimal_symbol desc_symbol
905 = lookup_minimal_symbol (jit_descriptor_name
, NULL
, the_objfile
);
906 if (desc_symbol
.minsym
== NULL
907 || BMSYMBOL_VALUE_ADDRESS (desc_symbol
) == 0)
910 jiter_objfile_data
*objf_data
911 = get_jiter_objfile_data (reg_symbol
.objfile
);
912 objf_data
->register_code
= reg_symbol
.minsym
;
913 objf_data
->descriptor
= desc_symbol
.minsym
;
915 CORE_ADDR addr
= MSYMBOL_VALUE_ADDRESS (the_objfile
,
916 objf_data
->register_code
);
919 fprintf_unfiltered (gdb_stdlog
,
920 "jit_breakpoint_re_set_internal, "
921 "breakpoint_addr = %s\n",
922 paddress (gdbarch
, addr
));
924 /* Check if we need to re-create the breakpoint. */
925 if (objf_data
->cached_code_address
== addr
)
928 /* Delete the old breakpoint. */
929 if (objf_data
->jit_breakpoint
!= nullptr)
930 delete_breakpoint (objf_data
->jit_breakpoint
);
932 /* Put a breakpoint in the registration symbol. */
933 objf_data
->cached_code_address
= addr
;
934 objf_data
->jit_breakpoint
= create_jit_event_breakpoint (gdbarch
, addr
);
938 /* The private data passed around in the frame unwind callback
941 struct jit_unwind_private
943 /* Cached register values. See jit_frame_sniffer to see how this
945 detached_regcache
*regcache
;
947 /* The frame being unwound. */
948 struct frame_info
*this_frame
;
951 /* Sets the value of a particular register in this frame. */
954 jit_unwind_reg_set_impl (struct gdb_unwind_callbacks
*cb
, int dwarf_regnum
,
955 struct gdb_reg_value
*value
)
957 struct jit_unwind_private
*priv
;
960 priv
= (struct jit_unwind_private
*) cb
->priv_data
;
962 gdb_reg
= gdbarch_dwarf2_reg_to_regnum (get_frame_arch (priv
->this_frame
),
967 fprintf_unfiltered (gdb_stdlog
,
968 _("Could not recognize DWARF regnum %d"),
974 priv
->regcache
->raw_supply (gdb_reg
, value
->value
);
979 reg_value_free_impl (struct gdb_reg_value
*value
)
984 /* Get the value of register REGNUM in the previous frame. */
986 static struct gdb_reg_value
*
987 jit_unwind_reg_get_impl (struct gdb_unwind_callbacks
*cb
, int regnum
)
989 struct jit_unwind_private
*priv
;
990 struct gdb_reg_value
*value
;
992 struct gdbarch
*frame_arch
;
994 priv
= (struct jit_unwind_private
*) cb
->priv_data
;
995 frame_arch
= get_frame_arch (priv
->this_frame
);
997 gdb_reg
= gdbarch_dwarf2_reg_to_regnum (frame_arch
, regnum
);
998 size
= register_size (frame_arch
, gdb_reg
);
999 value
= ((struct gdb_reg_value
*)
1000 xmalloc (sizeof (struct gdb_reg_value
) + size
- 1));
1001 value
->defined
= deprecated_frame_register_read (priv
->this_frame
, gdb_reg
,
1004 value
->free
= reg_value_free_impl
;
1008 /* gdb_reg_value has a free function, which must be called on each
1009 saved register value. */
1012 jit_dealloc_cache (struct frame_info
*this_frame
, void *cache
)
1014 struct jit_unwind_private
*priv_data
= (struct jit_unwind_private
*) cache
;
1016 gdb_assert (priv_data
->regcache
!= NULL
);
1017 delete priv_data
->regcache
;
1021 /* The frame sniffer for the pseudo unwinder.
1023 While this is nominally a frame sniffer, in the case where the JIT
1024 reader actually recognizes the frame, it does a lot more work -- it
1025 unwinds the frame and saves the corresponding register values in
1026 the cache. jit_frame_prev_register simply returns the saved
1030 jit_frame_sniffer (const struct frame_unwind
*self
,
1031 struct frame_info
*this_frame
, void **cache
)
1033 struct jit_unwind_private
*priv_data
;
1034 struct gdb_unwind_callbacks callbacks
;
1035 struct gdb_reader_funcs
*funcs
;
1037 callbacks
.reg_get
= jit_unwind_reg_get_impl
;
1038 callbacks
.reg_set
= jit_unwind_reg_set_impl
;
1039 callbacks
.target_read
= jit_target_read_impl
;
1041 if (loaded_jit_reader
== NULL
)
1044 funcs
= loaded_jit_reader
->functions
;
1046 gdb_assert (!*cache
);
1048 *cache
= XCNEW (struct jit_unwind_private
);
1049 priv_data
= (struct jit_unwind_private
*) *cache
;
1050 /* Take a snapshot of current regcache. */
1051 priv_data
->regcache
= new detached_regcache (get_frame_arch (this_frame
),
1053 priv_data
->this_frame
= this_frame
;
1055 callbacks
.priv_data
= priv_data
;
1057 /* Try to coax the provided unwinder to unwind the stack */
1058 if (funcs
->unwind (funcs
, &callbacks
) == GDB_SUCCESS
)
1061 fprintf_unfiltered (gdb_stdlog
, _("Successfully unwound frame using "
1066 fprintf_unfiltered (gdb_stdlog
, _("Could not unwind frame using "
1069 jit_dealloc_cache (this_frame
, *cache
);
1076 /* The frame_id function for the pseudo unwinder. Relays the call to
1077 the loaded plugin. */
1080 jit_frame_this_id (struct frame_info
*this_frame
, void **cache
,
1081 struct frame_id
*this_id
)
1083 struct jit_unwind_private priv
;
1084 struct gdb_frame_id frame_id
;
1085 struct gdb_reader_funcs
*funcs
;
1086 struct gdb_unwind_callbacks callbacks
;
1088 priv
.regcache
= NULL
;
1089 priv
.this_frame
= this_frame
;
1091 /* We don't expect the frame_id function to set any registers, so we
1092 set reg_set to NULL. */
1093 callbacks
.reg_get
= jit_unwind_reg_get_impl
;
1094 callbacks
.reg_set
= NULL
;
1095 callbacks
.target_read
= jit_target_read_impl
;
1096 callbacks
.priv_data
= &priv
;
1098 gdb_assert (loaded_jit_reader
);
1099 funcs
= loaded_jit_reader
->functions
;
1101 frame_id
= funcs
->get_frame_id (funcs
, &callbacks
);
1102 *this_id
= frame_id_build (frame_id
.stack_address
, frame_id
.code_address
);
1105 /* Pseudo unwinder function. Reads the previously fetched value for
1106 the register from the cache. */
1108 static struct value
*
1109 jit_frame_prev_register (struct frame_info
*this_frame
, void **cache
, int reg
)
1111 struct jit_unwind_private
*priv
= (struct jit_unwind_private
*) *cache
;
1112 struct gdbarch
*gdbarch
;
1115 return frame_unwind_got_optimized (this_frame
, reg
);
1117 gdbarch
= priv
->regcache
->arch ();
1118 gdb_byte
*buf
= (gdb_byte
*) alloca (register_size (gdbarch
, reg
));
1119 enum register_status status
= priv
->regcache
->cooked_read (reg
, buf
);
1121 if (status
== REG_VALID
)
1122 return frame_unwind_got_bytes (this_frame
, reg
, buf
);
1124 return frame_unwind_got_optimized (this_frame
, reg
);
1127 /* Relay everything back to the unwinder registered by the JIT debug
1130 static const struct frame_unwind jit_frame_unwind
=
1133 default_frame_unwind_stop_reason
,
1135 jit_frame_prev_register
,
1142 /* This is the information that is stored at jit_gdbarch_data for each
1145 struct jit_gdbarch_data_type
1147 /* Has the (pseudo) unwinder been prepended? */
1148 int unwinder_registered
;
1151 /* Check GDBARCH and prepend the pseudo JIT unwinder if needed. */
1154 jit_prepend_unwinder (struct gdbarch
*gdbarch
)
1156 struct jit_gdbarch_data_type
*data
;
1159 = (struct jit_gdbarch_data_type
*) gdbarch_data (gdbarch
, jit_gdbarch_data
);
1160 if (!data
->unwinder_registered
)
1162 frame_unwind_prepend_unwinder (gdbarch
, &jit_frame_unwind
);
1163 data
->unwinder_registered
= 1;
1167 /* Register any already created translations. */
1170 jit_inferior_init (struct gdbarch
*gdbarch
)
1172 struct jit_descriptor descriptor
;
1173 struct jit_code_entry cur_entry
;
1174 CORE_ADDR cur_entry_addr
;
1177 fprintf_unfiltered (gdb_stdlog
, "jit_inferior_init\n");
1179 jit_prepend_unwinder (gdbarch
);
1181 jit_breakpoint_re_set_internal (gdbarch
, current_program_space
);
1183 for (objfile
*jiter
: current_program_space
->objfiles ())
1185 if (jiter
->jiter_data
== nullptr)
1188 /* Read the descriptor so we can check the version number and load
1189 any already JITed functions. */
1190 if (!jit_read_descriptor (gdbarch
, &descriptor
, jiter
))
1193 /* Check that the version number agrees with that we support. */
1194 if (descriptor
.version
!= 1)
1196 printf_unfiltered (_("Unsupported JIT protocol version %ld "
1197 "in descriptor (expected 1)\n"),
1198 (long) descriptor
.version
);
1202 /* If we've attached to a running program, we need to check the
1203 descriptor to register any functions that were already
1205 for (cur_entry_addr
= descriptor
.first_entry
;
1206 cur_entry_addr
!= 0;
1207 cur_entry_addr
= cur_entry
.next_entry
)
1209 jit_read_code_entry (gdbarch
, cur_entry_addr
, &cur_entry
);
1211 /* This hook may be called many times during setup, so make sure
1212 we don't add the same symbol file twice. */
1213 if (jit_find_objf_with_entry_addr (cur_entry_addr
) != NULL
)
1216 jit_register_code (gdbarch
, cur_entry_addr
, &cur_entry
);
1221 /* inferior_created observer. */
1224 jit_inferior_created (struct target_ops
*ops
, int from_tty
)
1226 jit_inferior_created_hook ();
1229 /* Exported routine to call when an inferior has been created. */
1232 jit_inferior_created_hook (void)
1234 jit_inferior_init (target_gdbarch ());
1237 /* Exported routine to call to re-set the jit breakpoints,
1238 e.g. when a program is rerun. */
1241 jit_breakpoint_re_set (void)
1243 jit_breakpoint_re_set_internal (target_gdbarch (), current_program_space
);
1246 /* This function cleans up any code entries left over when the
1247 inferior exits. We get left over code when the inferior exits
1248 without unregistering its code, for example when it crashes. */
1251 jit_inferior_exit_hook (struct inferior
*inf
)
1253 for (objfile
*objf
: current_program_space
->objfiles_safe ())
1255 if (objf
->jited_data
!= nullptr && objf
->jited_data
->addr
!= 0)
1261 jit_event_handler (gdbarch
*gdbarch
, objfile
*jiter
)
1263 struct jit_descriptor descriptor
;
1265 /* If we get a JIT breakpoint event for this objfile, it is necessarily a
1267 gdb_assert (jiter
->jiter_data
!= nullptr);
1269 /* Read the descriptor from remote memory. */
1270 if (!jit_read_descriptor (gdbarch
, &descriptor
, jiter
))
1272 CORE_ADDR entry_addr
= descriptor
.relevant_entry
;
1274 /* Do the corresponding action. */
1275 switch (descriptor
.action_flag
)
1282 jit_code_entry code_entry
;
1283 jit_read_code_entry (gdbarch
, entry_addr
, &code_entry
);
1284 jit_register_code (gdbarch
, entry_addr
, &code_entry
);
1288 case JIT_UNREGISTER
:
1290 objfile
*jited
= jit_find_objf_with_entry_addr (entry_addr
);
1291 if (jited
== nullptr)
1292 printf_unfiltered (_("Unable to find JITed code "
1293 "entry at address: %s\n"),
1294 paddress (gdbarch
, entry_addr
));
1302 error (_("Unknown action_flag value in JIT descriptor!"));
1307 /* Initialize the jit_gdbarch_data slot with an instance of struct
1308 jit_gdbarch_data_type */
1311 jit_gdbarch_data_init (struct obstack
*obstack
)
1313 struct jit_gdbarch_data_type
*data
=
1314 XOBNEW (obstack
, struct jit_gdbarch_data_type
);
1316 data
->unwinder_registered
= 0;
1321 void _initialize_jit ();
1325 jit_reader_dir
= relocate_gdb_directory (JIT_READER_DIR
,
1326 JIT_READER_DIR_RELOCATABLE
);
1327 add_setshow_zuinteger_cmd ("jit", class_maintenance
, &jit_debug
,
1328 _("Set JIT debugging."),
1329 _("Show JIT debugging."),
1330 _("When non-zero, JIT debugging is enabled."),
1333 &setdebuglist
, &showdebuglist
);
1335 gdb::observers::inferior_created
.attach (jit_inferior_created
);
1336 gdb::observers::inferior_exit
.attach (jit_inferior_exit_hook
);
1337 gdb::observers::breakpoint_deleted
.attach (jit_breakpoint_deleted
);
1339 jit_gdbarch_data
= gdbarch_data_register_pre_init (jit_gdbarch_data_init
);
1340 if (is_dl_available ())
1342 struct cmd_list_element
*c
;
1344 c
= add_com ("jit-reader-load", no_class
, jit_reader_load_command
, _("\
1345 Load FILE as debug info reader and unwinder for JIT compiled code.\n\
1346 Usage: jit-reader-load FILE\n\
1347 Try to load file FILE as a debug info reader (and unwinder) for\n\
1348 JIT compiled code. The file is loaded from " JIT_READER_DIR
",\n\
1349 relocated relative to the GDB executable if required."));
1350 set_cmd_completer (c
, filename_completer
);
1352 c
= add_com ("jit-reader-unload", no_class
,
1353 jit_reader_unload_command
, _("\
1354 Unload the currently loaded JIT debug info reader.\n\
1355 Usage: jit-reader-unload\n\n\
1356 Do \"help jit-reader-load\" for info on loading debug info readers."));
1357 set_cmd_completer (c
, noop_completer
);