1 /* Handle JIT code generation in the inferior for GDB, the GNU Debugger.
3 Copyright (C) 2009-2014 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"
39 #include "gdb-dlfcn.h"
41 #include "exceptions.h"
44 static const char *jit_reader_dir
= NULL
;
46 static const struct objfile_data
*jit_objfile_data
;
48 static const char *const jit_break_name
= "__jit_debug_register_code";
50 static const char *const jit_descriptor_name
= "__jit_debug_descriptor";
52 static const struct program_space_data
*jit_program_space_data
= NULL
;
54 static void jit_inferior_init (struct gdbarch
*gdbarch
);
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 /* Openning 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 sb
->st_size
= buffer
->size
;
134 /* Open a BFD from the target's memory. */
137 bfd_open_from_target_memory (CORE_ADDR addr
, ULONGEST size
, char *target
)
139 struct target_buffer
*buffer
= xmalloc (sizeof (struct target_buffer
));
143 return gdb_bfd_openr_iovec ("<in-memory>", target
,
151 /* One reader that has been loaded successfully, and can potentially be used to
154 static struct jit_reader
156 struct gdb_reader_funcs
*functions
;
158 } *loaded_jit_reader
= NULL
;
160 typedef struct gdb_reader_funcs
* (reader_init_fn_type
) (void);
161 static const char *reader_init_fn_sym
= "gdb_init_reader";
163 /* Try to load FILE_NAME as a JIT debug info reader. */
165 static struct jit_reader
*
166 jit_reader_load (const char *file_name
)
169 reader_init_fn_type
*init_fn
;
170 struct jit_reader
*new_reader
= NULL
;
171 struct gdb_reader_funcs
*funcs
= NULL
;
172 struct cleanup
*old_cleanups
;
175 fprintf_unfiltered (gdb_stdlog
, _("Opening shared object %s.\n"),
177 so
= gdb_dlopen (file_name
);
178 old_cleanups
= make_cleanup_dlclose (so
);
180 init_fn
= gdb_dlsym (so
, reader_init_fn_sym
);
182 error (_("Could not locate initialization function: %s."),
185 if (gdb_dlsym (so
, "plugin_is_GPL_compatible") == NULL
)
186 error (_("Reader not GPL compatible."));
189 if (funcs
->reader_version
!= GDB_READER_INTERFACE_VERSION
)
190 error (_("Reader version does not match GDB version."));
192 new_reader
= XCNEW (struct jit_reader
);
193 new_reader
->functions
= funcs
;
194 new_reader
->handle
= so
;
196 discard_cleanups (old_cleanups
);
200 /* Provides the jit-reader-load command. */
203 jit_reader_load_command (char *args
, int from_tty
)
206 struct cleanup
*prev_cleanup
;
209 error (_("No reader name provided."));
211 if (loaded_jit_reader
!= NULL
)
212 error (_("JIT reader already loaded. Run jit-reader-unload first."));
214 if (IS_ABSOLUTE_PATH (args
))
215 so_name
= xstrdup (args
);
217 so_name
= xstrprintf ("%s%s%s", jit_reader_dir
, SLASH_STRING
, args
);
218 prev_cleanup
= make_cleanup (xfree
, so_name
);
220 loaded_jit_reader
= jit_reader_load (so_name
);
221 do_cleanups (prev_cleanup
);
224 /* Provides the jit-reader-unload command. */
227 jit_reader_unload_command (char *args
, int from_tty
)
229 if (!loaded_jit_reader
)
230 error (_("No JIT reader loaded."));
232 loaded_jit_reader
->functions
->destroy (loaded_jit_reader
->functions
);
234 gdb_dlclose (loaded_jit_reader
->handle
);
235 xfree (loaded_jit_reader
);
236 loaded_jit_reader
= NULL
;
239 /* Per-program space structure recording which objfile has the JIT
242 struct jit_program_space_data
244 /* The objfile. This is NULL if no objfile holds the JIT
247 struct objfile
*objfile
;
249 /* If this program space has __jit_debug_register_code, this is the
250 cached address from the minimal symbol. This is used to detect
251 relocations requiring the breakpoint to be re-created. */
253 CORE_ADDR cached_code_address
;
255 /* This is the JIT event breakpoint, or NULL if it has not been
258 struct breakpoint
*jit_breakpoint
;
261 /* Per-objfile structure recording the addresses in the program space.
262 This object serves two purposes: for ordinary objfiles, it may
263 cache some symbols related to the JIT interface; and for
264 JIT-created objfiles, it holds some information about the
267 struct jit_objfile_data
269 /* Symbol for __jit_debug_register_code. */
270 struct minimal_symbol
*register_code
;
272 /* Symbol for __jit_debug_descriptor. */
273 struct minimal_symbol
*descriptor
;
275 /* Address of struct jit_code_entry in this objfile. This is only
276 non-zero for objfiles that represent code created by the JIT. */
280 /* Fetch the jit_objfile_data associated with OBJF. If no data exists
281 yet, make a new structure and attach it. */
283 static struct jit_objfile_data
*
284 get_jit_objfile_data (struct objfile
*objf
)
286 struct jit_objfile_data
*objf_data
;
288 objf_data
= objfile_data (objf
, jit_objfile_data
);
289 if (objf_data
== NULL
)
291 objf_data
= XCNEW (struct jit_objfile_data
);
292 set_objfile_data (objf
, jit_objfile_data
, objf_data
);
298 /* Remember OBJFILE has been created for struct jit_code_entry located
299 at inferior address ENTRY. */
302 add_objfile_entry (struct objfile
*objfile
, CORE_ADDR entry
)
304 struct jit_objfile_data
*objf_data
;
306 objf_data
= get_jit_objfile_data (objfile
);
307 objf_data
->addr
= entry
;
310 /* Return jit_program_space_data for current program space. Allocate
311 if not already present. */
313 static struct jit_program_space_data
*
314 get_jit_program_space_data (void)
316 struct jit_program_space_data
*ps_data
;
318 ps_data
= program_space_data (current_program_space
, jit_program_space_data
);
321 ps_data
= XCNEW (struct jit_program_space_data
);
322 set_program_space_data (current_program_space
, jit_program_space_data
,
330 jit_program_space_data_cleanup (struct program_space
*ps
, void *arg
)
335 /* Helper function for reading the global JIT descriptor from remote
336 memory. Returns 1 if all went well, 0 otherwise. */
339 jit_read_descriptor (struct gdbarch
*gdbarch
,
340 struct jit_descriptor
*descriptor
,
341 struct jit_program_space_data
*ps_data
)
344 struct type
*ptr_type
;
348 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
349 struct jit_objfile_data
*objf_data
;
351 if (ps_data
->objfile
== NULL
)
353 objf_data
= get_jit_objfile_data (ps_data
->objfile
);
354 if (objf_data
->descriptor
== NULL
)
358 fprintf_unfiltered (gdb_stdlog
,
359 "jit_read_descriptor, descriptor_addr = %s\n",
360 paddress (gdbarch
, MSYMBOL_VALUE_ADDRESS (ps_data
->objfile
,
361 objf_data
->descriptor
)));
363 /* Figure out how big the descriptor is on the remote and how to read it. */
364 ptr_type
= builtin_type (gdbarch
)->builtin_data_ptr
;
365 ptr_size
= TYPE_LENGTH (ptr_type
);
366 desc_size
= 8 + 2 * ptr_size
; /* Two 32-bit ints and two pointers. */
367 desc_buf
= alloca (desc_size
);
369 /* Read the descriptor. */
370 err
= target_read_memory (MSYMBOL_VALUE_ADDRESS (ps_data
->objfile
,
371 objf_data
->descriptor
),
372 desc_buf
, desc_size
);
375 printf_unfiltered (_("Unable to read JIT descriptor from "
380 /* Fix the endianness to match the host. */
381 descriptor
->version
= extract_unsigned_integer (&desc_buf
[0], 4, byte_order
);
382 descriptor
->action_flag
=
383 extract_unsigned_integer (&desc_buf
[4], 4, byte_order
);
384 descriptor
->relevant_entry
= extract_typed_address (&desc_buf
[8], ptr_type
);
385 descriptor
->first_entry
=
386 extract_typed_address (&desc_buf
[8 + ptr_size
], ptr_type
);
391 /* Helper function for reading a JITed code entry from remote memory. */
394 jit_read_code_entry (struct gdbarch
*gdbarch
,
395 CORE_ADDR code_addr
, struct jit_code_entry
*code_entry
)
398 struct type
*ptr_type
;
403 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
405 /* Figure out how big the entry is on the remote and how to read it. */
406 ptr_type
= builtin_type (gdbarch
)->builtin_data_ptr
;
407 ptr_size
= TYPE_LENGTH (ptr_type
);
409 /* Figure out where the longlong value will be. */
410 align_bytes
= gdbarch_long_long_align_bit (gdbarch
) / 8;
412 off
= (off
+ (align_bytes
- 1)) & ~(align_bytes
- 1);
414 entry_size
= off
+ 8; /* Three pointers and one 64-bit int. */
415 entry_buf
= alloca (entry_size
);
417 /* Read the entry. */
418 err
= target_read_memory (code_addr
, entry_buf
, entry_size
);
420 error (_("Unable to read JIT code entry from remote memory!"));
422 /* Fix the endianness to match the host. */
423 ptr_type
= builtin_type (gdbarch
)->builtin_data_ptr
;
424 code_entry
->next_entry
= extract_typed_address (&entry_buf
[0], ptr_type
);
425 code_entry
->prev_entry
=
426 extract_typed_address (&entry_buf
[ptr_size
], ptr_type
);
427 code_entry
->symfile_addr
=
428 extract_typed_address (&entry_buf
[2 * ptr_size
], ptr_type
);
429 code_entry
->symfile_size
=
430 extract_unsigned_integer (&entry_buf
[off
], 8, byte_order
);
433 /* Proxy object for building a block. */
437 /* gdb_blocks are linked into a tree structure. Next points to the
438 next node at the same depth as this block and parent to the
440 struct gdb_block
*next
, *parent
;
442 /* Points to the "real" block that is being built out of this
443 instance. This block will be added to a blockvector, which will
444 then be added to a symtab. */
445 struct block
*real_block
;
447 /* The first and last code address corresponding to this block. */
448 CORE_ADDR begin
, end
;
450 /* The name of this block (if any). If this is non-NULL, the
451 FUNCTION symbol symbol is set to this value. */
455 /* Proxy object for building a symtab. */
459 /* The list of blocks in this symtab. These will eventually be
460 converted to real blocks. */
461 struct gdb_block
*blocks
;
463 /* The number of blocks inserted. */
466 /* A mapping between line numbers to PC. */
467 struct linetable
*linetable
;
469 /* The source file for this symtab. */
470 const char *file_name
;
471 struct gdb_symtab
*next
;
474 /* Proxy object for building an object. */
478 struct gdb_symtab
*symtabs
;
481 /* The type of the `private' data passed around by the callback
484 typedef CORE_ADDR jit_dbg_reader_data
;
486 /* The reader calls into this function to read data off the targets
489 static enum gdb_status
490 jit_target_read_impl (GDB_CORE_ADDR target_mem
, void *gdb_buf
, int len
)
492 int result
= target_read_memory ((CORE_ADDR
) target_mem
, gdb_buf
, len
);
499 /* The reader calls into this function to create a new gdb_object
500 which it can then pass around to the other callbacks. Right now,
501 all that is required is allocating the memory. */
503 static struct gdb_object
*
504 jit_object_open_impl (struct gdb_symbol_callbacks
*cb
)
506 /* CB is not required right now, but sometime in the future we might
507 need a handle to it, and we'd like to do that without breaking
509 return XCNEW (struct gdb_object
);
512 /* Readers call into this function to open a new gdb_symtab, which,
513 again, is passed around to other callbacks. */
515 static struct gdb_symtab
*
516 jit_symtab_open_impl (struct gdb_symbol_callbacks
*cb
,
517 struct gdb_object
*object
,
518 const char *file_name
)
520 struct gdb_symtab
*ret
;
522 /* CB stays unused. See comment in jit_object_open_impl. */
524 ret
= XCNEW (struct gdb_symtab
);
525 ret
->file_name
= file_name
? xstrdup (file_name
) : xstrdup ("");
526 ret
->next
= object
->symtabs
;
527 object
->symtabs
= ret
;
531 /* Returns true if the block corresponding to old should be placed
532 before the block corresponding to new in the final blockvector. */
535 compare_block (const struct gdb_block
*const old
,
536 const struct gdb_block
*const new)
540 if (old
->begin
< new->begin
)
542 else if (old
->begin
== new->begin
)
544 if (old
->end
> new->end
)
553 /* Called by readers to open a new gdb_block. This function also
554 inserts the new gdb_block in the correct place in the corresponding
557 static struct gdb_block
*
558 jit_block_open_impl (struct gdb_symbol_callbacks
*cb
,
559 struct gdb_symtab
*symtab
, struct gdb_block
*parent
,
560 GDB_CORE_ADDR begin
, GDB_CORE_ADDR end
, const char *name
)
562 struct gdb_block
*block
= XCNEW (struct gdb_block
);
564 block
->next
= symtab
->blocks
;
565 block
->begin
= (CORE_ADDR
) begin
;
566 block
->end
= (CORE_ADDR
) end
;
567 block
->name
= name
? xstrdup (name
) : NULL
;
568 block
->parent
= parent
;
570 /* Ensure that the blocks are inserted in the correct (reverse of
571 the order expected by blockvector). */
572 if (compare_block (symtab
->blocks
, block
))
574 symtab
->blocks
= block
;
578 struct gdb_block
*i
= symtab
->blocks
;
582 /* Guaranteed to terminate, since compare_block (NULL, _)
584 if (compare_block (i
->next
, block
))
586 block
->next
= i
->next
;
597 /* Readers call this to add a line mapping (from PC to line number) to
601 jit_symtab_line_mapping_add_impl (struct gdb_symbol_callbacks
*cb
,
602 struct gdb_symtab
*stab
, int nlines
,
603 struct gdb_line_mapping
*map
)
610 stab
->linetable
= xmalloc (sizeof (struct linetable
)
611 + (nlines
- 1) * sizeof (struct linetable_entry
));
612 stab
->linetable
->nitems
= nlines
;
613 for (i
= 0; i
< nlines
; i
++)
615 stab
->linetable
->item
[i
].pc
= (CORE_ADDR
) map
[i
].pc
;
616 stab
->linetable
->item
[i
].line
= map
[i
].line
;
620 /* Called by readers to close a gdb_symtab. Does not need to do
621 anything as of now. */
624 jit_symtab_close_impl (struct gdb_symbol_callbacks
*cb
,
625 struct gdb_symtab
*stab
)
627 /* Right now nothing needs to be done here. We may need to do some
628 cleanup here in the future (again, without breaking the plugin
632 /* Transform STAB to a proper symtab, and add it it OBJFILE. */
635 finalize_symtab (struct gdb_symtab
*stab
, struct objfile
*objfile
)
637 struct symtab
*symtab
;
638 struct gdb_block
*gdb_block_iter
, *gdb_block_iter_tmp
;
639 struct block
*block_iter
;
640 int actual_nblocks
, i
, blockvector_size
;
641 CORE_ADDR begin
, end
;
643 actual_nblocks
= FIRST_LOCAL_BLOCK
+ stab
->nblocks
;
645 symtab
= allocate_symtab (stab
->file_name
, objfile
);
646 /* JIT compilers compile in memory. */
647 symtab
->dirname
= NULL
;
649 /* Copy over the linetable entry if one was provided. */
652 int size
= ((stab
->linetable
->nitems
- 1)
653 * sizeof (struct linetable_entry
)
654 + sizeof (struct linetable
));
655 LINETABLE (symtab
) = obstack_alloc (&objfile
->objfile_obstack
, size
);
656 memcpy (LINETABLE (symtab
), stab
->linetable
, size
);
660 LINETABLE (symtab
) = NULL
;
663 blockvector_size
= (sizeof (struct blockvector
)
664 + (actual_nblocks
- 1) * sizeof (struct block
*));
665 symtab
->blockvector
= obstack_alloc (&objfile
->objfile_obstack
,
668 /* (begin, end) will contain the PC range this entire blockvector
670 set_symtab_primary (symtab
, 1);
671 BLOCKVECTOR_MAP (symtab
->blockvector
) = NULL
;
672 begin
= stab
->blocks
->begin
;
673 end
= stab
->blocks
->end
;
674 BLOCKVECTOR_NBLOCKS (symtab
->blockvector
) = 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_DICT (new_block
) = dict_create_linear (&objfile
->objfile_obstack
,
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_SYMTAB (block_name
) = symtab
;
700 SYMBOL_TYPE (block_name
) = lookup_function_type (block_type
);
701 SYMBOL_BLOCK_VALUE (block_name
) = new_block
;
703 block_name
->ginfo
.name
= obstack_copy0 (&objfile
->objfile_obstack
,
704 gdb_block_iter
->name
,
705 strlen (gdb_block_iter
->name
));
707 BLOCK_FUNCTION (new_block
) = block_name
;
709 BLOCKVECTOR_BLOCK (symtab
->blockvector
, i
) = new_block
;
710 if (begin
> BLOCK_START (new_block
))
711 begin
= BLOCK_START (new_block
);
712 if (end
< BLOCK_END (new_block
))
713 end
= BLOCK_END (new_block
);
715 gdb_block_iter
->real_block
= new_block
;
718 /* Now add the special blocks. */
720 for (i
= 0; i
< FIRST_LOCAL_BLOCK
; i
++)
722 struct block
*new_block
;
724 new_block
= (i
== GLOBAL_BLOCK
725 ? allocate_global_block (&objfile
->objfile_obstack
)
726 : allocate_block (&objfile
->objfile_obstack
));
727 BLOCK_DICT (new_block
) = dict_create_linear (&objfile
->objfile_obstack
,
729 BLOCK_SUPERBLOCK (new_block
) = block_iter
;
730 block_iter
= new_block
;
732 BLOCK_START (new_block
) = (CORE_ADDR
) begin
;
733 BLOCK_END (new_block
) = (CORE_ADDR
) end
;
735 BLOCKVECTOR_BLOCK (symtab
->blockvector
, i
) = new_block
;
737 if (i
== GLOBAL_BLOCK
)
738 set_block_symtab (new_block
, symtab
);
741 /* Fill up the superblock fields for the real blocks, using the
742 real_block fields populated earlier. */
743 for (gdb_block_iter
= stab
->blocks
;
745 gdb_block_iter
= gdb_block_iter
->next
)
747 if (gdb_block_iter
->parent
!= NULL
)
749 /* If the plugin specifically mentioned a parent block, we
751 BLOCK_SUPERBLOCK (gdb_block_iter
->real_block
) =
752 gdb_block_iter
->parent
->real_block
;
756 /* And if not, we set a default parent block. */
757 BLOCK_SUPERBLOCK (gdb_block_iter
->real_block
) =
758 BLOCKVECTOR_BLOCK (symtab
->blockvector
, STATIC_BLOCK
);
763 gdb_block_iter
= stab
->blocks
;
765 for (gdb_block_iter
= stab
->blocks
, gdb_block_iter_tmp
= gdb_block_iter
->next
;
767 gdb_block_iter
= gdb_block_iter_tmp
)
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
= cb
->priv_data
;
790 objfile
= allocate_objfile (NULL
, "<< JIT compiled code >>",
792 objfile
->per_bfd
->gdbarch
= target_gdbarch ();
794 terminate_minimal_symbol_table (objfile
);
797 for (i
= obj
->symtabs
; i
; i
= j
)
800 finalize_symtab (i
, objfile
);
802 add_objfile_entry (objfile
, *priv_data
);
806 /* Try to read CODE_ENTRY using the loaded jit reader (if any).
807 ENTRY_ADDR is the address of the struct jit_code_entry in the
808 inferior address space. */
811 jit_reader_try_read_symtab (struct jit_code_entry
*code_entry
,
812 CORE_ADDR entry_addr
)
816 jit_dbg_reader_data priv_data
;
817 struct gdb_reader_funcs
*funcs
;
818 volatile struct gdb_exception e
;
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_mem
= xmalloc (code_entry
->symfile_size
);
841 TRY_CATCH (e
, RETURN_MASK_ALL
)
842 if (target_read_memory (code_entry
->symfile_addr
, gdb_mem
,
843 code_entry
->symfile_size
))
850 funcs
= loaded_jit_reader
->functions
;
851 if (funcs
->read (funcs
, &callbacks
, gdb_mem
, 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
)
872 struct section_addr_info
*sai
;
873 struct bfd_section
*sec
;
874 struct objfile
*objfile
;
875 struct cleanup
*old_cleanups
;
877 const struct bfd_arch_info
*b
;
880 fprintf_unfiltered (gdb_stdlog
,
881 "jit_register_code, symfile_addr = %s, "
882 "symfile_size = %s\n",
883 paddress (gdbarch
, code_entry
->symfile_addr
),
884 pulongest (code_entry
->symfile_size
));
886 nbfd
= bfd_open_from_target_memory (code_entry
->symfile_addr
,
887 code_entry
->symfile_size
, gnutarget
);
890 puts_unfiltered (_("Error opening JITed symbol file, ignoring it.\n"));
894 /* Check the format. NOTE: This initializes important data that GDB uses!
895 We would segfault later without this line. */
896 if (!bfd_check_format (nbfd
, bfd_object
))
898 printf_unfiltered (_("\
899 JITed symbol file is not an object file, ignoring it.\n"));
900 gdb_bfd_unref (nbfd
);
904 /* Check bfd arch. */
905 b
= gdbarch_bfd_arch_info (gdbarch
);
906 if (b
->compatible (b
, bfd_get_arch_info (nbfd
)) != b
)
907 warning (_("JITed object file architecture %s is not compatible "
908 "with target architecture %s."), bfd_get_arch_info
909 (nbfd
)->printable_name
, b
->printable_name
);
911 /* Read the section address information out of the symbol file. Since the
912 file is generated by the JIT at runtime, it should all of the absolute
913 addresses that we care about. */
914 sai
= alloc_section_addr_info (bfd_count_sections (nbfd
));
915 old_cleanups
= make_cleanup_free_section_addr_info (sai
);
917 for (sec
= nbfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
918 if ((bfd_get_section_flags (nbfd
, sec
) & (SEC_ALLOC
|SEC_LOAD
)) != 0)
920 /* We assume that these virtual addresses are absolute, and do not
921 treat them as offsets. */
922 sai
->other
[i
].addr
= bfd_get_section_vma (nbfd
, sec
);
923 sai
->other
[i
].name
= xstrdup (bfd_get_section_name (nbfd
, sec
));
924 sai
->other
[i
].sectindex
= sec
->index
;
927 sai
->num_sections
= i
;
929 /* This call does not take ownership of SAI. */
930 make_cleanup_bfd_unref (nbfd
);
931 objfile
= symbol_file_add_from_bfd (nbfd
, bfd_get_filename (nbfd
), 0, sai
,
932 OBJF_SHARED
| OBJF_NOT_FILENAME
, NULL
);
934 do_cleanups (old_cleanups
);
935 add_objfile_entry (objfile
, entry_addr
);
938 /* This function registers code associated with a JIT code entry. It uses the
939 pointer and size pair in the entry to read the symbol file from the remote
940 and then calls symbol_file_add_from_local_memory to add it as though it were
941 a symbol file added by the user. */
944 jit_register_code (struct gdbarch
*gdbarch
,
945 CORE_ADDR entry_addr
, struct jit_code_entry
*code_entry
)
950 fprintf_unfiltered (gdb_stdlog
,
951 "jit_register_code, symfile_addr = %s, "
952 "symfile_size = %s\n",
953 paddress (gdbarch
, code_entry
->symfile_addr
),
954 pulongest (code_entry
->symfile_size
));
956 success
= jit_reader_try_read_symtab (code_entry
, entry_addr
);
959 jit_bfd_try_read_symtab (code_entry
, entry_addr
, gdbarch
);
962 /* This function unregisters JITed code and frees the corresponding
966 jit_unregister_code (struct objfile
*objfile
)
968 free_objfile (objfile
);
971 /* Look up the objfile with this code entry address. */
973 static struct objfile
*
974 jit_find_objf_with_entry_addr (CORE_ADDR entry_addr
)
976 struct objfile
*objf
;
980 struct jit_objfile_data
*objf_data
;
982 objf_data
= objfile_data (objf
, jit_objfile_data
);
983 if (objf_data
!= NULL
&& objf_data
->addr
== entry_addr
)
989 /* This is called when a breakpoint is deleted. It updates the
990 inferior's cache, if needed. */
993 jit_breakpoint_deleted (struct breakpoint
*b
)
995 struct bp_location
*iter
;
997 if (b
->type
!= bp_jit_event
)
1000 for (iter
= b
->loc
; iter
!= NULL
; iter
= iter
->next
)
1002 struct jit_program_space_data
*ps_data
;
1004 ps_data
= program_space_data (iter
->pspace
, jit_program_space_data
);
1005 if (ps_data
!= NULL
&& ps_data
->jit_breakpoint
== iter
->owner
)
1007 ps_data
->cached_code_address
= 0;
1008 ps_data
->jit_breakpoint
= NULL
;
1013 /* (Re-)Initialize the jit breakpoint if necessary.
1014 Return 0 on success. */
1017 jit_breakpoint_re_set_internal (struct gdbarch
*gdbarch
,
1018 struct jit_program_space_data
*ps_data
)
1020 struct bound_minimal_symbol reg_symbol
;
1021 struct bound_minimal_symbol desc_symbol
;
1022 struct jit_objfile_data
*objf_data
;
1025 if (ps_data
->objfile
== NULL
)
1027 /* Lookup the registration symbol. If it is missing, then we
1028 assume we are not attached to a JIT. */
1029 reg_symbol
= lookup_minimal_symbol_and_objfile (jit_break_name
);
1030 if (reg_symbol
.minsym
== NULL
1031 || BMSYMBOL_VALUE_ADDRESS (reg_symbol
) == 0)
1034 desc_symbol
= lookup_minimal_symbol (jit_descriptor_name
, NULL
,
1035 reg_symbol
.objfile
);
1036 if (desc_symbol
.minsym
== NULL
1037 || BMSYMBOL_VALUE_ADDRESS (desc_symbol
) == 0)
1040 objf_data
= get_jit_objfile_data (reg_symbol
.objfile
);
1041 objf_data
->register_code
= reg_symbol
.minsym
;
1042 objf_data
->descriptor
= desc_symbol
.minsym
;
1044 ps_data
->objfile
= reg_symbol
.objfile
;
1047 objf_data
= get_jit_objfile_data (ps_data
->objfile
);
1049 addr
= MSYMBOL_VALUE_ADDRESS (ps_data
->objfile
, objf_data
->register_code
);
1052 fprintf_unfiltered (gdb_stdlog
,
1053 "jit_breakpoint_re_set_internal, "
1054 "breakpoint_addr = %s\n",
1055 paddress (gdbarch
, addr
));
1057 if (ps_data
->cached_code_address
== addr
)
1060 /* Delete the old breakpoint. */
1061 if (ps_data
->jit_breakpoint
!= NULL
)
1062 delete_breakpoint (ps_data
->jit_breakpoint
);
1064 /* Put a breakpoint in the registration symbol. */
1065 ps_data
->cached_code_address
= addr
;
1066 ps_data
->jit_breakpoint
= create_jit_event_breakpoint (gdbarch
, addr
);
1071 /* The private data passed around in the frame unwind callback
1074 struct jit_unwind_private
1076 /* Cached register values. See jit_frame_sniffer to see how this
1078 struct gdb_reg_value
**registers
;
1080 /* The frame being unwound. */
1081 struct frame_info
*this_frame
;
1084 /* Sets the value of a particular register in this frame. */
1087 jit_unwind_reg_set_impl (struct gdb_unwind_callbacks
*cb
, int dwarf_regnum
,
1088 struct gdb_reg_value
*value
)
1090 struct jit_unwind_private
*priv
;
1093 priv
= cb
->priv_data
;
1095 gdb_reg
= gdbarch_dwarf2_reg_to_regnum (get_frame_arch (priv
->this_frame
),
1100 fprintf_unfiltered (gdb_stdlog
,
1101 _("Could not recognize DWARF regnum %d"),
1106 gdb_assert (priv
->registers
);
1107 priv
->registers
[gdb_reg
] = value
;
1111 reg_value_free_impl (struct gdb_reg_value
*value
)
1116 /* Get the value of register REGNUM in the previous frame. */
1118 static struct gdb_reg_value
*
1119 jit_unwind_reg_get_impl (struct gdb_unwind_callbacks
*cb
, int regnum
)
1121 struct jit_unwind_private
*priv
;
1122 struct gdb_reg_value
*value
;
1124 struct gdbarch
*frame_arch
;
1126 priv
= cb
->priv_data
;
1127 frame_arch
= get_frame_arch (priv
->this_frame
);
1129 gdb_reg
= gdbarch_dwarf2_reg_to_regnum (frame_arch
, regnum
);
1130 size
= register_size (frame_arch
, gdb_reg
);
1131 value
= xmalloc (sizeof (struct gdb_reg_value
) + size
- 1);
1132 value
->defined
= deprecated_frame_register_read (priv
->this_frame
, gdb_reg
,
1135 value
->free
= reg_value_free_impl
;
1139 /* gdb_reg_value has a free function, which must be called on each
1140 saved register value. */
1143 jit_dealloc_cache (struct frame_info
*this_frame
, void *cache
)
1145 struct jit_unwind_private
*priv_data
= cache
;
1146 struct gdbarch
*frame_arch
;
1149 gdb_assert (priv_data
->registers
);
1150 frame_arch
= get_frame_arch (priv_data
->this_frame
);
1152 for (i
= 0; i
< gdbarch_num_regs (frame_arch
); i
++)
1153 if (priv_data
->registers
[i
] && priv_data
->registers
[i
]->free
)
1154 priv_data
->registers
[i
]->free (priv_data
->registers
[i
]);
1156 xfree (priv_data
->registers
);
1160 /* The frame sniffer for the pseudo unwinder.
1162 While this is nominally a frame sniffer, in the case where the JIT
1163 reader actually recognizes the frame, it does a lot more work -- it
1164 unwinds the frame and saves the corresponding register values in
1165 the cache. jit_frame_prev_register simply returns the saved
1169 jit_frame_sniffer (const struct frame_unwind
*self
,
1170 struct frame_info
*this_frame
, void **cache
)
1172 struct jit_unwind_private
*priv_data
;
1173 struct gdb_unwind_callbacks callbacks
;
1174 struct gdb_reader_funcs
*funcs
;
1176 callbacks
.reg_get
= jit_unwind_reg_get_impl
;
1177 callbacks
.reg_set
= jit_unwind_reg_set_impl
;
1178 callbacks
.target_read
= jit_target_read_impl
;
1180 if (loaded_jit_reader
== NULL
)
1183 funcs
= loaded_jit_reader
->functions
;
1185 gdb_assert (!*cache
);
1187 *cache
= XCNEW (struct jit_unwind_private
);
1189 priv_data
->registers
=
1190 XCNEWVEC (struct gdb_reg_value
*,
1191 gdbarch_num_regs (get_frame_arch (this_frame
)));
1192 priv_data
->this_frame
= this_frame
;
1194 callbacks
.priv_data
= priv_data
;
1196 /* Try to coax the provided unwinder to unwind the stack */
1197 if (funcs
->unwind (funcs
, &callbacks
) == GDB_SUCCESS
)
1200 fprintf_unfiltered (gdb_stdlog
, _("Successfully unwound frame using "
1205 fprintf_unfiltered (gdb_stdlog
, _("Could not unwind frame using "
1208 jit_dealloc_cache (this_frame
, *cache
);
1215 /* The frame_id function for the pseudo unwinder. Relays the call to
1216 the loaded plugin. */
1219 jit_frame_this_id (struct frame_info
*this_frame
, void **cache
,
1220 struct frame_id
*this_id
)
1222 struct jit_unwind_private
private;
1223 struct gdb_frame_id frame_id
;
1224 struct gdb_reader_funcs
*funcs
;
1225 struct gdb_unwind_callbacks callbacks
;
1227 private.registers
= NULL
;
1228 private.this_frame
= this_frame
;
1230 /* We don't expect the frame_id function to set any registers, so we
1231 set reg_set to NULL. */
1232 callbacks
.reg_get
= jit_unwind_reg_get_impl
;
1233 callbacks
.reg_set
= NULL
;
1234 callbacks
.target_read
= jit_target_read_impl
;
1235 callbacks
.priv_data
= &private;
1237 gdb_assert (loaded_jit_reader
);
1238 funcs
= loaded_jit_reader
->functions
;
1240 frame_id
= funcs
->get_frame_id (funcs
, &callbacks
);
1241 *this_id
= frame_id_build (frame_id
.stack_address
, frame_id
.code_address
);
1244 /* Pseudo unwinder function. Reads the previously fetched value for
1245 the register from the cache. */
1247 static struct value
*
1248 jit_frame_prev_register (struct frame_info
*this_frame
, void **cache
, int reg
)
1250 struct jit_unwind_private
*priv
= *cache
;
1251 struct gdb_reg_value
*value
;
1254 return frame_unwind_got_optimized (this_frame
, reg
);
1256 gdb_assert (priv
->registers
);
1257 value
= priv
->registers
[reg
];
1258 if (value
&& value
->defined
)
1259 return frame_unwind_got_bytes (this_frame
, reg
, value
->value
);
1261 return frame_unwind_got_optimized (this_frame
, reg
);
1264 /* Relay everything back to the unwinder registered by the JIT debug
1267 static const struct frame_unwind jit_frame_unwind
=
1270 default_frame_unwind_stop_reason
,
1272 jit_frame_prev_register
,
1279 /* This is the information that is stored at jit_gdbarch_data for each
1282 struct jit_gdbarch_data_type
1284 /* Has the (pseudo) unwinder been prepended? */
1285 int unwinder_registered
;
1288 /* Check GDBARCH and prepend the pseudo JIT unwinder if needed. */
1291 jit_prepend_unwinder (struct gdbarch
*gdbarch
)
1293 struct jit_gdbarch_data_type
*data
;
1295 data
= gdbarch_data (gdbarch
, jit_gdbarch_data
);
1296 if (!data
->unwinder_registered
)
1298 frame_unwind_prepend_unwinder (gdbarch
, &jit_frame_unwind
);
1299 data
->unwinder_registered
= 1;
1303 /* Register any already created translations. */
1306 jit_inferior_init (struct gdbarch
*gdbarch
)
1308 struct jit_descriptor descriptor
;
1309 struct jit_code_entry cur_entry
;
1310 struct jit_program_space_data
*ps_data
;
1311 CORE_ADDR cur_entry_addr
;
1314 fprintf_unfiltered (gdb_stdlog
, "jit_inferior_init\n");
1316 jit_prepend_unwinder (gdbarch
);
1318 ps_data
= get_jit_program_space_data ();
1319 if (jit_breakpoint_re_set_internal (gdbarch
, ps_data
) != 0)
1322 /* Read the descriptor so we can check the version number and load
1323 any already JITed functions. */
1324 if (!jit_read_descriptor (gdbarch
, &descriptor
, ps_data
))
1327 /* Check that the version number agrees with that we support. */
1328 if (descriptor
.version
!= 1)
1330 printf_unfiltered (_("Unsupported JIT protocol version %ld "
1331 "in descriptor (expected 1)\n"),
1332 (long) descriptor
.version
);
1336 /* If we've attached to a running program, we need to check the descriptor
1337 to register any functions that were already generated. */
1338 for (cur_entry_addr
= descriptor
.first_entry
;
1339 cur_entry_addr
!= 0;
1340 cur_entry_addr
= cur_entry
.next_entry
)
1342 jit_read_code_entry (gdbarch
, cur_entry_addr
, &cur_entry
);
1344 /* This hook may be called many times during setup, so make sure we don't
1345 add the same symbol file twice. */
1346 if (jit_find_objf_with_entry_addr (cur_entry_addr
) != NULL
)
1349 jit_register_code (gdbarch
, cur_entry_addr
, &cur_entry
);
1353 /* Exported routine to call when an inferior has been created. */
1356 jit_inferior_created_hook (void)
1358 jit_inferior_init (target_gdbarch ());
1361 /* Exported routine to call to re-set the jit breakpoints,
1362 e.g. when a program is rerun. */
1365 jit_breakpoint_re_set (void)
1367 jit_breakpoint_re_set_internal (target_gdbarch (),
1368 get_jit_program_space_data ());
1371 /* This function cleans up any code entries left over when the
1372 inferior exits. We get left over code when the inferior exits
1373 without unregistering its code, for example when it crashes. */
1376 jit_inferior_exit_hook (struct inferior
*inf
)
1378 struct objfile
*objf
;
1379 struct objfile
*temp
;
1381 ALL_OBJFILES_SAFE (objf
, temp
)
1383 struct jit_objfile_data
*objf_data
= objfile_data (objf
,
1386 if (objf_data
!= NULL
&& objf_data
->addr
!= 0)
1387 jit_unregister_code (objf
);
1392 jit_event_handler (struct gdbarch
*gdbarch
)
1394 struct jit_descriptor descriptor
;
1395 struct jit_code_entry code_entry
;
1396 CORE_ADDR entry_addr
;
1397 struct objfile
*objf
;
1399 /* Read the descriptor from remote memory. */
1400 if (!jit_read_descriptor (gdbarch
, &descriptor
,
1401 get_jit_program_space_data ()))
1403 entry_addr
= descriptor
.relevant_entry
;
1405 /* Do the corresponding action. */
1406 switch (descriptor
.action_flag
)
1411 jit_read_code_entry (gdbarch
, entry_addr
, &code_entry
);
1412 jit_register_code (gdbarch
, entry_addr
, &code_entry
);
1414 case JIT_UNREGISTER
:
1415 objf
= jit_find_objf_with_entry_addr (entry_addr
);
1417 printf_unfiltered (_("Unable to find JITed code "
1418 "entry at address: %s\n"),
1419 paddress (gdbarch
, entry_addr
));
1421 jit_unregister_code (objf
);
1425 error (_("Unknown action_flag value in JIT descriptor!"));
1430 /* Called to free the data allocated to the jit_program_space_data slot. */
1433 free_objfile_data (struct objfile
*objfile
, void *data
)
1435 struct jit_objfile_data
*objf_data
= data
;
1437 if (objf_data
->register_code
!= NULL
)
1439 struct jit_program_space_data
*ps_data
;
1441 ps_data
= program_space_data (objfile
->pspace
, jit_program_space_data
);
1442 if (ps_data
!= NULL
&& ps_data
->objfile
== objfile
)
1443 ps_data
->objfile
= NULL
;
1449 /* Initialize the jit_gdbarch_data slot with an instance of struct
1450 jit_gdbarch_data_type */
1453 jit_gdbarch_data_init (struct obstack
*obstack
)
1455 struct jit_gdbarch_data_type
*data
;
1457 data
= obstack_alloc (obstack
, sizeof (struct jit_gdbarch_data_type
));
1458 data
->unwinder_registered
= 0;
1462 /* Provide a prototype to silence -Wmissing-prototypes. */
1464 extern void _initialize_jit (void);
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 observer_attach_inferior_exit (jit_inferior_exit_hook
);
1480 observer_attach_breakpoint_deleted (jit_breakpoint_deleted
);
1483 register_objfile_data_with_cleanup (NULL
, free_objfile_data
);
1484 jit_program_space_data
=
1485 register_program_space_data_with_cleanup (NULL
,
1486 jit_program_space_data_cleanup
);
1487 jit_gdbarch_data
= gdbarch_data_register_pre_init (jit_gdbarch_data_init
);
1488 if (is_dl_available ())
1490 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 add_com ("jit-reader-unload", no_class
, jit_reader_unload_command
, _("\
1497 Unload the currently loaded JIT debug info reader.\n\
1498 Usage: jit-reader-unload FILE\n\n\
1499 Do \"help jit-reader-load\" for info on loading debug info readers."));