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 /* 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
= objfile::make (nullptr, "<< 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
)
813 jit_dbg_reader_data priv_data
;
814 struct gdb_reader_funcs
*funcs
;
815 struct gdb_symbol_callbacks callbacks
=
817 jit_object_open_impl
,
818 jit_symtab_open_impl
,
820 jit_symtab_close_impl
,
821 jit_object_close_impl
,
823 jit_symtab_line_mapping_add_impl
,
824 jit_target_read_impl
,
829 priv_data
= entry_addr
;
831 if (!loaded_jit_reader
)
834 gdb::byte_vector
gdb_mem (code_entry
->symfile_size
);
839 if (target_read_memory (code_entry
->symfile_addr
, gdb_mem
.data (),
840 code_entry
->symfile_size
))
843 catch (const gdb_exception
&e
)
850 funcs
= loaded_jit_reader
->functions
;
851 if (funcs
->read (funcs
, &callbacks
, gdb_mem
.data (),
852 code_entry
->symfile_size
)
857 if (jit_debug
&& status
== 0)
858 fprintf_unfiltered (gdb_stdlog
,
859 "Could not read symtab using the loaded JIT reader.\n");
863 /* Try to read CODE_ENTRY using BFD. ENTRY_ADDR is the address of the
864 struct jit_code_entry in the inferior address space. */
867 jit_bfd_try_read_symtab (struct jit_code_entry
*code_entry
,
868 CORE_ADDR entry_addr
,
869 struct gdbarch
*gdbarch
)
871 struct bfd_section
*sec
;
872 struct objfile
*objfile
;
873 const struct bfd_arch_info
*b
;
876 fprintf_unfiltered (gdb_stdlog
,
877 "jit_bfd_try_read_symtab, symfile_addr = %s, "
878 "symfile_size = %s\n",
879 paddress (gdbarch
, code_entry
->symfile_addr
),
880 pulongest (code_entry
->symfile_size
));
882 gdb_bfd_ref_ptr
nbfd (bfd_open_from_target_memory (code_entry
->symfile_addr
,
883 code_entry
->symfile_size
,
887 puts_unfiltered (_("Error opening JITed symbol file, ignoring it.\n"));
891 /* Check the format. NOTE: This initializes important data that GDB uses!
892 We would segfault later without this line. */
893 if (!bfd_check_format (nbfd
.get (), bfd_object
))
895 printf_unfiltered (_("\
896 JITed symbol file is not an object file, ignoring it.\n"));
900 /* Check bfd arch. */
901 b
= gdbarch_bfd_arch_info (gdbarch
);
902 if (b
->compatible (b
, bfd_get_arch_info (nbfd
.get ())) != b
)
903 warning (_("JITed object file architecture %s is not compatible "
904 "with target architecture %s."),
905 bfd_get_arch_info (nbfd
.get ())->printable_name
,
908 /* Read the section address information out of the symbol file. Since the
909 file is generated by the JIT at runtime, it should all of the absolute
910 addresses that we care about. */
911 section_addr_info sai
;
912 for (sec
= nbfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
913 if ((bfd_section_flags (sec
) & (SEC_ALLOC
|SEC_LOAD
)) != 0)
915 /* We assume that these virtual addresses are absolute, and do not
916 treat them as offsets. */
917 sai
.emplace_back (bfd_section_vma (sec
),
918 bfd_section_name (sec
),
922 /* This call does not take ownership of SAI. */
923 objfile
= symbol_file_add_from_bfd (nbfd
.get (),
924 bfd_get_filename (nbfd
.get ()), 0,
926 OBJF_SHARED
| OBJF_NOT_FILENAME
, NULL
);
928 add_objfile_entry (objfile
, entry_addr
);
931 /* This function registers code associated with a JIT code entry. It uses the
932 pointer and size pair in the entry to read the symbol file from the remote
933 and then calls symbol_file_add_from_local_memory to add it as though it were
934 a symbol file added by the user. */
937 jit_register_code (struct gdbarch
*gdbarch
,
938 CORE_ADDR entry_addr
, struct jit_code_entry
*code_entry
)
943 fprintf_unfiltered (gdb_stdlog
,
944 "jit_register_code, symfile_addr = %s, "
945 "symfile_size = %s\n",
946 paddress (gdbarch
, code_entry
->symfile_addr
),
947 pulongest (code_entry
->symfile_size
));
949 success
= jit_reader_try_read_symtab (code_entry
, entry_addr
);
952 jit_bfd_try_read_symtab (code_entry
, entry_addr
, gdbarch
);
955 /* Look up the objfile with this code entry address. */
957 static struct objfile
*
958 jit_find_objf_with_entry_addr (CORE_ADDR entry_addr
)
960 for (objfile
*objf
: current_program_space
->objfiles ())
962 struct jit_objfile_data
*objf_data
;
965 = (struct jit_objfile_data
*) objfile_data (objf
, jit_objfile_data
);
966 if (objf_data
!= NULL
&& objf_data
->addr
== entry_addr
)
972 /* This is called when a breakpoint is deleted. It updates the
973 inferior's cache, if needed. */
976 jit_breakpoint_deleted (struct breakpoint
*b
)
978 struct bp_location
*iter
;
980 if (b
->type
!= bp_jit_event
)
983 for (iter
= b
->loc
; iter
!= NULL
; iter
= iter
->next
)
985 struct jit_program_space_data
*ps_data
;
987 ps_data
= jit_program_space_key
.get (iter
->pspace
);
988 if (ps_data
!= NULL
&& ps_data
->jit_breakpoint
== iter
->owner
)
990 ps_data
->cached_code_address
= 0;
991 ps_data
->jit_breakpoint
= NULL
;
996 /* (Re-)Initialize the jit breakpoint if necessary.
997 Return 0 if the jit breakpoint has been successfully initialized. */
1000 jit_breakpoint_re_set_internal (struct gdbarch
*gdbarch
,
1001 struct jit_program_space_data
*ps_data
)
1003 struct bound_minimal_symbol reg_symbol
;
1004 struct bound_minimal_symbol desc_symbol
;
1005 struct jit_objfile_data
*objf_data
;
1008 if (ps_data
->objfile
== NULL
)
1010 /* Lookup the registration symbol. If it is missing, then we
1011 assume we are not attached to a JIT. */
1012 reg_symbol
= lookup_bound_minimal_symbol (jit_break_name
);
1013 if (reg_symbol
.minsym
== NULL
1014 || BMSYMBOL_VALUE_ADDRESS (reg_symbol
) == 0)
1017 desc_symbol
= lookup_minimal_symbol (jit_descriptor_name
, NULL
,
1018 reg_symbol
.objfile
);
1019 if (desc_symbol
.minsym
== NULL
1020 || BMSYMBOL_VALUE_ADDRESS (desc_symbol
) == 0)
1023 objf_data
= get_jit_objfile_data (reg_symbol
.objfile
);
1024 objf_data
->register_code
= reg_symbol
.minsym
;
1025 objf_data
->descriptor
= desc_symbol
.minsym
;
1027 ps_data
->objfile
= reg_symbol
.objfile
;
1030 objf_data
= get_jit_objfile_data (ps_data
->objfile
);
1032 addr
= MSYMBOL_VALUE_ADDRESS (ps_data
->objfile
, objf_data
->register_code
);
1035 fprintf_unfiltered (gdb_stdlog
,
1036 "jit_breakpoint_re_set_internal, "
1037 "breakpoint_addr = %s\n",
1038 paddress (gdbarch
, addr
));
1040 if (ps_data
->cached_code_address
== addr
)
1043 /* Delete the old breakpoint. */
1044 if (ps_data
->jit_breakpoint
!= NULL
)
1045 delete_breakpoint (ps_data
->jit_breakpoint
);
1047 /* Put a breakpoint in the registration symbol. */
1048 ps_data
->cached_code_address
= addr
;
1049 ps_data
->jit_breakpoint
= create_jit_event_breakpoint (gdbarch
, addr
);
1054 /* The private data passed around in the frame unwind callback
1057 struct jit_unwind_private
1059 /* Cached register values. See jit_frame_sniffer to see how this
1061 detached_regcache
*regcache
;
1063 /* The frame being unwound. */
1064 struct frame_info
*this_frame
;
1067 /* Sets the value of a particular register in this frame. */
1070 jit_unwind_reg_set_impl (struct gdb_unwind_callbacks
*cb
, int dwarf_regnum
,
1071 struct gdb_reg_value
*value
)
1073 struct jit_unwind_private
*priv
;
1076 priv
= (struct jit_unwind_private
*) cb
->priv_data
;
1078 gdb_reg
= gdbarch_dwarf2_reg_to_regnum (get_frame_arch (priv
->this_frame
),
1083 fprintf_unfiltered (gdb_stdlog
,
1084 _("Could not recognize DWARF regnum %d"),
1086 value
->free (value
);
1090 priv
->regcache
->raw_supply (gdb_reg
, value
->value
);
1091 value
->free (value
);
1095 reg_value_free_impl (struct gdb_reg_value
*value
)
1100 /* Get the value of register REGNUM in the previous frame. */
1102 static struct gdb_reg_value
*
1103 jit_unwind_reg_get_impl (struct gdb_unwind_callbacks
*cb
, int regnum
)
1105 struct jit_unwind_private
*priv
;
1106 struct gdb_reg_value
*value
;
1108 struct gdbarch
*frame_arch
;
1110 priv
= (struct jit_unwind_private
*) cb
->priv_data
;
1111 frame_arch
= get_frame_arch (priv
->this_frame
);
1113 gdb_reg
= gdbarch_dwarf2_reg_to_regnum (frame_arch
, regnum
);
1114 size
= register_size (frame_arch
, gdb_reg
);
1115 value
= ((struct gdb_reg_value
*)
1116 xmalloc (sizeof (struct gdb_reg_value
) + size
- 1));
1117 value
->defined
= deprecated_frame_register_read (priv
->this_frame
, gdb_reg
,
1120 value
->free
= reg_value_free_impl
;
1124 /* gdb_reg_value has a free function, which must be called on each
1125 saved register value. */
1128 jit_dealloc_cache (struct frame_info
*this_frame
, void *cache
)
1130 struct jit_unwind_private
*priv_data
= (struct jit_unwind_private
*) cache
;
1132 gdb_assert (priv_data
->regcache
!= NULL
);
1133 delete priv_data
->regcache
;
1137 /* The frame sniffer for the pseudo unwinder.
1139 While this is nominally a frame sniffer, in the case where the JIT
1140 reader actually recognizes the frame, it does a lot more work -- it
1141 unwinds the frame and saves the corresponding register values in
1142 the cache. jit_frame_prev_register simply returns the saved
1146 jit_frame_sniffer (const struct frame_unwind
*self
,
1147 struct frame_info
*this_frame
, void **cache
)
1149 struct jit_unwind_private
*priv_data
;
1150 struct gdb_unwind_callbacks callbacks
;
1151 struct gdb_reader_funcs
*funcs
;
1153 callbacks
.reg_get
= jit_unwind_reg_get_impl
;
1154 callbacks
.reg_set
= jit_unwind_reg_set_impl
;
1155 callbacks
.target_read
= jit_target_read_impl
;
1157 if (loaded_jit_reader
== NULL
)
1160 funcs
= loaded_jit_reader
->functions
;
1162 gdb_assert (!*cache
);
1164 *cache
= XCNEW (struct jit_unwind_private
);
1165 priv_data
= (struct jit_unwind_private
*) *cache
;
1166 /* Take a snapshot of current regcache. */
1167 priv_data
->regcache
= new detached_regcache (get_frame_arch (this_frame
),
1169 priv_data
->this_frame
= this_frame
;
1171 callbacks
.priv_data
= priv_data
;
1173 /* Try to coax the provided unwinder to unwind the stack */
1174 if (funcs
->unwind (funcs
, &callbacks
) == GDB_SUCCESS
)
1177 fprintf_unfiltered (gdb_stdlog
, _("Successfully unwound frame using "
1182 fprintf_unfiltered (gdb_stdlog
, _("Could not unwind frame using "
1185 jit_dealloc_cache (this_frame
, *cache
);
1192 /* The frame_id function for the pseudo unwinder. Relays the call to
1193 the loaded plugin. */
1196 jit_frame_this_id (struct frame_info
*this_frame
, void **cache
,
1197 struct frame_id
*this_id
)
1199 struct jit_unwind_private priv
;
1200 struct gdb_frame_id frame_id
;
1201 struct gdb_reader_funcs
*funcs
;
1202 struct gdb_unwind_callbacks callbacks
;
1204 priv
.regcache
= NULL
;
1205 priv
.this_frame
= this_frame
;
1207 /* We don't expect the frame_id function to set any registers, so we
1208 set reg_set to NULL. */
1209 callbacks
.reg_get
= jit_unwind_reg_get_impl
;
1210 callbacks
.reg_set
= NULL
;
1211 callbacks
.target_read
= jit_target_read_impl
;
1212 callbacks
.priv_data
= &priv
;
1214 gdb_assert (loaded_jit_reader
);
1215 funcs
= loaded_jit_reader
->functions
;
1217 frame_id
= funcs
->get_frame_id (funcs
, &callbacks
);
1218 *this_id
= frame_id_build (frame_id
.stack_address
, frame_id
.code_address
);
1221 /* Pseudo unwinder function. Reads the previously fetched value for
1222 the register from the cache. */
1224 static struct value
*
1225 jit_frame_prev_register (struct frame_info
*this_frame
, void **cache
, int reg
)
1227 struct jit_unwind_private
*priv
= (struct jit_unwind_private
*) *cache
;
1228 struct gdbarch
*gdbarch
;
1231 return frame_unwind_got_optimized (this_frame
, reg
);
1233 gdbarch
= priv
->regcache
->arch ();
1234 gdb_byte
*buf
= (gdb_byte
*) alloca (register_size (gdbarch
, reg
));
1235 enum register_status status
= priv
->regcache
->cooked_read (reg
, buf
);
1237 if (status
== REG_VALID
)
1238 return frame_unwind_got_bytes (this_frame
, reg
, buf
);
1240 return frame_unwind_got_optimized (this_frame
, reg
);
1243 /* Relay everything back to the unwinder registered by the JIT debug
1246 static const struct frame_unwind jit_frame_unwind
=
1249 default_frame_unwind_stop_reason
,
1251 jit_frame_prev_register
,
1258 /* This is the information that is stored at jit_gdbarch_data for each
1261 struct jit_gdbarch_data_type
1263 /* Has the (pseudo) unwinder been prepended? */
1264 int unwinder_registered
;
1267 /* Check GDBARCH and prepend the pseudo JIT unwinder if needed. */
1270 jit_prepend_unwinder (struct gdbarch
*gdbarch
)
1272 struct jit_gdbarch_data_type
*data
;
1275 = (struct jit_gdbarch_data_type
*) gdbarch_data (gdbarch
, jit_gdbarch_data
);
1276 if (!data
->unwinder_registered
)
1278 frame_unwind_prepend_unwinder (gdbarch
, &jit_frame_unwind
);
1279 data
->unwinder_registered
= 1;
1283 /* Register any already created translations. */
1286 jit_inferior_init (struct gdbarch
*gdbarch
)
1288 struct jit_descriptor descriptor
;
1289 struct jit_code_entry cur_entry
;
1290 struct jit_program_space_data
*ps_data
;
1291 CORE_ADDR cur_entry_addr
;
1294 fprintf_unfiltered (gdb_stdlog
, "jit_inferior_init\n");
1296 jit_prepend_unwinder (gdbarch
);
1298 ps_data
= get_jit_program_space_data ();
1299 if (jit_breakpoint_re_set_internal (gdbarch
, ps_data
) != 0)
1302 /* Read the descriptor so we can check the version number and load
1303 any already JITed functions. */
1304 if (!jit_read_descriptor (gdbarch
, &descriptor
, ps_data
))
1307 /* Check that the version number agrees with that we support. */
1308 if (descriptor
.version
!= 1)
1310 printf_unfiltered (_("Unsupported JIT protocol version %ld "
1311 "in descriptor (expected 1)\n"),
1312 (long) descriptor
.version
);
1316 /* If we've attached to a running program, we need to check the descriptor
1317 to register any functions that were already generated. */
1318 for (cur_entry_addr
= descriptor
.first_entry
;
1319 cur_entry_addr
!= 0;
1320 cur_entry_addr
= cur_entry
.next_entry
)
1322 jit_read_code_entry (gdbarch
, cur_entry_addr
, &cur_entry
);
1324 /* This hook may be called many times during setup, so make sure we don't
1325 add the same symbol file twice. */
1326 if (jit_find_objf_with_entry_addr (cur_entry_addr
) != NULL
)
1329 jit_register_code (gdbarch
, cur_entry_addr
, &cur_entry
);
1333 /* inferior_created observer. */
1336 jit_inferior_created (struct target_ops
*ops
, int from_tty
)
1338 jit_inferior_created_hook ();
1341 /* Exported routine to call when an inferior has been created. */
1344 jit_inferior_created_hook (void)
1346 jit_inferior_init (target_gdbarch ());
1349 /* Exported routine to call to re-set the jit breakpoints,
1350 e.g. when a program is rerun. */
1353 jit_breakpoint_re_set (void)
1355 jit_breakpoint_re_set_internal (target_gdbarch (),
1356 get_jit_program_space_data ());
1359 /* This function cleans up any code entries left over when the
1360 inferior exits. We get left over code when the inferior exits
1361 without unregistering its code, for example when it crashes. */
1364 jit_inferior_exit_hook (struct inferior
*inf
)
1366 for (objfile
*objf
: current_program_space
->objfiles_safe ())
1368 struct jit_objfile_data
*objf_data
1369 = (struct jit_objfile_data
*) objfile_data (objf
, jit_objfile_data
);
1371 if (objf_data
!= NULL
&& objf_data
->addr
!= 0)
1377 jit_event_handler (struct gdbarch
*gdbarch
)
1379 struct jit_descriptor descriptor
;
1380 struct jit_code_entry code_entry
;
1381 CORE_ADDR entry_addr
;
1382 struct objfile
*objf
;
1384 /* Read the descriptor from remote memory. */
1385 if (!jit_read_descriptor (gdbarch
, &descriptor
,
1386 get_jit_program_space_data ()))
1388 entry_addr
= descriptor
.relevant_entry
;
1390 /* Do the corresponding action. */
1391 switch (descriptor
.action_flag
)
1396 jit_read_code_entry (gdbarch
, entry_addr
, &code_entry
);
1397 jit_register_code (gdbarch
, entry_addr
, &code_entry
);
1399 case JIT_UNREGISTER
:
1400 objf
= jit_find_objf_with_entry_addr (entry_addr
);
1402 printf_unfiltered (_("Unable to find JITed code "
1403 "entry at address: %s\n"),
1404 paddress (gdbarch
, entry_addr
));
1410 error (_("Unknown action_flag value in JIT descriptor!"));
1415 /* Called to free the data allocated to the jit_program_space_data slot. */
1418 free_objfile_data (struct objfile
*objfile
, void *data
)
1420 struct jit_objfile_data
*objf_data
= (struct jit_objfile_data
*) data
;
1422 if (objf_data
->register_code
!= NULL
)
1424 struct jit_program_space_data
*ps_data
;
1426 ps_data
= jit_program_space_key
.get (objfile
->pspace
);
1427 if (ps_data
!= NULL
&& ps_data
->objfile
== objfile
)
1429 ps_data
->objfile
= NULL
;
1430 if (ps_data
->jit_breakpoint
!= NULL
)
1431 delete_breakpoint (ps_data
->jit_breakpoint
);
1432 ps_data
->cached_code_address
= 0;
1439 /* Initialize the jit_gdbarch_data slot with an instance of struct
1440 jit_gdbarch_data_type */
1443 jit_gdbarch_data_init (struct obstack
*obstack
)
1445 struct jit_gdbarch_data_type
*data
=
1446 XOBNEW (obstack
, struct jit_gdbarch_data_type
);
1448 data
->unwinder_registered
= 0;
1454 _initialize_jit (void)
1456 jit_reader_dir
= relocate_gdb_directory (JIT_READER_DIR
,
1457 JIT_READER_DIR_RELOCATABLE
);
1458 add_setshow_zuinteger_cmd ("jit", class_maintenance
, &jit_debug
,
1459 _("Set JIT debugging."),
1460 _("Show JIT debugging."),
1461 _("When non-zero, JIT debugging is enabled."),
1464 &setdebuglist
, &showdebuglist
);
1466 gdb::observers::inferior_created
.attach (jit_inferior_created
);
1467 gdb::observers::inferior_exit
.attach (jit_inferior_exit_hook
);
1468 gdb::observers::breakpoint_deleted
.attach (jit_breakpoint_deleted
);
1471 register_objfile_data_with_cleanup (NULL
, free_objfile_data
);
1472 jit_gdbarch_data
= gdbarch_data_register_pre_init (jit_gdbarch_data_init
);
1473 if (is_dl_available ())
1475 struct cmd_list_element
*c
;
1477 c
= add_com ("jit-reader-load", no_class
, jit_reader_load_command
, _("\
1478 Load FILE as debug info reader and unwinder for JIT compiled code.\n\
1479 Usage: jit-reader-load FILE\n\
1480 Try to load file FILE as a debug info reader (and unwinder) for\n\
1481 JIT compiled code. The file is loaded from " JIT_READER_DIR
",\n\
1482 relocated relative to the GDB executable if required."));
1483 set_cmd_completer (c
, filename_completer
);
1485 c
= add_com ("jit-reader-unload", no_class
,
1486 jit_reader_unload_command
, _("\
1487 Unload the currently loaded JIT debug info reader.\n\
1488 Usage: jit-reader-unload\n\n\
1489 Do \"help jit-reader-load\" for info on loading debug info readers."));
1490 set_cmd_completer (c
, noop_completer
);