1 /* Handle JIT code generation in the inferior for GDB, the GNU Debugger.
3 Copyright (C) 2009-2017 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
23 #include "jit-reader.h"
25 #include "breakpoint.h"
27 #include "dictionary.h"
28 #include "filenames.h"
29 #include "frame-unwind.h"
39 #include "gdb-dlfcn.h"
42 #include "readline/tilde.h"
43 #include "completer.h"
45 static const char *jit_reader_dir = NULL;
47 static const struct objfile_data *jit_objfile_data;
49 static const char *const jit_break_name = "__jit_debug_register_code";
51 static const char *const jit_descriptor_name = "__jit_debug_descriptor";
53 static const struct program_space_data *jit_program_space_data = NULL;
55 static void jit_inferior_init (struct gdbarch *gdbarch);
56 static void jit_inferior_exit_hook (struct inferior *inf);
58 /* An unwinder is registered for every gdbarch. This key is used to
59 remember if the unwinder has been registered for a particular
62 static struct gdbarch_data *jit_gdbarch_data;
64 /* Non-zero if we want to see trace of jit level stuff. */
66 static unsigned int jit_debug = 0;
69 show_jit_debug (struct ui_file *file, int from_tty,
70 struct cmd_list_element *c, const char *value)
72 fprintf_filtered (file, _("JIT debugging is %s.\n"), value);
81 /* Openning the file is a no-op. */
84 mem_bfd_iovec_open (struct bfd *abfd, void *open_closure)
89 /* Closing the file is just freeing the base/size pair on our side. */
92 mem_bfd_iovec_close (struct bfd *abfd, void *stream)
96 /* Zero means success. */
100 /* For reading the file, we just need to pass through to target_read_memory and
101 fix up the arguments and return values. */
104 mem_bfd_iovec_pread (struct bfd *abfd, void *stream, void *buf,
105 file_ptr nbytes, file_ptr offset)
108 struct target_buffer *buffer = (struct target_buffer *) stream;
110 /* If this read will read all of the file, limit it to just the rest. */
111 if (offset + nbytes > buffer->size)
112 nbytes = buffer->size - offset;
114 /* If there are no more bytes left, we've reached EOF. */
118 err = target_read_memory (buffer->base + offset, (gdb_byte *) buf, nbytes);
125 /* For statting the file, we only support the st_size attribute. */
128 mem_bfd_iovec_stat (struct bfd *abfd, void *stream, struct stat *sb)
130 struct target_buffer *buffer = (struct target_buffer*) stream;
132 memset (sb, 0, sizeof (struct stat));
133 sb->st_size = buffer->size;
137 /* Open a BFD from the target's memory. */
139 static gdb_bfd_ref_ptr
140 bfd_open_from_target_memory (CORE_ADDR addr, ULONGEST size, char *target)
142 struct target_buffer *buffer = XNEW (struct target_buffer);
146 return gdb_bfd_openr_iovec ("<in-memory>", target,
156 jit_reader (struct gdb_reader_funcs *f, gdb_dlhandle_up &&h)
157 : functions (f), handle (std::move (h))
163 functions->destroy (functions);
166 jit_reader (const jit_reader &) = delete;
167 jit_reader &operator= (const jit_reader &) = delete;
169 struct gdb_reader_funcs *functions;
170 gdb_dlhandle_up handle;
173 /* One reader that has been loaded successfully, and can potentially be used to
176 static struct jit_reader *loaded_jit_reader = NULL;
178 typedef struct gdb_reader_funcs * (reader_init_fn_type) (void);
179 static const char *reader_init_fn_sym = "gdb_init_reader";
181 /* Try to load FILE_NAME as a JIT debug info reader. */
183 static struct jit_reader *
184 jit_reader_load (const char *file_name)
186 reader_init_fn_type *init_fn;
187 struct gdb_reader_funcs *funcs = NULL;
190 fprintf_unfiltered (gdb_stdlog, _("Opening shared object %s.\n"),
192 gdb_dlhandle_up so = gdb_dlopen (file_name);
194 init_fn = (reader_init_fn_type *) gdb_dlsym (so, reader_init_fn_sym);
196 error (_("Could not locate initialization function: %s."),
199 if (gdb_dlsym (so, "plugin_is_GPL_compatible") == NULL)
200 error (_("Reader not GPL compatible."));
203 if (funcs->reader_version != GDB_READER_INTERFACE_VERSION)
204 error (_("Reader version does not match GDB version."));
206 return new jit_reader (funcs, std::move (so));
209 /* Provides the jit-reader-load command. */
212 jit_reader_load_command (char *args, int from_tty)
215 error (_("No reader name provided."));
216 gdb::unique_xmalloc_ptr<char> file (tilde_expand (args));
218 if (loaded_jit_reader != NULL)
219 error (_("JIT reader already loaded. Run jit-reader-unload first."));
221 if (!IS_ABSOLUTE_PATH (file.get ()))
222 file.reset (xstrprintf ("%s%s%s", jit_reader_dir, SLASH_STRING,
225 loaded_jit_reader = jit_reader_load (file.get ());
226 reinit_frame_cache ();
227 jit_inferior_created_hook ();
230 /* Provides the jit-reader-unload command. */
233 jit_reader_unload_command (char *args, int from_tty)
235 if (!loaded_jit_reader)
236 error (_("No JIT reader loaded."));
238 reinit_frame_cache ();
239 jit_inferior_exit_hook (current_inferior ());
241 delete loaded_jit_reader;
242 loaded_jit_reader = NULL;
245 /* Per-program space structure recording which objfile has the JIT
248 struct jit_program_space_data
250 /* The objfile. This is NULL if no objfile holds the JIT
253 struct objfile *objfile;
255 /* If this program space has __jit_debug_register_code, this is the
256 cached address from the minimal symbol. This is used to detect
257 relocations requiring the breakpoint to be re-created. */
259 CORE_ADDR cached_code_address;
261 /* This is the JIT event breakpoint, or NULL if it has not been
264 struct breakpoint *jit_breakpoint;
267 /* Per-objfile structure recording the addresses in the program space.
268 This object serves two purposes: for ordinary objfiles, it may
269 cache some symbols related to the JIT interface; and for
270 JIT-created objfiles, it holds some information about the
273 struct jit_objfile_data
275 /* Symbol for __jit_debug_register_code. */
276 struct minimal_symbol *register_code;
278 /* Symbol for __jit_debug_descriptor. */
279 struct minimal_symbol *descriptor;
281 /* Address of struct jit_code_entry in this objfile. This is only
282 non-zero for objfiles that represent code created by the JIT. */
286 /* Fetch the jit_objfile_data associated with OBJF. If no data exists
287 yet, make a new structure and attach it. */
289 static struct jit_objfile_data *
290 get_jit_objfile_data (struct objfile *objf)
292 struct jit_objfile_data *objf_data;
294 objf_data = (struct jit_objfile_data *) objfile_data (objf, jit_objfile_data);
295 if (objf_data == NULL)
297 objf_data = XCNEW (struct jit_objfile_data);
298 set_objfile_data (objf, jit_objfile_data, objf_data);
304 /* Remember OBJFILE has been created for struct jit_code_entry located
305 at inferior address ENTRY. */
308 add_objfile_entry (struct objfile *objfile, CORE_ADDR entry)
310 struct jit_objfile_data *objf_data;
312 objf_data = get_jit_objfile_data (objfile);
313 objf_data->addr = entry;
316 /* Return jit_program_space_data for current program space. Allocate
317 if not already present. */
319 static struct jit_program_space_data *
320 get_jit_program_space_data (void)
322 struct jit_program_space_data *ps_data;
325 = ((struct jit_program_space_data *)
326 program_space_data (current_program_space, jit_program_space_data));
329 ps_data = XCNEW (struct jit_program_space_data);
330 set_program_space_data (current_program_space, jit_program_space_data,
338 jit_program_space_data_cleanup (struct program_space *ps, void *arg)
343 /* Helper function for reading the global JIT descriptor from remote
344 memory. Returns 1 if all went well, 0 otherwise. */
347 jit_read_descriptor (struct gdbarch *gdbarch,
348 struct jit_descriptor *descriptor,
349 struct jit_program_space_data *ps_data)
352 struct type *ptr_type;
356 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
357 struct jit_objfile_data *objf_data;
359 if (ps_data->objfile == NULL)
361 objf_data = get_jit_objfile_data (ps_data->objfile);
362 if (objf_data->descriptor == NULL)
366 fprintf_unfiltered (gdb_stdlog,
367 "jit_read_descriptor, descriptor_addr = %s\n",
368 paddress (gdbarch, MSYMBOL_VALUE_ADDRESS (ps_data->objfile,
369 objf_data->descriptor)));
371 /* Figure out how big the descriptor is on the remote and how to read it. */
372 ptr_type = builtin_type (gdbarch)->builtin_data_ptr;
373 ptr_size = TYPE_LENGTH (ptr_type);
374 desc_size = 8 + 2 * ptr_size; /* Two 32-bit ints and two pointers. */
375 desc_buf = (gdb_byte *) alloca (desc_size);
377 /* Read the descriptor. */
378 err = target_read_memory (MSYMBOL_VALUE_ADDRESS (ps_data->objfile,
379 objf_data->descriptor),
380 desc_buf, desc_size);
383 printf_unfiltered (_("Unable to read JIT descriptor from "
388 /* Fix the endianness to match the host. */
389 descriptor->version = extract_unsigned_integer (&desc_buf[0], 4, byte_order);
390 descriptor->action_flag =
391 extract_unsigned_integer (&desc_buf[4], 4, byte_order);
392 descriptor->relevant_entry = extract_typed_address (&desc_buf[8], ptr_type);
393 descriptor->first_entry =
394 extract_typed_address (&desc_buf[8 + ptr_size], ptr_type);
399 /* Helper function for reading a JITed code entry from remote memory. */
402 jit_read_code_entry (struct gdbarch *gdbarch,
403 CORE_ADDR code_addr, struct jit_code_entry *code_entry)
406 struct type *ptr_type;
411 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
413 /* Figure out how big the entry is on the remote and how to read it. */
414 ptr_type = builtin_type (gdbarch)->builtin_data_ptr;
415 ptr_size = TYPE_LENGTH (ptr_type);
417 /* Figure out where the longlong value will be. */
418 align_bytes = gdbarch_long_long_align_bit (gdbarch) / 8;
420 off = (off + (align_bytes - 1)) & ~(align_bytes - 1);
422 entry_size = off + 8; /* Three pointers and one 64-bit int. */
423 entry_buf = (gdb_byte *) alloca (entry_size);
425 /* Read the entry. */
426 err = target_read_memory (code_addr, entry_buf, entry_size);
428 error (_("Unable to read JIT code entry from remote memory!"));
430 /* Fix the endianness to match the host. */
431 ptr_type = builtin_type (gdbarch)->builtin_data_ptr;
432 code_entry->next_entry = extract_typed_address (&entry_buf[0], ptr_type);
433 code_entry->prev_entry =
434 extract_typed_address (&entry_buf[ptr_size], ptr_type);
435 code_entry->symfile_addr =
436 extract_typed_address (&entry_buf[2 * ptr_size], ptr_type);
437 code_entry->symfile_size =
438 extract_unsigned_integer (&entry_buf[off], 8, byte_order);
441 /* Proxy object for building a block. */
445 /* gdb_blocks are linked into a tree structure. Next points to the
446 next node at the same depth as this block and parent to the
448 struct gdb_block *next, *parent;
450 /* Points to the "real" block that is being built out of this
451 instance. This block will be added to a blockvector, which will
452 then be added to a symtab. */
453 struct block *real_block;
455 /* The first and last code address corresponding to this block. */
456 CORE_ADDR begin, end;
458 /* The name of this block (if any). If this is non-NULL, the
459 FUNCTION symbol symbol is set to this value. */
463 /* Proxy object for building a symtab. */
467 /* The list of blocks in this symtab. These will eventually be
468 converted to real blocks. */
469 struct gdb_block *blocks;
471 /* The number of blocks inserted. */
474 /* A mapping between line numbers to PC. */
475 struct linetable *linetable;
477 /* The source file for this symtab. */
478 const char *file_name;
479 struct gdb_symtab *next;
482 /* Proxy object for building an object. */
486 struct gdb_symtab *symtabs;
489 /* The type of the `private' data passed around by the callback
492 typedef CORE_ADDR jit_dbg_reader_data;
494 /* The reader calls into this function to read data off the targets
497 static enum gdb_status
498 jit_target_read_impl (GDB_CORE_ADDR target_mem, void *gdb_buf, int len)
500 int result = target_read_memory ((CORE_ADDR) target_mem,
501 (gdb_byte *) gdb_buf, len);
508 /* The reader calls into this function to create a new gdb_object
509 which it can then pass around to the other callbacks. Right now,
510 all that is required is allocating the memory. */
512 static struct gdb_object *
513 jit_object_open_impl (struct gdb_symbol_callbacks *cb)
515 /* CB is not required right now, but sometime in the future we might
516 need a handle to it, and we'd like to do that without breaking
518 return XCNEW (struct gdb_object);
521 /* Readers call into this function to open a new gdb_symtab, which,
522 again, is passed around to other callbacks. */
524 static struct gdb_symtab *
525 jit_symtab_open_impl (struct gdb_symbol_callbacks *cb,
526 struct gdb_object *object,
527 const char *file_name)
529 struct gdb_symtab *ret;
531 /* CB stays unused. See comment in jit_object_open_impl. */
533 ret = XCNEW (struct gdb_symtab);
534 ret->file_name = file_name ? xstrdup (file_name) : xstrdup ("");
535 ret->next = object->symtabs;
536 object->symtabs = ret;
540 /* Returns true if the block corresponding to old should be placed
541 before the block corresponding to new in the final blockvector. */
544 compare_block (const struct gdb_block *const old,
545 const struct gdb_block *const newobj)
549 if (old->begin < newobj->begin)
551 else if (old->begin == newobj->begin)
553 if (old->end > newobj->end)
562 /* Called by readers to open a new gdb_block. This function also
563 inserts the new gdb_block in the correct place in the corresponding
566 static struct gdb_block *
567 jit_block_open_impl (struct gdb_symbol_callbacks *cb,
568 struct gdb_symtab *symtab, struct gdb_block *parent,
569 GDB_CORE_ADDR begin, GDB_CORE_ADDR end, const char *name)
571 struct gdb_block *block = XCNEW (struct gdb_block);
573 block->next = symtab->blocks;
574 block->begin = (CORE_ADDR) begin;
575 block->end = (CORE_ADDR) end;
576 block->name = name ? xstrdup (name) : NULL;
577 block->parent = parent;
579 /* Ensure that the blocks are inserted in the correct (reverse of
580 the order expected by blockvector). */
581 if (compare_block (symtab->blocks, block))
583 symtab->blocks = block;
587 struct gdb_block *i = symtab->blocks;
591 /* Guaranteed to terminate, since compare_block (NULL, _)
593 if (compare_block (i->next, block))
595 block->next = i->next;
606 /* Readers call this to add a line mapping (from PC to line number) to
610 jit_symtab_line_mapping_add_impl (struct gdb_symbol_callbacks *cb,
611 struct gdb_symtab *stab, int nlines,
612 struct gdb_line_mapping *map)
620 alloc_len = sizeof (struct linetable)
621 + (nlines - 1) * sizeof (struct linetable_entry);
622 stab->linetable = (struct linetable *) xmalloc (alloc_len);
623 stab->linetable->nitems = nlines;
624 for (i = 0; i < nlines; i++)
626 stab->linetable->item[i].pc = (CORE_ADDR) map[i].pc;
627 stab->linetable->item[i].line = map[i].line;
631 /* Called by readers to close a gdb_symtab. Does not need to do
632 anything as of now. */
635 jit_symtab_close_impl (struct gdb_symbol_callbacks *cb,
636 struct gdb_symtab *stab)
638 /* Right now nothing needs to be done here. We may need to do some
639 cleanup here in the future (again, without breaking the plugin
643 /* Transform STAB to a proper symtab, and add it it OBJFILE. */
646 finalize_symtab (struct gdb_symtab *stab, struct objfile *objfile)
648 struct compunit_symtab *cust;
649 struct gdb_block *gdb_block_iter, *gdb_block_iter_tmp;
650 struct block *block_iter;
651 int actual_nblocks, i;
652 size_t blockvector_size;
653 CORE_ADDR begin, end;
654 struct blockvector *bv;
656 actual_nblocks = FIRST_LOCAL_BLOCK + stab->nblocks;
658 cust = allocate_compunit_symtab (objfile, stab->file_name);
659 allocate_symtab (cust, stab->file_name);
660 add_compunit_symtab_to_objfile (cust);
662 /* JIT compilers compile in memory. */
663 COMPUNIT_DIRNAME (cust) = NULL;
665 /* Copy over the linetable entry if one was provided. */
668 size_t size = ((stab->linetable->nitems - 1)
669 * sizeof (struct linetable_entry)
670 + sizeof (struct linetable));
671 SYMTAB_LINETABLE (COMPUNIT_FILETABS (cust))
672 = (struct linetable *) obstack_alloc (&objfile->objfile_obstack, size);
673 memcpy (SYMTAB_LINETABLE (COMPUNIT_FILETABS (cust)), stab->linetable,
677 blockvector_size = (sizeof (struct blockvector)
678 + (actual_nblocks - 1) * sizeof (struct block *));
679 bv = (struct blockvector *) obstack_alloc (&objfile->objfile_obstack,
681 COMPUNIT_BLOCKVECTOR (cust) = bv;
683 /* (begin, end) will contain the PC range this entire blockvector
685 BLOCKVECTOR_MAP (bv) = NULL;
686 begin = stab->blocks->begin;
687 end = stab->blocks->end;
688 BLOCKVECTOR_NBLOCKS (bv) = actual_nblocks;
690 /* First run over all the gdb_block objects, creating a real block
691 object for each. Simultaneously, keep setting the real_block
693 for (i = (actual_nblocks - 1), gdb_block_iter = stab->blocks;
694 i >= FIRST_LOCAL_BLOCK;
695 i--, gdb_block_iter = gdb_block_iter->next)
697 struct block *new_block = allocate_block (&objfile->objfile_obstack);
698 struct symbol *block_name = allocate_symbol (objfile);
699 struct type *block_type = arch_type (get_objfile_arch (objfile),
704 BLOCK_DICT (new_block) = dict_create_linear (&objfile->objfile_obstack,
706 /* The address range. */
707 BLOCK_START (new_block) = (CORE_ADDR) gdb_block_iter->begin;
708 BLOCK_END (new_block) = (CORE_ADDR) gdb_block_iter->end;
711 SYMBOL_DOMAIN (block_name) = VAR_DOMAIN;
712 SYMBOL_ACLASS_INDEX (block_name) = LOC_BLOCK;
713 symbol_set_symtab (block_name, COMPUNIT_FILETABS (cust));
714 SYMBOL_TYPE (block_name) = lookup_function_type (block_type);
715 SYMBOL_BLOCK_VALUE (block_name) = new_block;
717 block_name->ginfo.name
718 = (const char *) obstack_copy0 (&objfile->objfile_obstack,
719 gdb_block_iter->name,
720 strlen (gdb_block_iter->name));
722 BLOCK_FUNCTION (new_block) = block_name;
724 BLOCKVECTOR_BLOCK (bv, i) = new_block;
725 if (begin > BLOCK_START (new_block))
726 begin = BLOCK_START (new_block);
727 if (end < BLOCK_END (new_block))
728 end = BLOCK_END (new_block);
730 gdb_block_iter->real_block = new_block;
733 /* Now add the special blocks. */
735 for (i = 0; i < FIRST_LOCAL_BLOCK; i++)
737 struct block *new_block;
739 new_block = (i == GLOBAL_BLOCK
740 ? allocate_global_block (&objfile->objfile_obstack)
741 : allocate_block (&objfile->objfile_obstack));
742 BLOCK_DICT (new_block) = dict_create_linear (&objfile->objfile_obstack,
744 BLOCK_SUPERBLOCK (new_block) = block_iter;
745 block_iter = new_block;
747 BLOCK_START (new_block) = (CORE_ADDR) begin;
748 BLOCK_END (new_block) = (CORE_ADDR) end;
750 BLOCKVECTOR_BLOCK (bv, i) = new_block;
752 if (i == GLOBAL_BLOCK)
753 set_block_compunit_symtab (new_block, cust);
756 /* Fill up the superblock fields for the real blocks, using the
757 real_block fields populated earlier. */
758 for (gdb_block_iter = stab->blocks;
760 gdb_block_iter = gdb_block_iter->next)
762 if (gdb_block_iter->parent != NULL)
764 /* If the plugin specifically mentioned a parent block, we
766 BLOCK_SUPERBLOCK (gdb_block_iter->real_block) =
767 gdb_block_iter->parent->real_block;
771 /* And if not, we set a default parent block. */
772 BLOCK_SUPERBLOCK (gdb_block_iter->real_block) =
773 BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK);
778 gdb_block_iter = stab->blocks;
780 for (gdb_block_iter = stab->blocks, gdb_block_iter_tmp = gdb_block_iter->next;
782 gdb_block_iter = gdb_block_iter_tmp)
784 xfree ((void *) gdb_block_iter->name);
785 xfree (gdb_block_iter);
787 xfree (stab->linetable);
788 xfree ((char *) stab->file_name);
792 /* Called when closing a gdb_objfile. Converts OBJ to a proper
796 jit_object_close_impl (struct gdb_symbol_callbacks *cb,
797 struct gdb_object *obj)
799 struct gdb_symtab *i, *j;
800 struct objfile *objfile;
801 jit_dbg_reader_data *priv_data;
803 priv_data = (jit_dbg_reader_data *) cb->priv_data;
805 objfile = allocate_objfile (NULL, "<< JIT compiled code >>",
807 objfile->per_bfd->gdbarch = target_gdbarch ();
809 terminate_minimal_symbol_table (objfile);
812 for (i = obj->symtabs; i; i = j)
815 finalize_symtab (i, objfile);
817 add_objfile_entry (objfile, *priv_data);
821 /* Try to read CODE_ENTRY using the loaded jit reader (if any).
822 ENTRY_ADDR is the address of the struct jit_code_entry in the
823 inferior address space. */
826 jit_reader_try_read_symtab (struct jit_code_entry *code_entry,
827 CORE_ADDR entry_addr)
831 jit_dbg_reader_data priv_data;
832 struct gdb_reader_funcs *funcs;
833 struct gdb_symbol_callbacks callbacks =
835 jit_object_open_impl,
836 jit_symtab_open_impl,
838 jit_symtab_close_impl,
839 jit_object_close_impl,
841 jit_symtab_line_mapping_add_impl,
842 jit_target_read_impl,
847 priv_data = entry_addr;
849 if (!loaded_jit_reader)
852 gdb_mem = (gdb_byte *) xmalloc (code_entry->symfile_size);
857 if (target_read_memory (code_entry->symfile_addr, gdb_mem,
858 code_entry->symfile_size))
861 CATCH (e, RETURN_MASK_ALL)
869 funcs = loaded_jit_reader->functions;
870 if (funcs->read (funcs, &callbacks, gdb_mem, code_entry->symfile_size)
876 if (jit_debug && status == 0)
877 fprintf_unfiltered (gdb_stdlog,
878 "Could not read symtab using the loaded JIT reader.\n");
882 /* Try to read CODE_ENTRY using BFD. ENTRY_ADDR is the address of the
883 struct jit_code_entry in the inferior address space. */
886 jit_bfd_try_read_symtab (struct jit_code_entry *code_entry,
887 CORE_ADDR entry_addr,
888 struct gdbarch *gdbarch)
890 struct section_addr_info *sai;
891 struct bfd_section *sec;
892 struct objfile *objfile;
893 struct cleanup *old_cleanups;
895 const struct bfd_arch_info *b;
898 fprintf_unfiltered (gdb_stdlog,
899 "jit_register_code, symfile_addr = %s, "
900 "symfile_size = %s\n",
901 paddress (gdbarch, code_entry->symfile_addr),
902 pulongest (code_entry->symfile_size));
904 gdb_bfd_ref_ptr nbfd (bfd_open_from_target_memory (code_entry->symfile_addr,
905 code_entry->symfile_size,
909 puts_unfiltered (_("Error opening JITed symbol file, ignoring it.\n"));
913 /* Check the format. NOTE: This initializes important data that GDB uses!
914 We would segfault later without this line. */
915 if (!bfd_check_format (nbfd.get (), bfd_object))
917 printf_unfiltered (_("\
918 JITed symbol file is not an object file, ignoring it.\n"));
922 /* Check bfd arch. */
923 b = gdbarch_bfd_arch_info (gdbarch);
924 if (b->compatible (b, bfd_get_arch_info (nbfd.get ())) != b)
925 warning (_("JITed object file architecture %s is not compatible "
926 "with target architecture %s."),
927 bfd_get_arch_info (nbfd.get ())->printable_name,
930 /* Read the section address information out of the symbol file. Since the
931 file is generated by the JIT at runtime, it should all of the absolute
932 addresses that we care about. */
933 sai = alloc_section_addr_info (bfd_count_sections (nbfd.get ()));
934 old_cleanups = make_cleanup_free_section_addr_info (sai);
936 for (sec = nbfd->sections; sec != NULL; sec = sec->next)
937 if ((bfd_get_section_flags (nbfd.get (), sec) & (SEC_ALLOC|SEC_LOAD)) != 0)
939 /* We assume that these virtual addresses are absolute, and do not
940 treat them as offsets. */
941 sai->other[i].addr = bfd_get_section_vma (nbfd.get (), sec);
942 sai->other[i].name = xstrdup (bfd_get_section_name (nbfd.get (), sec));
943 sai->other[i].sectindex = sec->index;
946 sai->num_sections = i;
948 /* This call does not take ownership of SAI. */
949 objfile = symbol_file_add_from_bfd (nbfd.get (),
950 bfd_get_filename (nbfd.get ()), 0, sai,
951 OBJF_SHARED | OBJF_NOT_FILENAME, NULL);
953 do_cleanups (old_cleanups);
954 add_objfile_entry (objfile, entry_addr);
957 /* This function registers code associated with a JIT code entry. It uses the
958 pointer and size pair in the entry to read the symbol file from the remote
959 and then calls symbol_file_add_from_local_memory to add it as though it were
960 a symbol file added by the user. */
963 jit_register_code (struct gdbarch *gdbarch,
964 CORE_ADDR entry_addr, struct jit_code_entry *code_entry)
969 fprintf_unfiltered (gdb_stdlog,
970 "jit_register_code, symfile_addr = %s, "
971 "symfile_size = %s\n",
972 paddress (gdbarch, code_entry->symfile_addr),
973 pulongest (code_entry->symfile_size));
975 success = jit_reader_try_read_symtab (code_entry, entry_addr);
978 jit_bfd_try_read_symtab (code_entry, entry_addr, gdbarch);
981 /* This function unregisters JITed code and frees the corresponding
985 jit_unregister_code (struct objfile *objfile)
987 free_objfile (objfile);
990 /* Look up the objfile with this code entry address. */
992 static struct objfile *
993 jit_find_objf_with_entry_addr (CORE_ADDR entry_addr)
995 struct objfile *objf;
999 struct jit_objfile_data *objf_data;
1002 = (struct jit_objfile_data *) objfile_data (objf, jit_objfile_data);
1003 if (objf_data != NULL && objf_data->addr == entry_addr)
1009 /* This is called when a breakpoint is deleted. It updates the
1010 inferior's cache, if needed. */
1013 jit_breakpoint_deleted (struct breakpoint *b)
1015 struct bp_location *iter;
1017 if (b->type != bp_jit_event)
1020 for (iter = b->loc; iter != NULL; iter = iter->next)
1022 struct jit_program_space_data *ps_data;
1024 ps_data = ((struct jit_program_space_data *)
1025 program_space_data (iter->pspace, jit_program_space_data));
1026 if (ps_data != NULL && ps_data->jit_breakpoint == iter->owner)
1028 ps_data->cached_code_address = 0;
1029 ps_data->jit_breakpoint = NULL;
1034 /* (Re-)Initialize the jit breakpoint if necessary.
1035 Return 0 if the jit breakpoint has been successfully initialized. */
1038 jit_breakpoint_re_set_internal (struct gdbarch *gdbarch,
1039 struct jit_program_space_data *ps_data)
1041 struct bound_minimal_symbol reg_symbol;
1042 struct bound_minimal_symbol desc_symbol;
1043 struct jit_objfile_data *objf_data;
1046 if (ps_data->objfile == NULL)
1048 /* Lookup the registration symbol. If it is missing, then we
1049 assume we are not attached to a JIT. */
1050 reg_symbol = lookup_minimal_symbol_and_objfile (jit_break_name);
1051 if (reg_symbol.minsym == NULL
1052 || BMSYMBOL_VALUE_ADDRESS (reg_symbol) == 0)
1055 desc_symbol = lookup_minimal_symbol (jit_descriptor_name, NULL,
1056 reg_symbol.objfile);
1057 if (desc_symbol.minsym == NULL
1058 || BMSYMBOL_VALUE_ADDRESS (desc_symbol) == 0)
1061 objf_data = get_jit_objfile_data (reg_symbol.objfile);
1062 objf_data->register_code = reg_symbol.minsym;
1063 objf_data->descriptor = desc_symbol.minsym;
1065 ps_data->objfile = reg_symbol.objfile;
1068 objf_data = get_jit_objfile_data (ps_data->objfile);
1070 addr = MSYMBOL_VALUE_ADDRESS (ps_data->objfile, objf_data->register_code);
1073 fprintf_unfiltered (gdb_stdlog,
1074 "jit_breakpoint_re_set_internal, "
1075 "breakpoint_addr = %s\n",
1076 paddress (gdbarch, addr));
1078 if (ps_data->cached_code_address == addr)
1081 /* Delete the old breakpoint. */
1082 if (ps_data->jit_breakpoint != NULL)
1083 delete_breakpoint (ps_data->jit_breakpoint);
1085 /* Put a breakpoint in the registration symbol. */
1086 ps_data->cached_code_address = addr;
1087 ps_data->jit_breakpoint = create_jit_event_breakpoint (gdbarch, addr);
1092 /* The private data passed around in the frame unwind callback
1095 struct jit_unwind_private
1097 /* Cached register values. See jit_frame_sniffer to see how this
1099 struct regcache *regcache;
1101 /* The frame being unwound. */
1102 struct frame_info *this_frame;
1105 /* Sets the value of a particular register in this frame. */
1108 jit_unwind_reg_set_impl (struct gdb_unwind_callbacks *cb, int dwarf_regnum,
1109 struct gdb_reg_value *value)
1111 struct jit_unwind_private *priv;
1114 priv = (struct jit_unwind_private *) cb->priv_data;
1116 gdb_reg = gdbarch_dwarf2_reg_to_regnum (get_frame_arch (priv->this_frame),
1121 fprintf_unfiltered (gdb_stdlog,
1122 _("Could not recognize DWARF regnum %d"),
1124 value->free (value);
1128 regcache_raw_set_cached_value (priv->regcache, gdb_reg, value->value);
1129 value->free (value);
1133 reg_value_free_impl (struct gdb_reg_value *value)
1138 /* Get the value of register REGNUM in the previous frame. */
1140 static struct gdb_reg_value *
1141 jit_unwind_reg_get_impl (struct gdb_unwind_callbacks *cb, int regnum)
1143 struct jit_unwind_private *priv;
1144 struct gdb_reg_value *value;
1146 struct gdbarch *frame_arch;
1148 priv = (struct jit_unwind_private *) cb->priv_data;
1149 frame_arch = get_frame_arch (priv->this_frame);
1151 gdb_reg = gdbarch_dwarf2_reg_to_regnum (frame_arch, regnum);
1152 size = register_size (frame_arch, gdb_reg);
1153 value = ((struct gdb_reg_value *)
1154 xmalloc (sizeof (struct gdb_reg_value) + size - 1));
1155 value->defined = deprecated_frame_register_read (priv->this_frame, gdb_reg,
1158 value->free = reg_value_free_impl;
1162 /* gdb_reg_value has a free function, which must be called on each
1163 saved register value. */
1166 jit_dealloc_cache (struct frame_info *this_frame, void *cache)
1168 struct jit_unwind_private *priv_data = (struct jit_unwind_private *) cache;
1170 gdb_assert (priv_data->regcache != NULL);
1171 regcache_xfree (priv_data->regcache);
1175 /* The frame sniffer for the pseudo unwinder.
1177 While this is nominally a frame sniffer, in the case where the JIT
1178 reader actually recognizes the frame, it does a lot more work -- it
1179 unwinds the frame and saves the corresponding register values in
1180 the cache. jit_frame_prev_register simply returns the saved
1184 jit_frame_sniffer (const struct frame_unwind *self,
1185 struct frame_info *this_frame, void **cache)
1187 struct jit_unwind_private *priv_data;
1188 struct gdb_unwind_callbacks callbacks;
1189 struct gdb_reader_funcs *funcs;
1190 struct address_space *aspace;
1191 struct gdbarch *gdbarch;
1193 callbacks.reg_get = jit_unwind_reg_get_impl;
1194 callbacks.reg_set = jit_unwind_reg_set_impl;
1195 callbacks.target_read = jit_target_read_impl;
1197 if (loaded_jit_reader == NULL)
1200 funcs = loaded_jit_reader->functions;
1202 gdb_assert (!*cache);
1204 aspace = get_frame_address_space (this_frame);
1205 gdbarch = get_frame_arch (this_frame);
1207 *cache = XCNEW (struct jit_unwind_private);
1208 priv_data = (struct jit_unwind_private *) *cache;
1209 priv_data->regcache = regcache_xmalloc (gdbarch, aspace);
1210 priv_data->this_frame = this_frame;
1212 callbacks.priv_data = priv_data;
1214 /* Try to coax the provided unwinder to unwind the stack */
1215 if (funcs->unwind (funcs, &callbacks) == GDB_SUCCESS)
1218 fprintf_unfiltered (gdb_stdlog, _("Successfully unwound frame using "
1223 fprintf_unfiltered (gdb_stdlog, _("Could not unwind frame using "
1226 jit_dealloc_cache (this_frame, *cache);
1233 /* The frame_id function for the pseudo unwinder. Relays the call to
1234 the loaded plugin. */
1237 jit_frame_this_id (struct frame_info *this_frame, void **cache,
1238 struct frame_id *this_id)
1240 struct jit_unwind_private priv;
1241 struct gdb_frame_id frame_id;
1242 struct gdb_reader_funcs *funcs;
1243 struct gdb_unwind_callbacks callbacks;
1245 priv.regcache = NULL;
1246 priv.this_frame = this_frame;
1248 /* We don't expect the frame_id function to set any registers, so we
1249 set reg_set to NULL. */
1250 callbacks.reg_get = jit_unwind_reg_get_impl;
1251 callbacks.reg_set = NULL;
1252 callbacks.target_read = jit_target_read_impl;
1253 callbacks.priv_data = &priv;
1255 gdb_assert (loaded_jit_reader);
1256 funcs = loaded_jit_reader->functions;
1258 frame_id = funcs->get_frame_id (funcs, &callbacks);
1259 *this_id = frame_id_build (frame_id.stack_address, frame_id.code_address);
1262 /* Pseudo unwinder function. Reads the previously fetched value for
1263 the register from the cache. */
1265 static struct value *
1266 jit_frame_prev_register (struct frame_info *this_frame, void **cache, int reg)
1268 struct jit_unwind_private *priv = (struct jit_unwind_private *) *cache;
1269 struct gdbarch *gdbarch;
1272 return frame_unwind_got_optimized (this_frame, reg);
1274 gdbarch = get_regcache_arch (priv->regcache);
1275 if (reg < gdbarch_num_regs (gdbarch))
1277 gdb_byte *buf = (gdb_byte *) alloca (register_size (gdbarch, reg));
1278 enum register_status status;
1280 status = regcache_raw_read (priv->regcache, reg, buf);
1281 if (status == REG_VALID)
1282 return frame_unwind_got_bytes (this_frame, reg, buf);
1284 return frame_unwind_got_optimized (this_frame, reg);
1287 return gdbarch_pseudo_register_read_value (gdbarch, priv->regcache, reg);
1290 /* Relay everything back to the unwinder registered by the JIT debug
1293 static const struct frame_unwind jit_frame_unwind =
1296 default_frame_unwind_stop_reason,
1298 jit_frame_prev_register,
1305 /* This is the information that is stored at jit_gdbarch_data for each
1308 struct jit_gdbarch_data_type
1310 /* Has the (pseudo) unwinder been prepended? */
1311 int unwinder_registered;
1314 /* Check GDBARCH and prepend the pseudo JIT unwinder if needed. */
1317 jit_prepend_unwinder (struct gdbarch *gdbarch)
1319 struct jit_gdbarch_data_type *data;
1322 = (struct jit_gdbarch_data_type *) gdbarch_data (gdbarch, jit_gdbarch_data);
1323 if (!data->unwinder_registered)
1325 frame_unwind_prepend_unwinder (gdbarch, &jit_frame_unwind);
1326 data->unwinder_registered = 1;
1330 /* Register any already created translations. */
1333 jit_inferior_init (struct gdbarch *gdbarch)
1335 struct jit_descriptor descriptor;
1336 struct jit_code_entry cur_entry;
1337 struct jit_program_space_data *ps_data;
1338 CORE_ADDR cur_entry_addr;
1341 fprintf_unfiltered (gdb_stdlog, "jit_inferior_init\n");
1343 jit_prepend_unwinder (gdbarch);
1345 ps_data = get_jit_program_space_data ();
1346 if (jit_breakpoint_re_set_internal (gdbarch, ps_data) != 0)
1349 /* Read the descriptor so we can check the version number and load
1350 any already JITed functions. */
1351 if (!jit_read_descriptor (gdbarch, &descriptor, ps_data))
1354 /* Check that the version number agrees with that we support. */
1355 if (descriptor.version != 1)
1357 printf_unfiltered (_("Unsupported JIT protocol version %ld "
1358 "in descriptor (expected 1)\n"),
1359 (long) descriptor.version);
1363 /* If we've attached to a running program, we need to check the descriptor
1364 to register any functions that were already generated. */
1365 for (cur_entry_addr = descriptor.first_entry;
1366 cur_entry_addr != 0;
1367 cur_entry_addr = cur_entry.next_entry)
1369 jit_read_code_entry (gdbarch, cur_entry_addr, &cur_entry);
1371 /* This hook may be called many times during setup, so make sure we don't
1372 add the same symbol file twice. */
1373 if (jit_find_objf_with_entry_addr (cur_entry_addr) != NULL)
1376 jit_register_code (gdbarch, cur_entry_addr, &cur_entry);
1380 /* inferior_created observer. */
1383 jit_inferior_created (struct target_ops *ops, int from_tty)
1385 jit_inferior_created_hook ();
1388 /* Exported routine to call when an inferior has been created. */
1391 jit_inferior_created_hook (void)
1393 jit_inferior_init (target_gdbarch ());
1396 /* Exported routine to call to re-set the jit breakpoints,
1397 e.g. when a program is rerun. */
1400 jit_breakpoint_re_set (void)
1402 jit_breakpoint_re_set_internal (target_gdbarch (),
1403 get_jit_program_space_data ());
1406 /* This function cleans up any code entries left over when the
1407 inferior exits. We get left over code when the inferior exits
1408 without unregistering its code, for example when it crashes. */
1411 jit_inferior_exit_hook (struct inferior *inf)
1413 struct objfile *objf;
1414 struct objfile *temp;
1416 ALL_OBJFILES_SAFE (objf, temp)
1418 struct jit_objfile_data *objf_data
1419 = (struct jit_objfile_data *) objfile_data (objf, jit_objfile_data);
1421 if (objf_data != NULL && objf_data->addr != 0)
1422 jit_unregister_code (objf);
1427 jit_event_handler (struct gdbarch *gdbarch)
1429 struct jit_descriptor descriptor;
1430 struct jit_code_entry code_entry;
1431 CORE_ADDR entry_addr;
1432 struct objfile *objf;
1434 /* Read the descriptor from remote memory. */
1435 if (!jit_read_descriptor (gdbarch, &descriptor,
1436 get_jit_program_space_data ()))
1438 entry_addr = descriptor.relevant_entry;
1440 /* Do the corresponding action. */
1441 switch (descriptor.action_flag)
1446 jit_read_code_entry (gdbarch, entry_addr, &code_entry);
1447 jit_register_code (gdbarch, entry_addr, &code_entry);
1449 case JIT_UNREGISTER:
1450 objf = jit_find_objf_with_entry_addr (entry_addr);
1452 printf_unfiltered (_("Unable to find JITed code "
1453 "entry at address: %s\n"),
1454 paddress (gdbarch, entry_addr));
1456 jit_unregister_code (objf);
1460 error (_("Unknown action_flag value in JIT descriptor!"));
1465 /* Called to free the data allocated to the jit_program_space_data slot. */
1468 free_objfile_data (struct objfile *objfile, void *data)
1470 struct jit_objfile_data *objf_data = (struct jit_objfile_data *) data;
1472 if (objf_data->register_code != NULL)
1474 struct jit_program_space_data *ps_data;
1477 = ((struct jit_program_space_data *)
1478 program_space_data (objfile->pspace, jit_program_space_data));
1479 if (ps_data != NULL && ps_data->objfile == objfile)
1481 ps_data->objfile = NULL;
1482 delete_breakpoint (ps_data->jit_breakpoint);
1483 ps_data->cached_code_address = 0;
1490 /* Initialize the jit_gdbarch_data slot with an instance of struct
1491 jit_gdbarch_data_type */
1494 jit_gdbarch_data_init (struct obstack *obstack)
1496 struct jit_gdbarch_data_type *data =
1497 XOBNEW (obstack, struct jit_gdbarch_data_type);
1499 data->unwinder_registered = 0;
1504 /* Provide a prototype to silence -Wmissing-prototypes. */
1506 extern void _initialize_jit (void);
1509 _initialize_jit (void)
1511 jit_reader_dir = relocate_gdb_directory (JIT_READER_DIR,
1512 JIT_READER_DIR_RELOCATABLE);
1513 add_setshow_zuinteger_cmd ("jit", class_maintenance, &jit_debug,
1514 _("Set JIT debugging."),
1515 _("Show JIT debugging."),
1516 _("When non-zero, JIT debugging is enabled."),
1519 &setdebuglist, &showdebuglist);
1521 observer_attach_inferior_created (jit_inferior_created);
1522 observer_attach_inferior_exit (jit_inferior_exit_hook);
1523 observer_attach_breakpoint_deleted (jit_breakpoint_deleted);
1526 register_objfile_data_with_cleanup (NULL, free_objfile_data);
1527 jit_program_space_data =
1528 register_program_space_data_with_cleanup (NULL,
1529 jit_program_space_data_cleanup);
1530 jit_gdbarch_data = gdbarch_data_register_pre_init (jit_gdbarch_data_init);
1531 if (is_dl_available ())
1533 struct cmd_list_element *c;
1535 c = add_com ("jit-reader-load", no_class, jit_reader_load_command, _("\
1536 Load FILE as debug info reader and unwinder for JIT compiled code.\n\
1537 Usage: jit-reader-load FILE\n\
1538 Try to load file FILE as a debug info reader (and unwinder) for\n\
1539 JIT compiled code. The file is loaded from " JIT_READER_DIR ",\n\
1540 relocated relative to the GDB executable if required."));
1541 set_cmd_completer (c, filename_completer);
1543 c = add_com ("jit-reader-unload", no_class,
1544 jit_reader_unload_command, _("\
1545 Unload the currently loaded JIT debug info reader.\n\
1546 Usage: jit-reader-unload\n\n\
1547 Do \"help jit-reader-load\" for info on loading debug info readers."));
1548 set_cmd_completer (c, noop_completer);