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"
45 static std::string jit_reader_dir
;
47 static const struct objfile_data
*jit_objfile_data
;
49 static const char *const jit_break_name
= "__jit_debug_register_code";
51 static const char *const jit_descriptor_name
= "__jit_debug_descriptor";
53 static void jit_inferior_init (struct gdbarch
*gdbarch
);
54 static void jit_inferior_exit_hook (struct inferior
*inf
);
56 /* An unwinder is registered for every gdbarch. This key is used to
57 remember if the unwinder has been registered for a particular
60 static struct gdbarch_data
*jit_gdbarch_data
;
62 /* Non-zero if we want to see trace of jit level stuff. */
64 static unsigned int jit_debug
= 0;
67 show_jit_debug (struct ui_file
*file
, int from_tty
,
68 struct cmd_list_element
*c
, const char *value
)
70 fprintf_filtered (file
, _("JIT debugging is %s.\n"), value
);
79 /* Opening the file is a no-op. */
82 mem_bfd_iovec_open (struct bfd
*abfd
, void *open_closure
)
87 /* Closing the file is just freeing the base/size pair on our side. */
90 mem_bfd_iovec_close (struct bfd
*abfd
, void *stream
)
94 /* Zero means success. */
98 /* For reading the file, we just need to pass through to target_read_memory and
99 fix up the arguments and return values. */
102 mem_bfd_iovec_pread (struct bfd
*abfd
, void *stream
, void *buf
,
103 file_ptr nbytes
, file_ptr offset
)
106 struct target_buffer
*buffer
= (struct target_buffer
*) stream
;
108 /* If this read will read all of the file, limit it to just the rest. */
109 if (offset
+ nbytes
> buffer
->size
)
110 nbytes
= buffer
->size
- offset
;
112 /* If there are no more bytes left, we've reached EOF. */
116 err
= target_read_memory (buffer
->base
+ offset
, (gdb_byte
*) buf
, nbytes
);
123 /* For statting the file, we only support the st_size attribute. */
126 mem_bfd_iovec_stat (struct bfd
*abfd
, void *stream
, struct stat
*sb
)
128 struct target_buffer
*buffer
= (struct target_buffer
*) stream
;
130 memset (sb
, 0, sizeof (struct stat
));
131 sb
->st_size
= buffer
->size
;
135 /* Open a BFD from the target's memory. */
137 static gdb_bfd_ref_ptr
138 bfd_open_from_target_memory (CORE_ADDR addr
, ULONGEST size
, char *target
)
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 /* Per-objfile structure recording the addresses in the program space.
267 This object serves two purposes: for ordinary objfiles, it may
268 cache some symbols related to the JIT interface; and for
269 JIT-created objfiles, it holds some information about the
272 struct jit_objfile_data
274 /* Symbol for __jit_debug_register_code. */
275 struct minimal_symbol
*register_code
;
277 /* Symbol for __jit_debug_descriptor. */
278 struct minimal_symbol
*descriptor
;
280 /* Address of struct jit_code_entry in this objfile. This is only
281 non-zero for objfiles that represent code created by the JIT. */
285 /* Fetch the jit_objfile_data associated with OBJF. If no data exists
286 yet, make a new structure and attach it. */
288 static struct jit_objfile_data
*
289 get_jit_objfile_data (struct objfile
*objf
)
291 struct jit_objfile_data
*objf_data
;
293 objf_data
= (struct jit_objfile_data
*) objfile_data (objf
, jit_objfile_data
);
294 if (objf_data
== NULL
)
296 objf_data
= XCNEW (struct jit_objfile_data
);
297 set_objfile_data (objf
, jit_objfile_data
, objf_data
);
303 /* Remember OBJFILE has been created for struct jit_code_entry located
304 at inferior address ENTRY. */
307 add_objfile_entry (struct objfile
*objfile
, CORE_ADDR entry
)
309 struct jit_objfile_data
*objf_data
;
311 objf_data
= get_jit_objfile_data (objfile
);
312 objf_data
->addr
= entry
;
315 /* Return jit_program_space_data for current program space. Allocate
316 if not already present. */
318 static struct jit_program_space_data
*
319 get_jit_program_space_data ()
321 struct jit_program_space_data
*ps_data
;
323 ps_data
= jit_program_space_key
.get (current_program_space
);
325 ps_data
= jit_program_space_key
.emplace (current_program_space
);
329 /* Helper function for reading the global JIT descriptor from remote
330 memory. Returns 1 if all went well, 0 otherwise. */
333 jit_read_descriptor (struct gdbarch
*gdbarch
,
334 struct jit_descriptor
*descriptor
,
335 struct jit_program_space_data
*ps_data
)
338 struct type
*ptr_type
;
342 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
343 struct jit_objfile_data
*objf_data
;
345 if (ps_data
->objfile
== NULL
)
347 objf_data
= get_jit_objfile_data (ps_data
->objfile
);
348 if (objf_data
->descriptor
== NULL
)
352 fprintf_unfiltered (gdb_stdlog
,
353 "jit_read_descriptor, descriptor_addr = %s\n",
354 paddress (gdbarch
, MSYMBOL_VALUE_ADDRESS (ps_data
->objfile
,
355 objf_data
->descriptor
)));
357 /* Figure out how big the descriptor is on the remote and how to read it. */
358 ptr_type
= builtin_type (gdbarch
)->builtin_data_ptr
;
359 ptr_size
= TYPE_LENGTH (ptr_type
);
360 desc_size
= 8 + 2 * ptr_size
; /* Two 32-bit ints and two pointers. */
361 desc_buf
= (gdb_byte
*) alloca (desc_size
);
363 /* Read the descriptor. */
364 err
= target_read_memory (MSYMBOL_VALUE_ADDRESS (ps_data
->objfile
,
365 objf_data
->descriptor
),
366 desc_buf
, desc_size
);
369 printf_unfiltered (_("Unable to read JIT descriptor from "
374 /* Fix the endianness to match the host. */
375 descriptor
->version
= extract_unsigned_integer (&desc_buf
[0], 4, byte_order
);
376 descriptor
->action_flag
=
377 extract_unsigned_integer (&desc_buf
[4], 4, byte_order
);
378 descriptor
->relevant_entry
= extract_typed_address (&desc_buf
[8], ptr_type
);
379 descriptor
->first_entry
=
380 extract_typed_address (&desc_buf
[8 + ptr_size
], ptr_type
);
385 /* Helper function for reading a JITed code entry from remote memory. */
388 jit_read_code_entry (struct gdbarch
*gdbarch
,
389 CORE_ADDR code_addr
, struct jit_code_entry
*code_entry
)
392 struct type
*ptr_type
;
397 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
399 /* Figure out how big the entry is on the remote and how to read it. */
400 ptr_type
= builtin_type (gdbarch
)->builtin_data_ptr
;
401 ptr_size
= TYPE_LENGTH (ptr_type
);
403 /* Figure out where the uint64_t value will be. */
404 align_bytes
= type_align (builtin_type (gdbarch
)->builtin_uint64
);
406 off
= (off
+ (align_bytes
- 1)) & ~(align_bytes
- 1);
408 entry_size
= off
+ 8; /* Three pointers and one 64-bit int. */
409 entry_buf
= (gdb_byte
*) alloca (entry_size
);
411 /* Read the entry. */
412 err
= target_read_memory (code_addr
, entry_buf
, entry_size
);
414 error (_("Unable to read JIT code entry from remote memory!"));
416 /* Fix the endianness to match the host. */
417 ptr_type
= builtin_type (gdbarch
)->builtin_data_ptr
;
418 code_entry
->next_entry
= extract_typed_address (&entry_buf
[0], ptr_type
);
419 code_entry
->prev_entry
=
420 extract_typed_address (&entry_buf
[ptr_size
], ptr_type
);
421 code_entry
->symfile_addr
=
422 extract_typed_address (&entry_buf
[2 * ptr_size
], ptr_type
);
423 code_entry
->symfile_size
=
424 extract_unsigned_integer (&entry_buf
[off
], 8, byte_order
);
427 /* Proxy object for building a block. */
431 /* gdb_blocks are linked into a tree structure. Next points to the
432 next node at the same depth as this block and parent to the
434 struct gdb_block
*next
, *parent
;
436 /* Points to the "real" block that is being built out of this
437 instance. This block will be added to a blockvector, which will
438 then be added to a symtab. */
439 struct block
*real_block
;
441 /* The first and last code address corresponding to this block. */
442 CORE_ADDR begin
, end
;
444 /* The name of this block (if any). If this is non-NULL, the
445 FUNCTION symbol symbol is set to this value. */
449 /* Proxy object for building a symtab. */
453 explicit gdb_symtab (const char *file_name
)
454 : file_name (file_name
!= nullptr ? file_name
: "")
459 gdb_block
*gdb_block_iter
, *gdb_block_iter_tmp
;
461 for ((gdb_block_iter
= this->blocks
,
462 gdb_block_iter_tmp
= gdb_block_iter
->next
);
464 gdb_block_iter
= gdb_block_iter_tmp
)
466 gdb_block_iter_tmp
= gdb_block_iter
->next
;
467 xfree ((void *) gdb_block_iter
->name
);
468 xfree (gdb_block_iter
);
472 /* The list of blocks in this symtab. These will eventually be
473 converted to real blocks. */
474 struct gdb_block
*blocks
= nullptr;
476 /* The number of blocks inserted. */
479 /* A mapping between line numbers to PC. */
480 gdb::unique_xmalloc_ptr
<struct linetable
> linetable
;
482 /* The source file for this symtab. */
483 std::string file_name
;
485 struct gdb_symtab
*next
= nullptr;
488 /* Proxy object for building an object. */
492 struct gdb_symtab
*symtabs
;
495 /* The type of the `private' data passed around by the callback
498 typedef CORE_ADDR jit_dbg_reader_data
;
500 /* The reader calls into this function to read data off the targets
503 static enum gdb_status
504 jit_target_read_impl (GDB_CORE_ADDR target_mem
, void *gdb_buf
, int len
)
506 int result
= target_read_memory ((CORE_ADDR
) target_mem
,
507 (gdb_byte
*) gdb_buf
, len
);
514 /* The reader calls into this function to create a new gdb_object
515 which it can then pass around to the other callbacks. Right now,
516 all that is required is allocating the memory. */
518 static struct gdb_object
*
519 jit_object_open_impl (struct gdb_symbol_callbacks
*cb
)
521 /* CB is not required right now, but sometime in the future we might
522 need a handle to it, and we'd like to do that without breaking
524 return XCNEW (struct gdb_object
);
527 /* Readers call into this function to open a new gdb_symtab, which,
528 again, is passed around to other callbacks. */
530 static struct gdb_symtab
*
531 jit_symtab_open_impl (struct gdb_symbol_callbacks
*cb
,
532 struct gdb_object
*object
,
533 const char *file_name
)
535 /* CB stays unused. See comment in jit_object_open_impl. */
537 gdb_symtab
*ret
= new gdb_symtab (file_name
);
538 ret
->next
= object
->symtabs
;
539 object
->symtabs
= ret
;
543 /* Returns true if the block corresponding to old should be placed
544 before the block corresponding to new in the final blockvector. */
547 compare_block (const struct gdb_block
*const old
,
548 const struct gdb_block
*const newobj
)
552 if (old
->begin
< newobj
->begin
)
554 else if (old
->begin
== newobj
->begin
)
556 if (old
->end
> newobj
->end
)
565 /* Called by readers to open a new gdb_block. This function also
566 inserts the new gdb_block in the correct place in the corresponding
569 static struct gdb_block
*
570 jit_block_open_impl (struct gdb_symbol_callbacks
*cb
,
571 struct gdb_symtab
*symtab
, struct gdb_block
*parent
,
572 GDB_CORE_ADDR begin
, GDB_CORE_ADDR end
, const char *name
)
574 struct gdb_block
*block
= XCNEW (struct gdb_block
);
576 block
->next
= symtab
->blocks
;
577 block
->begin
= (CORE_ADDR
) begin
;
578 block
->end
= (CORE_ADDR
) end
;
579 block
->name
= name
? xstrdup (name
) : NULL
;
580 block
->parent
= parent
;
582 /* Ensure that the blocks are inserted in the correct (reverse of
583 the order expected by blockvector). */
584 if (compare_block (symtab
->blocks
, block
))
586 symtab
->blocks
= block
;
590 struct gdb_block
*i
= symtab
->blocks
;
594 /* Guaranteed to terminate, since compare_block (NULL, _)
596 if (compare_block (i
->next
, block
))
598 block
->next
= i
->next
;
609 /* Readers call this to add a line mapping (from PC to line number) to
613 jit_symtab_line_mapping_add_impl (struct gdb_symbol_callbacks
*cb
,
614 struct gdb_symtab
*stab
, int nlines
,
615 struct gdb_line_mapping
*map
)
623 alloc_len
= sizeof (struct linetable
)
624 + (nlines
- 1) * sizeof (struct linetable_entry
);
625 stab
->linetable
.reset (XNEWVAR (struct linetable
, alloc_len
));
626 stab
->linetable
->nitems
= nlines
;
627 for (i
= 0; i
< nlines
; i
++)
629 stab
->linetable
->item
[i
].pc
= (CORE_ADDR
) map
[i
].pc
;
630 stab
->linetable
->item
[i
].line
= map
[i
].line
;
634 /* Called by readers to close a gdb_symtab. Does not need to do
635 anything as of now. */
638 jit_symtab_close_impl (struct gdb_symbol_callbacks
*cb
,
639 struct gdb_symtab
*stab
)
641 /* Right now nothing needs to be done here. We may need to do some
642 cleanup here in the future (again, without breaking the plugin
646 /* Transform STAB to a proper symtab, and add it it OBJFILE. */
649 finalize_symtab (struct gdb_symtab
*stab
, struct objfile
*objfile
)
651 struct compunit_symtab
*cust
;
652 struct gdb_block
*gdb_block_iter
;
653 struct block
*block_iter
;
654 int actual_nblocks
, i
;
655 size_t blockvector_size
;
656 CORE_ADDR begin
, end
;
657 struct blockvector
*bv
;
659 actual_nblocks
= FIRST_LOCAL_BLOCK
+ stab
->nblocks
;
661 cust
= allocate_compunit_symtab (objfile
, stab
->file_name
.c_str ());
662 allocate_symtab (cust
, stab
->file_name
.c_str ());
663 add_compunit_symtab_to_objfile (cust
);
665 /* JIT compilers compile in memory. */
666 COMPUNIT_DIRNAME (cust
) = NULL
;
668 /* Copy over the linetable entry if one was provided. */
671 size_t size
= ((stab
->linetable
->nitems
- 1)
672 * sizeof (struct linetable_entry
)
673 + sizeof (struct linetable
));
674 SYMTAB_LINETABLE (COMPUNIT_FILETABS (cust
))
675 = (struct linetable
*) obstack_alloc (&objfile
->objfile_obstack
, size
);
676 memcpy (SYMTAB_LINETABLE (COMPUNIT_FILETABS (cust
)),
677 stab
->linetable
.get (), size
);
680 blockvector_size
= (sizeof (struct blockvector
)
681 + (actual_nblocks
- 1) * sizeof (struct block
*));
682 bv
= (struct blockvector
*) obstack_alloc (&objfile
->objfile_obstack
,
684 COMPUNIT_BLOCKVECTOR (cust
) = bv
;
686 /* (begin, end) will contain the PC range this entire blockvector
688 BLOCKVECTOR_MAP (bv
) = NULL
;
689 begin
= stab
->blocks
->begin
;
690 end
= stab
->blocks
->end
;
691 BLOCKVECTOR_NBLOCKS (bv
) = actual_nblocks
;
693 /* First run over all the gdb_block objects, creating a real block
694 object for each. Simultaneously, keep setting the real_block
696 for (i
= (actual_nblocks
- 1), gdb_block_iter
= stab
->blocks
;
697 i
>= FIRST_LOCAL_BLOCK
;
698 i
--, gdb_block_iter
= gdb_block_iter
->next
)
700 struct block
*new_block
= allocate_block (&objfile
->objfile_obstack
);
701 struct symbol
*block_name
= allocate_symbol (objfile
);
702 struct type
*block_type
= arch_type (get_objfile_arch (objfile
),
707 BLOCK_MULTIDICT (new_block
)
708 = mdict_create_linear (&objfile
->objfile_obstack
, NULL
);
709 /* The address range. */
710 BLOCK_START (new_block
) = (CORE_ADDR
) gdb_block_iter
->begin
;
711 BLOCK_END (new_block
) = (CORE_ADDR
) gdb_block_iter
->end
;
714 SYMBOL_DOMAIN (block_name
) = VAR_DOMAIN
;
715 SYMBOL_ACLASS_INDEX (block_name
) = LOC_BLOCK
;
716 symbol_set_symtab (block_name
, COMPUNIT_FILETABS (cust
));
717 SYMBOL_TYPE (block_name
) = lookup_function_type (block_type
);
718 SYMBOL_BLOCK_VALUE (block_name
) = new_block
;
720 block_name
->name
= obstack_strdup (&objfile
->objfile_obstack
,
721 gdb_block_iter
->name
);
723 BLOCK_FUNCTION (new_block
) = block_name
;
725 BLOCKVECTOR_BLOCK (bv
, i
) = new_block
;
726 if (begin
> BLOCK_START (new_block
))
727 begin
= BLOCK_START (new_block
);
728 if (end
< BLOCK_END (new_block
))
729 end
= BLOCK_END (new_block
);
731 gdb_block_iter
->real_block
= new_block
;
734 /* Now add the special blocks. */
736 for (i
= 0; i
< FIRST_LOCAL_BLOCK
; i
++)
738 struct block
*new_block
;
740 new_block
= (i
== GLOBAL_BLOCK
741 ? allocate_global_block (&objfile
->objfile_obstack
)
742 : allocate_block (&objfile
->objfile_obstack
));
743 BLOCK_MULTIDICT (new_block
)
744 = mdict_create_linear (&objfile
->objfile_obstack
, NULL
);
745 BLOCK_SUPERBLOCK (new_block
) = block_iter
;
746 block_iter
= new_block
;
748 BLOCK_START (new_block
) = (CORE_ADDR
) begin
;
749 BLOCK_END (new_block
) = (CORE_ADDR
) end
;
751 BLOCKVECTOR_BLOCK (bv
, i
) = new_block
;
753 if (i
== GLOBAL_BLOCK
)
754 set_block_compunit_symtab (new_block
, cust
);
757 /* Fill up the superblock fields for the real blocks, using the
758 real_block fields populated earlier. */
759 for (gdb_block_iter
= stab
->blocks
;
761 gdb_block_iter
= gdb_block_iter
->next
)
763 if (gdb_block_iter
->parent
!= NULL
)
765 /* If the plugin specifically mentioned a parent block, we
767 BLOCK_SUPERBLOCK (gdb_block_iter
->real_block
) =
768 gdb_block_iter
->parent
->real_block
;
772 /* And if not, we set a default parent block. */
773 BLOCK_SUPERBLOCK (gdb_block_iter
->real_block
) =
774 BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
);
781 /* Called when closing a gdb_objfile. Converts OBJ to a proper
785 jit_object_close_impl (struct gdb_symbol_callbacks
*cb
,
786 struct gdb_object
*obj
)
788 struct gdb_symtab
*i
, *j
;
789 struct objfile
*objfile
;
790 jit_dbg_reader_data
*priv_data
;
792 priv_data
= (jit_dbg_reader_data
*) cb
->priv_data
;
794 objfile
= objfile::make (nullptr, "<< JIT compiled code >>",
796 objfile
->per_bfd
->gdbarch
= target_gdbarch ();
799 for (i
= obj
->symtabs
; i
; i
= j
)
802 finalize_symtab (i
, objfile
);
804 add_objfile_entry (objfile
, *priv_data
);
808 /* Try to read CODE_ENTRY using the loaded jit reader (if any).
809 ENTRY_ADDR is the address of the struct jit_code_entry in the
810 inferior address space. */
813 jit_reader_try_read_symtab (struct jit_code_entry
*code_entry
,
814 CORE_ADDR entry_addr
)
817 jit_dbg_reader_data priv_data
;
818 struct gdb_reader_funcs
*funcs
;
819 struct gdb_symbol_callbacks callbacks
=
821 jit_object_open_impl
,
822 jit_symtab_open_impl
,
824 jit_symtab_close_impl
,
825 jit_object_close_impl
,
827 jit_symtab_line_mapping_add_impl
,
828 jit_target_read_impl
,
833 priv_data
= entry_addr
;
835 if (!loaded_jit_reader
)
838 gdb::byte_vector
gdb_mem (code_entry
->symfile_size
);
843 if (target_read_memory (code_entry
->symfile_addr
, gdb_mem
.data (),
844 code_entry
->symfile_size
))
847 catch (const gdb_exception
&e
)
854 funcs
= loaded_jit_reader
->functions
;
855 if (funcs
->read (funcs
, &callbacks
, gdb_mem
.data (),
856 code_entry
->symfile_size
)
861 if (jit_debug
&& status
== 0)
862 fprintf_unfiltered (gdb_stdlog
,
863 "Could not read symtab using the loaded JIT reader.\n");
867 /* Try to read CODE_ENTRY using BFD. ENTRY_ADDR is the address of the
868 struct jit_code_entry in the inferior address space. */
871 jit_bfd_try_read_symtab (struct jit_code_entry
*code_entry
,
872 CORE_ADDR entry_addr
,
873 struct gdbarch
*gdbarch
)
875 struct bfd_section
*sec
;
876 struct objfile
*objfile
;
877 const struct bfd_arch_info
*b
;
880 fprintf_unfiltered (gdb_stdlog
,
881 "jit_bfd_try_read_symtab, symfile_addr = %s, "
882 "symfile_size = %s\n",
883 paddress (gdbarch
, code_entry
->symfile_addr
),
884 pulongest (code_entry
->symfile_size
));
886 gdb_bfd_ref_ptr
nbfd (bfd_open_from_target_memory (code_entry
->symfile_addr
,
887 code_entry
->symfile_size
,
891 puts_unfiltered (_("Error opening JITed symbol file, ignoring it.\n"));
895 /* Check the format. NOTE: This initializes important data that GDB uses!
896 We would segfault later without this line. */
897 if (!bfd_check_format (nbfd
.get (), bfd_object
))
899 printf_unfiltered (_("\
900 JITed symbol file is not an object file, ignoring it.\n"));
904 /* Check bfd arch. */
905 b
= gdbarch_bfd_arch_info (gdbarch
);
906 if (b
->compatible (b
, bfd_get_arch_info (nbfd
.get ())) != b
)
907 warning (_("JITed object file architecture %s is not compatible "
908 "with target architecture %s."),
909 bfd_get_arch_info (nbfd
.get ())->printable_name
,
912 /* Read the section address information out of the symbol file. Since the
913 file is generated by the JIT at runtime, it should all of the absolute
914 addresses that we care about. */
915 section_addr_info sai
;
916 for (sec
= nbfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
917 if ((bfd_section_flags (sec
) & (SEC_ALLOC
|SEC_LOAD
)) != 0)
919 /* We assume that these virtual addresses are absolute, and do not
920 treat them as offsets. */
921 sai
.emplace_back (bfd_section_vma (sec
),
922 bfd_section_name (sec
),
926 /* This call does not take ownership of SAI. */
927 objfile
= symbol_file_add_from_bfd (nbfd
.get (),
928 bfd_get_filename (nbfd
.get ()), 0,
930 OBJF_SHARED
| OBJF_NOT_FILENAME
, NULL
);
932 add_objfile_entry (objfile
, entry_addr
);
935 /* This function registers code associated with a JIT code entry. It uses the
936 pointer and size pair in the entry to read the symbol file from the remote
937 and then calls symbol_file_add_from_local_memory to add it as though it were
938 a symbol file added by the user. */
941 jit_register_code (struct gdbarch
*gdbarch
,
942 CORE_ADDR entry_addr
, struct jit_code_entry
*code_entry
)
947 fprintf_unfiltered (gdb_stdlog
,
948 "jit_register_code, symfile_addr = %s, "
949 "symfile_size = %s\n",
950 paddress (gdbarch
, code_entry
->symfile_addr
),
951 pulongest (code_entry
->symfile_size
));
953 success
= jit_reader_try_read_symtab (code_entry
, entry_addr
);
956 jit_bfd_try_read_symtab (code_entry
, entry_addr
, gdbarch
);
959 /* Look up the objfile with this code entry address. */
961 static struct objfile
*
962 jit_find_objf_with_entry_addr (CORE_ADDR entry_addr
)
964 for (objfile
*objf
: current_program_space
->objfiles ())
966 struct jit_objfile_data
*objf_data
;
969 = (struct jit_objfile_data
*) objfile_data (objf
, jit_objfile_data
);
970 if (objf_data
!= NULL
&& objf_data
->addr
== entry_addr
)
976 /* This is called when a breakpoint is deleted. It updates the
977 inferior's cache, if needed. */
980 jit_breakpoint_deleted (struct breakpoint
*b
)
982 struct bp_location
*iter
;
984 if (b
->type
!= bp_jit_event
)
987 for (iter
= b
->loc
; iter
!= NULL
; iter
= iter
->next
)
989 struct jit_program_space_data
*ps_data
;
991 ps_data
= jit_program_space_key
.get (iter
->pspace
);
992 if (ps_data
!= NULL
&& ps_data
->jit_breakpoint
== iter
->owner
)
994 ps_data
->cached_code_address
= 0;
995 ps_data
->jit_breakpoint
= NULL
;
1000 /* (Re-)Initialize the jit breakpoint if necessary.
1001 Return 0 if the jit breakpoint has been successfully initialized. */
1004 jit_breakpoint_re_set_internal (struct gdbarch
*gdbarch
,
1005 struct jit_program_space_data
*ps_data
)
1007 struct bound_minimal_symbol reg_symbol
;
1008 struct bound_minimal_symbol desc_symbol
;
1009 struct jit_objfile_data
*objf_data
;
1012 if (ps_data
->objfile
== NULL
)
1014 /* Lookup the registration symbol. If it is missing, then we
1015 assume we are not attached to a JIT. */
1016 reg_symbol
= lookup_bound_minimal_symbol (jit_break_name
);
1017 if (reg_symbol
.minsym
== NULL
1018 || BMSYMBOL_VALUE_ADDRESS (reg_symbol
) == 0)
1021 desc_symbol
= lookup_minimal_symbol (jit_descriptor_name
, NULL
,
1022 reg_symbol
.objfile
);
1023 if (desc_symbol
.minsym
== NULL
1024 || BMSYMBOL_VALUE_ADDRESS (desc_symbol
) == 0)
1027 objf_data
= get_jit_objfile_data (reg_symbol
.objfile
);
1028 objf_data
->register_code
= reg_symbol
.minsym
;
1029 objf_data
->descriptor
= desc_symbol
.minsym
;
1031 ps_data
->objfile
= reg_symbol
.objfile
;
1034 objf_data
= get_jit_objfile_data (ps_data
->objfile
);
1036 addr
= MSYMBOL_VALUE_ADDRESS (ps_data
->objfile
, objf_data
->register_code
);
1039 fprintf_unfiltered (gdb_stdlog
,
1040 "jit_breakpoint_re_set_internal, "
1041 "breakpoint_addr = %s\n",
1042 paddress (gdbarch
, addr
));
1044 if (ps_data
->cached_code_address
== addr
)
1047 /* Delete the old breakpoint. */
1048 if (ps_data
->jit_breakpoint
!= NULL
)
1049 delete_breakpoint (ps_data
->jit_breakpoint
);
1051 /* Put a breakpoint in the registration symbol. */
1052 ps_data
->cached_code_address
= addr
;
1053 ps_data
->jit_breakpoint
= create_jit_event_breakpoint (gdbarch
, addr
);
1058 /* The private data passed around in the frame unwind callback
1061 struct jit_unwind_private
1063 /* Cached register values. See jit_frame_sniffer to see how this
1065 detached_regcache
*regcache
;
1067 /* The frame being unwound. */
1068 struct frame_info
*this_frame
;
1071 /* Sets the value of a particular register in this frame. */
1074 jit_unwind_reg_set_impl (struct gdb_unwind_callbacks
*cb
, int dwarf_regnum
,
1075 struct gdb_reg_value
*value
)
1077 struct jit_unwind_private
*priv
;
1080 priv
= (struct jit_unwind_private
*) cb
->priv_data
;
1082 gdb_reg
= gdbarch_dwarf2_reg_to_regnum (get_frame_arch (priv
->this_frame
),
1087 fprintf_unfiltered (gdb_stdlog
,
1088 _("Could not recognize DWARF regnum %d"),
1090 value
->free (value
);
1094 priv
->regcache
->raw_supply (gdb_reg
, value
->value
);
1095 value
->free (value
);
1099 reg_value_free_impl (struct gdb_reg_value
*value
)
1104 /* Get the value of register REGNUM in the previous frame. */
1106 static struct gdb_reg_value
*
1107 jit_unwind_reg_get_impl (struct gdb_unwind_callbacks
*cb
, int regnum
)
1109 struct jit_unwind_private
*priv
;
1110 struct gdb_reg_value
*value
;
1112 struct gdbarch
*frame_arch
;
1114 priv
= (struct jit_unwind_private
*) cb
->priv_data
;
1115 frame_arch
= get_frame_arch (priv
->this_frame
);
1117 gdb_reg
= gdbarch_dwarf2_reg_to_regnum (frame_arch
, regnum
);
1118 size
= register_size (frame_arch
, gdb_reg
);
1119 value
= ((struct gdb_reg_value
*)
1120 xmalloc (sizeof (struct gdb_reg_value
) + size
- 1));
1121 value
->defined
= deprecated_frame_register_read (priv
->this_frame
, gdb_reg
,
1124 value
->free
= reg_value_free_impl
;
1128 /* gdb_reg_value has a free function, which must be called on each
1129 saved register value. */
1132 jit_dealloc_cache (struct frame_info
*this_frame
, void *cache
)
1134 struct jit_unwind_private
*priv_data
= (struct jit_unwind_private
*) cache
;
1136 gdb_assert (priv_data
->regcache
!= NULL
);
1137 delete priv_data
->regcache
;
1141 /* The frame sniffer for the pseudo unwinder.
1143 While this is nominally a frame sniffer, in the case where the JIT
1144 reader actually recognizes the frame, it does a lot more work -- it
1145 unwinds the frame and saves the corresponding register values in
1146 the cache. jit_frame_prev_register simply returns the saved
1150 jit_frame_sniffer (const struct frame_unwind
*self
,
1151 struct frame_info
*this_frame
, void **cache
)
1153 struct jit_unwind_private
*priv_data
;
1154 struct gdb_unwind_callbacks callbacks
;
1155 struct gdb_reader_funcs
*funcs
;
1157 callbacks
.reg_get
= jit_unwind_reg_get_impl
;
1158 callbacks
.reg_set
= jit_unwind_reg_set_impl
;
1159 callbacks
.target_read
= jit_target_read_impl
;
1161 if (loaded_jit_reader
== NULL
)
1164 funcs
= loaded_jit_reader
->functions
;
1166 gdb_assert (!*cache
);
1168 *cache
= XCNEW (struct jit_unwind_private
);
1169 priv_data
= (struct jit_unwind_private
*) *cache
;
1170 /* Take a snapshot of current regcache. */
1171 priv_data
->regcache
= new detached_regcache (get_frame_arch (this_frame
),
1173 priv_data
->this_frame
= this_frame
;
1175 callbacks
.priv_data
= priv_data
;
1177 /* Try to coax the provided unwinder to unwind the stack */
1178 if (funcs
->unwind (funcs
, &callbacks
) == GDB_SUCCESS
)
1181 fprintf_unfiltered (gdb_stdlog
, _("Successfully unwound frame using "
1186 fprintf_unfiltered (gdb_stdlog
, _("Could not unwind frame using "
1189 jit_dealloc_cache (this_frame
, *cache
);
1196 /* The frame_id function for the pseudo unwinder. Relays the call to
1197 the loaded plugin. */
1200 jit_frame_this_id (struct frame_info
*this_frame
, void **cache
,
1201 struct frame_id
*this_id
)
1203 struct jit_unwind_private priv
;
1204 struct gdb_frame_id frame_id
;
1205 struct gdb_reader_funcs
*funcs
;
1206 struct gdb_unwind_callbacks callbacks
;
1208 priv
.regcache
= NULL
;
1209 priv
.this_frame
= this_frame
;
1211 /* We don't expect the frame_id function to set any registers, so we
1212 set reg_set to NULL. */
1213 callbacks
.reg_get
= jit_unwind_reg_get_impl
;
1214 callbacks
.reg_set
= NULL
;
1215 callbacks
.target_read
= jit_target_read_impl
;
1216 callbacks
.priv_data
= &priv
;
1218 gdb_assert (loaded_jit_reader
);
1219 funcs
= loaded_jit_reader
->functions
;
1221 frame_id
= funcs
->get_frame_id (funcs
, &callbacks
);
1222 *this_id
= frame_id_build (frame_id
.stack_address
, frame_id
.code_address
);
1225 /* Pseudo unwinder function. Reads the previously fetched value for
1226 the register from the cache. */
1228 static struct value
*
1229 jit_frame_prev_register (struct frame_info
*this_frame
, void **cache
, int reg
)
1231 struct jit_unwind_private
*priv
= (struct jit_unwind_private
*) *cache
;
1232 struct gdbarch
*gdbarch
;
1235 return frame_unwind_got_optimized (this_frame
, reg
);
1237 gdbarch
= priv
->regcache
->arch ();
1238 gdb_byte
*buf
= (gdb_byte
*) alloca (register_size (gdbarch
, reg
));
1239 enum register_status status
= priv
->regcache
->cooked_read (reg
, buf
);
1241 if (status
== REG_VALID
)
1242 return frame_unwind_got_bytes (this_frame
, reg
, buf
);
1244 return frame_unwind_got_optimized (this_frame
, reg
);
1247 /* Relay everything back to the unwinder registered by the JIT debug
1250 static const struct frame_unwind jit_frame_unwind
=
1253 default_frame_unwind_stop_reason
,
1255 jit_frame_prev_register
,
1262 /* This is the information that is stored at jit_gdbarch_data for each
1265 struct jit_gdbarch_data_type
1267 /* Has the (pseudo) unwinder been prepended? */
1268 int unwinder_registered
;
1271 /* Check GDBARCH and prepend the pseudo JIT unwinder if needed. */
1274 jit_prepend_unwinder (struct gdbarch
*gdbarch
)
1276 struct jit_gdbarch_data_type
*data
;
1279 = (struct jit_gdbarch_data_type
*) gdbarch_data (gdbarch
, jit_gdbarch_data
);
1280 if (!data
->unwinder_registered
)
1282 frame_unwind_prepend_unwinder (gdbarch
, &jit_frame_unwind
);
1283 data
->unwinder_registered
= 1;
1287 /* Register any already created translations. */
1290 jit_inferior_init (struct gdbarch
*gdbarch
)
1292 struct jit_descriptor descriptor
;
1293 struct jit_code_entry cur_entry
;
1294 struct jit_program_space_data
*ps_data
;
1295 CORE_ADDR cur_entry_addr
;
1298 fprintf_unfiltered (gdb_stdlog
, "jit_inferior_init\n");
1300 jit_prepend_unwinder (gdbarch
);
1302 ps_data
= get_jit_program_space_data ();
1303 if (jit_breakpoint_re_set_internal (gdbarch
, ps_data
) != 0)
1306 /* Read the descriptor so we can check the version number and load
1307 any already JITed functions. */
1308 if (!jit_read_descriptor (gdbarch
, &descriptor
, ps_data
))
1311 /* Check that the version number agrees with that we support. */
1312 if (descriptor
.version
!= 1)
1314 printf_unfiltered (_("Unsupported JIT protocol version %ld "
1315 "in descriptor (expected 1)\n"),
1316 (long) descriptor
.version
);
1320 /* If we've attached to a running program, we need to check the descriptor
1321 to register any functions that were already generated. */
1322 for (cur_entry_addr
= descriptor
.first_entry
;
1323 cur_entry_addr
!= 0;
1324 cur_entry_addr
= cur_entry
.next_entry
)
1326 jit_read_code_entry (gdbarch
, cur_entry_addr
, &cur_entry
);
1328 /* This hook may be called many times during setup, so make sure we don't
1329 add the same symbol file twice. */
1330 if (jit_find_objf_with_entry_addr (cur_entry_addr
) != NULL
)
1333 jit_register_code (gdbarch
, cur_entry_addr
, &cur_entry
);
1337 /* inferior_created observer. */
1340 jit_inferior_created (struct target_ops
*ops
, int from_tty
)
1342 jit_inferior_created_hook ();
1345 /* Exported routine to call when an inferior has been created. */
1348 jit_inferior_created_hook (void)
1350 jit_inferior_init (target_gdbarch ());
1353 /* Exported routine to call to re-set the jit breakpoints,
1354 e.g. when a program is rerun. */
1357 jit_breakpoint_re_set (void)
1359 jit_breakpoint_re_set_internal (target_gdbarch (),
1360 get_jit_program_space_data ());
1363 /* This function cleans up any code entries left over when the
1364 inferior exits. We get left over code when the inferior exits
1365 without unregistering its code, for example when it crashes. */
1368 jit_inferior_exit_hook (struct inferior
*inf
)
1370 for (objfile
*objf
: current_program_space
->objfiles_safe ())
1372 struct jit_objfile_data
*objf_data
1373 = (struct jit_objfile_data
*) objfile_data (objf
, jit_objfile_data
);
1375 if (objf_data
!= NULL
&& objf_data
->addr
!= 0)
1381 jit_event_handler (struct gdbarch
*gdbarch
)
1383 struct jit_descriptor descriptor
;
1384 struct jit_code_entry code_entry
;
1385 CORE_ADDR entry_addr
;
1386 struct objfile
*objf
;
1388 /* Read the descriptor from remote memory. */
1389 if (!jit_read_descriptor (gdbarch
, &descriptor
,
1390 get_jit_program_space_data ()))
1392 entry_addr
= descriptor
.relevant_entry
;
1394 /* Do the corresponding action. */
1395 switch (descriptor
.action_flag
)
1400 jit_read_code_entry (gdbarch
, entry_addr
, &code_entry
);
1401 jit_register_code (gdbarch
, entry_addr
, &code_entry
);
1403 case JIT_UNREGISTER
:
1404 objf
= jit_find_objf_with_entry_addr (entry_addr
);
1406 printf_unfiltered (_("Unable to find JITed code "
1407 "entry at address: %s\n"),
1408 paddress (gdbarch
, entry_addr
));
1414 error (_("Unknown action_flag value in JIT descriptor!"));
1419 /* Called to free the data allocated to the jit_program_space_data slot. */
1422 free_objfile_data (struct objfile
*objfile
, void *data
)
1424 struct jit_objfile_data
*objf_data
= (struct jit_objfile_data
*) data
;
1426 if (objf_data
->register_code
!= NULL
)
1428 struct jit_program_space_data
*ps_data
;
1430 ps_data
= jit_program_space_key
.get (objfile
->pspace
);
1431 if (ps_data
!= NULL
&& ps_data
->objfile
== objfile
)
1433 ps_data
->objfile
= NULL
;
1434 if (ps_data
->jit_breakpoint
!= NULL
)
1435 delete_breakpoint (ps_data
->jit_breakpoint
);
1436 ps_data
->cached_code_address
= 0;
1443 /* Initialize the jit_gdbarch_data slot with an instance of struct
1444 jit_gdbarch_data_type */
1447 jit_gdbarch_data_init (struct obstack
*obstack
)
1449 struct jit_gdbarch_data_type
*data
=
1450 XOBNEW (obstack
, struct jit_gdbarch_data_type
);
1452 data
->unwinder_registered
= 0;
1458 _initialize_jit (void)
1460 jit_reader_dir
= relocate_gdb_directory (JIT_READER_DIR
,
1461 JIT_READER_DIR_RELOCATABLE
);
1462 add_setshow_zuinteger_cmd ("jit", class_maintenance
, &jit_debug
,
1463 _("Set JIT debugging."),
1464 _("Show JIT debugging."),
1465 _("When non-zero, JIT debugging is enabled."),
1468 &setdebuglist
, &showdebuglist
);
1470 gdb::observers::inferior_created
.attach (jit_inferior_created
);
1471 gdb::observers::inferior_exit
.attach (jit_inferior_exit_hook
);
1472 gdb::observers::breakpoint_deleted
.attach (jit_breakpoint_deleted
);
1475 register_objfile_data_with_cleanup (NULL
, free_objfile_data
);
1476 jit_gdbarch_data
= gdbarch_data_register_pre_init (jit_gdbarch_data_init
);
1477 if (is_dl_available ())
1479 struct cmd_list_element
*c
;
1481 c
= add_com ("jit-reader-load", no_class
, jit_reader_load_command
, _("\
1482 Load FILE as debug info reader and unwinder for JIT compiled code.\n\
1483 Usage: jit-reader-load FILE\n\
1484 Try to load file FILE as a debug info reader (and unwinder) for\n\
1485 JIT compiled code. The file is loaded from " JIT_READER_DIR
",\n\
1486 relocated relative to the GDB executable if required."));
1487 set_cmd_completer (c
, filename_completer
);
1489 c
= add_com ("jit-reader-unload", no_class
,
1490 jit_reader_unload_command
, _("\
1491 Unload the currently loaded JIT debug info reader.\n\
1492 Usage: jit-reader-unload\n\n\
1493 Do \"help jit-reader-load\" for info on loading debug info readers."));
1494 set_cmd_completer (c
, noop_completer
);