1 /* Handle JIT code generation in the inferior for GDB, the GNU Debugger.
3 Copyright (C) 2009-2015 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
23 #include "jit-reader.h"
25 #include "breakpoint.h"
27 #include "dictionary.h"
28 #include "filenames.h"
29 #include "frame-unwind.h"
39 #include "gdb-dlfcn.h"
43 static const char *jit_reader_dir
= NULL
;
45 static const struct objfile_data
*jit_objfile_data
;
47 static const char *const jit_break_name
= "__jit_debug_register_code";
49 static const char *const jit_descriptor_name
= "__jit_debug_descriptor";
51 static const struct program_space_data
*jit_program_space_data
= NULL
;
53 static void jit_inferior_init (struct gdbarch
*gdbarch
);
55 /* An unwinder is registered for every gdbarch. This key is used to
56 remember if the unwinder has been registered for a particular
59 static struct gdbarch_data
*jit_gdbarch_data
;
61 /* Non-zero if we want to see trace of jit level stuff. */
63 static unsigned int jit_debug
= 0;
66 show_jit_debug (struct ui_file
*file
, int from_tty
,
67 struct cmd_list_element
*c
, const char *value
)
69 fprintf_filtered (file
, _("JIT debugging is %s.\n"), value
);
78 /* Openning the file is a no-op. */
81 mem_bfd_iovec_open (struct bfd
*abfd
, void *open_closure
)
86 /* Closing the file is just freeing the base/size pair on our side. */
89 mem_bfd_iovec_close (struct bfd
*abfd
, void *stream
)
93 /* Zero means success. */
97 /* For reading the file, we just need to pass through to target_read_memory and
98 fix up the arguments and return values. */
101 mem_bfd_iovec_pread (struct bfd
*abfd
, void *stream
, void *buf
,
102 file_ptr nbytes
, file_ptr offset
)
105 struct target_buffer
*buffer
= (struct target_buffer
*) stream
;
107 /* If this read will read all of the file, limit it to just the rest. */
108 if (offset
+ nbytes
> buffer
->size
)
109 nbytes
= buffer
->size
- offset
;
111 /* If there are no more bytes left, we've reached EOF. */
115 err
= target_read_memory (buffer
->base
+ offset
, (gdb_byte
*) buf
, nbytes
);
122 /* For statting the file, we only support the st_size attribute. */
125 mem_bfd_iovec_stat (struct bfd
*abfd
, void *stream
, struct stat
*sb
)
127 struct target_buffer
*buffer
= (struct target_buffer
*) stream
;
129 sb
->st_size
= buffer
->size
;
133 /* Open a BFD from the target's memory. */
136 bfd_open_from_target_memory (CORE_ADDR addr
, ULONGEST size
, char *target
)
138 struct target_buffer
*buffer
= xmalloc (sizeof (struct target_buffer
));
142 return gdb_bfd_openr_iovec ("<in-memory>", target
,
150 /* One reader that has been loaded successfully, and can potentially be used to
153 static struct jit_reader
155 struct gdb_reader_funcs
*functions
;
157 } *loaded_jit_reader
= NULL
;
159 typedef struct gdb_reader_funcs
* (reader_init_fn_type
) (void);
160 static const char *reader_init_fn_sym
= "gdb_init_reader";
162 /* Try to load FILE_NAME as a JIT debug info reader. */
164 static struct jit_reader
*
165 jit_reader_load (const char *file_name
)
168 reader_init_fn_type
*init_fn
;
169 struct jit_reader
*new_reader
= NULL
;
170 struct gdb_reader_funcs
*funcs
= NULL
;
171 struct cleanup
*old_cleanups
;
174 fprintf_unfiltered (gdb_stdlog
, _("Opening shared object %s.\n"),
176 so
= gdb_dlopen (file_name
);
177 old_cleanups
= make_cleanup_dlclose (so
);
179 init_fn
= gdb_dlsym (so
, reader_init_fn_sym
);
181 error (_("Could not locate initialization function: %s."),
184 if (gdb_dlsym (so
, "plugin_is_GPL_compatible") == NULL
)
185 error (_("Reader not GPL compatible."));
188 if (funcs
->reader_version
!= GDB_READER_INTERFACE_VERSION
)
189 error (_("Reader version does not match GDB version."));
191 new_reader
= XCNEW (struct jit_reader
);
192 new_reader
->functions
= funcs
;
193 new_reader
->handle
= so
;
195 discard_cleanups (old_cleanups
);
199 /* Provides the jit-reader-load command. */
202 jit_reader_load_command (char *args
, int from_tty
)
205 struct cleanup
*prev_cleanup
;
208 error (_("No reader name provided."));
210 if (loaded_jit_reader
!= NULL
)
211 error (_("JIT reader already loaded. Run jit-reader-unload first."));
213 if (IS_ABSOLUTE_PATH (args
))
214 so_name
= xstrdup (args
);
216 so_name
= xstrprintf ("%s%s%s", jit_reader_dir
, SLASH_STRING
, args
);
217 prev_cleanup
= make_cleanup (xfree
, so_name
);
219 loaded_jit_reader
= jit_reader_load (so_name
);
220 do_cleanups (prev_cleanup
);
223 /* Provides the jit-reader-unload command. */
226 jit_reader_unload_command (char *args
, int from_tty
)
228 if (!loaded_jit_reader
)
229 error (_("No JIT reader loaded."));
231 loaded_jit_reader
->functions
->destroy (loaded_jit_reader
->functions
);
233 gdb_dlclose (loaded_jit_reader
->handle
);
234 xfree (loaded_jit_reader
);
235 loaded_jit_reader
= NULL
;
238 /* Per-program space structure recording which objfile has the JIT
241 struct jit_program_space_data
243 /* The objfile. This is NULL if no objfile holds the JIT
246 struct objfile
*objfile
;
248 /* If this program space has __jit_debug_register_code, this is the
249 cached address from the minimal symbol. This is used to detect
250 relocations requiring the breakpoint to be re-created. */
252 CORE_ADDR cached_code_address
;
254 /* This is the JIT event breakpoint, or NULL if it has not been
257 struct breakpoint
*jit_breakpoint
;
260 /* Per-objfile structure recording the addresses in the program space.
261 This object serves two purposes: for ordinary objfiles, it may
262 cache some symbols related to the JIT interface; and for
263 JIT-created objfiles, it holds some information about the
266 struct jit_objfile_data
268 /* Symbol for __jit_debug_register_code. */
269 struct minimal_symbol
*register_code
;
271 /* Symbol for __jit_debug_descriptor. */
272 struct minimal_symbol
*descriptor
;
274 /* Address of struct jit_code_entry in this objfile. This is only
275 non-zero for objfiles that represent code created by the JIT. */
279 /* Fetch the jit_objfile_data associated with OBJF. If no data exists
280 yet, make a new structure and attach it. */
282 static struct jit_objfile_data
*
283 get_jit_objfile_data (struct objfile
*objf
)
285 struct jit_objfile_data
*objf_data
;
287 objf_data
= objfile_data (objf
, jit_objfile_data
);
288 if (objf_data
== NULL
)
290 objf_data
= XCNEW (struct jit_objfile_data
);
291 set_objfile_data (objf
, jit_objfile_data
, objf_data
);
297 /* Remember OBJFILE has been created for struct jit_code_entry located
298 at inferior address ENTRY. */
301 add_objfile_entry (struct objfile
*objfile
, CORE_ADDR entry
)
303 struct jit_objfile_data
*objf_data
;
305 objf_data
= get_jit_objfile_data (objfile
);
306 objf_data
->addr
= entry
;
309 /* Return jit_program_space_data for current program space. Allocate
310 if not already present. */
312 static struct jit_program_space_data
*
313 get_jit_program_space_data (void)
315 struct jit_program_space_data
*ps_data
;
317 ps_data
= program_space_data (current_program_space
, jit_program_space_data
);
320 ps_data
= XCNEW (struct jit_program_space_data
);
321 set_program_space_data (current_program_space
, jit_program_space_data
,
329 jit_program_space_data_cleanup (struct program_space
*ps
, void *arg
)
334 /* Helper function for reading the global JIT descriptor from remote
335 memory. Returns 1 if all went well, 0 otherwise. */
338 jit_read_descriptor (struct gdbarch
*gdbarch
,
339 struct jit_descriptor
*descriptor
,
340 struct jit_program_space_data
*ps_data
)
343 struct type
*ptr_type
;
347 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
348 struct jit_objfile_data
*objf_data
;
350 if (ps_data
->objfile
== NULL
)
352 objf_data
= get_jit_objfile_data (ps_data
->objfile
);
353 if (objf_data
->descriptor
== NULL
)
357 fprintf_unfiltered (gdb_stdlog
,
358 "jit_read_descriptor, descriptor_addr = %s\n",
359 paddress (gdbarch
, MSYMBOL_VALUE_ADDRESS (ps_data
->objfile
,
360 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 (ps_data
->objfile
,
370 objf_data
->descriptor
),
371 desc_buf
, desc_size
);
374 printf_unfiltered (_("Unable to read JIT descriptor from "
379 /* Fix the endianness to match the host. */
380 descriptor
->version
= extract_unsigned_integer (&desc_buf
[0], 4, byte_order
);
381 descriptor
->action_flag
=
382 extract_unsigned_integer (&desc_buf
[4], 4, byte_order
);
383 descriptor
->relevant_entry
= extract_typed_address (&desc_buf
[8], ptr_type
);
384 descriptor
->first_entry
=
385 extract_typed_address (&desc_buf
[8 + ptr_size
], ptr_type
);
390 /* Helper function for reading a JITed code entry from remote memory. */
393 jit_read_code_entry (struct gdbarch
*gdbarch
,
394 CORE_ADDR code_addr
, struct jit_code_entry
*code_entry
)
397 struct type
*ptr_type
;
402 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
404 /* Figure out how big the entry is on the remote and how to read it. */
405 ptr_type
= builtin_type (gdbarch
)->builtin_data_ptr
;
406 ptr_size
= TYPE_LENGTH (ptr_type
);
408 /* Figure out where the longlong value will be. */
409 align_bytes
= gdbarch_long_long_align_bit (gdbarch
) / 8;
411 off
= (off
+ (align_bytes
- 1)) & ~(align_bytes
- 1);
413 entry_size
= off
+ 8; /* Three pointers and one 64-bit int. */
414 entry_buf
= alloca (entry_size
);
416 /* Read the entry. */
417 err
= target_read_memory (code_addr
, entry_buf
, entry_size
);
419 error (_("Unable to read JIT code entry from remote memory!"));
421 /* Fix the endianness to match the host. */
422 ptr_type
= builtin_type (gdbarch
)->builtin_data_ptr
;
423 code_entry
->next_entry
= extract_typed_address (&entry_buf
[0], ptr_type
);
424 code_entry
->prev_entry
=
425 extract_typed_address (&entry_buf
[ptr_size
], ptr_type
);
426 code_entry
->symfile_addr
=
427 extract_typed_address (&entry_buf
[2 * ptr_size
], ptr_type
);
428 code_entry
->symfile_size
=
429 extract_unsigned_integer (&entry_buf
[off
], 8, byte_order
);
432 /* Proxy object for building a block. */
436 /* gdb_blocks are linked into a tree structure. Next points to the
437 next node at the same depth as this block and parent to the
439 struct gdb_block
*next
, *parent
;
441 /* Points to the "real" block that is being built out of this
442 instance. This block will be added to a blockvector, which will
443 then be added to a symtab. */
444 struct block
*real_block
;
446 /* The first and last code address corresponding to this block. */
447 CORE_ADDR begin
, end
;
449 /* The name of this block (if any). If this is non-NULL, the
450 FUNCTION symbol symbol is set to this value. */
454 /* Proxy object for building a symtab. */
458 /* The list of blocks in this symtab. These will eventually be
459 converted to real blocks. */
460 struct gdb_block
*blocks
;
462 /* The number of blocks inserted. */
465 /* A mapping between line numbers to PC. */
466 struct linetable
*linetable
;
468 /* The source file for this symtab. */
469 const char *file_name
;
470 struct gdb_symtab
*next
;
473 /* Proxy object for building an object. */
477 struct gdb_symtab
*symtabs
;
480 /* The type of the `private' data passed around by the callback
483 typedef CORE_ADDR jit_dbg_reader_data
;
485 /* The reader calls into this function to read data off the targets
488 static enum gdb_status
489 jit_target_read_impl (GDB_CORE_ADDR target_mem
, void *gdb_buf
, int len
)
491 int result
= target_read_memory ((CORE_ADDR
) target_mem
, gdb_buf
, len
);
498 /* The reader calls into this function to create a new gdb_object
499 which it can then pass around to the other callbacks. Right now,
500 all that is required is allocating the memory. */
502 static struct gdb_object
*
503 jit_object_open_impl (struct gdb_symbol_callbacks
*cb
)
505 /* CB is not required right now, but sometime in the future we might
506 need a handle to it, and we'd like to do that without breaking
508 return XCNEW (struct gdb_object
);
511 /* Readers call into this function to open a new gdb_symtab, which,
512 again, is passed around to other callbacks. */
514 static struct gdb_symtab
*
515 jit_symtab_open_impl (struct gdb_symbol_callbacks
*cb
,
516 struct gdb_object
*object
,
517 const char *file_name
)
519 struct gdb_symtab
*ret
;
521 /* CB stays unused. See comment in jit_object_open_impl. */
523 ret
= XCNEW (struct gdb_symtab
);
524 ret
->file_name
= file_name
? xstrdup (file_name
) : xstrdup ("");
525 ret
->next
= object
->symtabs
;
526 object
->symtabs
= ret
;
530 /* Returns true if the block corresponding to old should be placed
531 before the block corresponding to new in the final blockvector. */
534 compare_block (const struct gdb_block
*const old
,
535 const struct gdb_block
*const newobj
)
539 if (old
->begin
< newobj
->begin
)
541 else if (old
->begin
== newobj
->begin
)
543 if (old
->end
> newobj
->end
)
552 /* Called by readers to open a new gdb_block. This function also
553 inserts the new gdb_block in the correct place in the corresponding
556 static struct gdb_block
*
557 jit_block_open_impl (struct gdb_symbol_callbacks
*cb
,
558 struct gdb_symtab
*symtab
, struct gdb_block
*parent
,
559 GDB_CORE_ADDR begin
, GDB_CORE_ADDR end
, const char *name
)
561 struct gdb_block
*block
= XCNEW (struct gdb_block
);
563 block
->next
= symtab
->blocks
;
564 block
->begin
= (CORE_ADDR
) begin
;
565 block
->end
= (CORE_ADDR
) end
;
566 block
->name
= name
? xstrdup (name
) : NULL
;
567 block
->parent
= parent
;
569 /* Ensure that the blocks are inserted in the correct (reverse of
570 the order expected by blockvector). */
571 if (compare_block (symtab
->blocks
, block
))
573 symtab
->blocks
= block
;
577 struct gdb_block
*i
= symtab
->blocks
;
581 /* Guaranteed to terminate, since compare_block (NULL, _)
583 if (compare_block (i
->next
, block
))
585 block
->next
= i
->next
;
596 /* Readers call this to add a line mapping (from PC to line number) to
600 jit_symtab_line_mapping_add_impl (struct gdb_symbol_callbacks
*cb
,
601 struct gdb_symtab
*stab
, int nlines
,
602 struct gdb_line_mapping
*map
)
609 stab
->linetable
= xmalloc (sizeof (struct linetable
)
610 + (nlines
- 1) * sizeof (struct linetable_entry
));
611 stab
->linetable
->nitems
= nlines
;
612 for (i
= 0; i
< nlines
; i
++)
614 stab
->linetable
->item
[i
].pc
= (CORE_ADDR
) map
[i
].pc
;
615 stab
->linetable
->item
[i
].line
= map
[i
].line
;
619 /* Called by readers to close a gdb_symtab. Does not need to do
620 anything as of now. */
623 jit_symtab_close_impl (struct gdb_symbol_callbacks
*cb
,
624 struct gdb_symtab
*stab
)
626 /* Right now nothing needs to be done here. We may need to do some
627 cleanup here in the future (again, without breaking the plugin
631 /* Transform STAB to a proper symtab, and add it it OBJFILE. */
634 finalize_symtab (struct gdb_symtab
*stab
, struct objfile
*objfile
)
636 struct compunit_symtab
*cust
;
637 struct gdb_block
*gdb_block_iter
, *gdb_block_iter_tmp
;
638 struct block
*block_iter
;
639 int actual_nblocks
, i
;
640 size_t blockvector_size
;
641 CORE_ADDR begin
, end
;
642 struct blockvector
*bv
;
644 actual_nblocks
= FIRST_LOCAL_BLOCK
+ stab
->nblocks
;
646 cust
= allocate_compunit_symtab (objfile
, stab
->file_name
);
647 allocate_symtab (cust
, stab
->file_name
);
648 add_compunit_symtab_to_objfile (cust
);
650 /* JIT compilers compile in memory. */
651 COMPUNIT_DIRNAME (cust
) = NULL
;
653 /* Copy over the linetable entry if one was provided. */
656 size_t size
= ((stab
->linetable
->nitems
- 1)
657 * sizeof (struct linetable_entry
)
658 + sizeof (struct linetable
));
659 SYMTAB_LINETABLE (COMPUNIT_FILETABS (cust
))
660 = obstack_alloc (&objfile
->objfile_obstack
, size
);
661 memcpy (SYMTAB_LINETABLE (COMPUNIT_FILETABS (cust
)), stab
->linetable
,
665 blockvector_size
= (sizeof (struct blockvector
)
666 + (actual_nblocks
- 1) * sizeof (struct block
*));
667 bv
= obstack_alloc (&objfile
->objfile_obstack
, blockvector_size
);
668 COMPUNIT_BLOCKVECTOR (cust
) = bv
;
670 /* (begin, end) will contain the PC range this entire blockvector
672 BLOCKVECTOR_MAP (bv
) = NULL
;
673 begin
= stab
->blocks
->begin
;
674 end
= stab
->blocks
->end
;
675 BLOCKVECTOR_NBLOCKS (bv
) = actual_nblocks
;
677 /* First run over all the gdb_block objects, creating a real block
678 object for each. Simultaneously, keep setting the real_block
680 for (i
= (actual_nblocks
- 1), gdb_block_iter
= stab
->blocks
;
681 i
>= FIRST_LOCAL_BLOCK
;
682 i
--, gdb_block_iter
= gdb_block_iter
->next
)
684 struct block
*new_block
= allocate_block (&objfile
->objfile_obstack
);
685 struct symbol
*block_name
= allocate_symbol (objfile
);
686 struct type
*block_type
= arch_type (get_objfile_arch (objfile
),
691 BLOCK_DICT (new_block
) = dict_create_linear (&objfile
->objfile_obstack
,
693 /* The address range. */
694 BLOCK_START (new_block
) = (CORE_ADDR
) gdb_block_iter
->begin
;
695 BLOCK_END (new_block
) = (CORE_ADDR
) gdb_block_iter
->end
;
698 SYMBOL_DOMAIN (block_name
) = VAR_DOMAIN
;
699 SYMBOL_ACLASS_INDEX (block_name
) = LOC_BLOCK
;
700 symbol_set_symtab (block_name
, COMPUNIT_FILETABS (cust
));
701 SYMBOL_TYPE (block_name
) = lookup_function_type (block_type
);
702 SYMBOL_BLOCK_VALUE (block_name
) = new_block
;
704 block_name
->ginfo
.name
= obstack_copy0 (&objfile
->objfile_obstack
,
705 gdb_block_iter
->name
,
706 strlen (gdb_block_iter
->name
));
708 BLOCK_FUNCTION (new_block
) = block_name
;
710 BLOCKVECTOR_BLOCK (bv
, i
) = new_block
;
711 if (begin
> BLOCK_START (new_block
))
712 begin
= BLOCK_START (new_block
);
713 if (end
< BLOCK_END (new_block
))
714 end
= BLOCK_END (new_block
);
716 gdb_block_iter
->real_block
= new_block
;
719 /* Now add the special blocks. */
721 for (i
= 0; i
< FIRST_LOCAL_BLOCK
; i
++)
723 struct block
*new_block
;
725 new_block
= (i
== GLOBAL_BLOCK
726 ? allocate_global_block (&objfile
->objfile_obstack
)
727 : allocate_block (&objfile
->objfile_obstack
));
728 BLOCK_DICT (new_block
) = dict_create_linear (&objfile
->objfile_obstack
,
730 BLOCK_SUPERBLOCK (new_block
) = block_iter
;
731 block_iter
= new_block
;
733 BLOCK_START (new_block
) = (CORE_ADDR
) begin
;
734 BLOCK_END (new_block
) = (CORE_ADDR
) end
;
736 BLOCKVECTOR_BLOCK (bv
, i
) = new_block
;
738 if (i
== GLOBAL_BLOCK
)
739 set_block_compunit_symtab (new_block
, cust
);
742 /* Fill up the superblock fields for the real blocks, using the
743 real_block fields populated earlier. */
744 for (gdb_block_iter
= stab
->blocks
;
746 gdb_block_iter
= gdb_block_iter
->next
)
748 if (gdb_block_iter
->parent
!= NULL
)
750 /* If the plugin specifically mentioned a parent block, we
752 BLOCK_SUPERBLOCK (gdb_block_iter
->real_block
) =
753 gdb_block_iter
->parent
->real_block
;
757 /* And if not, we set a default parent block. */
758 BLOCK_SUPERBLOCK (gdb_block_iter
->real_block
) =
759 BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
);
764 gdb_block_iter
= stab
->blocks
;
766 for (gdb_block_iter
= stab
->blocks
, gdb_block_iter_tmp
= gdb_block_iter
->next
;
768 gdb_block_iter
= gdb_block_iter_tmp
)
770 xfree ((void *) gdb_block_iter
->name
);
771 xfree (gdb_block_iter
);
773 xfree (stab
->linetable
);
774 xfree ((char *) stab
->file_name
);
778 /* Called when closing a gdb_objfile. Converts OBJ to a proper
782 jit_object_close_impl (struct gdb_symbol_callbacks
*cb
,
783 struct gdb_object
*obj
)
785 struct gdb_symtab
*i
, *j
;
786 struct objfile
*objfile
;
787 jit_dbg_reader_data
*priv_data
;
789 priv_data
= cb
->priv_data
;
791 objfile
= allocate_objfile (NULL
, "<< JIT compiled code >>",
793 objfile
->per_bfd
->gdbarch
= target_gdbarch ();
795 terminate_minimal_symbol_table (objfile
);
798 for (i
= obj
->symtabs
; i
; i
= j
)
801 finalize_symtab (i
, objfile
);
803 add_objfile_entry (objfile
, *priv_data
);
807 /* Try to read CODE_ENTRY using the loaded jit reader (if any).
808 ENTRY_ADDR is the address of the struct jit_code_entry in the
809 inferior address space. */
812 jit_reader_try_read_symtab (struct jit_code_entry
*code_entry
,
813 CORE_ADDR entry_addr
)
817 jit_dbg_reader_data priv_data
;
818 struct gdb_reader_funcs
*funcs
;
819 struct gdb_symbol_callbacks callbacks
=
821 jit_object_open_impl
,
822 jit_symtab_open_impl
,
824 jit_symtab_close_impl
,
825 jit_object_close_impl
,
827 jit_symtab_line_mapping_add_impl
,
828 jit_target_read_impl
,
833 priv_data
= entry_addr
;
835 if (!loaded_jit_reader
)
838 gdb_mem
= xmalloc (code_entry
->symfile_size
);
843 if (target_read_memory (code_entry
->symfile_addr
, gdb_mem
,
844 code_entry
->symfile_size
))
847 CATCH (e
, RETURN_MASK_ALL
)
855 funcs
= loaded_jit_reader
->functions
;
856 if (funcs
->read (funcs
, &callbacks
, gdb_mem
, code_entry
->symfile_size
)
862 if (jit_debug
&& status
== 0)
863 fprintf_unfiltered (gdb_stdlog
,
864 "Could not read symtab using the loaded JIT reader.\n");
868 /* Try to read CODE_ENTRY using BFD. ENTRY_ADDR is the address of the
869 struct jit_code_entry in the inferior address space. */
872 jit_bfd_try_read_symtab (struct jit_code_entry
*code_entry
,
873 CORE_ADDR entry_addr
,
874 struct gdbarch
*gdbarch
)
877 struct section_addr_info
*sai
;
878 struct bfd_section
*sec
;
879 struct objfile
*objfile
;
880 struct cleanup
*old_cleanups
;
882 const struct bfd_arch_info
*b
;
885 fprintf_unfiltered (gdb_stdlog
,
886 "jit_register_code, symfile_addr = %s, "
887 "symfile_size = %s\n",
888 paddress (gdbarch
, code_entry
->symfile_addr
),
889 pulongest (code_entry
->symfile_size
));
891 nbfd
= bfd_open_from_target_memory (code_entry
->symfile_addr
,
892 code_entry
->symfile_size
, gnutarget
);
895 puts_unfiltered (_("Error opening JITed symbol file, ignoring it.\n"));
899 /* Check the format. NOTE: This initializes important data that GDB uses!
900 We would segfault later without this line. */
901 if (!bfd_check_format (nbfd
, bfd_object
))
903 printf_unfiltered (_("\
904 JITed symbol file is not an object file, ignoring it.\n"));
905 gdb_bfd_unref (nbfd
);
909 /* Check bfd arch. */
910 b
= gdbarch_bfd_arch_info (gdbarch
);
911 if (b
->compatible (b
, bfd_get_arch_info (nbfd
)) != b
)
912 warning (_("JITed object file architecture %s is not compatible "
913 "with target architecture %s."), bfd_get_arch_info
914 (nbfd
)->printable_name
, b
->printable_name
);
916 /* Read the section address information out of the symbol file. Since the
917 file is generated by the JIT at runtime, it should all of the absolute
918 addresses that we care about. */
919 sai
= alloc_section_addr_info (bfd_count_sections (nbfd
));
920 old_cleanups
= make_cleanup_free_section_addr_info (sai
);
922 for (sec
= nbfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
923 if ((bfd_get_section_flags (nbfd
, sec
) & (SEC_ALLOC
|SEC_LOAD
)) != 0)
925 /* We assume that these virtual addresses are absolute, and do not
926 treat them as offsets. */
927 sai
->other
[i
].addr
= bfd_get_section_vma (nbfd
, sec
);
928 sai
->other
[i
].name
= xstrdup (bfd_get_section_name (nbfd
, sec
));
929 sai
->other
[i
].sectindex
= sec
->index
;
932 sai
->num_sections
= i
;
934 /* This call does not take ownership of SAI. */
935 make_cleanup_bfd_unref (nbfd
);
936 objfile
= symbol_file_add_from_bfd (nbfd
, bfd_get_filename (nbfd
), 0, sai
,
937 OBJF_SHARED
| OBJF_NOT_FILENAME
, NULL
);
939 do_cleanups (old_cleanups
);
940 add_objfile_entry (objfile
, entry_addr
);
943 /* This function registers code associated with a JIT code entry. It uses the
944 pointer and size pair in the entry to read the symbol file from the remote
945 and then calls symbol_file_add_from_local_memory to add it as though it were
946 a symbol file added by the user. */
949 jit_register_code (struct gdbarch
*gdbarch
,
950 CORE_ADDR entry_addr
, struct jit_code_entry
*code_entry
)
955 fprintf_unfiltered (gdb_stdlog
,
956 "jit_register_code, symfile_addr = %s, "
957 "symfile_size = %s\n",
958 paddress (gdbarch
, code_entry
->symfile_addr
),
959 pulongest (code_entry
->symfile_size
));
961 success
= jit_reader_try_read_symtab (code_entry
, entry_addr
);
964 jit_bfd_try_read_symtab (code_entry
, entry_addr
, gdbarch
);
967 /* This function unregisters JITed code and frees the corresponding
971 jit_unregister_code (struct objfile
*objfile
)
973 free_objfile (objfile
);
976 /* Look up the objfile with this code entry address. */
978 static struct objfile
*
979 jit_find_objf_with_entry_addr (CORE_ADDR entry_addr
)
981 struct objfile
*objf
;
985 struct jit_objfile_data
*objf_data
;
987 objf_data
= objfile_data (objf
, jit_objfile_data
);
988 if (objf_data
!= NULL
&& objf_data
->addr
== entry_addr
)
994 /* This is called when a breakpoint is deleted. It updates the
995 inferior's cache, if needed. */
998 jit_breakpoint_deleted (struct breakpoint
*b
)
1000 struct bp_location
*iter
;
1002 if (b
->type
!= bp_jit_event
)
1005 for (iter
= b
->loc
; iter
!= NULL
; iter
= iter
->next
)
1007 struct jit_program_space_data
*ps_data
;
1009 ps_data
= program_space_data (iter
->pspace
, jit_program_space_data
);
1010 if (ps_data
!= NULL
&& ps_data
->jit_breakpoint
== iter
->owner
)
1012 ps_data
->cached_code_address
= 0;
1013 ps_data
->jit_breakpoint
= NULL
;
1018 /* (Re-)Initialize the jit breakpoint if necessary.
1019 Return 0 on success. */
1022 jit_breakpoint_re_set_internal (struct gdbarch
*gdbarch
,
1023 struct jit_program_space_data
*ps_data
)
1025 struct bound_minimal_symbol reg_symbol
;
1026 struct bound_minimal_symbol desc_symbol
;
1027 struct jit_objfile_data
*objf_data
;
1030 if (ps_data
->objfile
== NULL
)
1032 /* Lookup the registration symbol. If it is missing, then we
1033 assume we are not attached to a JIT. */
1034 reg_symbol
= lookup_minimal_symbol_and_objfile (jit_break_name
);
1035 if (reg_symbol
.minsym
== NULL
1036 || BMSYMBOL_VALUE_ADDRESS (reg_symbol
) == 0)
1039 desc_symbol
= lookup_minimal_symbol (jit_descriptor_name
, NULL
,
1040 reg_symbol
.objfile
);
1041 if (desc_symbol
.minsym
== NULL
1042 || BMSYMBOL_VALUE_ADDRESS (desc_symbol
) == 0)
1045 objf_data
= get_jit_objfile_data (reg_symbol
.objfile
);
1046 objf_data
->register_code
= reg_symbol
.minsym
;
1047 objf_data
->descriptor
= desc_symbol
.minsym
;
1049 ps_data
->objfile
= reg_symbol
.objfile
;
1052 objf_data
= get_jit_objfile_data (ps_data
->objfile
);
1054 addr
= MSYMBOL_VALUE_ADDRESS (ps_data
->objfile
, objf_data
->register_code
);
1057 fprintf_unfiltered (gdb_stdlog
,
1058 "jit_breakpoint_re_set_internal, "
1059 "breakpoint_addr = %s\n",
1060 paddress (gdbarch
, addr
));
1062 if (ps_data
->cached_code_address
== addr
)
1065 /* Delete the old breakpoint. */
1066 if (ps_data
->jit_breakpoint
!= NULL
)
1067 delete_breakpoint (ps_data
->jit_breakpoint
);
1069 /* Put a breakpoint in the registration symbol. */
1070 ps_data
->cached_code_address
= addr
;
1071 ps_data
->jit_breakpoint
= create_jit_event_breakpoint (gdbarch
, addr
);
1076 /* The private data passed around in the frame unwind callback
1079 struct jit_unwind_private
1081 /* Cached register values. See jit_frame_sniffer to see how this
1083 struct gdb_reg_value
**registers
;
1085 /* The frame being unwound. */
1086 struct frame_info
*this_frame
;
1089 /* Sets the value of a particular register in this frame. */
1092 jit_unwind_reg_set_impl (struct gdb_unwind_callbacks
*cb
, int dwarf_regnum
,
1093 struct gdb_reg_value
*value
)
1095 struct jit_unwind_private
*priv
;
1098 priv
= cb
->priv_data
;
1100 gdb_reg
= gdbarch_dwarf2_reg_to_regnum (get_frame_arch (priv
->this_frame
),
1105 fprintf_unfiltered (gdb_stdlog
,
1106 _("Could not recognize DWARF regnum %d"),
1111 gdb_assert (priv
->registers
);
1112 priv
->registers
[gdb_reg
] = value
;
1116 reg_value_free_impl (struct gdb_reg_value
*value
)
1121 /* Get the value of register REGNUM in the previous frame. */
1123 static struct gdb_reg_value
*
1124 jit_unwind_reg_get_impl (struct gdb_unwind_callbacks
*cb
, int regnum
)
1126 struct jit_unwind_private
*priv
;
1127 struct gdb_reg_value
*value
;
1129 struct gdbarch
*frame_arch
;
1131 priv
= cb
->priv_data
;
1132 frame_arch
= get_frame_arch (priv
->this_frame
);
1134 gdb_reg
= gdbarch_dwarf2_reg_to_regnum (frame_arch
, regnum
);
1135 size
= register_size (frame_arch
, gdb_reg
);
1136 value
= xmalloc (sizeof (struct gdb_reg_value
) + size
- 1);
1137 value
->defined
= deprecated_frame_register_read (priv
->this_frame
, gdb_reg
,
1140 value
->free
= reg_value_free_impl
;
1144 /* gdb_reg_value has a free function, which must be called on each
1145 saved register value. */
1148 jit_dealloc_cache (struct frame_info
*this_frame
, void *cache
)
1150 struct jit_unwind_private
*priv_data
= cache
;
1151 struct gdbarch
*frame_arch
;
1154 gdb_assert (priv_data
->registers
);
1155 frame_arch
= get_frame_arch (priv_data
->this_frame
);
1157 for (i
= 0; i
< gdbarch_num_regs (frame_arch
); i
++)
1158 if (priv_data
->registers
[i
] && priv_data
->registers
[i
]->free
)
1159 priv_data
->registers
[i
]->free (priv_data
->registers
[i
]);
1161 xfree (priv_data
->registers
);
1165 /* The frame sniffer for the pseudo unwinder.
1167 While this is nominally a frame sniffer, in the case where the JIT
1168 reader actually recognizes the frame, it does a lot more work -- it
1169 unwinds the frame and saves the corresponding register values in
1170 the cache. jit_frame_prev_register simply returns the saved
1174 jit_frame_sniffer (const struct frame_unwind
*self
,
1175 struct frame_info
*this_frame
, void **cache
)
1177 struct jit_unwind_private
*priv_data
;
1178 struct gdb_unwind_callbacks callbacks
;
1179 struct gdb_reader_funcs
*funcs
;
1181 callbacks
.reg_get
= jit_unwind_reg_get_impl
;
1182 callbacks
.reg_set
= jit_unwind_reg_set_impl
;
1183 callbacks
.target_read
= jit_target_read_impl
;
1185 if (loaded_jit_reader
== NULL
)
1188 funcs
= loaded_jit_reader
->functions
;
1190 gdb_assert (!*cache
);
1192 *cache
= XCNEW (struct jit_unwind_private
);
1194 priv_data
->registers
=
1195 XCNEWVEC (struct gdb_reg_value
*,
1196 gdbarch_num_regs (get_frame_arch (this_frame
)));
1197 priv_data
->this_frame
= this_frame
;
1199 callbacks
.priv_data
= priv_data
;
1201 /* Try to coax the provided unwinder to unwind the stack */
1202 if (funcs
->unwind (funcs
, &callbacks
) == GDB_SUCCESS
)
1205 fprintf_unfiltered (gdb_stdlog
, _("Successfully unwound frame using "
1210 fprintf_unfiltered (gdb_stdlog
, _("Could not unwind frame using "
1213 jit_dealloc_cache (this_frame
, *cache
);
1220 /* The frame_id function for the pseudo unwinder. Relays the call to
1221 the loaded plugin. */
1224 jit_frame_this_id (struct frame_info
*this_frame
, void **cache
,
1225 struct frame_id
*this_id
)
1227 struct jit_unwind_private priv
;
1228 struct gdb_frame_id frame_id
;
1229 struct gdb_reader_funcs
*funcs
;
1230 struct gdb_unwind_callbacks callbacks
;
1232 priv
.registers
= NULL
;
1233 priv
.this_frame
= this_frame
;
1235 /* We don't expect the frame_id function to set any registers, so we
1236 set reg_set to NULL. */
1237 callbacks
.reg_get
= jit_unwind_reg_get_impl
;
1238 callbacks
.reg_set
= NULL
;
1239 callbacks
.target_read
= jit_target_read_impl
;
1240 callbacks
.priv_data
= &priv
;
1242 gdb_assert (loaded_jit_reader
);
1243 funcs
= loaded_jit_reader
->functions
;
1245 frame_id
= funcs
->get_frame_id (funcs
, &callbacks
);
1246 *this_id
= frame_id_build (frame_id
.stack_address
, frame_id
.code_address
);
1249 /* Pseudo unwinder function. Reads the previously fetched value for
1250 the register from the cache. */
1252 static struct value
*
1253 jit_frame_prev_register (struct frame_info
*this_frame
, void **cache
, int reg
)
1255 struct jit_unwind_private
*priv
= *cache
;
1256 struct gdb_reg_value
*value
;
1259 return frame_unwind_got_optimized (this_frame
, reg
);
1261 gdb_assert (priv
->registers
);
1262 value
= priv
->registers
[reg
];
1263 if (value
&& value
->defined
)
1264 return frame_unwind_got_bytes (this_frame
, reg
, value
->value
);
1266 return frame_unwind_got_optimized (this_frame
, reg
);
1269 /* Relay everything back to the unwinder registered by the JIT debug
1272 static const struct frame_unwind jit_frame_unwind
=
1275 default_frame_unwind_stop_reason
,
1277 jit_frame_prev_register
,
1284 /* This is the information that is stored at jit_gdbarch_data for each
1287 struct jit_gdbarch_data_type
1289 /* Has the (pseudo) unwinder been prepended? */
1290 int unwinder_registered
;
1293 /* Check GDBARCH and prepend the pseudo JIT unwinder if needed. */
1296 jit_prepend_unwinder (struct gdbarch
*gdbarch
)
1298 struct jit_gdbarch_data_type
*data
;
1300 data
= gdbarch_data (gdbarch
, jit_gdbarch_data
);
1301 if (!data
->unwinder_registered
)
1303 frame_unwind_prepend_unwinder (gdbarch
, &jit_frame_unwind
);
1304 data
->unwinder_registered
= 1;
1308 /* Register any already created translations. */
1311 jit_inferior_init (struct gdbarch
*gdbarch
)
1313 struct jit_descriptor descriptor
;
1314 struct jit_code_entry cur_entry
;
1315 struct jit_program_space_data
*ps_data
;
1316 CORE_ADDR cur_entry_addr
;
1319 fprintf_unfiltered (gdb_stdlog
, "jit_inferior_init\n");
1321 jit_prepend_unwinder (gdbarch
);
1323 ps_data
= get_jit_program_space_data ();
1324 if (jit_breakpoint_re_set_internal (gdbarch
, ps_data
) != 0)
1327 /* Read the descriptor so we can check the version number and load
1328 any already JITed functions. */
1329 if (!jit_read_descriptor (gdbarch
, &descriptor
, ps_data
))
1332 /* Check that the version number agrees with that we support. */
1333 if (descriptor
.version
!= 1)
1335 printf_unfiltered (_("Unsupported JIT protocol version %ld "
1336 "in descriptor (expected 1)\n"),
1337 (long) descriptor
.version
);
1341 /* If we've attached to a running program, we need to check the descriptor
1342 to register any functions that were already generated. */
1343 for (cur_entry_addr
= descriptor
.first_entry
;
1344 cur_entry_addr
!= 0;
1345 cur_entry_addr
= cur_entry
.next_entry
)
1347 jit_read_code_entry (gdbarch
, cur_entry_addr
, &cur_entry
);
1349 /* This hook may be called many times during setup, so make sure we don't
1350 add the same symbol file twice. */
1351 if (jit_find_objf_with_entry_addr (cur_entry_addr
) != NULL
)
1354 jit_register_code (gdbarch
, cur_entry_addr
, &cur_entry
);
1358 /* Exported routine to call when an inferior has been created. */
1361 jit_inferior_created_hook (void)
1363 jit_inferior_init (target_gdbarch ());
1366 /* Exported routine to call to re-set the jit breakpoints,
1367 e.g. when a program is rerun. */
1370 jit_breakpoint_re_set (void)
1372 jit_breakpoint_re_set_internal (target_gdbarch (),
1373 get_jit_program_space_data ());
1376 /* This function cleans up any code entries left over when the
1377 inferior exits. We get left over code when the inferior exits
1378 without unregistering its code, for example when it crashes. */
1381 jit_inferior_exit_hook (struct inferior
*inf
)
1383 struct objfile
*objf
;
1384 struct objfile
*temp
;
1386 ALL_OBJFILES_SAFE (objf
, temp
)
1388 struct jit_objfile_data
*objf_data
= objfile_data (objf
,
1391 if (objf_data
!= NULL
&& objf_data
->addr
!= 0)
1392 jit_unregister_code (objf
);
1397 jit_event_handler (struct gdbarch
*gdbarch
)
1399 struct jit_descriptor descriptor
;
1400 struct jit_code_entry code_entry
;
1401 CORE_ADDR entry_addr
;
1402 struct objfile
*objf
;
1404 /* Read the descriptor from remote memory. */
1405 if (!jit_read_descriptor (gdbarch
, &descriptor
,
1406 get_jit_program_space_data ()))
1408 entry_addr
= descriptor
.relevant_entry
;
1410 /* Do the corresponding action. */
1411 switch (descriptor
.action_flag
)
1416 jit_read_code_entry (gdbarch
, entry_addr
, &code_entry
);
1417 jit_register_code (gdbarch
, entry_addr
, &code_entry
);
1419 case JIT_UNREGISTER
:
1420 objf
= jit_find_objf_with_entry_addr (entry_addr
);
1422 printf_unfiltered (_("Unable to find JITed code "
1423 "entry at address: %s\n"),
1424 paddress (gdbarch
, entry_addr
));
1426 jit_unregister_code (objf
);
1430 error (_("Unknown action_flag value in JIT descriptor!"));
1435 /* Called to free the data allocated to the jit_program_space_data slot. */
1438 free_objfile_data (struct objfile
*objfile
, void *data
)
1440 struct jit_objfile_data
*objf_data
= data
;
1442 if (objf_data
->register_code
!= NULL
)
1444 struct jit_program_space_data
*ps_data
;
1446 ps_data
= program_space_data (objfile
->pspace
, jit_program_space_data
);
1447 if (ps_data
!= NULL
&& ps_data
->objfile
== objfile
)
1448 ps_data
->objfile
= NULL
;
1454 /* Initialize the jit_gdbarch_data slot with an instance of struct
1455 jit_gdbarch_data_type */
1458 jit_gdbarch_data_init (struct obstack
*obstack
)
1460 struct jit_gdbarch_data_type
*data
;
1462 data
= obstack_alloc (obstack
, sizeof (struct jit_gdbarch_data_type
));
1463 data
->unwinder_registered
= 0;
1467 /* Provide a prototype to silence -Wmissing-prototypes. */
1469 extern void _initialize_jit (void);
1472 _initialize_jit (void)
1474 jit_reader_dir
= relocate_gdb_directory (JIT_READER_DIR
,
1475 JIT_READER_DIR_RELOCATABLE
);
1476 add_setshow_zuinteger_cmd ("jit", class_maintenance
, &jit_debug
,
1477 _("Set JIT debugging."),
1478 _("Show JIT debugging."),
1479 _("When non-zero, JIT debugging is enabled."),
1482 &setdebuglist
, &showdebuglist
);
1484 observer_attach_inferior_exit (jit_inferior_exit_hook
);
1485 observer_attach_breakpoint_deleted (jit_breakpoint_deleted
);
1488 register_objfile_data_with_cleanup (NULL
, free_objfile_data
);
1489 jit_program_space_data
=
1490 register_program_space_data_with_cleanup (NULL
,
1491 jit_program_space_data_cleanup
);
1492 jit_gdbarch_data
= gdbarch_data_register_pre_init (jit_gdbarch_data_init
);
1493 if (is_dl_available ())
1495 add_com ("jit-reader-load", no_class
, jit_reader_load_command
, _("\
1496 Load FILE as debug info reader and unwinder for JIT compiled code.\n\
1497 Usage: jit-reader-load FILE\n\
1498 Try to load file FILE as a debug info reader (and unwinder) for\n\
1499 JIT compiled code. The file is loaded from " JIT_READER_DIR
",\n\
1500 relocated relative to the GDB executable if required."));
1501 add_com ("jit-reader-unload", no_class
, jit_reader_unload_command
, _("\
1502 Unload the currently loaded JIT debug info reader.\n\
1503 Usage: jit-reader-unload FILE\n\n\
1504 Do \"help jit-reader-load\" for info on loading debug info readers."));