1 /* Handle JIT code generation in the inferior for GDB, the GNU Debugger.
3 Copyright (C) 2009-2016 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
);
54 static void jit_inferior_exit_hook (struct inferior
*inf
);
56 /* An unwinder is registered for every gdbarch. This key is used to
57 remember if the unwinder has been registered for a particular
60 static struct gdbarch_data
*jit_gdbarch_data
;
62 /* Non-zero if we want to see trace of jit level stuff. */
64 static unsigned int jit_debug
= 0;
67 show_jit_debug (struct ui_file
*file
, int from_tty
,
68 struct cmd_list_element
*c
, const char *value
)
70 fprintf_filtered (file
, _("JIT debugging is %s.\n"), value
);
79 /* 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 memset (sb
, 0, sizeof (struct stat
));
131 sb
->st_size
= buffer
->size
;
135 /* Open a BFD from the target's memory. */
138 bfd_open_from_target_memory (CORE_ADDR addr
, ULONGEST size
, char *target
)
140 struct target_buffer
*buffer
= XNEW (struct target_buffer
);
144 return gdb_bfd_openr_iovec ("<in-memory>", target
,
152 /* One reader that has been loaded successfully, and can potentially be used to
155 static struct jit_reader
157 struct gdb_reader_funcs
*functions
;
159 } *loaded_jit_reader
= NULL
;
161 typedef struct gdb_reader_funcs
* (reader_init_fn_type
) (void);
162 static const char *reader_init_fn_sym
= "gdb_init_reader";
164 /* Try to load FILE_NAME as a JIT debug info reader. */
166 static struct jit_reader
*
167 jit_reader_load (const char *file_name
)
170 reader_init_fn_type
*init_fn
;
171 struct jit_reader
*new_reader
= NULL
;
172 struct gdb_reader_funcs
*funcs
= NULL
;
173 struct cleanup
*old_cleanups
;
176 fprintf_unfiltered (gdb_stdlog
, _("Opening shared object %s.\n"),
178 so
= gdb_dlopen (file_name
);
179 old_cleanups
= make_cleanup_dlclose (so
);
181 init_fn
= (reader_init_fn_type
*) gdb_dlsym (so
, reader_init_fn_sym
);
183 error (_("Could not locate initialization function: %s."),
186 if (gdb_dlsym (so
, "plugin_is_GPL_compatible") == NULL
)
187 error (_("Reader not GPL compatible."));
190 if (funcs
->reader_version
!= GDB_READER_INTERFACE_VERSION
)
191 error (_("Reader version does not match GDB version."));
193 new_reader
= XCNEW (struct jit_reader
);
194 new_reader
->functions
= funcs
;
195 new_reader
->handle
= so
;
197 discard_cleanups (old_cleanups
);
201 /* Provides the jit-reader-load command. */
204 jit_reader_load_command (char *args
, int from_tty
)
207 struct cleanup
*prev_cleanup
;
210 error (_("No reader name provided."));
212 if (loaded_jit_reader
!= NULL
)
213 error (_("JIT reader already loaded. Run jit-reader-unload first."));
215 if (IS_ABSOLUTE_PATH (args
))
216 so_name
= xstrdup (args
);
218 so_name
= xstrprintf ("%s%s%s", jit_reader_dir
, SLASH_STRING
, args
);
219 prev_cleanup
= make_cleanup (xfree
, so_name
);
221 loaded_jit_reader
= jit_reader_load (so_name
);
222 reinit_frame_cache ();
223 jit_inferior_created_hook ();
224 do_cleanups (prev_cleanup
);
227 /* Provides the jit-reader-unload command. */
230 jit_reader_unload_command (char *args
, int from_tty
)
232 if (!loaded_jit_reader
)
233 error (_("No JIT reader loaded."));
235 reinit_frame_cache ();
236 jit_inferior_exit_hook (current_inferior ());
237 loaded_jit_reader
->functions
->destroy (loaded_jit_reader
->functions
);
239 gdb_dlclose (loaded_jit_reader
->handle
);
240 xfree (loaded_jit_reader
);
241 loaded_jit_reader
= NULL
;
244 /* Per-program space structure recording which objfile has the JIT
247 struct jit_program_space_data
249 /* The objfile. This is NULL if no objfile holds the JIT
252 struct objfile
*objfile
;
254 /* If this program space has __jit_debug_register_code, this is the
255 cached address from the minimal symbol. This is used to detect
256 relocations requiring the breakpoint to be re-created. */
258 CORE_ADDR cached_code_address
;
260 /* This is the JIT event breakpoint, or NULL if it has not been
263 struct breakpoint
*jit_breakpoint
;
266 /* Per-objfile structure recording the addresses in the program space.
267 This object serves two purposes: for ordinary objfiles, it may
268 cache some symbols related to the JIT interface; and for
269 JIT-created objfiles, it holds some information about the
272 struct jit_objfile_data
274 /* Symbol for __jit_debug_register_code. */
275 struct minimal_symbol
*register_code
;
277 /* Symbol for __jit_debug_descriptor. */
278 struct minimal_symbol
*descriptor
;
280 /* Address of struct jit_code_entry in this objfile. This is only
281 non-zero for objfiles that represent code created by the JIT. */
285 /* Fetch the jit_objfile_data associated with OBJF. If no data exists
286 yet, make a new structure and attach it. */
288 static struct jit_objfile_data
*
289 get_jit_objfile_data (struct objfile
*objf
)
291 struct jit_objfile_data
*objf_data
;
293 objf_data
= (struct jit_objfile_data
*) objfile_data (objf
, jit_objfile_data
);
294 if (objf_data
== NULL
)
296 objf_data
= XCNEW (struct jit_objfile_data
);
297 set_objfile_data (objf
, jit_objfile_data
, objf_data
);
303 /* Remember OBJFILE has been created for struct jit_code_entry located
304 at inferior address ENTRY. */
307 add_objfile_entry (struct objfile
*objfile
, CORE_ADDR entry
)
309 struct jit_objfile_data
*objf_data
;
311 objf_data
= get_jit_objfile_data (objfile
);
312 objf_data
->addr
= entry
;
315 /* Return jit_program_space_data for current program space. Allocate
316 if not already present. */
318 static struct jit_program_space_data
*
319 get_jit_program_space_data (void)
321 struct jit_program_space_data
*ps_data
;
324 = ((struct jit_program_space_data
*)
325 program_space_data (current_program_space
, jit_program_space_data
));
328 ps_data
= XCNEW (struct jit_program_space_data
);
329 set_program_space_data (current_program_space
, jit_program_space_data
,
337 jit_program_space_data_cleanup (struct program_space
*ps
, void *arg
)
342 /* Helper function for reading the global JIT descriptor from remote
343 memory. Returns 1 if all went well, 0 otherwise. */
346 jit_read_descriptor (struct gdbarch
*gdbarch
,
347 struct jit_descriptor
*descriptor
,
348 struct jit_program_space_data
*ps_data
)
351 struct type
*ptr_type
;
355 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
356 struct jit_objfile_data
*objf_data
;
358 if (ps_data
->objfile
== NULL
)
360 objf_data
= get_jit_objfile_data (ps_data
->objfile
);
361 if (objf_data
->descriptor
== NULL
)
365 fprintf_unfiltered (gdb_stdlog
,
366 "jit_read_descriptor, descriptor_addr = %s\n",
367 paddress (gdbarch
, MSYMBOL_VALUE_ADDRESS (ps_data
->objfile
,
368 objf_data
->descriptor
)));
370 /* Figure out how big the descriptor is on the remote and how to read it. */
371 ptr_type
= builtin_type (gdbarch
)->builtin_data_ptr
;
372 ptr_size
= TYPE_LENGTH (ptr_type
);
373 desc_size
= 8 + 2 * ptr_size
; /* Two 32-bit ints and two pointers. */
374 desc_buf
= (gdb_byte
*) alloca (desc_size
);
376 /* Read the descriptor. */
377 err
= target_read_memory (MSYMBOL_VALUE_ADDRESS (ps_data
->objfile
,
378 objf_data
->descriptor
),
379 desc_buf
, desc_size
);
382 printf_unfiltered (_("Unable to read JIT descriptor from "
387 /* Fix the endianness to match the host. */
388 descriptor
->version
= extract_unsigned_integer (&desc_buf
[0], 4, byte_order
);
389 descriptor
->action_flag
=
390 extract_unsigned_integer (&desc_buf
[4], 4, byte_order
);
391 descriptor
->relevant_entry
= extract_typed_address (&desc_buf
[8], ptr_type
);
392 descriptor
->first_entry
=
393 extract_typed_address (&desc_buf
[8 + ptr_size
], ptr_type
);
398 /* Helper function for reading a JITed code entry from remote memory. */
401 jit_read_code_entry (struct gdbarch
*gdbarch
,
402 CORE_ADDR code_addr
, struct jit_code_entry
*code_entry
)
405 struct type
*ptr_type
;
410 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
412 /* Figure out how big the entry is on the remote and how to read it. */
413 ptr_type
= builtin_type (gdbarch
)->builtin_data_ptr
;
414 ptr_size
= TYPE_LENGTH (ptr_type
);
416 /* Figure out where the longlong value will be. */
417 align_bytes
= gdbarch_long_long_align_bit (gdbarch
) / 8;
419 off
= (off
+ (align_bytes
- 1)) & ~(align_bytes
- 1);
421 entry_size
= off
+ 8; /* Three pointers and one 64-bit int. */
422 entry_buf
= (gdb_byte
*) alloca (entry_size
);
424 /* Read the entry. */
425 err
= target_read_memory (code_addr
, entry_buf
, entry_size
);
427 error (_("Unable to read JIT code entry from remote memory!"));
429 /* Fix the endianness to match the host. */
430 ptr_type
= builtin_type (gdbarch
)->builtin_data_ptr
;
431 code_entry
->next_entry
= extract_typed_address (&entry_buf
[0], ptr_type
);
432 code_entry
->prev_entry
=
433 extract_typed_address (&entry_buf
[ptr_size
], ptr_type
);
434 code_entry
->symfile_addr
=
435 extract_typed_address (&entry_buf
[2 * ptr_size
], ptr_type
);
436 code_entry
->symfile_size
=
437 extract_unsigned_integer (&entry_buf
[off
], 8, byte_order
);
440 /* Proxy object for building a block. */
444 /* gdb_blocks are linked into a tree structure. Next points to the
445 next node at the same depth as this block and parent to the
447 struct gdb_block
*next
, *parent
;
449 /* Points to the "real" block that is being built out of this
450 instance. This block will be added to a blockvector, which will
451 then be added to a symtab. */
452 struct block
*real_block
;
454 /* The first and last code address corresponding to this block. */
455 CORE_ADDR begin
, end
;
457 /* The name of this block (if any). If this is non-NULL, the
458 FUNCTION symbol symbol is set to this value. */
462 /* Proxy object for building a symtab. */
466 /* The list of blocks in this symtab. These will eventually be
467 converted to real blocks. */
468 struct gdb_block
*blocks
;
470 /* The number of blocks inserted. */
473 /* A mapping between line numbers to PC. */
474 struct linetable
*linetable
;
476 /* The source file for this symtab. */
477 const char *file_name
;
478 struct gdb_symtab
*next
;
481 /* Proxy object for building an object. */
485 struct gdb_symtab
*symtabs
;
488 /* The type of the `private' data passed around by the callback
491 typedef CORE_ADDR jit_dbg_reader_data
;
493 /* The reader calls into this function to read data off the targets
496 static enum gdb_status
497 jit_target_read_impl (GDB_CORE_ADDR target_mem
, void *gdb_buf
, int len
)
499 int result
= target_read_memory ((CORE_ADDR
) target_mem
,
500 (gdb_byte
*) gdb_buf
, len
);
507 /* The reader calls into this function to create a new gdb_object
508 which it can then pass around to the other callbacks. Right now,
509 all that is required is allocating the memory. */
511 static struct gdb_object
*
512 jit_object_open_impl (struct gdb_symbol_callbacks
*cb
)
514 /* CB is not required right now, but sometime in the future we might
515 need a handle to it, and we'd like to do that without breaking
517 return XCNEW (struct gdb_object
);
520 /* Readers call into this function to open a new gdb_symtab, which,
521 again, is passed around to other callbacks. */
523 static struct gdb_symtab
*
524 jit_symtab_open_impl (struct gdb_symbol_callbacks
*cb
,
525 struct gdb_object
*object
,
526 const char *file_name
)
528 struct gdb_symtab
*ret
;
530 /* CB stays unused. See comment in jit_object_open_impl. */
532 ret
= XCNEW (struct gdb_symtab
);
533 ret
->file_name
= file_name
? xstrdup (file_name
) : xstrdup ("");
534 ret
->next
= object
->symtabs
;
535 object
->symtabs
= ret
;
539 /* Returns true if the block corresponding to old should be placed
540 before the block corresponding to new in the final blockvector. */
543 compare_block (const struct gdb_block
*const old
,
544 const struct gdb_block
*const newobj
)
548 if (old
->begin
< newobj
->begin
)
550 else if (old
->begin
== newobj
->begin
)
552 if (old
->end
> newobj
->end
)
561 /* Called by readers to open a new gdb_block. This function also
562 inserts the new gdb_block in the correct place in the corresponding
565 static struct gdb_block
*
566 jit_block_open_impl (struct gdb_symbol_callbacks
*cb
,
567 struct gdb_symtab
*symtab
, struct gdb_block
*parent
,
568 GDB_CORE_ADDR begin
, GDB_CORE_ADDR end
, const char *name
)
570 struct gdb_block
*block
= XCNEW (struct gdb_block
);
572 block
->next
= symtab
->blocks
;
573 block
->begin
= (CORE_ADDR
) begin
;
574 block
->end
= (CORE_ADDR
) end
;
575 block
->name
= name
? xstrdup (name
) : NULL
;
576 block
->parent
= parent
;
578 /* Ensure that the blocks are inserted in the correct (reverse of
579 the order expected by blockvector). */
580 if (compare_block (symtab
->blocks
, block
))
582 symtab
->blocks
= block
;
586 struct gdb_block
*i
= symtab
->blocks
;
590 /* Guaranteed to terminate, since compare_block (NULL, _)
592 if (compare_block (i
->next
, block
))
594 block
->next
= i
->next
;
605 /* Readers call this to add a line mapping (from PC to line number) to
609 jit_symtab_line_mapping_add_impl (struct gdb_symbol_callbacks
*cb
,
610 struct gdb_symtab
*stab
, int nlines
,
611 struct gdb_line_mapping
*map
)
619 alloc_len
= sizeof (struct linetable
)
620 + (nlines
- 1) * sizeof (struct linetable_entry
);
621 stab
->linetable
= (struct linetable
*) xmalloc (alloc_len
);
622 stab
->linetable
->nitems
= nlines
;
623 for (i
= 0; i
< nlines
; i
++)
625 stab
->linetable
->item
[i
].pc
= (CORE_ADDR
) map
[i
].pc
;
626 stab
->linetable
->item
[i
].line
= map
[i
].line
;
630 /* Called by readers to close a gdb_symtab. Does not need to do
631 anything as of now. */
634 jit_symtab_close_impl (struct gdb_symbol_callbacks
*cb
,
635 struct gdb_symtab
*stab
)
637 /* Right now nothing needs to be done here. We may need to do some
638 cleanup here in the future (again, without breaking the plugin
642 /* Transform STAB to a proper symtab, and add it it OBJFILE. */
645 finalize_symtab (struct gdb_symtab
*stab
, struct objfile
*objfile
)
647 struct compunit_symtab
*cust
;
648 struct gdb_block
*gdb_block_iter
, *gdb_block_iter_tmp
;
649 struct block
*block_iter
;
650 int actual_nblocks
, i
;
651 size_t blockvector_size
;
652 CORE_ADDR begin
, end
;
653 struct blockvector
*bv
;
655 actual_nblocks
= FIRST_LOCAL_BLOCK
+ stab
->nblocks
;
657 cust
= allocate_compunit_symtab (objfile
, stab
->file_name
);
658 allocate_symtab (cust
, stab
->file_name
);
659 add_compunit_symtab_to_objfile (cust
);
661 /* JIT compilers compile in memory. */
662 COMPUNIT_DIRNAME (cust
) = NULL
;
664 /* Copy over the linetable entry if one was provided. */
667 size_t size
= ((stab
->linetable
->nitems
- 1)
668 * sizeof (struct linetable_entry
)
669 + sizeof (struct linetable
));
670 SYMTAB_LINETABLE (COMPUNIT_FILETABS (cust
))
671 = (struct linetable
*) obstack_alloc (&objfile
->objfile_obstack
, size
);
672 memcpy (SYMTAB_LINETABLE (COMPUNIT_FILETABS (cust
)), stab
->linetable
,
676 blockvector_size
= (sizeof (struct blockvector
)
677 + (actual_nblocks
- 1) * sizeof (struct block
*));
678 bv
= (struct blockvector
*) obstack_alloc (&objfile
->objfile_obstack
,
680 COMPUNIT_BLOCKVECTOR (cust
) = bv
;
682 /* (begin, end) will contain the PC range this entire blockvector
684 BLOCKVECTOR_MAP (bv
) = NULL
;
685 begin
= stab
->blocks
->begin
;
686 end
= stab
->blocks
->end
;
687 BLOCKVECTOR_NBLOCKS (bv
) = actual_nblocks
;
689 /* First run over all the gdb_block objects, creating a real block
690 object for each. Simultaneously, keep setting the real_block
692 for (i
= (actual_nblocks
- 1), gdb_block_iter
= stab
->blocks
;
693 i
>= FIRST_LOCAL_BLOCK
;
694 i
--, gdb_block_iter
= gdb_block_iter
->next
)
696 struct block
*new_block
= allocate_block (&objfile
->objfile_obstack
);
697 struct symbol
*block_name
= allocate_symbol (objfile
);
698 struct type
*block_type
= arch_type (get_objfile_arch (objfile
),
703 BLOCK_DICT (new_block
) = dict_create_linear (&objfile
->objfile_obstack
,
705 /* The address range. */
706 BLOCK_START (new_block
) = (CORE_ADDR
) gdb_block_iter
->begin
;
707 BLOCK_END (new_block
) = (CORE_ADDR
) gdb_block_iter
->end
;
710 SYMBOL_DOMAIN (block_name
) = VAR_DOMAIN
;
711 SYMBOL_ACLASS_INDEX (block_name
) = LOC_BLOCK
;
712 symbol_set_symtab (block_name
, COMPUNIT_FILETABS (cust
));
713 SYMBOL_TYPE (block_name
) = lookup_function_type (block_type
);
714 SYMBOL_BLOCK_VALUE (block_name
) = new_block
;
716 block_name
->ginfo
.name
717 = (const char *) obstack_copy0 (&objfile
->objfile_obstack
,
718 gdb_block_iter
->name
,
719 strlen (gdb_block_iter
->name
));
721 BLOCK_FUNCTION (new_block
) = block_name
;
723 BLOCKVECTOR_BLOCK (bv
, i
) = new_block
;
724 if (begin
> BLOCK_START (new_block
))
725 begin
= BLOCK_START (new_block
);
726 if (end
< BLOCK_END (new_block
))
727 end
= BLOCK_END (new_block
);
729 gdb_block_iter
->real_block
= new_block
;
732 /* Now add the special blocks. */
734 for (i
= 0; i
< FIRST_LOCAL_BLOCK
; i
++)
736 struct block
*new_block
;
738 new_block
= (i
== GLOBAL_BLOCK
739 ? allocate_global_block (&objfile
->objfile_obstack
)
740 : allocate_block (&objfile
->objfile_obstack
));
741 BLOCK_DICT (new_block
) = dict_create_linear (&objfile
->objfile_obstack
,
743 BLOCK_SUPERBLOCK (new_block
) = block_iter
;
744 block_iter
= new_block
;
746 BLOCK_START (new_block
) = (CORE_ADDR
) begin
;
747 BLOCK_END (new_block
) = (CORE_ADDR
) end
;
749 BLOCKVECTOR_BLOCK (bv
, i
) = new_block
;
751 if (i
== GLOBAL_BLOCK
)
752 set_block_compunit_symtab (new_block
, cust
);
755 /* Fill up the superblock fields for the real blocks, using the
756 real_block fields populated earlier. */
757 for (gdb_block_iter
= stab
->blocks
;
759 gdb_block_iter
= gdb_block_iter
->next
)
761 if (gdb_block_iter
->parent
!= NULL
)
763 /* If the plugin specifically mentioned a parent block, we
765 BLOCK_SUPERBLOCK (gdb_block_iter
->real_block
) =
766 gdb_block_iter
->parent
->real_block
;
770 /* And if not, we set a default parent block. */
771 BLOCK_SUPERBLOCK (gdb_block_iter
->real_block
) =
772 BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
);
777 gdb_block_iter
= stab
->blocks
;
779 for (gdb_block_iter
= stab
->blocks
, gdb_block_iter_tmp
= gdb_block_iter
->next
;
781 gdb_block_iter
= gdb_block_iter_tmp
)
783 xfree ((void *) gdb_block_iter
->name
);
784 xfree (gdb_block_iter
);
786 xfree (stab
->linetable
);
787 xfree ((char *) stab
->file_name
);
791 /* Called when closing a gdb_objfile. Converts OBJ to a proper
795 jit_object_close_impl (struct gdb_symbol_callbacks
*cb
,
796 struct gdb_object
*obj
)
798 struct gdb_symtab
*i
, *j
;
799 struct objfile
*objfile
;
800 jit_dbg_reader_data
*priv_data
;
802 priv_data
= (jit_dbg_reader_data
*) cb
->priv_data
;
804 objfile
= allocate_objfile (NULL
, "<< JIT compiled code >>",
806 objfile
->per_bfd
->gdbarch
= target_gdbarch ();
808 terminate_minimal_symbol_table (objfile
);
811 for (i
= obj
->symtabs
; i
; i
= j
)
814 finalize_symtab (i
, objfile
);
816 add_objfile_entry (objfile
, *priv_data
);
820 /* Try to read CODE_ENTRY using the loaded jit reader (if any).
821 ENTRY_ADDR is the address of the struct jit_code_entry in the
822 inferior address space. */
825 jit_reader_try_read_symtab (struct jit_code_entry
*code_entry
,
826 CORE_ADDR entry_addr
)
830 jit_dbg_reader_data priv_data
;
831 struct gdb_reader_funcs
*funcs
;
832 struct gdb_symbol_callbacks callbacks
=
834 jit_object_open_impl
,
835 jit_symtab_open_impl
,
837 jit_symtab_close_impl
,
838 jit_object_close_impl
,
840 jit_symtab_line_mapping_add_impl
,
841 jit_target_read_impl
,
846 priv_data
= entry_addr
;
848 if (!loaded_jit_reader
)
851 gdb_mem
= (gdb_byte
*) xmalloc (code_entry
->symfile_size
);
856 if (target_read_memory (code_entry
->symfile_addr
, gdb_mem
,
857 code_entry
->symfile_size
))
860 CATCH (e
, RETURN_MASK_ALL
)
868 funcs
= loaded_jit_reader
->functions
;
869 if (funcs
->read (funcs
, &callbacks
, gdb_mem
, code_entry
->symfile_size
)
875 if (jit_debug
&& status
== 0)
876 fprintf_unfiltered (gdb_stdlog
,
877 "Could not read symtab using the loaded JIT reader.\n");
881 /* Try to read CODE_ENTRY using BFD. ENTRY_ADDR is the address of the
882 struct jit_code_entry in the inferior address space. */
885 jit_bfd_try_read_symtab (struct jit_code_entry
*code_entry
,
886 CORE_ADDR entry_addr
,
887 struct gdbarch
*gdbarch
)
890 struct section_addr_info
*sai
;
891 struct bfd_section
*sec
;
892 struct objfile
*objfile
;
893 struct cleanup
*old_cleanups
;
895 const struct bfd_arch_info
*b
;
898 fprintf_unfiltered (gdb_stdlog
,
899 "jit_register_code, symfile_addr = %s, "
900 "symfile_size = %s\n",
901 paddress (gdbarch
, code_entry
->symfile_addr
),
902 pulongest (code_entry
->symfile_size
));
904 nbfd
= bfd_open_from_target_memory (code_entry
->symfile_addr
,
905 code_entry
->symfile_size
, gnutarget
);
908 puts_unfiltered (_("Error opening JITed symbol file, ignoring it.\n"));
912 /* Check the format. NOTE: This initializes important data that GDB uses!
913 We would segfault later without this line. */
914 if (!bfd_check_format (nbfd
, bfd_object
))
916 printf_unfiltered (_("\
917 JITed symbol file is not an object file, ignoring it.\n"));
918 gdb_bfd_unref (nbfd
);
922 /* Check bfd arch. */
923 b
= gdbarch_bfd_arch_info (gdbarch
);
924 if (b
->compatible (b
, bfd_get_arch_info (nbfd
)) != b
)
925 warning (_("JITed object file architecture %s is not compatible "
926 "with target architecture %s."), bfd_get_arch_info
927 (nbfd
)->printable_name
, b
->printable_name
);
929 /* Read the section address information out of the symbol file. Since the
930 file is generated by the JIT at runtime, it should all of the absolute
931 addresses that we care about. */
932 sai
= alloc_section_addr_info (bfd_count_sections (nbfd
));
933 old_cleanups
= make_cleanup_free_section_addr_info (sai
);
935 for (sec
= nbfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
936 if ((bfd_get_section_flags (nbfd
, sec
) & (SEC_ALLOC
|SEC_LOAD
)) != 0)
938 /* We assume that these virtual addresses are absolute, and do not
939 treat them as offsets. */
940 sai
->other
[i
].addr
= bfd_get_section_vma (nbfd
, sec
);
941 sai
->other
[i
].name
= xstrdup (bfd_get_section_name (nbfd
, sec
));
942 sai
->other
[i
].sectindex
= sec
->index
;
945 sai
->num_sections
= i
;
947 /* This call does not take ownership of SAI. */
948 make_cleanup_bfd_unref (nbfd
);
949 objfile
= symbol_file_add_from_bfd (nbfd
, bfd_get_filename (nbfd
), 0, sai
,
950 OBJF_SHARED
| OBJF_NOT_FILENAME
, NULL
);
952 do_cleanups (old_cleanups
);
953 add_objfile_entry (objfile
, entry_addr
);
956 /* This function registers code associated with a JIT code entry. It uses the
957 pointer and size pair in the entry to read the symbol file from the remote
958 and then calls symbol_file_add_from_local_memory to add it as though it were
959 a symbol file added by the user. */
962 jit_register_code (struct gdbarch
*gdbarch
,
963 CORE_ADDR entry_addr
, struct jit_code_entry
*code_entry
)
968 fprintf_unfiltered (gdb_stdlog
,
969 "jit_register_code, symfile_addr = %s, "
970 "symfile_size = %s\n",
971 paddress (gdbarch
, code_entry
->symfile_addr
),
972 pulongest (code_entry
->symfile_size
));
974 success
= jit_reader_try_read_symtab (code_entry
, entry_addr
);
977 jit_bfd_try_read_symtab (code_entry
, entry_addr
, gdbarch
);
980 /* This function unregisters JITed code and frees the corresponding
984 jit_unregister_code (struct objfile
*objfile
)
986 free_objfile (objfile
);
989 /* Look up the objfile with this code entry address. */
991 static struct objfile
*
992 jit_find_objf_with_entry_addr (CORE_ADDR entry_addr
)
994 struct objfile
*objf
;
998 struct jit_objfile_data
*objf_data
;
1001 = (struct jit_objfile_data
*) objfile_data (objf
, jit_objfile_data
);
1002 if (objf_data
!= NULL
&& objf_data
->addr
== entry_addr
)
1008 /* This is called when a breakpoint is deleted. It updates the
1009 inferior's cache, if needed. */
1012 jit_breakpoint_deleted (struct breakpoint
*b
)
1014 struct bp_location
*iter
;
1016 if (b
->type
!= bp_jit_event
)
1019 for (iter
= b
->loc
; iter
!= NULL
; iter
= iter
->next
)
1021 struct jit_program_space_data
*ps_data
;
1023 ps_data
= ((struct jit_program_space_data
*)
1024 program_space_data (iter
->pspace
, jit_program_space_data
));
1025 if (ps_data
!= NULL
&& ps_data
->jit_breakpoint
== iter
->owner
)
1027 ps_data
->cached_code_address
= 0;
1028 ps_data
->jit_breakpoint
= NULL
;
1033 /* (Re-)Initialize the jit breakpoint if necessary.
1034 Return 0 if the jit breakpoint has been successfully initialized. */
1037 jit_breakpoint_re_set_internal (struct gdbarch
*gdbarch
,
1038 struct jit_program_space_data
*ps_data
)
1040 struct bound_minimal_symbol reg_symbol
;
1041 struct bound_minimal_symbol desc_symbol
;
1042 struct jit_objfile_data
*objf_data
;
1045 if (ps_data
->objfile
== NULL
)
1047 /* Lookup the registration symbol. If it is missing, then we
1048 assume we are not attached to a JIT. */
1049 reg_symbol
= lookup_minimal_symbol_and_objfile (jit_break_name
);
1050 if (reg_symbol
.minsym
== NULL
1051 || BMSYMBOL_VALUE_ADDRESS (reg_symbol
) == 0)
1054 desc_symbol
= lookup_minimal_symbol (jit_descriptor_name
, NULL
,
1055 reg_symbol
.objfile
);
1056 if (desc_symbol
.minsym
== NULL
1057 || BMSYMBOL_VALUE_ADDRESS (desc_symbol
) == 0)
1060 objf_data
= get_jit_objfile_data (reg_symbol
.objfile
);
1061 objf_data
->register_code
= reg_symbol
.minsym
;
1062 objf_data
->descriptor
= desc_symbol
.minsym
;
1064 ps_data
->objfile
= reg_symbol
.objfile
;
1067 objf_data
= get_jit_objfile_data (ps_data
->objfile
);
1069 addr
= MSYMBOL_VALUE_ADDRESS (ps_data
->objfile
, objf_data
->register_code
);
1072 fprintf_unfiltered (gdb_stdlog
,
1073 "jit_breakpoint_re_set_internal, "
1074 "breakpoint_addr = %s\n",
1075 paddress (gdbarch
, addr
));
1077 if (ps_data
->cached_code_address
== addr
)
1080 /* Delete the old breakpoint. */
1081 if (ps_data
->jit_breakpoint
!= NULL
)
1082 delete_breakpoint (ps_data
->jit_breakpoint
);
1084 /* Put a breakpoint in the registration symbol. */
1085 ps_data
->cached_code_address
= addr
;
1086 ps_data
->jit_breakpoint
= create_jit_event_breakpoint (gdbarch
, addr
);
1091 /* The private data passed around in the frame unwind callback
1094 struct jit_unwind_private
1096 /* Cached register values. See jit_frame_sniffer to see how this
1098 struct regcache
*regcache
;
1100 /* The frame being unwound. */
1101 struct frame_info
*this_frame
;
1104 /* Sets the value of a particular register in this frame. */
1107 jit_unwind_reg_set_impl (struct gdb_unwind_callbacks
*cb
, int dwarf_regnum
,
1108 struct gdb_reg_value
*value
)
1110 struct jit_unwind_private
*priv
;
1113 priv
= (struct jit_unwind_private
*) cb
->priv_data
;
1115 gdb_reg
= gdbarch_dwarf2_reg_to_regnum (get_frame_arch (priv
->this_frame
),
1120 fprintf_unfiltered (gdb_stdlog
,
1121 _("Could not recognize DWARF regnum %d"),
1123 value
->free (value
);
1127 regcache_raw_set_cached_value (priv
->regcache
, gdb_reg
, value
->value
);
1128 value
->free (value
);
1132 reg_value_free_impl (struct gdb_reg_value
*value
)
1137 /* Get the value of register REGNUM in the previous frame. */
1139 static struct gdb_reg_value
*
1140 jit_unwind_reg_get_impl (struct gdb_unwind_callbacks
*cb
, int regnum
)
1142 struct jit_unwind_private
*priv
;
1143 struct gdb_reg_value
*value
;
1145 struct gdbarch
*frame_arch
;
1147 priv
= (struct jit_unwind_private
*) cb
->priv_data
;
1148 frame_arch
= get_frame_arch (priv
->this_frame
);
1150 gdb_reg
= gdbarch_dwarf2_reg_to_regnum (frame_arch
, regnum
);
1151 size
= register_size (frame_arch
, gdb_reg
);
1152 value
= ((struct gdb_reg_value
*)
1153 xmalloc (sizeof (struct gdb_reg_value
) + size
- 1));
1154 value
->defined
= deprecated_frame_register_read (priv
->this_frame
, gdb_reg
,
1157 value
->free
= reg_value_free_impl
;
1161 /* gdb_reg_value has a free function, which must be called on each
1162 saved register value. */
1165 jit_dealloc_cache (struct frame_info
*this_frame
, void *cache
)
1167 struct jit_unwind_private
*priv_data
= (struct jit_unwind_private
*) cache
;
1168 struct gdbarch
*frame_arch
;
1171 gdb_assert (priv_data
->regcache
!= NULL
);
1172 frame_arch
= get_frame_arch (priv_data
->this_frame
);
1174 regcache_xfree (priv_data
->regcache
);
1178 /* The frame sniffer for the pseudo unwinder.
1180 While this is nominally a frame sniffer, in the case where the JIT
1181 reader actually recognizes the frame, it does a lot more work -- it
1182 unwinds the frame and saves the corresponding register values in
1183 the cache. jit_frame_prev_register simply returns the saved
1187 jit_frame_sniffer (const struct frame_unwind
*self
,
1188 struct frame_info
*this_frame
, void **cache
)
1190 struct jit_unwind_private
*priv_data
;
1191 struct gdb_unwind_callbacks callbacks
;
1192 struct gdb_reader_funcs
*funcs
;
1193 struct address_space
*aspace
;
1194 struct gdbarch
*gdbarch
;
1196 callbacks
.reg_get
= jit_unwind_reg_get_impl
;
1197 callbacks
.reg_set
= jit_unwind_reg_set_impl
;
1198 callbacks
.target_read
= jit_target_read_impl
;
1200 if (loaded_jit_reader
== NULL
)
1203 funcs
= loaded_jit_reader
->functions
;
1205 gdb_assert (!*cache
);
1207 aspace
= get_frame_address_space (this_frame
);
1208 gdbarch
= get_frame_arch (this_frame
);
1210 *cache
= XCNEW (struct jit_unwind_private
);
1211 priv_data
= (struct jit_unwind_private
*) *cache
;
1212 priv_data
->regcache
= regcache_xmalloc (gdbarch
, aspace
);
1213 priv_data
->this_frame
= this_frame
;
1215 callbacks
.priv_data
= priv_data
;
1217 /* Try to coax the provided unwinder to unwind the stack */
1218 if (funcs
->unwind (funcs
, &callbacks
) == GDB_SUCCESS
)
1221 fprintf_unfiltered (gdb_stdlog
, _("Successfully unwound frame using "
1226 fprintf_unfiltered (gdb_stdlog
, _("Could not unwind frame using "
1229 jit_dealloc_cache (this_frame
, *cache
);
1236 /* The frame_id function for the pseudo unwinder. Relays the call to
1237 the loaded plugin. */
1240 jit_frame_this_id (struct frame_info
*this_frame
, void **cache
,
1241 struct frame_id
*this_id
)
1243 struct jit_unwind_private priv
;
1244 struct gdb_frame_id frame_id
;
1245 struct gdb_reader_funcs
*funcs
;
1246 struct gdb_unwind_callbacks callbacks
;
1248 priv
.regcache
= NULL
;
1249 priv
.this_frame
= this_frame
;
1251 /* We don't expect the frame_id function to set any registers, so we
1252 set reg_set to NULL. */
1253 callbacks
.reg_get
= jit_unwind_reg_get_impl
;
1254 callbacks
.reg_set
= NULL
;
1255 callbacks
.target_read
= jit_target_read_impl
;
1256 callbacks
.priv_data
= &priv
;
1258 gdb_assert (loaded_jit_reader
);
1259 funcs
= loaded_jit_reader
->functions
;
1261 frame_id
= funcs
->get_frame_id (funcs
, &callbacks
);
1262 *this_id
= frame_id_build (frame_id
.stack_address
, frame_id
.code_address
);
1265 /* Pseudo unwinder function. Reads the previously fetched value for
1266 the register from the cache. */
1268 static struct value
*
1269 jit_frame_prev_register (struct frame_info
*this_frame
, void **cache
, int reg
)
1271 struct jit_unwind_private
*priv
= (struct jit_unwind_private
*) *cache
;
1272 struct gdbarch
*gdbarch
;
1275 return frame_unwind_got_optimized (this_frame
, reg
);
1277 gdbarch
= get_regcache_arch (priv
->regcache
);
1278 if (reg
< gdbarch_num_regs (gdbarch
))
1280 gdb_byte
*buf
= (gdb_byte
*) alloca (register_size (gdbarch
, reg
));
1281 enum register_status status
;
1283 status
= regcache_raw_read (priv
->regcache
, reg
, buf
);
1284 if (status
== REG_VALID
)
1285 return frame_unwind_got_bytes (this_frame
, reg
, buf
);
1287 return frame_unwind_got_optimized (this_frame
, reg
);
1290 return gdbarch_pseudo_register_read_value (gdbarch
, priv
->regcache
, reg
);
1293 /* Relay everything back to the unwinder registered by the JIT debug
1296 static const struct frame_unwind jit_frame_unwind
=
1299 default_frame_unwind_stop_reason
,
1301 jit_frame_prev_register
,
1308 /* This is the information that is stored at jit_gdbarch_data for each
1311 struct jit_gdbarch_data_type
1313 /* Has the (pseudo) unwinder been prepended? */
1314 int unwinder_registered
;
1317 /* Check GDBARCH and prepend the pseudo JIT unwinder if needed. */
1320 jit_prepend_unwinder (struct gdbarch
*gdbarch
)
1322 struct jit_gdbarch_data_type
*data
;
1325 = (struct jit_gdbarch_data_type
*) gdbarch_data (gdbarch
, jit_gdbarch_data
);
1326 if (!data
->unwinder_registered
)
1328 frame_unwind_prepend_unwinder (gdbarch
, &jit_frame_unwind
);
1329 data
->unwinder_registered
= 1;
1333 /* Register any already created translations. */
1336 jit_inferior_init (struct gdbarch
*gdbarch
)
1338 struct jit_descriptor descriptor
;
1339 struct jit_code_entry cur_entry
;
1340 struct jit_program_space_data
*ps_data
;
1341 CORE_ADDR cur_entry_addr
;
1344 fprintf_unfiltered (gdb_stdlog
, "jit_inferior_init\n");
1346 jit_prepend_unwinder (gdbarch
);
1348 ps_data
= get_jit_program_space_data ();
1349 if (jit_breakpoint_re_set_internal (gdbarch
, ps_data
) != 0)
1352 /* Read the descriptor so we can check the version number and load
1353 any already JITed functions. */
1354 if (!jit_read_descriptor (gdbarch
, &descriptor
, ps_data
))
1357 /* Check that the version number agrees with that we support. */
1358 if (descriptor
.version
!= 1)
1360 printf_unfiltered (_("Unsupported JIT protocol version %ld "
1361 "in descriptor (expected 1)\n"),
1362 (long) descriptor
.version
);
1366 /* If we've attached to a running program, we need to check the descriptor
1367 to register any functions that were already generated. */
1368 for (cur_entry_addr
= descriptor
.first_entry
;
1369 cur_entry_addr
!= 0;
1370 cur_entry_addr
= cur_entry
.next_entry
)
1372 jit_read_code_entry (gdbarch
, cur_entry_addr
, &cur_entry
);
1374 /* This hook may be called many times during setup, so make sure we don't
1375 add the same symbol file twice. */
1376 if (jit_find_objf_with_entry_addr (cur_entry_addr
) != NULL
)
1379 jit_register_code (gdbarch
, cur_entry_addr
, &cur_entry
);
1383 /* inferior_created observer. */
1386 jit_inferior_created (struct target_ops
*ops
, int from_tty
)
1388 jit_inferior_created_hook ();
1391 /* Exported routine to call when an inferior has been created. */
1394 jit_inferior_created_hook (void)
1396 jit_inferior_init (target_gdbarch ());
1399 /* Exported routine to call to re-set the jit breakpoints,
1400 e.g. when a program is rerun. */
1403 jit_breakpoint_re_set (void)
1405 jit_breakpoint_re_set_internal (target_gdbarch (),
1406 get_jit_program_space_data ());
1409 /* This function cleans up any code entries left over when the
1410 inferior exits. We get left over code when the inferior exits
1411 without unregistering its code, for example when it crashes. */
1414 jit_inferior_exit_hook (struct inferior
*inf
)
1416 struct objfile
*objf
;
1417 struct objfile
*temp
;
1419 ALL_OBJFILES_SAFE (objf
, temp
)
1421 struct jit_objfile_data
*objf_data
1422 = (struct jit_objfile_data
*) objfile_data (objf
, jit_objfile_data
);
1424 if (objf_data
!= NULL
&& objf_data
->addr
!= 0)
1425 jit_unregister_code (objf
);
1430 jit_event_handler (struct gdbarch
*gdbarch
)
1432 struct jit_descriptor descriptor
;
1433 struct jit_code_entry code_entry
;
1434 CORE_ADDR entry_addr
;
1435 struct objfile
*objf
;
1437 /* Read the descriptor from remote memory. */
1438 if (!jit_read_descriptor (gdbarch
, &descriptor
,
1439 get_jit_program_space_data ()))
1441 entry_addr
= descriptor
.relevant_entry
;
1443 /* Do the corresponding action. */
1444 switch (descriptor
.action_flag
)
1449 jit_read_code_entry (gdbarch
, entry_addr
, &code_entry
);
1450 jit_register_code (gdbarch
, entry_addr
, &code_entry
);
1452 case JIT_UNREGISTER
:
1453 objf
= jit_find_objf_with_entry_addr (entry_addr
);
1455 printf_unfiltered (_("Unable to find JITed code "
1456 "entry at address: %s\n"),
1457 paddress (gdbarch
, entry_addr
));
1459 jit_unregister_code (objf
);
1463 error (_("Unknown action_flag value in JIT descriptor!"));
1468 /* Called to free the data allocated to the jit_program_space_data slot. */
1471 free_objfile_data (struct objfile
*objfile
, void *data
)
1473 struct jit_objfile_data
*objf_data
= (struct jit_objfile_data
*) data
;
1475 if (objf_data
->register_code
!= NULL
)
1477 struct jit_program_space_data
*ps_data
;
1480 = ((struct jit_program_space_data
*)
1481 program_space_data (objfile
->pspace
, jit_program_space_data
));
1482 if (ps_data
!= NULL
&& ps_data
->objfile
== objfile
)
1483 ps_data
->objfile
= NULL
;
1489 /* Initialize the jit_gdbarch_data slot with an instance of struct
1490 jit_gdbarch_data_type */
1493 jit_gdbarch_data_init (struct obstack
*obstack
)
1495 struct jit_gdbarch_data_type
*data
=
1496 XOBNEW (obstack
, struct jit_gdbarch_data_type
);
1498 data
->unwinder_registered
= 0;
1503 /* Provide a prototype to silence -Wmissing-prototypes. */
1505 extern void _initialize_jit (void);
1508 _initialize_jit (void)
1510 jit_reader_dir
= relocate_gdb_directory (JIT_READER_DIR
,
1511 JIT_READER_DIR_RELOCATABLE
);
1512 add_setshow_zuinteger_cmd ("jit", class_maintenance
, &jit_debug
,
1513 _("Set JIT debugging."),
1514 _("Show JIT debugging."),
1515 _("When non-zero, JIT debugging is enabled."),
1518 &setdebuglist
, &showdebuglist
);
1520 observer_attach_inferior_created (jit_inferior_created
);
1521 observer_attach_inferior_exit (jit_inferior_exit_hook
);
1522 observer_attach_breakpoint_deleted (jit_breakpoint_deleted
);
1525 register_objfile_data_with_cleanup (NULL
, free_objfile_data
);
1526 jit_program_space_data
=
1527 register_program_space_data_with_cleanup (NULL
,
1528 jit_program_space_data_cleanup
);
1529 jit_gdbarch_data
= gdbarch_data_register_pre_init (jit_gdbarch_data_init
);
1530 if (is_dl_available ())
1532 add_com ("jit-reader-load", no_class
, jit_reader_load_command
, _("\
1533 Load FILE as debug info reader and unwinder for JIT compiled code.\n\
1534 Usage: jit-reader-load FILE\n\
1535 Try to load file FILE as a debug info reader (and unwinder) for\n\
1536 JIT compiled code. The file is loaded from " JIT_READER_DIR
",\n\
1537 relocated relative to the GDB executable if required."));
1538 add_com ("jit-reader-unload", no_class
, jit_reader_unload_command
, _("\
1539 Unload the currently loaded JIT debug info reader.\n\
1540 Usage: jit-reader-unload FILE\n\n\
1541 Do \"help jit-reader-load\" for info on loading debug info readers."));