1 /* Handle JIT code generation in the inferior for GDB, the GNU Debugger.
3 Copyright (C) 2009-2013 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
23 #include "jit-reader.h"
25 #include "breakpoint.h"
27 #include "dictionary.h"
28 #include "filenames.h"
29 #include "frame-unwind.h"
39 #include "gdb-dlfcn.h"
41 #include "exceptions.h"
44 static const char *jit_reader_dir
= NULL
;
46 static const struct objfile_data
*jit_objfile_data
;
48 static const char *const jit_break_name
= "__jit_debug_register_code";
50 static const char *const jit_descriptor_name
= "__jit_debug_descriptor";
52 static const struct inferior_data
*jit_inferior_data
= NULL
;
54 static void jit_inferior_init (struct gdbarch
*gdbarch
);
56 /* An unwinder is registered for every gdbarch. This key is used to
57 remember if the unwinder has been registered for a particular
60 static struct gdbarch_data
*jit_gdbarch_data
;
62 /* Non-zero if we want to see trace of jit level stuff. */
64 static unsigned int jit_debug
= 0;
67 show_jit_debug (struct ui_file
*file
, int from_tty
,
68 struct cmd_list_element
*c
, const char *value
)
70 fprintf_filtered (file
, _("JIT debugging is %s.\n"), value
);
79 /* Openning the file is a no-op. */
82 mem_bfd_iovec_open (struct bfd
*abfd
, void *open_closure
)
87 /* Closing the file is just freeing the base/size pair on our side. */
90 mem_bfd_iovec_close (struct bfd
*abfd
, void *stream
)
96 /* For reading the file, we just need to pass through to target_read_memory and
97 fix up the arguments and return values. */
100 mem_bfd_iovec_pread (struct bfd
*abfd
, void *stream
, void *buf
,
101 file_ptr nbytes
, file_ptr offset
)
104 struct target_buffer
*buffer
= (struct target_buffer
*) stream
;
106 /* If this read will read all of the file, limit it to just the rest. */
107 if (offset
+ nbytes
> buffer
->size
)
108 nbytes
= buffer
->size
- offset
;
110 /* If there are no more bytes left, we've reached EOF. */
114 err
= target_read_memory (buffer
->base
+ offset
, (gdb_byte
*) buf
, nbytes
);
121 /* For statting the file, we only support the st_size attribute. */
124 mem_bfd_iovec_stat (struct bfd
*abfd
, void *stream
, struct stat
*sb
)
126 struct target_buffer
*buffer
= (struct target_buffer
*) stream
;
128 sb
->st_size
= buffer
->size
;
132 /* Open a BFD from the target's memory. */
135 bfd_open_from_target_memory (CORE_ADDR addr
, ULONGEST size
, char *target
)
137 struct target_buffer
*buffer
= xmalloc (sizeof (struct target_buffer
));
141 return gdb_bfd_openr_iovec ("<in-memory>", target
,
149 /* One reader that has been loaded successfully, and can potentially be used to
152 static struct jit_reader
154 struct gdb_reader_funcs
*functions
;
156 } *loaded_jit_reader
= NULL
;
158 typedef struct gdb_reader_funcs
* (reader_init_fn_type
) (void);
159 static const char *reader_init_fn_sym
= "gdb_init_reader";
161 /* Try to load FILE_NAME as a JIT debug info reader. */
163 static struct jit_reader
*
164 jit_reader_load (const char *file_name
)
167 reader_init_fn_type
*init_fn
;
168 struct jit_reader
*new_reader
= NULL
;
169 struct gdb_reader_funcs
*funcs
= NULL
;
170 struct cleanup
*old_cleanups
;
173 fprintf_unfiltered (gdb_stdlog
, _("Opening shared object %s.\n"),
175 so
= gdb_dlopen (file_name
);
176 old_cleanups
= make_cleanup_dlclose (so
);
178 init_fn
= gdb_dlsym (so
, reader_init_fn_sym
);
180 error (_("Could not locate initialization function: %s."),
183 if (gdb_dlsym (so
, "plugin_is_GPL_compatible") == NULL
)
184 error (_("Reader not GPL compatible."));
187 if (funcs
->reader_version
!= GDB_READER_INTERFACE_VERSION
)
188 error (_("Reader version does not match GDB version."));
190 new_reader
= XZALLOC (struct jit_reader
);
191 new_reader
->functions
= funcs
;
192 new_reader
->handle
= so
;
194 discard_cleanups (old_cleanups
);
198 /* Provides the jit-reader-load command. */
201 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 if (IS_ABSOLUTE_PATH (args
))
213 so_name
= xstrdup (args
);
215 so_name
= xstrprintf ("%s%s%s", SLASH_STRING
, jit_reader_dir
, args
);
216 prev_cleanup
= make_cleanup (xfree
, so_name
);
218 loaded_jit_reader
= jit_reader_load (so_name
);
219 do_cleanups (prev_cleanup
);
222 /* Provides the jit-reader-unload command. */
225 jit_reader_unload_command (char *args
, int from_tty
)
227 if (!loaded_jit_reader
)
228 error (_("No JIT reader loaded."));
230 loaded_jit_reader
->functions
->destroy (loaded_jit_reader
->functions
);
232 gdb_dlclose (loaded_jit_reader
->handle
);
233 xfree (loaded_jit_reader
);
234 loaded_jit_reader
= NULL
;
237 /* Per-inferior structure recording which objfile has the JIT
240 struct jit_inferior_data
242 /* The objfile. This is NULL if no objfile holds the JIT
245 struct objfile
*objfile
;
247 /* If this inferior has __jit_debug_register_code, this is the
248 cached address from the minimal symbol. This is used to detect
249 relocations requiring the breakpoint to be re-created. */
251 CORE_ADDR cached_code_address
;
253 /* This is the JIT event breakpoint, or NULL if it has not been
256 struct breakpoint
*jit_breakpoint
;
259 /* Per-objfile structure recording the addresses in the inferior.
260 This object serves two purposes: for ordinary objfiles, it may
261 cache some symbols related to the JIT interface; and for
262 JIT-created objfiles, it holds some information about the
265 struct jit_objfile_data
267 /* Symbol for __jit_debug_register_code. */
268 struct minimal_symbol
*register_code
;
270 /* Symbol for __jit_debug_descriptor. */
271 struct minimal_symbol
*descriptor
;
273 /* Address of struct jit_code_entry in this objfile. This is only
274 non-zero for objfiles that represent code created by the JIT. */
278 /* Fetch the jit_objfile_data associated with OBJF. If no data exists
279 yet, make a new structure and attach it. */
281 static struct jit_objfile_data
*
282 get_jit_objfile_data (struct objfile
*objf
)
284 struct jit_objfile_data
*objf_data
;
286 objf_data
= objfile_data (objf
, jit_objfile_data
);
287 if (objf_data
== NULL
)
289 objf_data
= XZALLOC (struct jit_objfile_data
);
290 set_objfile_data (objf
, jit_objfile_data
, objf_data
);
296 /* Remember OBJFILE has been created for struct jit_code_entry located
297 at inferior address ENTRY. */
300 add_objfile_entry (struct objfile
*objfile
, CORE_ADDR entry
)
302 struct jit_objfile_data
*objf_data
;
304 objf_data
= get_jit_objfile_data (objfile
);
305 objf_data
->addr
= entry
;
308 /* Return jit_inferior_data for current inferior. Allocate if not already
311 static struct jit_inferior_data
*
312 get_jit_inferior_data (void)
314 struct inferior
*inf
;
315 struct jit_inferior_data
*inf_data
;
317 inf
= current_inferior ();
318 inf_data
= inferior_data (inf
, jit_inferior_data
);
319 if (inf_data
== NULL
)
321 inf_data
= XZALLOC (struct jit_inferior_data
);
322 set_inferior_data (inf
, jit_inferior_data
, inf_data
);
329 jit_inferior_data_cleanup (struct inferior
*inf
, 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_inferior_data
*inf_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 (inf_data
->objfile
== NULL
)
352 objf_data
= get_jit_objfile_data (inf_data
->objfile
);
353 if (objf_data
->descriptor
== NULL
)
357 fprintf_unfiltered (gdb_stdlog
,
358 "jit_read_descriptor, descriptor_addr = %s\n",
359 paddress (gdbarch
, SYMBOL_VALUE_ADDRESS (objf_data
->descriptor
)));
361 /* Figure out how big the descriptor is on the remote and how to read it. */
362 ptr_type
= builtin_type (gdbarch
)->builtin_data_ptr
;
363 ptr_size
= TYPE_LENGTH (ptr_type
);
364 desc_size
= 8 + 2 * ptr_size
; /* Two 32-bit ints and two pointers. */
365 desc_buf
= alloca (desc_size
);
367 /* Read the descriptor. */
368 err
= target_read_memory (SYMBOL_VALUE_ADDRESS (objf_data
->descriptor
),
369 desc_buf
, desc_size
);
372 printf_unfiltered (_("Unable to read JIT descriptor from "
377 /* Fix the endianness to match the host. */
378 descriptor
->version
= extract_unsigned_integer (&desc_buf
[0], 4, byte_order
);
379 descriptor
->action_flag
=
380 extract_unsigned_integer (&desc_buf
[4], 4, byte_order
);
381 descriptor
->relevant_entry
= extract_typed_address (&desc_buf
[8], ptr_type
);
382 descriptor
->first_entry
=
383 extract_typed_address (&desc_buf
[8 + ptr_size
], ptr_type
);
388 /* Helper function for reading a JITed code entry from remote memory. */
391 jit_read_code_entry (struct gdbarch
*gdbarch
,
392 CORE_ADDR code_addr
, struct jit_code_entry
*code_entry
)
395 struct type
*ptr_type
;
400 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
402 /* Figure out how big the entry is on the remote and how to read it. */
403 ptr_type
= builtin_type (gdbarch
)->builtin_data_ptr
;
404 ptr_size
= TYPE_LENGTH (ptr_type
);
406 /* Figure out where the longlong value will be. */
407 align_bytes
= gdbarch_long_long_align_bit (gdbarch
) / 8;
409 off
= (off
+ (align_bytes
- 1)) & ~(align_bytes
- 1);
411 entry_size
= off
+ 8; /* Three pointers and one 64-bit int. */
412 entry_buf
= alloca (entry_size
);
414 /* Read the entry. */
415 err
= target_read_memory (code_addr
, entry_buf
, entry_size
);
417 error (_("Unable to read JIT code entry from remote memory!"));
419 /* Fix the endianness to match the host. */
420 ptr_type
= builtin_type (gdbarch
)->builtin_data_ptr
;
421 code_entry
->next_entry
= extract_typed_address (&entry_buf
[0], ptr_type
);
422 code_entry
->prev_entry
=
423 extract_typed_address (&entry_buf
[ptr_size
], ptr_type
);
424 code_entry
->symfile_addr
=
425 extract_typed_address (&entry_buf
[2 * ptr_size
], ptr_type
);
426 code_entry
->symfile_size
=
427 extract_unsigned_integer (&entry_buf
[off
], 8, byte_order
);
430 /* Proxy object for building a block. */
434 /* gdb_blocks are linked into a tree structure. Next points to the
435 next node at the same depth as this block and parent to the
437 struct gdb_block
*next
, *parent
;
439 /* Points to the "real" block that is being built out of this
440 instance. This block will be added to a blockvector, which will
441 then be added to a symtab. */
442 struct block
*real_block
;
444 /* The first and last code address corresponding to this block. */
445 CORE_ADDR begin
, end
;
447 /* The name of this block (if any). If this is non-NULL, the
448 FUNCTION symbol symbol is set to this value. */
452 /* Proxy object for building a symtab. */
456 /* The list of blocks in this symtab. These will eventually be
457 converted to real blocks. */
458 struct gdb_block
*blocks
;
460 /* The number of blocks inserted. */
463 /* A mapping between line numbers to PC. */
464 struct linetable
*linetable
;
466 /* The source file for this symtab. */
467 const char *file_name
;
468 struct gdb_symtab
*next
;
471 /* Proxy object for building an object. */
475 struct gdb_symtab
*symtabs
;
478 /* The type of the `private' data passed around by the callback
481 typedef CORE_ADDR jit_dbg_reader_data
;
483 /* The reader calls into this function to read data off the targets
486 static enum gdb_status
487 jit_target_read_impl (GDB_CORE_ADDR target_mem
, void *gdb_buf
, int len
)
489 int result
= target_read_memory ((CORE_ADDR
) target_mem
, gdb_buf
, len
);
496 /* The reader calls into this function to create a new gdb_object
497 which it can then pass around to the other callbacks. Right now,
498 all that is required is allocating the memory. */
500 static struct gdb_object
*
501 jit_object_open_impl (struct gdb_symbol_callbacks
*cb
)
503 /* CB is not required right now, but sometime in the future we might
504 need a handle to it, and we'd like to do that without breaking
506 return XZALLOC (struct gdb_object
);
509 /* Readers call into this function to open a new gdb_symtab, which,
510 again, is passed around to other callbacks. */
512 static struct gdb_symtab
*
513 jit_symtab_open_impl (struct gdb_symbol_callbacks
*cb
,
514 struct gdb_object
*object
,
515 const char *file_name
)
517 struct gdb_symtab
*ret
;
519 /* CB stays unused. See comment in jit_object_open_impl. */
521 ret
= XZALLOC (struct gdb_symtab
);
522 ret
->file_name
= file_name
? xstrdup (file_name
) : xstrdup ("");
523 ret
->next
= object
->symtabs
;
524 object
->symtabs
= ret
;
528 /* Returns true if the block corresponding to old should be placed
529 before the block corresponding to new in the final blockvector. */
532 compare_block (const struct gdb_block
*const old
,
533 const struct gdb_block
*const new)
537 if (old
->begin
< new->begin
)
539 else if (old
->begin
== new->begin
)
541 if (old
->end
> new->end
)
550 /* Called by readers to open a new gdb_block. This function also
551 inserts the new gdb_block in the correct place in the corresponding
554 static struct gdb_block
*
555 jit_block_open_impl (struct gdb_symbol_callbacks
*cb
,
556 struct gdb_symtab
*symtab
, struct gdb_block
*parent
,
557 GDB_CORE_ADDR begin
, GDB_CORE_ADDR end
, const char *name
)
559 struct gdb_block
*block
= XZALLOC (struct gdb_block
);
561 block
->next
= symtab
->blocks
;
562 block
->begin
= (CORE_ADDR
) begin
;
563 block
->end
= (CORE_ADDR
) end
;
564 block
->name
= name
? xstrdup (name
) : NULL
;
565 block
->parent
= parent
;
567 /* Ensure that the blocks are inserted in the correct (reverse of
568 the order expected by blockvector). */
569 if (compare_block (symtab
->blocks
, block
))
571 symtab
->blocks
= block
;
575 struct gdb_block
*i
= symtab
->blocks
;
579 /* Guaranteed to terminate, since compare_block (NULL, _)
581 if (compare_block (i
->next
, block
))
583 block
->next
= i
->next
;
594 /* Readers call this to add a line mapping (from PC to line number) to
598 jit_symtab_line_mapping_add_impl (struct gdb_symbol_callbacks
*cb
,
599 struct gdb_symtab
*stab
, int nlines
,
600 struct gdb_line_mapping
*map
)
607 stab
->linetable
= xmalloc (sizeof (struct linetable
)
608 + (nlines
- 1) * sizeof (struct linetable_entry
));
609 stab
->linetable
->nitems
= nlines
;
610 for (i
= 0; i
< nlines
; i
++)
612 stab
->linetable
->item
[i
].pc
= (CORE_ADDR
) map
[i
].pc
;
613 stab
->linetable
->item
[i
].line
= map
[i
].line
;
617 /* Called by readers to close a gdb_symtab. Does not need to do
618 anything as of now. */
621 jit_symtab_close_impl (struct gdb_symbol_callbacks
*cb
,
622 struct gdb_symtab
*stab
)
624 /* Right now nothing needs to be done here. We may need to do some
625 cleanup here in the future (again, without breaking the plugin
629 /* Transform STAB to a proper symtab, and add it it OBJFILE. */
632 finalize_symtab (struct gdb_symtab
*stab
, struct objfile
*objfile
)
634 struct symtab
*symtab
;
635 struct gdb_block
*gdb_block_iter
, *gdb_block_iter_tmp
;
636 struct block
*block_iter
;
637 int actual_nblocks
, i
, blockvector_size
;
638 CORE_ADDR begin
, end
;
640 actual_nblocks
= FIRST_LOCAL_BLOCK
+ stab
->nblocks
;
642 symtab
= allocate_symtab (stab
->file_name
, objfile
);
643 /* JIT compilers compile in memory. */
644 symtab
->dirname
= NULL
;
646 /* Copy over the linetable entry if one was provided. */
649 int size
= ((stab
->linetable
->nitems
- 1)
650 * sizeof (struct linetable_entry
)
651 + sizeof (struct linetable
));
652 LINETABLE (symtab
) = obstack_alloc (&objfile
->objfile_obstack
, size
);
653 memcpy (LINETABLE (symtab
), stab
->linetable
, size
);
657 LINETABLE (symtab
) = NULL
;
660 blockvector_size
= (sizeof (struct blockvector
)
661 + (actual_nblocks
- 1) * sizeof (struct block
*));
662 symtab
->blockvector
= obstack_alloc (&objfile
->objfile_obstack
,
665 /* (begin, end) will contain the PC range this entire blockvector
668 BLOCKVECTOR_MAP (symtab
->blockvector
) = NULL
;
669 begin
= stab
->blocks
->begin
;
670 end
= stab
->blocks
->end
;
671 BLOCKVECTOR_NBLOCKS (symtab
->blockvector
) = actual_nblocks
;
673 /* First run over all the gdb_block objects, creating a real block
674 object for each. Simultaneously, keep setting the real_block
676 for (i
= (actual_nblocks
- 1), gdb_block_iter
= stab
->blocks
;
677 i
>= FIRST_LOCAL_BLOCK
;
678 i
--, gdb_block_iter
= gdb_block_iter
->next
)
680 struct block
*new_block
= allocate_block (&objfile
->objfile_obstack
);
681 struct symbol
*block_name
= obstack_alloc (&objfile
->objfile_obstack
,
682 sizeof (struct symbol
));
683 struct type
*block_type
= arch_type (get_objfile_arch (objfile
),
688 BLOCK_DICT (new_block
) = dict_create_linear (&objfile
->objfile_obstack
,
690 /* The address range. */
691 BLOCK_START (new_block
) = (CORE_ADDR
) gdb_block_iter
->begin
;
692 BLOCK_END (new_block
) = (CORE_ADDR
) gdb_block_iter
->end
;
695 memset (block_name
, 0, sizeof (struct symbol
));
696 SYMBOL_DOMAIN (block_name
) = VAR_DOMAIN
;
697 SYMBOL_CLASS (block_name
) = LOC_BLOCK
;
698 SYMBOL_SYMTAB (block_name
) = symtab
;
699 SYMBOL_TYPE (block_name
) = lookup_function_type (block_type
);
700 SYMBOL_BLOCK_VALUE (block_name
) = new_block
;
702 block_name
->ginfo
.name
= obstack_copy0 (&objfile
->objfile_obstack
,
703 gdb_block_iter
->name
,
704 strlen (gdb_block_iter
->name
));
706 BLOCK_FUNCTION (new_block
) = block_name
;
708 BLOCKVECTOR_BLOCK (symtab
->blockvector
, i
) = new_block
;
709 if (begin
> BLOCK_START (new_block
))
710 begin
= BLOCK_START (new_block
);
711 if (end
< BLOCK_END (new_block
))
712 end
= BLOCK_END (new_block
);
714 gdb_block_iter
->real_block
= new_block
;
717 /* Now add the special blocks. */
719 for (i
= 0; i
< FIRST_LOCAL_BLOCK
; i
++)
721 struct block
*new_block
;
723 new_block
= (i
== GLOBAL_BLOCK
724 ? allocate_global_block (&objfile
->objfile_obstack
)
725 : allocate_block (&objfile
->objfile_obstack
));
726 BLOCK_DICT (new_block
) = dict_create_linear (&objfile
->objfile_obstack
,
728 BLOCK_SUPERBLOCK (new_block
) = block_iter
;
729 block_iter
= new_block
;
731 BLOCK_START (new_block
) = (CORE_ADDR
) begin
;
732 BLOCK_END (new_block
) = (CORE_ADDR
) end
;
734 BLOCKVECTOR_BLOCK (symtab
->blockvector
, i
) = new_block
;
736 if (i
== GLOBAL_BLOCK
)
737 set_block_symtab (new_block
, symtab
);
740 /* Fill up the superblock fields for the real blocks, using the
741 real_block fields populated earlier. */
742 for (gdb_block_iter
= stab
->blocks
;
744 gdb_block_iter
= gdb_block_iter
->next
)
746 if (gdb_block_iter
->parent
!= NULL
)
748 /* If the plugin specifically mentioned a parent block, we
750 BLOCK_SUPERBLOCK (gdb_block_iter
->real_block
) =
751 gdb_block_iter
->parent
->real_block
;
755 /* And if not, we set a default parent block. */
756 BLOCK_SUPERBLOCK (gdb_block_iter
->real_block
) =
757 BLOCKVECTOR_BLOCK (symtab
->blockvector
, STATIC_BLOCK
);
762 gdb_block_iter
= stab
->blocks
;
764 for (gdb_block_iter
= stab
->blocks
, gdb_block_iter_tmp
= gdb_block_iter
->next
;
766 gdb_block_iter
= gdb_block_iter_tmp
)
768 xfree ((void *) gdb_block_iter
->name
);
769 xfree (gdb_block_iter
);
771 xfree (stab
->linetable
);
772 xfree ((char *) stab
->file_name
);
776 /* Called when closing a gdb_objfile. Converts OBJ to a proper
780 jit_object_close_impl (struct gdb_symbol_callbacks
*cb
,
781 struct gdb_object
*obj
)
783 struct gdb_symtab
*i
, *j
;
784 struct objfile
*objfile
;
785 jit_dbg_reader_data
*priv_data
;
787 priv_data
= cb
->priv_data
;
789 objfile
= allocate_objfile (NULL
, 0);
790 objfile
->gdbarch
= target_gdbarch ();
792 terminate_minimal_symbol_table (objfile
);
794 objfile
->name
= "<< JIT compiled code >>";
797 for (i
= obj
->symtabs
; i
; i
= j
)
800 finalize_symtab (i
, objfile
);
802 add_objfile_entry (objfile
, *priv_data
);
806 /* Try to read CODE_ENTRY using the loaded jit reader (if any).
807 ENTRY_ADDR is the address of the struct jit_code_entry in the
808 inferior address space. */
811 jit_reader_try_read_symtab (struct jit_code_entry
*code_entry
,
812 CORE_ADDR entry_addr
)
816 jit_dbg_reader_data priv_data
;
817 struct gdb_reader_funcs
*funcs
;
818 volatile struct gdb_exception e
;
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
);
841 TRY_CATCH (e
, RETURN_MASK_ALL
)
842 if (target_read_memory (code_entry
->symfile_addr
, gdb_mem
,
843 code_entry
->symfile_size
))
850 funcs
= loaded_jit_reader
->functions
;
851 if (funcs
->read (funcs
, &callbacks
, gdb_mem
, code_entry
->symfile_size
)
857 if (jit_debug
&& status
== 0)
858 fprintf_unfiltered (gdb_stdlog
,
859 "Could not read symtab using the loaded JIT reader.\n");
863 /* Try to read CODE_ENTRY using BFD. ENTRY_ADDR is the address of the
864 struct jit_code_entry in the inferior address space. */
867 jit_bfd_try_read_symtab (struct jit_code_entry
*code_entry
,
868 CORE_ADDR entry_addr
,
869 struct gdbarch
*gdbarch
)
872 struct section_addr_info
*sai
;
873 struct bfd_section
*sec
;
874 struct objfile
*objfile
;
875 struct cleanup
*old_cleanups
;
877 const struct bfd_arch_info
*b
;
880 fprintf_unfiltered (gdb_stdlog
,
881 "jit_register_code, symfile_addr = %s, "
882 "symfile_size = %s\n",
883 paddress (gdbarch
, code_entry
->symfile_addr
),
884 pulongest (code_entry
->symfile_size
));
886 nbfd
= bfd_open_from_target_memory (code_entry
->symfile_addr
,
887 code_entry
->symfile_size
, gnutarget
);
890 puts_unfiltered (_("Error opening JITed symbol file, ignoring it.\n"));
894 /* Check the format. NOTE: This initializes important data that GDB uses!
895 We would segfault later without this line. */
896 if (!bfd_check_format (nbfd
, bfd_object
))
898 printf_unfiltered (_("\
899 JITed symbol file is not an object file, ignoring it.\n"));
900 gdb_bfd_unref (nbfd
);
904 /* Check bfd arch. */
905 b
= gdbarch_bfd_arch_info (gdbarch
);
906 if (b
->compatible (b
, bfd_get_arch_info (nbfd
)) != b
)
907 warning (_("JITed object file architecture %s is not compatible "
908 "with target architecture %s."), bfd_get_arch_info
909 (nbfd
)->printable_name
, b
->printable_name
);
911 /* Read the section address information out of the symbol file. Since the
912 file is generated by the JIT at runtime, it should all of the absolute
913 addresses that we care about. */
914 sai
= alloc_section_addr_info (bfd_count_sections (nbfd
));
915 old_cleanups
= make_cleanup_free_section_addr_info (sai
);
917 for (sec
= nbfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
918 if ((bfd_get_section_flags (nbfd
, sec
) & (SEC_ALLOC
|SEC_LOAD
)) != 0)
920 /* We assume that these virtual addresses are absolute, and do not
921 treat them as offsets. */
922 sai
->other
[i
].addr
= bfd_get_section_vma (nbfd
, sec
);
923 sai
->other
[i
].name
= xstrdup (bfd_get_section_name (nbfd
, sec
));
924 sai
->other
[i
].sectindex
= sec
->index
;
928 /* This call does not take ownership of SAI. */
929 make_cleanup_bfd_unref (nbfd
);
930 objfile
= symbol_file_add_from_bfd (nbfd
, 0, sai
, OBJF_SHARED
, NULL
);
932 do_cleanups (old_cleanups
);
933 add_objfile_entry (objfile
, entry_addr
);
936 /* This function registers code associated with a JIT code entry. It uses the
937 pointer and size pair in the entry to read the symbol file from the remote
938 and then calls symbol_file_add_from_local_memory to add it as though it were
939 a symbol file added by the user. */
942 jit_register_code (struct gdbarch
*gdbarch
,
943 CORE_ADDR entry_addr
, struct jit_code_entry
*code_entry
)
948 fprintf_unfiltered (gdb_stdlog
,
949 "jit_register_code, symfile_addr = %s, "
950 "symfile_size = %s\n",
951 paddress (gdbarch
, code_entry
->symfile_addr
),
952 pulongest (code_entry
->symfile_size
));
954 success
= jit_reader_try_read_symtab (code_entry
, entry_addr
);
957 jit_bfd_try_read_symtab (code_entry
, entry_addr
, gdbarch
);
960 /* This function unregisters JITed code and frees the corresponding
964 jit_unregister_code (struct objfile
*objfile
)
966 free_objfile (objfile
);
969 /* Look up the objfile with this code entry address. */
971 static struct objfile
*
972 jit_find_objf_with_entry_addr (CORE_ADDR entry_addr
)
974 struct objfile
*objf
;
978 struct jit_objfile_data
*objf_data
;
980 objf_data
= objfile_data (objf
, jit_objfile_data
);
981 if (objf_data
!= NULL
&& objf_data
->addr
== entry_addr
)
987 /* A callback for iterate_over_inferiors that updates the inferior's
988 JIT breakpoint information, if necessary. */
991 jit_update_inferior_cache (struct inferior
*inf
, void *data
)
993 struct bp_location
*loc
= data
;
995 if (inf
->pspace
== loc
->pspace
)
997 struct jit_inferior_data
*inf_data
;
999 inf_data
= inferior_data (inf
, jit_inferior_data
);
1000 if (inf_data
!= NULL
&& inf_data
->jit_breakpoint
== loc
->owner
)
1002 inf_data
->cached_code_address
= 0;
1003 inf_data
->jit_breakpoint
= NULL
;
1010 /* This is called when a breakpoint is deleted. It updates the
1011 inferior's cache, if needed. */
1014 jit_breakpoint_deleted (struct breakpoint
*b
)
1016 struct bp_location
*iter
;
1018 if (b
->type
!= bp_jit_event
)
1021 for (iter
= b
->loc
; iter
!= NULL
; iter
= iter
->next
)
1022 iterate_over_inferiors (jit_update_inferior_cache
, iter
);
1025 /* (Re-)Initialize the jit breakpoint if necessary.
1026 Return 0 on success. */
1029 jit_breakpoint_re_set_internal (struct gdbarch
*gdbarch
,
1030 struct jit_inferior_data
*inf_data
)
1032 struct minimal_symbol
*reg_symbol
, *desc_symbol
;
1033 struct objfile
*objf
;
1034 struct jit_objfile_data
*objf_data
;
1037 if (inf_data
->objfile
== NULL
)
1039 /* Lookup the registration symbol. If it is missing, then we
1040 assume we are not attached to a JIT. */
1041 reg_symbol
= lookup_minimal_symbol_and_objfile (jit_break_name
, &objf
);
1042 if (reg_symbol
== NULL
|| SYMBOL_VALUE_ADDRESS (reg_symbol
) == 0)
1045 desc_symbol
= lookup_minimal_symbol (jit_descriptor_name
, NULL
, objf
);
1046 if (desc_symbol
== NULL
|| SYMBOL_VALUE_ADDRESS (desc_symbol
) == 0)
1049 objf_data
= get_jit_objfile_data (objf
);
1050 objf_data
->register_code
= reg_symbol
;
1051 objf_data
->descriptor
= desc_symbol
;
1053 inf_data
->objfile
= objf
;
1056 objf_data
= get_jit_objfile_data (inf_data
->objfile
);
1058 addr
= SYMBOL_VALUE_ADDRESS (objf_data
->register_code
);
1061 fprintf_unfiltered (gdb_stdlog
,
1062 "jit_breakpoint_re_set_internal, "
1063 "breakpoint_addr = %s\n",
1064 paddress (gdbarch
, addr
));
1066 if (inf_data
->cached_code_address
== addr
)
1069 /* Delete the old breakpoint. */
1070 if (inf_data
->jit_breakpoint
!= NULL
)
1071 delete_breakpoint (inf_data
->jit_breakpoint
);
1073 /* Put a breakpoint in the registration symbol. */
1074 inf_data
->cached_code_address
= addr
;
1075 inf_data
->jit_breakpoint
= create_jit_event_breakpoint (gdbarch
, addr
);
1080 /* The private data passed around in the frame unwind callback
1083 struct jit_unwind_private
1085 /* Cached register values. See jit_frame_sniffer to see how this
1087 struct gdb_reg_value
**registers
;
1089 /* The frame being unwound. */
1090 struct frame_info
*this_frame
;
1093 /* Sets the value of a particular register in this frame. */
1096 jit_unwind_reg_set_impl (struct gdb_unwind_callbacks
*cb
, int dwarf_regnum
,
1097 struct gdb_reg_value
*value
)
1099 struct jit_unwind_private
*priv
;
1102 priv
= cb
->priv_data
;
1104 gdb_reg
= gdbarch_dwarf2_reg_to_regnum (get_frame_arch (priv
->this_frame
),
1109 fprintf_unfiltered (gdb_stdlog
,
1110 _("Could not recognize DWARF regnum %d"),
1115 gdb_assert (priv
->registers
);
1116 priv
->registers
[gdb_reg
] = value
;
1120 reg_value_free_impl (struct gdb_reg_value
*value
)
1125 /* Get the value of register REGNUM in the previous frame. */
1127 static struct gdb_reg_value
*
1128 jit_unwind_reg_get_impl (struct gdb_unwind_callbacks
*cb
, int regnum
)
1130 struct jit_unwind_private
*priv
;
1131 struct gdb_reg_value
*value
;
1133 struct gdbarch
*frame_arch
;
1135 priv
= cb
->priv_data
;
1136 frame_arch
= get_frame_arch (priv
->this_frame
);
1138 gdb_reg
= gdbarch_dwarf2_reg_to_regnum (frame_arch
, regnum
);
1139 size
= register_size (frame_arch
, gdb_reg
);
1140 value
= xmalloc (sizeof (struct gdb_reg_value
) + size
- 1);
1141 value
->defined
= deprecated_frame_register_read (priv
->this_frame
, gdb_reg
,
1144 value
->free
= reg_value_free_impl
;
1148 /* gdb_reg_value has a free function, which must be called on each
1149 saved register value. */
1152 jit_dealloc_cache (struct frame_info
*this_frame
, void *cache
)
1154 struct jit_unwind_private
*priv_data
= cache
;
1155 struct gdbarch
*frame_arch
;
1158 gdb_assert (priv_data
->registers
);
1159 frame_arch
= get_frame_arch (priv_data
->this_frame
);
1161 for (i
= 0; i
< gdbarch_num_regs (frame_arch
); i
++)
1162 if (priv_data
->registers
[i
] && priv_data
->registers
[i
]->free
)
1163 priv_data
->registers
[i
]->free (priv_data
->registers
[i
]);
1165 xfree (priv_data
->registers
);
1169 /* The frame sniffer for the pseudo unwinder.
1171 While this is nominally a frame sniffer, in the case where the JIT
1172 reader actually recognizes the frame, it does a lot more work -- it
1173 unwinds the frame and saves the corresponding register values in
1174 the cache. jit_frame_prev_register simply returns the saved
1178 jit_frame_sniffer (const struct frame_unwind
*self
,
1179 struct frame_info
*this_frame
, void **cache
)
1181 struct jit_unwind_private
*priv_data
;
1182 struct gdb_unwind_callbacks callbacks
;
1183 struct gdb_reader_funcs
*funcs
;
1185 callbacks
.reg_get
= jit_unwind_reg_get_impl
;
1186 callbacks
.reg_set
= jit_unwind_reg_set_impl
;
1187 callbacks
.target_read
= jit_target_read_impl
;
1189 if (loaded_jit_reader
== NULL
)
1192 funcs
= loaded_jit_reader
->functions
;
1194 gdb_assert (!*cache
);
1196 *cache
= XZALLOC (struct jit_unwind_private
);
1198 priv_data
->registers
=
1199 XCALLOC (gdbarch_num_regs (get_frame_arch (this_frame
)),
1200 struct gdb_reg_value
*);
1201 priv_data
->this_frame
= this_frame
;
1203 callbacks
.priv_data
= priv_data
;
1205 /* Try to coax the provided unwinder to unwind the stack */
1206 if (funcs
->unwind (funcs
, &callbacks
) == GDB_SUCCESS
)
1209 fprintf_unfiltered (gdb_stdlog
, _("Successfully unwound frame using "
1214 fprintf_unfiltered (gdb_stdlog
, _("Could not unwind frame using "
1217 jit_dealloc_cache (this_frame
, *cache
);
1224 /* The frame_id function for the pseudo unwinder. Relays the call to
1225 the loaded plugin. */
1228 jit_frame_this_id (struct frame_info
*this_frame
, void **cache
,
1229 struct frame_id
*this_id
)
1231 struct jit_unwind_private
private;
1232 struct gdb_frame_id frame_id
;
1233 struct gdb_reader_funcs
*funcs
;
1234 struct gdb_unwind_callbacks callbacks
;
1236 private.registers
= NULL
;
1237 private.this_frame
= this_frame
;
1239 /* We don't expect the frame_id function to set any registers, so we
1240 set reg_set to NULL. */
1241 callbacks
.reg_get
= jit_unwind_reg_get_impl
;
1242 callbacks
.reg_set
= NULL
;
1243 callbacks
.target_read
= jit_target_read_impl
;
1244 callbacks
.priv_data
= &private;
1246 gdb_assert (loaded_jit_reader
);
1247 funcs
= loaded_jit_reader
->functions
;
1249 frame_id
= funcs
->get_frame_id (funcs
, &callbacks
);
1250 *this_id
= frame_id_build (frame_id
.stack_address
, frame_id
.code_address
);
1253 /* Pseudo unwinder function. Reads the previously fetched value for
1254 the register from the cache. */
1256 static struct value
*
1257 jit_frame_prev_register (struct frame_info
*this_frame
, void **cache
, int reg
)
1259 struct jit_unwind_private
*priv
= *cache
;
1260 struct gdb_reg_value
*value
;
1263 return frame_unwind_got_optimized (this_frame
, reg
);
1265 gdb_assert (priv
->registers
);
1266 value
= priv
->registers
[reg
];
1267 if (value
&& value
->defined
)
1268 return frame_unwind_got_bytes (this_frame
, reg
, value
->value
);
1270 return frame_unwind_got_optimized (this_frame
, reg
);
1273 /* Relay everything back to the unwinder registered by the JIT debug
1276 static const struct frame_unwind jit_frame_unwind
=
1279 default_frame_unwind_stop_reason
,
1281 jit_frame_prev_register
,
1288 /* This is the information that is stored at jit_gdbarch_data for each
1291 struct jit_gdbarch_data_type
1293 /* Has the (pseudo) unwinder been prepended? */
1294 int unwinder_registered
;
1297 /* Check GDBARCH and prepend the pseudo JIT unwinder if needed. */
1300 jit_prepend_unwinder (struct gdbarch
*gdbarch
)
1302 struct jit_gdbarch_data_type
*data
;
1304 data
= gdbarch_data (gdbarch
, jit_gdbarch_data
);
1305 if (!data
->unwinder_registered
)
1307 frame_unwind_prepend_unwinder (gdbarch
, &jit_frame_unwind
);
1308 data
->unwinder_registered
= 1;
1312 /* Register any already created translations. */
1315 jit_inferior_init (struct gdbarch
*gdbarch
)
1317 struct jit_descriptor descriptor
;
1318 struct jit_code_entry cur_entry
;
1319 struct jit_inferior_data
*inf_data
;
1320 CORE_ADDR cur_entry_addr
;
1323 fprintf_unfiltered (gdb_stdlog
, "jit_inferior_init\n");
1325 jit_prepend_unwinder (gdbarch
);
1327 inf_data
= get_jit_inferior_data ();
1328 if (jit_breakpoint_re_set_internal (gdbarch
, inf_data
) != 0)
1331 /* Read the descriptor so we can check the version number and load
1332 any already JITed functions. */
1333 if (!jit_read_descriptor (gdbarch
, &descriptor
, inf_data
))
1336 /* Check that the version number agrees with that we support. */
1337 if (descriptor
.version
!= 1)
1339 printf_unfiltered (_("Unsupported JIT protocol version %ld "
1340 "in descriptor (expected 1)\n"),
1341 (long) descriptor
.version
);
1345 /* If we've attached to a running program, we need to check the descriptor
1346 to register any functions that were already generated. */
1347 for (cur_entry_addr
= descriptor
.first_entry
;
1348 cur_entry_addr
!= 0;
1349 cur_entry_addr
= cur_entry
.next_entry
)
1351 jit_read_code_entry (gdbarch
, cur_entry_addr
, &cur_entry
);
1353 /* This hook may be called many times during setup, so make sure we don't
1354 add the same symbol file twice. */
1355 if (jit_find_objf_with_entry_addr (cur_entry_addr
) != NULL
)
1358 jit_register_code (gdbarch
, cur_entry_addr
, &cur_entry
);
1362 /* Exported routine to call when an inferior has been created. */
1365 jit_inferior_created_hook (void)
1367 jit_inferior_init (target_gdbarch ());
1370 /* Exported routine to call to re-set the jit breakpoints,
1371 e.g. when a program is rerun. */
1374 jit_breakpoint_re_set (void)
1376 jit_breakpoint_re_set_internal (target_gdbarch (),
1377 get_jit_inferior_data ());
1380 /* This function cleans up any code entries left over when the
1381 inferior exits. We get left over code when the inferior exits
1382 without unregistering its code, for example when it crashes. */
1385 jit_inferior_exit_hook (struct inferior
*inf
)
1387 struct objfile
*objf
;
1388 struct objfile
*temp
;
1390 ALL_OBJFILES_SAFE (objf
, temp
)
1392 struct jit_objfile_data
*objf_data
= objfile_data (objf
,
1395 if (objf_data
!= NULL
&& objf_data
->addr
!= 0)
1396 jit_unregister_code (objf
);
1401 jit_event_handler (struct gdbarch
*gdbarch
)
1403 struct jit_descriptor descriptor
;
1404 struct jit_code_entry code_entry
;
1405 CORE_ADDR entry_addr
;
1406 struct objfile
*objf
;
1408 /* Read the descriptor from remote memory. */
1409 if (!jit_read_descriptor (gdbarch
, &descriptor
, get_jit_inferior_data ()))
1411 entry_addr
= descriptor
.relevant_entry
;
1413 /* Do the corresponding action. */
1414 switch (descriptor
.action_flag
)
1419 jit_read_code_entry (gdbarch
, entry_addr
, &code_entry
);
1420 jit_register_code (gdbarch
, entry_addr
, &code_entry
);
1422 case JIT_UNREGISTER
:
1423 objf
= jit_find_objf_with_entry_addr (entry_addr
);
1425 printf_unfiltered (_("Unable to find JITed code "
1426 "entry at address: %s\n"),
1427 paddress (gdbarch
, entry_addr
));
1429 jit_unregister_code (objf
);
1433 error (_("Unknown action_flag value in JIT descriptor!"));
1438 /* Called to free the data allocated to the jit_inferior_data slot. */
1441 free_objfile_data (struct objfile
*objfile
, void *data
)
1443 struct jit_objfile_data
*objf_data
= data
;
1445 if (objf_data
->register_code
!= NULL
)
1447 struct jit_inferior_data
*inf_data
= get_jit_inferior_data ();
1449 if (inf_data
->objfile
== objfile
)
1450 inf_data
->objfile
= NULL
;
1456 /* Initialize the jit_gdbarch_data slot with an instance of struct
1457 jit_gdbarch_data_type */
1460 jit_gdbarch_data_init (struct obstack
*obstack
)
1462 struct jit_gdbarch_data_type
*data
;
1464 data
= obstack_alloc (obstack
, sizeof (struct jit_gdbarch_data_type
));
1465 data
->unwinder_registered
= 0;
1469 /* Provide a prototype to silence -Wmissing-prototypes. */
1471 extern void _initialize_jit (void);
1474 _initialize_jit (void)
1476 jit_reader_dir
= relocate_gdb_directory (JIT_READER_DIR
,
1477 JIT_READER_DIR_RELOCATABLE
);
1478 add_setshow_zuinteger_cmd ("jit", class_maintenance
, &jit_debug
,
1479 _("Set JIT debugging."),
1480 _("Show JIT debugging."),
1481 _("When non-zero, JIT debugging is enabled."),
1484 &setdebuglist
, &showdebuglist
);
1486 observer_attach_inferior_exit (jit_inferior_exit_hook
);
1487 observer_attach_breakpoint_deleted (jit_breakpoint_deleted
);
1490 register_objfile_data_with_cleanup (NULL
, free_objfile_data
);
1492 register_inferior_data_with_cleanup (NULL
, jit_inferior_data_cleanup
);
1493 jit_gdbarch_data
= gdbarch_data_register_pre_init (jit_gdbarch_data_init
);
1494 if (is_dl_available ())
1496 add_com ("jit-reader-load", no_class
, jit_reader_load_command
, _("\
1497 Load FILE as debug info reader and unwinder for JIT compiled code.\n\
1498 Usage: jit-reader-load FILE\n\
1499 Try to load file FILE as a debug info reader (and unwinder) for\n\
1500 JIT compiled code. The file is loaded from " JIT_READER_DIR
",\n\
1501 relocated relative to the GDB executable if required."));
1502 add_com ("jit-reader-unload", no_class
, jit_reader_unload_command
, _("\
1503 Unload the currently loaded JIT debug info reader.\n\
1504 Usage: jit-reader-unload FILE\n\n\
1505 Do \"help jit-reader-load\" for info on loading debug info readers."));