1 /* Handle JIT code generation in the inferior for GDB, the GNU Debugger.
3 Copyright (C) 2009-2012 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 "frame-unwind.h"
38 #include "gdb-dlfcn.h"
40 #include "exceptions.h"
42 static const char *jit_reader_dir
= NULL
;
44 static const struct objfile_data
*jit_objfile_data
;
46 static const char *const jit_break_name
= "__jit_debug_register_code";
48 static const char *const jit_descriptor_name
= "__jit_debug_descriptor";
50 static const struct inferior_data
*jit_inferior_data
= NULL
;
52 static void jit_inferior_init (struct gdbarch
*gdbarch
);
54 /* An unwinder is registered for every gdbarch. This key is used to
55 remember if the unwinder has been registered for a particular
58 static struct gdbarch_data
*jit_gdbarch_data
;
60 /* Non-zero if we want to see trace of jit level stuff. */
62 static int jit_debug
= 0;
65 show_jit_debug (struct ui_file
*file
, int from_tty
,
66 struct cmd_list_element
*c
, const char *value
)
68 fprintf_filtered (file
, _("JIT debugging is %s.\n"), value
);
77 /* Openning the file is a no-op. */
80 mem_bfd_iovec_open (struct bfd
*abfd
, void *open_closure
)
85 /* Closing the file is just freeing the base/size pair on our side. */
88 mem_bfd_iovec_close (struct bfd
*abfd
, void *stream
)
94 /* For reading the file, we just need to pass through to target_read_memory and
95 fix up the arguments and return values. */
98 mem_bfd_iovec_pread (struct bfd
*abfd
, void *stream
, void *buf
,
99 file_ptr nbytes
, file_ptr offset
)
102 struct target_buffer
*buffer
= (struct target_buffer
*) stream
;
104 /* If this read will read all of the file, limit it to just the rest. */
105 if (offset
+ nbytes
> buffer
->size
)
106 nbytes
= buffer
->size
- offset
;
108 /* If there are no more bytes left, we've reached EOF. */
112 err
= target_read_memory (buffer
->base
+ offset
, (gdb_byte
*) buf
, nbytes
);
119 /* For statting the file, we only support the st_size attribute. */
122 mem_bfd_iovec_stat (struct bfd
*abfd
, void *stream
, struct stat
*sb
)
124 struct target_buffer
*buffer
= (struct target_buffer
*) stream
;
126 sb
->st_size
= buffer
->size
;
130 /* Open a BFD from the target's memory. */
133 bfd_open_from_target_memory (CORE_ADDR addr
, ULONGEST size
, char *target
)
135 const char *filename
= xstrdup ("<in-memory>");
136 struct target_buffer
*buffer
= xmalloc (sizeof (struct target_buffer
));
140 return bfd_openr_iovec (filename
, target
,
148 /* One reader that has been loaded successfully, and can potentially be used to
151 static struct jit_reader
153 struct gdb_reader_funcs
*functions
;
155 } *loaded_jit_reader
= NULL
;
157 typedef struct gdb_reader_funcs
* (reader_init_fn_type
) (void);
158 static const char *reader_init_fn_sym
= "gdb_init_reader";
160 /* Try to load FILE_NAME as a JIT debug info reader. */
162 static struct jit_reader
*
163 jit_reader_load (const char *file_name
)
166 reader_init_fn_type
*init_fn
;
167 struct jit_reader
*new_reader
= NULL
;
168 struct gdb_reader_funcs
*funcs
= NULL
;
169 struct cleanup
*old_cleanups
;
172 fprintf_unfiltered (gdb_stdlog
, _("Opening shared object %s.\n"),
174 so
= gdb_dlopen (file_name
);
175 old_cleanups
= make_cleanup_dlclose (so
);
177 init_fn
= gdb_dlsym (so
, reader_init_fn_sym
);
179 error (_("Could not locate initialization function: %s."),
182 if (gdb_dlsym (so
, "plugin_is_GPL_compatible") == NULL
)
183 error (_("Reader not GPL compatible."));
186 if (funcs
->reader_version
!= GDB_READER_INTERFACE_VERSION
)
187 error (_("Reader version does not match GDB version."));
189 new_reader
= XZALLOC (struct jit_reader
);
190 new_reader
->functions
= funcs
;
191 new_reader
->handle
= so
;
193 discard_cleanups (old_cleanups
);
197 /* Provides the jit-reader-load command. */
200 jit_reader_load_command (char *args
, int from_tty
)
204 struct cleanup
*prev_cleanup
;
207 error (_("No reader name provided."));
209 if (loaded_jit_reader
!= NULL
)
210 error (_("JIT reader already loaded. Run jit-reader-unload first."));
212 so_name
= xstrprintf ("%s/%s", jit_reader_dir
, args
);
213 prev_cleanup
= make_cleanup (xfree
, so_name
);
215 loaded_jit_reader
= jit_reader_load (so_name
);
216 do_cleanups (prev_cleanup
);
219 /* Provides the jit-reader-unload command. */
222 jit_reader_unload_command (char *args
, int from_tty
)
224 if (!loaded_jit_reader
)
225 error (_("No JIT reader loaded."));
227 loaded_jit_reader
->functions
->destroy (loaded_jit_reader
->functions
);
229 gdb_dlclose (loaded_jit_reader
->handle
);
230 xfree (loaded_jit_reader
);
231 loaded_jit_reader
= NULL
;
234 /* Per-inferior structure recording which objfile has the JIT
237 struct jit_inferior_data
239 /* The objfile. This is NULL if no objfile holds the JIT
242 struct objfile
*objfile
;
245 /* Per-objfile structure recording the addresses in the inferior. */
247 struct jit_objfile_data
249 /* Symbol for __jit_debug_register_code. */
250 struct minimal_symbol
*register_code
;
252 /* Symbol for __jit_debug_descriptor. */
253 struct minimal_symbol
*descriptor
;
255 /* Address of struct jit_code_entry in this objfile. */
259 /* Fetch the jit_objfile_data associated with OBJF. If no data exists
260 yet, make a new structure and attach it. */
262 static struct jit_objfile_data
*
263 get_jit_objfile_data (struct objfile
*objf
)
265 struct jit_objfile_data
*objf_data
;
267 objf_data
= objfile_data (objf
, jit_objfile_data
);
268 if (objf_data
== NULL
)
270 objf_data
= XZALLOC (struct jit_objfile_data
);
271 set_objfile_data (objf
, jit_objfile_data
, objf_data
);
277 /* Remember OBJFILE has been created for struct jit_code_entry located
278 at inferior address ENTRY. */
281 add_objfile_entry (struct objfile
*objfile
, CORE_ADDR entry
)
283 CORE_ADDR
*entry_addr_ptr
;
284 struct jit_objfile_data
*objf_data
;
286 objf_data
= get_jit_objfile_data (objfile
);
287 objf_data
->addr
= entry
;
290 /* Return jit_inferior_data for current inferior. Allocate if not already
293 static struct jit_inferior_data
*
294 get_jit_inferior_data (void)
296 struct inferior
*inf
;
297 struct jit_inferior_data
*inf_data
;
299 inf
= current_inferior ();
300 inf_data
= inferior_data (inf
, jit_inferior_data
);
301 if (inf_data
== NULL
)
303 inf_data
= XZALLOC (struct jit_inferior_data
);
304 set_inferior_data (inf
, jit_inferior_data
, inf_data
);
311 jit_inferior_data_cleanup (struct inferior
*inf
, void *arg
)
316 /* Helper function for reading the global JIT descriptor from remote
317 memory. Returns 1 if all went well, 0 otherwise. */
320 jit_read_descriptor (struct gdbarch
*gdbarch
,
321 struct jit_descriptor
*descriptor
,
322 struct jit_inferior_data
*inf_data
)
325 struct type
*ptr_type
;
329 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
330 struct jit_objfile_data
*objf_data
;
332 if (inf_data
->objfile
== NULL
)
334 objf_data
= get_jit_objfile_data (inf_data
->objfile
);
335 if (objf_data
->descriptor
== NULL
)
339 fprintf_unfiltered (gdb_stdlog
,
340 "jit_read_descriptor, descriptor_addr = %s\n",
341 paddress (gdbarch
, SYMBOL_VALUE_ADDRESS (objf_data
->descriptor
)));
343 /* Figure out how big the descriptor is on the remote and how to read it. */
344 ptr_type
= builtin_type (gdbarch
)->builtin_data_ptr
;
345 ptr_size
= TYPE_LENGTH (ptr_type
);
346 desc_size
= 8 + 2 * ptr_size
; /* Two 32-bit ints and two pointers. */
347 desc_buf
= alloca (desc_size
);
349 /* Read the descriptor. */
350 err
= target_read_memory (SYMBOL_VALUE_ADDRESS (objf_data
->descriptor
),
351 desc_buf
, desc_size
);
354 printf_unfiltered (_("Unable to read JIT descriptor from "
359 /* Fix the endianness to match the host. */
360 descriptor
->version
= extract_unsigned_integer (&desc_buf
[0], 4, byte_order
);
361 descriptor
->action_flag
=
362 extract_unsigned_integer (&desc_buf
[4], 4, byte_order
);
363 descriptor
->relevant_entry
= extract_typed_address (&desc_buf
[8], ptr_type
);
364 descriptor
->first_entry
=
365 extract_typed_address (&desc_buf
[8 + ptr_size
], ptr_type
);
370 /* Helper function for reading a JITed code entry from remote memory. */
373 jit_read_code_entry (struct gdbarch
*gdbarch
,
374 CORE_ADDR code_addr
, struct jit_code_entry
*code_entry
)
377 struct type
*ptr_type
;
382 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
384 /* Figure out how big the entry is on the remote and how to read it. */
385 ptr_type
= builtin_type (gdbarch
)->builtin_data_ptr
;
386 ptr_size
= TYPE_LENGTH (ptr_type
);
387 entry_size
= 3 * ptr_size
+ 8; /* Three pointers and one 64-bit int. */
388 entry_buf
= alloca (entry_size
);
390 /* Read the entry. */
391 err
= target_read_memory (code_addr
, entry_buf
, entry_size
);
393 error (_("Unable to read JIT code entry from remote memory!"));
395 /* Fix the endianness to match the host. */
396 ptr_type
= builtin_type (gdbarch
)->builtin_data_ptr
;
397 code_entry
->next_entry
= extract_typed_address (&entry_buf
[0], ptr_type
);
398 code_entry
->prev_entry
=
399 extract_typed_address (&entry_buf
[ptr_size
], ptr_type
);
400 code_entry
->symfile_addr
=
401 extract_typed_address (&entry_buf
[2 * ptr_size
], ptr_type
);
403 align_bytes
= gdbarch_long_long_align_bit (gdbarch
) / 8;
405 off
= (off
+ (align_bytes
- 1)) & ~(align_bytes
- 1);
407 code_entry
->symfile_size
=
408 extract_unsigned_integer (&entry_buf
[off
], 8, byte_order
);
411 /* Proxy object for building a block. */
415 /* gdb_blocks are linked into a tree structure. Next points to the
416 next node at the same depth as this block and parent to the
418 struct gdb_block
*next
, *parent
;
420 /* Points to the "real" block that is being built out of this
421 instance. This block will be added to a blockvector, which will
422 then be added to a symtab. */
423 struct block
*real_block
;
425 /* The first and last code address corresponding to this block. */
426 CORE_ADDR begin
, end
;
428 /* The name of this block (if any). If this is non-NULL, the
429 FUNCTION symbol symbol is set to this value. */
433 /* Proxy object for building a symtab. */
437 /* The list of blocks in this symtab. These will eventually be
438 converted to real blocks. */
439 struct gdb_block
*blocks
;
441 /* The number of blocks inserted. */
444 /* A mapping between line numbers to PC. */
445 struct linetable
*linetable
;
447 /* The source file for this symtab. */
448 const char *file_name
;
449 struct gdb_symtab
*next
;
452 /* Proxy object for building an object. */
456 struct gdb_symtab
*symtabs
;
459 /* The type of the `private' data passed around by the callback
462 typedef CORE_ADDR jit_dbg_reader_data
;
464 /* The reader calls into this function to read data off the targets
467 static enum gdb_status
468 jit_target_read_impl (GDB_CORE_ADDR target_mem
, void *gdb_buf
, int len
)
470 int result
= target_read_memory ((CORE_ADDR
) target_mem
, gdb_buf
, len
);
477 /* The reader calls into this function to create a new gdb_object
478 which it can then pass around to the other callbacks. Right now,
479 all that is required is allocating the memory. */
481 static struct gdb_object
*
482 jit_object_open_impl (struct gdb_symbol_callbacks
*cb
)
484 /* CB is not required right now, but sometime in the future we might
485 need a handle to it, and we'd like to do that without breaking
487 return XZALLOC (struct gdb_object
);
490 /* Readers call into this function to open a new gdb_symtab, which,
491 again, is passed around to other callbacks. */
493 static struct gdb_symtab
*
494 jit_symtab_open_impl (struct gdb_symbol_callbacks
*cb
,
495 struct gdb_object
*object
,
496 const char *file_name
)
498 struct gdb_symtab
*ret
;
500 /* CB stays unused. See comment in jit_object_open_impl. */
502 ret
= XZALLOC (struct gdb_symtab
);
503 ret
->file_name
= file_name
? xstrdup (file_name
) : xstrdup ("");
504 ret
->next
= object
->symtabs
;
505 object
->symtabs
= ret
;
509 /* Returns true if the block corresponding to old should be placed
510 before the block corresponding to new in the final blockvector. */
513 compare_block (const struct gdb_block
*const old
,
514 const struct gdb_block
*const new)
518 if (old
->begin
< new->begin
)
520 else if (old
->begin
== new->begin
)
522 if (old
->end
> new->end
)
531 /* Called by readers to open a new gdb_block. This function also
532 inserts the new gdb_block in the correct place in the corresponding
535 static struct gdb_block
*
536 jit_block_open_impl (struct gdb_symbol_callbacks
*cb
,
537 struct gdb_symtab
*symtab
, struct gdb_block
*parent
,
538 GDB_CORE_ADDR begin
, GDB_CORE_ADDR end
, const char *name
)
540 struct gdb_block
*block
= XZALLOC (struct gdb_block
);
542 block
->next
= symtab
->blocks
;
543 block
->begin
= (CORE_ADDR
) begin
;
544 block
->end
= (CORE_ADDR
) end
;
545 block
->name
= name
? xstrdup (name
) : NULL
;
546 block
->parent
= parent
;
548 /* Ensure that the blocks are inserted in the correct (reverse of
549 the order expected by blockvector). */
550 if (compare_block (symtab
->blocks
, block
))
552 symtab
->blocks
= block
;
556 struct gdb_block
*i
= symtab
->blocks
;
560 /* Guaranteed to terminate, since compare_block (NULL, _)
562 if (compare_block (i
->next
, block
))
564 block
->next
= i
->next
;
575 /* Readers call this to add a line mapping (from PC to line number) to
579 jit_symtab_line_mapping_add_impl (struct gdb_symbol_callbacks
*cb
,
580 struct gdb_symtab
*stab
, int nlines
,
581 struct gdb_line_mapping
*map
)
588 stab
->linetable
= xmalloc (sizeof (struct linetable
)
589 + (nlines
- 1) * sizeof (struct linetable_entry
));
590 stab
->linetable
->nitems
= nlines
;
591 for (i
= 0; i
< nlines
; i
++)
593 stab
->linetable
->item
[i
].pc
= (CORE_ADDR
) map
[i
].pc
;
594 stab
->linetable
->item
[i
].line
= map
[i
].line
;
598 /* Called by readers to close a gdb_symtab. Does not need to do
599 anything as of now. */
602 jit_symtab_close_impl (struct gdb_symbol_callbacks
*cb
,
603 struct gdb_symtab
*stab
)
605 /* Right now nothing needs to be done here. We may need to do some
606 cleanup here in the future (again, without breaking the plugin
610 /* Transform STAB to a proper symtab, and add it it OBJFILE. */
613 finalize_symtab (struct gdb_symtab
*stab
, struct objfile
*objfile
)
615 struct symtab
*symtab
;
616 struct gdb_block
*gdb_block_iter
, *gdb_block_iter_tmp
;
617 struct block
*block_iter
;
618 int actual_nblocks
, i
, blockvector_size
;
619 CORE_ADDR begin
, end
;
621 actual_nblocks
= FIRST_LOCAL_BLOCK
+ stab
->nblocks
;
623 symtab
= allocate_symtab (stab
->file_name
, objfile
);
624 /* JIT compilers compile in memory. */
625 symtab
->dirname
= NULL
;
627 /* Copy over the linetable entry if one was provided. */
630 int size
= ((stab
->linetable
->nitems
- 1)
631 * sizeof (struct linetable_entry
)
632 + sizeof (struct linetable
));
633 LINETABLE (symtab
) = obstack_alloc (&objfile
->objfile_obstack
, size
);
634 memcpy (LINETABLE (symtab
), stab
->linetable
, size
);
638 LINETABLE (symtab
) = NULL
;
641 blockvector_size
= (sizeof (struct blockvector
)
642 + (actual_nblocks
- 1) * sizeof (struct block
*));
643 symtab
->blockvector
= obstack_alloc (&objfile
->objfile_obstack
,
646 /* (begin, end) will contain the PC range this entire blockvector
649 BLOCKVECTOR_MAP (symtab
->blockvector
) = NULL
;
650 begin
= stab
->blocks
->begin
;
651 end
= stab
->blocks
->end
;
652 BLOCKVECTOR_NBLOCKS (symtab
->blockvector
) = actual_nblocks
;
654 /* First run over all the gdb_block objects, creating a real block
655 object for each. Simultaneously, keep setting the real_block
657 for (i
= (actual_nblocks
- 1), gdb_block_iter
= stab
->blocks
;
658 i
>= FIRST_LOCAL_BLOCK
;
659 i
--, gdb_block_iter
= gdb_block_iter
->next
)
661 struct block
*new_block
= allocate_block (&objfile
->objfile_obstack
);
662 struct symbol
*block_name
= obstack_alloc (&objfile
->objfile_obstack
,
663 sizeof (struct symbol
));
665 BLOCK_DICT (new_block
) = dict_create_linear (&objfile
->objfile_obstack
,
667 /* The address range. */
668 BLOCK_START (new_block
) = (CORE_ADDR
) gdb_block_iter
->begin
;
669 BLOCK_END (new_block
) = (CORE_ADDR
) gdb_block_iter
->end
;
672 memset (block_name
, 0, sizeof (struct symbol
));
673 SYMBOL_DOMAIN (block_name
) = VAR_DOMAIN
;
674 SYMBOL_CLASS (block_name
) = LOC_BLOCK
;
675 SYMBOL_SYMTAB (block_name
) = symtab
;
676 SYMBOL_BLOCK_VALUE (block_name
) = new_block
;
678 block_name
->ginfo
.name
= obsavestring (gdb_block_iter
->name
,
679 strlen (gdb_block_iter
->name
),
680 &objfile
->objfile_obstack
);
682 BLOCK_FUNCTION (new_block
) = block_name
;
684 BLOCKVECTOR_BLOCK (symtab
->blockvector
, i
) = new_block
;
685 if (begin
> BLOCK_START (new_block
))
686 begin
= BLOCK_START (new_block
);
687 if (end
< BLOCK_END (new_block
))
688 end
= BLOCK_END (new_block
);
690 gdb_block_iter
->real_block
= new_block
;
693 /* Now add the special blocks. */
695 for (i
= 0; i
< FIRST_LOCAL_BLOCK
; i
++)
697 struct block
*new_block
= allocate_block (&objfile
->objfile_obstack
);
698 BLOCK_DICT (new_block
) = dict_create_linear (&objfile
->objfile_obstack
,
700 BLOCK_SUPERBLOCK (new_block
) = block_iter
;
701 block_iter
= new_block
;
703 BLOCK_START (new_block
) = (CORE_ADDR
) begin
;
704 BLOCK_END (new_block
) = (CORE_ADDR
) end
;
706 BLOCKVECTOR_BLOCK (symtab
->blockvector
, i
) = new_block
;
709 /* Fill up the superblock fields for the real blocks, using the
710 real_block fields populated earlier. */
711 for (gdb_block_iter
= stab
->blocks
;
713 gdb_block_iter
= gdb_block_iter
->next
)
715 if (gdb_block_iter
->parent
!= NULL
)
716 BLOCK_SUPERBLOCK (gdb_block_iter
->real_block
) =
717 gdb_block_iter
->parent
->real_block
;
721 gdb_block_iter
= stab
->blocks
;
723 for (gdb_block_iter
= stab
->blocks
, gdb_block_iter_tmp
= gdb_block_iter
->next
;
725 gdb_block_iter
= gdb_block_iter_tmp
)
727 xfree ((void *) gdb_block_iter
->name
);
728 xfree (gdb_block_iter
);
730 xfree (stab
->linetable
);
731 xfree ((char *) stab
->file_name
);
735 /* Called when closing a gdb_objfile. Converts OBJ to a proper
739 jit_object_close_impl (struct gdb_symbol_callbacks
*cb
,
740 struct gdb_object
*obj
)
742 struct gdb_symtab
*i
, *j
;
743 struct objfile
*objfile
;
744 jit_dbg_reader_data
*priv_data
;
746 priv_data
= cb
->priv_data
;
748 objfile
= allocate_objfile (NULL
, 0);
749 objfile
->gdbarch
= target_gdbarch
;
751 terminate_minimal_symbol_table (objfile
);
753 xfree (objfile
->name
);
754 objfile
->name
= xstrdup ("<< JIT compiled code >>");
757 for (i
= obj
->symtabs
; i
; i
= j
)
760 finalize_symtab (i
, objfile
);
762 add_objfile_entry (objfile
, *priv_data
);
766 /* Try to read CODE_ENTRY using the loaded jit reader (if any).
767 ENTRY_ADDR is the address of the struct jit_code_entry in the
768 inferior address space. */
771 jit_reader_try_read_symtab (struct jit_code_entry
*code_entry
,
772 CORE_ADDR entry_addr
)
776 struct jit_dbg_reader
*i
;
777 jit_dbg_reader_data priv_data
;
778 struct gdb_reader_funcs
*funcs
;
779 volatile struct gdb_exception e
;
780 struct gdb_symbol_callbacks callbacks
=
782 jit_object_open_impl
,
783 jit_symtab_open_impl
,
785 jit_symtab_close_impl
,
786 jit_object_close_impl
,
788 jit_symtab_line_mapping_add_impl
,
789 jit_target_read_impl
,
794 priv_data
= entry_addr
;
796 if (!loaded_jit_reader
)
799 gdb_mem
= xmalloc (code_entry
->symfile_size
);
802 TRY_CATCH (e
, RETURN_MASK_ALL
)
803 if (target_read_memory (code_entry
->symfile_addr
, gdb_mem
,
804 code_entry
->symfile_size
))
811 funcs
= loaded_jit_reader
->functions
;
812 if (funcs
->read (funcs
, &callbacks
, gdb_mem
, code_entry
->symfile_size
)
818 if (jit_debug
&& status
== 0)
819 fprintf_unfiltered (gdb_stdlog
,
820 "Could not read symtab using the loaded JIT reader.\n");
824 /* Try to read CODE_ENTRY using BFD. ENTRY_ADDR is the address of the
825 struct jit_code_entry in the inferior address space. */
828 jit_bfd_try_read_symtab (struct jit_code_entry
*code_entry
,
829 CORE_ADDR entry_addr
,
830 struct gdbarch
*gdbarch
)
833 struct section_addr_info
*sai
;
834 struct bfd_section
*sec
;
835 struct objfile
*objfile
;
836 struct cleanup
*old_cleanups
;
838 const struct bfd_arch_info
*b
;
841 fprintf_unfiltered (gdb_stdlog
,
842 "jit_register_code, symfile_addr = %s, "
843 "symfile_size = %s\n",
844 paddress (gdbarch
, code_entry
->symfile_addr
),
845 pulongest (code_entry
->symfile_size
));
847 nbfd
= bfd_open_from_target_memory (code_entry
->symfile_addr
,
848 code_entry
->symfile_size
, gnutarget
);
851 puts_unfiltered (_("Error opening JITed symbol file, ignoring it.\n"));
855 /* Check the format. NOTE: This initializes important data that GDB uses!
856 We would segfault later without this line. */
857 if (!bfd_check_format (nbfd
, bfd_object
))
859 printf_unfiltered (_("\
860 JITed symbol file is not an object file, ignoring it.\n"));
865 /* Check bfd arch. */
866 b
= gdbarch_bfd_arch_info (gdbarch
);
867 if (b
->compatible (b
, bfd_get_arch_info (nbfd
)) != b
)
868 warning (_("JITed object file architecture %s is not compatible "
869 "with target architecture %s."), bfd_get_arch_info
870 (nbfd
)->printable_name
, b
->printable_name
);
872 /* Read the section address information out of the symbol file. Since the
873 file is generated by the JIT at runtime, it should all of the absolute
874 addresses that we care about. */
875 sai
= alloc_section_addr_info (bfd_count_sections (nbfd
));
876 old_cleanups
= make_cleanup_free_section_addr_info (sai
);
878 for (sec
= nbfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
879 if ((bfd_get_section_flags (nbfd
, sec
) & (SEC_ALLOC
|SEC_LOAD
)) != 0)
881 /* We assume that these virtual addresses are absolute, and do not
882 treat them as offsets. */
883 sai
->other
[i
].addr
= bfd_get_section_vma (nbfd
, sec
);
884 sai
->other
[i
].name
= xstrdup (bfd_get_section_name (nbfd
, sec
));
885 sai
->other
[i
].sectindex
= sec
->index
;
889 /* This call takes ownership of NBFD. It does not take ownership of SAI. */
890 objfile
= symbol_file_add_from_bfd (nbfd
, 0, sai
, OBJF_SHARED
, NULL
);
892 do_cleanups (old_cleanups
);
893 add_objfile_entry (objfile
, entry_addr
);
896 /* This function registers code associated with a JIT code entry. It uses the
897 pointer and size pair in the entry to read the symbol file from the remote
898 and then calls symbol_file_add_from_local_memory to add it as though it were
899 a symbol file added by the user. */
902 jit_register_code (struct gdbarch
*gdbarch
,
903 CORE_ADDR entry_addr
, struct jit_code_entry
*code_entry
)
906 const struct bfd_arch_info
*b
;
907 struct jit_inferior_data
*inf_data
= get_jit_inferior_data ();
910 fprintf_unfiltered (gdb_stdlog
,
911 "jit_register_code, symfile_addr = %s, "
912 "symfile_size = %s\n",
913 paddress (gdbarch
, code_entry
->symfile_addr
),
914 pulongest (code_entry
->symfile_size
));
916 success
= jit_reader_try_read_symtab (code_entry
, entry_addr
);
919 jit_bfd_try_read_symtab (code_entry
, entry_addr
, gdbarch
);
922 /* This function unregisters JITed code and frees the corresponding
926 jit_unregister_code (struct objfile
*objfile
)
928 free_objfile (objfile
);
931 /* Look up the objfile with this code entry address. */
933 static struct objfile
*
934 jit_find_objf_with_entry_addr (CORE_ADDR entry_addr
)
936 struct objfile
*objf
;
937 CORE_ADDR
*objf_entry_addr
;
941 struct jit_objfile_data
*objf_data
;
943 objf_data
= objfile_data (objf
, jit_objfile_data
);
944 if (objf_data
!= NULL
&& objf_data
->addr
== entry_addr
)
950 /* (Re-)Initialize the jit breakpoint if necessary.
951 Return 0 on success. */
954 jit_breakpoint_re_set_internal (struct gdbarch
*gdbarch
,
955 struct jit_inferior_data
*inf_data
)
957 struct minimal_symbol
*reg_symbol
, *desc_symbol
;
958 struct objfile
*objf
;
959 struct jit_objfile_data
*objf_data
;
961 if (inf_data
->objfile
!= NULL
)
964 /* Lookup the registration symbol. If it is missing, then we assume
965 we are not attached to a JIT. */
966 reg_symbol
= lookup_minimal_symbol_and_objfile (jit_break_name
, &objf
);
967 if (reg_symbol
== NULL
|| SYMBOL_VALUE_ADDRESS (reg_symbol
) == 0)
970 desc_symbol
= lookup_minimal_symbol (jit_descriptor_name
, NULL
, objf
);
971 if (desc_symbol
== NULL
|| SYMBOL_VALUE_ADDRESS (desc_symbol
) == 0)
974 objf_data
= get_jit_objfile_data (objf
);
975 objf_data
->register_code
= reg_symbol
;
976 objf_data
->descriptor
= desc_symbol
;
978 inf_data
->objfile
= objf
;
980 jit_inferior_init (gdbarch
);
983 fprintf_unfiltered (gdb_stdlog
,
984 "jit_breakpoint_re_set_internal, "
985 "breakpoint_addr = %s\n",
986 paddress (gdbarch
, SYMBOL_VALUE_ADDRESS (reg_symbol
)));
988 /* Put a breakpoint in the registration symbol. */
989 create_jit_event_breakpoint (gdbarch
, SYMBOL_VALUE_ADDRESS (reg_symbol
));
994 /* The private data passed around in the frame unwind callback
997 struct jit_unwind_private
999 /* Cached register values. See jit_frame_sniffer to see how this
1001 struct gdb_reg_value
**registers
;
1003 /* The frame being unwound. */
1004 struct frame_info
*this_frame
;
1007 /* Sets the value of a particular register in this frame. */
1010 jit_unwind_reg_set_impl (struct gdb_unwind_callbacks
*cb
, int dwarf_regnum
,
1011 struct gdb_reg_value
*value
)
1013 struct jit_unwind_private
*priv
;
1016 priv
= cb
->priv_data
;
1018 gdb_reg
= gdbarch_dwarf2_reg_to_regnum (get_frame_arch (priv
->this_frame
),
1023 fprintf_unfiltered (gdb_stdlog
,
1024 _("Could not recognize DWARF regnum %d"),
1029 gdb_assert (priv
->registers
);
1030 priv
->registers
[gdb_reg
] = value
;
1034 reg_value_free_impl (struct gdb_reg_value
*value
)
1039 /* Get the value of register REGNUM in the previous frame. */
1041 static struct gdb_reg_value
*
1042 jit_unwind_reg_get_impl (struct gdb_unwind_callbacks
*cb
, int regnum
)
1044 struct jit_unwind_private
*priv
;
1045 struct gdb_reg_value
*value
;
1047 struct gdbarch
*frame_arch
;
1049 priv
= cb
->priv_data
;
1050 frame_arch
= get_frame_arch (priv
->this_frame
);
1052 gdb_reg
= gdbarch_dwarf2_reg_to_regnum (frame_arch
, regnum
);
1053 size
= register_size (frame_arch
, gdb_reg
);
1054 value
= xmalloc (sizeof (struct gdb_reg_value
) + size
- 1);
1055 value
->defined
= frame_register_read (priv
->this_frame
, gdb_reg
,
1058 value
->free
= reg_value_free_impl
;
1062 /* gdb_reg_value has a free function, which must be called on each
1063 saved register value. */
1066 jit_dealloc_cache (struct frame_info
*this_frame
, void *cache
)
1068 struct jit_unwind_private
*priv_data
= cache
;
1069 struct gdbarch
*frame_arch
;
1072 gdb_assert (priv_data
->registers
);
1073 frame_arch
= get_frame_arch (priv_data
->this_frame
);
1075 for (i
= 0; i
< gdbarch_num_regs (frame_arch
); i
++)
1076 if (priv_data
->registers
[i
] && priv_data
->registers
[i
]->free
)
1077 priv_data
->registers
[i
]->free (priv_data
->registers
[i
]);
1079 xfree (priv_data
->registers
);
1083 /* The frame sniffer for the pseudo unwinder.
1085 While this is nominally a frame sniffer, in the case where the JIT
1086 reader actually recognizes the frame, it does a lot more work -- it
1087 unwinds the frame and saves the corresponding register values in
1088 the cache. jit_frame_prev_register simply returns the saved
1092 jit_frame_sniffer (const struct frame_unwind
*self
,
1093 struct frame_info
*this_frame
, void **cache
)
1095 struct jit_inferior_data
*inf_data
;
1096 struct jit_unwind_private
*priv_data
;
1097 struct jit_dbg_reader
*iter
;
1098 struct gdb_unwind_callbacks callbacks
;
1099 struct gdb_reader_funcs
*funcs
;
1101 inf_data
= get_jit_inferior_data ();
1103 callbacks
.reg_get
= jit_unwind_reg_get_impl
;
1104 callbacks
.reg_set
= jit_unwind_reg_set_impl
;
1105 callbacks
.target_read
= jit_target_read_impl
;
1107 if (loaded_jit_reader
== NULL
)
1110 funcs
= loaded_jit_reader
->functions
;
1112 gdb_assert (!*cache
);
1114 *cache
= XZALLOC (struct jit_unwind_private
);
1116 priv_data
->registers
=
1117 XCALLOC (gdbarch_num_regs (get_frame_arch (this_frame
)),
1118 struct gdb_reg_value
*);
1119 priv_data
->this_frame
= this_frame
;
1121 callbacks
.priv_data
= priv_data
;
1123 /* Try to coax the provided unwinder to unwind the stack */
1124 if (funcs
->unwind (funcs
, &callbacks
) == GDB_SUCCESS
)
1127 fprintf_unfiltered (gdb_stdlog
, _("Successfully unwound frame using "
1132 fprintf_unfiltered (gdb_stdlog
, _("Could not unwind frame using "
1135 jit_dealloc_cache (this_frame
, *cache
);
1142 /* The frame_id function for the pseudo unwinder. Relays the call to
1143 the loaded plugin. */
1146 jit_frame_this_id (struct frame_info
*this_frame
, void **cache
,
1147 struct frame_id
*this_id
)
1149 struct jit_unwind_private
private;
1150 struct gdb_frame_id frame_id
;
1151 struct gdb_reader_funcs
*funcs
;
1152 struct gdb_unwind_callbacks callbacks
;
1154 private.registers
= NULL
;
1155 private.this_frame
= this_frame
;
1157 /* We don't expect the frame_id function to set any registers, so we
1158 set reg_set to NULL. */
1159 callbacks
.reg_get
= jit_unwind_reg_get_impl
;
1160 callbacks
.reg_set
= NULL
;
1161 callbacks
.target_read
= jit_target_read_impl
;
1162 callbacks
.priv_data
= &private;
1164 gdb_assert (loaded_jit_reader
);
1165 funcs
= loaded_jit_reader
->functions
;
1167 frame_id
= funcs
->get_frame_id (funcs
, &callbacks
);
1168 *this_id
= frame_id_build (frame_id
.stack_address
, frame_id
.code_address
);
1171 /* Pseudo unwinder function. Reads the previously fetched value for
1172 the register from the cache. */
1174 static struct value
*
1175 jit_frame_prev_register (struct frame_info
*this_frame
, void **cache
, int reg
)
1177 struct jit_unwind_private
*priv
= *cache
;
1178 struct gdb_reg_value
*value
;
1181 return frame_unwind_got_optimized (this_frame
, reg
);
1183 gdb_assert (priv
->registers
);
1184 value
= priv
->registers
[reg
];
1185 if (value
&& value
->defined
)
1186 return frame_unwind_got_bytes (this_frame
, reg
, value
->value
);
1188 return frame_unwind_got_optimized (this_frame
, reg
);
1191 /* Relay everything back to the unwinder registered by the JIT debug
1194 static const struct frame_unwind jit_frame_unwind
=
1197 default_frame_unwind_stop_reason
,
1199 jit_frame_prev_register
,
1206 /* This is the information that is stored at jit_gdbarch_data for each
1209 struct jit_gdbarch_data_type
1211 /* Has the (pseudo) unwinder been prepended? */
1212 int unwinder_registered
;
1215 /* Check GDBARCH and prepend the pseudo JIT unwinder if needed. */
1218 jit_prepend_unwinder (struct gdbarch
*gdbarch
)
1220 struct jit_gdbarch_data_type
*data
;
1222 data
= gdbarch_data (gdbarch
, jit_gdbarch_data
);
1223 if (!data
->unwinder_registered
)
1225 frame_unwind_prepend_unwinder (gdbarch
, &jit_frame_unwind
);
1226 data
->unwinder_registered
= 1;
1230 /* Register any already created translations. */
1233 jit_inferior_init (struct gdbarch
*gdbarch
)
1235 struct jit_descriptor descriptor
;
1236 struct jit_code_entry cur_entry
;
1237 struct jit_inferior_data
*inf_data
;
1238 CORE_ADDR cur_entry_addr
;
1239 struct jit_objfile_data
*objf_data
;
1242 fprintf_unfiltered (gdb_stdlog
, "jit_inferior_init\n");
1244 jit_prepend_unwinder (gdbarch
);
1246 inf_data
= get_jit_inferior_data ();
1247 if (jit_breakpoint_re_set_internal (gdbarch
, inf_data
) != 0)
1250 /* Read the descriptor so we can check the version number and load
1251 any already JITed functions. */
1252 if (!jit_read_descriptor (gdbarch
, &descriptor
, inf_data
))
1255 /* Check that the version number agrees with that we support. */
1256 if (descriptor
.version
!= 1)
1258 printf_unfiltered (_("Unsupported JIT protocol version %ld "
1259 "in descriptor (expected 1)\n"),
1260 (long) descriptor
.version
);
1264 /* If we've attached to a running program, we need to check the descriptor
1265 to register any functions that were already generated. */
1266 for (cur_entry_addr
= descriptor
.first_entry
;
1267 cur_entry_addr
!= 0;
1268 cur_entry_addr
= cur_entry
.next_entry
)
1270 jit_read_code_entry (gdbarch
, cur_entry_addr
, &cur_entry
);
1272 /* This hook may be called many times during setup, so make sure we don't
1273 add the same symbol file twice. */
1274 if (jit_find_objf_with_entry_addr (cur_entry_addr
) != NULL
)
1277 jit_register_code (gdbarch
, cur_entry_addr
, &cur_entry
);
1281 /* Exported routine to call when an inferior has been created. */
1284 jit_inferior_created_hook (void)
1286 jit_inferior_init (target_gdbarch
);
1289 /* Exported routine to call to re-set the jit breakpoints,
1290 e.g. when a program is rerun. */
1293 jit_breakpoint_re_set (void)
1295 jit_breakpoint_re_set_internal (target_gdbarch
,
1296 get_jit_inferior_data ());
1299 /* This function cleans up any code entries left over when the
1300 inferior exits. We get left over code when the inferior exits
1301 without unregistering its code, for example when it crashes. */
1304 jit_inferior_exit_hook (struct inferior
*inf
)
1306 struct objfile
*objf
;
1307 struct objfile
*temp
;
1309 ALL_OBJFILES_SAFE (objf
, temp
)
1311 struct jit_objfile_data
*objf_data
= objfile_data (objf
,
1314 if (objf_data
!= NULL
&& objf_data
->addr
!= 0)
1315 jit_unregister_code (objf
);
1320 jit_event_handler (struct gdbarch
*gdbarch
)
1322 struct jit_descriptor descriptor
;
1323 struct jit_code_entry code_entry
;
1324 CORE_ADDR entry_addr
;
1325 struct objfile
*objf
;
1327 /* Read the descriptor from remote memory. */
1328 if (!jit_read_descriptor (gdbarch
, &descriptor
, get_jit_inferior_data ()))
1330 entry_addr
= descriptor
.relevant_entry
;
1332 /* Do the corresponding action. */
1333 switch (descriptor
.action_flag
)
1338 jit_read_code_entry (gdbarch
, entry_addr
, &code_entry
);
1339 jit_register_code (gdbarch
, entry_addr
, &code_entry
);
1341 case JIT_UNREGISTER
:
1342 objf
= jit_find_objf_with_entry_addr (entry_addr
);
1344 printf_unfiltered (_("Unable to find JITed code "
1345 "entry at address: %s\n"),
1346 paddress (gdbarch
, entry_addr
));
1348 jit_unregister_code (objf
);
1352 error (_("Unknown action_flag value in JIT descriptor!"));
1357 /* Called to free the data allocated to the jit_inferior_data slot. */
1360 free_objfile_data (struct objfile
*objfile
, void *data
)
1362 struct jit_objfile_data
*objf_data
= data
;
1364 if (objf_data
->register_code
!= NULL
)
1366 struct jit_inferior_data
*inf_data
= get_jit_inferior_data ();
1368 if (inf_data
->objfile
== objfile
)
1369 inf_data
->objfile
= NULL
;
1375 /* Initialize the jit_gdbarch_data slot with an instance of struct
1376 jit_gdbarch_data_type */
1379 jit_gdbarch_data_init (struct obstack
*obstack
)
1381 struct jit_gdbarch_data_type
*data
;
1383 data
= obstack_alloc (obstack
, sizeof (struct jit_gdbarch_data_type
));
1384 data
->unwinder_registered
= 0;
1388 /* Provide a prototype to silence -Wmissing-prototypes. */
1390 extern void _initialize_jit (void);
1393 _initialize_jit (void)
1395 jit_reader_dir
= relocate_gdb_directory (JIT_READER_DIR
,
1396 JIT_READER_DIR_RELOCATABLE
);
1397 add_setshow_zinteger_cmd ("jit", class_maintenance
, &jit_debug
,
1398 _("Set JIT debugging."),
1399 _("Show JIT debugging."),
1400 _("When non-zero, JIT debugging is enabled."),
1403 &setdebuglist
, &showdebuglist
);
1405 observer_attach_inferior_exit (jit_inferior_exit_hook
);
1407 register_objfile_data_with_cleanup (NULL
, free_objfile_data
);
1409 register_inferior_data_with_cleanup (jit_inferior_data_cleanup
);
1410 jit_gdbarch_data
= gdbarch_data_register_pre_init (jit_gdbarch_data_init
);
1411 if (is_dl_available ())
1413 add_com ("jit-reader-load", no_class
, jit_reader_load_command
, _("\
1414 Load FILE as debug info reader and unwinder for JIT compiled code.\n\
1415 Usage: jit-reader-load FILE\n\
1416 Try to load file FILE as a debug info reader (and unwinder) for\n\
1417 JIT compiled code. The file is loaded from " JIT_READER_DIR
",\n\
1418 relocated relative to the GDB executable if required."));
1419 add_com ("jit-reader-unload", no_class
, jit_reader_unload_command
, _("\
1420 Unload the currently loaded JIT debug info reader.\n\
1421 Usage: jit-reader-unload FILE\n\n\
1422 Do \"help jit-reader-load\" for info on loading debug info readers."));