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 (objf_data
->descriptor
)));
362 /* Figure out how big the descriptor is on the remote and how to read it. */
363 ptr_type
= builtin_type (gdbarch
)->builtin_data_ptr
;
364 ptr_size
= TYPE_LENGTH (ptr_type
);
365 desc_size
= 8 + 2 * ptr_size
; /* Two 32-bit ints and two pointers. */
366 desc_buf
= alloca (desc_size
);
368 /* Read the descriptor. */
369 err
= target_read_memory (MSYMBOL_VALUE_ADDRESS (objf_data
->descriptor
),
370 desc_buf
, desc_size
);
373 printf_unfiltered (_("Unable to read JIT descriptor from "
378 /* Fix the endianness to match the host. */
379 descriptor
->version
= extract_unsigned_integer (&desc_buf
[0], 4, byte_order
);
380 descriptor
->action_flag
=
381 extract_unsigned_integer (&desc_buf
[4], 4, byte_order
);
382 descriptor
->relevant_entry
= extract_typed_address (&desc_buf
[8], ptr_type
);
383 descriptor
->first_entry
=
384 extract_typed_address (&desc_buf
[8 + ptr_size
], ptr_type
);
389 /* Helper function for reading a JITed code entry from remote memory. */
392 jit_read_code_entry (struct gdbarch
*gdbarch
,
393 CORE_ADDR code_addr
, struct jit_code_entry
*code_entry
)
396 struct type
*ptr_type
;
401 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
403 /* Figure out how big the entry is on the remote and how to read it. */
404 ptr_type
= builtin_type (gdbarch
)->builtin_data_ptr
;
405 ptr_size
= TYPE_LENGTH (ptr_type
);
407 /* Figure out where the longlong value will be. */
408 align_bytes
= gdbarch_long_long_align_bit (gdbarch
) / 8;
410 off
= (off
+ (align_bytes
- 1)) & ~(align_bytes
- 1);
412 entry_size
= off
+ 8; /* Three pointers and one 64-bit int. */
413 entry_buf
= alloca (entry_size
);
415 /* Read the entry. */
416 err
= target_read_memory (code_addr
, entry_buf
, entry_size
);
418 error (_("Unable to read JIT code entry from remote memory!"));
420 /* Fix the endianness to match the host. */
421 ptr_type
= builtin_type (gdbarch
)->builtin_data_ptr
;
422 code_entry
->next_entry
= extract_typed_address (&entry_buf
[0], ptr_type
);
423 code_entry
->prev_entry
=
424 extract_typed_address (&entry_buf
[ptr_size
], ptr_type
);
425 code_entry
->symfile_addr
=
426 extract_typed_address (&entry_buf
[2 * ptr_size
], ptr_type
);
427 code_entry
->symfile_size
=
428 extract_unsigned_integer (&entry_buf
[off
], 8, byte_order
);
431 /* Proxy object for building a block. */
435 /* gdb_blocks are linked into a tree structure. Next points to the
436 next node at the same depth as this block and parent to the
438 struct gdb_block
*next
, *parent
;
440 /* Points to the "real" block that is being built out of this
441 instance. This block will be added to a blockvector, which will
442 then be added to a symtab. */
443 struct block
*real_block
;
445 /* The first and last code address corresponding to this block. */
446 CORE_ADDR begin
, end
;
448 /* The name of this block (if any). If this is non-NULL, the
449 FUNCTION symbol symbol is set to this value. */
453 /* Proxy object for building a symtab. */
457 /* The list of blocks in this symtab. These will eventually be
458 converted to real blocks. */
459 struct gdb_block
*blocks
;
461 /* The number of blocks inserted. */
464 /* A mapping between line numbers to PC. */
465 struct linetable
*linetable
;
467 /* The source file for this symtab. */
468 const char *file_name
;
469 struct gdb_symtab
*next
;
472 /* Proxy object for building an object. */
476 struct gdb_symtab
*symtabs
;
479 /* The type of the `private' data passed around by the callback
482 typedef CORE_ADDR jit_dbg_reader_data
;
484 /* The reader calls into this function to read data off the targets
487 static enum gdb_status
488 jit_target_read_impl (GDB_CORE_ADDR target_mem
, void *gdb_buf
, int len
)
490 int result
= target_read_memory ((CORE_ADDR
) target_mem
, gdb_buf
, len
);
497 /* The reader calls into this function to create a new gdb_object
498 which it can then pass around to the other callbacks. Right now,
499 all that is required is allocating the memory. */
501 static struct gdb_object
*
502 jit_object_open_impl (struct gdb_symbol_callbacks
*cb
)
504 /* CB is not required right now, but sometime in the future we might
505 need a handle to it, and we'd like to do that without breaking
507 return XCNEW (struct gdb_object
);
510 /* Readers call into this function to open a new gdb_symtab, which,
511 again, is passed around to other callbacks. */
513 static struct gdb_symtab
*
514 jit_symtab_open_impl (struct gdb_symbol_callbacks
*cb
,
515 struct gdb_object
*object
,
516 const char *file_name
)
518 struct gdb_symtab
*ret
;
520 /* CB stays unused. See comment in jit_object_open_impl. */
522 ret
= XCNEW (struct gdb_symtab
);
523 ret
->file_name
= file_name
? xstrdup (file_name
) : xstrdup ("");
524 ret
->next
= object
->symtabs
;
525 object
->symtabs
= ret
;
529 /* Returns true if the block corresponding to old should be placed
530 before the block corresponding to new in the final blockvector. */
533 compare_block (const struct gdb_block
*const old
,
534 const struct gdb_block
*const new)
538 if (old
->begin
< new->begin
)
540 else if (old
->begin
== new->begin
)
542 if (old
->end
> new->end
)
551 /* Called by readers to open a new gdb_block. This function also
552 inserts the new gdb_block in the correct place in the corresponding
555 static struct gdb_block
*
556 jit_block_open_impl (struct gdb_symbol_callbacks
*cb
,
557 struct gdb_symtab
*symtab
, struct gdb_block
*parent
,
558 GDB_CORE_ADDR begin
, GDB_CORE_ADDR end
, const char *name
)
560 struct gdb_block
*block
= XCNEW (struct gdb_block
);
562 block
->next
= symtab
->blocks
;
563 block
->begin
= (CORE_ADDR
) begin
;
564 block
->end
= (CORE_ADDR
) end
;
565 block
->name
= name
? xstrdup (name
) : NULL
;
566 block
->parent
= parent
;
568 /* Ensure that the blocks are inserted in the correct (reverse of
569 the order expected by blockvector). */
570 if (compare_block (symtab
->blocks
, block
))
572 symtab
->blocks
= block
;
576 struct gdb_block
*i
= symtab
->blocks
;
580 /* Guaranteed to terminate, since compare_block (NULL, _)
582 if (compare_block (i
->next
, block
))
584 block
->next
= i
->next
;
595 /* Readers call this to add a line mapping (from PC to line number) to
599 jit_symtab_line_mapping_add_impl (struct gdb_symbol_callbacks
*cb
,
600 struct gdb_symtab
*stab
, int nlines
,
601 struct gdb_line_mapping
*map
)
608 stab
->linetable
= xmalloc (sizeof (struct linetable
)
609 + (nlines
- 1) * sizeof (struct linetable_entry
));
610 stab
->linetable
->nitems
= nlines
;
611 for (i
= 0; i
< nlines
; i
++)
613 stab
->linetable
->item
[i
].pc
= (CORE_ADDR
) map
[i
].pc
;
614 stab
->linetable
->item
[i
].line
= map
[i
].line
;
618 /* Called by readers to close a gdb_symtab. Does not need to do
619 anything as of now. */
622 jit_symtab_close_impl (struct gdb_symbol_callbacks
*cb
,
623 struct gdb_symtab
*stab
)
625 /* Right now nothing needs to be done here. We may need to do some
626 cleanup here in the future (again, without breaking the plugin
630 /* Transform STAB to a proper symtab, and add it it OBJFILE. */
633 finalize_symtab (struct gdb_symtab
*stab
, struct objfile
*objfile
)
635 struct symtab
*symtab
;
636 struct gdb_block
*gdb_block_iter
, *gdb_block_iter_tmp
;
637 struct block
*block_iter
;
638 int actual_nblocks
, i
, blockvector_size
;
639 CORE_ADDR begin
, end
;
641 actual_nblocks
= FIRST_LOCAL_BLOCK
+ stab
->nblocks
;
643 symtab
= allocate_symtab (stab
->file_name
, objfile
);
644 /* JIT compilers compile in memory. */
645 symtab
->dirname
= NULL
;
647 /* Copy over the linetable entry if one was provided. */
650 int size
= ((stab
->linetable
->nitems
- 1)
651 * sizeof (struct linetable_entry
)
652 + sizeof (struct linetable
));
653 LINETABLE (symtab
) = obstack_alloc (&objfile
->objfile_obstack
, size
);
654 memcpy (LINETABLE (symtab
), stab
->linetable
, size
);
658 LINETABLE (symtab
) = NULL
;
661 blockvector_size
= (sizeof (struct blockvector
)
662 + (actual_nblocks
- 1) * sizeof (struct block
*));
663 symtab
->blockvector
= obstack_alloc (&objfile
->objfile_obstack
,
666 /* (begin, end) will contain the PC range this entire blockvector
668 set_symtab_primary (symtab
, 1);
669 BLOCKVECTOR_MAP (symtab
->blockvector
) = NULL
;
670 begin
= stab
->blocks
->begin
;
671 end
= stab
->blocks
->end
;
672 BLOCKVECTOR_NBLOCKS (symtab
->blockvector
) = actual_nblocks
;
674 /* First run over all the gdb_block objects, creating a real block
675 object for each. Simultaneously, keep setting the real_block
677 for (i
= (actual_nblocks
- 1), gdb_block_iter
= stab
->blocks
;
678 i
>= FIRST_LOCAL_BLOCK
;
679 i
--, gdb_block_iter
= gdb_block_iter
->next
)
681 struct block
*new_block
= allocate_block (&objfile
->objfile_obstack
);
682 struct symbol
*block_name
= allocate_symbol (objfile
);
683 struct type
*block_type
= arch_type (get_objfile_arch (objfile
),
688 BLOCK_DICT (new_block
) = dict_create_linear (&objfile
->objfile_obstack
,
690 /* The address range. */
691 BLOCK_START (new_block
) = (CORE_ADDR
) gdb_block_iter
->begin
;
692 BLOCK_END (new_block
) = (CORE_ADDR
) gdb_block_iter
->end
;
695 SYMBOL_DOMAIN (block_name
) = VAR_DOMAIN
;
696 SYMBOL_ACLASS_INDEX (block_name
) = LOC_BLOCK
;
697 SYMBOL_SYMTAB (block_name
) = symtab
;
698 SYMBOL_TYPE (block_name
) = lookup_function_type (block_type
);
699 SYMBOL_BLOCK_VALUE (block_name
) = new_block
;
701 block_name
->ginfo
.name
= obstack_copy0 (&objfile
->objfile_obstack
,
702 gdb_block_iter
->name
,
703 strlen (gdb_block_iter
->name
));
705 BLOCK_FUNCTION (new_block
) = block_name
;
707 BLOCKVECTOR_BLOCK (symtab
->blockvector
, i
) = new_block
;
708 if (begin
> BLOCK_START (new_block
))
709 begin
= BLOCK_START (new_block
);
710 if (end
< BLOCK_END (new_block
))
711 end
= BLOCK_END (new_block
);
713 gdb_block_iter
->real_block
= new_block
;
716 /* Now add the special blocks. */
718 for (i
= 0; i
< FIRST_LOCAL_BLOCK
; i
++)
720 struct block
*new_block
;
722 new_block
= (i
== GLOBAL_BLOCK
723 ? allocate_global_block (&objfile
->objfile_obstack
)
724 : allocate_block (&objfile
->objfile_obstack
));
725 BLOCK_DICT (new_block
) = dict_create_linear (&objfile
->objfile_obstack
,
727 BLOCK_SUPERBLOCK (new_block
) = block_iter
;
728 block_iter
= new_block
;
730 BLOCK_START (new_block
) = (CORE_ADDR
) begin
;
731 BLOCK_END (new_block
) = (CORE_ADDR
) end
;
733 BLOCKVECTOR_BLOCK (symtab
->blockvector
, i
) = new_block
;
735 if (i
== GLOBAL_BLOCK
)
736 set_block_symtab (new_block
, symtab
);
739 /* Fill up the superblock fields for the real blocks, using the
740 real_block fields populated earlier. */
741 for (gdb_block_iter
= stab
->blocks
;
743 gdb_block_iter
= gdb_block_iter
->next
)
745 if (gdb_block_iter
->parent
!= NULL
)
747 /* If the plugin specifically mentioned a parent block, we
749 BLOCK_SUPERBLOCK (gdb_block_iter
->real_block
) =
750 gdb_block_iter
->parent
->real_block
;
754 /* And if not, we set a default parent block. */
755 BLOCK_SUPERBLOCK (gdb_block_iter
->real_block
) =
756 BLOCKVECTOR_BLOCK (symtab
->blockvector
, STATIC_BLOCK
);
761 gdb_block_iter
= stab
->blocks
;
763 for (gdb_block_iter
= stab
->blocks
, gdb_block_iter_tmp
= gdb_block_iter
->next
;
765 gdb_block_iter
= gdb_block_iter_tmp
)
767 xfree ((void *) gdb_block_iter
->name
);
768 xfree (gdb_block_iter
);
770 xfree (stab
->linetable
);
771 xfree ((char *) stab
->file_name
);
775 /* Called when closing a gdb_objfile. Converts OBJ to a proper
779 jit_object_close_impl (struct gdb_symbol_callbacks
*cb
,
780 struct gdb_object
*obj
)
782 struct gdb_symtab
*i
, *j
;
783 struct objfile
*objfile
;
784 jit_dbg_reader_data
*priv_data
;
786 priv_data
= cb
->priv_data
;
788 objfile
= allocate_objfile (NULL
, "<< JIT compiled code >>",
790 objfile
->per_bfd
->gdbarch
= target_gdbarch ();
792 terminate_minimal_symbol_table (objfile
);
795 for (i
= obj
->symtabs
; i
; i
= j
)
798 finalize_symtab (i
, objfile
);
800 add_objfile_entry (objfile
, *priv_data
);
804 /* Try to read CODE_ENTRY using the loaded jit reader (if any).
805 ENTRY_ADDR is the address of the struct jit_code_entry in the
806 inferior address space. */
809 jit_reader_try_read_symtab (struct jit_code_entry
*code_entry
,
810 CORE_ADDR entry_addr
)
814 jit_dbg_reader_data priv_data
;
815 struct gdb_reader_funcs
*funcs
;
816 volatile struct gdb_exception e
;
817 struct gdb_symbol_callbacks callbacks
=
819 jit_object_open_impl
,
820 jit_symtab_open_impl
,
822 jit_symtab_close_impl
,
823 jit_object_close_impl
,
825 jit_symtab_line_mapping_add_impl
,
826 jit_target_read_impl
,
831 priv_data
= entry_addr
;
833 if (!loaded_jit_reader
)
836 gdb_mem
= xmalloc (code_entry
->symfile_size
);
839 TRY_CATCH (e
, RETURN_MASK_ALL
)
840 if (target_read_memory (code_entry
->symfile_addr
, gdb_mem
,
841 code_entry
->symfile_size
))
848 funcs
= loaded_jit_reader
->functions
;
849 if (funcs
->read (funcs
, &callbacks
, gdb_mem
, code_entry
->symfile_size
)
855 if (jit_debug
&& status
== 0)
856 fprintf_unfiltered (gdb_stdlog
,
857 "Could not read symtab using the loaded JIT reader.\n");
861 /* Try to read CODE_ENTRY using BFD. ENTRY_ADDR is the address of the
862 struct jit_code_entry in the inferior address space. */
865 jit_bfd_try_read_symtab (struct jit_code_entry
*code_entry
,
866 CORE_ADDR entry_addr
,
867 struct gdbarch
*gdbarch
)
870 struct section_addr_info
*sai
;
871 struct bfd_section
*sec
;
872 struct objfile
*objfile
;
873 struct cleanup
*old_cleanups
;
875 const struct bfd_arch_info
*b
;
878 fprintf_unfiltered (gdb_stdlog
,
879 "jit_register_code, symfile_addr = %s, "
880 "symfile_size = %s\n",
881 paddress (gdbarch
, code_entry
->symfile_addr
),
882 pulongest (code_entry
->symfile_size
));
884 nbfd
= bfd_open_from_target_memory (code_entry
->symfile_addr
,
885 code_entry
->symfile_size
, gnutarget
);
888 puts_unfiltered (_("Error opening JITed symbol file, ignoring it.\n"));
892 /* Check the format. NOTE: This initializes important data that GDB uses!
893 We would segfault later without this line. */
894 if (!bfd_check_format (nbfd
, bfd_object
))
896 printf_unfiltered (_("\
897 JITed symbol file is not an object file, ignoring it.\n"));
898 gdb_bfd_unref (nbfd
);
902 /* Check bfd arch. */
903 b
= gdbarch_bfd_arch_info (gdbarch
);
904 if (b
->compatible (b
, bfd_get_arch_info (nbfd
)) != b
)
905 warning (_("JITed object file architecture %s is not compatible "
906 "with target architecture %s."), bfd_get_arch_info
907 (nbfd
)->printable_name
, b
->printable_name
);
909 /* Read the section address information out of the symbol file. Since the
910 file is generated by the JIT at runtime, it should all of the absolute
911 addresses that we care about. */
912 sai
= alloc_section_addr_info (bfd_count_sections (nbfd
));
913 old_cleanups
= make_cleanup_free_section_addr_info (sai
);
915 for (sec
= nbfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
916 if ((bfd_get_section_flags (nbfd
, sec
) & (SEC_ALLOC
|SEC_LOAD
)) != 0)
918 /* We assume that these virtual addresses are absolute, and do not
919 treat them as offsets. */
920 sai
->other
[i
].addr
= bfd_get_section_vma (nbfd
, sec
);
921 sai
->other
[i
].name
= xstrdup (bfd_get_section_name (nbfd
, sec
));
922 sai
->other
[i
].sectindex
= sec
->index
;
925 sai
->num_sections
= i
;
927 /* This call does not take ownership of SAI. */
928 make_cleanup_bfd_unref (nbfd
);
929 objfile
= symbol_file_add_from_bfd (nbfd
, bfd_get_filename (nbfd
), 0, sai
,
930 OBJF_SHARED
| OBJF_NOT_FILENAME
, NULL
);
932 do_cleanups (old_cleanups
);
933 add_objfile_entry (objfile
, entry_addr
);
936 /* This function registers code associated with a JIT code entry. It uses the
937 pointer and size pair in the entry to read the symbol file from the remote
938 and then calls symbol_file_add_from_local_memory to add it as though it were
939 a symbol file added by the user. */
942 jit_register_code (struct gdbarch
*gdbarch
,
943 CORE_ADDR entry_addr
, struct jit_code_entry
*code_entry
)
948 fprintf_unfiltered (gdb_stdlog
,
949 "jit_register_code, symfile_addr = %s, "
950 "symfile_size = %s\n",
951 paddress (gdbarch
, code_entry
->symfile_addr
),
952 pulongest (code_entry
->symfile_size
));
954 success
= jit_reader_try_read_symtab (code_entry
, entry_addr
);
957 jit_bfd_try_read_symtab (code_entry
, entry_addr
, gdbarch
);
960 /* This function unregisters JITed code and frees the corresponding
964 jit_unregister_code (struct objfile
*objfile
)
966 free_objfile (objfile
);
969 /* Look up the objfile with this code entry address. */
971 static struct objfile
*
972 jit_find_objf_with_entry_addr (CORE_ADDR entry_addr
)
974 struct objfile
*objf
;
978 struct jit_objfile_data
*objf_data
;
980 objf_data
= objfile_data (objf
, jit_objfile_data
);
981 if (objf_data
!= NULL
&& objf_data
->addr
== entry_addr
)
987 /* This is called when a breakpoint is deleted. It updates the
988 inferior's cache, if needed. */
991 jit_breakpoint_deleted (struct breakpoint
*b
)
993 struct bp_location
*iter
;
995 if (b
->type
!= bp_jit_event
)
998 for (iter
= b
->loc
; iter
!= NULL
; iter
= iter
->next
)
1000 struct jit_program_space_data
*ps_data
;
1002 ps_data
= program_space_data (iter
->pspace
, jit_program_space_data
);
1003 if (ps_data
!= NULL
&& ps_data
->jit_breakpoint
== iter
->owner
)
1005 ps_data
->cached_code_address
= 0;
1006 ps_data
->jit_breakpoint
= NULL
;
1011 /* (Re-)Initialize the jit breakpoint if necessary.
1012 Return 0 on success. */
1015 jit_breakpoint_re_set_internal (struct gdbarch
*gdbarch
,
1016 struct jit_program_space_data
*ps_data
)
1018 struct bound_minimal_symbol reg_symbol
;
1019 struct bound_minimal_symbol desc_symbol
;
1020 struct jit_objfile_data
*objf_data
;
1023 if (ps_data
->objfile
== NULL
)
1025 /* Lookup the registration symbol. If it is missing, then we
1026 assume we are not attached to a JIT. */
1027 reg_symbol
= lookup_minimal_symbol_and_objfile (jit_break_name
);
1028 if (reg_symbol
.minsym
== NULL
1029 || MSYMBOL_VALUE_ADDRESS (reg_symbol
.minsym
) == 0)
1032 desc_symbol
= lookup_minimal_symbol (jit_descriptor_name
, NULL
,
1033 reg_symbol
.objfile
);
1034 if (desc_symbol
.minsym
== NULL
1035 || MSYMBOL_VALUE_ADDRESS (desc_symbol
.minsym
) == 0)
1038 objf_data
= get_jit_objfile_data (reg_symbol
.objfile
);
1039 objf_data
->register_code
= reg_symbol
.minsym
;
1040 objf_data
->descriptor
= desc_symbol
.minsym
;
1042 ps_data
->objfile
= reg_symbol
.objfile
;
1045 objf_data
= get_jit_objfile_data (ps_data
->objfile
);
1047 addr
= MSYMBOL_VALUE_ADDRESS (objf_data
->register_code
);
1050 fprintf_unfiltered (gdb_stdlog
,
1051 "jit_breakpoint_re_set_internal, "
1052 "breakpoint_addr = %s\n",
1053 paddress (gdbarch
, addr
));
1055 if (ps_data
->cached_code_address
== addr
)
1058 /* Delete the old breakpoint. */
1059 if (ps_data
->jit_breakpoint
!= NULL
)
1060 delete_breakpoint (ps_data
->jit_breakpoint
);
1062 /* Put a breakpoint in the registration symbol. */
1063 ps_data
->cached_code_address
= addr
;
1064 ps_data
->jit_breakpoint
= create_jit_event_breakpoint (gdbarch
, addr
);
1069 /* The private data passed around in the frame unwind callback
1072 struct jit_unwind_private
1074 /* Cached register values. See jit_frame_sniffer to see how this
1076 struct gdb_reg_value
**registers
;
1078 /* The frame being unwound. */
1079 struct frame_info
*this_frame
;
1082 /* Sets the value of a particular register in this frame. */
1085 jit_unwind_reg_set_impl (struct gdb_unwind_callbacks
*cb
, int dwarf_regnum
,
1086 struct gdb_reg_value
*value
)
1088 struct jit_unwind_private
*priv
;
1091 priv
= cb
->priv_data
;
1093 gdb_reg
= gdbarch_dwarf2_reg_to_regnum (get_frame_arch (priv
->this_frame
),
1098 fprintf_unfiltered (gdb_stdlog
,
1099 _("Could not recognize DWARF regnum %d"),
1104 gdb_assert (priv
->registers
);
1105 priv
->registers
[gdb_reg
] = value
;
1109 reg_value_free_impl (struct gdb_reg_value
*value
)
1114 /* Get the value of register REGNUM in the previous frame. */
1116 static struct gdb_reg_value
*
1117 jit_unwind_reg_get_impl (struct gdb_unwind_callbacks
*cb
, int regnum
)
1119 struct jit_unwind_private
*priv
;
1120 struct gdb_reg_value
*value
;
1122 struct gdbarch
*frame_arch
;
1124 priv
= cb
->priv_data
;
1125 frame_arch
= get_frame_arch (priv
->this_frame
);
1127 gdb_reg
= gdbarch_dwarf2_reg_to_regnum (frame_arch
, regnum
);
1128 size
= register_size (frame_arch
, gdb_reg
);
1129 value
= xmalloc (sizeof (struct gdb_reg_value
) + size
- 1);
1130 value
->defined
= deprecated_frame_register_read (priv
->this_frame
, gdb_reg
,
1133 value
->free
= reg_value_free_impl
;
1137 /* gdb_reg_value has a free function, which must be called on each
1138 saved register value. */
1141 jit_dealloc_cache (struct frame_info
*this_frame
, void *cache
)
1143 struct jit_unwind_private
*priv_data
= cache
;
1144 struct gdbarch
*frame_arch
;
1147 gdb_assert (priv_data
->registers
);
1148 frame_arch
= get_frame_arch (priv_data
->this_frame
);
1150 for (i
= 0; i
< gdbarch_num_regs (frame_arch
); i
++)
1151 if (priv_data
->registers
[i
] && priv_data
->registers
[i
]->free
)
1152 priv_data
->registers
[i
]->free (priv_data
->registers
[i
]);
1154 xfree (priv_data
->registers
);
1158 /* The frame sniffer for the pseudo unwinder.
1160 While this is nominally a frame sniffer, in the case where the JIT
1161 reader actually recognizes the frame, it does a lot more work -- it
1162 unwinds the frame and saves the corresponding register values in
1163 the cache. jit_frame_prev_register simply returns the saved
1167 jit_frame_sniffer (const struct frame_unwind
*self
,
1168 struct frame_info
*this_frame
, void **cache
)
1170 struct jit_unwind_private
*priv_data
;
1171 struct gdb_unwind_callbacks callbacks
;
1172 struct gdb_reader_funcs
*funcs
;
1174 callbacks
.reg_get
= jit_unwind_reg_get_impl
;
1175 callbacks
.reg_set
= jit_unwind_reg_set_impl
;
1176 callbacks
.target_read
= jit_target_read_impl
;
1178 if (loaded_jit_reader
== NULL
)
1181 funcs
= loaded_jit_reader
->functions
;
1183 gdb_assert (!*cache
);
1185 *cache
= XCNEW (struct jit_unwind_private
);
1187 priv_data
->registers
=
1188 XCNEWVEC (struct gdb_reg_value
*,
1189 gdbarch_num_regs (get_frame_arch (this_frame
)));
1190 priv_data
->this_frame
= this_frame
;
1192 callbacks
.priv_data
= priv_data
;
1194 /* Try to coax the provided unwinder to unwind the stack */
1195 if (funcs
->unwind (funcs
, &callbacks
) == GDB_SUCCESS
)
1198 fprintf_unfiltered (gdb_stdlog
, _("Successfully unwound frame using "
1203 fprintf_unfiltered (gdb_stdlog
, _("Could not unwind frame using "
1206 jit_dealloc_cache (this_frame
, *cache
);
1213 /* The frame_id function for the pseudo unwinder. Relays the call to
1214 the loaded plugin. */
1217 jit_frame_this_id (struct frame_info
*this_frame
, void **cache
,
1218 struct frame_id
*this_id
)
1220 struct jit_unwind_private
private;
1221 struct gdb_frame_id frame_id
;
1222 struct gdb_reader_funcs
*funcs
;
1223 struct gdb_unwind_callbacks callbacks
;
1225 private.registers
= NULL
;
1226 private.this_frame
= this_frame
;
1228 /* We don't expect the frame_id function to set any registers, so we
1229 set reg_set to NULL. */
1230 callbacks
.reg_get
= jit_unwind_reg_get_impl
;
1231 callbacks
.reg_set
= NULL
;
1232 callbacks
.target_read
= jit_target_read_impl
;
1233 callbacks
.priv_data
= &private;
1235 gdb_assert (loaded_jit_reader
);
1236 funcs
= loaded_jit_reader
->functions
;
1238 frame_id
= funcs
->get_frame_id (funcs
, &callbacks
);
1239 *this_id
= frame_id_build (frame_id
.stack_address
, frame_id
.code_address
);
1242 /* Pseudo unwinder function. Reads the previously fetched value for
1243 the register from the cache. */
1245 static struct value
*
1246 jit_frame_prev_register (struct frame_info
*this_frame
, void **cache
, int reg
)
1248 struct jit_unwind_private
*priv
= *cache
;
1249 struct gdb_reg_value
*value
;
1252 return frame_unwind_got_optimized (this_frame
, reg
);
1254 gdb_assert (priv
->registers
);
1255 value
= priv
->registers
[reg
];
1256 if (value
&& value
->defined
)
1257 return frame_unwind_got_bytes (this_frame
, reg
, value
->value
);
1259 return frame_unwind_got_optimized (this_frame
, reg
);
1262 /* Relay everything back to the unwinder registered by the JIT debug
1265 static const struct frame_unwind jit_frame_unwind
=
1268 default_frame_unwind_stop_reason
,
1270 jit_frame_prev_register
,
1277 /* This is the information that is stored at jit_gdbarch_data for each
1280 struct jit_gdbarch_data_type
1282 /* Has the (pseudo) unwinder been prepended? */
1283 int unwinder_registered
;
1286 /* Check GDBARCH and prepend the pseudo JIT unwinder if needed. */
1289 jit_prepend_unwinder (struct gdbarch
*gdbarch
)
1291 struct jit_gdbarch_data_type
*data
;
1293 data
= gdbarch_data (gdbarch
, jit_gdbarch_data
);
1294 if (!data
->unwinder_registered
)
1296 frame_unwind_prepend_unwinder (gdbarch
, &jit_frame_unwind
);
1297 data
->unwinder_registered
= 1;
1301 /* Register any already created translations. */
1304 jit_inferior_init (struct gdbarch
*gdbarch
)
1306 struct jit_descriptor descriptor
;
1307 struct jit_code_entry cur_entry
;
1308 struct jit_program_space_data
*ps_data
;
1309 CORE_ADDR cur_entry_addr
;
1312 fprintf_unfiltered (gdb_stdlog
, "jit_inferior_init\n");
1314 jit_prepend_unwinder (gdbarch
);
1316 ps_data
= get_jit_program_space_data ();
1317 if (jit_breakpoint_re_set_internal (gdbarch
, ps_data
) != 0)
1320 /* Read the descriptor so we can check the version number and load
1321 any already JITed functions. */
1322 if (!jit_read_descriptor (gdbarch
, &descriptor
, ps_data
))
1325 /* Check that the version number agrees with that we support. */
1326 if (descriptor
.version
!= 1)
1328 printf_unfiltered (_("Unsupported JIT protocol version %ld "
1329 "in descriptor (expected 1)\n"),
1330 (long) descriptor
.version
);
1334 /* If we've attached to a running program, we need to check the descriptor
1335 to register any functions that were already generated. */
1336 for (cur_entry_addr
= descriptor
.first_entry
;
1337 cur_entry_addr
!= 0;
1338 cur_entry_addr
= cur_entry
.next_entry
)
1340 jit_read_code_entry (gdbarch
, cur_entry_addr
, &cur_entry
);
1342 /* This hook may be called many times during setup, so make sure we don't
1343 add the same symbol file twice. */
1344 if (jit_find_objf_with_entry_addr (cur_entry_addr
) != NULL
)
1347 jit_register_code (gdbarch
, cur_entry_addr
, &cur_entry
);
1351 /* Exported routine to call when an inferior has been created. */
1354 jit_inferior_created_hook (void)
1356 jit_inferior_init (target_gdbarch ());
1359 /* Exported routine to call to re-set the jit breakpoints,
1360 e.g. when a program is rerun. */
1363 jit_breakpoint_re_set (void)
1365 jit_breakpoint_re_set_internal (target_gdbarch (),
1366 get_jit_program_space_data ());
1369 /* This function cleans up any code entries left over when the
1370 inferior exits. We get left over code when the inferior exits
1371 without unregistering its code, for example when it crashes. */
1374 jit_inferior_exit_hook (struct inferior
*inf
)
1376 struct objfile
*objf
;
1377 struct objfile
*temp
;
1379 ALL_OBJFILES_SAFE (objf
, temp
)
1381 struct jit_objfile_data
*objf_data
= objfile_data (objf
,
1384 if (objf_data
!= NULL
&& objf_data
->addr
!= 0)
1385 jit_unregister_code (objf
);
1390 jit_event_handler (struct gdbarch
*gdbarch
)
1392 struct jit_descriptor descriptor
;
1393 struct jit_code_entry code_entry
;
1394 CORE_ADDR entry_addr
;
1395 struct objfile
*objf
;
1397 /* Read the descriptor from remote memory. */
1398 if (!jit_read_descriptor (gdbarch
, &descriptor
,
1399 get_jit_program_space_data ()))
1401 entry_addr
= descriptor
.relevant_entry
;
1403 /* Do the corresponding action. */
1404 switch (descriptor
.action_flag
)
1409 jit_read_code_entry (gdbarch
, entry_addr
, &code_entry
);
1410 jit_register_code (gdbarch
, entry_addr
, &code_entry
);
1412 case JIT_UNREGISTER
:
1413 objf
= jit_find_objf_with_entry_addr (entry_addr
);
1415 printf_unfiltered (_("Unable to find JITed code "
1416 "entry at address: %s\n"),
1417 paddress (gdbarch
, entry_addr
));
1419 jit_unregister_code (objf
);
1423 error (_("Unknown action_flag value in JIT descriptor!"));
1428 /* Called to free the data allocated to the jit_program_space_data slot. */
1431 free_objfile_data (struct objfile
*objfile
, void *data
)
1433 struct jit_objfile_data
*objf_data
= data
;
1435 if (objf_data
->register_code
!= NULL
)
1437 struct jit_program_space_data
*ps_data
;
1439 ps_data
= program_space_data (objfile
->pspace
, jit_program_space_data
);
1440 if (ps_data
!= NULL
&& ps_data
->objfile
== objfile
)
1441 ps_data
->objfile
= NULL
;
1447 /* Initialize the jit_gdbarch_data slot with an instance of struct
1448 jit_gdbarch_data_type */
1451 jit_gdbarch_data_init (struct obstack
*obstack
)
1453 struct jit_gdbarch_data_type
*data
;
1455 data
= obstack_alloc (obstack
, sizeof (struct jit_gdbarch_data_type
));
1456 data
->unwinder_registered
= 0;
1460 /* Provide a prototype to silence -Wmissing-prototypes. */
1462 extern void _initialize_jit (void);
1465 _initialize_jit (void)
1467 jit_reader_dir
= relocate_gdb_directory (JIT_READER_DIR
,
1468 JIT_READER_DIR_RELOCATABLE
);
1469 add_setshow_zuinteger_cmd ("jit", class_maintenance
, &jit_debug
,
1470 _("Set JIT debugging."),
1471 _("Show JIT debugging."),
1472 _("When non-zero, JIT debugging is enabled."),
1475 &setdebuglist
, &showdebuglist
);
1477 observer_attach_inferior_exit (jit_inferior_exit_hook
);
1478 observer_attach_breakpoint_deleted (jit_breakpoint_deleted
);
1481 register_objfile_data_with_cleanup (NULL
, free_objfile_data
);
1482 jit_program_space_data
=
1483 register_program_space_data_with_cleanup (NULL
,
1484 jit_program_space_data_cleanup
);
1485 jit_gdbarch_data
= gdbarch_data_register_pre_init (jit_gdbarch_data_init
);
1486 if (is_dl_available ())
1488 add_com ("jit-reader-load", no_class
, jit_reader_load_command
, _("\
1489 Load FILE as debug info reader and unwinder for JIT compiled code.\n\
1490 Usage: jit-reader-load FILE\n\
1491 Try to load file FILE as a debug info reader (and unwinder) for\n\
1492 JIT compiled code. The file is loaded from " JIT_READER_DIR
",\n\
1493 relocated relative to the GDB executable if required."));
1494 add_com ("jit-reader-unload", no_class
, jit_reader_unload_command
, _("\
1495 Unload the currently loaded JIT debug info reader.\n\
1496 Usage: jit-reader-unload FILE\n\n\
1497 Do \"help jit-reader-load\" for info on loading debug info readers."));