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 unsigned int jit_debug = 0;
66 show_jit_debug (struct ui_file *file, int from_tty,
67 struct cmd_list_element *c, const char *value)
69 fprintf_filtered (file, _("JIT debugging is %s.\n"), value);
78 /* Openning the file is a no-op. */
81 mem_bfd_iovec_open (struct bfd *abfd, void *open_closure)
86 /* Closing the file is just freeing the base/size pair on our side. */
89 mem_bfd_iovec_close (struct bfd *abfd, void *stream)
95 /* For reading the file, we just need to pass through to target_read_memory and
96 fix up the arguments and return values. */
99 mem_bfd_iovec_pread (struct bfd *abfd, void *stream, void *buf,
100 file_ptr nbytes, file_ptr offset)
103 struct target_buffer *buffer = (struct target_buffer *) stream;
105 /* If this read will read all of the file, limit it to just the rest. */
106 if (offset + nbytes > buffer->size)
107 nbytes = buffer->size - offset;
109 /* If there are no more bytes left, we've reached EOF. */
113 err = target_read_memory (buffer->base + offset, (gdb_byte *) buf, nbytes);
120 /* For statting the file, we only support the st_size attribute. */
123 mem_bfd_iovec_stat (struct bfd *abfd, void *stream, struct stat *sb)
125 struct target_buffer *buffer = (struct target_buffer*) stream;
127 sb->st_size = buffer->size;
131 /* Open a BFD from the target's memory. */
134 bfd_open_from_target_memory (CORE_ADDR addr, ULONGEST size, char *target)
136 struct target_buffer *buffer = xmalloc (sizeof (struct target_buffer));
140 return gdb_bfd_openr_iovec ("<in-memory>", target,
148 /* One reader that has been loaded successfully, and can potentially be used to
151 static struct jit_reader
153 struct gdb_reader_funcs *functions;
155 } *loaded_jit_reader = NULL;
157 typedef struct gdb_reader_funcs * (reader_init_fn_type) (void);
158 static const char *reader_init_fn_sym = "gdb_init_reader";
160 /* Try to load FILE_NAME as a JIT debug info reader. */
162 static struct jit_reader *
163 jit_reader_load (const char *file_name)
166 reader_init_fn_type *init_fn;
167 struct jit_reader *new_reader = NULL;
168 struct gdb_reader_funcs *funcs = NULL;
169 struct cleanup *old_cleanups;
172 fprintf_unfiltered (gdb_stdlog, _("Opening shared object %s.\n"),
174 so = gdb_dlopen (file_name);
175 old_cleanups = make_cleanup_dlclose (so);
177 init_fn = gdb_dlsym (so, reader_init_fn_sym);
179 error (_("Could not locate initialization function: %s."),
182 if (gdb_dlsym (so, "plugin_is_GPL_compatible") == NULL)
183 error (_("Reader not GPL compatible."));
186 if (funcs->reader_version != GDB_READER_INTERFACE_VERSION)
187 error (_("Reader version does not match GDB version."));
189 new_reader = XZALLOC (struct jit_reader);
190 new_reader->functions = funcs;
191 new_reader->handle = so;
193 discard_cleanups (old_cleanups);
197 /* Provides the jit-reader-load command. */
200 jit_reader_load_command (char *args, int from_tty)
203 struct cleanup *prev_cleanup;
206 error (_("No reader name provided."));
208 if (loaded_jit_reader != NULL)
209 error (_("JIT reader already loaded. Run jit-reader-unload first."));
211 so_name = xstrprintf ("%s/%s", jit_reader_dir, args);
212 prev_cleanup = make_cleanup (xfree, so_name);
214 loaded_jit_reader = jit_reader_load (so_name);
215 do_cleanups (prev_cleanup);
218 /* Provides the jit-reader-unload command. */
221 jit_reader_unload_command (char *args, int from_tty)
223 if (!loaded_jit_reader)
224 error (_("No JIT reader loaded."));
226 loaded_jit_reader->functions->destroy (loaded_jit_reader->functions);
228 gdb_dlclose (loaded_jit_reader->handle);
229 xfree (loaded_jit_reader);
230 loaded_jit_reader = NULL;
233 /* Per-inferior structure recording which objfile has the JIT
236 struct jit_inferior_data
238 /* The objfile. This is NULL if no objfile holds the JIT
241 struct objfile *objfile;
244 /* Per-objfile structure recording the addresses in the inferior. */
246 struct jit_objfile_data
248 /* Symbol for __jit_debug_register_code. */
249 struct minimal_symbol *register_code;
251 /* Symbol for __jit_debug_descriptor. */
252 struct minimal_symbol *descriptor;
254 /* Address of struct jit_code_entry in this objfile. */
258 /* Fetch the jit_objfile_data associated with OBJF. If no data exists
259 yet, make a new structure and attach it. */
261 static struct jit_objfile_data *
262 get_jit_objfile_data (struct objfile *objf)
264 struct jit_objfile_data *objf_data;
266 objf_data = objfile_data (objf, jit_objfile_data);
267 if (objf_data == NULL)
269 objf_data = XZALLOC (struct jit_objfile_data);
270 set_objfile_data (objf, jit_objfile_data, objf_data);
276 /* Remember OBJFILE has been created for struct jit_code_entry located
277 at inferior address ENTRY. */
280 add_objfile_entry (struct objfile *objfile, CORE_ADDR entry)
282 struct jit_objfile_data *objf_data;
284 objf_data = get_jit_objfile_data (objfile);
285 objf_data->addr = entry;
288 /* Return jit_inferior_data for current inferior. Allocate if not already
291 static struct jit_inferior_data *
292 get_jit_inferior_data (void)
294 struct inferior *inf;
295 struct jit_inferior_data *inf_data;
297 inf = current_inferior ();
298 inf_data = inferior_data (inf, jit_inferior_data);
299 if (inf_data == NULL)
301 inf_data = XZALLOC (struct jit_inferior_data);
302 set_inferior_data (inf, jit_inferior_data, inf_data);
309 jit_inferior_data_cleanup (struct inferior *inf, void *arg)
314 /* Helper function for reading the global JIT descriptor from remote
315 memory. Returns 1 if all went well, 0 otherwise. */
318 jit_read_descriptor (struct gdbarch *gdbarch,
319 struct jit_descriptor *descriptor,
320 struct jit_inferior_data *inf_data)
323 struct type *ptr_type;
327 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
328 struct jit_objfile_data *objf_data;
330 if (inf_data->objfile == NULL)
332 objf_data = get_jit_objfile_data (inf_data->objfile);
333 if (objf_data->descriptor == NULL)
337 fprintf_unfiltered (gdb_stdlog,
338 "jit_read_descriptor, descriptor_addr = %s\n",
339 paddress (gdbarch, SYMBOL_VALUE_ADDRESS (objf_data->descriptor)));
341 /* Figure out how big the descriptor is on the remote and how to read it. */
342 ptr_type = builtin_type (gdbarch)->builtin_data_ptr;
343 ptr_size = TYPE_LENGTH (ptr_type);
344 desc_size = 8 + 2 * ptr_size; /* Two 32-bit ints and two pointers. */
345 desc_buf = alloca (desc_size);
347 /* Read the descriptor. */
348 err = target_read_memory (SYMBOL_VALUE_ADDRESS (objf_data->descriptor),
349 desc_buf, desc_size);
352 printf_unfiltered (_("Unable to read JIT descriptor from "
357 /* Fix the endianness to match the host. */
358 descriptor->version = extract_unsigned_integer (&desc_buf[0], 4, byte_order);
359 descriptor->action_flag =
360 extract_unsigned_integer (&desc_buf[4], 4, byte_order);
361 descriptor->relevant_entry = extract_typed_address (&desc_buf[8], ptr_type);
362 descriptor->first_entry =
363 extract_typed_address (&desc_buf[8 + ptr_size], ptr_type);
368 /* Helper function for reading a JITed code entry from remote memory. */
371 jit_read_code_entry (struct gdbarch *gdbarch,
372 CORE_ADDR code_addr, struct jit_code_entry *code_entry)
375 struct type *ptr_type;
380 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
382 /* Figure out how big the entry is on the remote and how to read it. */
383 ptr_type = builtin_type (gdbarch)->builtin_data_ptr;
384 ptr_size = TYPE_LENGTH (ptr_type);
386 /* Figure out where the longlong value will be. */
387 align_bytes = gdbarch_long_long_align_bit (gdbarch) / 8;
389 off = (off + (align_bytes - 1)) & ~(align_bytes - 1);
391 entry_size = off + 8; /* Three pointers and one 64-bit int. */
392 entry_buf = alloca (entry_size);
394 /* Read the entry. */
395 err = target_read_memory (code_addr, entry_buf, entry_size);
397 error (_("Unable to read JIT code entry from remote memory!"));
399 /* Fix the endianness to match the host. */
400 ptr_type = builtin_type (gdbarch)->builtin_data_ptr;
401 code_entry->next_entry = extract_typed_address (&entry_buf[0], ptr_type);
402 code_entry->prev_entry =
403 extract_typed_address (&entry_buf[ptr_size], ptr_type);
404 code_entry->symfile_addr =
405 extract_typed_address (&entry_buf[2 * ptr_size], ptr_type);
406 code_entry->symfile_size =
407 extract_unsigned_integer (&entry_buf[off], 8, byte_order);
410 /* Proxy object for building a block. */
414 /* gdb_blocks are linked into a tree structure. Next points to the
415 next node at the same depth as this block and parent to the
417 struct gdb_block *next, *parent;
419 /* Points to the "real" block that is being built out of this
420 instance. This block will be added to a blockvector, which will
421 then be added to a symtab. */
422 struct block *real_block;
424 /* The first and last code address corresponding to this block. */
425 CORE_ADDR begin, end;
427 /* The name of this block (if any). If this is non-NULL, the
428 FUNCTION symbol symbol is set to this value. */
432 /* Proxy object for building a symtab. */
436 /* The list of blocks in this symtab. These will eventually be
437 converted to real blocks. */
438 struct gdb_block *blocks;
440 /* The number of blocks inserted. */
443 /* A mapping between line numbers to PC. */
444 struct linetable *linetable;
446 /* The source file for this symtab. */
447 const char *file_name;
448 struct gdb_symtab *next;
451 /* Proxy object for building an object. */
455 struct gdb_symtab *symtabs;
458 /* The type of the `private' data passed around by the callback
461 typedef CORE_ADDR jit_dbg_reader_data;
463 /* The reader calls into this function to read data off the targets
466 static enum gdb_status
467 jit_target_read_impl (GDB_CORE_ADDR target_mem, void *gdb_buf, int len)
469 int result = target_read_memory ((CORE_ADDR) target_mem, gdb_buf, len);
476 /* The reader calls into this function to create a new gdb_object
477 which it can then pass around to the other callbacks. Right now,
478 all that is required is allocating the memory. */
480 static struct gdb_object *
481 jit_object_open_impl (struct gdb_symbol_callbacks *cb)
483 /* CB is not required right now, but sometime in the future we might
484 need a handle to it, and we'd like to do that without breaking
486 return XZALLOC (struct gdb_object);
489 /* Readers call into this function to open a new gdb_symtab, which,
490 again, is passed around to other callbacks. */
492 static struct gdb_symtab *
493 jit_symtab_open_impl (struct gdb_symbol_callbacks *cb,
494 struct gdb_object *object,
495 const char *file_name)
497 struct gdb_symtab *ret;
499 /* CB stays unused. See comment in jit_object_open_impl. */
501 ret = XZALLOC (struct gdb_symtab);
502 ret->file_name = file_name ? xstrdup (file_name) : xstrdup ("");
503 ret->next = object->symtabs;
504 object->symtabs = ret;
508 /* Returns true if the block corresponding to old should be placed
509 before the block corresponding to new in the final blockvector. */
512 compare_block (const struct gdb_block *const old,
513 const struct gdb_block *const new)
517 if (old->begin < new->begin)
519 else if (old->begin == new->begin)
521 if (old->end > new->end)
530 /* Called by readers to open a new gdb_block. This function also
531 inserts the new gdb_block in the correct place in the corresponding
534 static struct gdb_block *
535 jit_block_open_impl (struct gdb_symbol_callbacks *cb,
536 struct gdb_symtab *symtab, struct gdb_block *parent,
537 GDB_CORE_ADDR begin, GDB_CORE_ADDR end, const char *name)
539 struct gdb_block *block = XZALLOC (struct gdb_block);
541 block->next = symtab->blocks;
542 block->begin = (CORE_ADDR) begin;
543 block->end = (CORE_ADDR) end;
544 block->name = name ? xstrdup (name) : NULL;
545 block->parent = parent;
547 /* Ensure that the blocks are inserted in the correct (reverse of
548 the order expected by blockvector). */
549 if (compare_block (symtab->blocks, block))
551 symtab->blocks = block;
555 struct gdb_block *i = symtab->blocks;
559 /* Guaranteed to terminate, since compare_block (NULL, _)
561 if (compare_block (i->next, block))
563 block->next = i->next;
574 /* Readers call this to add a line mapping (from PC to line number) to
578 jit_symtab_line_mapping_add_impl (struct gdb_symbol_callbacks *cb,
579 struct gdb_symtab *stab, int nlines,
580 struct gdb_line_mapping *map)
587 stab->linetable = xmalloc (sizeof (struct linetable)
588 + (nlines - 1) * sizeof (struct linetable_entry));
589 stab->linetable->nitems = nlines;
590 for (i = 0; i < nlines; i++)
592 stab->linetable->item[i].pc = (CORE_ADDR) map[i].pc;
593 stab->linetable->item[i].line = map[i].line;
597 /* Called by readers to close a gdb_symtab. Does not need to do
598 anything as of now. */
601 jit_symtab_close_impl (struct gdb_symbol_callbacks *cb,
602 struct gdb_symtab *stab)
604 /* Right now nothing needs to be done here. We may need to do some
605 cleanup here in the future (again, without breaking the plugin
609 /* Transform STAB to a proper symtab, and add it it OBJFILE. */
612 finalize_symtab (struct gdb_symtab *stab, struct objfile *objfile)
614 struct symtab *symtab;
615 struct gdb_block *gdb_block_iter, *gdb_block_iter_tmp;
616 struct block *block_iter;
617 int actual_nblocks, i, blockvector_size;
618 CORE_ADDR begin, end;
620 actual_nblocks = FIRST_LOCAL_BLOCK + stab->nblocks;
622 symtab = allocate_symtab (stab->file_name, objfile);
623 /* JIT compilers compile in memory. */
624 symtab->dirname = NULL;
626 /* Copy over the linetable entry if one was provided. */
629 int size = ((stab->linetable->nitems - 1)
630 * sizeof (struct linetable_entry)
631 + sizeof (struct linetable));
632 LINETABLE (symtab) = obstack_alloc (&objfile->objfile_obstack, size);
633 memcpy (LINETABLE (symtab), stab->linetable, size);
637 LINETABLE (symtab) = NULL;
640 blockvector_size = (sizeof (struct blockvector)
641 + (actual_nblocks - 1) * sizeof (struct block *));
642 symtab->blockvector = obstack_alloc (&objfile->objfile_obstack,
645 /* (begin, end) will contain the PC range this entire blockvector
648 BLOCKVECTOR_MAP (symtab->blockvector) = NULL;
649 begin = stab->blocks->begin;
650 end = stab->blocks->end;
651 BLOCKVECTOR_NBLOCKS (symtab->blockvector) = actual_nblocks;
653 /* First run over all the gdb_block objects, creating a real block
654 object for each. Simultaneously, keep setting the real_block
656 for (i = (actual_nblocks - 1), gdb_block_iter = stab->blocks;
657 i >= FIRST_LOCAL_BLOCK;
658 i--, gdb_block_iter = gdb_block_iter->next)
660 struct block *new_block = allocate_block (&objfile->objfile_obstack);
661 struct symbol *block_name = obstack_alloc (&objfile->objfile_obstack,
662 sizeof (struct symbol));
663 struct type *block_type = arch_type (get_objfile_arch (objfile),
668 BLOCK_DICT (new_block) = dict_create_linear (&objfile->objfile_obstack,
670 /* The address range. */
671 BLOCK_START (new_block) = (CORE_ADDR) gdb_block_iter->begin;
672 BLOCK_END (new_block) = (CORE_ADDR) gdb_block_iter->end;
675 memset (block_name, 0, sizeof (struct symbol));
676 SYMBOL_DOMAIN (block_name) = VAR_DOMAIN;
677 SYMBOL_CLASS (block_name) = LOC_BLOCK;
678 SYMBOL_SYMTAB (block_name) = symtab;
679 SYMBOL_TYPE (block_name) = lookup_function_type (block_type);
680 SYMBOL_BLOCK_VALUE (block_name) = new_block;
682 block_name->ginfo.name = obsavestring (gdb_block_iter->name,
683 strlen (gdb_block_iter->name),
684 &objfile->objfile_obstack);
686 BLOCK_FUNCTION (new_block) = block_name;
688 BLOCKVECTOR_BLOCK (symtab->blockvector, i) = new_block;
689 if (begin > BLOCK_START (new_block))
690 begin = BLOCK_START (new_block);
691 if (end < BLOCK_END (new_block))
692 end = BLOCK_END (new_block);
694 gdb_block_iter->real_block = new_block;
697 /* Now add the special blocks. */
699 for (i = 0; i < FIRST_LOCAL_BLOCK; i++)
701 struct block *new_block;
703 new_block = (i == GLOBAL_BLOCK
704 ? allocate_global_block (&objfile->objfile_obstack)
705 : allocate_block (&objfile->objfile_obstack));
706 BLOCK_DICT (new_block) = dict_create_linear (&objfile->objfile_obstack,
708 BLOCK_SUPERBLOCK (new_block) = block_iter;
709 block_iter = new_block;
711 BLOCK_START (new_block) = (CORE_ADDR) begin;
712 BLOCK_END (new_block) = (CORE_ADDR) end;
714 BLOCKVECTOR_BLOCK (symtab->blockvector, i) = new_block;
716 if (i == GLOBAL_BLOCK)
717 set_block_symtab (new_block, symtab);
720 /* Fill up the superblock fields for the real blocks, using the
721 real_block fields populated earlier. */
722 for (gdb_block_iter = stab->blocks;
724 gdb_block_iter = gdb_block_iter->next)
726 if (gdb_block_iter->parent != NULL)
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 objfile->name = "<< JIT compiled code >>";
767 for (i = obj->symtabs; i; i = j)
770 finalize_symtab (i, objfile);
772 add_objfile_entry (objfile, *priv_data);
776 /* Try to read CODE_ENTRY using the loaded jit reader (if any).
777 ENTRY_ADDR is the address of the struct jit_code_entry in the
778 inferior address space. */
781 jit_reader_try_read_symtab (struct jit_code_entry *code_entry,
782 CORE_ADDR entry_addr)
786 jit_dbg_reader_data priv_data;
787 struct gdb_reader_funcs *funcs;
788 volatile struct gdb_exception e;
789 struct gdb_symbol_callbacks callbacks =
791 jit_object_open_impl,
792 jit_symtab_open_impl,
794 jit_symtab_close_impl,
795 jit_object_close_impl,
797 jit_symtab_line_mapping_add_impl,
798 jit_target_read_impl,
803 priv_data = entry_addr;
805 if (!loaded_jit_reader)
808 gdb_mem = xmalloc (code_entry->symfile_size);
811 TRY_CATCH (e, RETURN_MASK_ALL)
812 if (target_read_memory (code_entry->symfile_addr, gdb_mem,
813 code_entry->symfile_size))
820 funcs = loaded_jit_reader->functions;
821 if (funcs->read (funcs, &callbacks, gdb_mem, code_entry->symfile_size)
827 if (jit_debug && status == 0)
828 fprintf_unfiltered (gdb_stdlog,
829 "Could not read symtab using the loaded JIT reader.\n");
833 /* Try to read CODE_ENTRY using BFD. ENTRY_ADDR is the address of the
834 struct jit_code_entry in the inferior address space. */
837 jit_bfd_try_read_symtab (struct jit_code_entry *code_entry,
838 CORE_ADDR entry_addr,
839 struct gdbarch *gdbarch)
842 struct section_addr_info *sai;
843 struct bfd_section *sec;
844 struct objfile *objfile;
845 struct cleanup *old_cleanups;
847 const struct bfd_arch_info *b;
850 fprintf_unfiltered (gdb_stdlog,
851 "jit_register_code, symfile_addr = %s, "
852 "symfile_size = %s\n",
853 paddress (gdbarch, code_entry->symfile_addr),
854 pulongest (code_entry->symfile_size));
856 nbfd = bfd_open_from_target_memory (code_entry->symfile_addr,
857 code_entry->symfile_size, gnutarget);
860 puts_unfiltered (_("Error opening JITed symbol file, ignoring it.\n"));
864 /* Check the format. NOTE: This initializes important data that GDB uses!
865 We would segfault later without this line. */
866 if (!bfd_check_format (nbfd, bfd_object))
868 printf_unfiltered (_("\
869 JITed symbol file is not an object file, ignoring it.\n"));
870 gdb_bfd_unref (nbfd);
874 /* Check bfd arch. */
875 b = gdbarch_bfd_arch_info (gdbarch);
876 if (b->compatible (b, bfd_get_arch_info (nbfd)) != b)
877 warning (_("JITed object file architecture %s is not compatible "
878 "with target architecture %s."), bfd_get_arch_info
879 (nbfd)->printable_name, b->printable_name);
881 /* Read the section address information out of the symbol file. Since the
882 file is generated by the JIT at runtime, it should all of the absolute
883 addresses that we care about. */
884 sai = alloc_section_addr_info (bfd_count_sections (nbfd));
885 old_cleanups = make_cleanup_free_section_addr_info (sai);
887 for (sec = nbfd->sections; sec != NULL; sec = sec->next)
888 if ((bfd_get_section_flags (nbfd, sec) & (SEC_ALLOC|SEC_LOAD)) != 0)
890 /* We assume that these virtual addresses are absolute, and do not
891 treat them as offsets. */
892 sai->other[i].addr = bfd_get_section_vma (nbfd, sec);
893 sai->other[i].name = xstrdup (bfd_get_section_name (nbfd, sec));
894 sai->other[i].sectindex = sec->index;
898 /* This call does not take ownership of SAI. */
899 make_cleanup_bfd_unref (nbfd);
900 objfile = symbol_file_add_from_bfd (nbfd, 0, sai, OBJF_SHARED, NULL);
902 do_cleanups (old_cleanups);
903 add_objfile_entry (objfile, entry_addr);
906 /* This function registers code associated with a JIT code entry. It uses the
907 pointer and size pair in the entry to read the symbol file from the remote
908 and then calls symbol_file_add_from_local_memory to add it as though it were
909 a symbol file added by the user. */
912 jit_register_code (struct gdbarch *gdbarch,
913 CORE_ADDR entry_addr, struct jit_code_entry *code_entry)
916 const struct bfd_arch_info *b;
917 struct jit_inferior_data *inf_data = get_jit_inferior_data ();
920 fprintf_unfiltered (gdb_stdlog,
921 "jit_register_code, symfile_addr = %s, "
922 "symfile_size = %s\n",
923 paddress (gdbarch, code_entry->symfile_addr),
924 pulongest (code_entry->symfile_size));
926 success = jit_reader_try_read_symtab (code_entry, entry_addr);
929 jit_bfd_try_read_symtab (code_entry, entry_addr, gdbarch);
932 /* This function unregisters JITed code and frees the corresponding
936 jit_unregister_code (struct objfile *objfile)
938 free_objfile (objfile);
941 /* Look up the objfile with this code entry address. */
943 static struct objfile *
944 jit_find_objf_with_entry_addr (CORE_ADDR entry_addr)
946 struct objfile *objf;
950 struct jit_objfile_data *objf_data;
952 objf_data = objfile_data (objf, jit_objfile_data);
953 if (objf_data != NULL && objf_data->addr == entry_addr)
959 /* (Re-)Initialize the jit breakpoint if necessary.
960 Return 0 on success. */
963 jit_breakpoint_re_set_internal (struct gdbarch *gdbarch,
964 struct jit_inferior_data *inf_data)
966 struct minimal_symbol *reg_symbol, *desc_symbol;
967 struct objfile *objf;
968 struct jit_objfile_data *objf_data;
970 if (inf_data->objfile != NULL)
973 /* Lookup the registration symbol. If it is missing, then we assume
974 we are not attached to a JIT. */
975 reg_symbol = lookup_minimal_symbol_and_objfile (jit_break_name, &objf);
976 if (reg_symbol == NULL || SYMBOL_VALUE_ADDRESS (reg_symbol) == 0)
979 desc_symbol = lookup_minimal_symbol (jit_descriptor_name, NULL, objf);
980 if (desc_symbol == NULL || SYMBOL_VALUE_ADDRESS (desc_symbol) == 0)
983 objf_data = get_jit_objfile_data (objf);
984 objf_data->register_code = reg_symbol;
985 objf_data->descriptor = desc_symbol;
987 inf_data->objfile = objf;
989 jit_inferior_init (gdbarch);
992 fprintf_unfiltered (gdb_stdlog,
993 "jit_breakpoint_re_set_internal, "
994 "breakpoint_addr = %s\n",
995 paddress (gdbarch, SYMBOL_VALUE_ADDRESS (reg_symbol)));
997 /* Put a breakpoint in the registration symbol. */
998 create_jit_event_breakpoint (gdbarch, SYMBOL_VALUE_ADDRESS (reg_symbol));
1003 /* The private data passed around in the frame unwind callback
1006 struct jit_unwind_private
1008 /* Cached register values. See jit_frame_sniffer to see how this
1010 struct gdb_reg_value **registers;
1012 /* The frame being unwound. */
1013 struct frame_info *this_frame;
1016 /* Sets the value of a particular register in this frame. */
1019 jit_unwind_reg_set_impl (struct gdb_unwind_callbacks *cb, int dwarf_regnum,
1020 struct gdb_reg_value *value)
1022 struct jit_unwind_private *priv;
1025 priv = cb->priv_data;
1027 gdb_reg = gdbarch_dwarf2_reg_to_regnum (get_frame_arch (priv->this_frame),
1032 fprintf_unfiltered (gdb_stdlog,
1033 _("Could not recognize DWARF regnum %d"),
1038 gdb_assert (priv->registers);
1039 priv->registers[gdb_reg] = value;
1043 reg_value_free_impl (struct gdb_reg_value *value)
1048 /* Get the value of register REGNUM in the previous frame. */
1050 static struct gdb_reg_value *
1051 jit_unwind_reg_get_impl (struct gdb_unwind_callbacks *cb, int regnum)
1053 struct jit_unwind_private *priv;
1054 struct gdb_reg_value *value;
1056 struct gdbarch *frame_arch;
1058 priv = cb->priv_data;
1059 frame_arch = get_frame_arch (priv->this_frame);
1061 gdb_reg = gdbarch_dwarf2_reg_to_regnum (frame_arch, regnum);
1062 size = register_size (frame_arch, gdb_reg);
1063 value = xmalloc (sizeof (struct gdb_reg_value) + size - 1);
1064 value->defined = frame_register_read (priv->this_frame, gdb_reg,
1067 value->free = reg_value_free_impl;
1071 /* gdb_reg_value has a free function, which must be called on each
1072 saved register value. */
1075 jit_dealloc_cache (struct frame_info *this_frame, void *cache)
1077 struct jit_unwind_private *priv_data = cache;
1078 struct gdbarch *frame_arch;
1081 gdb_assert (priv_data->registers);
1082 frame_arch = get_frame_arch (priv_data->this_frame);
1084 for (i = 0; i < gdbarch_num_regs (frame_arch); i++)
1085 if (priv_data->registers[i] && priv_data->registers[i]->free)
1086 priv_data->registers[i]->free (priv_data->registers[i]);
1088 xfree (priv_data->registers);
1092 /* The frame sniffer for the pseudo unwinder.
1094 While this is nominally a frame sniffer, in the case where the JIT
1095 reader actually recognizes the frame, it does a lot more work -- it
1096 unwinds the frame and saves the corresponding register values in
1097 the cache. jit_frame_prev_register simply returns the saved
1101 jit_frame_sniffer (const struct frame_unwind *self,
1102 struct frame_info *this_frame, void **cache)
1104 struct jit_inferior_data *inf_data;
1105 struct jit_unwind_private *priv_data;
1106 struct gdb_unwind_callbacks callbacks;
1107 struct gdb_reader_funcs *funcs;
1109 inf_data = get_jit_inferior_data ();
1111 callbacks.reg_get = jit_unwind_reg_get_impl;
1112 callbacks.reg_set = jit_unwind_reg_set_impl;
1113 callbacks.target_read = jit_target_read_impl;
1115 if (loaded_jit_reader == NULL)
1118 funcs = loaded_jit_reader->functions;
1120 gdb_assert (!*cache);
1122 *cache = XZALLOC (struct jit_unwind_private);
1124 priv_data->registers =
1125 XCALLOC (gdbarch_num_regs (get_frame_arch (this_frame)),
1126 struct gdb_reg_value *);
1127 priv_data->this_frame = this_frame;
1129 callbacks.priv_data = priv_data;
1131 /* Try to coax the provided unwinder to unwind the stack */
1132 if (funcs->unwind (funcs, &callbacks) == GDB_SUCCESS)
1135 fprintf_unfiltered (gdb_stdlog, _("Successfully unwound frame using "
1140 fprintf_unfiltered (gdb_stdlog, _("Could not unwind frame using "
1143 jit_dealloc_cache (this_frame, *cache);
1150 /* The frame_id function for the pseudo unwinder. Relays the call to
1151 the loaded plugin. */
1154 jit_frame_this_id (struct frame_info *this_frame, void **cache,
1155 struct frame_id *this_id)
1157 struct jit_unwind_private private;
1158 struct gdb_frame_id frame_id;
1159 struct gdb_reader_funcs *funcs;
1160 struct gdb_unwind_callbacks callbacks;
1162 private.registers = NULL;
1163 private.this_frame = this_frame;
1165 /* We don't expect the frame_id function to set any registers, so we
1166 set reg_set to NULL. */
1167 callbacks.reg_get = jit_unwind_reg_get_impl;
1168 callbacks.reg_set = NULL;
1169 callbacks.target_read = jit_target_read_impl;
1170 callbacks.priv_data = &private;
1172 gdb_assert (loaded_jit_reader);
1173 funcs = loaded_jit_reader->functions;
1175 frame_id = funcs->get_frame_id (funcs, &callbacks);
1176 *this_id = frame_id_build (frame_id.stack_address, frame_id.code_address);
1179 /* Pseudo unwinder function. Reads the previously fetched value for
1180 the register from the cache. */
1182 static struct value *
1183 jit_frame_prev_register (struct frame_info *this_frame, void **cache, int reg)
1185 struct jit_unwind_private *priv = *cache;
1186 struct gdb_reg_value *value;
1189 return frame_unwind_got_optimized (this_frame, reg);
1191 gdb_assert (priv->registers);
1192 value = priv->registers[reg];
1193 if (value && value->defined)
1194 return frame_unwind_got_bytes (this_frame, reg, value->value);
1196 return frame_unwind_got_optimized (this_frame, reg);
1199 /* Relay everything back to the unwinder registered by the JIT debug
1202 static const struct frame_unwind jit_frame_unwind =
1205 default_frame_unwind_stop_reason,
1207 jit_frame_prev_register,
1214 /* This is the information that is stored at jit_gdbarch_data for each
1217 struct jit_gdbarch_data_type
1219 /* Has the (pseudo) unwinder been prepended? */
1220 int unwinder_registered;
1223 /* Check GDBARCH and prepend the pseudo JIT unwinder if needed. */
1226 jit_prepend_unwinder (struct gdbarch *gdbarch)
1228 struct jit_gdbarch_data_type *data;
1230 data = gdbarch_data (gdbarch, jit_gdbarch_data);
1231 if (!data->unwinder_registered)
1233 frame_unwind_prepend_unwinder (gdbarch, &jit_frame_unwind);
1234 data->unwinder_registered = 1;
1238 /* Register any already created translations. */
1241 jit_inferior_init (struct gdbarch *gdbarch)
1243 struct jit_descriptor descriptor;
1244 struct jit_code_entry cur_entry;
1245 struct jit_inferior_data *inf_data;
1246 CORE_ADDR cur_entry_addr;
1249 fprintf_unfiltered (gdb_stdlog, "jit_inferior_init\n");
1251 jit_prepend_unwinder (gdbarch);
1253 inf_data = get_jit_inferior_data ();
1254 if (jit_breakpoint_re_set_internal (gdbarch, inf_data) != 0)
1257 /* Read the descriptor so we can check the version number and load
1258 any already JITed functions. */
1259 if (!jit_read_descriptor (gdbarch, &descriptor, inf_data))
1262 /* Check that the version number agrees with that we support. */
1263 if (descriptor.version != 1)
1265 printf_unfiltered (_("Unsupported JIT protocol version %ld "
1266 "in descriptor (expected 1)\n"),
1267 (long) descriptor.version);
1271 /* If we've attached to a running program, we need to check the descriptor
1272 to register any functions that were already generated. */
1273 for (cur_entry_addr = descriptor.first_entry;
1274 cur_entry_addr != 0;
1275 cur_entry_addr = cur_entry.next_entry)
1277 jit_read_code_entry (gdbarch, cur_entry_addr, &cur_entry);
1279 /* This hook may be called many times during setup, so make sure we don't
1280 add the same symbol file twice. */
1281 if (jit_find_objf_with_entry_addr (cur_entry_addr) != NULL)
1284 jit_register_code (gdbarch, cur_entry_addr, &cur_entry);
1288 /* Exported routine to call when an inferior has been created. */
1291 jit_inferior_created_hook (void)
1293 jit_inferior_init (target_gdbarch);
1296 /* Exported routine to call to re-set the jit breakpoints,
1297 e.g. when a program is rerun. */
1300 jit_breakpoint_re_set (void)
1302 jit_breakpoint_re_set_internal (target_gdbarch,
1303 get_jit_inferior_data ());
1306 /* This function cleans up any code entries left over when the
1307 inferior exits. We get left over code when the inferior exits
1308 without unregistering its code, for example when it crashes. */
1311 jit_inferior_exit_hook (struct inferior *inf)
1313 struct objfile *objf;
1314 struct objfile *temp;
1316 ALL_OBJFILES_SAFE (objf, temp)
1318 struct jit_objfile_data *objf_data = objfile_data (objf,
1321 if (objf_data != NULL && objf_data->addr != 0)
1322 jit_unregister_code (objf);
1327 jit_event_handler (struct gdbarch *gdbarch)
1329 struct jit_descriptor descriptor;
1330 struct jit_code_entry code_entry;
1331 CORE_ADDR entry_addr;
1332 struct objfile *objf;
1334 /* Read the descriptor from remote memory. */
1335 if (!jit_read_descriptor (gdbarch, &descriptor, get_jit_inferior_data ()))
1337 entry_addr = descriptor.relevant_entry;
1339 /* Do the corresponding action. */
1340 switch (descriptor.action_flag)
1345 jit_read_code_entry (gdbarch, entry_addr, &code_entry);
1346 jit_register_code (gdbarch, entry_addr, &code_entry);
1348 case JIT_UNREGISTER:
1349 objf = jit_find_objf_with_entry_addr (entry_addr);
1351 printf_unfiltered (_("Unable to find JITed code "
1352 "entry at address: %s\n"),
1353 paddress (gdbarch, entry_addr));
1355 jit_unregister_code (objf);
1359 error (_("Unknown action_flag value in JIT descriptor!"));
1364 /* Called to free the data allocated to the jit_inferior_data slot. */
1367 free_objfile_data (struct objfile *objfile, void *data)
1369 struct jit_objfile_data *objf_data = data;
1371 if (objf_data->register_code != NULL)
1373 struct jit_inferior_data *inf_data = get_jit_inferior_data ();
1375 if (inf_data->objfile == objfile)
1376 inf_data->objfile = NULL;
1382 /* Initialize the jit_gdbarch_data slot with an instance of struct
1383 jit_gdbarch_data_type */
1386 jit_gdbarch_data_init (struct obstack *obstack)
1388 struct jit_gdbarch_data_type *data;
1390 data = obstack_alloc (obstack, sizeof (struct jit_gdbarch_data_type));
1391 data->unwinder_registered = 0;
1395 /* Provide a prototype to silence -Wmissing-prototypes. */
1397 extern void _initialize_jit (void);
1400 _initialize_jit (void)
1402 jit_reader_dir = relocate_gdb_directory (JIT_READER_DIR,
1403 JIT_READER_DIR_RELOCATABLE);
1404 add_setshow_zuinteger_cmd ("jit", class_maintenance, &jit_debug,
1405 _("Set JIT debugging."),
1406 _("Show JIT debugging."),
1407 _("When non-zero, JIT debugging is enabled."),
1410 &setdebuglist, &showdebuglist);
1412 observer_attach_inferior_exit (jit_inferior_exit_hook);
1414 register_objfile_data_with_cleanup (NULL, free_objfile_data);
1416 register_inferior_data_with_cleanup (NULL, jit_inferior_data_cleanup);
1417 jit_gdbarch_data = gdbarch_data_register_pre_init (jit_gdbarch_data_init);
1418 if (is_dl_available ())
1420 add_com ("jit-reader-load", no_class, jit_reader_load_command, _("\
1421 Load FILE as debug info reader and unwinder for JIT compiled code.\n\
1422 Usage: jit-reader-load FILE\n\
1423 Try to load file FILE as a debug info reader (and unwinder) for\n\
1424 JIT compiled code. The file is loaded from " JIT_READER_DIR ",\n\
1425 relocated relative to the GDB executable if required."));
1426 add_com ("jit-reader-unload", no_class, jit_reader_unload_command, _("\
1427 Unload the currently loaded JIT debug info reader.\n\
1428 Usage: jit-reader-unload FILE\n\n\
1429 Do \"help jit-reader-load\" for info on loading debug info readers."));