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"
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 /* The list of blocks in this symtab. These will eventually be
454 converted to real blocks. */
455 struct gdb_block
*blocks
;
457 /* The number of blocks inserted. */
460 /* A mapping between line numbers to PC. */
461 struct linetable
*linetable
;
463 /* The source file for this symtab. */
464 const char *file_name
;
465 struct gdb_symtab
*next
;
468 /* Proxy object for building an object. */
472 struct gdb_symtab
*symtabs
;
475 /* The type of the `private' data passed around by the callback
478 typedef CORE_ADDR jit_dbg_reader_data
;
480 /* The reader calls into this function to read data off the targets
483 static enum gdb_status
484 jit_target_read_impl (GDB_CORE_ADDR target_mem
, void *gdb_buf
, int len
)
486 int result
= target_read_memory ((CORE_ADDR
) target_mem
,
487 (gdb_byte
*) gdb_buf
, len
);
494 /* The reader calls into this function to create a new gdb_object
495 which it can then pass around to the other callbacks. Right now,
496 all that is required is allocating the memory. */
498 static struct gdb_object
*
499 jit_object_open_impl (struct gdb_symbol_callbacks
*cb
)
501 /* CB is not required right now, but sometime in the future we might
502 need a handle to it, and we'd like to do that without breaking
504 return XCNEW (struct gdb_object
);
507 /* Readers call into this function to open a new gdb_symtab, which,
508 again, is passed around to other callbacks. */
510 static struct gdb_symtab
*
511 jit_symtab_open_impl (struct gdb_symbol_callbacks
*cb
,
512 struct gdb_object
*object
,
513 const char *file_name
)
515 struct gdb_symtab
*ret
;
517 /* CB stays unused. See comment in jit_object_open_impl. */
519 ret
= XCNEW (struct gdb_symtab
);
520 ret
->file_name
= file_name
? xstrdup (file_name
) : xstrdup ("");
521 ret
->next
= object
->symtabs
;
522 object
->symtabs
= ret
;
526 /* Returns true if the block corresponding to old should be placed
527 before the block corresponding to new in the final blockvector. */
530 compare_block (const struct gdb_block
*const old
,
531 const struct gdb_block
*const newobj
)
535 if (old
->begin
< newobj
->begin
)
537 else if (old
->begin
== newobj
->begin
)
539 if (old
->end
> newobj
->end
)
548 /* Called by readers to open a new gdb_block. This function also
549 inserts the new gdb_block in the correct place in the corresponding
552 static struct gdb_block
*
553 jit_block_open_impl (struct gdb_symbol_callbacks
*cb
,
554 struct gdb_symtab
*symtab
, struct gdb_block
*parent
,
555 GDB_CORE_ADDR begin
, GDB_CORE_ADDR end
, const char *name
)
557 struct gdb_block
*block
= XCNEW (struct gdb_block
);
559 block
->next
= symtab
->blocks
;
560 block
->begin
= (CORE_ADDR
) begin
;
561 block
->end
= (CORE_ADDR
) end
;
562 block
->name
= name
? xstrdup (name
) : NULL
;
563 block
->parent
= parent
;
565 /* Ensure that the blocks are inserted in the correct (reverse of
566 the order expected by blockvector). */
567 if (compare_block (symtab
->blocks
, block
))
569 symtab
->blocks
= block
;
573 struct gdb_block
*i
= symtab
->blocks
;
577 /* Guaranteed to terminate, since compare_block (NULL, _)
579 if (compare_block (i
->next
, block
))
581 block
->next
= i
->next
;
592 /* Readers call this to add a line mapping (from PC to line number) to
596 jit_symtab_line_mapping_add_impl (struct gdb_symbol_callbacks
*cb
,
597 struct gdb_symtab
*stab
, int nlines
,
598 struct gdb_line_mapping
*map
)
606 alloc_len
= sizeof (struct linetable
)
607 + (nlines
- 1) * sizeof (struct linetable_entry
);
608 stab
->linetable
= (struct linetable
*) xmalloc (alloc_len
);
609 stab
->linetable
->nitems
= nlines
;
610 for (i
= 0; i
< nlines
; i
++)
612 stab
->linetable
->item
[i
].pc
= (CORE_ADDR
) map
[i
].pc
;
613 stab
->linetable
->item
[i
].line
= map
[i
].line
;
617 /* Called by readers to close a gdb_symtab. Does not need to do
618 anything as of now. */
621 jit_symtab_close_impl (struct gdb_symbol_callbacks
*cb
,
622 struct gdb_symtab
*stab
)
624 /* Right now nothing needs to be done here. We may need to do some
625 cleanup here in the future (again, without breaking the plugin
629 /* Transform STAB to a proper symtab, and add it it OBJFILE. */
632 finalize_symtab (struct gdb_symtab
*stab
, struct objfile
*objfile
)
634 struct compunit_symtab
*cust
;
635 struct gdb_block
*gdb_block_iter
, *gdb_block_iter_tmp
;
636 struct block
*block_iter
;
637 int actual_nblocks
, i
;
638 size_t blockvector_size
;
639 CORE_ADDR begin
, end
;
640 struct blockvector
*bv
;
642 actual_nblocks
= FIRST_LOCAL_BLOCK
+ stab
->nblocks
;
644 cust
= allocate_compunit_symtab (objfile
, stab
->file_name
);
645 allocate_symtab (cust
, stab
->file_name
);
646 add_compunit_symtab_to_objfile (cust
);
648 /* JIT compilers compile in memory. */
649 COMPUNIT_DIRNAME (cust
) = NULL
;
651 /* Copy over the linetable entry if one was provided. */
654 size_t size
= ((stab
->linetable
->nitems
- 1)
655 * sizeof (struct linetable_entry
)
656 + sizeof (struct linetable
));
657 SYMTAB_LINETABLE (COMPUNIT_FILETABS (cust
))
658 = (struct linetable
*) obstack_alloc (&objfile
->objfile_obstack
, size
);
659 memcpy (SYMTAB_LINETABLE (COMPUNIT_FILETABS (cust
)), stab
->linetable
,
663 blockvector_size
= (sizeof (struct blockvector
)
664 + (actual_nblocks
- 1) * sizeof (struct block
*));
665 bv
= (struct blockvector
*) obstack_alloc (&objfile
->objfile_obstack
,
667 COMPUNIT_BLOCKVECTOR (cust
) = bv
;
669 /* (begin, end) will contain the PC range this entire blockvector
671 BLOCKVECTOR_MAP (bv
) = NULL
;
672 begin
= stab
->blocks
->begin
;
673 end
= stab
->blocks
->end
;
674 BLOCKVECTOR_NBLOCKS (bv
) = actual_nblocks
;
676 /* First run over all the gdb_block objects, creating a real block
677 object for each. Simultaneously, keep setting the real_block
679 for (i
= (actual_nblocks
- 1), gdb_block_iter
= stab
->blocks
;
680 i
>= FIRST_LOCAL_BLOCK
;
681 i
--, gdb_block_iter
= gdb_block_iter
->next
)
683 struct block
*new_block
= allocate_block (&objfile
->objfile_obstack
);
684 struct symbol
*block_name
= allocate_symbol (objfile
);
685 struct type
*block_type
= arch_type (get_objfile_arch (objfile
),
690 BLOCK_MULTIDICT (new_block
)
691 = mdict_create_linear (&objfile
->objfile_obstack
, NULL
);
692 /* The address range. */
693 BLOCK_START (new_block
) = (CORE_ADDR
) gdb_block_iter
->begin
;
694 BLOCK_END (new_block
) = (CORE_ADDR
) gdb_block_iter
->end
;
697 SYMBOL_DOMAIN (block_name
) = VAR_DOMAIN
;
698 SYMBOL_ACLASS_INDEX (block_name
) = LOC_BLOCK
;
699 symbol_set_symtab (block_name
, COMPUNIT_FILETABS (cust
));
700 SYMBOL_TYPE (block_name
) = lookup_function_type (block_type
);
701 SYMBOL_BLOCK_VALUE (block_name
) = new_block
;
703 block_name
->name
= obstack_strdup (&objfile
->objfile_obstack
,
704 gdb_block_iter
->name
);
706 BLOCK_FUNCTION (new_block
) = block_name
;
708 BLOCKVECTOR_BLOCK (bv
, i
) = new_block
;
709 if (begin
> BLOCK_START (new_block
))
710 begin
= BLOCK_START (new_block
);
711 if (end
< BLOCK_END (new_block
))
712 end
= BLOCK_END (new_block
);
714 gdb_block_iter
->real_block
= new_block
;
717 /* Now add the special blocks. */
719 for (i
= 0; i
< FIRST_LOCAL_BLOCK
; i
++)
721 struct block
*new_block
;
723 new_block
= (i
== GLOBAL_BLOCK
724 ? allocate_global_block (&objfile
->objfile_obstack
)
725 : allocate_block (&objfile
->objfile_obstack
));
726 BLOCK_MULTIDICT (new_block
)
727 = mdict_create_linear (&objfile
->objfile_obstack
, NULL
);
728 BLOCK_SUPERBLOCK (new_block
) = block_iter
;
729 block_iter
= new_block
;
731 BLOCK_START (new_block
) = (CORE_ADDR
) begin
;
732 BLOCK_END (new_block
) = (CORE_ADDR
) end
;
734 BLOCKVECTOR_BLOCK (bv
, i
) = new_block
;
736 if (i
== GLOBAL_BLOCK
)
737 set_block_compunit_symtab (new_block
, cust
);
740 /* Fill up the superblock fields for the real blocks, using the
741 real_block fields populated earlier. */
742 for (gdb_block_iter
= stab
->blocks
;
744 gdb_block_iter
= gdb_block_iter
->next
)
746 if (gdb_block_iter
->parent
!= NULL
)
748 /* If the plugin specifically mentioned a parent block, we
750 BLOCK_SUPERBLOCK (gdb_block_iter
->real_block
) =
751 gdb_block_iter
->parent
->real_block
;
755 /* And if not, we set a default parent block. */
756 BLOCK_SUPERBLOCK (gdb_block_iter
->real_block
) =
757 BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
);
762 gdb_block_iter
= stab
->blocks
;
764 for (gdb_block_iter
= stab
->blocks
, gdb_block_iter_tmp
= gdb_block_iter
->next
;
766 gdb_block_iter
= gdb_block_iter_tmp
)
768 gdb_block_iter_tmp
= gdb_block_iter
->next
;
769 xfree ((void *) gdb_block_iter
->name
);
770 xfree (gdb_block_iter
);
772 xfree (stab
->linetable
);
773 xfree ((char *) stab
->file_name
);
777 /* Called when closing a gdb_objfile. Converts OBJ to a proper
781 jit_object_close_impl (struct gdb_symbol_callbacks
*cb
,
782 struct gdb_object
*obj
)
784 struct gdb_symtab
*i
, *j
;
785 struct objfile
*objfile
;
786 jit_dbg_reader_data
*priv_data
;
788 priv_data
= (jit_dbg_reader_data
*) cb
->priv_data
;
790 objfile
= new struct objfile (NULL
, "<< JIT compiled code >>",
792 objfile
->per_bfd
->gdbarch
= target_gdbarch ();
795 for (i
= obj
->symtabs
; i
; i
= j
)
798 finalize_symtab (i
, objfile
);
800 add_objfile_entry (objfile
, *priv_data
);
804 /* Try to read CODE_ENTRY using the loaded jit reader (if any).
805 ENTRY_ADDR is the address of the struct jit_code_entry in the
806 inferior address space. */
809 jit_reader_try_read_symtab (struct jit_code_entry
*code_entry
,
810 CORE_ADDR entry_addr
)
814 jit_dbg_reader_data priv_data
;
815 struct gdb_reader_funcs
*funcs
;
816 struct gdb_symbol_callbacks callbacks
=
818 jit_object_open_impl
,
819 jit_symtab_open_impl
,
821 jit_symtab_close_impl
,
822 jit_object_close_impl
,
824 jit_symtab_line_mapping_add_impl
,
825 jit_target_read_impl
,
830 priv_data
= entry_addr
;
832 if (!loaded_jit_reader
)
835 gdb_mem
= (gdb_byte
*) xmalloc (code_entry
->symfile_size
);
840 if (target_read_memory (code_entry
->symfile_addr
, gdb_mem
,
841 code_entry
->symfile_size
))
844 catch (const gdb_exception
&e
)
851 funcs
= loaded_jit_reader
->functions
;
852 if (funcs
->read (funcs
, &callbacks
, gdb_mem
, code_entry
->symfile_size
)
858 if (jit_debug
&& status
== 0)
859 fprintf_unfiltered (gdb_stdlog
,
860 "Could not read symtab using the loaded JIT reader.\n");
864 /* Try to read CODE_ENTRY using BFD. ENTRY_ADDR is the address of the
865 struct jit_code_entry in the inferior address space. */
868 jit_bfd_try_read_symtab (struct jit_code_entry
*code_entry
,
869 CORE_ADDR entry_addr
,
870 struct gdbarch
*gdbarch
)
872 struct bfd_section
*sec
;
873 struct objfile
*objfile
;
874 const struct bfd_arch_info
*b
;
877 fprintf_unfiltered (gdb_stdlog
,
878 "jit_bfd_try_read_symtab, symfile_addr = %s, "
879 "symfile_size = %s\n",
880 paddress (gdbarch
, code_entry
->symfile_addr
),
881 pulongest (code_entry
->symfile_size
));
883 gdb_bfd_ref_ptr
nbfd (bfd_open_from_target_memory (code_entry
->symfile_addr
,
884 code_entry
->symfile_size
,
888 puts_unfiltered (_("Error opening JITed symbol file, ignoring it.\n"));
892 /* Check the format. NOTE: This initializes important data that GDB uses!
893 We would segfault later without this line. */
894 if (!bfd_check_format (nbfd
.get (), bfd_object
))
896 printf_unfiltered (_("\
897 JITed symbol file is not an object file, ignoring it.\n"));
901 /* Check bfd arch. */
902 b
= gdbarch_bfd_arch_info (gdbarch
);
903 if (b
->compatible (b
, bfd_get_arch_info (nbfd
.get ())) != b
)
904 warning (_("JITed object file architecture %s is not compatible "
905 "with target architecture %s."),
906 bfd_get_arch_info (nbfd
.get ())->printable_name
,
909 /* Read the section address information out of the symbol file. Since the
910 file is generated by the JIT at runtime, it should all of the absolute
911 addresses that we care about. */
912 section_addr_info sai
;
913 for (sec
= nbfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
914 if ((bfd_section_flags (sec
) & (SEC_ALLOC
|SEC_LOAD
)) != 0)
916 /* We assume that these virtual addresses are absolute, and do not
917 treat them as offsets. */
918 sai
.emplace_back (bfd_section_vma (sec
),
919 bfd_section_name (sec
),
923 /* This call does not take ownership of SAI. */
924 objfile
= symbol_file_add_from_bfd (nbfd
.get (),
925 bfd_get_filename (nbfd
.get ()), 0,
927 OBJF_SHARED
| OBJF_NOT_FILENAME
, NULL
);
929 add_objfile_entry (objfile
, entry_addr
);
932 /* This function registers code associated with a JIT code entry. It uses the
933 pointer and size pair in the entry to read the symbol file from the remote
934 and then calls symbol_file_add_from_local_memory to add it as though it were
935 a symbol file added by the user. */
938 jit_register_code (struct gdbarch
*gdbarch
,
939 CORE_ADDR entry_addr
, struct jit_code_entry
*code_entry
)
944 fprintf_unfiltered (gdb_stdlog
,
945 "jit_register_code, symfile_addr = %s, "
946 "symfile_size = %s\n",
947 paddress (gdbarch
, code_entry
->symfile_addr
),
948 pulongest (code_entry
->symfile_size
));
950 success
= jit_reader_try_read_symtab (code_entry
, entry_addr
);
953 jit_bfd_try_read_symtab (code_entry
, entry_addr
, gdbarch
);
956 /* This function unregisters JITed code and frees the corresponding
960 jit_unregister_code (struct objfile
*objfile
)
963 fprintf_unfiltered (gdb_stdlog
, "jit_unregister_code (%s)\n",
964 host_address_to_string (objfile
));
968 /* Look up the objfile with this code entry address. */
970 static struct objfile
*
971 jit_find_objf_with_entry_addr (CORE_ADDR entry_addr
)
973 for (objfile
*objf
: current_program_space
->objfiles ())
975 struct jit_objfile_data
*objf_data
;
978 = (struct jit_objfile_data
*) objfile_data (objf
, jit_objfile_data
);
979 if (objf_data
!= NULL
&& objf_data
->addr
== entry_addr
)
985 /* This is called when a breakpoint is deleted. It updates the
986 inferior's cache, if needed. */
989 jit_breakpoint_deleted (struct breakpoint
*b
)
991 struct bp_location
*iter
;
993 if (b
->type
!= bp_jit_event
)
996 for (iter
= b
->loc
; iter
!= NULL
; iter
= iter
->next
)
998 struct jit_program_space_data
*ps_data
;
1000 ps_data
= jit_program_space_key
.get (iter
->pspace
);
1001 if (ps_data
!= NULL
&& ps_data
->jit_breakpoint
== iter
->owner
)
1003 ps_data
->cached_code_address
= 0;
1004 ps_data
->jit_breakpoint
= NULL
;
1009 /* (Re-)Initialize the jit breakpoint if necessary.
1010 Return 0 if the jit breakpoint has been successfully initialized. */
1013 jit_breakpoint_re_set_internal (struct gdbarch
*gdbarch
,
1014 struct jit_program_space_data
*ps_data
)
1016 struct bound_minimal_symbol reg_symbol
;
1017 struct bound_minimal_symbol desc_symbol
;
1018 struct jit_objfile_data
*objf_data
;
1021 if (ps_data
->objfile
== NULL
)
1023 /* Lookup the registration symbol. If it is missing, then we
1024 assume we are not attached to a JIT. */
1025 reg_symbol
= lookup_bound_minimal_symbol (jit_break_name
);
1026 if (reg_symbol
.minsym
== NULL
1027 || BMSYMBOL_VALUE_ADDRESS (reg_symbol
) == 0)
1030 desc_symbol
= lookup_minimal_symbol (jit_descriptor_name
, NULL
,
1031 reg_symbol
.objfile
);
1032 if (desc_symbol
.minsym
== NULL
1033 || BMSYMBOL_VALUE_ADDRESS (desc_symbol
) == 0)
1036 objf_data
= get_jit_objfile_data (reg_symbol
.objfile
);
1037 objf_data
->register_code
= reg_symbol
.minsym
;
1038 objf_data
->descriptor
= desc_symbol
.minsym
;
1040 ps_data
->objfile
= reg_symbol
.objfile
;
1043 objf_data
= get_jit_objfile_data (ps_data
->objfile
);
1045 addr
= MSYMBOL_VALUE_ADDRESS (ps_data
->objfile
, objf_data
->register_code
);
1048 fprintf_unfiltered (gdb_stdlog
,
1049 "jit_breakpoint_re_set_internal, "
1050 "breakpoint_addr = %s\n",
1051 paddress (gdbarch
, addr
));
1053 if (ps_data
->cached_code_address
== addr
)
1056 /* Delete the old breakpoint. */
1057 if (ps_data
->jit_breakpoint
!= NULL
)
1058 delete_breakpoint (ps_data
->jit_breakpoint
);
1060 /* Put a breakpoint in the registration symbol. */
1061 ps_data
->cached_code_address
= addr
;
1062 ps_data
->jit_breakpoint
= create_jit_event_breakpoint (gdbarch
, addr
);
1067 /* The private data passed around in the frame unwind callback
1070 struct jit_unwind_private
1072 /* Cached register values. See jit_frame_sniffer to see how this
1074 detached_regcache
*regcache
;
1076 /* The frame being unwound. */
1077 struct frame_info
*this_frame
;
1080 /* Sets the value of a particular register in this frame. */
1083 jit_unwind_reg_set_impl (struct gdb_unwind_callbacks
*cb
, int dwarf_regnum
,
1084 struct gdb_reg_value
*value
)
1086 struct jit_unwind_private
*priv
;
1089 priv
= (struct jit_unwind_private
*) cb
->priv_data
;
1091 gdb_reg
= gdbarch_dwarf2_reg_to_regnum (get_frame_arch (priv
->this_frame
),
1096 fprintf_unfiltered (gdb_stdlog
,
1097 _("Could not recognize DWARF regnum %d"),
1099 value
->free (value
);
1103 priv
->regcache
->raw_supply (gdb_reg
, value
->value
);
1104 value
->free (value
);
1108 reg_value_free_impl (struct gdb_reg_value
*value
)
1113 /* Get the value of register REGNUM in the previous frame. */
1115 static struct gdb_reg_value
*
1116 jit_unwind_reg_get_impl (struct gdb_unwind_callbacks
*cb
, int regnum
)
1118 struct jit_unwind_private
*priv
;
1119 struct gdb_reg_value
*value
;
1121 struct gdbarch
*frame_arch
;
1123 priv
= (struct jit_unwind_private
*) cb
->priv_data
;
1124 frame_arch
= get_frame_arch (priv
->this_frame
);
1126 gdb_reg
= gdbarch_dwarf2_reg_to_regnum (frame_arch
, regnum
);
1127 size
= register_size (frame_arch
, gdb_reg
);
1128 value
= ((struct gdb_reg_value
*)
1129 xmalloc (sizeof (struct gdb_reg_value
) + size
- 1));
1130 value
->defined
= deprecated_frame_register_read (priv
->this_frame
, gdb_reg
,
1133 value
->free
= reg_value_free_impl
;
1137 /* gdb_reg_value has a free function, which must be called on each
1138 saved register value. */
1141 jit_dealloc_cache (struct frame_info
*this_frame
, void *cache
)
1143 struct jit_unwind_private
*priv_data
= (struct jit_unwind_private
*) cache
;
1145 gdb_assert (priv_data
->regcache
!= NULL
);
1146 delete priv_data
->regcache
;
1150 /* The frame sniffer for the pseudo unwinder.
1152 While this is nominally a frame sniffer, in the case where the JIT
1153 reader actually recognizes the frame, it does a lot more work -- it
1154 unwinds the frame and saves the corresponding register values in
1155 the cache. jit_frame_prev_register simply returns the saved
1159 jit_frame_sniffer (const struct frame_unwind
*self
,
1160 struct frame_info
*this_frame
, void **cache
)
1162 struct jit_unwind_private
*priv_data
;
1163 struct gdb_unwind_callbacks callbacks
;
1164 struct gdb_reader_funcs
*funcs
;
1166 callbacks
.reg_get
= jit_unwind_reg_get_impl
;
1167 callbacks
.reg_set
= jit_unwind_reg_set_impl
;
1168 callbacks
.target_read
= jit_target_read_impl
;
1170 if (loaded_jit_reader
== NULL
)
1173 funcs
= loaded_jit_reader
->functions
;
1175 gdb_assert (!*cache
);
1177 *cache
= XCNEW (struct jit_unwind_private
);
1178 priv_data
= (struct jit_unwind_private
*) *cache
;
1179 /* Take a snapshot of current regcache. */
1180 priv_data
->regcache
= new detached_regcache (get_frame_arch (this_frame
),
1182 priv_data
->this_frame
= this_frame
;
1184 callbacks
.priv_data
= priv_data
;
1186 /* Try to coax the provided unwinder to unwind the stack */
1187 if (funcs
->unwind (funcs
, &callbacks
) == GDB_SUCCESS
)
1190 fprintf_unfiltered (gdb_stdlog
, _("Successfully unwound frame using "
1195 fprintf_unfiltered (gdb_stdlog
, _("Could not unwind frame using "
1198 jit_dealloc_cache (this_frame
, *cache
);
1205 /* The frame_id function for the pseudo unwinder. Relays the call to
1206 the loaded plugin. */
1209 jit_frame_this_id (struct frame_info
*this_frame
, void **cache
,
1210 struct frame_id
*this_id
)
1212 struct jit_unwind_private priv
;
1213 struct gdb_frame_id frame_id
;
1214 struct gdb_reader_funcs
*funcs
;
1215 struct gdb_unwind_callbacks callbacks
;
1217 priv
.regcache
= NULL
;
1218 priv
.this_frame
= this_frame
;
1220 /* We don't expect the frame_id function to set any registers, so we
1221 set reg_set to NULL. */
1222 callbacks
.reg_get
= jit_unwind_reg_get_impl
;
1223 callbacks
.reg_set
= NULL
;
1224 callbacks
.target_read
= jit_target_read_impl
;
1225 callbacks
.priv_data
= &priv
;
1227 gdb_assert (loaded_jit_reader
);
1228 funcs
= loaded_jit_reader
->functions
;
1230 frame_id
= funcs
->get_frame_id (funcs
, &callbacks
);
1231 *this_id
= frame_id_build (frame_id
.stack_address
, frame_id
.code_address
);
1234 /* Pseudo unwinder function. Reads the previously fetched value for
1235 the register from the cache. */
1237 static struct value
*
1238 jit_frame_prev_register (struct frame_info
*this_frame
, void **cache
, int reg
)
1240 struct jit_unwind_private
*priv
= (struct jit_unwind_private
*) *cache
;
1241 struct gdbarch
*gdbarch
;
1244 return frame_unwind_got_optimized (this_frame
, reg
);
1246 gdbarch
= priv
->regcache
->arch ();
1247 gdb_byte
*buf
= (gdb_byte
*) alloca (register_size (gdbarch
, reg
));
1248 enum register_status status
= priv
->regcache
->cooked_read (reg
, buf
);
1250 if (status
== REG_VALID
)
1251 return frame_unwind_got_bytes (this_frame
, reg
, buf
);
1253 return frame_unwind_got_optimized (this_frame
, reg
);
1256 /* Relay everything back to the unwinder registered by the JIT debug
1259 static const struct frame_unwind jit_frame_unwind
=
1262 default_frame_unwind_stop_reason
,
1264 jit_frame_prev_register
,
1271 /* This is the information that is stored at jit_gdbarch_data for each
1274 struct jit_gdbarch_data_type
1276 /* Has the (pseudo) unwinder been prepended? */
1277 int unwinder_registered
;
1280 /* Check GDBARCH and prepend the pseudo JIT unwinder if needed. */
1283 jit_prepend_unwinder (struct gdbarch
*gdbarch
)
1285 struct jit_gdbarch_data_type
*data
;
1288 = (struct jit_gdbarch_data_type
*) gdbarch_data (gdbarch
, jit_gdbarch_data
);
1289 if (!data
->unwinder_registered
)
1291 frame_unwind_prepend_unwinder (gdbarch
, &jit_frame_unwind
);
1292 data
->unwinder_registered
= 1;
1296 /* Register any already created translations. */
1299 jit_inferior_init (struct gdbarch
*gdbarch
)
1301 struct jit_descriptor descriptor
;
1302 struct jit_code_entry cur_entry
;
1303 struct jit_program_space_data
*ps_data
;
1304 CORE_ADDR cur_entry_addr
;
1307 fprintf_unfiltered (gdb_stdlog
, "jit_inferior_init\n");
1309 jit_prepend_unwinder (gdbarch
);
1311 ps_data
= get_jit_program_space_data ();
1312 if (jit_breakpoint_re_set_internal (gdbarch
, ps_data
) != 0)
1315 /* Read the descriptor so we can check the version number and load
1316 any already JITed functions. */
1317 if (!jit_read_descriptor (gdbarch
, &descriptor
, ps_data
))
1320 /* Check that the version number agrees with that we support. */
1321 if (descriptor
.version
!= 1)
1323 printf_unfiltered (_("Unsupported JIT protocol version %ld "
1324 "in descriptor (expected 1)\n"),
1325 (long) descriptor
.version
);
1329 /* If we've attached to a running program, we need to check the descriptor
1330 to register any functions that were already generated. */
1331 for (cur_entry_addr
= descriptor
.first_entry
;
1332 cur_entry_addr
!= 0;
1333 cur_entry_addr
= cur_entry
.next_entry
)
1335 jit_read_code_entry (gdbarch
, cur_entry_addr
, &cur_entry
);
1337 /* This hook may be called many times during setup, so make sure we don't
1338 add the same symbol file twice. */
1339 if (jit_find_objf_with_entry_addr (cur_entry_addr
) != NULL
)
1342 jit_register_code (gdbarch
, cur_entry_addr
, &cur_entry
);
1346 /* inferior_created observer. */
1349 jit_inferior_created (struct target_ops
*ops
, int from_tty
)
1351 jit_inferior_created_hook ();
1354 /* Exported routine to call when an inferior has been created. */
1357 jit_inferior_created_hook (void)
1359 jit_inferior_init (target_gdbarch ());
1362 /* Exported routine to call to re-set the jit breakpoints,
1363 e.g. when a program is rerun. */
1366 jit_breakpoint_re_set (void)
1368 jit_breakpoint_re_set_internal (target_gdbarch (),
1369 get_jit_program_space_data ());
1372 /* This function cleans up any code entries left over when the
1373 inferior exits. We get left over code when the inferior exits
1374 without unregistering its code, for example when it crashes. */
1377 jit_inferior_exit_hook (struct inferior
*inf
)
1379 for (objfile
*objf
: current_program_space
->objfiles_safe ())
1381 struct jit_objfile_data
*objf_data
1382 = (struct jit_objfile_data
*) objfile_data (objf
, jit_objfile_data
);
1384 if (objf_data
!= NULL
&& objf_data
->addr
!= 0)
1385 jit_unregister_code (objf
);
1390 jit_event_handler (struct gdbarch
*gdbarch
)
1392 struct jit_descriptor descriptor
;
1393 struct jit_code_entry code_entry
;
1394 CORE_ADDR entry_addr
;
1395 struct objfile
*objf
;
1397 /* Read the descriptor from remote memory. */
1398 if (!jit_read_descriptor (gdbarch
, &descriptor
,
1399 get_jit_program_space_data ()))
1401 entry_addr
= descriptor
.relevant_entry
;
1403 /* Do the corresponding action. */
1404 switch (descriptor
.action_flag
)
1409 jit_read_code_entry (gdbarch
, entry_addr
, &code_entry
);
1410 jit_register_code (gdbarch
, entry_addr
, &code_entry
);
1412 case JIT_UNREGISTER
:
1413 objf
= jit_find_objf_with_entry_addr (entry_addr
);
1415 printf_unfiltered (_("Unable to find JITed code "
1416 "entry at address: %s\n"),
1417 paddress (gdbarch
, entry_addr
));
1419 jit_unregister_code (objf
);
1423 error (_("Unknown action_flag value in JIT descriptor!"));
1428 /* Called to free the data allocated to the jit_program_space_data slot. */
1431 free_objfile_data (struct objfile
*objfile
, void *data
)
1433 struct jit_objfile_data
*objf_data
= (struct jit_objfile_data
*) data
;
1435 if (objf_data
->register_code
!= NULL
)
1437 struct jit_program_space_data
*ps_data
;
1439 ps_data
= jit_program_space_key
.get (objfile
->pspace
);
1440 if (ps_data
!= NULL
&& ps_data
->objfile
== objfile
)
1442 ps_data
->objfile
= NULL
;
1443 if (ps_data
->jit_breakpoint
!= NULL
)
1444 delete_breakpoint (ps_data
->jit_breakpoint
);
1445 ps_data
->cached_code_address
= 0;
1452 /* Initialize the jit_gdbarch_data slot with an instance of struct
1453 jit_gdbarch_data_type */
1456 jit_gdbarch_data_init (struct obstack
*obstack
)
1458 struct jit_gdbarch_data_type
*data
=
1459 XOBNEW (obstack
, struct jit_gdbarch_data_type
);
1461 data
->unwinder_registered
= 0;
1467 _initialize_jit (void)
1469 jit_reader_dir
= relocate_gdb_directory (JIT_READER_DIR
,
1470 JIT_READER_DIR_RELOCATABLE
);
1471 add_setshow_zuinteger_cmd ("jit", class_maintenance
, &jit_debug
,
1472 _("Set JIT debugging."),
1473 _("Show JIT debugging."),
1474 _("When non-zero, JIT debugging is enabled."),
1477 &setdebuglist
, &showdebuglist
);
1479 gdb::observers::inferior_created
.attach (jit_inferior_created
);
1480 gdb::observers::inferior_exit
.attach (jit_inferior_exit_hook
);
1481 gdb::observers::breakpoint_deleted
.attach (jit_breakpoint_deleted
);
1484 register_objfile_data_with_cleanup (NULL
, free_objfile_data
);
1485 jit_gdbarch_data
= gdbarch_data_register_pre_init (jit_gdbarch_data_init
);
1486 if (is_dl_available ())
1488 struct cmd_list_element
*c
;
1490 c
= add_com ("jit-reader-load", no_class
, jit_reader_load_command
, _("\
1491 Load FILE as debug info reader and unwinder for JIT compiled code.\n\
1492 Usage: jit-reader-load FILE\n\
1493 Try to load file FILE as a debug info reader (and unwinder) for\n\
1494 JIT compiled code. The file is loaded from " JIT_READER_DIR
",\n\
1495 relocated relative to the GDB executable if required."));
1496 set_cmd_completer (c
, filename_completer
);
1498 c
= add_com ("jit-reader-unload", no_class
,
1499 jit_reader_unload_command
, _("\
1500 Unload the currently loaded JIT debug info reader.\n\
1501 Usage: jit-reader-unload\n\n\
1502 Do \"help jit-reader-load\" for info on loading debug info readers."));
1503 set_cmd_completer (c
, noop_completer
);