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 program_space_data *jit_program_space_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-program space structure recording which objfile has the JIT
240 struct jit_program_space_data
242 /* The objfile. This is NULL if no objfile holds the JIT
245 struct objfile *objfile;
247 /* If this program space 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 program space.
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_program_space_data for current program space. Allocate
309 if not already present. */
311 static struct jit_program_space_data *
312 get_jit_program_space_data (void)
314 struct jit_program_space_data *ps_data;
316 ps_data = program_space_data (current_program_space, jit_program_space_data);
319 ps_data = XZALLOC (struct jit_program_space_data);
320 set_program_space_data (current_program_space, jit_program_space_data,
328 jit_program_space_data_cleanup (struct program_space *ps, void *arg)
333 /* Helper function for reading the global JIT descriptor from remote
334 memory. Returns 1 if all went well, 0 otherwise. */
337 jit_read_descriptor (struct gdbarch *gdbarch,
338 struct jit_descriptor *descriptor,
339 struct jit_program_space_data *ps_data)
342 struct type *ptr_type;
346 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
347 struct jit_objfile_data *objf_data;
349 if (ps_data->objfile == NULL)
351 objf_data = get_jit_objfile_data (ps_data->objfile);
352 if (objf_data->descriptor == NULL)
356 fprintf_unfiltered (gdb_stdlog,
357 "jit_read_descriptor, descriptor_addr = %s\n",
358 paddress (gdbarch, SYMBOL_VALUE_ADDRESS (objf_data->descriptor)));
360 /* Figure out how big the descriptor is on the remote and how to read it. */
361 ptr_type = builtin_type (gdbarch)->builtin_data_ptr;
362 ptr_size = TYPE_LENGTH (ptr_type);
363 desc_size = 8 + 2 * ptr_size; /* Two 32-bit ints and two pointers. */
364 desc_buf = alloca (desc_size);
366 /* Read the descriptor. */
367 err = target_read_memory (SYMBOL_VALUE_ADDRESS (objf_data->descriptor),
368 desc_buf, desc_size);
371 printf_unfiltered (_("Unable to read JIT descriptor from "
376 /* Fix the endianness to match the host. */
377 descriptor->version = extract_unsigned_integer (&desc_buf[0], 4, byte_order);
378 descriptor->action_flag =
379 extract_unsigned_integer (&desc_buf[4], 4, byte_order);
380 descriptor->relevant_entry = extract_typed_address (&desc_buf[8], ptr_type);
381 descriptor->first_entry =
382 extract_typed_address (&desc_buf[8 + ptr_size], ptr_type);
387 /* Helper function for reading a JITed code entry from remote memory. */
390 jit_read_code_entry (struct gdbarch *gdbarch,
391 CORE_ADDR code_addr, struct jit_code_entry *code_entry)
394 struct type *ptr_type;
399 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
401 /* Figure out how big the entry is on the remote and how to read it. */
402 ptr_type = builtin_type (gdbarch)->builtin_data_ptr;
403 ptr_size = TYPE_LENGTH (ptr_type);
405 /* Figure out where the longlong value will be. */
406 align_bytes = gdbarch_long_long_align_bit (gdbarch) / 8;
408 off = (off + (align_bytes - 1)) & ~(align_bytes - 1);
410 entry_size = off + 8; /* Three pointers and one 64-bit int. */
411 entry_buf = alloca (entry_size);
413 /* Read the entry. */
414 err = target_read_memory (code_addr, entry_buf, entry_size);
416 error (_("Unable to read JIT code entry from remote memory!"));
418 /* Fix the endianness to match the host. */
419 ptr_type = builtin_type (gdbarch)->builtin_data_ptr;
420 code_entry->next_entry = extract_typed_address (&entry_buf[0], ptr_type);
421 code_entry->prev_entry =
422 extract_typed_address (&entry_buf[ptr_size], ptr_type);
423 code_entry->symfile_addr =
424 extract_typed_address (&entry_buf[2 * ptr_size], ptr_type);
425 code_entry->symfile_size =
426 extract_unsigned_integer (&entry_buf[off], 8, byte_order);
429 /* Proxy object for building a block. */
433 /* gdb_blocks are linked into a tree structure. Next points to the
434 next node at the same depth as this block and parent to the
436 struct gdb_block *next, *parent;
438 /* Points to the "real" block that is being built out of this
439 instance. This block will be added to a blockvector, which will
440 then be added to a symtab. */
441 struct block *real_block;
443 /* The first and last code address corresponding to this block. */
444 CORE_ADDR begin, end;
446 /* The name of this block (if any). If this is non-NULL, the
447 FUNCTION symbol symbol is set to this value. */
451 /* Proxy object for building a symtab. */
455 /* The list of blocks in this symtab. These will eventually be
456 converted to real blocks. */
457 struct gdb_block *blocks;
459 /* The number of blocks inserted. */
462 /* A mapping between line numbers to PC. */
463 struct linetable *linetable;
465 /* The source file for this symtab. */
466 const char *file_name;
467 struct gdb_symtab *next;
470 /* Proxy object for building an object. */
474 struct gdb_symtab *symtabs;
477 /* The type of the `private' data passed around by the callback
480 typedef CORE_ADDR jit_dbg_reader_data;
482 /* The reader calls into this function to read data off the targets
485 static enum gdb_status
486 jit_target_read_impl (GDB_CORE_ADDR target_mem, void *gdb_buf, int len)
488 int result = target_read_memory ((CORE_ADDR) target_mem, gdb_buf, len);
495 /* The reader calls into this function to create a new gdb_object
496 which it can then pass around to the other callbacks. Right now,
497 all that is required is allocating the memory. */
499 static struct gdb_object *
500 jit_object_open_impl (struct gdb_symbol_callbacks *cb)
502 /* CB is not required right now, but sometime in the future we might
503 need a handle to it, and we'd like to do that without breaking
505 return XZALLOC (struct gdb_object);
508 /* Readers call into this function to open a new gdb_symtab, which,
509 again, is passed around to other callbacks. */
511 static struct gdb_symtab *
512 jit_symtab_open_impl (struct gdb_symbol_callbacks *cb,
513 struct gdb_object *object,
514 const char *file_name)
516 struct gdb_symtab *ret;
518 /* CB stays unused. See comment in jit_object_open_impl. */
520 ret = XZALLOC (struct gdb_symtab);
521 ret->file_name = file_name ? xstrdup (file_name) : xstrdup ("");
522 ret->next = object->symtabs;
523 object->symtabs = ret;
527 /* Returns true if the block corresponding to old should be placed
528 before the block corresponding to new in the final blockvector. */
531 compare_block (const struct gdb_block *const old,
532 const struct gdb_block *const new)
536 if (old->begin < new->begin)
538 else if (old->begin == new->begin)
540 if (old->end > new->end)
549 /* Called by readers to open a new gdb_block. This function also
550 inserts the new gdb_block in the correct place in the corresponding
553 static struct gdb_block *
554 jit_block_open_impl (struct gdb_symbol_callbacks *cb,
555 struct gdb_symtab *symtab, struct gdb_block *parent,
556 GDB_CORE_ADDR begin, GDB_CORE_ADDR end, const char *name)
558 struct gdb_block *block = XZALLOC (struct gdb_block);
560 block->next = symtab->blocks;
561 block->begin = (CORE_ADDR) begin;
562 block->end = (CORE_ADDR) end;
563 block->name = name ? xstrdup (name) : NULL;
564 block->parent = parent;
566 /* Ensure that the blocks are inserted in the correct (reverse of
567 the order expected by blockvector). */
568 if (compare_block (symtab->blocks, block))
570 symtab->blocks = block;
574 struct gdb_block *i = symtab->blocks;
578 /* Guaranteed to terminate, since compare_block (NULL, _)
580 if (compare_block (i->next, block))
582 block->next = i->next;
593 /* Readers call this to add a line mapping (from PC to line number) to
597 jit_symtab_line_mapping_add_impl (struct gdb_symbol_callbacks *cb,
598 struct gdb_symtab *stab, int nlines,
599 struct gdb_line_mapping *map)
606 stab->linetable = xmalloc (sizeof (struct linetable)
607 + (nlines - 1) * sizeof (struct linetable_entry));
608 stab->linetable->nitems = nlines;
609 for (i = 0; i < nlines; i++)
611 stab->linetable->item[i].pc = (CORE_ADDR) map[i].pc;
612 stab->linetable->item[i].line = map[i].line;
616 /* Called by readers to close a gdb_symtab. Does not need to do
617 anything as of now. */
620 jit_symtab_close_impl (struct gdb_symbol_callbacks *cb,
621 struct gdb_symtab *stab)
623 /* Right now nothing needs to be done here. We may need to do some
624 cleanup here in the future (again, without breaking the plugin
628 /* Transform STAB to a proper symtab, and add it it OBJFILE. */
631 finalize_symtab (struct gdb_symtab *stab, struct objfile *objfile)
633 struct symtab *symtab;
634 struct gdb_block *gdb_block_iter, *gdb_block_iter_tmp;
635 struct block *block_iter;
636 int actual_nblocks, i, blockvector_size;
637 CORE_ADDR begin, end;
639 actual_nblocks = FIRST_LOCAL_BLOCK + stab->nblocks;
641 symtab = allocate_symtab (stab->file_name, objfile);
642 /* JIT compilers compile in memory. */
643 symtab->dirname = NULL;
645 /* Copy over the linetable entry if one was provided. */
648 int size = ((stab->linetable->nitems - 1)
649 * sizeof (struct linetable_entry)
650 + sizeof (struct linetable));
651 LINETABLE (symtab) = obstack_alloc (&objfile->objfile_obstack, size);
652 memcpy (LINETABLE (symtab), stab->linetable, size);
656 LINETABLE (symtab) = NULL;
659 blockvector_size = (sizeof (struct blockvector)
660 + (actual_nblocks - 1) * sizeof (struct block *));
661 symtab->blockvector = obstack_alloc (&objfile->objfile_obstack,
664 /* (begin, end) will contain the PC range this entire blockvector
667 BLOCKVECTOR_MAP (symtab->blockvector) = NULL;
668 begin = stab->blocks->begin;
669 end = stab->blocks->end;
670 BLOCKVECTOR_NBLOCKS (symtab->blockvector) = actual_nblocks;
672 /* First run over all the gdb_block objects, creating a real block
673 object for each. Simultaneously, keep setting the real_block
675 for (i = (actual_nblocks - 1), gdb_block_iter = stab->blocks;
676 i >= FIRST_LOCAL_BLOCK;
677 i--, gdb_block_iter = gdb_block_iter->next)
679 struct block *new_block = allocate_block (&objfile->objfile_obstack);
680 struct symbol *block_name = allocate_symbol (objfile);
681 struct type *block_type = arch_type (get_objfile_arch (objfile),
686 BLOCK_DICT (new_block) = dict_create_linear (&objfile->objfile_obstack,
688 /* The address range. */
689 BLOCK_START (new_block) = (CORE_ADDR) gdb_block_iter->begin;
690 BLOCK_END (new_block) = (CORE_ADDR) gdb_block_iter->end;
693 SYMBOL_DOMAIN (block_name) = VAR_DOMAIN;
694 SYMBOL_ACLASS_INDEX (block_name) = LOC_BLOCK;
695 SYMBOL_SYMTAB (block_name) = symtab;
696 SYMBOL_TYPE (block_name) = lookup_function_type (block_type);
697 SYMBOL_BLOCK_VALUE (block_name) = new_block;
699 block_name->ginfo.name = obstack_copy0 (&objfile->objfile_obstack,
700 gdb_block_iter->name,
701 strlen (gdb_block_iter->name));
703 BLOCK_FUNCTION (new_block) = block_name;
705 BLOCKVECTOR_BLOCK (symtab->blockvector, i) = new_block;
706 if (begin > BLOCK_START (new_block))
707 begin = BLOCK_START (new_block);
708 if (end < BLOCK_END (new_block))
709 end = BLOCK_END (new_block);
711 gdb_block_iter->real_block = new_block;
714 /* Now add the special blocks. */
716 for (i = 0; i < FIRST_LOCAL_BLOCK; i++)
718 struct block *new_block;
720 new_block = (i == GLOBAL_BLOCK
721 ? allocate_global_block (&objfile->objfile_obstack)
722 : allocate_block (&objfile->objfile_obstack));
723 BLOCK_DICT (new_block) = dict_create_linear (&objfile->objfile_obstack,
725 BLOCK_SUPERBLOCK (new_block) = block_iter;
726 block_iter = new_block;
728 BLOCK_START (new_block) = (CORE_ADDR) begin;
729 BLOCK_END (new_block) = (CORE_ADDR) end;
731 BLOCKVECTOR_BLOCK (symtab->blockvector, i) = new_block;
733 if (i == GLOBAL_BLOCK)
734 set_block_symtab (new_block, symtab);
737 /* Fill up the superblock fields for the real blocks, using the
738 real_block fields populated earlier. */
739 for (gdb_block_iter = stab->blocks;
741 gdb_block_iter = gdb_block_iter->next)
743 if (gdb_block_iter->parent != NULL)
745 /* If the plugin specifically mentioned a parent block, we
747 BLOCK_SUPERBLOCK (gdb_block_iter->real_block) =
748 gdb_block_iter->parent->real_block;
752 /* And if not, we set a default parent block. */
753 BLOCK_SUPERBLOCK (gdb_block_iter->real_block) =
754 BLOCKVECTOR_BLOCK (symtab->blockvector, STATIC_BLOCK);
759 gdb_block_iter = stab->blocks;
761 for (gdb_block_iter = stab->blocks, gdb_block_iter_tmp = gdb_block_iter->next;
763 gdb_block_iter = gdb_block_iter_tmp)
765 xfree ((void *) gdb_block_iter->name);
766 xfree (gdb_block_iter);
768 xfree (stab->linetable);
769 xfree ((char *) stab->file_name);
773 /* Called when closing a gdb_objfile. Converts OBJ to a proper
777 jit_object_close_impl (struct gdb_symbol_callbacks *cb,
778 struct gdb_object *obj)
780 struct gdb_symtab *i, *j;
781 struct objfile *objfile;
782 jit_dbg_reader_data *priv_data;
784 priv_data = cb->priv_data;
786 objfile = allocate_objfile (NULL, 0);
787 objfile->gdbarch = target_gdbarch ();
789 terminate_minimal_symbol_table (objfile);
791 objfile->name = "<< JIT compiled code >>";
794 for (i = obj->symtabs; i; i = j)
797 finalize_symtab (i, objfile);
799 add_objfile_entry (objfile, *priv_data);
803 /* Try to read CODE_ENTRY using the loaded jit reader (if any).
804 ENTRY_ADDR is the address of the struct jit_code_entry in the
805 inferior address space. */
808 jit_reader_try_read_symtab (struct jit_code_entry *code_entry,
809 CORE_ADDR entry_addr)
813 jit_dbg_reader_data priv_data;
814 struct gdb_reader_funcs *funcs;
815 volatile struct gdb_exception e;
816 struct gdb_symbol_callbacks callbacks =
818 jit_object_open_impl,
819 jit_symtab_open_impl,
821 jit_symtab_close_impl,
822 jit_object_close_impl,
824 jit_symtab_line_mapping_add_impl,
825 jit_target_read_impl,
830 priv_data = entry_addr;
832 if (!loaded_jit_reader)
835 gdb_mem = xmalloc (code_entry->symfile_size);
838 TRY_CATCH (e, RETURN_MASK_ALL)
839 if (target_read_memory (code_entry->symfile_addr, gdb_mem,
840 code_entry->symfile_size))
847 funcs = loaded_jit_reader->functions;
848 if (funcs->read (funcs, &callbacks, gdb_mem, code_entry->symfile_size)
854 if (jit_debug && status == 0)
855 fprintf_unfiltered (gdb_stdlog,
856 "Could not read symtab using the loaded JIT reader.\n");
860 /* Try to read CODE_ENTRY using BFD. ENTRY_ADDR is the address of the
861 struct jit_code_entry in the inferior address space. */
864 jit_bfd_try_read_symtab (struct jit_code_entry *code_entry,
865 CORE_ADDR entry_addr,
866 struct gdbarch *gdbarch)
869 struct section_addr_info *sai;
870 struct bfd_section *sec;
871 struct objfile *objfile;
872 struct cleanup *old_cleanups;
874 const struct bfd_arch_info *b;
877 fprintf_unfiltered (gdb_stdlog,
878 "jit_register_code, symfile_addr = %s, "
879 "symfile_size = %s\n",
880 paddress (gdbarch, code_entry->symfile_addr),
881 pulongest (code_entry->symfile_size));
883 nbfd = bfd_open_from_target_memory (code_entry->symfile_addr,
884 code_entry->symfile_size, gnutarget);
887 puts_unfiltered (_("Error opening JITed symbol file, ignoring it.\n"));
891 /* Check the format. NOTE: This initializes important data that GDB uses!
892 We would segfault later without this line. */
893 if (!bfd_check_format (nbfd, bfd_object))
895 printf_unfiltered (_("\
896 JITed symbol file is not an object file, ignoring it.\n"));
897 gdb_bfd_unref (nbfd);
901 /* Check bfd arch. */
902 b = gdbarch_bfd_arch_info (gdbarch);
903 if (b->compatible (b, bfd_get_arch_info (nbfd)) != b)
904 warning (_("JITed object file architecture %s is not compatible "
905 "with target architecture %s."), bfd_get_arch_info
906 (nbfd)->printable_name, b->printable_name);
908 /* Read the section address information out of the symbol file. Since the
909 file is generated by the JIT at runtime, it should all of the absolute
910 addresses that we care about. */
911 sai = alloc_section_addr_info (bfd_count_sections (nbfd));
912 old_cleanups = make_cleanup_free_section_addr_info (sai);
914 for (sec = nbfd->sections; sec != NULL; sec = sec->next)
915 if ((bfd_get_section_flags (nbfd, sec) & (SEC_ALLOC|SEC_LOAD)) != 0)
917 /* We assume that these virtual addresses are absolute, and do not
918 treat them as offsets. */
919 sai->other[i].addr = bfd_get_section_vma (nbfd, sec);
920 sai->other[i].name = xstrdup (bfd_get_section_name (nbfd, sec));
921 sai->other[i].sectindex = sec->index;
924 sai->num_sections = i;
926 /* This call does not take ownership of SAI. */
927 make_cleanup_bfd_unref (nbfd);
928 objfile = symbol_file_add_from_bfd (nbfd, 0, sai, OBJF_SHARED, NULL);
930 do_cleanups (old_cleanups);
931 add_objfile_entry (objfile, entry_addr);
934 /* This function registers code associated with a JIT code entry. It uses the
935 pointer and size pair in the entry to read the symbol file from the remote
936 and then calls symbol_file_add_from_local_memory to add it as though it were
937 a symbol file added by the user. */
940 jit_register_code (struct gdbarch *gdbarch,
941 CORE_ADDR entry_addr, struct jit_code_entry *code_entry)
946 fprintf_unfiltered (gdb_stdlog,
947 "jit_register_code, symfile_addr = %s, "
948 "symfile_size = %s\n",
949 paddress (gdbarch, code_entry->symfile_addr),
950 pulongest (code_entry->symfile_size));
952 success = jit_reader_try_read_symtab (code_entry, entry_addr);
955 jit_bfd_try_read_symtab (code_entry, entry_addr, gdbarch);
958 /* This function unregisters JITed code and frees the corresponding
962 jit_unregister_code (struct objfile *objfile)
964 free_objfile (objfile);
967 /* Look up the objfile with this code entry address. */
969 static struct objfile *
970 jit_find_objf_with_entry_addr (CORE_ADDR entry_addr)
972 struct objfile *objf;
976 struct jit_objfile_data *objf_data;
978 objf_data = objfile_data (objf, jit_objfile_data);
979 if (objf_data != NULL && objf_data->addr == entry_addr)
985 /* This is called when a breakpoint is deleted. It updates the
986 inferior's cache, if needed. */
989 jit_breakpoint_deleted (struct breakpoint *b)
991 struct bp_location *iter;
993 if (b->type != bp_jit_event)
996 for (iter = b->loc; iter != NULL; iter = iter->next)
998 struct jit_program_space_data *ps_data;
1000 ps_data = program_space_data (iter->pspace, jit_program_space_data);
1001 if (ps_data != NULL && ps_data->jit_breakpoint == iter->owner)
1003 ps_data->cached_code_address = 0;
1004 ps_data->jit_breakpoint = NULL;
1009 /* (Re-)Initialize the jit breakpoint if necessary.
1010 Return 0 on success. */
1013 jit_breakpoint_re_set_internal (struct gdbarch *gdbarch,
1014 struct jit_program_space_data *ps_data)
1016 struct bound_minimal_symbol reg_symbol;
1017 struct minimal_symbol *desc_symbol;
1018 struct jit_objfile_data *objf_data;
1021 if (ps_data->objfile == NULL)
1023 /* Lookup the registration symbol. If it is missing, then we
1024 assume we are not attached to a JIT. */
1025 reg_symbol = lookup_minimal_symbol_and_objfile (jit_break_name);
1026 if (reg_symbol.minsym == NULL
1027 || SYMBOL_VALUE_ADDRESS (reg_symbol.minsym) == 0)
1030 desc_symbol = lookup_minimal_symbol (jit_descriptor_name, NULL,
1031 reg_symbol.objfile);
1032 if (desc_symbol == NULL || SYMBOL_VALUE_ADDRESS (desc_symbol) == 0)
1035 objf_data = get_jit_objfile_data (reg_symbol.objfile);
1036 objf_data->register_code = reg_symbol.minsym;
1037 objf_data->descriptor = desc_symbol;
1039 ps_data->objfile = reg_symbol.objfile;
1042 objf_data = get_jit_objfile_data (ps_data->objfile);
1044 addr = SYMBOL_VALUE_ADDRESS (objf_data->register_code);
1047 fprintf_unfiltered (gdb_stdlog,
1048 "jit_breakpoint_re_set_internal, "
1049 "breakpoint_addr = %s\n",
1050 paddress (gdbarch, addr));
1052 if (ps_data->cached_code_address == addr)
1055 /* Delete the old breakpoint. */
1056 if (ps_data->jit_breakpoint != NULL)
1057 delete_breakpoint (ps_data->jit_breakpoint);
1059 /* Put a breakpoint in the registration symbol. */
1060 ps_data->cached_code_address = addr;
1061 ps_data->jit_breakpoint = create_jit_event_breakpoint (gdbarch, addr);
1066 /* The private data passed around in the frame unwind callback
1069 struct jit_unwind_private
1071 /* Cached register values. See jit_frame_sniffer to see how this
1073 struct gdb_reg_value **registers;
1075 /* The frame being unwound. */
1076 struct frame_info *this_frame;
1079 /* Sets the value of a particular register in this frame. */
1082 jit_unwind_reg_set_impl (struct gdb_unwind_callbacks *cb, int dwarf_regnum,
1083 struct gdb_reg_value *value)
1085 struct jit_unwind_private *priv;
1088 priv = cb->priv_data;
1090 gdb_reg = gdbarch_dwarf2_reg_to_regnum (get_frame_arch (priv->this_frame),
1095 fprintf_unfiltered (gdb_stdlog,
1096 _("Could not recognize DWARF regnum %d"),
1101 gdb_assert (priv->registers);
1102 priv->registers[gdb_reg] = value;
1106 reg_value_free_impl (struct gdb_reg_value *value)
1111 /* Get the value of register REGNUM in the previous frame. */
1113 static struct gdb_reg_value *
1114 jit_unwind_reg_get_impl (struct gdb_unwind_callbacks *cb, int regnum)
1116 struct jit_unwind_private *priv;
1117 struct gdb_reg_value *value;
1119 struct gdbarch *frame_arch;
1121 priv = cb->priv_data;
1122 frame_arch = get_frame_arch (priv->this_frame);
1124 gdb_reg = gdbarch_dwarf2_reg_to_regnum (frame_arch, regnum);
1125 size = register_size (frame_arch, gdb_reg);
1126 value = xmalloc (sizeof (struct gdb_reg_value) + size - 1);
1127 value->defined = deprecated_frame_register_read (priv->this_frame, gdb_reg,
1130 value->free = reg_value_free_impl;
1134 /* gdb_reg_value has a free function, which must be called on each
1135 saved register value. */
1138 jit_dealloc_cache (struct frame_info *this_frame, void *cache)
1140 struct jit_unwind_private *priv_data = cache;
1141 struct gdbarch *frame_arch;
1144 gdb_assert (priv_data->registers);
1145 frame_arch = get_frame_arch (priv_data->this_frame);
1147 for (i = 0; i < gdbarch_num_regs (frame_arch); i++)
1148 if (priv_data->registers[i] && priv_data->registers[i]->free)
1149 priv_data->registers[i]->free (priv_data->registers[i]);
1151 xfree (priv_data->registers);
1155 /* The frame sniffer for the pseudo unwinder.
1157 While this is nominally a frame sniffer, in the case where the JIT
1158 reader actually recognizes the frame, it does a lot more work -- it
1159 unwinds the frame and saves the corresponding register values in
1160 the cache. jit_frame_prev_register simply returns the saved
1164 jit_frame_sniffer (const struct frame_unwind *self,
1165 struct frame_info *this_frame, void **cache)
1167 struct jit_unwind_private *priv_data;
1168 struct gdb_unwind_callbacks callbacks;
1169 struct gdb_reader_funcs *funcs;
1171 callbacks.reg_get = jit_unwind_reg_get_impl;
1172 callbacks.reg_set = jit_unwind_reg_set_impl;
1173 callbacks.target_read = jit_target_read_impl;
1175 if (loaded_jit_reader == NULL)
1178 funcs = loaded_jit_reader->functions;
1180 gdb_assert (!*cache);
1182 *cache = XZALLOC (struct jit_unwind_private);
1184 priv_data->registers =
1185 XCALLOC (gdbarch_num_regs (get_frame_arch (this_frame)),
1186 struct gdb_reg_value *);
1187 priv_data->this_frame = this_frame;
1189 callbacks.priv_data = priv_data;
1191 /* Try to coax the provided unwinder to unwind the stack */
1192 if (funcs->unwind (funcs, &callbacks) == GDB_SUCCESS)
1195 fprintf_unfiltered (gdb_stdlog, _("Successfully unwound frame using "
1200 fprintf_unfiltered (gdb_stdlog, _("Could not unwind frame using "
1203 jit_dealloc_cache (this_frame, *cache);
1210 /* The frame_id function for the pseudo unwinder. Relays the call to
1211 the loaded plugin. */
1214 jit_frame_this_id (struct frame_info *this_frame, void **cache,
1215 struct frame_id *this_id)
1217 struct jit_unwind_private private;
1218 struct gdb_frame_id frame_id;
1219 struct gdb_reader_funcs *funcs;
1220 struct gdb_unwind_callbacks callbacks;
1222 private.registers = NULL;
1223 private.this_frame = this_frame;
1225 /* We don't expect the frame_id function to set any registers, so we
1226 set reg_set to NULL. */
1227 callbacks.reg_get = jit_unwind_reg_get_impl;
1228 callbacks.reg_set = NULL;
1229 callbacks.target_read = jit_target_read_impl;
1230 callbacks.priv_data = &private;
1232 gdb_assert (loaded_jit_reader);
1233 funcs = loaded_jit_reader->functions;
1235 frame_id = funcs->get_frame_id (funcs, &callbacks);
1236 *this_id = frame_id_build (frame_id.stack_address, frame_id.code_address);
1239 /* Pseudo unwinder function. Reads the previously fetched value for
1240 the register from the cache. */
1242 static struct value *
1243 jit_frame_prev_register (struct frame_info *this_frame, void **cache, int reg)
1245 struct jit_unwind_private *priv = *cache;
1246 struct gdb_reg_value *value;
1249 return frame_unwind_got_optimized (this_frame, reg);
1251 gdb_assert (priv->registers);
1252 value = priv->registers[reg];
1253 if (value && value->defined)
1254 return frame_unwind_got_bytes (this_frame, reg, value->value);
1256 return frame_unwind_got_optimized (this_frame, reg);
1259 /* Relay everything back to the unwinder registered by the JIT debug
1262 static const struct frame_unwind jit_frame_unwind =
1265 default_frame_unwind_stop_reason,
1267 jit_frame_prev_register,
1274 /* This is the information that is stored at jit_gdbarch_data for each
1277 struct jit_gdbarch_data_type
1279 /* Has the (pseudo) unwinder been prepended? */
1280 int unwinder_registered;
1283 /* Check GDBARCH and prepend the pseudo JIT unwinder if needed. */
1286 jit_prepend_unwinder (struct gdbarch *gdbarch)
1288 struct jit_gdbarch_data_type *data;
1290 data = gdbarch_data (gdbarch, jit_gdbarch_data);
1291 if (!data->unwinder_registered)
1293 frame_unwind_prepend_unwinder (gdbarch, &jit_frame_unwind);
1294 data->unwinder_registered = 1;
1298 /* Register any already created translations. */
1301 jit_inferior_init (struct gdbarch *gdbarch)
1303 struct jit_descriptor descriptor;
1304 struct jit_code_entry cur_entry;
1305 struct jit_program_space_data *ps_data;
1306 CORE_ADDR cur_entry_addr;
1309 fprintf_unfiltered (gdb_stdlog, "jit_inferior_init\n");
1311 jit_prepend_unwinder (gdbarch);
1313 ps_data = get_jit_program_space_data ();
1314 if (jit_breakpoint_re_set_internal (gdbarch, ps_data) != 0)
1317 /* Read the descriptor so we can check the version number and load
1318 any already JITed functions. */
1319 if (!jit_read_descriptor (gdbarch, &descriptor, ps_data))
1322 /* Check that the version number agrees with that we support. */
1323 if (descriptor.version != 1)
1325 printf_unfiltered (_("Unsupported JIT protocol version %ld "
1326 "in descriptor (expected 1)\n"),
1327 (long) descriptor.version);
1331 /* If we've attached to a running program, we need to check the descriptor
1332 to register any functions that were already generated. */
1333 for (cur_entry_addr = descriptor.first_entry;
1334 cur_entry_addr != 0;
1335 cur_entry_addr = cur_entry.next_entry)
1337 jit_read_code_entry (gdbarch, cur_entry_addr, &cur_entry);
1339 /* This hook may be called many times during setup, so make sure we don't
1340 add the same symbol file twice. */
1341 if (jit_find_objf_with_entry_addr (cur_entry_addr) != NULL)
1344 jit_register_code (gdbarch, cur_entry_addr, &cur_entry);
1348 /* Exported routine to call when an inferior has been created. */
1351 jit_inferior_created_hook (void)
1353 jit_inferior_init (target_gdbarch ());
1356 /* Exported routine to call to re-set the jit breakpoints,
1357 e.g. when a program is rerun. */
1360 jit_breakpoint_re_set (void)
1362 jit_breakpoint_re_set_internal (target_gdbarch (),
1363 get_jit_program_space_data ());
1366 /* This function cleans up any code entries left over when the
1367 inferior exits. We get left over code when the inferior exits
1368 without unregistering its code, for example when it crashes. */
1371 jit_inferior_exit_hook (struct inferior *inf)
1373 struct objfile *objf;
1374 struct objfile *temp;
1376 ALL_OBJFILES_SAFE (objf, temp)
1378 struct jit_objfile_data *objf_data = objfile_data (objf,
1381 if (objf_data != NULL && objf_data->addr != 0)
1382 jit_unregister_code (objf);
1387 jit_event_handler (struct gdbarch *gdbarch)
1389 struct jit_descriptor descriptor;
1390 struct jit_code_entry code_entry;
1391 CORE_ADDR entry_addr;
1392 struct objfile *objf;
1394 /* Read the descriptor from remote memory. */
1395 if (!jit_read_descriptor (gdbarch, &descriptor,
1396 get_jit_program_space_data ()))
1398 entry_addr = descriptor.relevant_entry;
1400 /* Do the corresponding action. */
1401 switch (descriptor.action_flag)
1406 jit_read_code_entry (gdbarch, entry_addr, &code_entry);
1407 jit_register_code (gdbarch, entry_addr, &code_entry);
1409 case JIT_UNREGISTER:
1410 objf = jit_find_objf_with_entry_addr (entry_addr);
1412 printf_unfiltered (_("Unable to find JITed code "
1413 "entry at address: %s\n"),
1414 paddress (gdbarch, entry_addr));
1416 jit_unregister_code (objf);
1420 error (_("Unknown action_flag value in JIT descriptor!"));
1425 /* Called to free the data allocated to the jit_program_space_data slot. */
1428 free_objfile_data (struct objfile *objfile, void *data)
1430 struct jit_objfile_data *objf_data = data;
1432 if (objf_data->register_code != NULL)
1434 struct jit_program_space_data *ps_data;
1436 ps_data = program_space_data (objfile->pspace, jit_program_space_data);
1437 if (ps_data != NULL && ps_data->objfile == objfile)
1438 ps_data->objfile = NULL;
1444 /* Initialize the jit_gdbarch_data slot with an instance of struct
1445 jit_gdbarch_data_type */
1448 jit_gdbarch_data_init (struct obstack *obstack)
1450 struct jit_gdbarch_data_type *data;
1452 data = obstack_alloc (obstack, sizeof (struct jit_gdbarch_data_type));
1453 data->unwinder_registered = 0;
1457 /* Provide a prototype to silence -Wmissing-prototypes. */
1459 extern void _initialize_jit (void);
1462 _initialize_jit (void)
1464 jit_reader_dir = relocate_gdb_directory (JIT_READER_DIR,
1465 JIT_READER_DIR_RELOCATABLE);
1466 add_setshow_zuinteger_cmd ("jit", class_maintenance, &jit_debug,
1467 _("Set JIT debugging."),
1468 _("Show JIT debugging."),
1469 _("When non-zero, JIT debugging is enabled."),
1472 &setdebuglist, &showdebuglist);
1474 observer_attach_inferior_exit (jit_inferior_exit_hook);
1475 observer_attach_breakpoint_deleted (jit_breakpoint_deleted);
1478 register_objfile_data_with_cleanup (NULL, free_objfile_data);
1479 jit_program_space_data =
1480 register_program_space_data_with_cleanup (NULL,
1481 jit_program_space_data_cleanup);
1482 jit_gdbarch_data = gdbarch_data_register_pre_init (jit_gdbarch_data_init);
1483 if (is_dl_available ())
1485 add_com ("jit-reader-load", no_class, jit_reader_load_command, _("\
1486 Load FILE as debug info reader and unwinder for JIT compiled code.\n\
1487 Usage: jit-reader-load FILE\n\
1488 Try to load file FILE as a debug info reader (and unwinder) for\n\
1489 JIT compiled code. The file is loaded from " JIT_READER_DIR ",\n\
1490 relocated relative to the GDB executable if required."));
1491 add_com ("jit-reader-unload", no_class, jit_reader_unload_command, _("\
1492 Unload the currently loaded JIT debug info reader.\n\
1493 Usage: jit-reader-unload FILE\n\n\
1494 Do \"help jit-reader-load\" for info on loading debug info readers."));