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 struct target_buffer *buffer = xmalloc (sizeof (struct target_buffer));
140 return gdb_bfd_openr_iovec ("<in-memory>", target,
148 /* One reader that has been loaded successfully, and can potentially be used to
151 static struct jit_reader
153 struct gdb_reader_funcs *functions;
155 } *loaded_jit_reader = NULL;
157 typedef struct gdb_reader_funcs * (reader_init_fn_type) (void);
158 static const char *reader_init_fn_sym = "gdb_init_reader";
160 /* Try to load FILE_NAME as a JIT debug info reader. */
162 static struct jit_reader *
163 jit_reader_load (const char *file_name)
166 reader_init_fn_type *init_fn;
167 struct jit_reader *new_reader = NULL;
168 struct gdb_reader_funcs *funcs = NULL;
169 struct cleanup *old_cleanups;
172 fprintf_unfiltered (gdb_stdlog, _("Opening shared object %s.\n"),
174 so = gdb_dlopen (file_name);
175 old_cleanups = make_cleanup_dlclose (so);
177 init_fn = gdb_dlsym (so, reader_init_fn_sym);
179 error (_("Could not locate initialization function: %s."),
182 if (gdb_dlsym (so, "plugin_is_GPL_compatible") == NULL)
183 error (_("Reader not GPL compatible."));
186 if (funcs->reader_version != GDB_READER_INTERFACE_VERSION)
187 error (_("Reader version does not match GDB version."));
189 new_reader = XZALLOC (struct jit_reader);
190 new_reader->functions = funcs;
191 new_reader->handle = so;
193 discard_cleanups (old_cleanups);
197 /* Provides the jit-reader-load command. */
200 jit_reader_load_command (char *args, int from_tty)
203 struct cleanup *prev_cleanup;
206 error (_("No reader name provided."));
208 if (loaded_jit_reader != NULL)
209 error (_("JIT reader already loaded. Run jit-reader-unload first."));
211 so_name = xstrprintf ("%s/%s", jit_reader_dir, args);
212 prev_cleanup = make_cleanup (xfree, so_name);
214 loaded_jit_reader = jit_reader_load (so_name);
215 do_cleanups (prev_cleanup);
218 /* Provides the jit-reader-unload command. */
221 jit_reader_unload_command (char *args, int from_tty)
223 if (!loaded_jit_reader)
224 error (_("No JIT reader loaded."));
226 loaded_jit_reader->functions->destroy (loaded_jit_reader->functions);
228 gdb_dlclose (loaded_jit_reader->handle);
229 xfree (loaded_jit_reader);
230 loaded_jit_reader = NULL;
233 /* Per-inferior structure recording which objfile has the JIT
236 struct jit_inferior_data
238 /* The objfile. This is NULL if no objfile holds the JIT
241 struct objfile *objfile;
244 /* Per-objfile structure recording the addresses in the inferior. */
246 struct jit_objfile_data
248 /* Symbol for __jit_debug_register_code. */
249 struct minimal_symbol *register_code;
251 /* Symbol for __jit_debug_descriptor. */
252 struct minimal_symbol *descriptor;
254 /* Address of struct jit_code_entry in this objfile. */
258 /* Fetch the jit_objfile_data associated with OBJF. If no data exists
259 yet, make a new structure and attach it. */
261 static struct jit_objfile_data *
262 get_jit_objfile_data (struct objfile *objf)
264 struct jit_objfile_data *objf_data;
266 objf_data = objfile_data (objf, jit_objfile_data);
267 if (objf_data == NULL)
269 objf_data = XZALLOC (struct jit_objfile_data);
270 set_objfile_data (objf, jit_objfile_data, objf_data);
276 /* Remember OBJFILE has been created for struct jit_code_entry located
277 at inferior address ENTRY. */
280 add_objfile_entry (struct objfile *objfile, CORE_ADDR entry)
282 struct jit_objfile_data *objf_data;
284 objf_data = get_jit_objfile_data (objfile);
285 objf_data->addr = entry;
288 /* Return jit_inferior_data for current inferior. Allocate if not already
291 static struct jit_inferior_data *
292 get_jit_inferior_data (void)
294 struct inferior *inf;
295 struct jit_inferior_data *inf_data;
297 inf = current_inferior ();
298 inf_data = inferior_data (inf, jit_inferior_data);
299 if (inf_data == NULL)
301 inf_data = XZALLOC (struct jit_inferior_data);
302 set_inferior_data (inf, jit_inferior_data, inf_data);
309 jit_inferior_data_cleanup (struct inferior *inf, void *arg)
314 /* Helper function for reading the global JIT descriptor from remote
315 memory. Returns 1 if all went well, 0 otherwise. */
318 jit_read_descriptor (struct gdbarch *gdbarch,
319 struct jit_descriptor *descriptor,
320 struct jit_inferior_data *inf_data)
323 struct type *ptr_type;
327 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
328 struct jit_objfile_data *objf_data;
330 if (inf_data->objfile == NULL)
332 objf_data = get_jit_objfile_data (inf_data->objfile);
333 if (objf_data->descriptor == NULL)
337 fprintf_unfiltered (gdb_stdlog,
338 "jit_read_descriptor, descriptor_addr = %s\n",
339 paddress (gdbarch, SYMBOL_VALUE_ADDRESS (objf_data->descriptor)));
341 /* Figure out how big the descriptor is on the remote and how to read it. */
342 ptr_type = builtin_type (gdbarch)->builtin_data_ptr;
343 ptr_size = TYPE_LENGTH (ptr_type);
344 desc_size = 8 + 2 * ptr_size; /* Two 32-bit ints and two pointers. */
345 desc_buf = alloca (desc_size);
347 /* Read the descriptor. */
348 err = target_read_memory (SYMBOL_VALUE_ADDRESS (objf_data->descriptor),
349 desc_buf, desc_size);
352 printf_unfiltered (_("Unable to read JIT descriptor from "
357 /* Fix the endianness to match the host. */
358 descriptor->version = extract_unsigned_integer (&desc_buf[0], 4, byte_order);
359 descriptor->action_flag =
360 extract_unsigned_integer (&desc_buf[4], 4, byte_order);
361 descriptor->relevant_entry = extract_typed_address (&desc_buf[8], ptr_type);
362 descriptor->first_entry =
363 extract_typed_address (&desc_buf[8 + ptr_size], ptr_type);
368 /* Helper function for reading a JITed code entry from remote memory. */
371 jit_read_code_entry (struct gdbarch *gdbarch,
372 CORE_ADDR code_addr, struct jit_code_entry *code_entry)
375 struct type *ptr_type;
380 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
382 /* Figure out how big the entry is on the remote and how to read it. */
383 ptr_type = builtin_type (gdbarch)->builtin_data_ptr;
384 ptr_size = TYPE_LENGTH (ptr_type);
386 /* Figure out where the longlong value will be. */
387 align_bytes = gdbarch_long_long_align_bit (gdbarch) / 8;
389 off = (off + (align_bytes - 1)) & ~(align_bytes - 1);
391 entry_size = off + 8; /* Three pointers and one 64-bit int. */
392 entry_buf = alloca (entry_size);
394 /* Read the entry. */
395 err = target_read_memory (code_addr, entry_buf, entry_size);
397 error (_("Unable to read JIT code entry from remote memory!"));
399 /* Fix the endianness to match the host. */
400 ptr_type = builtin_type (gdbarch)->builtin_data_ptr;
401 code_entry->next_entry = extract_typed_address (&entry_buf[0], ptr_type);
402 code_entry->prev_entry =
403 extract_typed_address (&entry_buf[ptr_size], ptr_type);
404 code_entry->symfile_addr =
405 extract_typed_address (&entry_buf[2 * ptr_size], ptr_type);
406 code_entry->symfile_size =
407 extract_unsigned_integer (&entry_buf[off], 8, byte_order);
410 /* Proxy object for building a block. */
414 /* gdb_blocks are linked into a tree structure. Next points to the
415 next node at the same depth as this block and parent to the
417 struct gdb_block *next, *parent;
419 /* Points to the "real" block that is being built out of this
420 instance. This block will be added to a blockvector, which will
421 then be added to a symtab. */
422 struct block *real_block;
424 /* The first and last code address corresponding to this block. */
425 CORE_ADDR begin, end;
427 /* The name of this block (if any). If this is non-NULL, the
428 FUNCTION symbol symbol is set to this value. */
432 /* Proxy object for building a symtab. */
436 /* The list of blocks in this symtab. These will eventually be
437 converted to real blocks. */
438 struct gdb_block *blocks;
440 /* The number of blocks inserted. */
443 /* A mapping between line numbers to PC. */
444 struct linetable *linetable;
446 /* The source file for this symtab. */
447 const char *file_name;
448 struct gdb_symtab *next;
451 /* Proxy object for building an object. */
455 struct gdb_symtab *symtabs;
458 /* The type of the `private' data passed around by the callback
461 typedef CORE_ADDR jit_dbg_reader_data;
463 /* The reader calls into this function to read data off the targets
466 static enum gdb_status
467 jit_target_read_impl (GDB_CORE_ADDR target_mem, void *gdb_buf, int len)
469 int result = target_read_memory ((CORE_ADDR) target_mem, gdb_buf, len);
476 /* The reader calls into this function to create a new gdb_object
477 which it can then pass around to the other callbacks. Right now,
478 all that is required is allocating the memory. */
480 static struct gdb_object *
481 jit_object_open_impl (struct gdb_symbol_callbacks *cb)
483 /* CB is not required right now, but sometime in the future we might
484 need a handle to it, and we'd like to do that without breaking
486 return XZALLOC (struct gdb_object);
489 /* Readers call into this function to open a new gdb_symtab, which,
490 again, is passed around to other callbacks. */
492 static struct gdb_symtab *
493 jit_symtab_open_impl (struct gdb_symbol_callbacks *cb,
494 struct gdb_object *object,
495 const char *file_name)
497 struct gdb_symtab *ret;
499 /* CB stays unused. See comment in jit_object_open_impl. */
501 ret = XZALLOC (struct gdb_symtab);
502 ret->file_name = file_name ? xstrdup (file_name) : xstrdup ("");
503 ret->next = object->symtabs;
504 object->symtabs = ret;
508 /* Returns true if the block corresponding to old should be placed
509 before the block corresponding to new in the final blockvector. */
512 compare_block (const struct gdb_block *const old,
513 const struct gdb_block *const new)
517 if (old->begin < new->begin)
519 else if (old->begin == new->begin)
521 if (old->end > new->end)
530 /* Called by readers to open a new gdb_block. This function also
531 inserts the new gdb_block in the correct place in the corresponding
534 static struct gdb_block *
535 jit_block_open_impl (struct gdb_symbol_callbacks *cb,
536 struct gdb_symtab *symtab, struct gdb_block *parent,
537 GDB_CORE_ADDR begin, GDB_CORE_ADDR end, const char *name)
539 struct gdb_block *block = XZALLOC (struct gdb_block);
541 block->next = symtab->blocks;
542 block->begin = (CORE_ADDR) begin;
543 block->end = (CORE_ADDR) end;
544 block->name = name ? xstrdup (name) : NULL;
545 block->parent = parent;
547 /* Ensure that the blocks are inserted in the correct (reverse of
548 the order expected by blockvector). */
549 if (compare_block (symtab->blocks, block))
551 symtab->blocks = block;
555 struct gdb_block *i = symtab->blocks;
559 /* Guaranteed to terminate, since compare_block (NULL, _)
561 if (compare_block (i->next, block))
563 block->next = i->next;
574 /* Readers call this to add a line mapping (from PC to line number) to
578 jit_symtab_line_mapping_add_impl (struct gdb_symbol_callbacks *cb,
579 struct gdb_symtab *stab, int nlines,
580 struct gdb_line_mapping *map)
587 stab->linetable = xmalloc (sizeof (struct linetable)
588 + (nlines - 1) * sizeof (struct linetable_entry));
589 stab->linetable->nitems = nlines;
590 for (i = 0; i < nlines; i++)
592 stab->linetable->item[i].pc = (CORE_ADDR) map[i].pc;
593 stab->linetable->item[i].line = map[i].line;
597 /* Called by readers to close a gdb_symtab. Does not need to do
598 anything as of now. */
601 jit_symtab_close_impl (struct gdb_symbol_callbacks *cb,
602 struct gdb_symtab *stab)
604 /* Right now nothing needs to be done here. We may need to do some
605 cleanup here in the future (again, without breaking the plugin
609 /* Transform STAB to a proper symtab, and add it it OBJFILE. */
612 finalize_symtab (struct gdb_symtab *stab, struct objfile *objfile)
614 struct symtab *symtab;
615 struct gdb_block *gdb_block_iter, *gdb_block_iter_tmp;
616 struct block *block_iter;
617 int actual_nblocks, i, blockvector_size;
618 CORE_ADDR begin, end;
620 actual_nblocks = FIRST_LOCAL_BLOCK + stab->nblocks;
622 symtab = allocate_symtab (stab->file_name, objfile);
623 /* JIT compilers compile in memory. */
624 symtab->dirname = NULL;
626 /* Copy over the linetable entry if one was provided. */
629 int size = ((stab->linetable->nitems - 1)
630 * sizeof (struct linetable_entry)
631 + sizeof (struct linetable));
632 LINETABLE (symtab) = obstack_alloc (&objfile->objfile_obstack, size);
633 memcpy (LINETABLE (symtab), stab->linetable, size);
637 LINETABLE (symtab) = NULL;
640 blockvector_size = (sizeof (struct blockvector)
641 + (actual_nblocks - 1) * sizeof (struct block *));
642 symtab->blockvector = obstack_alloc (&objfile->objfile_obstack,
645 /* (begin, end) will contain the PC range this entire blockvector
648 BLOCKVECTOR_MAP (symtab->blockvector) = NULL;
649 begin = stab->blocks->begin;
650 end = stab->blocks->end;
651 BLOCKVECTOR_NBLOCKS (symtab->blockvector) = actual_nblocks;
653 /* First run over all the gdb_block objects, creating a real block
654 object for each. Simultaneously, keep setting the real_block
656 for (i = (actual_nblocks - 1), gdb_block_iter = stab->blocks;
657 i >= FIRST_LOCAL_BLOCK;
658 i--, gdb_block_iter = gdb_block_iter->next)
660 struct block *new_block = allocate_block (&objfile->objfile_obstack);
661 struct symbol *block_name = obstack_alloc (&objfile->objfile_obstack,
662 sizeof (struct symbol));
663 struct type *block_type = arch_type (get_objfile_arch (objfile),
668 BLOCK_DICT (new_block) = dict_create_linear (&objfile->objfile_obstack,
670 /* The address range. */
671 BLOCK_START (new_block) = (CORE_ADDR) gdb_block_iter->begin;
672 BLOCK_END (new_block) = (CORE_ADDR) gdb_block_iter->end;
675 memset (block_name, 0, sizeof (struct symbol));
676 SYMBOL_DOMAIN (block_name) = VAR_DOMAIN;
677 SYMBOL_CLASS (block_name) = LOC_BLOCK;
678 SYMBOL_SYMTAB (block_name) = symtab;
679 SYMBOL_TYPE (block_name) = lookup_function_type (block_type);
680 SYMBOL_BLOCK_VALUE (block_name) = new_block;
682 block_name->ginfo.name = obsavestring (gdb_block_iter->name,
683 strlen (gdb_block_iter->name),
684 &objfile->objfile_obstack);
686 BLOCK_FUNCTION (new_block) = block_name;
688 BLOCKVECTOR_BLOCK (symtab->blockvector, i) = new_block;
689 if (begin > BLOCK_START (new_block))
690 begin = BLOCK_START (new_block);
691 if (end < BLOCK_END (new_block))
692 end = BLOCK_END (new_block);
694 gdb_block_iter->real_block = new_block;
697 /* Now add the special blocks. */
699 for (i = 0; i < FIRST_LOCAL_BLOCK; i++)
701 struct block *new_block;
703 new_block = (i == GLOBAL_BLOCK
704 ? allocate_global_block (&objfile->objfile_obstack)
705 : allocate_block (&objfile->objfile_obstack));
706 BLOCK_DICT (new_block) = dict_create_linear (&objfile->objfile_obstack,
708 BLOCK_SUPERBLOCK (new_block) = block_iter;
709 block_iter = new_block;
711 BLOCK_START (new_block) = (CORE_ADDR) begin;
712 BLOCK_END (new_block) = (CORE_ADDR) end;
714 BLOCKVECTOR_BLOCK (symtab->blockvector, i) = new_block;
716 if (i == GLOBAL_BLOCK)
717 set_block_symtab (new_block, symtab);
720 /* Fill up the superblock fields for the real blocks, using the
721 real_block fields populated earlier. */
722 for (gdb_block_iter = stab->blocks;
724 gdb_block_iter = gdb_block_iter->next)
726 if (gdb_block_iter->parent != NULL)
727 BLOCK_SUPERBLOCK (gdb_block_iter->real_block) =
728 gdb_block_iter->parent->real_block;
732 gdb_block_iter = stab->blocks;
734 for (gdb_block_iter = stab->blocks, gdb_block_iter_tmp = gdb_block_iter->next;
736 gdb_block_iter = gdb_block_iter_tmp)
738 xfree ((void *) gdb_block_iter->name);
739 xfree (gdb_block_iter);
741 xfree (stab->linetable);
742 xfree ((char *) stab->file_name);
746 /* Called when closing a gdb_objfile. Converts OBJ to a proper
750 jit_object_close_impl (struct gdb_symbol_callbacks *cb,
751 struct gdb_object *obj)
753 struct gdb_symtab *i, *j;
754 struct objfile *objfile;
755 jit_dbg_reader_data *priv_data;
757 priv_data = cb->priv_data;
759 objfile = allocate_objfile (NULL, 0);
760 objfile->gdbarch = target_gdbarch;
762 terminate_minimal_symbol_table (objfile);
764 xfree (objfile->name);
765 objfile->name = xstrdup ("<< JIT compiled code >>");
768 for (i = obj->symtabs; i; i = j)
771 finalize_symtab (i, objfile);
773 add_objfile_entry (objfile, *priv_data);
777 /* Try to read CODE_ENTRY using the loaded jit reader (if any).
778 ENTRY_ADDR is the address of the struct jit_code_entry in the
779 inferior address space. */
782 jit_reader_try_read_symtab (struct jit_code_entry *code_entry,
783 CORE_ADDR entry_addr)
787 jit_dbg_reader_data priv_data;
788 struct gdb_reader_funcs *funcs;
789 volatile struct gdb_exception e;
790 struct gdb_symbol_callbacks callbacks =
792 jit_object_open_impl,
793 jit_symtab_open_impl,
795 jit_symtab_close_impl,
796 jit_object_close_impl,
798 jit_symtab_line_mapping_add_impl,
799 jit_target_read_impl,
804 priv_data = entry_addr;
806 if (!loaded_jit_reader)
809 gdb_mem = xmalloc (code_entry->symfile_size);
812 TRY_CATCH (e, RETURN_MASK_ALL)
813 if (target_read_memory (code_entry->symfile_addr, gdb_mem,
814 code_entry->symfile_size))
821 funcs = loaded_jit_reader->functions;
822 if (funcs->read (funcs, &callbacks, gdb_mem, code_entry->symfile_size)
828 if (jit_debug && status == 0)
829 fprintf_unfiltered (gdb_stdlog,
830 "Could not read symtab using the loaded JIT reader.\n");
834 /* Try to read CODE_ENTRY using BFD. ENTRY_ADDR is the address of the
835 struct jit_code_entry in the inferior address space. */
838 jit_bfd_try_read_symtab (struct jit_code_entry *code_entry,
839 CORE_ADDR entry_addr,
840 struct gdbarch *gdbarch)
843 struct section_addr_info *sai;
844 struct bfd_section *sec;
845 struct objfile *objfile;
846 struct cleanup *old_cleanups;
848 const struct bfd_arch_info *b;
851 fprintf_unfiltered (gdb_stdlog,
852 "jit_register_code, symfile_addr = %s, "
853 "symfile_size = %s\n",
854 paddress (gdbarch, code_entry->symfile_addr),
855 pulongest (code_entry->symfile_size));
857 nbfd = bfd_open_from_target_memory (code_entry->symfile_addr,
858 code_entry->symfile_size, gnutarget);
861 puts_unfiltered (_("Error opening JITed symbol file, ignoring it.\n"));
865 /* Check the format. NOTE: This initializes important data that GDB uses!
866 We would segfault later without this line. */
867 if (!bfd_check_format (nbfd, bfd_object))
869 printf_unfiltered (_("\
870 JITed symbol file is not an object file, ignoring it.\n"));
871 gdb_bfd_unref (nbfd);
875 /* Check bfd arch. */
876 b = gdbarch_bfd_arch_info (gdbarch);
877 if (b->compatible (b, bfd_get_arch_info (nbfd)) != b)
878 warning (_("JITed object file architecture %s is not compatible "
879 "with target architecture %s."), bfd_get_arch_info
880 (nbfd)->printable_name, b->printable_name);
882 /* Read the section address information out of the symbol file. Since the
883 file is generated by the JIT at runtime, it should all of the absolute
884 addresses that we care about. */
885 sai = alloc_section_addr_info (bfd_count_sections (nbfd));
886 old_cleanups = make_cleanup_free_section_addr_info (sai);
888 for (sec = nbfd->sections; sec != NULL; sec = sec->next)
889 if ((bfd_get_section_flags (nbfd, sec) & (SEC_ALLOC|SEC_LOAD)) != 0)
891 /* We assume that these virtual addresses are absolute, and do not
892 treat them as offsets. */
893 sai->other[i].addr = bfd_get_section_vma (nbfd, sec);
894 sai->other[i].name = xstrdup (bfd_get_section_name (nbfd, sec));
895 sai->other[i].sectindex = sec->index;
899 /* This call does not take ownership of SAI. */
900 make_cleanup_bfd_unref (nbfd);
901 objfile = symbol_file_add_from_bfd (nbfd, 0, sai, OBJF_SHARED, NULL);
903 do_cleanups (old_cleanups);
904 add_objfile_entry (objfile, entry_addr);
907 /* This function registers code associated with a JIT code entry. It uses the
908 pointer and size pair in the entry to read the symbol file from the remote
909 and then calls symbol_file_add_from_local_memory to add it as though it were
910 a symbol file added by the user. */
913 jit_register_code (struct gdbarch *gdbarch,
914 CORE_ADDR entry_addr, struct jit_code_entry *code_entry)
917 const struct bfd_arch_info *b;
918 struct jit_inferior_data *inf_data = get_jit_inferior_data ();
921 fprintf_unfiltered (gdb_stdlog,
922 "jit_register_code, symfile_addr = %s, "
923 "symfile_size = %s\n",
924 paddress (gdbarch, code_entry->symfile_addr),
925 pulongest (code_entry->symfile_size));
927 success = jit_reader_try_read_symtab (code_entry, entry_addr);
930 jit_bfd_try_read_symtab (code_entry, entry_addr, gdbarch);
933 /* This function unregisters JITed code and frees the corresponding
937 jit_unregister_code (struct objfile *objfile)
939 free_objfile (objfile);
942 /* Look up the objfile with this code entry address. */
944 static struct objfile *
945 jit_find_objf_with_entry_addr (CORE_ADDR entry_addr)
947 struct objfile *objf;
951 struct jit_objfile_data *objf_data;
953 objf_data = objfile_data (objf, jit_objfile_data);
954 if (objf_data != NULL && objf_data->addr == entry_addr)
960 /* (Re-)Initialize the jit breakpoint if necessary.
961 Return 0 on success. */
964 jit_breakpoint_re_set_internal (struct gdbarch *gdbarch,
965 struct jit_inferior_data *inf_data)
967 struct minimal_symbol *reg_symbol, *desc_symbol;
968 struct objfile *objf;
969 struct jit_objfile_data *objf_data;
971 if (inf_data->objfile != NULL)
974 /* Lookup the registration symbol. If it is missing, then we assume
975 we are not attached to a JIT. */
976 reg_symbol = lookup_minimal_symbol_and_objfile (jit_break_name, &objf);
977 if (reg_symbol == NULL || SYMBOL_VALUE_ADDRESS (reg_symbol) == 0)
980 desc_symbol = lookup_minimal_symbol (jit_descriptor_name, NULL, objf);
981 if (desc_symbol == NULL || SYMBOL_VALUE_ADDRESS (desc_symbol) == 0)
984 objf_data = get_jit_objfile_data (objf);
985 objf_data->register_code = reg_symbol;
986 objf_data->descriptor = desc_symbol;
988 inf_data->objfile = objf;
990 jit_inferior_init (gdbarch);
993 fprintf_unfiltered (gdb_stdlog,
994 "jit_breakpoint_re_set_internal, "
995 "breakpoint_addr = %s\n",
996 paddress (gdbarch, SYMBOL_VALUE_ADDRESS (reg_symbol)));
998 /* Put a breakpoint in the registration symbol. */
999 create_jit_event_breakpoint (gdbarch, SYMBOL_VALUE_ADDRESS (reg_symbol));
1004 /* The private data passed around in the frame unwind callback
1007 struct jit_unwind_private
1009 /* Cached register values. See jit_frame_sniffer to see how this
1011 struct gdb_reg_value **registers;
1013 /* The frame being unwound. */
1014 struct frame_info *this_frame;
1017 /* Sets the value of a particular register in this frame. */
1020 jit_unwind_reg_set_impl (struct gdb_unwind_callbacks *cb, int dwarf_regnum,
1021 struct gdb_reg_value *value)
1023 struct jit_unwind_private *priv;
1026 priv = cb->priv_data;
1028 gdb_reg = gdbarch_dwarf2_reg_to_regnum (get_frame_arch (priv->this_frame),
1033 fprintf_unfiltered (gdb_stdlog,
1034 _("Could not recognize DWARF regnum %d"),
1039 gdb_assert (priv->registers);
1040 priv->registers[gdb_reg] = value;
1044 reg_value_free_impl (struct gdb_reg_value *value)
1049 /* Get the value of register REGNUM in the previous frame. */
1051 static struct gdb_reg_value *
1052 jit_unwind_reg_get_impl (struct gdb_unwind_callbacks *cb, int regnum)
1054 struct jit_unwind_private *priv;
1055 struct gdb_reg_value *value;
1057 struct gdbarch *frame_arch;
1059 priv = cb->priv_data;
1060 frame_arch = get_frame_arch (priv->this_frame);
1062 gdb_reg = gdbarch_dwarf2_reg_to_regnum (frame_arch, regnum);
1063 size = register_size (frame_arch, gdb_reg);
1064 value = xmalloc (sizeof (struct gdb_reg_value) + size - 1);
1065 value->defined = frame_register_read (priv->this_frame, gdb_reg,
1068 value->free = reg_value_free_impl;
1072 /* gdb_reg_value has a free function, which must be called on each
1073 saved register value. */
1076 jit_dealloc_cache (struct frame_info *this_frame, void *cache)
1078 struct jit_unwind_private *priv_data = cache;
1079 struct gdbarch *frame_arch;
1082 gdb_assert (priv_data->registers);
1083 frame_arch = get_frame_arch (priv_data->this_frame);
1085 for (i = 0; i < gdbarch_num_regs (frame_arch); i++)
1086 if (priv_data->registers[i] && priv_data->registers[i]->free)
1087 priv_data->registers[i]->free (priv_data->registers[i]);
1089 xfree (priv_data->registers);
1093 /* The frame sniffer for the pseudo unwinder.
1095 While this is nominally a frame sniffer, in the case where the JIT
1096 reader actually recognizes the frame, it does a lot more work -- it
1097 unwinds the frame and saves the corresponding register values in
1098 the cache. jit_frame_prev_register simply returns the saved
1102 jit_frame_sniffer (const struct frame_unwind *self,
1103 struct frame_info *this_frame, void **cache)
1105 struct jit_inferior_data *inf_data;
1106 struct jit_unwind_private *priv_data;
1107 struct gdb_unwind_callbacks callbacks;
1108 struct gdb_reader_funcs *funcs;
1110 inf_data = get_jit_inferior_data ();
1112 callbacks.reg_get = jit_unwind_reg_get_impl;
1113 callbacks.reg_set = jit_unwind_reg_set_impl;
1114 callbacks.target_read = jit_target_read_impl;
1116 if (loaded_jit_reader == NULL)
1119 funcs = loaded_jit_reader->functions;
1121 gdb_assert (!*cache);
1123 *cache = XZALLOC (struct jit_unwind_private);
1125 priv_data->registers =
1126 XCALLOC (gdbarch_num_regs (get_frame_arch (this_frame)),
1127 struct gdb_reg_value *);
1128 priv_data->this_frame = this_frame;
1130 callbacks.priv_data = priv_data;
1132 /* Try to coax the provided unwinder to unwind the stack */
1133 if (funcs->unwind (funcs, &callbacks) == GDB_SUCCESS)
1136 fprintf_unfiltered (gdb_stdlog, _("Successfully unwound frame using "
1141 fprintf_unfiltered (gdb_stdlog, _("Could not unwind frame using "
1144 jit_dealloc_cache (this_frame, *cache);
1151 /* The frame_id function for the pseudo unwinder. Relays the call to
1152 the loaded plugin. */
1155 jit_frame_this_id (struct frame_info *this_frame, void **cache,
1156 struct frame_id *this_id)
1158 struct jit_unwind_private private;
1159 struct gdb_frame_id frame_id;
1160 struct gdb_reader_funcs *funcs;
1161 struct gdb_unwind_callbacks callbacks;
1163 private.registers = NULL;
1164 private.this_frame = this_frame;
1166 /* We don't expect the frame_id function to set any registers, so we
1167 set reg_set to NULL. */
1168 callbacks.reg_get = jit_unwind_reg_get_impl;
1169 callbacks.reg_set = NULL;
1170 callbacks.target_read = jit_target_read_impl;
1171 callbacks.priv_data = &private;
1173 gdb_assert (loaded_jit_reader);
1174 funcs = loaded_jit_reader->functions;
1176 frame_id = funcs->get_frame_id (funcs, &callbacks);
1177 *this_id = frame_id_build (frame_id.stack_address, frame_id.code_address);
1180 /* Pseudo unwinder function. Reads the previously fetched value for
1181 the register from the cache. */
1183 static struct value *
1184 jit_frame_prev_register (struct frame_info *this_frame, void **cache, int reg)
1186 struct jit_unwind_private *priv = *cache;
1187 struct gdb_reg_value *value;
1190 return frame_unwind_got_optimized (this_frame, reg);
1192 gdb_assert (priv->registers);
1193 value = priv->registers[reg];
1194 if (value && value->defined)
1195 return frame_unwind_got_bytes (this_frame, reg, value->value);
1197 return frame_unwind_got_optimized (this_frame, reg);
1200 /* Relay everything back to the unwinder registered by the JIT debug
1203 static const struct frame_unwind jit_frame_unwind =
1206 default_frame_unwind_stop_reason,
1208 jit_frame_prev_register,
1215 /* This is the information that is stored at jit_gdbarch_data for each
1218 struct jit_gdbarch_data_type
1220 /* Has the (pseudo) unwinder been prepended? */
1221 int unwinder_registered;
1224 /* Check GDBARCH and prepend the pseudo JIT unwinder if needed. */
1227 jit_prepend_unwinder (struct gdbarch *gdbarch)
1229 struct jit_gdbarch_data_type *data;
1231 data = gdbarch_data (gdbarch, jit_gdbarch_data);
1232 if (!data->unwinder_registered)
1234 frame_unwind_prepend_unwinder (gdbarch, &jit_frame_unwind);
1235 data->unwinder_registered = 1;
1239 /* Register any already created translations. */
1242 jit_inferior_init (struct gdbarch *gdbarch)
1244 struct jit_descriptor descriptor;
1245 struct jit_code_entry cur_entry;
1246 struct jit_inferior_data *inf_data;
1247 CORE_ADDR cur_entry_addr;
1250 fprintf_unfiltered (gdb_stdlog, "jit_inferior_init\n");
1252 jit_prepend_unwinder (gdbarch);
1254 inf_data = get_jit_inferior_data ();
1255 if (jit_breakpoint_re_set_internal (gdbarch, inf_data) != 0)
1258 /* Read the descriptor so we can check the version number and load
1259 any already JITed functions. */
1260 if (!jit_read_descriptor (gdbarch, &descriptor, inf_data))
1263 /* Check that the version number agrees with that we support. */
1264 if (descriptor.version != 1)
1266 printf_unfiltered (_("Unsupported JIT protocol version %ld "
1267 "in descriptor (expected 1)\n"),
1268 (long) descriptor.version);
1272 /* If we've attached to a running program, we need to check the descriptor
1273 to register any functions that were already generated. */
1274 for (cur_entry_addr = descriptor.first_entry;
1275 cur_entry_addr != 0;
1276 cur_entry_addr = cur_entry.next_entry)
1278 jit_read_code_entry (gdbarch, cur_entry_addr, &cur_entry);
1280 /* This hook may be called many times during setup, so make sure we don't
1281 add the same symbol file twice. */
1282 if (jit_find_objf_with_entry_addr (cur_entry_addr) != NULL)
1285 jit_register_code (gdbarch, cur_entry_addr, &cur_entry);
1289 /* Exported routine to call when an inferior has been created. */
1292 jit_inferior_created_hook (void)
1294 jit_inferior_init (target_gdbarch);
1297 /* Exported routine to call to re-set the jit breakpoints,
1298 e.g. when a program is rerun. */
1301 jit_breakpoint_re_set (void)
1303 jit_breakpoint_re_set_internal (target_gdbarch,
1304 get_jit_inferior_data ());
1307 /* This function cleans up any code entries left over when the
1308 inferior exits. We get left over code when the inferior exits
1309 without unregistering its code, for example when it crashes. */
1312 jit_inferior_exit_hook (struct inferior *inf)
1314 struct objfile *objf;
1315 struct objfile *temp;
1317 ALL_OBJFILES_SAFE (objf, temp)
1319 struct jit_objfile_data *objf_data = objfile_data (objf,
1322 if (objf_data != NULL && objf_data->addr != 0)
1323 jit_unregister_code (objf);
1328 jit_event_handler (struct gdbarch *gdbarch)
1330 struct jit_descriptor descriptor;
1331 struct jit_code_entry code_entry;
1332 CORE_ADDR entry_addr;
1333 struct objfile *objf;
1335 /* Read the descriptor from remote memory. */
1336 if (!jit_read_descriptor (gdbarch, &descriptor, get_jit_inferior_data ()))
1338 entry_addr = descriptor.relevant_entry;
1340 /* Do the corresponding action. */
1341 switch (descriptor.action_flag)
1346 jit_read_code_entry (gdbarch, entry_addr, &code_entry);
1347 jit_register_code (gdbarch, entry_addr, &code_entry);
1349 case JIT_UNREGISTER:
1350 objf = jit_find_objf_with_entry_addr (entry_addr);
1352 printf_unfiltered (_("Unable to find JITed code "
1353 "entry at address: %s\n"),
1354 paddress (gdbarch, entry_addr));
1356 jit_unregister_code (objf);
1360 error (_("Unknown action_flag value in JIT descriptor!"));
1365 /* Called to free the data allocated to the jit_inferior_data slot. */
1368 free_objfile_data (struct objfile *objfile, void *data)
1370 struct jit_objfile_data *objf_data = data;
1372 if (objf_data->register_code != NULL)
1374 struct jit_inferior_data *inf_data = get_jit_inferior_data ();
1376 if (inf_data->objfile == objfile)
1377 inf_data->objfile = NULL;
1383 /* Initialize the jit_gdbarch_data slot with an instance of struct
1384 jit_gdbarch_data_type */
1387 jit_gdbarch_data_init (struct obstack *obstack)
1389 struct jit_gdbarch_data_type *data;
1391 data = obstack_alloc (obstack, sizeof (struct jit_gdbarch_data_type));
1392 data->unwinder_registered = 0;
1396 /* Provide a prototype to silence -Wmissing-prototypes. */
1398 extern void _initialize_jit (void);
1401 _initialize_jit (void)
1403 jit_reader_dir = relocate_gdb_directory (JIT_READER_DIR,
1404 JIT_READER_DIR_RELOCATABLE);
1405 add_setshow_zinteger_cmd ("jit", class_maintenance, &jit_debug,
1406 _("Set JIT debugging."),
1407 _("Show JIT debugging."),
1408 _("When non-zero, JIT debugging is enabled."),
1411 &setdebuglist, &showdebuglist);
1413 observer_attach_inferior_exit (jit_inferior_exit_hook);
1415 register_objfile_data_with_cleanup (NULL, free_objfile_data);
1417 register_inferior_data_with_cleanup (jit_inferior_data_cleanup);
1418 jit_gdbarch_data = gdbarch_data_register_pre_init (jit_gdbarch_data_init);
1419 if (is_dl_available ())
1421 add_com ("jit-reader-load", no_class, jit_reader_load_command, _("\
1422 Load FILE as debug info reader and unwinder for JIT compiled code.\n\
1423 Usage: jit-reader-load FILE\n\
1424 Try to load file FILE as a debug info reader (and unwinder) for\n\
1425 JIT compiled code. The file is loaded from " JIT_READER_DIR ",\n\
1426 relocated relative to the GDB executable if required."));
1427 add_com ("jit-reader-unload", no_class, jit_reader_unload_command, _("\
1428 Unload the currently loaded JIT debug info reader.\n\
1429 Usage: jit-reader-unload FILE\n\n\
1430 Do \"help jit-reader-load\" for info on loading debug info readers."));