1 /* Handle JIT code generation in the inferior for GDB, the GNU Debugger.
3 Copyright (C) 2009-2015 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 "filenames.h"
29 #include "frame-unwind.h"
39 #include "gdb-dlfcn.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 program_space_data *jit_program_space_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)
93 /* Zero means success. */
97 /* For reading the file, we just need to pass through to target_read_memory and
98 fix up the arguments and return values. */
101 mem_bfd_iovec_pread (struct bfd *abfd, void *stream, void *buf,
102 file_ptr nbytes, file_ptr offset)
105 struct target_buffer *buffer = (struct target_buffer *) stream;
107 /* If this read will read all of the file, limit it to just the rest. */
108 if (offset + nbytes > buffer->size)
109 nbytes = buffer->size - offset;
111 /* If there are no more bytes left, we've reached EOF. */
115 err = target_read_memory (buffer->base + offset, (gdb_byte *) buf, nbytes);
122 /* For statting the file, we only support the st_size attribute. */
125 mem_bfd_iovec_stat (struct bfd *abfd, void *stream, struct stat *sb)
127 struct target_buffer *buffer = (struct target_buffer*) stream;
129 memset (sb, 0, sizeof (struct stat));
130 sb->st_size = buffer->size;
134 /* Open a BFD from the target's memory. */
137 bfd_open_from_target_memory (CORE_ADDR addr, ULONGEST size, char *target)
139 struct target_buffer *buffer = XNEW (struct target_buffer);
143 return gdb_bfd_openr_iovec ("<in-memory>", target,
151 /* One reader that has been loaded successfully, and can potentially be used to
154 static struct jit_reader
156 struct gdb_reader_funcs *functions;
158 } *loaded_jit_reader = NULL;
160 typedef struct gdb_reader_funcs * (reader_init_fn_type) (void);
161 static const char *reader_init_fn_sym = "gdb_init_reader";
163 /* Try to load FILE_NAME as a JIT debug info reader. */
165 static struct jit_reader *
166 jit_reader_load (const char *file_name)
169 reader_init_fn_type *init_fn;
170 struct jit_reader *new_reader = NULL;
171 struct gdb_reader_funcs *funcs = NULL;
172 struct cleanup *old_cleanups;
175 fprintf_unfiltered (gdb_stdlog, _("Opening shared object %s.\n"),
177 so = gdb_dlopen (file_name);
178 old_cleanups = make_cleanup_dlclose (so);
180 init_fn = gdb_dlsym (so, reader_init_fn_sym);
182 error (_("Could not locate initialization function: %s."),
185 if (gdb_dlsym (so, "plugin_is_GPL_compatible") == NULL)
186 error (_("Reader not GPL compatible."));
189 if (funcs->reader_version != GDB_READER_INTERFACE_VERSION)
190 error (_("Reader version does not match GDB version."));
192 new_reader = XCNEW (struct jit_reader);
193 new_reader->functions = funcs;
194 new_reader->handle = so;
196 discard_cleanups (old_cleanups);
200 /* Provides the jit-reader-load command. */
203 jit_reader_load_command (char *args, int from_tty)
206 struct cleanup *prev_cleanup;
209 error (_("No reader name provided."));
211 if (loaded_jit_reader != NULL)
212 error (_("JIT reader already loaded. Run jit-reader-unload first."));
214 if (IS_ABSOLUTE_PATH (args))
215 so_name = xstrdup (args);
217 so_name = xstrprintf ("%s%s%s", jit_reader_dir, SLASH_STRING, args);
218 prev_cleanup = make_cleanup (xfree, so_name);
220 loaded_jit_reader = jit_reader_load (so_name);
221 do_cleanups (prev_cleanup);
224 /* Provides the jit-reader-unload command. */
227 jit_reader_unload_command (char *args, int from_tty)
229 if (!loaded_jit_reader)
230 error (_("No JIT reader loaded."));
232 loaded_jit_reader->functions->destroy (loaded_jit_reader->functions);
234 gdb_dlclose (loaded_jit_reader->handle);
235 xfree (loaded_jit_reader);
236 loaded_jit_reader = NULL;
239 /* Per-program space structure recording which objfile has the JIT
242 struct jit_program_space_data
244 /* The objfile. This is NULL if no objfile holds the JIT
247 struct objfile *objfile;
249 /* If this program space has __jit_debug_register_code, this is the
250 cached address from the minimal symbol. This is used to detect
251 relocations requiring the breakpoint to be re-created. */
253 CORE_ADDR cached_code_address;
255 /* This is the JIT event breakpoint, or NULL if it has not been
258 struct breakpoint *jit_breakpoint;
261 /* Per-objfile structure recording the addresses in the program space.
262 This object serves two purposes: for ordinary objfiles, it may
263 cache some symbols related to the JIT interface; and for
264 JIT-created objfiles, it holds some information about the
267 struct jit_objfile_data
269 /* Symbol for __jit_debug_register_code. */
270 struct minimal_symbol *register_code;
272 /* Symbol for __jit_debug_descriptor. */
273 struct minimal_symbol *descriptor;
275 /* Address of struct jit_code_entry in this objfile. This is only
276 non-zero for objfiles that represent code created by the JIT. */
280 /* Fetch the jit_objfile_data associated with OBJF. If no data exists
281 yet, make a new structure and attach it. */
283 static struct jit_objfile_data *
284 get_jit_objfile_data (struct objfile *objf)
286 struct jit_objfile_data *objf_data;
288 objf_data = (struct jit_objfile_data *) objfile_data (objf, jit_objfile_data);
289 if (objf_data == NULL)
291 objf_data = XCNEW (struct jit_objfile_data);
292 set_objfile_data (objf, jit_objfile_data, objf_data);
298 /* Remember OBJFILE has been created for struct jit_code_entry located
299 at inferior address ENTRY. */
302 add_objfile_entry (struct objfile *objfile, CORE_ADDR entry)
304 struct jit_objfile_data *objf_data;
306 objf_data = get_jit_objfile_data (objfile);
307 objf_data->addr = entry;
310 /* Return jit_program_space_data for current program space. Allocate
311 if not already present. */
313 static struct jit_program_space_data *
314 get_jit_program_space_data (void)
316 struct jit_program_space_data *ps_data;
319 = ((struct jit_program_space_data *)
320 program_space_data (current_program_space, jit_program_space_data));
323 ps_data = XCNEW (struct jit_program_space_data);
324 set_program_space_data (current_program_space, jit_program_space_data,
332 jit_program_space_data_cleanup (struct program_space *ps, void *arg)
337 /* Helper function for reading the global JIT descriptor from remote
338 memory. Returns 1 if all went well, 0 otherwise. */
341 jit_read_descriptor (struct gdbarch *gdbarch,
342 struct jit_descriptor *descriptor,
343 struct jit_program_space_data *ps_data)
346 struct type *ptr_type;
350 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
351 struct jit_objfile_data *objf_data;
353 if (ps_data->objfile == NULL)
355 objf_data = get_jit_objfile_data (ps_data->objfile);
356 if (objf_data->descriptor == NULL)
360 fprintf_unfiltered (gdb_stdlog,
361 "jit_read_descriptor, descriptor_addr = %s\n",
362 paddress (gdbarch, MSYMBOL_VALUE_ADDRESS (ps_data->objfile,
363 objf_data->descriptor)));
365 /* Figure out how big the descriptor is on the remote and how to read it. */
366 ptr_type = builtin_type (gdbarch)->builtin_data_ptr;
367 ptr_size = TYPE_LENGTH (ptr_type);
368 desc_size = 8 + 2 * ptr_size; /* Two 32-bit ints and two pointers. */
369 desc_buf = (gdb_byte *) alloca (desc_size);
371 /* Read the descriptor. */
372 err = target_read_memory (MSYMBOL_VALUE_ADDRESS (ps_data->objfile,
373 objf_data->descriptor),
374 desc_buf, desc_size);
377 printf_unfiltered (_("Unable to read JIT descriptor from "
382 /* Fix the endianness to match the host. */
383 descriptor->version = extract_unsigned_integer (&desc_buf[0], 4, byte_order);
384 descriptor->action_flag =
385 extract_unsigned_integer (&desc_buf[4], 4, byte_order);
386 descriptor->relevant_entry = extract_typed_address (&desc_buf[8], ptr_type);
387 descriptor->first_entry =
388 extract_typed_address (&desc_buf[8 + ptr_size], ptr_type);
393 /* Helper function for reading a JITed code entry from remote memory. */
396 jit_read_code_entry (struct gdbarch *gdbarch,
397 CORE_ADDR code_addr, struct jit_code_entry *code_entry)
400 struct type *ptr_type;
405 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
407 /* Figure out how big the entry is on the remote and how to read it. */
408 ptr_type = builtin_type (gdbarch)->builtin_data_ptr;
409 ptr_size = TYPE_LENGTH (ptr_type);
411 /* Figure out where the longlong value will be. */
412 align_bytes = gdbarch_long_long_align_bit (gdbarch) / 8;
414 off = (off + (align_bytes - 1)) & ~(align_bytes - 1);
416 entry_size = off + 8; /* Three pointers and one 64-bit int. */
417 entry_buf = (gdb_byte *) alloca (entry_size);
419 /* Read the entry. */
420 err = target_read_memory (code_addr, entry_buf, entry_size);
422 error (_("Unable to read JIT code entry from remote memory!"));
424 /* Fix the endianness to match the host. */
425 ptr_type = builtin_type (gdbarch)->builtin_data_ptr;
426 code_entry->next_entry = extract_typed_address (&entry_buf[0], ptr_type);
427 code_entry->prev_entry =
428 extract_typed_address (&entry_buf[ptr_size], ptr_type);
429 code_entry->symfile_addr =
430 extract_typed_address (&entry_buf[2 * ptr_size], ptr_type);
431 code_entry->symfile_size =
432 extract_unsigned_integer (&entry_buf[off], 8, byte_order);
435 /* Proxy object for building a block. */
439 /* gdb_blocks are linked into a tree structure. Next points to the
440 next node at the same depth as this block and parent to the
442 struct gdb_block *next, *parent;
444 /* Points to the "real" block that is being built out of this
445 instance. This block will be added to a blockvector, which will
446 then be added to a symtab. */
447 struct block *real_block;
449 /* The first and last code address corresponding to this block. */
450 CORE_ADDR begin, end;
452 /* The name of this block (if any). If this is non-NULL, the
453 FUNCTION symbol symbol is set to this value. */
457 /* Proxy object for building a symtab. */
461 /* The list of blocks in this symtab. These will eventually be
462 converted to real blocks. */
463 struct gdb_block *blocks;
465 /* The number of blocks inserted. */
468 /* A mapping between line numbers to PC. */
469 struct linetable *linetable;
471 /* The source file for this symtab. */
472 const char *file_name;
473 struct gdb_symtab *next;
476 /* Proxy object for building an object. */
480 struct gdb_symtab *symtabs;
483 /* The type of the `private' data passed around by the callback
486 typedef CORE_ADDR jit_dbg_reader_data;
488 /* The reader calls into this function to read data off the targets
491 static enum gdb_status
492 jit_target_read_impl (GDB_CORE_ADDR target_mem, void *gdb_buf, int len)
494 int result = target_read_memory ((CORE_ADDR) target_mem, gdb_buf, len);
501 /* The reader calls into this function to create a new gdb_object
502 which it can then pass around to the other callbacks. Right now,
503 all that is required is allocating the memory. */
505 static struct gdb_object *
506 jit_object_open_impl (struct gdb_symbol_callbacks *cb)
508 /* CB is not required right now, but sometime in the future we might
509 need a handle to it, and we'd like to do that without breaking
511 return XCNEW (struct gdb_object);
514 /* Readers call into this function to open a new gdb_symtab, which,
515 again, is passed around to other callbacks. */
517 static struct gdb_symtab *
518 jit_symtab_open_impl (struct gdb_symbol_callbacks *cb,
519 struct gdb_object *object,
520 const char *file_name)
522 struct gdb_symtab *ret;
524 /* CB stays unused. See comment in jit_object_open_impl. */
526 ret = XCNEW (struct gdb_symtab);
527 ret->file_name = file_name ? xstrdup (file_name) : xstrdup ("");
528 ret->next = object->symtabs;
529 object->symtabs = ret;
533 /* Returns true if the block corresponding to old should be placed
534 before the block corresponding to new in the final blockvector. */
537 compare_block (const struct gdb_block *const old,
538 const struct gdb_block *const newobj)
542 if (old->begin < newobj->begin)
544 else if (old->begin == newobj->begin)
546 if (old->end > newobj->end)
555 /* Called by readers to open a new gdb_block. This function also
556 inserts the new gdb_block in the correct place in the corresponding
559 static struct gdb_block *
560 jit_block_open_impl (struct gdb_symbol_callbacks *cb,
561 struct gdb_symtab *symtab, struct gdb_block *parent,
562 GDB_CORE_ADDR begin, GDB_CORE_ADDR end, const char *name)
564 struct gdb_block *block = XCNEW (struct gdb_block);
566 block->next = symtab->blocks;
567 block->begin = (CORE_ADDR) begin;
568 block->end = (CORE_ADDR) end;
569 block->name = name ? xstrdup (name) : NULL;
570 block->parent = parent;
572 /* Ensure that the blocks are inserted in the correct (reverse of
573 the order expected by blockvector). */
574 if (compare_block (symtab->blocks, block))
576 symtab->blocks = block;
580 struct gdb_block *i = symtab->blocks;
584 /* Guaranteed to terminate, since compare_block (NULL, _)
586 if (compare_block (i->next, block))
588 block->next = i->next;
599 /* Readers call this to add a line mapping (from PC to line number) to
603 jit_symtab_line_mapping_add_impl (struct gdb_symbol_callbacks *cb,
604 struct gdb_symtab *stab, int nlines,
605 struct gdb_line_mapping *map)
613 alloc_len = sizeof (struct linetable)
614 + (nlines - 1) * sizeof (struct linetable_entry);
615 stab->linetable = (struct linetable *) xmalloc (alloc_len);
616 stab->linetable->nitems = nlines;
617 for (i = 0; i < nlines; i++)
619 stab->linetable->item[i].pc = (CORE_ADDR) map[i].pc;
620 stab->linetable->item[i].line = map[i].line;
624 /* Called by readers to close a gdb_symtab. Does not need to do
625 anything as of now. */
628 jit_symtab_close_impl (struct gdb_symbol_callbacks *cb,
629 struct gdb_symtab *stab)
631 /* Right now nothing needs to be done here. We may need to do some
632 cleanup here in the future (again, without breaking the plugin
636 /* Transform STAB to a proper symtab, and add it it OBJFILE. */
639 finalize_symtab (struct gdb_symtab *stab, struct objfile *objfile)
641 struct compunit_symtab *cust;
642 struct gdb_block *gdb_block_iter, *gdb_block_iter_tmp;
643 struct block *block_iter;
644 int actual_nblocks, i;
645 size_t blockvector_size;
646 CORE_ADDR begin, end;
647 struct blockvector *bv;
649 actual_nblocks = FIRST_LOCAL_BLOCK + stab->nblocks;
651 cust = allocate_compunit_symtab (objfile, stab->file_name);
652 allocate_symtab (cust, stab->file_name);
653 add_compunit_symtab_to_objfile (cust);
655 /* JIT compilers compile in memory. */
656 COMPUNIT_DIRNAME (cust) = NULL;
658 /* Copy over the linetable entry if one was provided. */
661 size_t size = ((stab->linetable->nitems - 1)
662 * sizeof (struct linetable_entry)
663 + sizeof (struct linetable));
664 SYMTAB_LINETABLE (COMPUNIT_FILETABS (cust))
665 = (struct linetable *) obstack_alloc (&objfile->objfile_obstack, size);
666 memcpy (SYMTAB_LINETABLE (COMPUNIT_FILETABS (cust)), stab->linetable,
670 blockvector_size = (sizeof (struct blockvector)
671 + (actual_nblocks - 1) * sizeof (struct block *));
672 bv = (struct blockvector *) obstack_alloc (&objfile->objfile_obstack,
674 COMPUNIT_BLOCKVECTOR (cust) = bv;
676 /* (begin, end) will contain the PC range this entire blockvector
678 BLOCKVECTOR_MAP (bv) = NULL;
679 begin = stab->blocks->begin;
680 end = stab->blocks->end;
681 BLOCKVECTOR_NBLOCKS (bv) = actual_nblocks;
683 /* First run over all the gdb_block objects, creating a real block
684 object for each. Simultaneously, keep setting the real_block
686 for (i = (actual_nblocks - 1), gdb_block_iter = stab->blocks;
687 i >= FIRST_LOCAL_BLOCK;
688 i--, gdb_block_iter = gdb_block_iter->next)
690 struct block *new_block = allocate_block (&objfile->objfile_obstack);
691 struct symbol *block_name = allocate_symbol (objfile);
692 struct type *block_type = arch_type (get_objfile_arch (objfile),
697 BLOCK_DICT (new_block) = dict_create_linear (&objfile->objfile_obstack,
699 /* The address range. */
700 BLOCK_START (new_block) = (CORE_ADDR) gdb_block_iter->begin;
701 BLOCK_END (new_block) = (CORE_ADDR) gdb_block_iter->end;
704 SYMBOL_DOMAIN (block_name) = VAR_DOMAIN;
705 SYMBOL_ACLASS_INDEX (block_name) = LOC_BLOCK;
706 symbol_set_symtab (block_name, COMPUNIT_FILETABS (cust));
707 SYMBOL_TYPE (block_name) = lookup_function_type (block_type);
708 SYMBOL_BLOCK_VALUE (block_name) = new_block;
710 block_name->ginfo.name
711 = (const char *) obstack_copy0 (&objfile->objfile_obstack,
712 gdb_block_iter->name,
713 strlen (gdb_block_iter->name));
715 BLOCK_FUNCTION (new_block) = block_name;
717 BLOCKVECTOR_BLOCK (bv, i) = new_block;
718 if (begin > BLOCK_START (new_block))
719 begin = BLOCK_START (new_block);
720 if (end < BLOCK_END (new_block))
721 end = BLOCK_END (new_block);
723 gdb_block_iter->real_block = new_block;
726 /* Now add the special blocks. */
728 for (i = 0; i < FIRST_LOCAL_BLOCK; i++)
730 struct block *new_block;
732 new_block = (i == GLOBAL_BLOCK
733 ? allocate_global_block (&objfile->objfile_obstack)
734 : allocate_block (&objfile->objfile_obstack));
735 BLOCK_DICT (new_block) = dict_create_linear (&objfile->objfile_obstack,
737 BLOCK_SUPERBLOCK (new_block) = block_iter;
738 block_iter = new_block;
740 BLOCK_START (new_block) = (CORE_ADDR) begin;
741 BLOCK_END (new_block) = (CORE_ADDR) end;
743 BLOCKVECTOR_BLOCK (bv, i) = new_block;
745 if (i == GLOBAL_BLOCK)
746 set_block_compunit_symtab (new_block, cust);
749 /* Fill up the superblock fields for the real blocks, using the
750 real_block fields populated earlier. */
751 for (gdb_block_iter = stab->blocks;
753 gdb_block_iter = gdb_block_iter->next)
755 if (gdb_block_iter->parent != NULL)
757 /* If the plugin specifically mentioned a parent block, we
759 BLOCK_SUPERBLOCK (gdb_block_iter->real_block) =
760 gdb_block_iter->parent->real_block;
764 /* And if not, we set a default parent block. */
765 BLOCK_SUPERBLOCK (gdb_block_iter->real_block) =
766 BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK);
771 gdb_block_iter = stab->blocks;
773 for (gdb_block_iter = stab->blocks, gdb_block_iter_tmp = gdb_block_iter->next;
775 gdb_block_iter = gdb_block_iter_tmp)
777 xfree ((void *) gdb_block_iter->name);
778 xfree (gdb_block_iter);
780 xfree (stab->linetable);
781 xfree ((char *) stab->file_name);
785 /* Called when closing a gdb_objfile. Converts OBJ to a proper
789 jit_object_close_impl (struct gdb_symbol_callbacks *cb,
790 struct gdb_object *obj)
792 struct gdb_symtab *i, *j;
793 struct objfile *objfile;
794 jit_dbg_reader_data *priv_data;
796 priv_data = (jit_dbg_reader_data *) cb->priv_data;
798 objfile = allocate_objfile (NULL, "<< JIT compiled code >>",
800 objfile->per_bfd->gdbarch = target_gdbarch ();
802 terminate_minimal_symbol_table (objfile);
805 for (i = obj->symtabs; i; i = j)
808 finalize_symtab (i, objfile);
810 add_objfile_entry (objfile, *priv_data);
814 /* Try to read CODE_ENTRY using the loaded jit reader (if any).
815 ENTRY_ADDR is the address of the struct jit_code_entry in the
816 inferior address space. */
819 jit_reader_try_read_symtab (struct jit_code_entry *code_entry,
820 CORE_ADDR entry_addr)
824 jit_dbg_reader_data priv_data;
825 struct gdb_reader_funcs *funcs;
826 struct gdb_symbol_callbacks callbacks =
828 jit_object_open_impl,
829 jit_symtab_open_impl,
831 jit_symtab_close_impl,
832 jit_object_close_impl,
834 jit_symtab_line_mapping_add_impl,
835 jit_target_read_impl,
840 priv_data = entry_addr;
842 if (!loaded_jit_reader)
845 gdb_mem = (gdb_byte *) xmalloc (code_entry->symfile_size);
850 if (target_read_memory (code_entry->symfile_addr, gdb_mem,
851 code_entry->symfile_size))
854 CATCH (e, RETURN_MASK_ALL)
862 funcs = loaded_jit_reader->functions;
863 if (funcs->read (funcs, &callbacks, gdb_mem, code_entry->symfile_size)
869 if (jit_debug && status == 0)
870 fprintf_unfiltered (gdb_stdlog,
871 "Could not read symtab using the loaded JIT reader.\n");
875 /* Try to read CODE_ENTRY using BFD. ENTRY_ADDR is the address of the
876 struct jit_code_entry in the inferior address space. */
879 jit_bfd_try_read_symtab (struct jit_code_entry *code_entry,
880 CORE_ADDR entry_addr,
881 struct gdbarch *gdbarch)
884 struct section_addr_info *sai;
885 struct bfd_section *sec;
886 struct objfile *objfile;
887 struct cleanup *old_cleanups;
889 const struct bfd_arch_info *b;
892 fprintf_unfiltered (gdb_stdlog,
893 "jit_register_code, symfile_addr = %s, "
894 "symfile_size = %s\n",
895 paddress (gdbarch, code_entry->symfile_addr),
896 pulongest (code_entry->symfile_size));
898 nbfd = bfd_open_from_target_memory (code_entry->symfile_addr,
899 code_entry->symfile_size, gnutarget);
902 puts_unfiltered (_("Error opening JITed symbol file, ignoring it.\n"));
906 /* Check the format. NOTE: This initializes important data that GDB uses!
907 We would segfault later without this line. */
908 if (!bfd_check_format (nbfd, bfd_object))
910 printf_unfiltered (_("\
911 JITed symbol file is not an object file, ignoring it.\n"));
912 gdb_bfd_unref (nbfd);
916 /* Check bfd arch. */
917 b = gdbarch_bfd_arch_info (gdbarch);
918 if (b->compatible (b, bfd_get_arch_info (nbfd)) != b)
919 warning (_("JITed object file architecture %s is not compatible "
920 "with target architecture %s."), bfd_get_arch_info
921 (nbfd)->printable_name, b->printable_name);
923 /* Read the section address information out of the symbol file. Since the
924 file is generated by the JIT at runtime, it should all of the absolute
925 addresses that we care about. */
926 sai = alloc_section_addr_info (bfd_count_sections (nbfd));
927 old_cleanups = make_cleanup_free_section_addr_info (sai);
929 for (sec = nbfd->sections; sec != NULL; sec = sec->next)
930 if ((bfd_get_section_flags (nbfd, sec) & (SEC_ALLOC|SEC_LOAD)) != 0)
932 /* We assume that these virtual addresses are absolute, and do not
933 treat them as offsets. */
934 sai->other[i].addr = bfd_get_section_vma (nbfd, sec);
935 sai->other[i].name = xstrdup (bfd_get_section_name (nbfd, sec));
936 sai->other[i].sectindex = sec->index;
939 sai->num_sections = i;
941 /* This call does not take ownership of SAI. */
942 make_cleanup_bfd_unref (nbfd);
943 objfile = symbol_file_add_from_bfd (nbfd, bfd_get_filename (nbfd), 0, sai,
944 OBJF_SHARED | OBJF_NOT_FILENAME, NULL);
946 do_cleanups (old_cleanups);
947 add_objfile_entry (objfile, entry_addr);
950 /* This function registers code associated with a JIT code entry. It uses the
951 pointer and size pair in the entry to read the symbol file from the remote
952 and then calls symbol_file_add_from_local_memory to add it as though it were
953 a symbol file added by the user. */
956 jit_register_code (struct gdbarch *gdbarch,
957 CORE_ADDR entry_addr, struct jit_code_entry *code_entry)
962 fprintf_unfiltered (gdb_stdlog,
963 "jit_register_code, symfile_addr = %s, "
964 "symfile_size = %s\n",
965 paddress (gdbarch, code_entry->symfile_addr),
966 pulongest (code_entry->symfile_size));
968 success = jit_reader_try_read_symtab (code_entry, entry_addr);
971 jit_bfd_try_read_symtab (code_entry, entry_addr, gdbarch);
974 /* This function unregisters JITed code and frees the corresponding
978 jit_unregister_code (struct objfile *objfile)
980 free_objfile (objfile);
983 /* Look up the objfile with this code entry address. */
985 static struct objfile *
986 jit_find_objf_with_entry_addr (CORE_ADDR entry_addr)
988 struct objfile *objf;
992 struct jit_objfile_data *objf_data;
995 = (struct jit_objfile_data *) objfile_data (objf, jit_objfile_data);
996 if (objf_data != NULL && objf_data->addr == entry_addr)
1002 /* This is called when a breakpoint is deleted. It updates the
1003 inferior's cache, if needed. */
1006 jit_breakpoint_deleted (struct breakpoint *b)
1008 struct bp_location *iter;
1010 if (b->type != bp_jit_event)
1013 for (iter = b->loc; iter != NULL; iter = iter->next)
1015 struct jit_program_space_data *ps_data;
1017 ps_data = ((struct jit_program_space_data *)
1018 program_space_data (iter->pspace, jit_program_space_data));
1019 if (ps_data != NULL && ps_data->jit_breakpoint == iter->owner)
1021 ps_data->cached_code_address = 0;
1022 ps_data->jit_breakpoint = NULL;
1027 /* (Re-)Initialize the jit breakpoint if necessary.
1028 Return 0 on success. */
1031 jit_breakpoint_re_set_internal (struct gdbarch *gdbarch,
1032 struct jit_program_space_data *ps_data)
1034 struct bound_minimal_symbol reg_symbol;
1035 struct bound_minimal_symbol desc_symbol;
1036 struct jit_objfile_data *objf_data;
1039 if (ps_data->objfile == NULL)
1041 /* Lookup the registration symbol. If it is missing, then we
1042 assume we are not attached to a JIT. */
1043 reg_symbol = lookup_minimal_symbol_and_objfile (jit_break_name);
1044 if (reg_symbol.minsym == NULL
1045 || BMSYMBOL_VALUE_ADDRESS (reg_symbol) == 0)
1048 desc_symbol = lookup_minimal_symbol (jit_descriptor_name, NULL,
1049 reg_symbol.objfile);
1050 if (desc_symbol.minsym == NULL
1051 || BMSYMBOL_VALUE_ADDRESS (desc_symbol) == 0)
1054 objf_data = get_jit_objfile_data (reg_symbol.objfile);
1055 objf_data->register_code = reg_symbol.minsym;
1056 objf_data->descriptor = desc_symbol.minsym;
1058 ps_data->objfile = reg_symbol.objfile;
1061 objf_data = get_jit_objfile_data (ps_data->objfile);
1063 addr = MSYMBOL_VALUE_ADDRESS (ps_data->objfile, objf_data->register_code);
1066 fprintf_unfiltered (gdb_stdlog,
1067 "jit_breakpoint_re_set_internal, "
1068 "breakpoint_addr = %s\n",
1069 paddress (gdbarch, addr));
1071 if (ps_data->cached_code_address == addr)
1074 /* Delete the old breakpoint. */
1075 if (ps_data->jit_breakpoint != NULL)
1076 delete_breakpoint (ps_data->jit_breakpoint);
1078 /* Put a breakpoint in the registration symbol. */
1079 ps_data->cached_code_address = addr;
1080 ps_data->jit_breakpoint = create_jit_event_breakpoint (gdbarch, addr);
1085 /* The private data passed around in the frame unwind callback
1088 struct jit_unwind_private
1090 /* Cached register values. See jit_frame_sniffer to see how this
1092 struct gdb_reg_value **registers;
1094 /* The frame being unwound. */
1095 struct frame_info *this_frame;
1098 /* Sets the value of a particular register in this frame. */
1101 jit_unwind_reg_set_impl (struct gdb_unwind_callbacks *cb, int dwarf_regnum,
1102 struct gdb_reg_value *value)
1104 struct jit_unwind_private *priv;
1107 priv = (struct jit_unwind_private *) cb->priv_data;
1109 gdb_reg = gdbarch_dwarf2_reg_to_regnum (get_frame_arch (priv->this_frame),
1114 fprintf_unfiltered (gdb_stdlog,
1115 _("Could not recognize DWARF regnum %d"),
1120 gdb_assert (priv->registers);
1121 priv->registers[gdb_reg] = value;
1125 reg_value_free_impl (struct gdb_reg_value *value)
1130 /* Get the value of register REGNUM in the previous frame. */
1132 static struct gdb_reg_value *
1133 jit_unwind_reg_get_impl (struct gdb_unwind_callbacks *cb, int regnum)
1135 struct jit_unwind_private *priv;
1136 struct gdb_reg_value *value;
1138 struct gdbarch *frame_arch;
1140 priv = (struct jit_unwind_private *) cb->priv_data;
1141 frame_arch = get_frame_arch (priv->this_frame);
1143 gdb_reg = gdbarch_dwarf2_reg_to_regnum (frame_arch, regnum);
1144 size = register_size (frame_arch, gdb_reg);
1145 value = ((struct gdb_reg_value *)
1146 xmalloc (sizeof (struct gdb_reg_value) + size - 1));
1147 value->defined = deprecated_frame_register_read (priv->this_frame, gdb_reg,
1150 value->free = reg_value_free_impl;
1154 /* gdb_reg_value has a free function, which must be called on each
1155 saved register value. */
1158 jit_dealloc_cache (struct frame_info *this_frame, void *cache)
1160 struct jit_unwind_private *priv_data = (struct jit_unwind_private *) cache;
1161 struct gdbarch *frame_arch;
1164 gdb_assert (priv_data->registers);
1165 frame_arch = get_frame_arch (priv_data->this_frame);
1167 for (i = 0; i < gdbarch_num_regs (frame_arch); i++)
1168 if (priv_data->registers[i] && priv_data->registers[i]->free)
1169 priv_data->registers[i]->free (priv_data->registers[i]);
1171 xfree (priv_data->registers);
1175 /* The frame sniffer for the pseudo unwinder.
1177 While this is nominally a frame sniffer, in the case where the JIT
1178 reader actually recognizes the frame, it does a lot more work -- it
1179 unwinds the frame and saves the corresponding register values in
1180 the cache. jit_frame_prev_register simply returns the saved
1184 jit_frame_sniffer (const struct frame_unwind *self,
1185 struct frame_info *this_frame, void **cache)
1187 struct jit_unwind_private *priv_data;
1188 struct gdb_unwind_callbacks callbacks;
1189 struct gdb_reader_funcs *funcs;
1191 callbacks.reg_get = jit_unwind_reg_get_impl;
1192 callbacks.reg_set = jit_unwind_reg_set_impl;
1193 callbacks.target_read = jit_target_read_impl;
1195 if (loaded_jit_reader == NULL)
1198 funcs = loaded_jit_reader->functions;
1200 gdb_assert (!*cache);
1202 *cache = XCNEW (struct jit_unwind_private);
1203 priv_data = (struct jit_unwind_private *) *cache;
1204 priv_data->registers =
1205 XCNEWVEC (struct gdb_reg_value *,
1206 gdbarch_num_regs (get_frame_arch (this_frame)));
1207 priv_data->this_frame = this_frame;
1209 callbacks.priv_data = priv_data;
1211 /* Try to coax the provided unwinder to unwind the stack */
1212 if (funcs->unwind (funcs, &callbacks) == GDB_SUCCESS)
1215 fprintf_unfiltered (gdb_stdlog, _("Successfully unwound frame using "
1220 fprintf_unfiltered (gdb_stdlog, _("Could not unwind frame using "
1223 jit_dealloc_cache (this_frame, *cache);
1230 /* The frame_id function for the pseudo unwinder. Relays the call to
1231 the loaded plugin. */
1234 jit_frame_this_id (struct frame_info *this_frame, void **cache,
1235 struct frame_id *this_id)
1237 struct jit_unwind_private priv;
1238 struct gdb_frame_id frame_id;
1239 struct gdb_reader_funcs *funcs;
1240 struct gdb_unwind_callbacks callbacks;
1242 priv.registers = NULL;
1243 priv.this_frame = this_frame;
1245 /* We don't expect the frame_id function to set any registers, so we
1246 set reg_set to NULL. */
1247 callbacks.reg_get = jit_unwind_reg_get_impl;
1248 callbacks.reg_set = NULL;
1249 callbacks.target_read = jit_target_read_impl;
1250 callbacks.priv_data = &priv;
1252 gdb_assert (loaded_jit_reader);
1253 funcs = loaded_jit_reader->functions;
1255 frame_id = funcs->get_frame_id (funcs, &callbacks);
1256 *this_id = frame_id_build (frame_id.stack_address, frame_id.code_address);
1259 /* Pseudo unwinder function. Reads the previously fetched value for
1260 the register from the cache. */
1262 static struct value *
1263 jit_frame_prev_register (struct frame_info *this_frame, void **cache, int reg)
1265 struct jit_unwind_private *priv = (struct jit_unwind_private *) *cache;
1266 struct gdb_reg_value *value;
1269 return frame_unwind_got_optimized (this_frame, reg);
1271 gdb_assert (priv->registers);
1272 value = priv->registers[reg];
1273 if (value && value->defined)
1274 return frame_unwind_got_bytes (this_frame, reg, value->value);
1276 return frame_unwind_got_optimized (this_frame, reg);
1279 /* Relay everything back to the unwinder registered by the JIT debug
1282 static const struct frame_unwind jit_frame_unwind =
1285 default_frame_unwind_stop_reason,
1287 jit_frame_prev_register,
1294 /* This is the information that is stored at jit_gdbarch_data for each
1297 struct jit_gdbarch_data_type
1299 /* Has the (pseudo) unwinder been prepended? */
1300 int unwinder_registered;
1303 /* Check GDBARCH and prepend the pseudo JIT unwinder if needed. */
1306 jit_prepend_unwinder (struct gdbarch *gdbarch)
1308 struct jit_gdbarch_data_type *data;
1311 = (struct jit_gdbarch_data_type *) gdbarch_data (gdbarch, jit_gdbarch_data);
1312 if (!data->unwinder_registered)
1314 frame_unwind_prepend_unwinder (gdbarch, &jit_frame_unwind);
1315 data->unwinder_registered = 1;
1319 /* Register any already created translations. */
1322 jit_inferior_init (struct gdbarch *gdbarch)
1324 struct jit_descriptor descriptor;
1325 struct jit_code_entry cur_entry;
1326 struct jit_program_space_data *ps_data;
1327 CORE_ADDR cur_entry_addr;
1330 fprintf_unfiltered (gdb_stdlog, "jit_inferior_init\n");
1332 jit_prepend_unwinder (gdbarch);
1334 ps_data = get_jit_program_space_data ();
1335 if (jit_breakpoint_re_set_internal (gdbarch, ps_data) != 0)
1338 /* Read the descriptor so we can check the version number and load
1339 any already JITed functions. */
1340 if (!jit_read_descriptor (gdbarch, &descriptor, ps_data))
1343 /* Check that the version number agrees with that we support. */
1344 if (descriptor.version != 1)
1346 printf_unfiltered (_("Unsupported JIT protocol version %ld "
1347 "in descriptor (expected 1)\n"),
1348 (long) descriptor.version);
1352 /* If we've attached to a running program, we need to check the descriptor
1353 to register any functions that were already generated. */
1354 for (cur_entry_addr = descriptor.first_entry;
1355 cur_entry_addr != 0;
1356 cur_entry_addr = cur_entry.next_entry)
1358 jit_read_code_entry (gdbarch, cur_entry_addr, &cur_entry);
1360 /* This hook may be called many times during setup, so make sure we don't
1361 add the same symbol file twice. */
1362 if (jit_find_objf_with_entry_addr (cur_entry_addr) != NULL)
1365 jit_register_code (gdbarch, cur_entry_addr, &cur_entry);
1369 /* Exported routine to call when an inferior has been created. */
1372 jit_inferior_created_hook (void)
1374 jit_inferior_init (target_gdbarch ());
1377 /* Exported routine to call to re-set the jit breakpoints,
1378 e.g. when a program is rerun. */
1381 jit_breakpoint_re_set (void)
1383 jit_breakpoint_re_set_internal (target_gdbarch (),
1384 get_jit_program_space_data ());
1387 /* This function cleans up any code entries left over when the
1388 inferior exits. We get left over code when the inferior exits
1389 without unregistering its code, for example when it crashes. */
1392 jit_inferior_exit_hook (struct inferior *inf)
1394 struct objfile *objf;
1395 struct objfile *temp;
1397 ALL_OBJFILES_SAFE (objf, temp)
1399 struct jit_objfile_data *objf_data
1400 = (struct jit_objfile_data *) objfile_data (objf, jit_objfile_data);
1402 if (objf_data != NULL && objf_data->addr != 0)
1403 jit_unregister_code (objf);
1408 jit_event_handler (struct gdbarch *gdbarch)
1410 struct jit_descriptor descriptor;
1411 struct jit_code_entry code_entry;
1412 CORE_ADDR entry_addr;
1413 struct objfile *objf;
1415 /* Read the descriptor from remote memory. */
1416 if (!jit_read_descriptor (gdbarch, &descriptor,
1417 get_jit_program_space_data ()))
1419 entry_addr = descriptor.relevant_entry;
1421 /* Do the corresponding action. */
1422 switch (descriptor.action_flag)
1427 jit_read_code_entry (gdbarch, entry_addr, &code_entry);
1428 jit_register_code (gdbarch, entry_addr, &code_entry);
1430 case JIT_UNREGISTER:
1431 objf = jit_find_objf_with_entry_addr (entry_addr);
1433 printf_unfiltered (_("Unable to find JITed code "
1434 "entry at address: %s\n"),
1435 paddress (gdbarch, entry_addr));
1437 jit_unregister_code (objf);
1441 error (_("Unknown action_flag value in JIT descriptor!"));
1446 /* Called to free the data allocated to the jit_program_space_data slot. */
1449 free_objfile_data (struct objfile *objfile, void *data)
1451 struct jit_objfile_data *objf_data = (struct jit_objfile_data *) data;
1453 if (objf_data->register_code != NULL)
1455 struct jit_program_space_data *ps_data;
1458 = ((struct jit_program_space_data *)
1459 program_space_data (objfile->pspace, jit_program_space_data));
1460 if (ps_data != NULL && ps_data->objfile == objfile)
1461 ps_data->objfile = NULL;
1467 /* Initialize the jit_gdbarch_data slot with an instance of struct
1468 jit_gdbarch_data_type */
1471 jit_gdbarch_data_init (struct obstack *obstack)
1473 struct jit_gdbarch_data_type *data =
1474 XOBNEW (obstack, struct jit_gdbarch_data_type);
1476 data->unwinder_registered = 0;
1481 /* Provide a prototype to silence -Wmissing-prototypes. */
1483 extern void _initialize_jit (void);
1486 _initialize_jit (void)
1488 jit_reader_dir = relocate_gdb_directory (JIT_READER_DIR,
1489 JIT_READER_DIR_RELOCATABLE);
1490 add_setshow_zuinteger_cmd ("jit", class_maintenance, &jit_debug,
1491 _("Set JIT debugging."),
1492 _("Show JIT debugging."),
1493 _("When non-zero, JIT debugging is enabled."),
1496 &setdebuglist, &showdebuglist);
1498 observer_attach_inferior_exit (jit_inferior_exit_hook);
1499 observer_attach_breakpoint_deleted (jit_breakpoint_deleted);
1502 register_objfile_data_with_cleanup (NULL, free_objfile_data);
1503 jit_program_space_data =
1504 register_program_space_data_with_cleanup (NULL,
1505 jit_program_space_data_cleanup);
1506 jit_gdbarch_data = gdbarch_data_register_pre_init (jit_gdbarch_data_init);
1507 if (is_dl_available ())
1509 add_com ("jit-reader-load", no_class, jit_reader_load_command, _("\
1510 Load FILE as debug info reader and unwinder for JIT compiled code.\n\
1511 Usage: jit-reader-load FILE\n\
1512 Try to load file FILE as a debug info reader (and unwinder) for\n\
1513 JIT compiled code. The file is loaded from " JIT_READER_DIR ",\n\
1514 relocated relative to the GDB executable if required."));
1515 add_com ("jit-reader-unload", no_class, jit_reader_unload_command, _("\
1516 Unload the currently loaded JIT debug info reader.\n\
1517 Usage: jit-reader-unload FILE\n\n\
1518 Do \"help jit-reader-load\" for info on loading debug info readers."));