1 /* Handle JIT code generation in the inferior for GDB, the GNU Debugger.
3 Copyright (C) 2009-2012 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
23 #include "jit-reader.h"
25 #include "breakpoint.h"
27 #include "dictionary.h"
28 #include "frame-unwind.h"
38 #include "gdb-dlfcn.h"
40 #include "exceptions.h"
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 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 const char *filename = xstrdup ("<in-memory>");
137 struct target_buffer *buffer = xmalloc (sizeof (struct target_buffer));
141 return bfd_openr_iovec (filename, 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 so_name = xstrprintf ("%s/%s", jit_reader_dir, args);
213 prev_cleanup = make_cleanup (xfree, so_name);
215 loaded_jit_reader = jit_reader_load (so_name);
216 do_cleanups (prev_cleanup);
219 /* Provides the jit-reader-unload command. */
222 jit_reader_unload_command (char *args, int from_tty)
224 if (!loaded_jit_reader)
225 error (_("No JIT reader loaded."));
227 loaded_jit_reader->functions->destroy (loaded_jit_reader->functions);
229 gdb_dlclose (loaded_jit_reader->handle);
230 xfree (loaded_jit_reader);
231 loaded_jit_reader = NULL;
234 /* Per-inferior structure recording which objfile has the JIT
237 struct jit_inferior_data
239 /* The objfile. This is NULL if no objfile holds the JIT
242 struct objfile *objfile;
245 /* Per-objfile structure recording the addresses in the inferior. */
247 struct jit_objfile_data
249 /* Symbol for __jit_debug_register_code. */
250 struct minimal_symbol *register_code;
252 /* Symbol for __jit_debug_descriptor. */
253 struct minimal_symbol *descriptor;
255 /* Address of struct jit_code_entry in this objfile. */
259 /* Fetch the jit_objfile_data associated with OBJF. If no data exists
260 yet, make a new structure and attach it. */
262 static struct jit_objfile_data *
263 get_jit_objfile_data (struct objfile *objf)
265 struct jit_objfile_data *objf_data;
267 objf_data = objfile_data (objf, jit_objfile_data);
268 if (objf_data == NULL)
270 objf_data = XZALLOC (struct jit_objfile_data);
271 set_objfile_data (objf, jit_objfile_data, objf_data);
277 /* Remember OBJFILE has been created for struct jit_code_entry located
278 at inferior address ENTRY. */
281 add_objfile_entry (struct objfile *objfile, CORE_ADDR entry)
283 struct jit_objfile_data *objf_data;
285 objf_data = get_jit_objfile_data (objfile);
286 objf_data->addr = entry;
289 /* Return jit_inferior_data for current inferior. Allocate if not already
292 static struct jit_inferior_data *
293 get_jit_inferior_data (void)
295 struct inferior *inf;
296 struct jit_inferior_data *inf_data;
298 inf = current_inferior ();
299 inf_data = inferior_data (inf, jit_inferior_data);
300 if (inf_data == NULL)
302 inf_data = XZALLOC (struct jit_inferior_data);
303 set_inferior_data (inf, jit_inferior_data, inf_data);
310 jit_inferior_data_cleanup (struct inferior *inf, void *arg)
315 /* Helper function for reading the global JIT descriptor from remote
316 memory. Returns 1 if all went well, 0 otherwise. */
319 jit_read_descriptor (struct gdbarch *gdbarch,
320 struct jit_descriptor *descriptor,
321 struct jit_inferior_data *inf_data)
324 struct type *ptr_type;
328 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
329 struct jit_objfile_data *objf_data;
331 if (inf_data->objfile == NULL)
333 objf_data = get_jit_objfile_data (inf_data->objfile);
334 if (objf_data->descriptor == NULL)
338 fprintf_unfiltered (gdb_stdlog,
339 "jit_read_descriptor, descriptor_addr = %s\n",
340 paddress (gdbarch, SYMBOL_VALUE_ADDRESS (objf_data->descriptor)));
342 /* Figure out how big the descriptor is on the remote and how to read it. */
343 ptr_type = builtin_type (gdbarch)->builtin_data_ptr;
344 ptr_size = TYPE_LENGTH (ptr_type);
345 desc_size = 8 + 2 * ptr_size; /* Two 32-bit ints and two pointers. */
346 desc_buf = alloca (desc_size);
348 /* Read the descriptor. */
349 err = target_read_memory (SYMBOL_VALUE_ADDRESS (objf_data->descriptor),
350 desc_buf, desc_size);
353 printf_unfiltered (_("Unable to read JIT descriptor from "
358 /* Fix the endianness to match the host. */
359 descriptor->version = extract_unsigned_integer (&desc_buf[0], 4, byte_order);
360 descriptor->action_flag =
361 extract_unsigned_integer (&desc_buf[4], 4, byte_order);
362 descriptor->relevant_entry = extract_typed_address (&desc_buf[8], ptr_type);
363 descriptor->first_entry =
364 extract_typed_address (&desc_buf[8 + ptr_size], ptr_type);
369 /* Helper function for reading a JITed code entry from remote memory. */
372 jit_read_code_entry (struct gdbarch *gdbarch,
373 CORE_ADDR code_addr, struct jit_code_entry *code_entry)
376 struct type *ptr_type;
381 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
383 /* Figure out how big the entry is on the remote and how to read it. */
384 ptr_type = builtin_type (gdbarch)->builtin_data_ptr;
385 ptr_size = TYPE_LENGTH (ptr_type);
387 /* Figure out where the longlong value will be. */
388 align_bytes = gdbarch_long_long_align_bit (gdbarch) / 8;
390 off = (off + (align_bytes - 1)) & ~(align_bytes - 1);
392 entry_size = off + 8; /* Three pointers and one 64-bit int. */
393 entry_buf = alloca (entry_size);
395 /* Read the entry. */
396 err = target_read_memory (code_addr, entry_buf, entry_size);
398 error (_("Unable to read JIT code entry from remote memory!"));
400 /* Fix the endianness to match the host. */
401 ptr_type = builtin_type (gdbarch)->builtin_data_ptr;
402 code_entry->next_entry = extract_typed_address (&entry_buf[0], ptr_type);
403 code_entry->prev_entry =
404 extract_typed_address (&entry_buf[ptr_size], ptr_type);
405 code_entry->symfile_addr =
406 extract_typed_address (&entry_buf[2 * ptr_size], ptr_type);
407 code_entry->symfile_size =
408 extract_unsigned_integer (&entry_buf[off], 8, byte_order);
411 /* Proxy object for building a block. */
415 /* gdb_blocks are linked into a tree structure. Next points to the
416 next node at the same depth as this block and parent to the
418 struct gdb_block *next, *parent;
420 /* Points to the "real" block that is being built out of this
421 instance. This block will be added to a blockvector, which will
422 then be added to a symtab. */
423 struct block *real_block;
425 /* The first and last code address corresponding to this block. */
426 CORE_ADDR begin, end;
428 /* The name of this block (if any). If this is non-NULL, the
429 FUNCTION symbol symbol is set to this value. */
433 /* Proxy object for building a symtab. */
437 /* The list of blocks in this symtab. These will eventually be
438 converted to real blocks. */
439 struct gdb_block *blocks;
441 /* The number of blocks inserted. */
444 /* A mapping between line numbers to PC. */
445 struct linetable *linetable;
447 /* The source file for this symtab. */
448 const char *file_name;
449 struct gdb_symtab *next;
452 /* Proxy object for building an object. */
456 struct gdb_symtab *symtabs;
459 /* The type of the `private' data passed around by the callback
462 typedef CORE_ADDR jit_dbg_reader_data;
464 /* The reader calls into this function to read data off the targets
467 static enum gdb_status
468 jit_target_read_impl (GDB_CORE_ADDR target_mem, void *gdb_buf, int len)
470 int result = target_read_memory ((CORE_ADDR) target_mem, gdb_buf, len);
477 /* The reader calls into this function to create a new gdb_object
478 which it can then pass around to the other callbacks. Right now,
479 all that is required is allocating the memory. */
481 static struct gdb_object *
482 jit_object_open_impl (struct gdb_symbol_callbacks *cb)
484 /* CB is not required right now, but sometime in the future we might
485 need a handle to it, and we'd like to do that without breaking
487 return XZALLOC (struct gdb_object);
490 /* Readers call into this function to open a new gdb_symtab, which,
491 again, is passed around to other callbacks. */
493 static struct gdb_symtab *
494 jit_symtab_open_impl (struct gdb_symbol_callbacks *cb,
495 struct gdb_object *object,
496 const char *file_name)
498 struct gdb_symtab *ret;
500 /* CB stays unused. See comment in jit_object_open_impl. */
502 ret = XZALLOC (struct gdb_symtab);
503 ret->file_name = file_name ? xstrdup (file_name) : xstrdup ("");
504 ret->next = object->symtabs;
505 object->symtabs = ret;
509 /* Returns true if the block corresponding to old should be placed
510 before the block corresponding to new in the final blockvector. */
513 compare_block (const struct gdb_block *const old,
514 const struct gdb_block *const new)
518 if (old->begin < new->begin)
520 else if (old->begin == new->begin)
522 if (old->end > new->end)
531 /* Called by readers to open a new gdb_block. This function also
532 inserts the new gdb_block in the correct place in the corresponding
535 static struct gdb_block *
536 jit_block_open_impl (struct gdb_symbol_callbacks *cb,
537 struct gdb_symtab *symtab, struct gdb_block *parent,
538 GDB_CORE_ADDR begin, GDB_CORE_ADDR end, const char *name)
540 struct gdb_block *block = XZALLOC (struct gdb_block);
542 block->next = symtab->blocks;
543 block->begin = (CORE_ADDR) begin;
544 block->end = (CORE_ADDR) end;
545 block->name = name ? xstrdup (name) : NULL;
546 block->parent = parent;
548 /* Ensure that the blocks are inserted in the correct (reverse of
549 the order expected by blockvector). */
550 if (compare_block (symtab->blocks, block))
552 symtab->blocks = block;
556 struct gdb_block *i = symtab->blocks;
560 /* Guaranteed to terminate, since compare_block (NULL, _)
562 if (compare_block (i->next, block))
564 block->next = i->next;
575 /* Readers call this to add a line mapping (from PC to line number) to
579 jit_symtab_line_mapping_add_impl (struct gdb_symbol_callbacks *cb,
580 struct gdb_symtab *stab, int nlines,
581 struct gdb_line_mapping *map)
588 stab->linetable = xmalloc (sizeof (struct linetable)
589 + (nlines - 1) * sizeof (struct linetable_entry));
590 stab->linetable->nitems = nlines;
591 for (i = 0; i < nlines; i++)
593 stab->linetable->item[i].pc = (CORE_ADDR) map[i].pc;
594 stab->linetable->item[i].line = map[i].line;
598 /* Called by readers to close a gdb_symtab. Does not need to do
599 anything as of now. */
602 jit_symtab_close_impl (struct gdb_symbol_callbacks *cb,
603 struct gdb_symtab *stab)
605 /* Right now nothing needs to be done here. We may need to do some
606 cleanup here in the future (again, without breaking the plugin
610 /* Transform STAB to a proper symtab, and add it it OBJFILE. */
613 finalize_symtab (struct gdb_symtab *stab, struct objfile *objfile)
615 struct symtab *symtab;
616 struct gdb_block *gdb_block_iter, *gdb_block_iter_tmp;
617 struct block *block_iter;
618 int actual_nblocks, i, blockvector_size;
619 CORE_ADDR begin, end;
621 actual_nblocks = FIRST_LOCAL_BLOCK + stab->nblocks;
623 symtab = allocate_symtab (stab->file_name, objfile);
624 /* JIT compilers compile in memory. */
625 symtab->dirname = NULL;
627 /* Copy over the linetable entry if one was provided. */
630 int size = ((stab->linetable->nitems - 1)
631 * sizeof (struct linetable_entry)
632 + sizeof (struct linetable));
633 LINETABLE (symtab) = obstack_alloc (&objfile->objfile_obstack, size);
634 memcpy (LINETABLE (symtab), stab->linetable, size);
638 LINETABLE (symtab) = NULL;
641 blockvector_size = (sizeof (struct blockvector)
642 + (actual_nblocks - 1) * sizeof (struct block *));
643 symtab->blockvector = obstack_alloc (&objfile->objfile_obstack,
646 /* (begin, end) will contain the PC range this entire blockvector
649 BLOCKVECTOR_MAP (symtab->blockvector) = NULL;
650 begin = stab->blocks->begin;
651 end = stab->blocks->end;
652 BLOCKVECTOR_NBLOCKS (symtab->blockvector) = actual_nblocks;
654 /* First run over all the gdb_block objects, creating a real block
655 object for each. Simultaneously, keep setting the real_block
657 for (i = (actual_nblocks - 1), gdb_block_iter = stab->blocks;
658 i >= FIRST_LOCAL_BLOCK;
659 i--, gdb_block_iter = gdb_block_iter->next)
661 struct block *new_block = allocate_block (&objfile->objfile_obstack);
662 struct symbol *block_name = obstack_alloc (&objfile->objfile_obstack,
663 sizeof (struct symbol));
664 struct type *block_type = arch_type (get_objfile_arch (objfile),
669 BLOCK_DICT (new_block) = dict_create_linear (&objfile->objfile_obstack,
671 /* The address range. */
672 BLOCK_START (new_block) = (CORE_ADDR) gdb_block_iter->begin;
673 BLOCK_END (new_block) = (CORE_ADDR) gdb_block_iter->end;
676 memset (block_name, 0, sizeof (struct symbol));
677 SYMBOL_DOMAIN (block_name) = VAR_DOMAIN;
678 SYMBOL_CLASS (block_name) = LOC_BLOCK;
679 SYMBOL_SYMTAB (block_name) = symtab;
680 SYMBOL_TYPE (block_name) = lookup_function_type (block_type);
681 SYMBOL_BLOCK_VALUE (block_name) = new_block;
683 block_name->ginfo.name = obsavestring (gdb_block_iter->name,
684 strlen (gdb_block_iter->name),
685 &objfile->objfile_obstack);
687 BLOCK_FUNCTION (new_block) = block_name;
689 BLOCKVECTOR_BLOCK (symtab->blockvector, i) = new_block;
690 if (begin > BLOCK_START (new_block))
691 begin = BLOCK_START (new_block);
692 if (end < BLOCK_END (new_block))
693 end = BLOCK_END (new_block);
695 gdb_block_iter->real_block = new_block;
698 /* Now add the special blocks. */
700 for (i = 0; i < FIRST_LOCAL_BLOCK; i++)
702 struct block *new_block;
704 new_block = (i == GLOBAL_BLOCK
705 ? allocate_global_block (&objfile->objfile_obstack)
706 : allocate_block (&objfile->objfile_obstack));
707 BLOCK_DICT (new_block) = dict_create_linear (&objfile->objfile_obstack,
709 BLOCK_SUPERBLOCK (new_block) = block_iter;
710 block_iter = new_block;
712 BLOCK_START (new_block) = (CORE_ADDR) begin;
713 BLOCK_END (new_block) = (CORE_ADDR) end;
715 BLOCKVECTOR_BLOCK (symtab->blockvector, i) = new_block;
717 if (i == GLOBAL_BLOCK)
718 set_block_symtab (new_block, symtab);
721 /* Fill up the superblock fields for the real blocks, using the
722 real_block fields populated earlier. */
723 for (gdb_block_iter = stab->blocks;
725 gdb_block_iter = gdb_block_iter->next)
727 if (gdb_block_iter->parent != NULL)
728 BLOCK_SUPERBLOCK (gdb_block_iter->real_block) =
729 gdb_block_iter->parent->real_block;
733 gdb_block_iter = stab->blocks;
735 for (gdb_block_iter = stab->blocks, gdb_block_iter_tmp = gdb_block_iter->next;
737 gdb_block_iter = gdb_block_iter_tmp)
739 xfree ((void *) gdb_block_iter->name);
740 xfree (gdb_block_iter);
742 xfree (stab->linetable);
743 xfree ((char *) stab->file_name);
747 /* Called when closing a gdb_objfile. Converts OBJ to a proper
751 jit_object_close_impl (struct gdb_symbol_callbacks *cb,
752 struct gdb_object *obj)
754 struct gdb_symtab *i, *j;
755 struct objfile *objfile;
756 jit_dbg_reader_data *priv_data;
758 priv_data = cb->priv_data;
760 objfile = allocate_objfile (NULL, 0);
761 objfile->gdbarch = target_gdbarch;
763 terminate_minimal_symbol_table (objfile);
765 xfree (objfile->name);
766 objfile->name = xstrdup ("<< JIT compiled code >>");
769 for (i = obj->symtabs; i; i = j)
772 finalize_symtab (i, objfile);
774 add_objfile_entry (objfile, *priv_data);
778 /* Try to read CODE_ENTRY using the loaded jit reader (if any).
779 ENTRY_ADDR is the address of the struct jit_code_entry in the
780 inferior address space. */
783 jit_reader_try_read_symtab (struct jit_code_entry *code_entry,
784 CORE_ADDR entry_addr)
788 jit_dbg_reader_data priv_data;
789 struct gdb_reader_funcs *funcs;
790 volatile struct gdb_exception e;
791 struct gdb_symbol_callbacks callbacks =
793 jit_object_open_impl,
794 jit_symtab_open_impl,
796 jit_symtab_close_impl,
797 jit_object_close_impl,
799 jit_symtab_line_mapping_add_impl,
800 jit_target_read_impl,
805 priv_data = entry_addr;
807 if (!loaded_jit_reader)
810 gdb_mem = xmalloc (code_entry->symfile_size);
813 TRY_CATCH (e, RETURN_MASK_ALL)
814 if (target_read_memory (code_entry->symfile_addr, gdb_mem,
815 code_entry->symfile_size))
822 funcs = loaded_jit_reader->functions;
823 if (funcs->read (funcs, &callbacks, gdb_mem, code_entry->symfile_size)
829 if (jit_debug && status == 0)
830 fprintf_unfiltered (gdb_stdlog,
831 "Could not read symtab using the loaded JIT reader.\n");
835 /* Try to read CODE_ENTRY using BFD. ENTRY_ADDR is the address of the
836 struct jit_code_entry in the inferior address space. */
839 jit_bfd_try_read_symtab (struct jit_code_entry *code_entry,
840 CORE_ADDR entry_addr,
841 struct gdbarch *gdbarch)
844 struct section_addr_info *sai;
845 struct bfd_section *sec;
846 struct objfile *objfile;
847 struct cleanup *old_cleanups;
849 const struct bfd_arch_info *b;
852 fprintf_unfiltered (gdb_stdlog,
853 "jit_register_code, symfile_addr = %s, "
854 "symfile_size = %s\n",
855 paddress (gdbarch, code_entry->symfile_addr),
856 pulongest (code_entry->symfile_size));
858 nbfd = bfd_open_from_target_memory (code_entry->symfile_addr,
859 code_entry->symfile_size, gnutarget);
862 puts_unfiltered (_("Error opening JITed symbol file, ignoring it.\n"));
865 nbfd = gdb_bfd_ref (nbfd);
867 /* Check the format. NOTE: This initializes important data that GDB uses!
868 We would segfault later without this line. */
869 if (!bfd_check_format (nbfd, bfd_object))
871 printf_unfiltered (_("\
872 JITed symbol file is not an object file, ignoring it.\n"));
873 gdb_bfd_unref (nbfd);
877 /* Check bfd arch. */
878 b = gdbarch_bfd_arch_info (gdbarch);
879 if (b->compatible (b, bfd_get_arch_info (nbfd)) != b)
880 warning (_("JITed object file architecture %s is not compatible "
881 "with target architecture %s."), bfd_get_arch_info
882 (nbfd)->printable_name, b->printable_name);
884 /* Read the section address information out of the symbol file. Since the
885 file is generated by the JIT at runtime, it should all of the absolute
886 addresses that we care about. */
887 sai = alloc_section_addr_info (bfd_count_sections (nbfd));
888 old_cleanups = make_cleanup_free_section_addr_info (sai);
890 for (sec = nbfd->sections; sec != NULL; sec = sec->next)
891 if ((bfd_get_section_flags (nbfd, sec) & (SEC_ALLOC|SEC_LOAD)) != 0)
893 /* We assume that these virtual addresses are absolute, and do not
894 treat them as offsets. */
895 sai->other[i].addr = bfd_get_section_vma (nbfd, sec);
896 sai->other[i].name = xstrdup (bfd_get_section_name (nbfd, sec));
897 sai->other[i].sectindex = sec->index;
901 /* This call takes ownership of NBFD. It does not take ownership of SAI. */
902 objfile = symbol_file_add_from_bfd (nbfd, 0, sai, OBJF_SHARED, NULL);
904 do_cleanups (old_cleanups);
905 add_objfile_entry (objfile, entry_addr);
908 /* This function registers code associated with a JIT code entry. It uses the
909 pointer and size pair in the entry to read the symbol file from the remote
910 and then calls symbol_file_add_from_local_memory to add it as though it were
911 a symbol file added by the user. */
914 jit_register_code (struct gdbarch *gdbarch,
915 CORE_ADDR entry_addr, struct jit_code_entry *code_entry)
918 const struct bfd_arch_info *b;
919 struct jit_inferior_data *inf_data = get_jit_inferior_data ();
922 fprintf_unfiltered (gdb_stdlog,
923 "jit_register_code, symfile_addr = %s, "
924 "symfile_size = %s\n",
925 paddress (gdbarch, code_entry->symfile_addr),
926 pulongest (code_entry->symfile_size));
928 success = jit_reader_try_read_symtab (code_entry, entry_addr);
931 jit_bfd_try_read_symtab (code_entry, entry_addr, gdbarch);
934 /* This function unregisters JITed code and frees the corresponding
938 jit_unregister_code (struct objfile *objfile)
940 free_objfile (objfile);
943 /* Look up the objfile with this code entry address. */
945 static struct objfile *
946 jit_find_objf_with_entry_addr (CORE_ADDR entry_addr)
948 struct objfile *objf;
952 struct jit_objfile_data *objf_data;
954 objf_data = objfile_data (objf, jit_objfile_data);
955 if (objf_data != NULL && objf_data->addr == entry_addr)
961 /* (Re-)Initialize the jit breakpoint if necessary.
962 Return 0 on success. */
965 jit_breakpoint_re_set_internal (struct gdbarch *gdbarch,
966 struct jit_inferior_data *inf_data)
968 struct minimal_symbol *reg_symbol, *desc_symbol;
969 struct objfile *objf;
970 struct jit_objfile_data *objf_data;
972 if (inf_data->objfile != NULL)
975 /* Lookup the registration symbol. If it is missing, then we assume
976 we are not attached to a JIT. */
977 reg_symbol = lookup_minimal_symbol_and_objfile (jit_break_name, &objf);
978 if (reg_symbol == NULL || SYMBOL_VALUE_ADDRESS (reg_symbol) == 0)
981 desc_symbol = lookup_minimal_symbol (jit_descriptor_name, NULL, objf);
982 if (desc_symbol == NULL || SYMBOL_VALUE_ADDRESS (desc_symbol) == 0)
985 objf_data = get_jit_objfile_data (objf);
986 objf_data->register_code = reg_symbol;
987 objf_data->descriptor = desc_symbol;
989 inf_data->objfile = objf;
991 jit_inferior_init (gdbarch);
994 fprintf_unfiltered (gdb_stdlog,
995 "jit_breakpoint_re_set_internal, "
996 "breakpoint_addr = %s\n",
997 paddress (gdbarch, SYMBOL_VALUE_ADDRESS (reg_symbol)));
999 /* Put a breakpoint in the registration symbol. */
1000 create_jit_event_breakpoint (gdbarch, SYMBOL_VALUE_ADDRESS (reg_symbol));
1005 /* The private data passed around in the frame unwind callback
1008 struct jit_unwind_private
1010 /* Cached register values. See jit_frame_sniffer to see how this
1012 struct gdb_reg_value **registers;
1014 /* The frame being unwound. */
1015 struct frame_info *this_frame;
1018 /* Sets the value of a particular register in this frame. */
1021 jit_unwind_reg_set_impl (struct gdb_unwind_callbacks *cb, int dwarf_regnum,
1022 struct gdb_reg_value *value)
1024 struct jit_unwind_private *priv;
1027 priv = cb->priv_data;
1029 gdb_reg = gdbarch_dwarf2_reg_to_regnum (get_frame_arch (priv->this_frame),
1034 fprintf_unfiltered (gdb_stdlog,
1035 _("Could not recognize DWARF regnum %d"),
1040 gdb_assert (priv->registers);
1041 priv->registers[gdb_reg] = value;
1045 reg_value_free_impl (struct gdb_reg_value *value)
1050 /* Get the value of register REGNUM in the previous frame. */
1052 static struct gdb_reg_value *
1053 jit_unwind_reg_get_impl (struct gdb_unwind_callbacks *cb, int regnum)
1055 struct jit_unwind_private *priv;
1056 struct gdb_reg_value *value;
1058 struct gdbarch *frame_arch;
1060 priv = cb->priv_data;
1061 frame_arch = get_frame_arch (priv->this_frame);
1063 gdb_reg = gdbarch_dwarf2_reg_to_regnum (frame_arch, regnum);
1064 size = register_size (frame_arch, gdb_reg);
1065 value = xmalloc (sizeof (struct gdb_reg_value) + size - 1);
1066 value->defined = frame_register_read (priv->this_frame, gdb_reg,
1069 value->free = reg_value_free_impl;
1073 /* gdb_reg_value has a free function, which must be called on each
1074 saved register value. */
1077 jit_dealloc_cache (struct frame_info *this_frame, void *cache)
1079 struct jit_unwind_private *priv_data = cache;
1080 struct gdbarch *frame_arch;
1083 gdb_assert (priv_data->registers);
1084 frame_arch = get_frame_arch (priv_data->this_frame);
1086 for (i = 0; i < gdbarch_num_regs (frame_arch); i++)
1087 if (priv_data->registers[i] && priv_data->registers[i]->free)
1088 priv_data->registers[i]->free (priv_data->registers[i]);
1090 xfree (priv_data->registers);
1094 /* The frame sniffer for the pseudo unwinder.
1096 While this is nominally a frame sniffer, in the case where the JIT
1097 reader actually recognizes the frame, it does a lot more work -- it
1098 unwinds the frame and saves the corresponding register values in
1099 the cache. jit_frame_prev_register simply returns the saved
1103 jit_frame_sniffer (const struct frame_unwind *self,
1104 struct frame_info *this_frame, void **cache)
1106 struct jit_inferior_data *inf_data;
1107 struct jit_unwind_private *priv_data;
1108 struct gdb_unwind_callbacks callbacks;
1109 struct gdb_reader_funcs *funcs;
1111 inf_data = get_jit_inferior_data ();
1113 callbacks.reg_get = jit_unwind_reg_get_impl;
1114 callbacks.reg_set = jit_unwind_reg_set_impl;
1115 callbacks.target_read = jit_target_read_impl;
1117 if (loaded_jit_reader == NULL)
1120 funcs = loaded_jit_reader->functions;
1122 gdb_assert (!*cache);
1124 *cache = XZALLOC (struct jit_unwind_private);
1126 priv_data->registers =
1127 XCALLOC (gdbarch_num_regs (get_frame_arch (this_frame)),
1128 struct gdb_reg_value *);
1129 priv_data->this_frame = this_frame;
1131 callbacks.priv_data = priv_data;
1133 /* Try to coax the provided unwinder to unwind the stack */
1134 if (funcs->unwind (funcs, &callbacks) == GDB_SUCCESS)
1137 fprintf_unfiltered (gdb_stdlog, _("Successfully unwound frame using "
1142 fprintf_unfiltered (gdb_stdlog, _("Could not unwind frame using "
1145 jit_dealloc_cache (this_frame, *cache);
1152 /* The frame_id function for the pseudo unwinder. Relays the call to
1153 the loaded plugin. */
1156 jit_frame_this_id (struct frame_info *this_frame, void **cache,
1157 struct frame_id *this_id)
1159 struct jit_unwind_private private;
1160 struct gdb_frame_id frame_id;
1161 struct gdb_reader_funcs *funcs;
1162 struct gdb_unwind_callbacks callbacks;
1164 private.registers = NULL;
1165 private.this_frame = this_frame;
1167 /* We don't expect the frame_id function to set any registers, so we
1168 set reg_set to NULL. */
1169 callbacks.reg_get = jit_unwind_reg_get_impl;
1170 callbacks.reg_set = NULL;
1171 callbacks.target_read = jit_target_read_impl;
1172 callbacks.priv_data = &private;
1174 gdb_assert (loaded_jit_reader);
1175 funcs = loaded_jit_reader->functions;
1177 frame_id = funcs->get_frame_id (funcs, &callbacks);
1178 *this_id = frame_id_build (frame_id.stack_address, frame_id.code_address);
1181 /* Pseudo unwinder function. Reads the previously fetched value for
1182 the register from the cache. */
1184 static struct value *
1185 jit_frame_prev_register (struct frame_info *this_frame, void **cache, int reg)
1187 struct jit_unwind_private *priv = *cache;
1188 struct gdb_reg_value *value;
1191 return frame_unwind_got_optimized (this_frame, reg);
1193 gdb_assert (priv->registers);
1194 value = priv->registers[reg];
1195 if (value && value->defined)
1196 return frame_unwind_got_bytes (this_frame, reg, value->value);
1198 return frame_unwind_got_optimized (this_frame, reg);
1201 /* Relay everything back to the unwinder registered by the JIT debug
1204 static const struct frame_unwind jit_frame_unwind =
1207 default_frame_unwind_stop_reason,
1209 jit_frame_prev_register,
1216 /* This is the information that is stored at jit_gdbarch_data for each
1219 struct jit_gdbarch_data_type
1221 /* Has the (pseudo) unwinder been prepended? */
1222 int unwinder_registered;
1225 /* Check GDBARCH and prepend the pseudo JIT unwinder if needed. */
1228 jit_prepend_unwinder (struct gdbarch *gdbarch)
1230 struct jit_gdbarch_data_type *data;
1232 data = gdbarch_data (gdbarch, jit_gdbarch_data);
1233 if (!data->unwinder_registered)
1235 frame_unwind_prepend_unwinder (gdbarch, &jit_frame_unwind);
1236 data->unwinder_registered = 1;
1240 /* Register any already created translations. */
1243 jit_inferior_init (struct gdbarch *gdbarch)
1245 struct jit_descriptor descriptor;
1246 struct jit_code_entry cur_entry;
1247 struct jit_inferior_data *inf_data;
1248 CORE_ADDR cur_entry_addr;
1251 fprintf_unfiltered (gdb_stdlog, "jit_inferior_init\n");
1253 jit_prepend_unwinder (gdbarch);
1255 inf_data = get_jit_inferior_data ();
1256 if (jit_breakpoint_re_set_internal (gdbarch, inf_data) != 0)
1259 /* Read the descriptor so we can check the version number and load
1260 any already JITed functions. */
1261 if (!jit_read_descriptor (gdbarch, &descriptor, inf_data))
1264 /* Check that the version number agrees with that we support. */
1265 if (descriptor.version != 1)
1267 printf_unfiltered (_("Unsupported JIT protocol version %ld "
1268 "in descriptor (expected 1)\n"),
1269 (long) descriptor.version);
1273 /* If we've attached to a running program, we need to check the descriptor
1274 to register any functions that were already generated. */
1275 for (cur_entry_addr = descriptor.first_entry;
1276 cur_entry_addr != 0;
1277 cur_entry_addr = cur_entry.next_entry)
1279 jit_read_code_entry (gdbarch, cur_entry_addr, &cur_entry);
1281 /* This hook may be called many times during setup, so make sure we don't
1282 add the same symbol file twice. */
1283 if (jit_find_objf_with_entry_addr (cur_entry_addr) != NULL)
1286 jit_register_code (gdbarch, cur_entry_addr, &cur_entry);
1290 /* Exported routine to call when an inferior has been created. */
1293 jit_inferior_created_hook (void)
1295 jit_inferior_init (target_gdbarch);
1298 /* Exported routine to call to re-set the jit breakpoints,
1299 e.g. when a program is rerun. */
1302 jit_breakpoint_re_set (void)
1304 jit_breakpoint_re_set_internal (target_gdbarch,
1305 get_jit_inferior_data ());
1308 /* This function cleans up any code entries left over when the
1309 inferior exits. We get left over code when the inferior exits
1310 without unregistering its code, for example when it crashes. */
1313 jit_inferior_exit_hook (struct inferior *inf)
1315 struct objfile *objf;
1316 struct objfile *temp;
1318 ALL_OBJFILES_SAFE (objf, temp)
1320 struct jit_objfile_data *objf_data = objfile_data (objf,
1323 if (objf_data != NULL && objf_data->addr != 0)
1324 jit_unregister_code (objf);
1329 jit_event_handler (struct gdbarch *gdbarch)
1331 struct jit_descriptor descriptor;
1332 struct jit_code_entry code_entry;
1333 CORE_ADDR entry_addr;
1334 struct objfile *objf;
1336 /* Read the descriptor from remote memory. */
1337 if (!jit_read_descriptor (gdbarch, &descriptor, get_jit_inferior_data ()))
1339 entry_addr = descriptor.relevant_entry;
1341 /* Do the corresponding action. */
1342 switch (descriptor.action_flag)
1347 jit_read_code_entry (gdbarch, entry_addr, &code_entry);
1348 jit_register_code (gdbarch, entry_addr, &code_entry);
1350 case JIT_UNREGISTER:
1351 objf = jit_find_objf_with_entry_addr (entry_addr);
1353 printf_unfiltered (_("Unable to find JITed code "
1354 "entry at address: %s\n"),
1355 paddress (gdbarch, entry_addr));
1357 jit_unregister_code (objf);
1361 error (_("Unknown action_flag value in JIT descriptor!"));
1366 /* Called to free the data allocated to the jit_inferior_data slot. */
1369 free_objfile_data (struct objfile *objfile, void *data)
1371 struct jit_objfile_data *objf_data = data;
1373 if (objf_data->register_code != NULL)
1375 struct jit_inferior_data *inf_data = get_jit_inferior_data ();
1377 if (inf_data->objfile == objfile)
1378 inf_data->objfile = NULL;
1384 /* Initialize the jit_gdbarch_data slot with an instance of struct
1385 jit_gdbarch_data_type */
1388 jit_gdbarch_data_init (struct obstack *obstack)
1390 struct jit_gdbarch_data_type *data;
1392 data = obstack_alloc (obstack, sizeof (struct jit_gdbarch_data_type));
1393 data->unwinder_registered = 0;
1397 /* Provide a prototype to silence -Wmissing-prototypes. */
1399 extern void _initialize_jit (void);
1402 _initialize_jit (void)
1404 jit_reader_dir = relocate_gdb_directory (JIT_READER_DIR,
1405 JIT_READER_DIR_RELOCATABLE);
1406 add_setshow_zinteger_cmd ("jit", class_maintenance, &jit_debug,
1407 _("Set JIT debugging."),
1408 _("Show JIT debugging."),
1409 _("When non-zero, JIT debugging is enabled."),
1412 &setdebuglist, &showdebuglist);
1414 observer_attach_inferior_exit (jit_inferior_exit_hook);
1416 register_objfile_data_with_cleanup (NULL, free_objfile_data);
1418 register_inferior_data_with_cleanup (jit_inferior_data_cleanup);
1419 jit_gdbarch_data = gdbarch_data_register_pre_init (jit_gdbarch_data_init);
1420 if (is_dl_available ())
1422 add_com ("jit-reader-load", no_class, jit_reader_load_command, _("\
1423 Load FILE as debug info reader and unwinder for JIT compiled code.\n\
1424 Usage: jit-reader-load FILE\n\
1425 Try to load file FILE as a debug info reader (and unwinder) for\n\
1426 JIT compiled code. The file is loaded from " JIT_READER_DIR ",\n\
1427 relocated relative to the GDB executable if required."));
1428 add_com ("jit-reader-unload", no_class, jit_reader_unload_command, _("\
1429 Unload the currently loaded JIT debug info reader.\n\
1430 Usage: jit-reader-unload FILE\n\n\
1431 Do \"help jit-reader-load\" for info on loading debug info readers."));