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)
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));
664 BLOCK_DICT (new_block) = dict_create_linear (&objfile->objfile_obstack,
666 /* The address range. */
667 BLOCK_START (new_block) = (CORE_ADDR) gdb_block_iter->begin;
668 BLOCK_END (new_block) = (CORE_ADDR) gdb_block_iter->end;
671 memset (block_name, 0, sizeof (struct symbol));
672 SYMBOL_DOMAIN (block_name) = VAR_DOMAIN;
673 SYMBOL_CLASS (block_name) = LOC_BLOCK;
674 SYMBOL_SYMTAB (block_name) = symtab;
675 SYMBOL_BLOCK_VALUE (block_name) = new_block;
677 block_name->ginfo.name = obsavestring (gdb_block_iter->name,
678 strlen (gdb_block_iter->name),
679 &objfile->objfile_obstack);
681 BLOCK_FUNCTION (new_block) = block_name;
683 BLOCKVECTOR_BLOCK (symtab->blockvector, i) = new_block;
684 if (begin > BLOCK_START (new_block))
685 begin = BLOCK_START (new_block);
686 if (end < BLOCK_END (new_block))
687 end = BLOCK_END (new_block);
689 gdb_block_iter->real_block = new_block;
692 /* Now add the special blocks. */
694 for (i = 0; i < FIRST_LOCAL_BLOCK; i++)
696 struct block *new_block;
698 new_block = (i == GLOBAL_BLOCK
699 ? allocate_global_block (&objfile->objfile_obstack)
700 : allocate_block (&objfile->objfile_obstack));
701 BLOCK_DICT (new_block) = dict_create_linear (&objfile->objfile_obstack,
703 BLOCK_SUPERBLOCK (new_block) = block_iter;
704 block_iter = new_block;
706 BLOCK_START (new_block) = (CORE_ADDR) begin;
707 BLOCK_END (new_block) = (CORE_ADDR) end;
709 BLOCKVECTOR_BLOCK (symtab->blockvector, i) = new_block;
711 if (i == GLOBAL_BLOCK)
712 set_block_symtab (new_block, symtab);
715 /* Fill up the superblock fields for the real blocks, using the
716 real_block fields populated earlier. */
717 for (gdb_block_iter = stab->blocks;
719 gdb_block_iter = gdb_block_iter->next)
721 if (gdb_block_iter->parent != NULL)
722 BLOCK_SUPERBLOCK (gdb_block_iter->real_block) =
723 gdb_block_iter->parent->real_block;
727 gdb_block_iter = stab->blocks;
729 for (gdb_block_iter = stab->blocks, gdb_block_iter_tmp = gdb_block_iter->next;
731 gdb_block_iter = gdb_block_iter_tmp)
733 xfree ((void *) gdb_block_iter->name);
734 xfree (gdb_block_iter);
736 xfree (stab->linetable);
737 xfree ((char *) stab->file_name);
741 /* Called when closing a gdb_objfile. Converts OBJ to a proper
745 jit_object_close_impl (struct gdb_symbol_callbacks *cb,
746 struct gdb_object *obj)
748 struct gdb_symtab *i, *j;
749 struct objfile *objfile;
750 jit_dbg_reader_data *priv_data;
752 priv_data = cb->priv_data;
754 objfile = allocate_objfile (NULL, 0);
755 objfile->gdbarch = target_gdbarch;
757 terminate_minimal_symbol_table (objfile);
759 xfree (objfile->name);
760 objfile->name = xstrdup ("<< JIT compiled code >>");
763 for (i = obj->symtabs; i; i = j)
766 finalize_symtab (i, objfile);
768 add_objfile_entry (objfile, *priv_data);
772 /* Try to read CODE_ENTRY using the loaded jit reader (if any).
773 ENTRY_ADDR is the address of the struct jit_code_entry in the
774 inferior address space. */
777 jit_reader_try_read_symtab (struct jit_code_entry *code_entry,
778 CORE_ADDR entry_addr)
782 jit_dbg_reader_data priv_data;
783 struct gdb_reader_funcs *funcs;
784 volatile struct gdb_exception e;
785 struct gdb_symbol_callbacks callbacks =
787 jit_object_open_impl,
788 jit_symtab_open_impl,
790 jit_symtab_close_impl,
791 jit_object_close_impl,
793 jit_symtab_line_mapping_add_impl,
794 jit_target_read_impl,
799 priv_data = entry_addr;
801 if (!loaded_jit_reader)
804 gdb_mem = xmalloc (code_entry->symfile_size);
807 TRY_CATCH (e, RETURN_MASK_ALL)
808 if (target_read_memory (code_entry->symfile_addr, gdb_mem,
809 code_entry->symfile_size))
816 funcs = loaded_jit_reader->functions;
817 if (funcs->read (funcs, &callbacks, gdb_mem, code_entry->symfile_size)
823 if (jit_debug && status == 0)
824 fprintf_unfiltered (gdb_stdlog,
825 "Could not read symtab using the loaded JIT reader.\n");
829 /* Try to read CODE_ENTRY using BFD. ENTRY_ADDR is the address of the
830 struct jit_code_entry in the inferior address space. */
833 jit_bfd_try_read_symtab (struct jit_code_entry *code_entry,
834 CORE_ADDR entry_addr,
835 struct gdbarch *gdbarch)
838 struct section_addr_info *sai;
839 struct bfd_section *sec;
840 struct objfile *objfile;
841 struct cleanup *old_cleanups;
843 const struct bfd_arch_info *b;
846 fprintf_unfiltered (gdb_stdlog,
847 "jit_register_code, symfile_addr = %s, "
848 "symfile_size = %s\n",
849 paddress (gdbarch, code_entry->symfile_addr),
850 pulongest (code_entry->symfile_size));
852 nbfd = bfd_open_from_target_memory (code_entry->symfile_addr,
853 code_entry->symfile_size, gnutarget);
856 puts_unfiltered (_("Error opening JITed symbol file, ignoring it.\n"));
860 /* Check the format. NOTE: This initializes important data that GDB uses!
861 We would segfault later without this line. */
862 if (!bfd_check_format (nbfd, bfd_object))
864 printf_unfiltered (_("\
865 JITed symbol file is not an object file, ignoring it.\n"));
870 /* Check bfd arch. */
871 b = gdbarch_bfd_arch_info (gdbarch);
872 if (b->compatible (b, bfd_get_arch_info (nbfd)) != b)
873 warning (_("JITed object file architecture %s is not compatible "
874 "with target architecture %s."), bfd_get_arch_info
875 (nbfd)->printable_name, b->printable_name);
877 /* Read the section address information out of the symbol file. Since the
878 file is generated by the JIT at runtime, it should all of the absolute
879 addresses that we care about. */
880 sai = alloc_section_addr_info (bfd_count_sections (nbfd));
881 old_cleanups = make_cleanup_free_section_addr_info (sai);
883 for (sec = nbfd->sections; sec != NULL; sec = sec->next)
884 if ((bfd_get_section_flags (nbfd, sec) & (SEC_ALLOC|SEC_LOAD)) != 0)
886 /* We assume that these virtual addresses are absolute, and do not
887 treat them as offsets. */
888 sai->other[i].addr = bfd_get_section_vma (nbfd, sec);
889 sai->other[i].name = xstrdup (bfd_get_section_name (nbfd, sec));
890 sai->other[i].sectindex = sec->index;
894 /* This call takes ownership of NBFD. It does not take ownership of SAI. */
895 objfile = symbol_file_add_from_bfd (nbfd, 0, sai, OBJF_SHARED, NULL);
897 do_cleanups (old_cleanups);
898 add_objfile_entry (objfile, entry_addr);
901 /* This function registers code associated with a JIT code entry. It uses the
902 pointer and size pair in the entry to read the symbol file from the remote
903 and then calls symbol_file_add_from_local_memory to add it as though it were
904 a symbol file added by the user. */
907 jit_register_code (struct gdbarch *gdbarch,
908 CORE_ADDR entry_addr, struct jit_code_entry *code_entry)
911 const struct bfd_arch_info *b;
912 struct jit_inferior_data *inf_data = get_jit_inferior_data ();
915 fprintf_unfiltered (gdb_stdlog,
916 "jit_register_code, symfile_addr = %s, "
917 "symfile_size = %s\n",
918 paddress (gdbarch, code_entry->symfile_addr),
919 pulongest (code_entry->symfile_size));
921 success = jit_reader_try_read_symtab (code_entry, entry_addr);
924 jit_bfd_try_read_symtab (code_entry, entry_addr, gdbarch);
927 /* This function unregisters JITed code and frees the corresponding
931 jit_unregister_code (struct objfile *objfile)
933 free_objfile (objfile);
936 /* Look up the objfile with this code entry address. */
938 static struct objfile *
939 jit_find_objf_with_entry_addr (CORE_ADDR entry_addr)
941 struct objfile *objf;
945 struct jit_objfile_data *objf_data;
947 objf_data = objfile_data (objf, jit_objfile_data);
948 if (objf_data != NULL && objf_data->addr == entry_addr)
954 /* (Re-)Initialize the jit breakpoint if necessary.
955 Return 0 on success. */
958 jit_breakpoint_re_set_internal (struct gdbarch *gdbarch,
959 struct jit_inferior_data *inf_data)
961 struct minimal_symbol *reg_symbol, *desc_symbol;
962 struct objfile *objf;
963 struct jit_objfile_data *objf_data;
965 if (inf_data->objfile != NULL)
968 /* Lookup the registration symbol. If it is missing, then we assume
969 we are not attached to a JIT. */
970 reg_symbol = lookup_minimal_symbol_and_objfile (jit_break_name, &objf);
971 if (reg_symbol == NULL || SYMBOL_VALUE_ADDRESS (reg_symbol) == 0)
974 desc_symbol = lookup_minimal_symbol (jit_descriptor_name, NULL, objf);
975 if (desc_symbol == NULL || SYMBOL_VALUE_ADDRESS (desc_symbol) == 0)
978 objf_data = get_jit_objfile_data (objf);
979 objf_data->register_code = reg_symbol;
980 objf_data->descriptor = desc_symbol;
982 inf_data->objfile = objf;
984 jit_inferior_init (gdbarch);
987 fprintf_unfiltered (gdb_stdlog,
988 "jit_breakpoint_re_set_internal, "
989 "breakpoint_addr = %s\n",
990 paddress (gdbarch, SYMBOL_VALUE_ADDRESS (reg_symbol)));
992 /* Put a breakpoint in the registration symbol. */
993 create_jit_event_breakpoint (gdbarch, SYMBOL_VALUE_ADDRESS (reg_symbol));
998 /* The private data passed around in the frame unwind callback
1001 struct jit_unwind_private
1003 /* Cached register values. See jit_frame_sniffer to see how this
1005 struct gdb_reg_value **registers;
1007 /* The frame being unwound. */
1008 struct frame_info *this_frame;
1011 /* Sets the value of a particular register in this frame. */
1014 jit_unwind_reg_set_impl (struct gdb_unwind_callbacks *cb, int dwarf_regnum,
1015 struct gdb_reg_value *value)
1017 struct jit_unwind_private *priv;
1020 priv = cb->priv_data;
1022 gdb_reg = gdbarch_dwarf2_reg_to_regnum (get_frame_arch (priv->this_frame),
1027 fprintf_unfiltered (gdb_stdlog,
1028 _("Could not recognize DWARF regnum %d"),
1033 gdb_assert (priv->registers);
1034 priv->registers[gdb_reg] = value;
1038 reg_value_free_impl (struct gdb_reg_value *value)
1043 /* Get the value of register REGNUM in the previous frame. */
1045 static struct gdb_reg_value *
1046 jit_unwind_reg_get_impl (struct gdb_unwind_callbacks *cb, int regnum)
1048 struct jit_unwind_private *priv;
1049 struct gdb_reg_value *value;
1051 struct gdbarch *frame_arch;
1053 priv = cb->priv_data;
1054 frame_arch = get_frame_arch (priv->this_frame);
1056 gdb_reg = gdbarch_dwarf2_reg_to_regnum (frame_arch, regnum);
1057 size = register_size (frame_arch, gdb_reg);
1058 value = xmalloc (sizeof (struct gdb_reg_value) + size - 1);
1059 value->defined = frame_register_read (priv->this_frame, gdb_reg,
1062 value->free = reg_value_free_impl;
1066 /* gdb_reg_value has a free function, which must be called on each
1067 saved register value. */
1070 jit_dealloc_cache (struct frame_info *this_frame, void *cache)
1072 struct jit_unwind_private *priv_data = cache;
1073 struct gdbarch *frame_arch;
1076 gdb_assert (priv_data->registers);
1077 frame_arch = get_frame_arch (priv_data->this_frame);
1079 for (i = 0; i < gdbarch_num_regs (frame_arch); i++)
1080 if (priv_data->registers[i] && priv_data->registers[i]->free)
1081 priv_data->registers[i]->free (priv_data->registers[i]);
1083 xfree (priv_data->registers);
1087 /* The frame sniffer for the pseudo unwinder.
1089 While this is nominally a frame sniffer, in the case where the JIT
1090 reader actually recognizes the frame, it does a lot more work -- it
1091 unwinds the frame and saves the corresponding register values in
1092 the cache. jit_frame_prev_register simply returns the saved
1096 jit_frame_sniffer (const struct frame_unwind *self,
1097 struct frame_info *this_frame, void **cache)
1099 struct jit_inferior_data *inf_data;
1100 struct jit_unwind_private *priv_data;
1101 struct gdb_unwind_callbacks callbacks;
1102 struct gdb_reader_funcs *funcs;
1104 inf_data = get_jit_inferior_data ();
1106 callbacks.reg_get = jit_unwind_reg_get_impl;
1107 callbacks.reg_set = jit_unwind_reg_set_impl;
1108 callbacks.target_read = jit_target_read_impl;
1110 if (loaded_jit_reader == NULL)
1113 funcs = loaded_jit_reader->functions;
1115 gdb_assert (!*cache);
1117 *cache = XZALLOC (struct jit_unwind_private);
1119 priv_data->registers =
1120 XCALLOC (gdbarch_num_regs (get_frame_arch (this_frame)),
1121 struct gdb_reg_value *);
1122 priv_data->this_frame = this_frame;
1124 callbacks.priv_data = priv_data;
1126 /* Try to coax the provided unwinder to unwind the stack */
1127 if (funcs->unwind (funcs, &callbacks) == GDB_SUCCESS)
1130 fprintf_unfiltered (gdb_stdlog, _("Successfully unwound frame using "
1135 fprintf_unfiltered (gdb_stdlog, _("Could not unwind frame using "
1138 jit_dealloc_cache (this_frame, *cache);
1145 /* The frame_id function for the pseudo unwinder. Relays the call to
1146 the loaded plugin. */
1149 jit_frame_this_id (struct frame_info *this_frame, void **cache,
1150 struct frame_id *this_id)
1152 struct jit_unwind_private private;
1153 struct gdb_frame_id frame_id;
1154 struct gdb_reader_funcs *funcs;
1155 struct gdb_unwind_callbacks callbacks;
1157 private.registers = NULL;
1158 private.this_frame = this_frame;
1160 /* We don't expect the frame_id function to set any registers, so we
1161 set reg_set to NULL. */
1162 callbacks.reg_get = jit_unwind_reg_get_impl;
1163 callbacks.reg_set = NULL;
1164 callbacks.target_read = jit_target_read_impl;
1165 callbacks.priv_data = &private;
1167 gdb_assert (loaded_jit_reader);
1168 funcs = loaded_jit_reader->functions;
1170 frame_id = funcs->get_frame_id (funcs, &callbacks);
1171 *this_id = frame_id_build (frame_id.stack_address, frame_id.code_address);
1174 /* Pseudo unwinder function. Reads the previously fetched value for
1175 the register from the cache. */
1177 static struct value *
1178 jit_frame_prev_register (struct frame_info *this_frame, void **cache, int reg)
1180 struct jit_unwind_private *priv = *cache;
1181 struct gdb_reg_value *value;
1184 return frame_unwind_got_optimized (this_frame, reg);
1186 gdb_assert (priv->registers);
1187 value = priv->registers[reg];
1188 if (value && value->defined)
1189 return frame_unwind_got_bytes (this_frame, reg, value->value);
1191 return frame_unwind_got_optimized (this_frame, reg);
1194 /* Relay everything back to the unwinder registered by the JIT debug
1197 static const struct frame_unwind jit_frame_unwind =
1200 default_frame_unwind_stop_reason,
1202 jit_frame_prev_register,
1209 /* This is the information that is stored at jit_gdbarch_data for each
1212 struct jit_gdbarch_data_type
1214 /* Has the (pseudo) unwinder been prepended? */
1215 int unwinder_registered;
1218 /* Check GDBARCH and prepend the pseudo JIT unwinder if needed. */
1221 jit_prepend_unwinder (struct gdbarch *gdbarch)
1223 struct jit_gdbarch_data_type *data;
1225 data = gdbarch_data (gdbarch, jit_gdbarch_data);
1226 if (!data->unwinder_registered)
1228 frame_unwind_prepend_unwinder (gdbarch, &jit_frame_unwind);
1229 data->unwinder_registered = 1;
1233 /* Register any already created translations. */
1236 jit_inferior_init (struct gdbarch *gdbarch)
1238 struct jit_descriptor descriptor;
1239 struct jit_code_entry cur_entry;
1240 struct jit_inferior_data *inf_data;
1241 CORE_ADDR cur_entry_addr;
1244 fprintf_unfiltered (gdb_stdlog, "jit_inferior_init\n");
1246 jit_prepend_unwinder (gdbarch);
1248 inf_data = get_jit_inferior_data ();
1249 if (jit_breakpoint_re_set_internal (gdbarch, inf_data) != 0)
1252 /* Read the descriptor so we can check the version number and load
1253 any already JITed functions. */
1254 if (!jit_read_descriptor (gdbarch, &descriptor, inf_data))
1257 /* Check that the version number agrees with that we support. */
1258 if (descriptor.version != 1)
1260 printf_unfiltered (_("Unsupported JIT protocol version %ld "
1261 "in descriptor (expected 1)\n"),
1262 (long) descriptor.version);
1266 /* If we've attached to a running program, we need to check the descriptor
1267 to register any functions that were already generated. */
1268 for (cur_entry_addr = descriptor.first_entry;
1269 cur_entry_addr != 0;
1270 cur_entry_addr = cur_entry.next_entry)
1272 jit_read_code_entry (gdbarch, cur_entry_addr, &cur_entry);
1274 /* This hook may be called many times during setup, so make sure we don't
1275 add the same symbol file twice. */
1276 if (jit_find_objf_with_entry_addr (cur_entry_addr) != NULL)
1279 jit_register_code (gdbarch, cur_entry_addr, &cur_entry);
1283 /* Exported routine to call when an inferior has been created. */
1286 jit_inferior_created_hook (void)
1288 jit_inferior_init (target_gdbarch);
1291 /* Exported routine to call to re-set the jit breakpoints,
1292 e.g. when a program is rerun. */
1295 jit_breakpoint_re_set (void)
1297 jit_breakpoint_re_set_internal (target_gdbarch,
1298 get_jit_inferior_data ());
1301 /* This function cleans up any code entries left over when the
1302 inferior exits. We get left over code when the inferior exits
1303 without unregistering its code, for example when it crashes. */
1306 jit_inferior_exit_hook (struct inferior *inf)
1308 struct objfile *objf;
1309 struct objfile *temp;
1311 ALL_OBJFILES_SAFE (objf, temp)
1313 struct jit_objfile_data *objf_data = objfile_data (objf,
1316 if (objf_data != NULL && objf_data->addr != 0)
1317 jit_unregister_code (objf);
1322 jit_event_handler (struct gdbarch *gdbarch)
1324 struct jit_descriptor descriptor;
1325 struct jit_code_entry code_entry;
1326 CORE_ADDR entry_addr;
1327 struct objfile *objf;
1329 /* Read the descriptor from remote memory. */
1330 if (!jit_read_descriptor (gdbarch, &descriptor, get_jit_inferior_data ()))
1332 entry_addr = descriptor.relevant_entry;
1334 /* Do the corresponding action. */
1335 switch (descriptor.action_flag)
1340 jit_read_code_entry (gdbarch, entry_addr, &code_entry);
1341 jit_register_code (gdbarch, entry_addr, &code_entry);
1343 case JIT_UNREGISTER:
1344 objf = jit_find_objf_with_entry_addr (entry_addr);
1346 printf_unfiltered (_("Unable to find JITed code "
1347 "entry at address: %s\n"),
1348 paddress (gdbarch, entry_addr));
1350 jit_unregister_code (objf);
1354 error (_("Unknown action_flag value in JIT descriptor!"));
1359 /* Called to free the data allocated to the jit_inferior_data slot. */
1362 free_objfile_data (struct objfile *objfile, void *data)
1364 struct jit_objfile_data *objf_data = data;
1366 if (objf_data->register_code != NULL)
1368 struct jit_inferior_data *inf_data = get_jit_inferior_data ();
1370 if (inf_data->objfile == objfile)
1371 inf_data->objfile = NULL;
1377 /* Initialize the jit_gdbarch_data slot with an instance of struct
1378 jit_gdbarch_data_type */
1381 jit_gdbarch_data_init (struct obstack *obstack)
1383 struct jit_gdbarch_data_type *data;
1385 data = obstack_alloc (obstack, sizeof (struct jit_gdbarch_data_type));
1386 data->unwinder_registered = 0;
1390 /* Provide a prototype to silence -Wmissing-prototypes. */
1392 extern void _initialize_jit (void);
1395 _initialize_jit (void)
1397 jit_reader_dir = relocate_gdb_directory (JIT_READER_DIR,
1398 JIT_READER_DIR_RELOCATABLE);
1399 add_setshow_zinteger_cmd ("jit", class_maintenance, &jit_debug,
1400 _("Set JIT debugging."),
1401 _("Show JIT debugging."),
1402 _("When non-zero, JIT debugging is enabled."),
1405 &setdebuglist, &showdebuglist);
1407 observer_attach_inferior_exit (jit_inferior_exit_hook);
1409 register_objfile_data_with_cleanup (NULL, free_objfile_data);
1411 register_inferior_data_with_cleanup (jit_inferior_data_cleanup);
1412 jit_gdbarch_data = gdbarch_data_register_pre_init (jit_gdbarch_data_init);
1413 if (is_dl_available ())
1415 add_com ("jit-reader-load", no_class, jit_reader_load_command, _("\
1416 Load FILE as debug info reader and unwinder for JIT compiled code.\n\
1417 Usage: jit-reader-load FILE\n\
1418 Try to load file FILE as a debug info reader (and unwinder) for\n\
1419 JIT compiled code. The file is loaded from " JIT_READER_DIR ",\n\
1420 relocated relative to the GDB executable if required."));
1421 add_com ("jit-reader-unload", no_class, jit_reader_unload_command, _("\
1422 Unload the currently loaded JIT debug info reader.\n\
1423 Usage: jit-reader-unload FILE\n\n\
1424 Do \"help jit-reader-load\" for info on loading debug info readers."));