1 /* Handle JIT code generation in the inferior for GDB, the GNU Debugger.
3 Copyright (C) 2009-2015 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"
43 static const char *jit_reader_dir
= NULL
;
45 static const struct objfile_data
*jit_objfile_data
;
47 static const char *const jit_break_name
= "__jit_debug_register_code";
49 static const char *const jit_descriptor_name
= "__jit_debug_descriptor";
51 static const struct program_space_data
*jit_program_space_data
= NULL
;
53 static void jit_inferior_init (struct gdbarch
*gdbarch
);
55 /* An unwinder is registered for every gdbarch. This key is used to
56 remember if the unwinder has been registered for a particular
59 static struct gdbarch_data
*jit_gdbarch_data
;
61 /* Non-zero if we want to see trace of jit level stuff. */
63 static unsigned int jit_debug
= 0;
66 show_jit_debug (struct ui_file
*file
, int from_tty
,
67 struct cmd_list_element
*c
, const char *value
)
69 fprintf_filtered (file
, _("JIT debugging is %s.\n"), value
);
78 /* Openning the file is a no-op. */
81 mem_bfd_iovec_open (struct bfd
*abfd
, void *open_closure
)
86 /* Closing the file is just freeing the base/size pair on our side. */
89 mem_bfd_iovec_close (struct bfd
*abfd
, void *stream
)
93 /* Zero means success. */
97 /* For reading the file, we just need to pass through to target_read_memory and
98 fix up the arguments and return values. */
101 mem_bfd_iovec_pread (struct bfd
*abfd
, void *stream
, void *buf
,
102 file_ptr nbytes
, file_ptr offset
)
105 struct target_buffer
*buffer
= (struct target_buffer
*) stream
;
107 /* If this read will read all of the file, limit it to just the rest. */
108 if (offset
+ nbytes
> buffer
->size
)
109 nbytes
= buffer
->size
- offset
;
111 /* If there are no more bytes left, we've reached EOF. */
115 err
= target_read_memory (buffer
->base
+ offset
, (gdb_byte
*) buf
, nbytes
);
122 /* For statting the file, we only support the st_size attribute. */
125 mem_bfd_iovec_stat (struct bfd
*abfd
, void *stream
, struct stat
*sb
)
127 struct target_buffer
*buffer
= (struct target_buffer
*) stream
;
129 memset (sb
, 0, sizeof (struct stat
));
130 sb
->st_size
= buffer
->size
;
134 /* Open a BFD from the target's memory. */
137 bfd_open_from_target_memory (CORE_ADDR addr
, ULONGEST size
, char *target
)
139 struct target_buffer
*buffer
= XNEW (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
= (gdb_byte
*) 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
= (gdb_byte
*) 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 newobj
)
540 if (old
->begin
< newobj
->begin
)
542 else if (old
->begin
== newobj
->begin
)
544 if (old
->end
> newobj
->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
)
611 alloc_len
= sizeof (struct linetable
)
612 + (nlines
- 1) * sizeof (struct linetable_entry
);
613 stab
->linetable
= (struct linetable
*) xmalloc (alloc_len
);
614 stab
->linetable
->nitems
= nlines
;
615 for (i
= 0; i
< nlines
; i
++)
617 stab
->linetable
->item
[i
].pc
= (CORE_ADDR
) map
[i
].pc
;
618 stab
->linetable
->item
[i
].line
= map
[i
].line
;
622 /* Called by readers to close a gdb_symtab. Does not need to do
623 anything as of now. */
626 jit_symtab_close_impl (struct gdb_symbol_callbacks
*cb
,
627 struct gdb_symtab
*stab
)
629 /* Right now nothing needs to be done here. We may need to do some
630 cleanup here in the future (again, without breaking the plugin
634 /* Transform STAB to a proper symtab, and add it it OBJFILE. */
637 finalize_symtab (struct gdb_symtab
*stab
, struct objfile
*objfile
)
639 struct compunit_symtab
*cust
;
640 struct gdb_block
*gdb_block_iter
, *gdb_block_iter_tmp
;
641 struct block
*block_iter
;
642 int actual_nblocks
, i
;
643 size_t blockvector_size
;
644 CORE_ADDR begin
, end
;
645 struct blockvector
*bv
;
647 actual_nblocks
= FIRST_LOCAL_BLOCK
+ stab
->nblocks
;
649 cust
= allocate_compunit_symtab (objfile
, stab
->file_name
);
650 allocate_symtab (cust
, stab
->file_name
);
651 add_compunit_symtab_to_objfile (cust
);
653 /* JIT compilers compile in memory. */
654 COMPUNIT_DIRNAME (cust
) = NULL
;
656 /* Copy over the linetable entry if one was provided. */
659 size_t size
= ((stab
->linetable
->nitems
- 1)
660 * sizeof (struct linetable_entry
)
661 + sizeof (struct linetable
));
662 SYMTAB_LINETABLE (COMPUNIT_FILETABS (cust
))
663 = (struct linetable
*) obstack_alloc (&objfile
->objfile_obstack
, size
);
664 memcpy (SYMTAB_LINETABLE (COMPUNIT_FILETABS (cust
)), stab
->linetable
,
668 blockvector_size
= (sizeof (struct blockvector
)
669 + (actual_nblocks
- 1) * sizeof (struct block
*));
670 bv
= (struct blockvector
*) obstack_alloc (&objfile
->objfile_obstack
,
672 COMPUNIT_BLOCKVECTOR (cust
) = bv
;
674 /* (begin, end) will contain the PC range this entire blockvector
676 BLOCKVECTOR_MAP (bv
) = NULL
;
677 begin
= stab
->blocks
->begin
;
678 end
= stab
->blocks
->end
;
679 BLOCKVECTOR_NBLOCKS (bv
) = actual_nblocks
;
681 /* First run over all the gdb_block objects, creating a real block
682 object for each. Simultaneously, keep setting the real_block
684 for (i
= (actual_nblocks
- 1), gdb_block_iter
= stab
->blocks
;
685 i
>= FIRST_LOCAL_BLOCK
;
686 i
--, gdb_block_iter
= gdb_block_iter
->next
)
688 struct block
*new_block
= allocate_block (&objfile
->objfile_obstack
);
689 struct symbol
*block_name
= allocate_symbol (objfile
);
690 struct type
*block_type
= arch_type (get_objfile_arch (objfile
),
695 BLOCK_DICT (new_block
) = dict_create_linear (&objfile
->objfile_obstack
,
697 /* The address range. */
698 BLOCK_START (new_block
) = (CORE_ADDR
) gdb_block_iter
->begin
;
699 BLOCK_END (new_block
) = (CORE_ADDR
) gdb_block_iter
->end
;
702 SYMBOL_DOMAIN (block_name
) = VAR_DOMAIN
;
703 SYMBOL_ACLASS_INDEX (block_name
) = LOC_BLOCK
;
704 symbol_set_symtab (block_name
, COMPUNIT_FILETABS (cust
));
705 SYMBOL_TYPE (block_name
) = lookup_function_type (block_type
);
706 SYMBOL_BLOCK_VALUE (block_name
) = new_block
;
708 block_name
->ginfo
.name
709 = (const char *) obstack_copy0 (&objfile
->objfile_obstack
,
710 gdb_block_iter
->name
,
711 strlen (gdb_block_iter
->name
));
713 BLOCK_FUNCTION (new_block
) = block_name
;
715 BLOCKVECTOR_BLOCK (bv
, i
) = new_block
;
716 if (begin
> BLOCK_START (new_block
))
717 begin
= BLOCK_START (new_block
);
718 if (end
< BLOCK_END (new_block
))
719 end
= BLOCK_END (new_block
);
721 gdb_block_iter
->real_block
= new_block
;
724 /* Now add the special blocks. */
726 for (i
= 0; i
< FIRST_LOCAL_BLOCK
; i
++)
728 struct block
*new_block
;
730 new_block
= (i
== GLOBAL_BLOCK
731 ? allocate_global_block (&objfile
->objfile_obstack
)
732 : allocate_block (&objfile
->objfile_obstack
));
733 BLOCK_DICT (new_block
) = dict_create_linear (&objfile
->objfile_obstack
,
735 BLOCK_SUPERBLOCK (new_block
) = block_iter
;
736 block_iter
= new_block
;
738 BLOCK_START (new_block
) = (CORE_ADDR
) begin
;
739 BLOCK_END (new_block
) = (CORE_ADDR
) end
;
741 BLOCKVECTOR_BLOCK (bv
, i
) = new_block
;
743 if (i
== GLOBAL_BLOCK
)
744 set_block_compunit_symtab (new_block
, cust
);
747 /* Fill up the superblock fields for the real blocks, using the
748 real_block fields populated earlier. */
749 for (gdb_block_iter
= stab
->blocks
;
751 gdb_block_iter
= gdb_block_iter
->next
)
753 if (gdb_block_iter
->parent
!= NULL
)
755 /* If the plugin specifically mentioned a parent block, we
757 BLOCK_SUPERBLOCK (gdb_block_iter
->real_block
) =
758 gdb_block_iter
->parent
->real_block
;
762 /* And if not, we set a default parent block. */
763 BLOCK_SUPERBLOCK (gdb_block_iter
->real_block
) =
764 BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
);
769 gdb_block_iter
= stab
->blocks
;
771 for (gdb_block_iter
= stab
->blocks
, gdb_block_iter_tmp
= gdb_block_iter
->next
;
773 gdb_block_iter
= gdb_block_iter_tmp
)
775 xfree ((void *) gdb_block_iter
->name
);
776 xfree (gdb_block_iter
);
778 xfree (stab
->linetable
);
779 xfree ((char *) stab
->file_name
);
783 /* Called when closing a gdb_objfile. Converts OBJ to a proper
787 jit_object_close_impl (struct gdb_symbol_callbacks
*cb
,
788 struct gdb_object
*obj
)
790 struct gdb_symtab
*i
, *j
;
791 struct objfile
*objfile
;
792 jit_dbg_reader_data
*priv_data
;
794 priv_data
= cb
->priv_data
;
796 objfile
= allocate_objfile (NULL
, "<< JIT compiled code >>",
798 objfile
->per_bfd
->gdbarch
= target_gdbarch ();
800 terminate_minimal_symbol_table (objfile
);
803 for (i
= obj
->symtabs
; i
; i
= j
)
806 finalize_symtab (i
, objfile
);
808 add_objfile_entry (objfile
, *priv_data
);
812 /* Try to read CODE_ENTRY using the loaded jit reader (if any).
813 ENTRY_ADDR is the address of the struct jit_code_entry in the
814 inferior address space. */
817 jit_reader_try_read_symtab (struct jit_code_entry
*code_entry
,
818 CORE_ADDR entry_addr
)
822 jit_dbg_reader_data priv_data
;
823 struct gdb_reader_funcs
*funcs
;
824 struct gdb_symbol_callbacks callbacks
=
826 jit_object_open_impl
,
827 jit_symtab_open_impl
,
829 jit_symtab_close_impl
,
830 jit_object_close_impl
,
832 jit_symtab_line_mapping_add_impl
,
833 jit_target_read_impl
,
838 priv_data
= entry_addr
;
840 if (!loaded_jit_reader
)
843 gdb_mem
= xmalloc (code_entry
->symfile_size
);
848 if (target_read_memory (code_entry
->symfile_addr
, gdb_mem
,
849 code_entry
->symfile_size
))
852 CATCH (e
, RETURN_MASK_ALL
)
860 funcs
= loaded_jit_reader
->functions
;
861 if (funcs
->read (funcs
, &callbacks
, gdb_mem
, code_entry
->symfile_size
)
867 if (jit_debug
&& status
== 0)
868 fprintf_unfiltered (gdb_stdlog
,
869 "Could not read symtab using the loaded JIT reader.\n");
873 /* Try to read CODE_ENTRY using BFD. ENTRY_ADDR is the address of the
874 struct jit_code_entry in the inferior address space. */
877 jit_bfd_try_read_symtab (struct jit_code_entry
*code_entry
,
878 CORE_ADDR entry_addr
,
879 struct gdbarch
*gdbarch
)
882 struct section_addr_info
*sai
;
883 struct bfd_section
*sec
;
884 struct objfile
*objfile
;
885 struct cleanup
*old_cleanups
;
887 const struct bfd_arch_info
*b
;
890 fprintf_unfiltered (gdb_stdlog
,
891 "jit_register_code, symfile_addr = %s, "
892 "symfile_size = %s\n",
893 paddress (gdbarch
, code_entry
->symfile_addr
),
894 pulongest (code_entry
->symfile_size
));
896 nbfd
= bfd_open_from_target_memory (code_entry
->symfile_addr
,
897 code_entry
->symfile_size
, gnutarget
);
900 puts_unfiltered (_("Error opening JITed symbol file, ignoring it.\n"));
904 /* Check the format. NOTE: This initializes important data that GDB uses!
905 We would segfault later without this line. */
906 if (!bfd_check_format (nbfd
, bfd_object
))
908 printf_unfiltered (_("\
909 JITed symbol file is not an object file, ignoring it.\n"));
910 gdb_bfd_unref (nbfd
);
914 /* Check bfd arch. */
915 b
= gdbarch_bfd_arch_info (gdbarch
);
916 if (b
->compatible (b
, bfd_get_arch_info (nbfd
)) != b
)
917 warning (_("JITed object file architecture %s is not compatible "
918 "with target architecture %s."), bfd_get_arch_info
919 (nbfd
)->printable_name
, b
->printable_name
);
921 /* Read the section address information out of the symbol file. Since the
922 file is generated by the JIT at runtime, it should all of the absolute
923 addresses that we care about. */
924 sai
= alloc_section_addr_info (bfd_count_sections (nbfd
));
925 old_cleanups
= make_cleanup_free_section_addr_info (sai
);
927 for (sec
= nbfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
928 if ((bfd_get_section_flags (nbfd
, sec
) & (SEC_ALLOC
|SEC_LOAD
)) != 0)
930 /* We assume that these virtual addresses are absolute, and do not
931 treat them as offsets. */
932 sai
->other
[i
].addr
= bfd_get_section_vma (nbfd
, sec
);
933 sai
->other
[i
].name
= xstrdup (bfd_get_section_name (nbfd
, sec
));
934 sai
->other
[i
].sectindex
= sec
->index
;
937 sai
->num_sections
= i
;
939 /* This call does not take ownership of SAI. */
940 make_cleanup_bfd_unref (nbfd
);
941 objfile
= symbol_file_add_from_bfd (nbfd
, bfd_get_filename (nbfd
), 0, sai
,
942 OBJF_SHARED
| OBJF_NOT_FILENAME
, NULL
);
944 do_cleanups (old_cleanups
);
945 add_objfile_entry (objfile
, entry_addr
);
948 /* This function registers code associated with a JIT code entry. It uses the
949 pointer and size pair in the entry to read the symbol file from the remote
950 and then calls symbol_file_add_from_local_memory to add it as though it were
951 a symbol file added by the user. */
954 jit_register_code (struct gdbarch
*gdbarch
,
955 CORE_ADDR entry_addr
, struct jit_code_entry
*code_entry
)
960 fprintf_unfiltered (gdb_stdlog
,
961 "jit_register_code, symfile_addr = %s, "
962 "symfile_size = %s\n",
963 paddress (gdbarch
, code_entry
->symfile_addr
),
964 pulongest (code_entry
->symfile_size
));
966 success
= jit_reader_try_read_symtab (code_entry
, entry_addr
);
969 jit_bfd_try_read_symtab (code_entry
, entry_addr
, gdbarch
);
972 /* This function unregisters JITed code and frees the corresponding
976 jit_unregister_code (struct objfile
*objfile
)
978 free_objfile (objfile
);
981 /* Look up the objfile with this code entry address. */
983 static struct objfile
*
984 jit_find_objf_with_entry_addr (CORE_ADDR entry_addr
)
986 struct objfile
*objf
;
990 struct jit_objfile_data
*objf_data
;
992 objf_data
= objfile_data (objf
, jit_objfile_data
);
993 if (objf_data
!= NULL
&& objf_data
->addr
== entry_addr
)
999 /* This is called when a breakpoint is deleted. It updates the
1000 inferior's cache, if needed. */
1003 jit_breakpoint_deleted (struct breakpoint
*b
)
1005 struct bp_location
*iter
;
1007 if (b
->type
!= bp_jit_event
)
1010 for (iter
= b
->loc
; iter
!= NULL
; iter
= iter
->next
)
1012 struct jit_program_space_data
*ps_data
;
1014 ps_data
= program_space_data (iter
->pspace
, jit_program_space_data
);
1015 if (ps_data
!= NULL
&& ps_data
->jit_breakpoint
== iter
->owner
)
1017 ps_data
->cached_code_address
= 0;
1018 ps_data
->jit_breakpoint
= NULL
;
1023 /* (Re-)Initialize the jit breakpoint if necessary.
1024 Return 0 on success. */
1027 jit_breakpoint_re_set_internal (struct gdbarch
*gdbarch
,
1028 struct jit_program_space_data
*ps_data
)
1030 struct bound_minimal_symbol reg_symbol
;
1031 struct bound_minimal_symbol desc_symbol
;
1032 struct jit_objfile_data
*objf_data
;
1035 if (ps_data
->objfile
== NULL
)
1037 /* Lookup the registration symbol. If it is missing, then we
1038 assume we are not attached to a JIT. */
1039 reg_symbol
= lookup_minimal_symbol_and_objfile (jit_break_name
);
1040 if (reg_symbol
.minsym
== NULL
1041 || BMSYMBOL_VALUE_ADDRESS (reg_symbol
) == 0)
1044 desc_symbol
= lookup_minimal_symbol (jit_descriptor_name
, NULL
,
1045 reg_symbol
.objfile
);
1046 if (desc_symbol
.minsym
== NULL
1047 || BMSYMBOL_VALUE_ADDRESS (desc_symbol
) == 0)
1050 objf_data
= get_jit_objfile_data (reg_symbol
.objfile
);
1051 objf_data
->register_code
= reg_symbol
.minsym
;
1052 objf_data
->descriptor
= desc_symbol
.minsym
;
1054 ps_data
->objfile
= reg_symbol
.objfile
;
1057 objf_data
= get_jit_objfile_data (ps_data
->objfile
);
1059 addr
= MSYMBOL_VALUE_ADDRESS (ps_data
->objfile
, objf_data
->register_code
);
1062 fprintf_unfiltered (gdb_stdlog
,
1063 "jit_breakpoint_re_set_internal, "
1064 "breakpoint_addr = %s\n",
1065 paddress (gdbarch
, addr
));
1067 if (ps_data
->cached_code_address
== addr
)
1070 /* Delete the old breakpoint. */
1071 if (ps_data
->jit_breakpoint
!= NULL
)
1072 delete_breakpoint (ps_data
->jit_breakpoint
);
1074 /* Put a breakpoint in the registration symbol. */
1075 ps_data
->cached_code_address
= addr
;
1076 ps_data
->jit_breakpoint
= create_jit_event_breakpoint (gdbarch
, addr
);
1081 /* The private data passed around in the frame unwind callback
1084 struct jit_unwind_private
1086 /* Cached register values. See jit_frame_sniffer to see how this
1088 struct gdb_reg_value
**registers
;
1090 /* The frame being unwound. */
1091 struct frame_info
*this_frame
;
1094 /* Sets the value of a particular register in this frame. */
1097 jit_unwind_reg_set_impl (struct gdb_unwind_callbacks
*cb
, int dwarf_regnum
,
1098 struct gdb_reg_value
*value
)
1100 struct jit_unwind_private
*priv
;
1103 priv
= cb
->priv_data
;
1105 gdb_reg
= gdbarch_dwarf2_reg_to_regnum (get_frame_arch (priv
->this_frame
),
1110 fprintf_unfiltered (gdb_stdlog
,
1111 _("Could not recognize DWARF regnum %d"),
1116 gdb_assert (priv
->registers
);
1117 priv
->registers
[gdb_reg
] = value
;
1121 reg_value_free_impl (struct gdb_reg_value
*value
)
1126 /* Get the value of register REGNUM in the previous frame. */
1128 static struct gdb_reg_value
*
1129 jit_unwind_reg_get_impl (struct gdb_unwind_callbacks
*cb
, int regnum
)
1131 struct jit_unwind_private
*priv
;
1132 struct gdb_reg_value
*value
;
1134 struct gdbarch
*frame_arch
;
1136 priv
= cb
->priv_data
;
1137 frame_arch
= get_frame_arch (priv
->this_frame
);
1139 gdb_reg
= gdbarch_dwarf2_reg_to_regnum (frame_arch
, regnum
);
1140 size
= register_size (frame_arch
, gdb_reg
);
1141 value
= ((struct gdb_reg_value
*)
1142 xmalloc (sizeof (struct gdb_reg_value
) + size
- 1));
1143 value
->defined
= deprecated_frame_register_read (priv
->this_frame
, gdb_reg
,
1146 value
->free
= reg_value_free_impl
;
1150 /* gdb_reg_value has a free function, which must be called on each
1151 saved register value. */
1154 jit_dealloc_cache (struct frame_info
*this_frame
, void *cache
)
1156 struct jit_unwind_private
*priv_data
= cache
;
1157 struct gdbarch
*frame_arch
;
1160 gdb_assert (priv_data
->registers
);
1161 frame_arch
= get_frame_arch (priv_data
->this_frame
);
1163 for (i
= 0; i
< gdbarch_num_regs (frame_arch
); i
++)
1164 if (priv_data
->registers
[i
] && priv_data
->registers
[i
]->free
)
1165 priv_data
->registers
[i
]->free (priv_data
->registers
[i
]);
1167 xfree (priv_data
->registers
);
1171 /* The frame sniffer for the pseudo unwinder.
1173 While this is nominally a frame sniffer, in the case where the JIT
1174 reader actually recognizes the frame, it does a lot more work -- it
1175 unwinds the frame and saves the corresponding register values in
1176 the cache. jit_frame_prev_register simply returns the saved
1180 jit_frame_sniffer (const struct frame_unwind
*self
,
1181 struct frame_info
*this_frame
, void **cache
)
1183 struct jit_unwind_private
*priv_data
;
1184 struct gdb_unwind_callbacks callbacks
;
1185 struct gdb_reader_funcs
*funcs
;
1187 callbacks
.reg_get
= jit_unwind_reg_get_impl
;
1188 callbacks
.reg_set
= jit_unwind_reg_set_impl
;
1189 callbacks
.target_read
= jit_target_read_impl
;
1191 if (loaded_jit_reader
== NULL
)
1194 funcs
= loaded_jit_reader
->functions
;
1196 gdb_assert (!*cache
);
1198 *cache
= XCNEW (struct jit_unwind_private
);
1200 priv_data
->registers
=
1201 XCNEWVEC (struct gdb_reg_value
*,
1202 gdbarch_num_regs (get_frame_arch (this_frame
)));
1203 priv_data
->this_frame
= this_frame
;
1205 callbacks
.priv_data
= priv_data
;
1207 /* Try to coax the provided unwinder to unwind the stack */
1208 if (funcs
->unwind (funcs
, &callbacks
) == GDB_SUCCESS
)
1211 fprintf_unfiltered (gdb_stdlog
, _("Successfully unwound frame using "
1216 fprintf_unfiltered (gdb_stdlog
, _("Could not unwind frame using "
1219 jit_dealloc_cache (this_frame
, *cache
);
1226 /* The frame_id function for the pseudo unwinder. Relays the call to
1227 the loaded plugin. */
1230 jit_frame_this_id (struct frame_info
*this_frame
, void **cache
,
1231 struct frame_id
*this_id
)
1233 struct jit_unwind_private priv
;
1234 struct gdb_frame_id frame_id
;
1235 struct gdb_reader_funcs
*funcs
;
1236 struct gdb_unwind_callbacks callbacks
;
1238 priv
.registers
= NULL
;
1239 priv
.this_frame
= this_frame
;
1241 /* We don't expect the frame_id function to set any registers, so we
1242 set reg_set to NULL. */
1243 callbacks
.reg_get
= jit_unwind_reg_get_impl
;
1244 callbacks
.reg_set
= NULL
;
1245 callbacks
.target_read
= jit_target_read_impl
;
1246 callbacks
.priv_data
= &priv
;
1248 gdb_assert (loaded_jit_reader
);
1249 funcs
= loaded_jit_reader
->functions
;
1251 frame_id
= funcs
->get_frame_id (funcs
, &callbacks
);
1252 *this_id
= frame_id_build (frame_id
.stack_address
, frame_id
.code_address
);
1255 /* Pseudo unwinder function. Reads the previously fetched value for
1256 the register from the cache. */
1258 static struct value
*
1259 jit_frame_prev_register (struct frame_info
*this_frame
, void **cache
, int reg
)
1261 struct jit_unwind_private
*priv
= *cache
;
1262 struct gdb_reg_value
*value
;
1265 return frame_unwind_got_optimized (this_frame
, reg
);
1267 gdb_assert (priv
->registers
);
1268 value
= priv
->registers
[reg
];
1269 if (value
&& value
->defined
)
1270 return frame_unwind_got_bytes (this_frame
, reg
, value
->value
);
1272 return frame_unwind_got_optimized (this_frame
, reg
);
1275 /* Relay everything back to the unwinder registered by the JIT debug
1278 static const struct frame_unwind jit_frame_unwind
=
1281 default_frame_unwind_stop_reason
,
1283 jit_frame_prev_register
,
1290 /* This is the information that is stored at jit_gdbarch_data for each
1293 struct jit_gdbarch_data_type
1295 /* Has the (pseudo) unwinder been prepended? */
1296 int unwinder_registered
;
1299 /* Check GDBARCH and prepend the pseudo JIT unwinder if needed. */
1302 jit_prepend_unwinder (struct gdbarch
*gdbarch
)
1304 struct jit_gdbarch_data_type
*data
;
1306 data
= gdbarch_data (gdbarch
, jit_gdbarch_data
);
1307 if (!data
->unwinder_registered
)
1309 frame_unwind_prepend_unwinder (gdbarch
, &jit_frame_unwind
);
1310 data
->unwinder_registered
= 1;
1314 /* Register any already created translations. */
1317 jit_inferior_init (struct gdbarch
*gdbarch
)
1319 struct jit_descriptor descriptor
;
1320 struct jit_code_entry cur_entry
;
1321 struct jit_program_space_data
*ps_data
;
1322 CORE_ADDR cur_entry_addr
;
1325 fprintf_unfiltered (gdb_stdlog
, "jit_inferior_init\n");
1327 jit_prepend_unwinder (gdbarch
);
1329 ps_data
= get_jit_program_space_data ();
1330 if (jit_breakpoint_re_set_internal (gdbarch
, ps_data
) != 0)
1333 /* Read the descriptor so we can check the version number and load
1334 any already JITed functions. */
1335 if (!jit_read_descriptor (gdbarch
, &descriptor
, ps_data
))
1338 /* Check that the version number agrees with that we support. */
1339 if (descriptor
.version
!= 1)
1341 printf_unfiltered (_("Unsupported JIT protocol version %ld "
1342 "in descriptor (expected 1)\n"),
1343 (long) descriptor
.version
);
1347 /* If we've attached to a running program, we need to check the descriptor
1348 to register any functions that were already generated. */
1349 for (cur_entry_addr
= descriptor
.first_entry
;
1350 cur_entry_addr
!= 0;
1351 cur_entry_addr
= cur_entry
.next_entry
)
1353 jit_read_code_entry (gdbarch
, cur_entry_addr
, &cur_entry
);
1355 /* This hook may be called many times during setup, so make sure we don't
1356 add the same symbol file twice. */
1357 if (jit_find_objf_with_entry_addr (cur_entry_addr
) != NULL
)
1360 jit_register_code (gdbarch
, cur_entry_addr
, &cur_entry
);
1364 /* Exported routine to call when an inferior has been created. */
1367 jit_inferior_created_hook (void)
1369 jit_inferior_init (target_gdbarch ());
1372 /* Exported routine to call to re-set the jit breakpoints,
1373 e.g. when a program is rerun. */
1376 jit_breakpoint_re_set (void)
1378 jit_breakpoint_re_set_internal (target_gdbarch (),
1379 get_jit_program_space_data ());
1382 /* This function cleans up any code entries left over when the
1383 inferior exits. We get left over code when the inferior exits
1384 without unregistering its code, for example when it crashes. */
1387 jit_inferior_exit_hook (struct inferior
*inf
)
1389 struct objfile
*objf
;
1390 struct objfile
*temp
;
1392 ALL_OBJFILES_SAFE (objf
, temp
)
1394 struct jit_objfile_data
*objf_data
= objfile_data (objf
,
1397 if (objf_data
!= NULL
&& objf_data
->addr
!= 0)
1398 jit_unregister_code (objf
);
1403 jit_event_handler (struct gdbarch
*gdbarch
)
1405 struct jit_descriptor descriptor
;
1406 struct jit_code_entry code_entry
;
1407 CORE_ADDR entry_addr
;
1408 struct objfile
*objf
;
1410 /* Read the descriptor from remote memory. */
1411 if (!jit_read_descriptor (gdbarch
, &descriptor
,
1412 get_jit_program_space_data ()))
1414 entry_addr
= descriptor
.relevant_entry
;
1416 /* Do the corresponding action. */
1417 switch (descriptor
.action_flag
)
1422 jit_read_code_entry (gdbarch
, entry_addr
, &code_entry
);
1423 jit_register_code (gdbarch
, entry_addr
, &code_entry
);
1425 case JIT_UNREGISTER
:
1426 objf
= jit_find_objf_with_entry_addr (entry_addr
);
1428 printf_unfiltered (_("Unable to find JITed code "
1429 "entry at address: %s\n"),
1430 paddress (gdbarch
, entry_addr
));
1432 jit_unregister_code (objf
);
1436 error (_("Unknown action_flag value in JIT descriptor!"));
1441 /* Called to free the data allocated to the jit_program_space_data slot. */
1444 free_objfile_data (struct objfile
*objfile
, void *data
)
1446 struct jit_objfile_data
*objf_data
= data
;
1448 if (objf_data
->register_code
!= NULL
)
1450 struct jit_program_space_data
*ps_data
;
1452 ps_data
= program_space_data (objfile
->pspace
, jit_program_space_data
);
1453 if (ps_data
!= NULL
&& ps_data
->objfile
== objfile
)
1454 ps_data
->objfile
= NULL
;
1460 /* Initialize the jit_gdbarch_data slot with an instance of struct
1461 jit_gdbarch_data_type */
1464 jit_gdbarch_data_init (struct obstack
*obstack
)
1466 struct jit_gdbarch_data_type
*data
=
1467 XOBNEW (obstack
, struct jit_gdbarch_data_type
);
1469 data
->unwinder_registered
= 0;
1474 /* Provide a prototype to silence -Wmissing-prototypes. */
1476 extern void _initialize_jit (void);
1479 _initialize_jit (void)
1481 jit_reader_dir
= relocate_gdb_directory (JIT_READER_DIR
,
1482 JIT_READER_DIR_RELOCATABLE
);
1483 add_setshow_zuinteger_cmd ("jit", class_maintenance
, &jit_debug
,
1484 _("Set JIT debugging."),
1485 _("Show JIT debugging."),
1486 _("When non-zero, JIT debugging is enabled."),
1489 &setdebuglist
, &showdebuglist
);
1491 observer_attach_inferior_exit (jit_inferior_exit_hook
);
1492 observer_attach_breakpoint_deleted (jit_breakpoint_deleted
);
1495 register_objfile_data_with_cleanup (NULL
, free_objfile_data
);
1496 jit_program_space_data
=
1497 register_program_space_data_with_cleanup (NULL
,
1498 jit_program_space_data_cleanup
);
1499 jit_gdbarch_data
= gdbarch_data_register_pre_init (jit_gdbarch_data_init
);
1500 if (is_dl_available ())
1502 add_com ("jit-reader-load", no_class
, jit_reader_load_command
, _("\
1503 Load FILE as debug info reader and unwinder for JIT compiled code.\n\
1504 Usage: jit-reader-load FILE\n\
1505 Try to load file FILE as a debug info reader (and unwinder) for\n\
1506 JIT compiled code. The file is loaded from " JIT_READER_DIR
",\n\
1507 relocated relative to the GDB executable if required."));
1508 add_com ("jit-reader-unload", no_class
, jit_reader_unload_command
, _("\
1509 Unload the currently loaded JIT debug info reader.\n\
1510 Usage: jit-reader-unload FILE\n\n\
1511 Do \"help jit-reader-load\" for info on loading debug info readers."));