1 /* Handle JIT code generation in the inferior for GDB, the GNU Debugger.
3 Copyright (C) 2009-2017 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"
42 #include "readline/tilde.h"
43 #include "completer.h"
45 static const char *jit_reader_dir
= NULL
;
47 static const struct objfile_data
*jit_objfile_data
;
49 static const char *const jit_break_name
= "__jit_debug_register_code";
51 static const char *const jit_descriptor_name
= "__jit_debug_descriptor";
53 static const struct program_space_data
*jit_program_space_data
= NULL
;
55 static void jit_inferior_init (struct gdbarch
*gdbarch
);
56 static void jit_inferior_exit_hook (struct inferior
*inf
);
58 /* An unwinder is registered for every gdbarch. This key is used to
59 remember if the unwinder has been registered for a particular
62 static struct gdbarch_data
*jit_gdbarch_data
;
64 /* Non-zero if we want to see trace of jit level stuff. */
66 static unsigned int jit_debug
= 0;
69 show_jit_debug (struct ui_file
*file
, int from_tty
,
70 struct cmd_list_element
*c
, const char *value
)
72 fprintf_filtered (file
, _("JIT debugging is %s.\n"), value
);
81 /* Openning the file is a no-op. */
84 mem_bfd_iovec_open (struct bfd
*abfd
, void *open_closure
)
89 /* Closing the file is just freeing the base/size pair on our side. */
92 mem_bfd_iovec_close (struct bfd
*abfd
, void *stream
)
96 /* Zero means success. */
100 /* For reading the file, we just need to pass through to target_read_memory and
101 fix up the arguments and return values. */
104 mem_bfd_iovec_pread (struct bfd
*abfd
, void *stream
, void *buf
,
105 file_ptr nbytes
, file_ptr offset
)
108 struct target_buffer
*buffer
= (struct target_buffer
*) stream
;
110 /* If this read will read all of the file, limit it to just the rest. */
111 if (offset
+ nbytes
> buffer
->size
)
112 nbytes
= buffer
->size
- offset
;
114 /* If there are no more bytes left, we've reached EOF. */
118 err
= target_read_memory (buffer
->base
+ offset
, (gdb_byte
*) buf
, nbytes
);
125 /* For statting the file, we only support the st_size attribute. */
128 mem_bfd_iovec_stat (struct bfd
*abfd
, void *stream
, struct stat
*sb
)
130 struct target_buffer
*buffer
= (struct target_buffer
*) stream
;
132 memset (sb
, 0, sizeof (struct stat
));
133 sb
->st_size
= buffer
->size
;
137 /* Open a BFD from the target's memory. */
139 static gdb_bfd_ref_ptr
140 bfd_open_from_target_memory (CORE_ADDR addr
, ULONGEST size
, char *target
)
142 struct target_buffer
*buffer
= XNEW (struct target_buffer
);
146 return gdb_bfd_openr_iovec ("<in-memory>", target
,
156 jit_reader (struct gdb_reader_funcs
*f
, gdb_dlhandle_up
&&h
)
157 : functions (f
), handle (std::move (h
))
163 functions
->destroy (functions
);
166 jit_reader (const jit_reader
&) = delete;
167 jit_reader
&operator= (const jit_reader
&) = delete;
169 struct gdb_reader_funcs
*functions
;
170 gdb_dlhandle_up handle
;
173 /* One reader that has been loaded successfully, and can potentially be used to
176 static struct jit_reader
*loaded_jit_reader
= NULL
;
178 typedef struct gdb_reader_funcs
* (reader_init_fn_type
) (void);
179 static const char *reader_init_fn_sym
= "gdb_init_reader";
181 /* Try to load FILE_NAME as a JIT debug info reader. */
183 static struct jit_reader
*
184 jit_reader_load (const char *file_name
)
186 reader_init_fn_type
*init_fn
;
187 struct gdb_reader_funcs
*funcs
= NULL
;
190 fprintf_unfiltered (gdb_stdlog
, _("Opening shared object %s.\n"),
192 gdb_dlhandle_up so
= gdb_dlopen (file_name
);
194 init_fn
= (reader_init_fn_type
*) gdb_dlsym (so
, reader_init_fn_sym
);
196 error (_("Could not locate initialization function: %s."),
199 if (gdb_dlsym (so
, "plugin_is_GPL_compatible") == NULL
)
200 error (_("Reader not GPL compatible."));
203 if (funcs
->reader_version
!= GDB_READER_INTERFACE_VERSION
)
204 error (_("Reader version does not match GDB version."));
206 return new jit_reader (funcs
, std::move (so
));
209 /* Provides the jit-reader-load command. */
212 jit_reader_load_command (char *args
, int from_tty
)
215 struct cleanup
*prev_cleanup
;
218 error (_("No reader name provided."));
219 args
= tilde_expand (args
);
220 prev_cleanup
= make_cleanup (xfree
, args
);
222 if (loaded_jit_reader
!= NULL
)
223 error (_("JIT reader already loaded. Run jit-reader-unload first."));
225 if (IS_ABSOLUTE_PATH (args
))
229 so_name
= xstrprintf ("%s%s%s", jit_reader_dir
, SLASH_STRING
, args
);
230 make_cleanup (xfree
, so_name
);
233 loaded_jit_reader
= jit_reader_load (so_name
);
234 reinit_frame_cache ();
235 jit_inferior_created_hook ();
236 do_cleanups (prev_cleanup
);
239 /* Provides the jit-reader-unload command. */
242 jit_reader_unload_command (char *args
, int from_tty
)
244 if (!loaded_jit_reader
)
245 error (_("No JIT reader loaded."));
247 reinit_frame_cache ();
248 jit_inferior_exit_hook (current_inferior ());
250 delete loaded_jit_reader
;
251 loaded_jit_reader
= NULL
;
254 /* Per-program space structure recording which objfile has the JIT
257 struct jit_program_space_data
259 /* The objfile. This is NULL if no objfile holds the JIT
262 struct objfile
*objfile
;
264 /* If this program space has __jit_debug_register_code, this is the
265 cached address from the minimal symbol. This is used to detect
266 relocations requiring the breakpoint to be re-created. */
268 CORE_ADDR cached_code_address
;
270 /* This is the JIT event breakpoint, or NULL if it has not been
273 struct breakpoint
*jit_breakpoint
;
276 /* Per-objfile structure recording the addresses in the program space.
277 This object serves two purposes: for ordinary objfiles, it may
278 cache some symbols related to the JIT interface; and for
279 JIT-created objfiles, it holds some information about the
282 struct jit_objfile_data
284 /* Symbol for __jit_debug_register_code. */
285 struct minimal_symbol
*register_code
;
287 /* Symbol for __jit_debug_descriptor. */
288 struct minimal_symbol
*descriptor
;
290 /* Address of struct jit_code_entry in this objfile. This is only
291 non-zero for objfiles that represent code created by the JIT. */
295 /* Fetch the jit_objfile_data associated with OBJF. If no data exists
296 yet, make a new structure and attach it. */
298 static struct jit_objfile_data
*
299 get_jit_objfile_data (struct objfile
*objf
)
301 struct jit_objfile_data
*objf_data
;
303 objf_data
= (struct jit_objfile_data
*) objfile_data (objf
, jit_objfile_data
);
304 if (objf_data
== NULL
)
306 objf_data
= XCNEW (struct jit_objfile_data
);
307 set_objfile_data (objf
, jit_objfile_data
, objf_data
);
313 /* Remember OBJFILE has been created for struct jit_code_entry located
314 at inferior address ENTRY. */
317 add_objfile_entry (struct objfile
*objfile
, CORE_ADDR entry
)
319 struct jit_objfile_data
*objf_data
;
321 objf_data
= get_jit_objfile_data (objfile
);
322 objf_data
->addr
= entry
;
325 /* Return jit_program_space_data for current program space. Allocate
326 if not already present. */
328 static struct jit_program_space_data
*
329 get_jit_program_space_data (void)
331 struct jit_program_space_data
*ps_data
;
334 = ((struct jit_program_space_data
*)
335 program_space_data (current_program_space
, jit_program_space_data
));
338 ps_data
= XCNEW (struct jit_program_space_data
);
339 set_program_space_data (current_program_space
, jit_program_space_data
,
347 jit_program_space_data_cleanup (struct program_space
*ps
, void *arg
)
352 /* Helper function for reading the global JIT descriptor from remote
353 memory. Returns 1 if all went well, 0 otherwise. */
356 jit_read_descriptor (struct gdbarch
*gdbarch
,
357 struct jit_descriptor
*descriptor
,
358 struct jit_program_space_data
*ps_data
)
361 struct type
*ptr_type
;
365 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
366 struct jit_objfile_data
*objf_data
;
368 if (ps_data
->objfile
== NULL
)
370 objf_data
= get_jit_objfile_data (ps_data
->objfile
);
371 if (objf_data
->descriptor
== NULL
)
375 fprintf_unfiltered (gdb_stdlog
,
376 "jit_read_descriptor, descriptor_addr = %s\n",
377 paddress (gdbarch
, MSYMBOL_VALUE_ADDRESS (ps_data
->objfile
,
378 objf_data
->descriptor
)));
380 /* Figure out how big the descriptor is on the remote and how to read it. */
381 ptr_type
= builtin_type (gdbarch
)->builtin_data_ptr
;
382 ptr_size
= TYPE_LENGTH (ptr_type
);
383 desc_size
= 8 + 2 * ptr_size
; /* Two 32-bit ints and two pointers. */
384 desc_buf
= (gdb_byte
*) alloca (desc_size
);
386 /* Read the descriptor. */
387 err
= target_read_memory (MSYMBOL_VALUE_ADDRESS (ps_data
->objfile
,
388 objf_data
->descriptor
),
389 desc_buf
, desc_size
);
392 printf_unfiltered (_("Unable to read JIT descriptor from "
397 /* Fix the endianness to match the host. */
398 descriptor
->version
= extract_unsigned_integer (&desc_buf
[0], 4, byte_order
);
399 descriptor
->action_flag
=
400 extract_unsigned_integer (&desc_buf
[4], 4, byte_order
);
401 descriptor
->relevant_entry
= extract_typed_address (&desc_buf
[8], ptr_type
);
402 descriptor
->first_entry
=
403 extract_typed_address (&desc_buf
[8 + ptr_size
], ptr_type
);
408 /* Helper function for reading a JITed code entry from remote memory. */
411 jit_read_code_entry (struct gdbarch
*gdbarch
,
412 CORE_ADDR code_addr
, struct jit_code_entry
*code_entry
)
415 struct type
*ptr_type
;
420 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
422 /* Figure out how big the entry is on the remote and how to read it. */
423 ptr_type
= builtin_type (gdbarch
)->builtin_data_ptr
;
424 ptr_size
= TYPE_LENGTH (ptr_type
);
426 /* Figure out where the longlong value will be. */
427 align_bytes
= gdbarch_long_long_align_bit (gdbarch
) / 8;
429 off
= (off
+ (align_bytes
- 1)) & ~(align_bytes
- 1);
431 entry_size
= off
+ 8; /* Three pointers and one 64-bit int. */
432 entry_buf
= (gdb_byte
*) alloca (entry_size
);
434 /* Read the entry. */
435 err
= target_read_memory (code_addr
, entry_buf
, entry_size
);
437 error (_("Unable to read JIT code entry from remote memory!"));
439 /* Fix the endianness to match the host. */
440 ptr_type
= builtin_type (gdbarch
)->builtin_data_ptr
;
441 code_entry
->next_entry
= extract_typed_address (&entry_buf
[0], ptr_type
);
442 code_entry
->prev_entry
=
443 extract_typed_address (&entry_buf
[ptr_size
], ptr_type
);
444 code_entry
->symfile_addr
=
445 extract_typed_address (&entry_buf
[2 * ptr_size
], ptr_type
);
446 code_entry
->symfile_size
=
447 extract_unsigned_integer (&entry_buf
[off
], 8, byte_order
);
450 /* Proxy object for building a block. */
454 /* gdb_blocks are linked into a tree structure. Next points to the
455 next node at the same depth as this block and parent to the
457 struct gdb_block
*next
, *parent
;
459 /* Points to the "real" block that is being built out of this
460 instance. This block will be added to a blockvector, which will
461 then be added to a symtab. */
462 struct block
*real_block
;
464 /* The first and last code address corresponding to this block. */
465 CORE_ADDR begin
, end
;
467 /* The name of this block (if any). If this is non-NULL, the
468 FUNCTION symbol symbol is set to this value. */
472 /* Proxy object for building a symtab. */
476 /* The list of blocks in this symtab. These will eventually be
477 converted to real blocks. */
478 struct gdb_block
*blocks
;
480 /* The number of blocks inserted. */
483 /* A mapping between line numbers to PC. */
484 struct linetable
*linetable
;
486 /* The source file for this symtab. */
487 const char *file_name
;
488 struct gdb_symtab
*next
;
491 /* Proxy object for building an object. */
495 struct gdb_symtab
*symtabs
;
498 /* The type of the `private' data passed around by the callback
501 typedef CORE_ADDR jit_dbg_reader_data
;
503 /* The reader calls into this function to read data off the targets
506 static enum gdb_status
507 jit_target_read_impl (GDB_CORE_ADDR target_mem
, void *gdb_buf
, int len
)
509 int result
= target_read_memory ((CORE_ADDR
) target_mem
,
510 (gdb_byte
*) gdb_buf
, len
);
517 /* The reader calls into this function to create a new gdb_object
518 which it can then pass around to the other callbacks. Right now,
519 all that is required is allocating the memory. */
521 static struct gdb_object
*
522 jit_object_open_impl (struct gdb_symbol_callbacks
*cb
)
524 /* CB is not required right now, but sometime in the future we might
525 need a handle to it, and we'd like to do that without breaking
527 return XCNEW (struct gdb_object
);
530 /* Readers call into this function to open a new gdb_symtab, which,
531 again, is passed around to other callbacks. */
533 static struct gdb_symtab
*
534 jit_symtab_open_impl (struct gdb_symbol_callbacks
*cb
,
535 struct gdb_object
*object
,
536 const char *file_name
)
538 struct gdb_symtab
*ret
;
540 /* CB stays unused. See comment in jit_object_open_impl. */
542 ret
= XCNEW (struct gdb_symtab
);
543 ret
->file_name
= file_name
? xstrdup (file_name
) : xstrdup ("");
544 ret
->next
= object
->symtabs
;
545 object
->symtabs
= ret
;
549 /* Returns true if the block corresponding to old should be placed
550 before the block corresponding to new in the final blockvector. */
553 compare_block (const struct gdb_block
*const old
,
554 const struct gdb_block
*const newobj
)
558 if (old
->begin
< newobj
->begin
)
560 else if (old
->begin
== newobj
->begin
)
562 if (old
->end
> newobj
->end
)
571 /* Called by readers to open a new gdb_block. This function also
572 inserts the new gdb_block in the correct place in the corresponding
575 static struct gdb_block
*
576 jit_block_open_impl (struct gdb_symbol_callbacks
*cb
,
577 struct gdb_symtab
*symtab
, struct gdb_block
*parent
,
578 GDB_CORE_ADDR begin
, GDB_CORE_ADDR end
, const char *name
)
580 struct gdb_block
*block
= XCNEW (struct gdb_block
);
582 block
->next
= symtab
->blocks
;
583 block
->begin
= (CORE_ADDR
) begin
;
584 block
->end
= (CORE_ADDR
) end
;
585 block
->name
= name
? xstrdup (name
) : NULL
;
586 block
->parent
= parent
;
588 /* Ensure that the blocks are inserted in the correct (reverse of
589 the order expected by blockvector). */
590 if (compare_block (symtab
->blocks
, block
))
592 symtab
->blocks
= block
;
596 struct gdb_block
*i
= symtab
->blocks
;
600 /* Guaranteed to terminate, since compare_block (NULL, _)
602 if (compare_block (i
->next
, block
))
604 block
->next
= i
->next
;
615 /* Readers call this to add a line mapping (from PC to line number) to
619 jit_symtab_line_mapping_add_impl (struct gdb_symbol_callbacks
*cb
,
620 struct gdb_symtab
*stab
, int nlines
,
621 struct gdb_line_mapping
*map
)
629 alloc_len
= sizeof (struct linetable
)
630 + (nlines
- 1) * sizeof (struct linetable_entry
);
631 stab
->linetable
= (struct linetable
*) xmalloc (alloc_len
);
632 stab
->linetable
->nitems
= nlines
;
633 for (i
= 0; i
< nlines
; i
++)
635 stab
->linetable
->item
[i
].pc
= (CORE_ADDR
) map
[i
].pc
;
636 stab
->linetable
->item
[i
].line
= map
[i
].line
;
640 /* Called by readers to close a gdb_symtab. Does not need to do
641 anything as of now. */
644 jit_symtab_close_impl (struct gdb_symbol_callbacks
*cb
,
645 struct gdb_symtab
*stab
)
647 /* Right now nothing needs to be done here. We may need to do some
648 cleanup here in the future (again, without breaking the plugin
652 /* Transform STAB to a proper symtab, and add it it OBJFILE. */
655 finalize_symtab (struct gdb_symtab
*stab
, struct objfile
*objfile
)
657 struct compunit_symtab
*cust
;
658 struct gdb_block
*gdb_block_iter
, *gdb_block_iter_tmp
;
659 struct block
*block_iter
;
660 int actual_nblocks
, i
;
661 size_t blockvector_size
;
662 CORE_ADDR begin
, end
;
663 struct blockvector
*bv
;
665 actual_nblocks
= FIRST_LOCAL_BLOCK
+ stab
->nblocks
;
667 cust
= allocate_compunit_symtab (objfile
, stab
->file_name
);
668 allocate_symtab (cust
, stab
->file_name
);
669 add_compunit_symtab_to_objfile (cust
);
671 /* JIT compilers compile in memory. */
672 COMPUNIT_DIRNAME (cust
) = NULL
;
674 /* Copy over the linetable entry if one was provided. */
677 size_t size
= ((stab
->linetable
->nitems
- 1)
678 * sizeof (struct linetable_entry
)
679 + sizeof (struct linetable
));
680 SYMTAB_LINETABLE (COMPUNIT_FILETABS (cust
))
681 = (struct linetable
*) obstack_alloc (&objfile
->objfile_obstack
, size
);
682 memcpy (SYMTAB_LINETABLE (COMPUNIT_FILETABS (cust
)), stab
->linetable
,
686 blockvector_size
= (sizeof (struct blockvector
)
687 + (actual_nblocks
- 1) * sizeof (struct block
*));
688 bv
= (struct blockvector
*) obstack_alloc (&objfile
->objfile_obstack
,
690 COMPUNIT_BLOCKVECTOR (cust
) = bv
;
692 /* (begin, end) will contain the PC range this entire blockvector
694 BLOCKVECTOR_MAP (bv
) = NULL
;
695 begin
= stab
->blocks
->begin
;
696 end
= stab
->blocks
->end
;
697 BLOCKVECTOR_NBLOCKS (bv
) = actual_nblocks
;
699 /* First run over all the gdb_block objects, creating a real block
700 object for each. Simultaneously, keep setting the real_block
702 for (i
= (actual_nblocks
- 1), gdb_block_iter
= stab
->blocks
;
703 i
>= FIRST_LOCAL_BLOCK
;
704 i
--, gdb_block_iter
= gdb_block_iter
->next
)
706 struct block
*new_block
= allocate_block (&objfile
->objfile_obstack
);
707 struct symbol
*block_name
= allocate_symbol (objfile
);
708 struct type
*block_type
= arch_type (get_objfile_arch (objfile
),
713 BLOCK_DICT (new_block
) = dict_create_linear (&objfile
->objfile_obstack
,
715 /* The address range. */
716 BLOCK_START (new_block
) = (CORE_ADDR
) gdb_block_iter
->begin
;
717 BLOCK_END (new_block
) = (CORE_ADDR
) gdb_block_iter
->end
;
720 SYMBOL_DOMAIN (block_name
) = VAR_DOMAIN
;
721 SYMBOL_ACLASS_INDEX (block_name
) = LOC_BLOCK
;
722 symbol_set_symtab (block_name
, COMPUNIT_FILETABS (cust
));
723 SYMBOL_TYPE (block_name
) = lookup_function_type (block_type
);
724 SYMBOL_BLOCK_VALUE (block_name
) = new_block
;
726 block_name
->ginfo
.name
727 = (const char *) obstack_copy0 (&objfile
->objfile_obstack
,
728 gdb_block_iter
->name
,
729 strlen (gdb_block_iter
->name
));
731 BLOCK_FUNCTION (new_block
) = block_name
;
733 BLOCKVECTOR_BLOCK (bv
, i
) = new_block
;
734 if (begin
> BLOCK_START (new_block
))
735 begin
= BLOCK_START (new_block
);
736 if (end
< BLOCK_END (new_block
))
737 end
= BLOCK_END (new_block
);
739 gdb_block_iter
->real_block
= new_block
;
742 /* Now add the special blocks. */
744 for (i
= 0; i
< FIRST_LOCAL_BLOCK
; i
++)
746 struct block
*new_block
;
748 new_block
= (i
== GLOBAL_BLOCK
749 ? allocate_global_block (&objfile
->objfile_obstack
)
750 : allocate_block (&objfile
->objfile_obstack
));
751 BLOCK_DICT (new_block
) = dict_create_linear (&objfile
->objfile_obstack
,
753 BLOCK_SUPERBLOCK (new_block
) = block_iter
;
754 block_iter
= new_block
;
756 BLOCK_START (new_block
) = (CORE_ADDR
) begin
;
757 BLOCK_END (new_block
) = (CORE_ADDR
) end
;
759 BLOCKVECTOR_BLOCK (bv
, i
) = new_block
;
761 if (i
== GLOBAL_BLOCK
)
762 set_block_compunit_symtab (new_block
, cust
);
765 /* Fill up the superblock fields for the real blocks, using the
766 real_block fields populated earlier. */
767 for (gdb_block_iter
= stab
->blocks
;
769 gdb_block_iter
= gdb_block_iter
->next
)
771 if (gdb_block_iter
->parent
!= NULL
)
773 /* If the plugin specifically mentioned a parent block, we
775 BLOCK_SUPERBLOCK (gdb_block_iter
->real_block
) =
776 gdb_block_iter
->parent
->real_block
;
780 /* And if not, we set a default parent block. */
781 BLOCK_SUPERBLOCK (gdb_block_iter
->real_block
) =
782 BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
);
787 gdb_block_iter
= stab
->blocks
;
789 for (gdb_block_iter
= stab
->blocks
, gdb_block_iter_tmp
= gdb_block_iter
->next
;
791 gdb_block_iter
= gdb_block_iter_tmp
)
793 xfree ((void *) gdb_block_iter
->name
);
794 xfree (gdb_block_iter
);
796 xfree (stab
->linetable
);
797 xfree ((char *) stab
->file_name
);
801 /* Called when closing a gdb_objfile. Converts OBJ to a proper
805 jit_object_close_impl (struct gdb_symbol_callbacks
*cb
,
806 struct gdb_object
*obj
)
808 struct gdb_symtab
*i
, *j
;
809 struct objfile
*objfile
;
810 jit_dbg_reader_data
*priv_data
;
812 priv_data
= (jit_dbg_reader_data
*) cb
->priv_data
;
814 objfile
= allocate_objfile (NULL
, "<< JIT compiled code >>",
816 objfile
->per_bfd
->gdbarch
= target_gdbarch ();
818 terminate_minimal_symbol_table (objfile
);
821 for (i
= obj
->symtabs
; i
; i
= j
)
824 finalize_symtab (i
, objfile
);
826 add_objfile_entry (objfile
, *priv_data
);
830 /* Try to read CODE_ENTRY using the loaded jit reader (if any).
831 ENTRY_ADDR is the address of the struct jit_code_entry in the
832 inferior address space. */
835 jit_reader_try_read_symtab (struct jit_code_entry
*code_entry
,
836 CORE_ADDR entry_addr
)
840 jit_dbg_reader_data priv_data
;
841 struct gdb_reader_funcs
*funcs
;
842 struct gdb_symbol_callbacks callbacks
=
844 jit_object_open_impl
,
845 jit_symtab_open_impl
,
847 jit_symtab_close_impl
,
848 jit_object_close_impl
,
850 jit_symtab_line_mapping_add_impl
,
851 jit_target_read_impl
,
856 priv_data
= entry_addr
;
858 if (!loaded_jit_reader
)
861 gdb_mem
= (gdb_byte
*) xmalloc (code_entry
->symfile_size
);
866 if (target_read_memory (code_entry
->symfile_addr
, gdb_mem
,
867 code_entry
->symfile_size
))
870 CATCH (e
, RETURN_MASK_ALL
)
878 funcs
= loaded_jit_reader
->functions
;
879 if (funcs
->read (funcs
, &callbacks
, gdb_mem
, code_entry
->symfile_size
)
885 if (jit_debug
&& status
== 0)
886 fprintf_unfiltered (gdb_stdlog
,
887 "Could not read symtab using the loaded JIT reader.\n");
891 /* Try to read CODE_ENTRY using BFD. ENTRY_ADDR is the address of the
892 struct jit_code_entry in the inferior address space. */
895 jit_bfd_try_read_symtab (struct jit_code_entry
*code_entry
,
896 CORE_ADDR entry_addr
,
897 struct gdbarch
*gdbarch
)
899 struct section_addr_info
*sai
;
900 struct bfd_section
*sec
;
901 struct objfile
*objfile
;
902 struct cleanup
*old_cleanups
;
904 const struct bfd_arch_info
*b
;
907 fprintf_unfiltered (gdb_stdlog
,
908 "jit_register_code, symfile_addr = %s, "
909 "symfile_size = %s\n",
910 paddress (gdbarch
, code_entry
->symfile_addr
),
911 pulongest (code_entry
->symfile_size
));
913 gdb_bfd_ref_ptr
nbfd (bfd_open_from_target_memory (code_entry
->symfile_addr
,
914 code_entry
->symfile_size
,
918 puts_unfiltered (_("Error opening JITed symbol file, ignoring it.\n"));
922 /* Check the format. NOTE: This initializes important data that GDB uses!
923 We would segfault later without this line. */
924 if (!bfd_check_format (nbfd
.get (), bfd_object
))
926 printf_unfiltered (_("\
927 JITed symbol file is not an object file, ignoring it.\n"));
931 /* Check bfd arch. */
932 b
= gdbarch_bfd_arch_info (gdbarch
);
933 if (b
->compatible (b
, bfd_get_arch_info (nbfd
.get ())) != b
)
934 warning (_("JITed object file architecture %s is not compatible "
935 "with target architecture %s."),
936 bfd_get_arch_info (nbfd
.get ())->printable_name
,
939 /* Read the section address information out of the symbol file. Since the
940 file is generated by the JIT at runtime, it should all of the absolute
941 addresses that we care about. */
942 sai
= alloc_section_addr_info (bfd_count_sections (nbfd
.get ()));
943 old_cleanups
= make_cleanup_free_section_addr_info (sai
);
945 for (sec
= nbfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
946 if ((bfd_get_section_flags (nbfd
.get (), sec
) & (SEC_ALLOC
|SEC_LOAD
)) != 0)
948 /* We assume that these virtual addresses are absolute, and do not
949 treat them as offsets. */
950 sai
->other
[i
].addr
= bfd_get_section_vma (nbfd
.get (), sec
);
951 sai
->other
[i
].name
= xstrdup (bfd_get_section_name (nbfd
.get (), sec
));
952 sai
->other
[i
].sectindex
= sec
->index
;
955 sai
->num_sections
= i
;
957 /* This call does not take ownership of SAI. */
958 objfile
= symbol_file_add_from_bfd (nbfd
.get (),
959 bfd_get_filename (nbfd
.get ()), 0, sai
,
960 OBJF_SHARED
| OBJF_NOT_FILENAME
, NULL
);
962 do_cleanups (old_cleanups
);
963 add_objfile_entry (objfile
, entry_addr
);
966 /* This function registers code associated with a JIT code entry. It uses the
967 pointer and size pair in the entry to read the symbol file from the remote
968 and then calls symbol_file_add_from_local_memory to add it as though it were
969 a symbol file added by the user. */
972 jit_register_code (struct gdbarch
*gdbarch
,
973 CORE_ADDR entry_addr
, struct jit_code_entry
*code_entry
)
978 fprintf_unfiltered (gdb_stdlog
,
979 "jit_register_code, symfile_addr = %s, "
980 "symfile_size = %s\n",
981 paddress (gdbarch
, code_entry
->symfile_addr
),
982 pulongest (code_entry
->symfile_size
));
984 success
= jit_reader_try_read_symtab (code_entry
, entry_addr
);
987 jit_bfd_try_read_symtab (code_entry
, entry_addr
, gdbarch
);
990 /* This function unregisters JITed code and frees the corresponding
994 jit_unregister_code (struct objfile
*objfile
)
996 free_objfile (objfile
);
999 /* Look up the objfile with this code entry address. */
1001 static struct objfile
*
1002 jit_find_objf_with_entry_addr (CORE_ADDR entry_addr
)
1004 struct objfile
*objf
;
1008 struct jit_objfile_data
*objf_data
;
1011 = (struct jit_objfile_data
*) objfile_data (objf
, jit_objfile_data
);
1012 if (objf_data
!= NULL
&& objf_data
->addr
== entry_addr
)
1018 /* This is called when a breakpoint is deleted. It updates the
1019 inferior's cache, if needed. */
1022 jit_breakpoint_deleted (struct breakpoint
*b
)
1024 struct bp_location
*iter
;
1026 if (b
->type
!= bp_jit_event
)
1029 for (iter
= b
->loc
; iter
!= NULL
; iter
= iter
->next
)
1031 struct jit_program_space_data
*ps_data
;
1033 ps_data
= ((struct jit_program_space_data
*)
1034 program_space_data (iter
->pspace
, jit_program_space_data
));
1035 if (ps_data
!= NULL
&& ps_data
->jit_breakpoint
== iter
->owner
)
1037 ps_data
->cached_code_address
= 0;
1038 ps_data
->jit_breakpoint
= NULL
;
1043 /* (Re-)Initialize the jit breakpoint if necessary.
1044 Return 0 if the jit breakpoint has been successfully initialized. */
1047 jit_breakpoint_re_set_internal (struct gdbarch
*gdbarch
,
1048 struct jit_program_space_data
*ps_data
)
1050 struct bound_minimal_symbol reg_symbol
;
1051 struct bound_minimal_symbol desc_symbol
;
1052 struct jit_objfile_data
*objf_data
;
1055 if (ps_data
->objfile
== NULL
)
1057 /* Lookup the registration symbol. If it is missing, then we
1058 assume we are not attached to a JIT. */
1059 reg_symbol
= lookup_minimal_symbol_and_objfile (jit_break_name
);
1060 if (reg_symbol
.minsym
== NULL
1061 || BMSYMBOL_VALUE_ADDRESS (reg_symbol
) == 0)
1064 desc_symbol
= lookup_minimal_symbol (jit_descriptor_name
, NULL
,
1065 reg_symbol
.objfile
);
1066 if (desc_symbol
.minsym
== NULL
1067 || BMSYMBOL_VALUE_ADDRESS (desc_symbol
) == 0)
1070 objf_data
= get_jit_objfile_data (reg_symbol
.objfile
);
1071 objf_data
->register_code
= reg_symbol
.minsym
;
1072 objf_data
->descriptor
= desc_symbol
.minsym
;
1074 ps_data
->objfile
= reg_symbol
.objfile
;
1077 objf_data
= get_jit_objfile_data (ps_data
->objfile
);
1079 addr
= MSYMBOL_VALUE_ADDRESS (ps_data
->objfile
, objf_data
->register_code
);
1082 fprintf_unfiltered (gdb_stdlog
,
1083 "jit_breakpoint_re_set_internal, "
1084 "breakpoint_addr = %s\n",
1085 paddress (gdbarch
, addr
));
1087 if (ps_data
->cached_code_address
== addr
)
1090 /* Delete the old breakpoint. */
1091 if (ps_data
->jit_breakpoint
!= NULL
)
1092 delete_breakpoint (ps_data
->jit_breakpoint
);
1094 /* Put a breakpoint in the registration symbol. */
1095 ps_data
->cached_code_address
= addr
;
1096 ps_data
->jit_breakpoint
= create_jit_event_breakpoint (gdbarch
, addr
);
1101 /* The private data passed around in the frame unwind callback
1104 struct jit_unwind_private
1106 /* Cached register values. See jit_frame_sniffer to see how this
1108 struct regcache
*regcache
;
1110 /* The frame being unwound. */
1111 struct frame_info
*this_frame
;
1114 /* Sets the value of a particular register in this frame. */
1117 jit_unwind_reg_set_impl (struct gdb_unwind_callbacks
*cb
, int dwarf_regnum
,
1118 struct gdb_reg_value
*value
)
1120 struct jit_unwind_private
*priv
;
1123 priv
= (struct jit_unwind_private
*) cb
->priv_data
;
1125 gdb_reg
= gdbarch_dwarf2_reg_to_regnum (get_frame_arch (priv
->this_frame
),
1130 fprintf_unfiltered (gdb_stdlog
,
1131 _("Could not recognize DWARF regnum %d"),
1133 value
->free (value
);
1137 regcache_raw_set_cached_value (priv
->regcache
, gdb_reg
, value
->value
);
1138 value
->free (value
);
1142 reg_value_free_impl (struct gdb_reg_value
*value
)
1147 /* Get the value of register REGNUM in the previous frame. */
1149 static struct gdb_reg_value
*
1150 jit_unwind_reg_get_impl (struct gdb_unwind_callbacks
*cb
, int regnum
)
1152 struct jit_unwind_private
*priv
;
1153 struct gdb_reg_value
*value
;
1155 struct gdbarch
*frame_arch
;
1157 priv
= (struct jit_unwind_private
*) cb
->priv_data
;
1158 frame_arch
= get_frame_arch (priv
->this_frame
);
1160 gdb_reg
= gdbarch_dwarf2_reg_to_regnum (frame_arch
, regnum
);
1161 size
= register_size (frame_arch
, gdb_reg
);
1162 value
= ((struct gdb_reg_value
*)
1163 xmalloc (sizeof (struct gdb_reg_value
) + size
- 1));
1164 value
->defined
= deprecated_frame_register_read (priv
->this_frame
, gdb_reg
,
1167 value
->free
= reg_value_free_impl
;
1171 /* gdb_reg_value has a free function, which must be called on each
1172 saved register value. */
1175 jit_dealloc_cache (struct frame_info
*this_frame
, void *cache
)
1177 struct jit_unwind_private
*priv_data
= (struct jit_unwind_private
*) cache
;
1179 gdb_assert (priv_data
->regcache
!= NULL
);
1180 regcache_xfree (priv_data
->regcache
);
1184 /* The frame sniffer for the pseudo unwinder.
1186 While this is nominally a frame sniffer, in the case where the JIT
1187 reader actually recognizes the frame, it does a lot more work -- it
1188 unwinds the frame and saves the corresponding register values in
1189 the cache. jit_frame_prev_register simply returns the saved
1193 jit_frame_sniffer (const struct frame_unwind
*self
,
1194 struct frame_info
*this_frame
, void **cache
)
1196 struct jit_unwind_private
*priv_data
;
1197 struct gdb_unwind_callbacks callbacks
;
1198 struct gdb_reader_funcs
*funcs
;
1199 struct address_space
*aspace
;
1200 struct gdbarch
*gdbarch
;
1202 callbacks
.reg_get
= jit_unwind_reg_get_impl
;
1203 callbacks
.reg_set
= jit_unwind_reg_set_impl
;
1204 callbacks
.target_read
= jit_target_read_impl
;
1206 if (loaded_jit_reader
== NULL
)
1209 funcs
= loaded_jit_reader
->functions
;
1211 gdb_assert (!*cache
);
1213 aspace
= get_frame_address_space (this_frame
);
1214 gdbarch
= get_frame_arch (this_frame
);
1216 *cache
= XCNEW (struct jit_unwind_private
);
1217 priv_data
= (struct jit_unwind_private
*) *cache
;
1218 priv_data
->regcache
= regcache_xmalloc (gdbarch
, aspace
);
1219 priv_data
->this_frame
= this_frame
;
1221 callbacks
.priv_data
= priv_data
;
1223 /* Try to coax the provided unwinder to unwind the stack */
1224 if (funcs
->unwind (funcs
, &callbacks
) == GDB_SUCCESS
)
1227 fprintf_unfiltered (gdb_stdlog
, _("Successfully unwound frame using "
1232 fprintf_unfiltered (gdb_stdlog
, _("Could not unwind frame using "
1235 jit_dealloc_cache (this_frame
, *cache
);
1242 /* The frame_id function for the pseudo unwinder. Relays the call to
1243 the loaded plugin. */
1246 jit_frame_this_id (struct frame_info
*this_frame
, void **cache
,
1247 struct frame_id
*this_id
)
1249 struct jit_unwind_private priv
;
1250 struct gdb_frame_id frame_id
;
1251 struct gdb_reader_funcs
*funcs
;
1252 struct gdb_unwind_callbacks callbacks
;
1254 priv
.regcache
= NULL
;
1255 priv
.this_frame
= this_frame
;
1257 /* We don't expect the frame_id function to set any registers, so we
1258 set reg_set to NULL. */
1259 callbacks
.reg_get
= jit_unwind_reg_get_impl
;
1260 callbacks
.reg_set
= NULL
;
1261 callbacks
.target_read
= jit_target_read_impl
;
1262 callbacks
.priv_data
= &priv
;
1264 gdb_assert (loaded_jit_reader
);
1265 funcs
= loaded_jit_reader
->functions
;
1267 frame_id
= funcs
->get_frame_id (funcs
, &callbacks
);
1268 *this_id
= frame_id_build (frame_id
.stack_address
, frame_id
.code_address
);
1271 /* Pseudo unwinder function. Reads the previously fetched value for
1272 the register from the cache. */
1274 static struct value
*
1275 jit_frame_prev_register (struct frame_info
*this_frame
, void **cache
, int reg
)
1277 struct jit_unwind_private
*priv
= (struct jit_unwind_private
*) *cache
;
1278 struct gdbarch
*gdbarch
;
1281 return frame_unwind_got_optimized (this_frame
, reg
);
1283 gdbarch
= get_regcache_arch (priv
->regcache
);
1284 if (reg
< gdbarch_num_regs (gdbarch
))
1286 gdb_byte
*buf
= (gdb_byte
*) alloca (register_size (gdbarch
, reg
));
1287 enum register_status status
;
1289 status
= regcache_raw_read (priv
->regcache
, reg
, buf
);
1290 if (status
== REG_VALID
)
1291 return frame_unwind_got_bytes (this_frame
, reg
, buf
);
1293 return frame_unwind_got_optimized (this_frame
, reg
);
1296 return gdbarch_pseudo_register_read_value (gdbarch
, priv
->regcache
, reg
);
1299 /* Relay everything back to the unwinder registered by the JIT debug
1302 static const struct frame_unwind jit_frame_unwind
=
1305 default_frame_unwind_stop_reason
,
1307 jit_frame_prev_register
,
1314 /* This is the information that is stored at jit_gdbarch_data for each
1317 struct jit_gdbarch_data_type
1319 /* Has the (pseudo) unwinder been prepended? */
1320 int unwinder_registered
;
1323 /* Check GDBARCH and prepend the pseudo JIT unwinder if needed. */
1326 jit_prepend_unwinder (struct gdbarch
*gdbarch
)
1328 struct jit_gdbarch_data_type
*data
;
1331 = (struct jit_gdbarch_data_type
*) gdbarch_data (gdbarch
, jit_gdbarch_data
);
1332 if (!data
->unwinder_registered
)
1334 frame_unwind_prepend_unwinder (gdbarch
, &jit_frame_unwind
);
1335 data
->unwinder_registered
= 1;
1339 /* Register any already created translations. */
1342 jit_inferior_init (struct gdbarch
*gdbarch
)
1344 struct jit_descriptor descriptor
;
1345 struct jit_code_entry cur_entry
;
1346 struct jit_program_space_data
*ps_data
;
1347 CORE_ADDR cur_entry_addr
;
1350 fprintf_unfiltered (gdb_stdlog
, "jit_inferior_init\n");
1352 jit_prepend_unwinder (gdbarch
);
1354 ps_data
= get_jit_program_space_data ();
1355 if (jit_breakpoint_re_set_internal (gdbarch
, ps_data
) != 0)
1358 /* Read the descriptor so we can check the version number and load
1359 any already JITed functions. */
1360 if (!jit_read_descriptor (gdbarch
, &descriptor
, ps_data
))
1363 /* Check that the version number agrees with that we support. */
1364 if (descriptor
.version
!= 1)
1366 printf_unfiltered (_("Unsupported JIT protocol version %ld "
1367 "in descriptor (expected 1)\n"),
1368 (long) descriptor
.version
);
1372 /* If we've attached to a running program, we need to check the descriptor
1373 to register any functions that were already generated. */
1374 for (cur_entry_addr
= descriptor
.first_entry
;
1375 cur_entry_addr
!= 0;
1376 cur_entry_addr
= cur_entry
.next_entry
)
1378 jit_read_code_entry (gdbarch
, cur_entry_addr
, &cur_entry
);
1380 /* This hook may be called many times during setup, so make sure we don't
1381 add the same symbol file twice. */
1382 if (jit_find_objf_with_entry_addr (cur_entry_addr
) != NULL
)
1385 jit_register_code (gdbarch
, cur_entry_addr
, &cur_entry
);
1389 /* inferior_created observer. */
1392 jit_inferior_created (struct target_ops
*ops
, int from_tty
)
1394 jit_inferior_created_hook ();
1397 /* Exported routine to call when an inferior has been created. */
1400 jit_inferior_created_hook (void)
1402 jit_inferior_init (target_gdbarch ());
1405 /* Exported routine to call to re-set the jit breakpoints,
1406 e.g. when a program is rerun. */
1409 jit_breakpoint_re_set (void)
1411 jit_breakpoint_re_set_internal (target_gdbarch (),
1412 get_jit_program_space_data ());
1415 /* This function cleans up any code entries left over when the
1416 inferior exits. We get left over code when the inferior exits
1417 without unregistering its code, for example when it crashes. */
1420 jit_inferior_exit_hook (struct inferior
*inf
)
1422 struct objfile
*objf
;
1423 struct objfile
*temp
;
1425 ALL_OBJFILES_SAFE (objf
, temp
)
1427 struct jit_objfile_data
*objf_data
1428 = (struct jit_objfile_data
*) objfile_data (objf
, jit_objfile_data
);
1430 if (objf_data
!= NULL
&& objf_data
->addr
!= 0)
1431 jit_unregister_code (objf
);
1436 jit_event_handler (struct gdbarch
*gdbarch
)
1438 struct jit_descriptor descriptor
;
1439 struct jit_code_entry code_entry
;
1440 CORE_ADDR entry_addr
;
1441 struct objfile
*objf
;
1443 /* Read the descriptor from remote memory. */
1444 if (!jit_read_descriptor (gdbarch
, &descriptor
,
1445 get_jit_program_space_data ()))
1447 entry_addr
= descriptor
.relevant_entry
;
1449 /* Do the corresponding action. */
1450 switch (descriptor
.action_flag
)
1455 jit_read_code_entry (gdbarch
, entry_addr
, &code_entry
);
1456 jit_register_code (gdbarch
, entry_addr
, &code_entry
);
1458 case JIT_UNREGISTER
:
1459 objf
= jit_find_objf_with_entry_addr (entry_addr
);
1461 printf_unfiltered (_("Unable to find JITed code "
1462 "entry at address: %s\n"),
1463 paddress (gdbarch
, entry_addr
));
1465 jit_unregister_code (objf
);
1469 error (_("Unknown action_flag value in JIT descriptor!"));
1474 /* Called to free the data allocated to the jit_program_space_data slot. */
1477 free_objfile_data (struct objfile
*objfile
, void *data
)
1479 struct jit_objfile_data
*objf_data
= (struct jit_objfile_data
*) data
;
1481 if (objf_data
->register_code
!= NULL
)
1483 struct jit_program_space_data
*ps_data
;
1486 = ((struct jit_program_space_data
*)
1487 program_space_data (objfile
->pspace
, jit_program_space_data
));
1488 if (ps_data
!= NULL
&& ps_data
->objfile
== objfile
)
1490 ps_data
->objfile
= NULL
;
1491 delete_breakpoint (ps_data
->jit_breakpoint
);
1492 ps_data
->cached_code_address
= 0;
1499 /* Initialize the jit_gdbarch_data slot with an instance of struct
1500 jit_gdbarch_data_type */
1503 jit_gdbarch_data_init (struct obstack
*obstack
)
1505 struct jit_gdbarch_data_type
*data
=
1506 XOBNEW (obstack
, struct jit_gdbarch_data_type
);
1508 data
->unwinder_registered
= 0;
1513 /* Provide a prototype to silence -Wmissing-prototypes. */
1515 extern void _initialize_jit (void);
1518 _initialize_jit (void)
1520 jit_reader_dir
= relocate_gdb_directory (JIT_READER_DIR
,
1521 JIT_READER_DIR_RELOCATABLE
);
1522 add_setshow_zuinteger_cmd ("jit", class_maintenance
, &jit_debug
,
1523 _("Set JIT debugging."),
1524 _("Show JIT debugging."),
1525 _("When non-zero, JIT debugging is enabled."),
1528 &setdebuglist
, &showdebuglist
);
1530 observer_attach_inferior_created (jit_inferior_created
);
1531 observer_attach_inferior_exit (jit_inferior_exit_hook
);
1532 observer_attach_breakpoint_deleted (jit_breakpoint_deleted
);
1535 register_objfile_data_with_cleanup (NULL
, free_objfile_data
);
1536 jit_program_space_data
=
1537 register_program_space_data_with_cleanup (NULL
,
1538 jit_program_space_data_cleanup
);
1539 jit_gdbarch_data
= gdbarch_data_register_pre_init (jit_gdbarch_data_init
);
1540 if (is_dl_available ())
1542 struct cmd_list_element
*c
;
1544 c
= add_com ("jit-reader-load", no_class
, jit_reader_load_command
, _("\
1545 Load FILE as debug info reader and unwinder for JIT compiled code.\n\
1546 Usage: jit-reader-load FILE\n\
1547 Try to load file FILE as a debug info reader (and unwinder) for\n\
1548 JIT compiled code. The file is loaded from " JIT_READER_DIR
",\n\
1549 relocated relative to the GDB executable if required."));
1550 set_cmd_completer (c
, filename_completer
);
1552 c
= add_com ("jit-reader-unload", no_class
,
1553 jit_reader_unload_command
, _("\
1554 Unload the currently loaded JIT debug info reader.\n\
1555 Usage: jit-reader-unload\n\n\
1556 Do \"help jit-reader-load\" for info on loading debug info readers."));
1557 set_cmd_completer (c
, noop_completer
);