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"
42 static const char *jit_reader_dir = NULL;
44 static const struct objfile_data *jit_objfile_data;
46 static const char *const jit_break_name = "__jit_debug_register_code";
48 static const char *const jit_descriptor_name = "__jit_debug_descriptor";
50 static const struct inferior_data *jit_inferior_data = NULL;
52 static void jit_inferior_init (struct gdbarch *gdbarch);
54 /* An unwinder is registered for every gdbarch. This key is used to
55 remember if the unwinder has been registered for a particular
58 static struct gdbarch_data *jit_gdbarch_data;
60 /* Non-zero if we want to see trace of jit level stuff. */
62 static int jit_debug = 0;
65 show_jit_debug (struct ui_file *file, int from_tty,
66 struct cmd_list_element *c, const char *value)
68 fprintf_filtered (file, _("JIT debugging is %s.\n"), value);
77 /* Openning the file is a no-op. */
80 mem_bfd_iovec_open (struct bfd *abfd, void *open_closure)
85 /* Closing the file is just freeing the base/size pair on our side. */
88 mem_bfd_iovec_close (struct bfd *abfd, void *stream)
94 /* For reading the file, we just need to pass through to target_read_memory and
95 fix up the arguments and return values. */
98 mem_bfd_iovec_pread (struct bfd *abfd, void *stream, void *buf,
99 file_ptr nbytes, file_ptr offset)
102 struct target_buffer *buffer = (struct target_buffer *) stream;
104 /* If this read will read all of the file, limit it to just the rest. */
105 if (offset + nbytes > buffer->size)
106 nbytes = buffer->size - offset;
108 /* If there are no more bytes left, we've reached EOF. */
112 err = target_read_memory (buffer->base + offset, (gdb_byte *) buf, nbytes);
119 /* For statting the file, we only support the st_size attribute. */
122 mem_bfd_iovec_stat (struct bfd *abfd, void *stream, struct stat *sb)
124 struct target_buffer *buffer = (struct target_buffer*) stream;
126 sb->st_size = buffer->size;
130 /* Open a BFD from the target's memory. */
133 bfd_open_from_target_memory (CORE_ADDR addr, ULONGEST size, char *target)
135 const char *filename = xstrdup ("<in-memory>");
136 struct target_buffer *buffer = xmalloc (sizeof (struct target_buffer));
140 return bfd_openr_iovec (filename, 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)
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 CORE_ADDR *entry_addr_ptr;
284 struct jit_objfile_data *objf_data;
286 objf_data = get_jit_objfile_data (objfile);
287 objf_data->addr = entry;
290 /* Return jit_inferior_data for current inferior. Allocate if not already
293 static struct jit_inferior_data *
294 get_jit_inferior_data (void)
296 struct inferior *inf;
297 struct jit_inferior_data *inf_data;
299 inf = current_inferior ();
300 inf_data = inferior_data (inf, jit_inferior_data);
301 if (inf_data == NULL)
303 inf_data = XZALLOC (struct jit_inferior_data);
304 set_inferior_data (inf, jit_inferior_data, inf_data);
311 jit_inferior_data_cleanup (struct inferior *inf, void *arg)
316 /* Helper function for reading the global JIT descriptor from remote
317 memory. Returns 1 if all went well, 0 otherwise. */
320 jit_read_descriptor (struct gdbarch *gdbarch,
321 struct jit_descriptor *descriptor,
322 struct jit_inferior_data *inf_data)
325 struct type *ptr_type;
329 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
330 struct jit_objfile_data *objf_data;
332 if (inf_data->objfile == NULL)
334 objf_data = get_jit_objfile_data (inf_data->objfile);
335 if (objf_data->descriptor == NULL)
339 fprintf_unfiltered (gdb_stdlog,
340 "jit_read_descriptor, descriptor_addr = %s\n",
341 paddress (gdbarch, SYMBOL_VALUE_ADDRESS (objf_data->descriptor)));
343 /* Figure out how big the descriptor is on the remote and how to read it. */
344 ptr_type = builtin_type (gdbarch)->builtin_data_ptr;
345 ptr_size = TYPE_LENGTH (ptr_type);
346 desc_size = 8 + 2 * ptr_size; /* Two 32-bit ints and two pointers. */
347 desc_buf = alloca (desc_size);
349 /* Read the descriptor. */
350 err = target_read_memory (SYMBOL_VALUE_ADDRESS (objf_data->descriptor),
351 desc_buf, desc_size);
354 printf_unfiltered (_("Unable to read JIT descriptor from "
359 /* Fix the endianness to match the host. */
360 descriptor->version = extract_unsigned_integer (&desc_buf[0], 4, byte_order);
361 descriptor->action_flag =
362 extract_unsigned_integer (&desc_buf[4], 4, byte_order);
363 descriptor->relevant_entry = extract_typed_address (&desc_buf[8], ptr_type);
364 descriptor->first_entry =
365 extract_typed_address (&desc_buf[8 + ptr_size], ptr_type);
370 /* Helper function for reading a JITed code entry from remote memory. */
373 jit_read_code_entry (struct gdbarch *gdbarch,
374 CORE_ADDR code_addr, struct jit_code_entry *code_entry)
377 struct type *ptr_type;
382 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
384 /* Figure out how big the entry is on the remote and how to read it. */
385 ptr_type = builtin_type (gdbarch)->builtin_data_ptr;
386 ptr_size = TYPE_LENGTH (ptr_type);
388 /* Figure out where the longlong value will be. */
389 align_bytes = gdbarch_long_long_align_bit (gdbarch) / 8;
391 off = (off + (align_bytes - 1)) & ~(align_bytes - 1);
393 entry_size = off + 8; /* Three pointers and one 64-bit int. */
394 entry_buf = alloca (entry_size);
396 /* Read the entry. */
397 err = target_read_memory (code_addr, entry_buf, entry_size);
399 error (_("Unable to read JIT code entry from remote memory!"));
401 /* Fix the endianness to match the host. */
402 ptr_type = builtin_type (gdbarch)->builtin_data_ptr;
403 code_entry->next_entry = extract_typed_address (&entry_buf[0], ptr_type);
404 code_entry->prev_entry =
405 extract_typed_address (&entry_buf[ptr_size], ptr_type);
406 code_entry->symfile_addr =
407 extract_typed_address (&entry_buf[2 * ptr_size], ptr_type);
408 code_entry->symfile_size =
409 extract_unsigned_integer (&entry_buf[off], 8, byte_order);
412 /* Proxy object for building a block. */
416 /* gdb_blocks are linked into a tree structure. Next points to the
417 next node at the same depth as this block and parent to the
419 struct gdb_block *next, *parent;
421 /* Points to the "real" block that is being built out of this
422 instance. This block will be added to a blockvector, which will
423 then be added to a symtab. */
424 struct block *real_block;
426 /* The first and last code address corresponding to this block. */
427 CORE_ADDR begin, end;
429 /* The name of this block (if any). If this is non-NULL, the
430 FUNCTION symbol symbol is set to this value. */
434 /* Proxy object for building a symtab. */
438 /* The list of blocks in this symtab. These will eventually be
439 converted to real blocks. */
440 struct gdb_block *blocks;
442 /* The number of blocks inserted. */
445 /* A mapping between line numbers to PC. */
446 struct linetable *linetable;
448 /* The source file for this symtab. */
449 const char *file_name;
450 struct gdb_symtab *next;
453 /* Proxy object for building an object. */
457 struct gdb_symtab *symtabs;
460 /* The type of the `private' data passed around by the callback
463 typedef CORE_ADDR jit_dbg_reader_data;
465 /* The reader calls into this function to read data off the targets
468 static enum gdb_status
469 jit_target_read_impl (GDB_CORE_ADDR target_mem, void *gdb_buf, int len)
471 int result = target_read_memory ((CORE_ADDR) target_mem, gdb_buf, len);
478 /* The reader calls into this function to create a new gdb_object
479 which it can then pass around to the other callbacks. Right now,
480 all that is required is allocating the memory. */
482 static struct gdb_object *
483 jit_object_open_impl (struct gdb_symbol_callbacks *cb)
485 /* CB is not required right now, but sometime in the future we might
486 need a handle to it, and we'd like to do that without breaking
488 return XZALLOC (struct gdb_object);
491 /* Readers call into this function to open a new gdb_symtab, which,
492 again, is passed around to other callbacks. */
494 static struct gdb_symtab *
495 jit_symtab_open_impl (struct gdb_symbol_callbacks *cb,
496 struct gdb_object *object,
497 const char *file_name)
499 struct gdb_symtab *ret;
501 /* CB stays unused. See comment in jit_object_open_impl. */
503 ret = XZALLOC (struct gdb_symtab);
504 ret->file_name = file_name ? xstrdup (file_name) : xstrdup ("");
505 ret->next = object->symtabs;
506 object->symtabs = ret;
510 /* Returns true if the block corresponding to old should be placed
511 before the block corresponding to new in the final blockvector. */
514 compare_block (const struct gdb_block *const old,
515 const struct gdb_block *const new)
519 if (old->begin < new->begin)
521 else if (old->begin == new->begin)
523 if (old->end > new->end)
532 /* Called by readers to open a new gdb_block. This function also
533 inserts the new gdb_block in the correct place in the corresponding
536 static struct gdb_block *
537 jit_block_open_impl (struct gdb_symbol_callbacks *cb,
538 struct gdb_symtab *symtab, struct gdb_block *parent,
539 GDB_CORE_ADDR begin, GDB_CORE_ADDR end, const char *name)
541 struct gdb_block *block = XZALLOC (struct gdb_block);
543 block->next = symtab->blocks;
544 block->begin = (CORE_ADDR) begin;
545 block->end = (CORE_ADDR) end;
546 block->name = name ? xstrdup (name) : NULL;
547 block->parent = parent;
549 /* Ensure that the blocks are inserted in the correct (reverse of
550 the order expected by blockvector). */
551 if (compare_block (symtab->blocks, block))
553 symtab->blocks = block;
557 struct gdb_block *i = symtab->blocks;
561 /* Guaranteed to terminate, since compare_block (NULL, _)
563 if (compare_block (i->next, block))
565 block->next = i->next;
576 /* Readers call this to add a line mapping (from PC to line number) to
580 jit_symtab_line_mapping_add_impl (struct gdb_symbol_callbacks *cb,
581 struct gdb_symtab *stab, int nlines,
582 struct gdb_line_mapping *map)
589 stab->linetable = xmalloc (sizeof (struct linetable)
590 + (nlines - 1) * sizeof (struct linetable_entry));
591 stab->linetable->nitems = nlines;
592 for (i = 0; i < nlines; i++)
594 stab->linetable->item[i].pc = (CORE_ADDR) map[i].pc;
595 stab->linetable->item[i].line = map[i].line;
599 /* Called by readers to close a gdb_symtab. Does not need to do
600 anything as of now. */
603 jit_symtab_close_impl (struct gdb_symbol_callbacks *cb,
604 struct gdb_symtab *stab)
606 /* Right now nothing needs to be done here. We may need to do some
607 cleanup here in the future (again, without breaking the plugin
611 /* Transform STAB to a proper symtab, and add it it OBJFILE. */
614 finalize_symtab (struct gdb_symtab *stab, struct objfile *objfile)
616 struct symtab *symtab;
617 struct gdb_block *gdb_block_iter, *gdb_block_iter_tmp;
618 struct block *block_iter;
619 int actual_nblocks, i, blockvector_size;
620 CORE_ADDR begin, end;
622 actual_nblocks = FIRST_LOCAL_BLOCK + stab->nblocks;
624 symtab = allocate_symtab (stab->file_name, objfile);
625 /* JIT compilers compile in memory. */
626 symtab->dirname = NULL;
628 /* Copy over the linetable entry if one was provided. */
631 int size = ((stab->linetable->nitems - 1)
632 * sizeof (struct linetable_entry)
633 + sizeof (struct linetable));
634 LINETABLE (symtab) = obstack_alloc (&objfile->objfile_obstack, size);
635 memcpy (LINETABLE (symtab), stab->linetable, size);
639 LINETABLE (symtab) = NULL;
642 blockvector_size = (sizeof (struct blockvector)
643 + (actual_nblocks - 1) * sizeof (struct block *));
644 symtab->blockvector = obstack_alloc (&objfile->objfile_obstack,
647 /* (begin, end) will contain the PC range this entire blockvector
650 BLOCKVECTOR_MAP (symtab->blockvector) = NULL;
651 begin = stab->blocks->begin;
652 end = stab->blocks->end;
653 BLOCKVECTOR_NBLOCKS (symtab->blockvector) = actual_nblocks;
655 /* First run over all the gdb_block objects, creating a real block
656 object for each. Simultaneously, keep setting the real_block
658 for (i = (actual_nblocks - 1), gdb_block_iter = stab->blocks;
659 i >= FIRST_LOCAL_BLOCK;
660 i--, gdb_block_iter = gdb_block_iter->next)
662 struct block *new_block = allocate_block (&objfile->objfile_obstack);
663 struct symbol *block_name = obstack_alloc (&objfile->objfile_obstack,
664 sizeof (struct symbol));
666 BLOCK_DICT (new_block) = dict_create_linear (&objfile->objfile_obstack,
668 /* The address range. */
669 BLOCK_START (new_block) = (CORE_ADDR) gdb_block_iter->begin;
670 BLOCK_END (new_block) = (CORE_ADDR) gdb_block_iter->end;
673 memset (block_name, 0, sizeof (struct symbol));
674 SYMBOL_DOMAIN (block_name) = VAR_DOMAIN;
675 SYMBOL_CLASS (block_name) = LOC_BLOCK;
676 SYMBOL_SYMTAB (block_name) = symtab;
677 SYMBOL_BLOCK_VALUE (block_name) = new_block;
679 block_name->ginfo.name = obsavestring (gdb_block_iter->name,
680 strlen (gdb_block_iter->name),
681 &objfile->objfile_obstack);
683 BLOCK_FUNCTION (new_block) = block_name;
685 BLOCKVECTOR_BLOCK (symtab->blockvector, i) = new_block;
686 if (begin > BLOCK_START (new_block))
687 begin = BLOCK_START (new_block);
688 if (end < BLOCK_END (new_block))
689 end = BLOCK_END (new_block);
691 gdb_block_iter->real_block = new_block;
694 /* Now add the special blocks. */
696 for (i = 0; i < FIRST_LOCAL_BLOCK; i++)
698 struct block *new_block;
700 new_block = (i == GLOBAL_BLOCK
701 ? allocate_global_block (&objfile->objfile_obstack)
702 : allocate_block (&objfile->objfile_obstack));
703 BLOCK_DICT (new_block) = dict_create_linear (&objfile->objfile_obstack,
705 BLOCK_SUPERBLOCK (new_block) = block_iter;
706 block_iter = new_block;
708 BLOCK_START (new_block) = (CORE_ADDR) begin;
709 BLOCK_END (new_block) = (CORE_ADDR) end;
711 BLOCKVECTOR_BLOCK (symtab->blockvector, i) = new_block;
713 if (i == GLOBAL_BLOCK)
714 set_block_symtab (new_block, symtab);
717 /* Fill up the superblock fields for the real blocks, using the
718 real_block fields populated earlier. */
719 for (gdb_block_iter = stab->blocks;
721 gdb_block_iter = gdb_block_iter->next)
723 if (gdb_block_iter->parent != NULL)
724 BLOCK_SUPERBLOCK (gdb_block_iter->real_block) =
725 gdb_block_iter->parent->real_block;
729 gdb_block_iter = stab->blocks;
731 for (gdb_block_iter = stab->blocks, gdb_block_iter_tmp = gdb_block_iter->next;
733 gdb_block_iter = gdb_block_iter_tmp)
735 xfree ((void *) gdb_block_iter->name);
736 xfree (gdb_block_iter);
738 xfree (stab->linetable);
739 xfree ((char *) stab->file_name);
743 /* Called when closing a gdb_objfile. Converts OBJ to a proper
747 jit_object_close_impl (struct gdb_symbol_callbacks *cb,
748 struct gdb_object *obj)
750 struct gdb_symtab *i, *j;
751 struct objfile *objfile;
752 jit_dbg_reader_data *priv_data;
754 priv_data = cb->priv_data;
756 objfile = allocate_objfile (NULL, 0);
757 objfile->gdbarch = target_gdbarch;
759 terminate_minimal_symbol_table (objfile);
761 xfree (objfile->name);
762 objfile->name = xstrdup ("<< JIT compiled code >>");
765 for (i = obj->symtabs; i; i = j)
768 finalize_symtab (i, objfile);
770 add_objfile_entry (objfile, *priv_data);
774 /* Try to read CODE_ENTRY using the loaded jit reader (if any).
775 ENTRY_ADDR is the address of the struct jit_code_entry in the
776 inferior address space. */
779 jit_reader_try_read_symtab (struct jit_code_entry *code_entry,
780 CORE_ADDR entry_addr)
784 struct jit_dbg_reader *i;
785 jit_dbg_reader_data priv_data;
786 struct gdb_reader_funcs *funcs;
787 volatile struct gdb_exception e;
788 struct gdb_symbol_callbacks callbacks =
790 jit_object_open_impl,
791 jit_symtab_open_impl,
793 jit_symtab_close_impl,
794 jit_object_close_impl,
796 jit_symtab_line_mapping_add_impl,
797 jit_target_read_impl,
802 priv_data = entry_addr;
804 if (!loaded_jit_reader)
807 gdb_mem = xmalloc (code_entry->symfile_size);
810 TRY_CATCH (e, RETURN_MASK_ALL)
811 if (target_read_memory (code_entry->symfile_addr, gdb_mem,
812 code_entry->symfile_size))
819 funcs = loaded_jit_reader->functions;
820 if (funcs->read (funcs, &callbacks, gdb_mem, code_entry->symfile_size)
826 if (jit_debug && status == 0)
827 fprintf_unfiltered (gdb_stdlog,
828 "Could not read symtab using the loaded JIT reader.\n");
832 /* Try to read CODE_ENTRY using BFD. ENTRY_ADDR is the address of the
833 struct jit_code_entry in the inferior address space. */
836 jit_bfd_try_read_symtab (struct jit_code_entry *code_entry,
837 CORE_ADDR entry_addr,
838 struct gdbarch *gdbarch)
841 struct section_addr_info *sai;
842 struct bfd_section *sec;
843 struct objfile *objfile;
844 struct cleanup *old_cleanups;
846 const struct bfd_arch_info *b;
849 fprintf_unfiltered (gdb_stdlog,
850 "jit_register_code, symfile_addr = %s, "
851 "symfile_size = %s\n",
852 paddress (gdbarch, code_entry->symfile_addr),
853 pulongest (code_entry->symfile_size));
855 nbfd = bfd_open_from_target_memory (code_entry->symfile_addr,
856 code_entry->symfile_size, gnutarget);
859 puts_unfiltered (_("Error opening JITed symbol file, ignoring it.\n"));
863 /* Check the format. NOTE: This initializes important data that GDB uses!
864 We would segfault later without this line. */
865 if (!bfd_check_format (nbfd, bfd_object))
867 printf_unfiltered (_("\
868 JITed symbol file is not an object file, ignoring it.\n"));
873 /* Check bfd arch. */
874 b = gdbarch_bfd_arch_info (gdbarch);
875 if (b->compatible (b, bfd_get_arch_info (nbfd)) != b)
876 warning (_("JITed object file architecture %s is not compatible "
877 "with target architecture %s."), bfd_get_arch_info
878 (nbfd)->printable_name, b->printable_name);
880 /* Read the section address information out of the symbol file. Since the
881 file is generated by the JIT at runtime, it should all of the absolute
882 addresses that we care about. */
883 sai = alloc_section_addr_info (bfd_count_sections (nbfd));
884 old_cleanups = make_cleanup_free_section_addr_info (sai);
886 for (sec = nbfd->sections; sec != NULL; sec = sec->next)
887 if ((bfd_get_section_flags (nbfd, sec) & (SEC_ALLOC|SEC_LOAD)) != 0)
889 /* We assume that these virtual addresses are absolute, and do not
890 treat them as offsets. */
891 sai->other[i].addr = bfd_get_section_vma (nbfd, sec);
892 sai->other[i].name = xstrdup (bfd_get_section_name (nbfd, sec));
893 sai->other[i].sectindex = sec->index;
897 /* This call takes ownership of NBFD. It does not take ownership of SAI. */
898 objfile = symbol_file_add_from_bfd (nbfd, 0, sai, OBJF_SHARED, NULL);
900 do_cleanups (old_cleanups);
901 add_objfile_entry (objfile, entry_addr);
904 /* This function registers code associated with a JIT code entry. It uses the
905 pointer and size pair in the entry to read the symbol file from the remote
906 and then calls symbol_file_add_from_local_memory to add it as though it were
907 a symbol file added by the user. */
910 jit_register_code (struct gdbarch *gdbarch,
911 CORE_ADDR entry_addr, struct jit_code_entry *code_entry)
914 const struct bfd_arch_info *b;
915 struct jit_inferior_data *inf_data = get_jit_inferior_data ();
918 fprintf_unfiltered (gdb_stdlog,
919 "jit_register_code, symfile_addr = %s, "
920 "symfile_size = %s\n",
921 paddress (gdbarch, code_entry->symfile_addr),
922 pulongest (code_entry->symfile_size));
924 success = jit_reader_try_read_symtab (code_entry, entry_addr);
927 jit_bfd_try_read_symtab (code_entry, entry_addr, gdbarch);
930 /* This function unregisters JITed code and frees the corresponding
934 jit_unregister_code (struct objfile *objfile)
936 free_objfile (objfile);
939 /* Look up the objfile with this code entry address. */
941 static struct objfile *
942 jit_find_objf_with_entry_addr (CORE_ADDR entry_addr)
944 struct objfile *objf;
945 CORE_ADDR *objf_entry_addr;
949 struct jit_objfile_data *objf_data;
951 objf_data = objfile_data (objf, jit_objfile_data);
952 if (objf_data != NULL && objf_data->addr == entry_addr)
958 /* (Re-)Initialize the jit breakpoint if necessary.
959 Return 0 on success. */
962 jit_breakpoint_re_set_internal (struct gdbarch *gdbarch,
963 struct jit_inferior_data *inf_data)
965 struct minimal_symbol *reg_symbol, *desc_symbol;
966 struct objfile *objf;
967 struct jit_objfile_data *objf_data;
969 if (inf_data->objfile != NULL)
972 /* Lookup the registration symbol. If it is missing, then we assume
973 we are not attached to a JIT. */
974 reg_symbol = lookup_minimal_symbol_and_objfile (jit_break_name, &objf);
975 if (reg_symbol == NULL || SYMBOL_VALUE_ADDRESS (reg_symbol) == 0)
978 desc_symbol = lookup_minimal_symbol (jit_descriptor_name, NULL, objf);
979 if (desc_symbol == NULL || SYMBOL_VALUE_ADDRESS (desc_symbol) == 0)
982 objf_data = get_jit_objfile_data (objf);
983 objf_data->register_code = reg_symbol;
984 objf_data->descriptor = desc_symbol;
986 inf_data->objfile = objf;
988 jit_inferior_init (gdbarch);
991 fprintf_unfiltered (gdb_stdlog,
992 "jit_breakpoint_re_set_internal, "
993 "breakpoint_addr = %s\n",
994 paddress (gdbarch, SYMBOL_VALUE_ADDRESS (reg_symbol)));
996 /* Put a breakpoint in the registration symbol. */
997 create_jit_event_breakpoint (gdbarch, SYMBOL_VALUE_ADDRESS (reg_symbol));
1002 /* The private data passed around in the frame unwind callback
1005 struct jit_unwind_private
1007 /* Cached register values. See jit_frame_sniffer to see how this
1009 struct gdb_reg_value **registers;
1011 /* The frame being unwound. */
1012 struct frame_info *this_frame;
1015 /* Sets the value of a particular register in this frame. */
1018 jit_unwind_reg_set_impl (struct gdb_unwind_callbacks *cb, int dwarf_regnum,
1019 struct gdb_reg_value *value)
1021 struct jit_unwind_private *priv;
1024 priv = cb->priv_data;
1026 gdb_reg = gdbarch_dwarf2_reg_to_regnum (get_frame_arch (priv->this_frame),
1031 fprintf_unfiltered (gdb_stdlog,
1032 _("Could not recognize DWARF regnum %d"),
1037 gdb_assert (priv->registers);
1038 priv->registers[gdb_reg] = value;
1042 reg_value_free_impl (struct gdb_reg_value *value)
1047 /* Get the value of register REGNUM in the previous frame. */
1049 static struct gdb_reg_value *
1050 jit_unwind_reg_get_impl (struct gdb_unwind_callbacks *cb, int regnum)
1052 struct jit_unwind_private *priv;
1053 struct gdb_reg_value *value;
1055 struct gdbarch *frame_arch;
1057 priv = cb->priv_data;
1058 frame_arch = get_frame_arch (priv->this_frame);
1060 gdb_reg = gdbarch_dwarf2_reg_to_regnum (frame_arch, regnum);
1061 size = register_size (frame_arch, gdb_reg);
1062 value = xmalloc (sizeof (struct gdb_reg_value) + size - 1);
1063 value->defined = frame_register_read (priv->this_frame, gdb_reg,
1066 value->free = reg_value_free_impl;
1070 /* gdb_reg_value has a free function, which must be called on each
1071 saved register value. */
1074 jit_dealloc_cache (struct frame_info *this_frame, void *cache)
1076 struct jit_unwind_private *priv_data = cache;
1077 struct gdbarch *frame_arch;
1080 gdb_assert (priv_data->registers);
1081 frame_arch = get_frame_arch (priv_data->this_frame);
1083 for (i = 0; i < gdbarch_num_regs (frame_arch); i++)
1084 if (priv_data->registers[i] && priv_data->registers[i]->free)
1085 priv_data->registers[i]->free (priv_data->registers[i]);
1087 xfree (priv_data->registers);
1091 /* The frame sniffer for the pseudo unwinder.
1093 While this is nominally a frame sniffer, in the case where the JIT
1094 reader actually recognizes the frame, it does a lot more work -- it
1095 unwinds the frame and saves the corresponding register values in
1096 the cache. jit_frame_prev_register simply returns the saved
1100 jit_frame_sniffer (const struct frame_unwind *self,
1101 struct frame_info *this_frame, void **cache)
1103 struct jit_inferior_data *inf_data;
1104 struct jit_unwind_private *priv_data;
1105 struct jit_dbg_reader *iter;
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;
1247 struct jit_objfile_data *objf_data;
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."));