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 "frame-unwind.h"
38 #include "gdb-dlfcn.h"
40 #include "exceptions.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 inferior_data
*jit_inferior_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
)
95 /* For reading the file, we just need to pass through to target_read_memory and
96 fix up the arguments and return values. */
99 mem_bfd_iovec_pread (struct bfd
*abfd
, void *stream
, void *buf
,
100 file_ptr nbytes
, file_ptr offset
)
103 struct target_buffer
*buffer
= (struct target_buffer
*) stream
;
105 /* If this read will read all of the file, limit it to just the rest. */
106 if (offset
+ nbytes
> buffer
->size
)
107 nbytes
= buffer
->size
- offset
;
109 /* If there are no more bytes left, we've reached EOF. */
113 err
= target_read_memory (buffer
->base
+ offset
, (gdb_byte
*) buf
, nbytes
);
120 /* For statting the file, we only support the st_size attribute. */
123 mem_bfd_iovec_stat (struct bfd
*abfd
, void *stream
, struct stat
*sb
)
125 struct target_buffer
*buffer
= (struct target_buffer
*) stream
;
127 sb
->st_size
= buffer
->size
;
131 /* Open a BFD from the target's memory. */
134 bfd_open_from_target_memory (CORE_ADDR addr
, ULONGEST size
, char *target
)
136 struct target_buffer
*buffer
= xmalloc (sizeof (struct target_buffer
));
140 return gdb_bfd_openr_iovec ("<in-memory>", 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
)
203 struct cleanup
*prev_cleanup
;
206 error (_("No reader name provided."));
208 if (loaded_jit_reader
!= NULL
)
209 error (_("JIT reader already loaded. Run jit-reader-unload first."));
211 so_name
= xstrprintf ("%s/%s", jit_reader_dir
, args
);
212 prev_cleanup
= make_cleanup (xfree
, so_name
);
214 loaded_jit_reader
= jit_reader_load (so_name
);
215 do_cleanups (prev_cleanup
);
218 /* Provides the jit-reader-unload command. */
221 jit_reader_unload_command (char *args
, int from_tty
)
223 if (!loaded_jit_reader
)
224 error (_("No JIT reader loaded."));
226 loaded_jit_reader
->functions
->destroy (loaded_jit_reader
->functions
);
228 gdb_dlclose (loaded_jit_reader
->handle
);
229 xfree (loaded_jit_reader
);
230 loaded_jit_reader
= NULL
;
233 /* Per-inferior structure recording which objfile has the JIT
236 struct jit_inferior_data
238 /* The objfile. This is NULL if no objfile holds the JIT
241 struct objfile
*objfile
;
244 /* Per-objfile structure recording the addresses in the inferior. */
246 struct jit_objfile_data
248 /* Symbol for __jit_debug_register_code. */
249 struct minimal_symbol
*register_code
;
251 /* Symbol for __jit_debug_descriptor. */
252 struct minimal_symbol
*descriptor
;
254 /* Address of struct jit_code_entry in this objfile. */
258 /* Fetch the jit_objfile_data associated with OBJF. If no data exists
259 yet, make a new structure and attach it. */
261 static struct jit_objfile_data
*
262 get_jit_objfile_data (struct objfile
*objf
)
264 struct jit_objfile_data
*objf_data
;
266 objf_data
= objfile_data (objf
, jit_objfile_data
);
267 if (objf_data
== NULL
)
269 objf_data
= XZALLOC (struct jit_objfile_data
);
270 set_objfile_data (objf
, jit_objfile_data
, objf_data
);
276 /* Remember OBJFILE has been created for struct jit_code_entry located
277 at inferior address ENTRY. */
280 add_objfile_entry (struct objfile
*objfile
, CORE_ADDR entry
)
282 struct jit_objfile_data
*objf_data
;
284 objf_data
= get_jit_objfile_data (objfile
);
285 objf_data
->addr
= entry
;
288 /* Return jit_inferior_data for current inferior. Allocate if not already
291 static struct jit_inferior_data
*
292 get_jit_inferior_data (void)
294 struct inferior
*inf
;
295 struct jit_inferior_data
*inf_data
;
297 inf
= current_inferior ();
298 inf_data
= inferior_data (inf
, jit_inferior_data
);
299 if (inf_data
== NULL
)
301 inf_data
= XZALLOC (struct jit_inferior_data
);
302 set_inferior_data (inf
, jit_inferior_data
, inf_data
);
309 jit_inferior_data_cleanup (struct inferior
*inf
, void *arg
)
314 /* Helper function for reading the global JIT descriptor from remote
315 memory. Returns 1 if all went well, 0 otherwise. */
318 jit_read_descriptor (struct gdbarch
*gdbarch
,
319 struct jit_descriptor
*descriptor
,
320 struct jit_inferior_data
*inf_data
)
323 struct type
*ptr_type
;
327 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
328 struct jit_objfile_data
*objf_data
;
330 if (inf_data
->objfile
== NULL
)
332 objf_data
= get_jit_objfile_data (inf_data
->objfile
);
333 if (objf_data
->descriptor
== NULL
)
337 fprintf_unfiltered (gdb_stdlog
,
338 "jit_read_descriptor, descriptor_addr = %s\n",
339 paddress (gdbarch
, SYMBOL_VALUE_ADDRESS (objf_data
->descriptor
)));
341 /* Figure out how big the descriptor is on the remote and how to read it. */
342 ptr_type
= builtin_type (gdbarch
)->builtin_data_ptr
;
343 ptr_size
= TYPE_LENGTH (ptr_type
);
344 desc_size
= 8 + 2 * ptr_size
; /* Two 32-bit ints and two pointers. */
345 desc_buf
= alloca (desc_size
);
347 /* Read the descriptor. */
348 err
= target_read_memory (SYMBOL_VALUE_ADDRESS (objf_data
->descriptor
),
349 desc_buf
, desc_size
);
352 printf_unfiltered (_("Unable to read JIT descriptor from "
357 /* Fix the endianness to match the host. */
358 descriptor
->version
= extract_unsigned_integer (&desc_buf
[0], 4, byte_order
);
359 descriptor
->action_flag
=
360 extract_unsigned_integer (&desc_buf
[4], 4, byte_order
);
361 descriptor
->relevant_entry
= extract_typed_address (&desc_buf
[8], ptr_type
);
362 descriptor
->first_entry
=
363 extract_typed_address (&desc_buf
[8 + ptr_size
], ptr_type
);
368 /* Helper function for reading a JITed code entry from remote memory. */
371 jit_read_code_entry (struct gdbarch
*gdbarch
,
372 CORE_ADDR code_addr
, struct jit_code_entry
*code_entry
)
375 struct type
*ptr_type
;
380 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
382 /* Figure out how big the entry is on the remote and how to read it. */
383 ptr_type
= builtin_type (gdbarch
)->builtin_data_ptr
;
384 ptr_size
= TYPE_LENGTH (ptr_type
);
386 /* Figure out where the longlong value will be. */
387 align_bytes
= gdbarch_long_long_align_bit (gdbarch
) / 8;
389 off
= (off
+ (align_bytes
- 1)) & ~(align_bytes
- 1);
391 entry_size
= off
+ 8; /* Three pointers and one 64-bit int. */
392 entry_buf
= alloca (entry_size
);
394 /* Read the entry. */
395 err
= target_read_memory (code_addr
, entry_buf
, entry_size
);
397 error (_("Unable to read JIT code entry from remote memory!"));
399 /* Fix the endianness to match the host. */
400 ptr_type
= builtin_type (gdbarch
)->builtin_data_ptr
;
401 code_entry
->next_entry
= extract_typed_address (&entry_buf
[0], ptr_type
);
402 code_entry
->prev_entry
=
403 extract_typed_address (&entry_buf
[ptr_size
], ptr_type
);
404 code_entry
->symfile_addr
=
405 extract_typed_address (&entry_buf
[2 * ptr_size
], ptr_type
);
406 code_entry
->symfile_size
=
407 extract_unsigned_integer (&entry_buf
[off
], 8, byte_order
);
410 /* Proxy object for building a block. */
414 /* gdb_blocks are linked into a tree structure. Next points to the
415 next node at the same depth as this block and parent to the
417 struct gdb_block
*next
, *parent
;
419 /* Points to the "real" block that is being built out of this
420 instance. This block will be added to a blockvector, which will
421 then be added to a symtab. */
422 struct block
*real_block
;
424 /* The first and last code address corresponding to this block. */
425 CORE_ADDR begin
, end
;
427 /* The name of this block (if any). If this is non-NULL, the
428 FUNCTION symbol symbol is set to this value. */
432 /* Proxy object for building a symtab. */
436 /* The list of blocks in this symtab. These will eventually be
437 converted to real blocks. */
438 struct gdb_block
*blocks
;
440 /* The number of blocks inserted. */
443 /* A mapping between line numbers to PC. */
444 struct linetable
*linetable
;
446 /* The source file for this symtab. */
447 const char *file_name
;
448 struct gdb_symtab
*next
;
451 /* Proxy object for building an object. */
455 struct gdb_symtab
*symtabs
;
458 /* The type of the `private' data passed around by the callback
461 typedef CORE_ADDR jit_dbg_reader_data
;
463 /* The reader calls into this function to read data off the targets
466 static enum gdb_status
467 jit_target_read_impl (GDB_CORE_ADDR target_mem
, void *gdb_buf
, int len
)
469 int result
= target_read_memory ((CORE_ADDR
) target_mem
, gdb_buf
, len
);
476 /* The reader calls into this function to create a new gdb_object
477 which it can then pass around to the other callbacks. Right now,
478 all that is required is allocating the memory. */
480 static struct gdb_object
*
481 jit_object_open_impl (struct gdb_symbol_callbacks
*cb
)
483 /* CB is not required right now, but sometime in the future we might
484 need a handle to it, and we'd like to do that without breaking
486 return XZALLOC (struct gdb_object
);
489 /* Readers call into this function to open a new gdb_symtab, which,
490 again, is passed around to other callbacks. */
492 static struct gdb_symtab
*
493 jit_symtab_open_impl (struct gdb_symbol_callbacks
*cb
,
494 struct gdb_object
*object
,
495 const char *file_name
)
497 struct gdb_symtab
*ret
;
499 /* CB stays unused. See comment in jit_object_open_impl. */
501 ret
= XZALLOC (struct gdb_symtab
);
502 ret
->file_name
= file_name
? xstrdup (file_name
) : xstrdup ("");
503 ret
->next
= object
->symtabs
;
504 object
->symtabs
= ret
;
508 /* Returns true if the block corresponding to old should be placed
509 before the block corresponding to new in the final blockvector. */
512 compare_block (const struct gdb_block
*const old
,
513 const struct gdb_block
*const new)
517 if (old
->begin
< new->begin
)
519 else if (old
->begin
== new->begin
)
521 if (old
->end
> new->end
)
530 /* Called by readers to open a new gdb_block. This function also
531 inserts the new gdb_block in the correct place in the corresponding
534 static struct gdb_block
*
535 jit_block_open_impl (struct gdb_symbol_callbacks
*cb
,
536 struct gdb_symtab
*symtab
, struct gdb_block
*parent
,
537 GDB_CORE_ADDR begin
, GDB_CORE_ADDR end
, const char *name
)
539 struct gdb_block
*block
= XZALLOC (struct gdb_block
);
541 block
->next
= symtab
->blocks
;
542 block
->begin
= (CORE_ADDR
) begin
;
543 block
->end
= (CORE_ADDR
) end
;
544 block
->name
= name
? xstrdup (name
) : NULL
;
545 block
->parent
= parent
;
547 /* Ensure that the blocks are inserted in the correct (reverse of
548 the order expected by blockvector). */
549 if (compare_block (symtab
->blocks
, block
))
551 symtab
->blocks
= block
;
555 struct gdb_block
*i
= symtab
->blocks
;
559 /* Guaranteed to terminate, since compare_block (NULL, _)
561 if (compare_block (i
->next
, block
))
563 block
->next
= i
->next
;
574 /* Readers call this to add a line mapping (from PC to line number) to
578 jit_symtab_line_mapping_add_impl (struct gdb_symbol_callbacks
*cb
,
579 struct gdb_symtab
*stab
, int nlines
,
580 struct gdb_line_mapping
*map
)
587 stab
->linetable
= xmalloc (sizeof (struct linetable
)
588 + (nlines
- 1) * sizeof (struct linetable_entry
));
589 stab
->linetable
->nitems
= nlines
;
590 for (i
= 0; i
< nlines
; i
++)
592 stab
->linetable
->item
[i
].pc
= (CORE_ADDR
) map
[i
].pc
;
593 stab
->linetable
->item
[i
].line
= map
[i
].line
;
597 /* Called by readers to close a gdb_symtab. Does not need to do
598 anything as of now. */
601 jit_symtab_close_impl (struct gdb_symbol_callbacks
*cb
,
602 struct gdb_symtab
*stab
)
604 /* Right now nothing needs to be done here. We may need to do some
605 cleanup here in the future (again, without breaking the plugin
609 /* Transform STAB to a proper symtab, and add it it OBJFILE. */
612 finalize_symtab (struct gdb_symtab
*stab
, struct objfile
*objfile
)
614 struct symtab
*symtab
;
615 struct gdb_block
*gdb_block_iter
, *gdb_block_iter_tmp
;
616 struct block
*block_iter
;
617 int actual_nblocks
, i
, blockvector_size
;
618 CORE_ADDR begin
, end
;
620 actual_nblocks
= FIRST_LOCAL_BLOCK
+ stab
->nblocks
;
622 symtab
= allocate_symtab (stab
->file_name
, objfile
);
623 /* JIT compilers compile in memory. */
624 symtab
->dirname
= NULL
;
626 /* Copy over the linetable entry if one was provided. */
629 int size
= ((stab
->linetable
->nitems
- 1)
630 * sizeof (struct linetable_entry
)
631 + sizeof (struct linetable
));
632 LINETABLE (symtab
) = obstack_alloc (&objfile
->objfile_obstack
, size
);
633 memcpy (LINETABLE (symtab
), stab
->linetable
, size
);
637 LINETABLE (symtab
) = NULL
;
640 blockvector_size
= (sizeof (struct blockvector
)
641 + (actual_nblocks
- 1) * sizeof (struct block
*));
642 symtab
->blockvector
= obstack_alloc (&objfile
->objfile_obstack
,
645 /* (begin, end) will contain the PC range this entire blockvector
648 BLOCKVECTOR_MAP (symtab
->blockvector
) = NULL
;
649 begin
= stab
->blocks
->begin
;
650 end
= stab
->blocks
->end
;
651 BLOCKVECTOR_NBLOCKS (symtab
->blockvector
) = actual_nblocks
;
653 /* First run over all the gdb_block objects, creating a real block
654 object for each. Simultaneously, keep setting the real_block
656 for (i
= (actual_nblocks
- 1), gdb_block_iter
= stab
->blocks
;
657 i
>= FIRST_LOCAL_BLOCK
;
658 i
--, gdb_block_iter
= gdb_block_iter
->next
)
660 struct block
*new_block
= allocate_block (&objfile
->objfile_obstack
);
661 struct symbol
*block_name
= obstack_alloc (&objfile
->objfile_obstack
,
662 sizeof (struct symbol
));
663 struct type
*block_type
= arch_type (get_objfile_arch (objfile
),
668 BLOCK_DICT (new_block
) = dict_create_linear (&objfile
->objfile_obstack
,
670 /* The address range. */
671 BLOCK_START (new_block
) = (CORE_ADDR
) gdb_block_iter
->begin
;
672 BLOCK_END (new_block
) = (CORE_ADDR
) gdb_block_iter
->end
;
675 memset (block_name
, 0, sizeof (struct symbol
));
676 SYMBOL_DOMAIN (block_name
) = VAR_DOMAIN
;
677 SYMBOL_CLASS (block_name
) = LOC_BLOCK
;
678 SYMBOL_SYMTAB (block_name
) = symtab
;
679 SYMBOL_TYPE (block_name
) = lookup_function_type (block_type
);
680 SYMBOL_BLOCK_VALUE (block_name
) = new_block
;
682 block_name
->ginfo
.name
= obsavestring (gdb_block_iter
->name
,
683 strlen (gdb_block_iter
->name
),
684 &objfile
->objfile_obstack
);
686 BLOCK_FUNCTION (new_block
) = block_name
;
688 BLOCKVECTOR_BLOCK (symtab
->blockvector
, i
) = new_block
;
689 if (begin
> BLOCK_START (new_block
))
690 begin
= BLOCK_START (new_block
);
691 if (end
< BLOCK_END (new_block
))
692 end
= BLOCK_END (new_block
);
694 gdb_block_iter
->real_block
= new_block
;
697 /* Now add the special blocks. */
699 for (i
= 0; i
< FIRST_LOCAL_BLOCK
; i
++)
701 struct block
*new_block
;
703 new_block
= (i
== GLOBAL_BLOCK
704 ? allocate_global_block (&objfile
->objfile_obstack
)
705 : allocate_block (&objfile
->objfile_obstack
));
706 BLOCK_DICT (new_block
) = dict_create_linear (&objfile
->objfile_obstack
,
708 BLOCK_SUPERBLOCK (new_block
) = block_iter
;
709 block_iter
= new_block
;
711 BLOCK_START (new_block
) = (CORE_ADDR
) begin
;
712 BLOCK_END (new_block
) = (CORE_ADDR
) end
;
714 BLOCKVECTOR_BLOCK (symtab
->blockvector
, i
) = new_block
;
716 if (i
== GLOBAL_BLOCK
)
717 set_block_symtab (new_block
, symtab
);
720 /* Fill up the superblock fields for the real blocks, using the
721 real_block fields populated earlier. */
722 for (gdb_block_iter
= stab
->blocks
;
724 gdb_block_iter
= gdb_block_iter
->next
)
726 if (gdb_block_iter
->parent
!= NULL
)
728 /* If the plugin specifically mentioned a parent block, we
730 BLOCK_SUPERBLOCK (gdb_block_iter
->real_block
) =
731 gdb_block_iter
->parent
->real_block
;
735 /* And if not, we set a default parent block. */
736 BLOCK_SUPERBLOCK (gdb_block_iter
->real_block
) =
737 BLOCKVECTOR_BLOCK (symtab
->blockvector
, STATIC_BLOCK
);
742 gdb_block_iter
= stab
->blocks
;
744 for (gdb_block_iter
= stab
->blocks
, gdb_block_iter_tmp
= gdb_block_iter
->next
;
746 gdb_block_iter
= gdb_block_iter_tmp
)
748 xfree ((void *) gdb_block_iter
->name
);
749 xfree (gdb_block_iter
);
751 xfree (stab
->linetable
);
752 xfree ((char *) stab
->file_name
);
756 /* Called when closing a gdb_objfile. Converts OBJ to a proper
760 jit_object_close_impl (struct gdb_symbol_callbacks
*cb
,
761 struct gdb_object
*obj
)
763 struct gdb_symtab
*i
, *j
;
764 struct objfile
*objfile
;
765 jit_dbg_reader_data
*priv_data
;
767 priv_data
= cb
->priv_data
;
769 objfile
= allocate_objfile (NULL
, 0);
770 objfile
->gdbarch
= target_gdbarch ();
772 terminate_minimal_symbol_table (objfile
);
774 objfile
->name
= "<< JIT compiled code >>";
777 for (i
= obj
->symtabs
; i
; i
= j
)
780 finalize_symtab (i
, objfile
);
782 add_objfile_entry (objfile
, *priv_data
);
786 /* Try to read CODE_ENTRY using the loaded jit reader (if any).
787 ENTRY_ADDR is the address of the struct jit_code_entry in the
788 inferior address space. */
791 jit_reader_try_read_symtab (struct jit_code_entry
*code_entry
,
792 CORE_ADDR entry_addr
)
796 jit_dbg_reader_data priv_data
;
797 struct gdb_reader_funcs
*funcs
;
798 volatile struct gdb_exception e
;
799 struct gdb_symbol_callbacks callbacks
=
801 jit_object_open_impl
,
802 jit_symtab_open_impl
,
804 jit_symtab_close_impl
,
805 jit_object_close_impl
,
807 jit_symtab_line_mapping_add_impl
,
808 jit_target_read_impl
,
813 priv_data
= entry_addr
;
815 if (!loaded_jit_reader
)
818 gdb_mem
= xmalloc (code_entry
->symfile_size
);
821 TRY_CATCH (e
, RETURN_MASK_ALL
)
822 if (target_read_memory (code_entry
->symfile_addr
, gdb_mem
,
823 code_entry
->symfile_size
))
830 funcs
= loaded_jit_reader
->functions
;
831 if (funcs
->read (funcs
, &callbacks
, gdb_mem
, code_entry
->symfile_size
)
837 if (jit_debug
&& status
== 0)
838 fprintf_unfiltered (gdb_stdlog
,
839 "Could not read symtab using the loaded JIT reader.\n");
843 /* Try to read CODE_ENTRY using BFD. ENTRY_ADDR is the address of the
844 struct jit_code_entry in the inferior address space. */
847 jit_bfd_try_read_symtab (struct jit_code_entry
*code_entry
,
848 CORE_ADDR entry_addr
,
849 struct gdbarch
*gdbarch
)
852 struct section_addr_info
*sai
;
853 struct bfd_section
*sec
;
854 struct objfile
*objfile
;
855 struct cleanup
*old_cleanups
;
857 const struct bfd_arch_info
*b
;
860 fprintf_unfiltered (gdb_stdlog
,
861 "jit_register_code, symfile_addr = %s, "
862 "symfile_size = %s\n",
863 paddress (gdbarch
, code_entry
->symfile_addr
),
864 pulongest (code_entry
->symfile_size
));
866 nbfd
= bfd_open_from_target_memory (code_entry
->symfile_addr
,
867 code_entry
->symfile_size
, gnutarget
);
870 puts_unfiltered (_("Error opening JITed symbol file, ignoring it.\n"));
874 /* Check the format. NOTE: This initializes important data that GDB uses!
875 We would segfault later without this line. */
876 if (!bfd_check_format (nbfd
, bfd_object
))
878 printf_unfiltered (_("\
879 JITed symbol file is not an object file, ignoring it.\n"));
880 gdb_bfd_unref (nbfd
);
884 /* Check bfd arch. */
885 b
= gdbarch_bfd_arch_info (gdbarch
);
886 if (b
->compatible (b
, bfd_get_arch_info (nbfd
)) != b
)
887 warning (_("JITed object file architecture %s is not compatible "
888 "with target architecture %s."), bfd_get_arch_info
889 (nbfd
)->printable_name
, b
->printable_name
);
891 /* Read the section address information out of the symbol file. Since the
892 file is generated by the JIT at runtime, it should all of the absolute
893 addresses that we care about. */
894 sai
= alloc_section_addr_info (bfd_count_sections (nbfd
));
895 old_cleanups
= make_cleanup_free_section_addr_info (sai
);
897 for (sec
= nbfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
898 if ((bfd_get_section_flags (nbfd
, sec
) & (SEC_ALLOC
|SEC_LOAD
)) != 0)
900 /* We assume that these virtual addresses are absolute, and do not
901 treat them as offsets. */
902 sai
->other
[i
].addr
= bfd_get_section_vma (nbfd
, sec
);
903 sai
->other
[i
].name
= xstrdup (bfd_get_section_name (nbfd
, sec
));
904 sai
->other
[i
].sectindex
= sec
->index
;
908 /* This call does not take ownership of SAI. */
909 make_cleanup_bfd_unref (nbfd
);
910 objfile
= symbol_file_add_from_bfd (nbfd
, 0, sai
, OBJF_SHARED
, NULL
);
912 do_cleanups (old_cleanups
);
913 add_objfile_entry (objfile
, entry_addr
);
916 /* This function registers code associated with a JIT code entry. It uses the
917 pointer and size pair in the entry to read the symbol file from the remote
918 and then calls symbol_file_add_from_local_memory to add it as though it were
919 a symbol file added by the user. */
922 jit_register_code (struct gdbarch
*gdbarch
,
923 CORE_ADDR entry_addr
, struct jit_code_entry
*code_entry
)
926 const struct bfd_arch_info
*b
;
927 struct jit_inferior_data
*inf_data
= get_jit_inferior_data ();
930 fprintf_unfiltered (gdb_stdlog
,
931 "jit_register_code, symfile_addr = %s, "
932 "symfile_size = %s\n",
933 paddress (gdbarch
, code_entry
->symfile_addr
),
934 pulongest (code_entry
->symfile_size
));
936 success
= jit_reader_try_read_symtab (code_entry
, entry_addr
);
939 jit_bfd_try_read_symtab (code_entry
, entry_addr
, gdbarch
);
942 /* This function unregisters JITed code and frees the corresponding
946 jit_unregister_code (struct objfile
*objfile
)
948 free_objfile (objfile
);
951 /* Look up the objfile with this code entry address. */
953 static struct objfile
*
954 jit_find_objf_with_entry_addr (CORE_ADDR entry_addr
)
956 struct objfile
*objf
;
960 struct jit_objfile_data
*objf_data
;
962 objf_data
= objfile_data (objf
, jit_objfile_data
);
963 if (objf_data
!= NULL
&& objf_data
->addr
== entry_addr
)
969 /* (Re-)Initialize the jit breakpoint if necessary.
970 Return 0 on success. */
973 jit_breakpoint_re_set_internal (struct gdbarch
*gdbarch
,
974 struct jit_inferior_data
*inf_data
)
976 struct minimal_symbol
*reg_symbol
, *desc_symbol
;
977 struct objfile
*objf
;
978 struct jit_objfile_data
*objf_data
;
980 if (inf_data
->objfile
!= NULL
)
983 /* Lookup the registration symbol. If it is missing, then we assume
984 we are not attached to a JIT. */
985 reg_symbol
= lookup_minimal_symbol_and_objfile (jit_break_name
, &objf
);
986 if (reg_symbol
== NULL
|| SYMBOL_VALUE_ADDRESS (reg_symbol
) == 0)
989 desc_symbol
= lookup_minimal_symbol (jit_descriptor_name
, NULL
, objf
);
990 if (desc_symbol
== NULL
|| SYMBOL_VALUE_ADDRESS (desc_symbol
) == 0)
993 objf_data
= get_jit_objfile_data (objf
);
994 objf_data
->register_code
= reg_symbol
;
995 objf_data
->descriptor
= desc_symbol
;
997 inf_data
->objfile
= objf
;
999 jit_inferior_init (gdbarch
);
1002 fprintf_unfiltered (gdb_stdlog
,
1003 "jit_breakpoint_re_set_internal, "
1004 "breakpoint_addr = %s\n",
1005 paddress (gdbarch
, SYMBOL_VALUE_ADDRESS (reg_symbol
)));
1007 /* Put a breakpoint in the registration symbol. */
1008 create_jit_event_breakpoint (gdbarch
, SYMBOL_VALUE_ADDRESS (reg_symbol
));
1013 /* The private data passed around in the frame unwind callback
1016 struct jit_unwind_private
1018 /* Cached register values. See jit_frame_sniffer to see how this
1020 struct gdb_reg_value
**registers
;
1022 /* The frame being unwound. */
1023 struct frame_info
*this_frame
;
1026 /* Sets the value of a particular register in this frame. */
1029 jit_unwind_reg_set_impl (struct gdb_unwind_callbacks
*cb
, int dwarf_regnum
,
1030 struct gdb_reg_value
*value
)
1032 struct jit_unwind_private
*priv
;
1035 priv
= cb
->priv_data
;
1037 gdb_reg
= gdbarch_dwarf2_reg_to_regnum (get_frame_arch (priv
->this_frame
),
1042 fprintf_unfiltered (gdb_stdlog
,
1043 _("Could not recognize DWARF regnum %d"),
1048 gdb_assert (priv
->registers
);
1049 priv
->registers
[gdb_reg
] = value
;
1053 reg_value_free_impl (struct gdb_reg_value
*value
)
1058 /* Get the value of register REGNUM in the previous frame. */
1060 static struct gdb_reg_value
*
1061 jit_unwind_reg_get_impl (struct gdb_unwind_callbacks
*cb
, int regnum
)
1063 struct jit_unwind_private
*priv
;
1064 struct gdb_reg_value
*value
;
1066 struct gdbarch
*frame_arch
;
1068 priv
= cb
->priv_data
;
1069 frame_arch
= get_frame_arch (priv
->this_frame
);
1071 gdb_reg
= gdbarch_dwarf2_reg_to_regnum (frame_arch
, regnum
);
1072 size
= register_size (frame_arch
, gdb_reg
);
1073 value
= xmalloc (sizeof (struct gdb_reg_value
) + size
- 1);
1074 value
->defined
= deprecated_frame_register_read (priv
->this_frame
, gdb_reg
,
1077 value
->free
= reg_value_free_impl
;
1081 /* gdb_reg_value has a free function, which must be called on each
1082 saved register value. */
1085 jit_dealloc_cache (struct frame_info
*this_frame
, void *cache
)
1087 struct jit_unwind_private
*priv_data
= cache
;
1088 struct gdbarch
*frame_arch
;
1091 gdb_assert (priv_data
->registers
);
1092 frame_arch
= get_frame_arch (priv_data
->this_frame
);
1094 for (i
= 0; i
< gdbarch_num_regs (frame_arch
); i
++)
1095 if (priv_data
->registers
[i
] && priv_data
->registers
[i
]->free
)
1096 priv_data
->registers
[i
]->free (priv_data
->registers
[i
]);
1098 xfree (priv_data
->registers
);
1102 /* The frame sniffer for the pseudo unwinder.
1104 While this is nominally a frame sniffer, in the case where the JIT
1105 reader actually recognizes the frame, it does a lot more work -- it
1106 unwinds the frame and saves the corresponding register values in
1107 the cache. jit_frame_prev_register simply returns the saved
1111 jit_frame_sniffer (const struct frame_unwind
*self
,
1112 struct frame_info
*this_frame
, void **cache
)
1114 struct jit_inferior_data
*inf_data
;
1115 struct jit_unwind_private
*priv_data
;
1116 struct gdb_unwind_callbacks callbacks
;
1117 struct gdb_reader_funcs
*funcs
;
1119 inf_data
= get_jit_inferior_data ();
1121 callbacks
.reg_get
= jit_unwind_reg_get_impl
;
1122 callbacks
.reg_set
= jit_unwind_reg_set_impl
;
1123 callbacks
.target_read
= jit_target_read_impl
;
1125 if (loaded_jit_reader
== NULL
)
1128 funcs
= loaded_jit_reader
->functions
;
1130 gdb_assert (!*cache
);
1132 *cache
= XZALLOC (struct jit_unwind_private
);
1134 priv_data
->registers
=
1135 XCALLOC (gdbarch_num_regs (get_frame_arch (this_frame
)),
1136 struct gdb_reg_value
*);
1137 priv_data
->this_frame
= this_frame
;
1139 callbacks
.priv_data
= priv_data
;
1141 /* Try to coax the provided unwinder to unwind the stack */
1142 if (funcs
->unwind (funcs
, &callbacks
) == GDB_SUCCESS
)
1145 fprintf_unfiltered (gdb_stdlog
, _("Successfully unwound frame using "
1150 fprintf_unfiltered (gdb_stdlog
, _("Could not unwind frame using "
1153 jit_dealloc_cache (this_frame
, *cache
);
1160 /* The frame_id function for the pseudo unwinder. Relays the call to
1161 the loaded plugin. */
1164 jit_frame_this_id (struct frame_info
*this_frame
, void **cache
,
1165 struct frame_id
*this_id
)
1167 struct jit_unwind_private
private;
1168 struct gdb_frame_id frame_id
;
1169 struct gdb_reader_funcs
*funcs
;
1170 struct gdb_unwind_callbacks callbacks
;
1172 private.registers
= NULL
;
1173 private.this_frame
= this_frame
;
1175 /* We don't expect the frame_id function to set any registers, so we
1176 set reg_set to NULL. */
1177 callbacks
.reg_get
= jit_unwind_reg_get_impl
;
1178 callbacks
.reg_set
= NULL
;
1179 callbacks
.target_read
= jit_target_read_impl
;
1180 callbacks
.priv_data
= &private;
1182 gdb_assert (loaded_jit_reader
);
1183 funcs
= loaded_jit_reader
->functions
;
1185 frame_id
= funcs
->get_frame_id (funcs
, &callbacks
);
1186 *this_id
= frame_id_build (frame_id
.stack_address
, frame_id
.code_address
);
1189 /* Pseudo unwinder function. Reads the previously fetched value for
1190 the register from the cache. */
1192 static struct value
*
1193 jit_frame_prev_register (struct frame_info
*this_frame
, void **cache
, int reg
)
1195 struct jit_unwind_private
*priv
= *cache
;
1196 struct gdb_reg_value
*value
;
1199 return frame_unwind_got_optimized (this_frame
, reg
);
1201 gdb_assert (priv
->registers
);
1202 value
= priv
->registers
[reg
];
1203 if (value
&& value
->defined
)
1204 return frame_unwind_got_bytes (this_frame
, reg
, value
->value
);
1206 return frame_unwind_got_optimized (this_frame
, reg
);
1209 /* Relay everything back to the unwinder registered by the JIT debug
1212 static const struct frame_unwind jit_frame_unwind
=
1215 default_frame_unwind_stop_reason
,
1217 jit_frame_prev_register
,
1224 /* This is the information that is stored at jit_gdbarch_data for each
1227 struct jit_gdbarch_data_type
1229 /* Has the (pseudo) unwinder been prepended? */
1230 int unwinder_registered
;
1233 /* Check GDBARCH and prepend the pseudo JIT unwinder if needed. */
1236 jit_prepend_unwinder (struct gdbarch
*gdbarch
)
1238 struct jit_gdbarch_data_type
*data
;
1240 data
= gdbarch_data (gdbarch
, jit_gdbarch_data
);
1241 if (!data
->unwinder_registered
)
1243 frame_unwind_prepend_unwinder (gdbarch
, &jit_frame_unwind
);
1244 data
->unwinder_registered
= 1;
1248 /* Register any already created translations. */
1251 jit_inferior_init (struct gdbarch
*gdbarch
)
1253 struct jit_descriptor descriptor
;
1254 struct jit_code_entry cur_entry
;
1255 struct jit_inferior_data
*inf_data
;
1256 CORE_ADDR cur_entry_addr
;
1259 fprintf_unfiltered (gdb_stdlog
, "jit_inferior_init\n");
1261 jit_prepend_unwinder (gdbarch
);
1263 inf_data
= get_jit_inferior_data ();
1264 if (jit_breakpoint_re_set_internal (gdbarch
, inf_data
) != 0)
1267 /* Read the descriptor so we can check the version number and load
1268 any already JITed functions. */
1269 if (!jit_read_descriptor (gdbarch
, &descriptor
, inf_data
))
1272 /* Check that the version number agrees with that we support. */
1273 if (descriptor
.version
!= 1)
1275 printf_unfiltered (_("Unsupported JIT protocol version %ld "
1276 "in descriptor (expected 1)\n"),
1277 (long) descriptor
.version
);
1281 /* If we've attached to a running program, we need to check the descriptor
1282 to register any functions that were already generated. */
1283 for (cur_entry_addr
= descriptor
.first_entry
;
1284 cur_entry_addr
!= 0;
1285 cur_entry_addr
= cur_entry
.next_entry
)
1287 jit_read_code_entry (gdbarch
, cur_entry_addr
, &cur_entry
);
1289 /* This hook may be called many times during setup, so make sure we don't
1290 add the same symbol file twice. */
1291 if (jit_find_objf_with_entry_addr (cur_entry_addr
) != NULL
)
1294 jit_register_code (gdbarch
, cur_entry_addr
, &cur_entry
);
1298 /* Exported routine to call when an inferior has been created. */
1301 jit_inferior_created_hook (void)
1303 jit_inferior_init (target_gdbarch ());
1306 /* Exported routine to call to re-set the jit breakpoints,
1307 e.g. when a program is rerun. */
1310 jit_breakpoint_re_set (void)
1312 jit_breakpoint_re_set_internal (target_gdbarch (),
1313 get_jit_inferior_data ());
1316 /* This function cleans up any code entries left over when the
1317 inferior exits. We get left over code when the inferior exits
1318 without unregistering its code, for example when it crashes. */
1321 jit_inferior_exit_hook (struct inferior
*inf
)
1323 struct objfile
*objf
;
1324 struct objfile
*temp
;
1326 ALL_OBJFILES_SAFE (objf
, temp
)
1328 struct jit_objfile_data
*objf_data
= objfile_data (objf
,
1331 if (objf_data
!= NULL
&& objf_data
->addr
!= 0)
1332 jit_unregister_code (objf
);
1337 jit_event_handler (struct gdbarch
*gdbarch
)
1339 struct jit_descriptor descriptor
;
1340 struct jit_code_entry code_entry
;
1341 CORE_ADDR entry_addr
;
1342 struct objfile
*objf
;
1344 /* Read the descriptor from remote memory. */
1345 if (!jit_read_descriptor (gdbarch
, &descriptor
, get_jit_inferior_data ()))
1347 entry_addr
= descriptor
.relevant_entry
;
1349 /* Do the corresponding action. */
1350 switch (descriptor
.action_flag
)
1355 jit_read_code_entry (gdbarch
, entry_addr
, &code_entry
);
1356 jit_register_code (gdbarch
, entry_addr
, &code_entry
);
1358 case JIT_UNREGISTER
:
1359 objf
= jit_find_objf_with_entry_addr (entry_addr
);
1361 printf_unfiltered (_("Unable to find JITed code "
1362 "entry at address: %s\n"),
1363 paddress (gdbarch
, entry_addr
));
1365 jit_unregister_code (objf
);
1369 error (_("Unknown action_flag value in JIT descriptor!"));
1374 /* Called to free the data allocated to the jit_inferior_data slot. */
1377 free_objfile_data (struct objfile
*objfile
, void *data
)
1379 struct jit_objfile_data
*objf_data
= data
;
1381 if (objf_data
->register_code
!= NULL
)
1383 struct jit_inferior_data
*inf_data
= get_jit_inferior_data ();
1385 if (inf_data
->objfile
== objfile
)
1386 inf_data
->objfile
= NULL
;
1392 /* Initialize the jit_gdbarch_data slot with an instance of struct
1393 jit_gdbarch_data_type */
1396 jit_gdbarch_data_init (struct obstack
*obstack
)
1398 struct jit_gdbarch_data_type
*data
;
1400 data
= obstack_alloc (obstack
, sizeof (struct jit_gdbarch_data_type
));
1401 data
->unwinder_registered
= 0;
1405 /* Provide a prototype to silence -Wmissing-prototypes. */
1407 extern void _initialize_jit (void);
1410 _initialize_jit (void)
1412 jit_reader_dir
= relocate_gdb_directory (JIT_READER_DIR
,
1413 JIT_READER_DIR_RELOCATABLE
);
1414 add_setshow_zuinteger_cmd ("jit", class_maintenance
, &jit_debug
,
1415 _("Set JIT debugging."),
1416 _("Show JIT debugging."),
1417 _("When non-zero, JIT debugging is enabled."),
1420 &setdebuglist
, &showdebuglist
);
1422 observer_attach_inferior_exit (jit_inferior_exit_hook
);
1424 register_objfile_data_with_cleanup (NULL
, free_objfile_data
);
1426 register_inferior_data_with_cleanup (NULL
, jit_inferior_data_cleanup
);
1427 jit_gdbarch_data
= gdbarch_data_register_pre_init (jit_gdbarch_data_init
);
1428 if (is_dl_available ())
1430 add_com ("jit-reader-load", no_class
, jit_reader_load_command
, _("\
1431 Load FILE as debug info reader and unwinder for JIT compiled code.\n\
1432 Usage: jit-reader-load FILE\n\
1433 Try to load file FILE as a debug info reader (and unwinder) for\n\
1434 JIT compiled code. The file is loaded from " JIT_READER_DIR
",\n\
1435 relocated relative to the GDB executable if required."));
1436 add_com ("jit-reader-unload", no_class
, jit_reader_unload_command
, _("\
1437 Unload the currently loaded JIT debug info reader.\n\
1438 Usage: jit-reader-unload FILE\n\n\
1439 Do \"help jit-reader-load\" for info on loading debug info readers."));