GDB (xrefs)
/tmp/gdb-7.10/gdb/jit.c
Go to the documentation of this file.
1 /* Handle JIT code generation in the inferior for GDB, the GNU Debugger.
2 
3  Copyright (C) 2009-2015 Free Software Foundation, Inc.
4 
5  This file is part of GDB.
6 
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.
11 
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.
16 
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/>. */
19 
20 #include "defs.h"
21 
22 #include "jit.h"
23 #include "jit-reader.h"
24 #include "block.h"
25 #include "breakpoint.h"
26 #include "command.h"
27 #include "dictionary.h"
28 #include "filenames.h"
29 #include "frame-unwind.h"
30 #include "gdbcmd.h"
31 #include "gdbcore.h"
32 #include "inferior.h"
33 #include "observer.h"
34 #include "objfiles.h"
35 #include "regcache.h"
36 #include "symfile.h"
37 #include "symtab.h"
38 #include "target.h"
39 #include "gdb-dlfcn.h"
40 #include <sys/stat.h>
41 #include "gdb_bfd.h"
42 
43 static const char *jit_reader_dir = NULL;
44 
45 static const struct objfile_data *jit_objfile_data;
46 
47 static const char *const jit_break_name = "__jit_debug_register_code";
48 
49 static const char *const jit_descriptor_name = "__jit_debug_descriptor";
50 
51 static const struct program_space_data *jit_program_space_data = NULL;
52 
53 static void jit_inferior_init (struct gdbarch *gdbarch);
54 
55 /* An unwinder is registered for every gdbarch. This key is used to
56  remember if the unwinder has been registered for a particular
57  gdbarch. */
58 
60 
61 /* Non-zero if we want to see trace of jit level stuff. */
62 
63 static unsigned int jit_debug = 0;
64 
65 static void
66 show_jit_debug (struct ui_file *file, int from_tty,
67  struct cmd_list_element *c, const char *value)
68 {
69  fprintf_filtered (file, _("JIT debugging is %s.\n"), value);
70 }
71 
73 {
76 };
77 
78 /* Openning the file is a no-op. */
79 
80 static void *
81 mem_bfd_iovec_open (struct bfd *abfd, void *open_closure)
82 {
83  return open_closure;
84 }
85 
86 /* Closing the file is just freeing the base/size pair on our side. */
87 
88 static int
89 mem_bfd_iovec_close (struct bfd *abfd, void *stream)
90 {
91  xfree (stream);
92 
93  /* Zero means success. */
94  return 0;
95 }
96 
97 /* For reading the file, we just need to pass through to target_read_memory and
98  fix up the arguments and return values. */
99 
100 static file_ptr
101 mem_bfd_iovec_pread (struct bfd *abfd, void *stream, void *buf,
102  file_ptr nbytes, file_ptr offset)
103 {
104  int err;
105  struct target_buffer *buffer = (struct target_buffer *) stream;
106 
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;
110 
111  /* If there are no more bytes left, we've reached EOF. */
112  if (nbytes == 0)
113  return 0;
114 
115  err = target_read_memory (buffer->base + offset, (gdb_byte *) buf, nbytes);
116  if (err)
117  return -1;
118 
119  return nbytes;
120 }
121 
122 /* For statting the file, we only support the st_size attribute. */
123 
124 static int
125 mem_bfd_iovec_stat (struct bfd *abfd, void *stream, struct stat *sb)
126 {
127  struct target_buffer *buffer = (struct target_buffer*) stream;
128 
129  memset (sb, 0, sizeof (struct stat));
130  sb->st_size = buffer->size;
131  return 0;
132 }
133 
134 /* Open a BFD from the target's memory. */
135 
136 static struct bfd *
138 {
139  struct target_buffer *buffer = xmalloc (sizeof (struct target_buffer));
140 
141  buffer->base = addr;
142  buffer->size = size;
143  return gdb_bfd_openr_iovec ("<in-memory>", target,
145  buffer,
149 }
150 
151 /* One reader that has been loaded successfully, and can potentially be used to
152  parse debug info. */
153 
154 static struct jit_reader
155 {
157  void *handle;
158 } *loaded_jit_reader = NULL;
159 
160 typedef struct gdb_reader_funcs * (reader_init_fn_type) (void);
161 static const char *reader_init_fn_sym = "gdb_init_reader";
162 
163 /* Try to load FILE_NAME as a JIT debug info reader. */
164 
165 static struct jit_reader *
166 jit_reader_load (const char *file_name)
167 {
168  void *so;
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;
173 
174  if (jit_debug)
175  fprintf_unfiltered (gdb_stdlog, _("Opening shared object %s.\n"),
176  file_name);
177  so = gdb_dlopen (file_name);
178  old_cleanups = make_cleanup_dlclose (so);
179 
180  init_fn = gdb_dlsym (so, reader_init_fn_sym);
181  if (!init_fn)
182  error (_("Could not locate initialization function: %s."),
183  reader_init_fn_sym);
184 
185  if (gdb_dlsym (so, "plugin_is_GPL_compatible") == NULL)
186  error (_("Reader not GPL compatible."));
187 
188  funcs = init_fn ();
190  error (_("Reader version does not match GDB version."));
191 
192  new_reader = XCNEW (struct jit_reader);
193  new_reader->functions = funcs;
194  new_reader->handle = so;
195 
196  discard_cleanups (old_cleanups);
197  return new_reader;
198 }
199 
200 /* Provides the jit-reader-load command. */
201 
202 static void
203 jit_reader_load_command (char *args, int from_tty)
204 {
205  char *so_name;
206  struct cleanup *prev_cleanup;
207 
208  if (args == NULL)
209  error (_("No reader name provided."));
210 
211  if (loaded_jit_reader != NULL)
212  error (_("JIT reader already loaded. Run jit-reader-unload first."));
213 
214  if (IS_ABSOLUTE_PATH (args))
215  so_name = xstrdup (args);
216  else
217  so_name = xstrprintf ("%s%s%s", jit_reader_dir, SLASH_STRING, args);
218  prev_cleanup = make_cleanup (xfree, so_name);
219 
221  do_cleanups (prev_cleanup);
222 }
223 
224 /* Provides the jit-reader-unload command. */
225 
226 static void
227 jit_reader_unload_command (char *args, int from_tty)
228 {
229  if (!loaded_jit_reader)
230  error (_("No JIT reader loaded."));
231 
233 
236  loaded_jit_reader = NULL;
237 }
238 
239 /* Per-program space structure recording which objfile has the JIT
240  symbols. */
241 
242 struct jit_program_space_data
243 {
244  /* The objfile. This is NULL if no objfile holds the JIT
245  symbols. */
246 
247  struct objfile *objfile;
248 
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. */
252 
254 
255  /* This is the JIT event breakpoint, or NULL if it has not been
256  set. */
257 
259 };
260 
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
265  jit_code_entry. */
266 
267 struct jit_objfile_data
268 {
269  /* Symbol for __jit_debug_register_code. */
271 
272  /* Symbol for __jit_debug_descriptor. */
274 
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. */
278 };
279 
280 /* Fetch the jit_objfile_data associated with OBJF. If no data exists
281  yet, make a new structure and attach it. */
282 
283 static struct jit_objfile_data *
285 {
286  struct jit_objfile_data *objf_data;
287 
288  objf_data = objfile_data (objf, jit_objfile_data);
289  if (objf_data == NULL)
290  {
291  objf_data = XCNEW (struct jit_objfile_data);
292  set_objfile_data (objf, jit_objfile_data, objf_data);
293  }
294 
295  return objf_data;
296 }
297 
298 /* Remember OBJFILE has been created for struct jit_code_entry located
299  at inferior address ENTRY. */
300 
301 static void
303 {
304  struct jit_objfile_data *objf_data;
305 
306  objf_data = get_jit_objfile_data (objfile);
307  objf_data->addr = entry;
308 }
309 
310 /* Return jit_program_space_data for current program space. Allocate
311  if not already present. */
312 
313 static struct jit_program_space_data *
315 {
316  struct jit_program_space_data *ps_data;
317 
318  ps_data = program_space_data (current_program_space, jit_program_space_data);
319  if (ps_data == NULL)
320  {
321  ps_data = XCNEW (struct jit_program_space_data);
322  set_program_space_data (current_program_space, jit_program_space_data,
323  ps_data);
324  }
325 
326  return ps_data;
327 }
328 
329 static void
331 {
332  xfree (arg);
333 }
334 
335 /* Helper function for reading the global JIT descriptor from remote
336  memory. Returns 1 if all went well, 0 otherwise. */
337 
338 static int
340  struct jit_descriptor *descriptor,
341  struct jit_program_space_data *ps_data)
342 {
343  int err;
344  struct type *ptr_type;
345  int ptr_size;
346  int desc_size;
347  gdb_byte *desc_buf;
348  enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
349  struct jit_objfile_data *objf_data;
350 
351  if (ps_data->objfile == NULL)
352  return 0;
353  objf_data = get_jit_objfile_data (ps_data->objfile);
354  if (objf_data->descriptor == NULL)
355  return 0;
356 
357  if (jit_debug)
359  "jit_read_descriptor, descriptor_addr = %s\n",
360  paddress (gdbarch, MSYMBOL_VALUE_ADDRESS (ps_data->objfile,
361  objf_data->descriptor)));
362 
363  /* Figure out how big the descriptor is on the remote and how to read it. */
364  ptr_type = builtin_type (gdbarch)->builtin_data_ptr;
365  ptr_size = TYPE_LENGTH (ptr_type);
366  desc_size = 8 + 2 * ptr_size; /* Two 32-bit ints and two pointers. */
367  desc_buf = alloca (desc_size);
368 
369  /* Read the descriptor. */
371  objf_data->descriptor),
372  desc_buf, desc_size);
373  if (err)
374  {
375  printf_unfiltered (_("Unable to read JIT descriptor from "
376  "remote memory\n"));
377  return 0;
378  }
379 
380  /* Fix the endianness to match the host. */
381  descriptor->version = extract_unsigned_integer (&desc_buf[0], 4, byte_order);
382  descriptor->action_flag =
383  extract_unsigned_integer (&desc_buf[4], 4, byte_order);
384  descriptor->relevant_entry = extract_typed_address (&desc_buf[8], ptr_type);
385  descriptor->first_entry =
386  extract_typed_address (&desc_buf[8 + ptr_size], ptr_type);
387 
388  return 1;
389 }
390 
391 /* Helper function for reading a JITed code entry from remote memory. */
392 
393 static void
395  CORE_ADDR code_addr, struct jit_code_entry *code_entry)
396 {
397  int err, off;
398  struct type *ptr_type;
399  int ptr_size;
400  int entry_size;
401  int align_bytes;
402  gdb_byte *entry_buf;
403  enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
404 
405  /* Figure out how big the entry is on the remote and how to read it. */
406  ptr_type = builtin_type (gdbarch)->builtin_data_ptr;
407  ptr_size = TYPE_LENGTH (ptr_type);
408 
409  /* Figure out where the longlong value will be. */
410  align_bytes = gdbarch_long_long_align_bit (gdbarch) / 8;
411  off = 3 * ptr_size;
412  off = (off + (align_bytes - 1)) & ~(align_bytes - 1);
413 
414  entry_size = off + 8; /* Three pointers and one 64-bit int. */
415  entry_buf = alloca (entry_size);
416 
417  /* Read the entry. */
418  err = target_read_memory (code_addr, entry_buf, entry_size);
419  if (err)
420  error (_("Unable to read JIT code entry from remote memory!"));
421 
422  /* Fix the endianness to match the host. */
423  ptr_type = builtin_type (gdbarch)->builtin_data_ptr;
424  code_entry->next_entry = extract_typed_address (&entry_buf[0], ptr_type);
425  code_entry->prev_entry =
426  extract_typed_address (&entry_buf[ptr_size], ptr_type);
427  code_entry->symfile_addr =
428  extract_typed_address (&entry_buf[2 * ptr_size], ptr_type);
429  code_entry->symfile_size =
430  extract_unsigned_integer (&entry_buf[off], 8, byte_order);
431 }
432 
433 /* Proxy object for building a block. */
434 
435 struct gdb_block
436 {
437  /* gdb_blocks are linked into a tree structure. Next points to the
438  next node at the same depth as this block and parent to the
439  parent gdb_block. */
440  struct gdb_block *next, *parent;
441 
442  /* Points to the "real" block that is being built out of this
443  instance. This block will be added to a blockvector, which will
444  then be added to a symtab. */
445  struct block *real_block;
446 
447  /* The first and last code address corresponding to this block. */
449 
450  /* The name of this block (if any). If this is non-NULL, the
451  FUNCTION symbol symbol is set to this value. */
452  const char *name;
453 };
454 
455 /* Proxy object for building a symtab. */
456 
458 {
459  /* The list of blocks in this symtab. These will eventually be
460  converted to real blocks. */
461  struct gdb_block *blocks;
462 
463  /* The number of blocks inserted. */
464  int nblocks;
465 
466  /* A mapping between line numbers to PC. */
468 
469  /* The source file for this symtab. */
470  const char *file_name;
471  struct gdb_symtab *next;
472 };
473 
474 /* Proxy object for building an object. */
475 
477 {
479 };
480 
481 /* The type of the `private' data passed around by the callback
482  functions. */
483 
485 
486 /* The reader calls into this function to read data off the targets
487  address space. */
488 
489 static enum gdb_status
490 jit_target_read_impl (GDB_CORE_ADDR target_mem, void *gdb_buf, int len)
491 {
492  int result = target_read_memory ((CORE_ADDR) target_mem, gdb_buf, len);
493  if (result == 0)
494  return GDB_SUCCESS;
495  else
496  return GDB_FAIL;
497 }
498 
499 /* The reader calls into this function to create a new gdb_object
500  which it can then pass around to the other callbacks. Right now,
501  all that is required is allocating the memory. */
502 
503 static struct gdb_object *
505 {
506  /* CB is not required right now, but sometime in the future we might
507  need a handle to it, and we'd like to do that without breaking
508  the ABI. */
509  return XCNEW (struct gdb_object);
510 }
511 
512 /* Readers call into this function to open a new gdb_symtab, which,
513  again, is passed around to other callbacks. */
514 
515 static struct gdb_symtab *
517  struct gdb_object *object,
518  const char *file_name)
519 {
520  struct gdb_symtab *ret;
521 
522  /* CB stays unused. See comment in jit_object_open_impl. */
523 
524  ret = XCNEW (struct gdb_symtab);
525  ret->file_name = file_name ? xstrdup (file_name) : xstrdup ("");
526  ret->next = object->symtabs;
527  object->symtabs = ret;
528  return ret;
529 }
530 
531 /* Returns true if the block corresponding to old should be placed
532  before the block corresponding to new in the final blockvector. */
533 
534 static int
535 compare_block (const struct gdb_block *const old,
536  const struct gdb_block *const newobj)
537 {
538  if (old == NULL)
539  return 1;
540  if (old->begin < newobj->begin)
541  return 1;
542  else if (old->begin == newobj->begin)
543  {
544  if (old->end > newobj->end)
545  return 1;
546  else
547  return 0;
548  }
549  else
550  return 0;
551 }
552 
553 /* Called by readers to open a new gdb_block. This function also
554  inserts the new gdb_block in the correct place in the corresponding
555  gdb_symtab. */
556 
557 static struct gdb_block *
559  struct gdb_symtab *symtab, struct gdb_block *parent,
560  GDB_CORE_ADDR begin, GDB_CORE_ADDR end, const char *name)
561 {
562  struct gdb_block *block = XCNEW (struct gdb_block);
563 
564  block->next = symtab->blocks;
565  block->begin = (CORE_ADDR) begin;
566  block->end = (CORE_ADDR) end;
567  block->name = name ? xstrdup (name) : NULL;
568  block->parent = parent;
569 
570  /* Ensure that the blocks are inserted in the correct (reverse of
571  the order expected by blockvector). */
572  if (compare_block (symtab->blocks, block))
573  {
574  symtab->blocks = block;
575  }
576  else
577  {
578  struct gdb_block *i = symtab->blocks;
579 
580  for (;; i = i->next)
581  {
582  /* Guaranteed to terminate, since compare_block (NULL, _)
583  returns 1. */
584  if (compare_block (i->next, block))
585  {
586  block->next = i->next;
587  i->next = block;
588  break;
589  }
590  }
591  }
592  symtab->nblocks++;
593 
594  return block;
595 }
596 
597 /* Readers call this to add a line mapping (from PC to line number) to
598  a gdb_symtab. */
599 
600 static void
602  struct gdb_symtab *stab, int nlines,
603  struct gdb_line_mapping *map)
604 {
605  int i;
606 
607  if (nlines < 1)
608  return;
609 
610  stab->linetable = xmalloc (sizeof (struct linetable)
611  + (nlines - 1) * sizeof (struct linetable_entry));
612  stab->linetable->nitems = nlines;
613  for (i = 0; i < nlines; i++)
614  {
615  stab->linetable->item[i].pc = (CORE_ADDR) map[i].pc;
616  stab->linetable->item[i].line = map[i].line;
617  }
618 }
619 
620 /* Called by readers to close a gdb_symtab. Does not need to do
621  anything as of now. */
622 
623 static void
625  struct gdb_symtab *stab)
626 {
627  /* Right now nothing needs to be done here. We may need to do some
628  cleanup here in the future (again, without breaking the plugin
629  ABI). */
630 }
631 
632 /* Transform STAB to a proper symtab, and add it it OBJFILE. */
633 
634 static void
635 finalize_symtab (struct gdb_symtab *stab, struct objfile *objfile)
636 {
637  struct compunit_symtab *cust;
638  struct gdb_block *gdb_block_iter, *gdb_block_iter_tmp;
639  struct block *block_iter;
640  int actual_nblocks, i;
641  size_t blockvector_size;
642  CORE_ADDR begin, end;
643  struct blockvector *bv;
644 
645  actual_nblocks = FIRST_LOCAL_BLOCK + stab->nblocks;
646 
647  cust = allocate_compunit_symtab (objfile, stab->file_name);
648  allocate_symtab (cust, stab->file_name);
650 
651  /* JIT compilers compile in memory. */
652  COMPUNIT_DIRNAME (cust) = NULL;
653 
654  /* Copy over the linetable entry if one was provided. */
655  if (stab->linetable)
656  {
657  size_t size = ((stab->linetable->nitems - 1)
658  * sizeof (struct linetable_entry)
659  + sizeof (struct linetable));
661  = obstack_alloc (&objfile->objfile_obstack, size);
662  memcpy (SYMTAB_LINETABLE (COMPUNIT_FILETABS (cust)), stab->linetable,
663  size);
664  }
665 
666  blockvector_size = (sizeof (struct blockvector)
667  + (actual_nblocks - 1) * sizeof (struct block *));
668  bv = obstack_alloc (&objfile->objfile_obstack, blockvector_size);
669  COMPUNIT_BLOCKVECTOR (cust) = bv;
670 
671  /* (begin, end) will contain the PC range this entire blockvector
672  spans. */
673  BLOCKVECTOR_MAP (bv) = NULL;
674  begin = stab->blocks->begin;
675  end = stab->blocks->end;
676  BLOCKVECTOR_NBLOCKS (bv) = actual_nblocks;
677 
678  /* First run over all the gdb_block objects, creating a real block
679  object for each. Simultaneously, keep setting the real_block
680  fields. */
681  for (i = (actual_nblocks - 1), gdb_block_iter = stab->blocks;
682  i >= FIRST_LOCAL_BLOCK;
683  i--, gdb_block_iter = gdb_block_iter->next)
684  {
685  struct block *new_block = allocate_block (&objfile->objfile_obstack);
686  struct symbol *block_name = allocate_symbol (objfile);
687  struct type *block_type = arch_type (get_objfile_arch (objfile),
689  1,
690  "void");
691 
692  BLOCK_DICT (new_block) = dict_create_linear (&objfile->objfile_obstack,
693  NULL);
694  /* The address range. */
695  BLOCK_START (new_block) = (CORE_ADDR) gdb_block_iter->begin;
696  BLOCK_END (new_block) = (CORE_ADDR) gdb_block_iter->end;
697 
698  /* The name. */
699  SYMBOL_DOMAIN (block_name) = VAR_DOMAIN;
700  SYMBOL_ACLASS_INDEX (block_name) = LOC_BLOCK;
701  symbol_set_symtab (block_name, COMPUNIT_FILETABS (cust));
702  SYMBOL_TYPE (block_name) = lookup_function_type (block_type);
703  SYMBOL_BLOCK_VALUE (block_name) = new_block;
704 
705  block_name->ginfo.name = obstack_copy0 (&objfile->objfile_obstack,
706  gdb_block_iter->name,
707  strlen (gdb_block_iter->name));
708 
709  BLOCK_FUNCTION (new_block) = block_name;
710 
711  BLOCKVECTOR_BLOCK (bv, i) = new_block;
712  if (begin > BLOCK_START (new_block))
713  begin = BLOCK_START (new_block);
714  if (end < BLOCK_END (new_block))
715  end = BLOCK_END (new_block);
716 
717  gdb_block_iter->real_block = new_block;
718  }
719 
720  /* Now add the special blocks. */
721  block_iter = NULL;
722  for (i = 0; i < FIRST_LOCAL_BLOCK; i++)
723  {
724  struct block *new_block;
725 
726  new_block = (i == GLOBAL_BLOCK
728  : allocate_block (&objfile->objfile_obstack));
729  BLOCK_DICT (new_block) = dict_create_linear (&objfile->objfile_obstack,
730  NULL);
731  BLOCK_SUPERBLOCK (new_block) = block_iter;
732  block_iter = new_block;
733 
734  BLOCK_START (new_block) = (CORE_ADDR) begin;
735  BLOCK_END (new_block) = (CORE_ADDR) end;
736 
737  BLOCKVECTOR_BLOCK (bv, i) = new_block;
738 
739  if (i == GLOBAL_BLOCK)
740  set_block_compunit_symtab (new_block, cust);
741  }
742 
743  /* Fill up the superblock fields for the real blocks, using the
744  real_block fields populated earlier. */
745  for (gdb_block_iter = stab->blocks;
746  gdb_block_iter;
747  gdb_block_iter = gdb_block_iter->next)
748  {
749  if (gdb_block_iter->parent != NULL)
750  {
751  /* If the plugin specifically mentioned a parent block, we
752  use that. */
753  BLOCK_SUPERBLOCK (gdb_block_iter->real_block) =
754  gdb_block_iter->parent->real_block;
755  }
756  else
757  {
758  /* And if not, we set a default parent block. */
759  BLOCK_SUPERBLOCK (gdb_block_iter->real_block) =
761  }
762  }
763 
764  /* Free memory. */
765  gdb_block_iter = stab->blocks;
766 
767  for (gdb_block_iter = stab->blocks, gdb_block_iter_tmp = gdb_block_iter->next;
768  gdb_block_iter;
769  gdb_block_iter = gdb_block_iter_tmp)
770  {
771  xfree ((void *) gdb_block_iter->name);
772  xfree (gdb_block_iter);
773  }
774  xfree (stab->linetable);
775  xfree ((char *) stab->file_name);
776  xfree (stab);
777 }
778 
779 /* Called when closing a gdb_objfile. Converts OBJ to a proper
780  objfile. */
781 
782 static void
784  struct gdb_object *obj)
785 {
786  struct gdb_symtab *i, *j;
787  struct objfile *objfile;
788  jit_dbg_reader_data *priv_data;
789 
790  priv_data = cb->priv_data;
791 
792  objfile = allocate_objfile (NULL, "<< JIT compiled code >>",
794  objfile->per_bfd->gdbarch = target_gdbarch ();
795 
797 
798  j = NULL;
799  for (i = obj->symtabs; i; i = j)
800  {
801  j = i->next;
802  finalize_symtab (i, objfile);
803  }
804  add_objfile_entry (objfile, *priv_data);
805  xfree (obj);
806 }
807 
808 /* Try to read CODE_ENTRY using the loaded jit reader (if any).
809  ENTRY_ADDR is the address of the struct jit_code_entry in the
810  inferior address space. */
811 
812 static int
814  CORE_ADDR entry_addr)
815 {
816  void *gdb_mem;
817  int status;
818  jit_dbg_reader_data priv_data;
819  struct gdb_reader_funcs *funcs;
820  struct gdb_symbol_callbacks callbacks =
821  {
827 
830 
831  &priv_data
832  };
833 
834  priv_data = entry_addr;
835 
836  if (!loaded_jit_reader)
837  return 0;
838 
839  gdb_mem = xmalloc (code_entry->symfile_size);
840 
841  status = 1;
842  TRY
843  {
844  if (target_read_memory (code_entry->symfile_addr, gdb_mem,
845  code_entry->symfile_size))
846  status = 0;
847  }
849  {
850  status = 0;
851  }
852  END_CATCH
853 
854  if (status)
855  {
856  funcs = loaded_jit_reader->functions;
857  if (funcs->read (funcs, &callbacks, gdb_mem, code_entry->symfile_size)
858  != GDB_SUCCESS)
859  status = 0;
860  }
861 
862  xfree (gdb_mem);
863  if (jit_debug && status == 0)
865  "Could not read symtab using the loaded JIT reader.\n");
866  return status;
867 }
868 
869 /* Try to read CODE_ENTRY using BFD. ENTRY_ADDR is the address of the
870  struct jit_code_entry in the inferior address space. */
871 
872 static void
874  CORE_ADDR entry_addr,
875  struct gdbarch *gdbarch)
876 {
877  bfd *nbfd;
878  struct section_addr_info *sai;
879  struct bfd_section *sec;
880  struct objfile *objfile;
881  struct cleanup *old_cleanups;
882  int i;
883  const struct bfd_arch_info *b;
884 
885  if (jit_debug)
887  "jit_register_code, symfile_addr = %s, "
888  "symfile_size = %s\n",
889  paddress (gdbarch, code_entry->symfile_addr),
890  pulongest (code_entry->symfile_size));
891 
892  nbfd = bfd_open_from_target_memory (code_entry->symfile_addr,
893  code_entry->symfile_size, gnutarget);
894  if (nbfd == NULL)
895  {
896  puts_unfiltered (_("Error opening JITed symbol file, ignoring it.\n"));
897  return;
898  }
899 
900  /* Check the format. NOTE: This initializes important data that GDB uses!
901  We would segfault later without this line. */
902  if (!bfd_check_format (nbfd, bfd_object))
903  {
904  printf_unfiltered (_("\
905 JITed symbol file is not an object file, ignoring it.\n"));
906  gdb_bfd_unref (nbfd);
907  return;
908  }
909 
910  /* Check bfd arch. */
911  b = gdbarch_bfd_arch_info (gdbarch);
912  if (b->compatible (b, bfd_get_arch_info (nbfd)) != b)
913  warning (_("JITed object file architecture %s is not compatible "
914  "with target architecture %s."), bfd_get_arch_info
915  (nbfd)->printable_name, b->printable_name);
916 
917  /* Read the section address information out of the symbol file. Since the
918  file is generated by the JIT at runtime, it should all of the absolute
919  addresses that we care about. */
920  sai = alloc_section_addr_info (bfd_count_sections (nbfd));
921  old_cleanups = make_cleanup_free_section_addr_info (sai);
922  i = 0;
923  for (sec = nbfd->sections; sec != NULL; sec = sec->next)
924  if ((bfd_get_section_flags (nbfd, sec) & (SEC_ALLOC|SEC_LOAD)) != 0)
925  {
926  /* We assume that these virtual addresses are absolute, and do not
927  treat them as offsets. */
928  sai->other[i].addr = bfd_get_section_vma (nbfd, sec);
929  sai->other[i].name = xstrdup (bfd_get_section_name (nbfd, sec));
930  sai->other[i].sectindex = sec->index;
931  ++i;
932  }
933  sai->num_sections = i;
934 
935  /* This call does not take ownership of SAI. */
936  make_cleanup_bfd_unref (nbfd);
937  objfile = symbol_file_add_from_bfd (nbfd, bfd_get_filename (nbfd), 0, sai,
939 
940  do_cleanups (old_cleanups);
941  add_objfile_entry (objfile, entry_addr);
942 }
943 
944 /* This function registers code associated with a JIT code entry. It uses the
945  pointer and size pair in the entry to read the symbol file from the remote
946  and then calls symbol_file_add_from_local_memory to add it as though it were
947  a symbol file added by the user. */
948 
949 static void
951  CORE_ADDR entry_addr, struct jit_code_entry *code_entry)
952 {
953  int success;
954 
955  if (jit_debug)
957  "jit_register_code, symfile_addr = %s, "
958  "symfile_size = %s\n",
959  paddress (gdbarch, code_entry->symfile_addr),
960  pulongest (code_entry->symfile_size));
961 
962  success = jit_reader_try_read_symtab (code_entry, entry_addr);
963 
964  if (!success)
965  jit_bfd_try_read_symtab (code_entry, entry_addr, gdbarch);
966 }
967 
968 /* This function unregisters JITed code and frees the corresponding
969  objfile. */
970 
971 static void
973 {
974  free_objfile (objfile);
975 }
976 
977 /* Look up the objfile with this code entry address. */
978 
979 static struct objfile *
981 {
982  struct objfile *objf;
983 
984  ALL_OBJFILES (objf)
985  {
986  struct jit_objfile_data *objf_data;
987 
988  objf_data = objfile_data (objf, jit_objfile_data);
989  if (objf_data != NULL && objf_data->addr == entry_addr)
990  return objf;
991  }
992  return NULL;
993 }
994 
995 /* This is called when a breakpoint is deleted. It updates the
996  inferior's cache, if needed. */
997 
998 static void
1000 {
1001  struct bp_location *iter;
1002 
1003  if (b->type != bp_jit_event)
1004  return;
1005 
1006  for (iter = b->loc; iter != NULL; iter = iter->next)
1007  {
1008  struct jit_program_space_data *ps_data;
1009 
1010  ps_data = program_space_data (iter->pspace, jit_program_space_data);
1011  if (ps_data != NULL && ps_data->jit_breakpoint == iter->owner)
1012  {
1013  ps_data->cached_code_address = 0;
1014  ps_data->jit_breakpoint = NULL;
1015  }
1016  }
1017 }
1018 
1019 /* (Re-)Initialize the jit breakpoint if necessary.
1020  Return 0 on success. */
1021 
1022 static int
1024  struct jit_program_space_data *ps_data)
1025 {
1026  struct bound_minimal_symbol reg_symbol;
1027  struct bound_minimal_symbol desc_symbol;
1028  struct jit_objfile_data *objf_data;
1029  CORE_ADDR addr;
1030 
1031  if (ps_data->objfile == NULL)
1032  {
1033  /* Lookup the registration symbol. If it is missing, then we
1034  assume we are not attached to a JIT. */
1035  reg_symbol = lookup_minimal_symbol_and_objfile (jit_break_name);
1036  if (reg_symbol.minsym == NULL
1037  || BMSYMBOL_VALUE_ADDRESS (reg_symbol) == 0)
1038  return 1;
1039 
1040  desc_symbol = lookup_minimal_symbol (jit_descriptor_name, NULL,
1041  reg_symbol.objfile);
1042  if (desc_symbol.minsym == NULL
1043  || BMSYMBOL_VALUE_ADDRESS (desc_symbol) == 0)
1044  return 1;
1045 
1046  objf_data = get_jit_objfile_data (reg_symbol.objfile);
1047  objf_data->register_code = reg_symbol.minsym;
1048  objf_data->descriptor = desc_symbol.minsym;
1049 
1050  ps_data->objfile = reg_symbol.objfile;
1051  }
1052  else
1053  objf_data = get_jit_objfile_data (ps_data->objfile);
1054 
1055  addr = MSYMBOL_VALUE_ADDRESS (ps_data->objfile, objf_data->register_code);
1056 
1057  if (jit_debug)
1059  "jit_breakpoint_re_set_internal, "
1060  "breakpoint_addr = %s\n",
1061  paddress (gdbarch, addr));
1062 
1063  if (ps_data->cached_code_address == addr)
1064  return 1;
1065 
1066  /* Delete the old breakpoint. */
1067  if (ps_data->jit_breakpoint != NULL)
1068  delete_breakpoint (ps_data->jit_breakpoint);
1069 
1070  /* Put a breakpoint in the registration symbol. */
1071  ps_data->cached_code_address = addr;
1072  ps_data->jit_breakpoint = create_jit_event_breakpoint (gdbarch, addr);
1073 
1074  return 0;
1075 }
1076 
1077 /* The private data passed around in the frame unwind callback
1078  functions. */
1079 
1081 {
1082  /* Cached register values. See jit_frame_sniffer to see how this
1083  works. */
1085 
1086  /* The frame being unwound. */
1088 };
1089 
1090 /* Sets the value of a particular register in this frame. */
1091 
1092 static void
1093 jit_unwind_reg_set_impl (struct gdb_unwind_callbacks *cb, int dwarf_regnum,
1094  struct gdb_reg_value *value)
1095 {
1096  struct jit_unwind_private *priv;
1097  int gdb_reg;
1098 
1099  priv = cb->priv_data;
1100 
1102  dwarf_regnum);
1103  if (gdb_reg == -1)
1104  {
1105  if (jit_debug)
1107  _("Could not recognize DWARF regnum %d"),
1108  dwarf_regnum);
1109  return;
1110  }
1111 
1112  gdb_assert (priv->registers);
1113  priv->registers[gdb_reg] = value;
1114 }
1115 
1116 static void
1118 {
1119  xfree (value);
1120 }
1121 
1122 /* Get the value of register REGNUM in the previous frame. */
1123 
1124 static struct gdb_reg_value *
1126 {
1127  struct jit_unwind_private *priv;
1128  struct gdb_reg_value *value;
1129  int gdb_reg, size;
1130  struct gdbarch *frame_arch;
1131 
1132  priv = cb->priv_data;
1133  frame_arch = get_frame_arch (priv->this_frame);
1134 
1135  gdb_reg = gdbarch_dwarf2_reg_to_regnum (frame_arch, regnum);
1136  size = register_size (frame_arch, gdb_reg);
1137  value = xmalloc (sizeof (struct gdb_reg_value) + size - 1);
1138  value->defined = deprecated_frame_register_read (priv->this_frame, gdb_reg,
1139  value->value);
1140  value->size = size;
1141  value->free = reg_value_free_impl;
1142  return value;
1143 }
1144 
1145 /* gdb_reg_value has a free function, which must be called on each
1146  saved register value. */
1147 
1148 static void
1149 jit_dealloc_cache (struct frame_info *this_frame, void *cache)
1150 {
1151  struct jit_unwind_private *priv_data = cache;
1152  struct gdbarch *frame_arch;
1153  int i;
1154 
1155  gdb_assert (priv_data->registers);
1156  frame_arch = get_frame_arch (priv_data->this_frame);
1157 
1158  for (i = 0; i < gdbarch_num_regs (frame_arch); i++)
1159  if (priv_data->registers[i] && priv_data->registers[i]->free)
1160  priv_data->registers[i]->free (priv_data->registers[i]);
1161 
1162  xfree (priv_data->registers);
1163  xfree (priv_data);
1164 }
1165 
1166 /* The frame sniffer for the pseudo unwinder.
1167 
1168  While this is nominally a frame sniffer, in the case where the JIT
1169  reader actually recognizes the frame, it does a lot more work -- it
1170  unwinds the frame and saves the corresponding register values in
1171  the cache. jit_frame_prev_register simply returns the saved
1172  register values. */
1173 
1174 static int
1175 jit_frame_sniffer (const struct frame_unwind *self,
1176  struct frame_info *this_frame, void **cache)
1177 {
1178  struct jit_unwind_private *priv_data;
1179  struct gdb_unwind_callbacks callbacks;
1180  struct gdb_reader_funcs *funcs;
1181 
1182  callbacks.reg_get = jit_unwind_reg_get_impl;
1183  callbacks.reg_set = jit_unwind_reg_set_impl;
1184  callbacks.target_read = jit_target_read_impl;
1185 
1186  if (loaded_jit_reader == NULL)
1187  return 0;
1188 
1189  funcs = loaded_jit_reader->functions;
1190 
1191  gdb_assert (!*cache);
1192 
1193  *cache = XCNEW (struct jit_unwind_private);
1194  priv_data = *cache;
1195  priv_data->registers =
1196  XCNEWVEC (struct gdb_reg_value *,
1197  gdbarch_num_regs (get_frame_arch (this_frame)));
1198  priv_data->this_frame = this_frame;
1199 
1200  callbacks.priv_data = priv_data;
1201 
1202  /* Try to coax the provided unwinder to unwind the stack */
1203  if (funcs->unwind (funcs, &callbacks) == GDB_SUCCESS)
1204  {
1205  if (jit_debug)
1206  fprintf_unfiltered (gdb_stdlog, _("Successfully unwound frame using "
1207  "JIT reader.\n"));
1208  return 1;
1209  }
1210  if (jit_debug)
1211  fprintf_unfiltered (gdb_stdlog, _("Could not unwind frame using "
1212  "JIT reader.\n"));
1213 
1214  jit_dealloc_cache (this_frame, *cache);
1215  *cache = NULL;
1216 
1217  return 0;
1218 }
1219 
1220 
1221 /* The frame_id function for the pseudo unwinder. Relays the call to
1222  the loaded plugin. */
1223 
1224 static void
1225 jit_frame_this_id (struct frame_info *this_frame, void **cache,
1226  struct frame_id *this_id)
1227 {
1228  struct jit_unwind_private priv;
1229  struct gdb_frame_id frame_id;
1230  struct gdb_reader_funcs *funcs;
1231  struct gdb_unwind_callbacks callbacks;
1232 
1233  priv.registers = NULL;
1234  priv.this_frame = this_frame;
1235 
1236  /* We don't expect the frame_id function to set any registers, so we
1237  set reg_set to NULL. */
1238  callbacks.reg_get = jit_unwind_reg_get_impl;
1239  callbacks.reg_set = NULL;
1240  callbacks.target_read = jit_target_read_impl;
1241  callbacks.priv_data = &priv;
1242 
1244  funcs = loaded_jit_reader->functions;
1245 
1246  frame_id = funcs->get_frame_id (funcs, &callbacks);
1247  *this_id = frame_id_build (frame_id.stack_address, frame_id.code_address);
1248 }
1249 
1250 /* Pseudo unwinder function. Reads the previously fetched value for
1251  the register from the cache. */
1252 
1253 static struct value *
1254 jit_frame_prev_register (struct frame_info *this_frame, void **cache, int reg)
1255 {
1256  struct jit_unwind_private *priv = *cache;
1257  struct gdb_reg_value *value;
1258 
1259  if (priv == NULL)
1260  return frame_unwind_got_optimized (this_frame, reg);
1261 
1262  gdb_assert (priv->registers);
1263  value = priv->registers[reg];
1264  if (value && value->defined)
1265  return frame_unwind_got_bytes (this_frame, reg, value->value);
1266  else
1267  return frame_unwind_got_optimized (this_frame, reg);
1268 }
1269 
1270 /* Relay everything back to the unwinder registered by the JIT debug
1271  info reader.*/
1272 
1273 static const struct frame_unwind jit_frame_unwind =
1274 {
1275  NORMAL_FRAME,
1279  NULL,
1282 };
1283 
1284 
1285 /* This is the information that is stored at jit_gdbarch_data for each
1286  architecture. */
1287 
1289 {
1290  /* Has the (pseudo) unwinder been prepended? */
1292 };
1293 
1294 /* Check GDBARCH and prepend the pseudo JIT unwinder if needed. */
1295 
1296 static void
1298 {
1299  struct jit_gdbarch_data_type *data;
1300 
1301  data = gdbarch_data (gdbarch, jit_gdbarch_data);
1302  if (!data->unwinder_registered)
1303  {
1304  frame_unwind_prepend_unwinder (gdbarch, &jit_frame_unwind);
1305  data->unwinder_registered = 1;
1306  }
1307 }
1308 
1309 /* Register any already created translations. */
1310 
1311 static void
1313 {
1314  struct jit_descriptor descriptor;
1315  struct jit_code_entry cur_entry;
1316  struct jit_program_space_data *ps_data;
1317  CORE_ADDR cur_entry_addr;
1318 
1319  if (jit_debug)
1320  fprintf_unfiltered (gdb_stdlog, "jit_inferior_init\n");
1321 
1322  jit_prepend_unwinder (gdbarch);
1323 
1324  ps_data = get_jit_program_space_data ();
1325  if (jit_breakpoint_re_set_internal (gdbarch, ps_data) != 0)
1326  return;
1327 
1328  /* Read the descriptor so we can check the version number and load
1329  any already JITed functions. */
1330  if (!jit_read_descriptor (gdbarch, &descriptor, ps_data))
1331  return;
1332 
1333  /* Check that the version number agrees with that we support. */
1334  if (descriptor.version != 1)
1335  {
1336  printf_unfiltered (_("Unsupported JIT protocol version %ld "
1337  "in descriptor (expected 1)\n"),
1338  (long) descriptor.version);
1339  return;
1340  }
1341 
1342  /* If we've attached to a running program, we need to check the descriptor
1343  to register any functions that were already generated. */
1344  for (cur_entry_addr = descriptor.first_entry;
1345  cur_entry_addr != 0;
1346  cur_entry_addr = cur_entry.next_entry)
1347  {
1348  jit_read_code_entry (gdbarch, cur_entry_addr, &cur_entry);
1349 
1350  /* This hook may be called many times during setup, so make sure we don't
1351  add the same symbol file twice. */
1352  if (jit_find_objf_with_entry_addr (cur_entry_addr) != NULL)
1353  continue;
1354 
1355  jit_register_code (gdbarch, cur_entry_addr, &cur_entry);
1356  }
1357 }
1358 
1359 /* Exported routine to call when an inferior has been created. */
1360 
1361 void
1363 {
1365 }
1366 
1367 /* Exported routine to call to re-set the jit breakpoints,
1368  e.g. when a program is rerun. */
1369 
1370 void
1372 {
1375 }
1376 
1377 /* This function cleans up any code entries left over when the
1378  inferior exits. We get left over code when the inferior exits
1379  without unregistering its code, for example when it crashes. */
1380 
1381 static void
1383 {
1384  struct objfile *objf;
1385  struct objfile *temp;
1386 
1387  ALL_OBJFILES_SAFE (objf, temp)
1388  {
1389  struct jit_objfile_data *objf_data = objfile_data (objf,
1390  jit_objfile_data);
1391 
1392  if (objf_data != NULL && objf_data->addr != 0)
1393  jit_unregister_code (objf);
1394  }
1395 }
1396 
1397 void
1399 {
1400  struct jit_descriptor descriptor;
1401  struct jit_code_entry code_entry;
1402  CORE_ADDR entry_addr;
1403  struct objfile *objf;
1404 
1405  /* Read the descriptor from remote memory. */
1406  if (!jit_read_descriptor (gdbarch, &descriptor,
1408  return;
1409  entry_addr = descriptor.relevant_entry;
1410 
1411  /* Do the corresponding action. */
1412  switch (descriptor.action_flag)
1413  {
1414  case JIT_NOACTION:
1415  break;
1416  case JIT_REGISTER:
1417  jit_read_code_entry (gdbarch, entry_addr, &code_entry);
1418  jit_register_code (gdbarch, entry_addr, &code_entry);
1419  break;
1420  case JIT_UNREGISTER:
1421  objf = jit_find_objf_with_entry_addr (entry_addr);
1422  if (objf == NULL)
1423  printf_unfiltered (_("Unable to find JITed code "
1424  "entry at address: %s\n"),
1425  paddress (gdbarch, entry_addr));
1426  else
1427  jit_unregister_code (objf);
1428 
1429  break;
1430  default:
1431  error (_("Unknown action_flag value in JIT descriptor!"));
1432  break;
1433  }
1434 }
1435 
1436 /* Called to free the data allocated to the jit_program_space_data slot. */
1437 
1438 static void
1439 free_objfile_data (struct objfile *objfile, void *data)
1440 {
1441  struct jit_objfile_data *objf_data = data;
1442 
1443  if (objf_data->register_code != NULL)
1444  {
1445  struct jit_program_space_data *ps_data;
1446 
1447  ps_data = program_space_data (objfile->pspace, jit_program_space_data);
1448  if (ps_data != NULL && ps_data->objfile == objfile)
1449  ps_data->objfile = NULL;
1450  }
1451 
1452  xfree (data);
1453 }
1454 
1455 /* Initialize the jit_gdbarch_data slot with an instance of struct
1456  jit_gdbarch_data_type */
1457 
1458 static void *
1459 jit_gdbarch_data_init (struct obstack *obstack)
1460 {
1461  struct jit_gdbarch_data_type *data;
1462 
1463  data = obstack_alloc (obstack, sizeof (struct jit_gdbarch_data_type));
1464  data->unwinder_registered = 0;
1465  return data;
1466 }
1467 
1468 /* Provide a prototype to silence -Wmissing-prototypes. */
1469 
1470 extern void _initialize_jit (void);
1471 
1472 void
1474 {
1475  jit_reader_dir = relocate_gdb_directory (JIT_READER_DIR,
1477  add_setshow_zuinteger_cmd ("jit", class_maintenance, &jit_debug,
1478  _("Set JIT debugging."),
1479  _("Show JIT debugging."),
1480  _("When non-zero, JIT debugging is enabled."),
1481  NULL,
1484 
1487 
1488  jit_objfile_data =
1489  register_objfile_data_with_cleanup (NULL, free_objfile_data);
1490  jit_program_space_data =
1491  register_program_space_data_with_cleanup (NULL,
1494  if (is_dl_available ())
1495  {
1496  add_com ("jit-reader-load", no_class, jit_reader_load_command, _("\
1497 Load FILE as debug info reader and unwinder for JIT compiled code.\n\
1498 Usage: jit-reader-load FILE\n\
1499 Try to load file FILE as a debug info reader (and unwinder) for\n\
1500 JIT compiled code. The file is loaded from " JIT_READER_DIR ",\n\
1501 relocated relative to the GDB executable if required."));
1502  add_com ("jit-reader-unload", no_class, jit_reader_unload_command, _("\
1503 Unload the currently loaded JIT debug info reader.\n\
1504 Usage: jit-reader-unload FILE\n\n\
1505 Do \"help jit-reader-load\" for info on loading debug info readers."));
1506  }
1507 }
unsigned char value[1]
Definition: jit-reader.h:211
struct gdbarch * target_gdbarch(void)
Definition: gdbarch.c:5143
struct linetable * linetable
Definition: jit.c:467
char * name
Definition: symfile.h:78
ULONGEST extract_unsigned_integer(const gdb_byte *, int, enum bfd_endian)
Definition: findvar.c:84
struct breakpoint * create_jit_event_breakpoint(struct gdbarch *gdbarch, CORE_ADDR address)
Definition: breakpoint.c:7657
#define OBJF_SHARED
Definition: objfiles.h:432
struct gdb_reader_funcs * functions
Definition: jit.c:156
static void free_objfile_data(struct objfile *objfile, void *data)
Definition: jit.c:1439
struct observer * observer_attach_breakpoint_deleted(observer_breakpoint_deleted_ftype *f)
struct frame_id frame_id_build(CORE_ADDR stack_addr, CORE_ADDR code_addr)
Definition: frame.c:554
CORE_ADDR extract_typed_address(const gdb_byte *buf, struct type *type)
Definition: findvar.c:169
struct value * frame_unwind_got_bytes(struct frame_info *frame, int regnum, gdb_byte *buf)
Definition: frame-unwind.c:255
#define GDB_READER_INTERFACE_VERSION
Definition: jit-reader.h:29
#define JIT_READER_DIR
Definition: config.h:608
int gdb_dlclose(void *handle)
Definition: gdb-dlfcn.c:110
static file_ptr mem_bfd_iovec_pread(struct bfd *abfd, void *stream, void *buf, file_ptr nbytes, file_ptr offset)
Definition: jit.c:101
static struct jit_reader * jit_reader_load(const char *file_name)
Definition: jit.c:166
void add_setshow_zuinteger_cmd(const char *name, enum command_class theclass, unsigned int *var, const char *set_doc, const char *show_doc, const char *help_doc, cmd_sfunc_ftype *set_func, show_value_ftype *show_func, struct cmd_list_element **set_list, struct cmd_list_element **show_list)
Definition: cli-decode.c:763
void _initialize_jit(void)
Definition: jit.c:1473
void symbol_set_symtab(struct symbol *symbol, struct symtab *symtab)
Definition: symtab.c:6259
const char * file_name
Definition: jit.c:470
CORE_ADDR begin
Definition: jit.c:448
bfd_vma CORE_ADDR
Definition: common-types.h:41
struct linetable_entry item[1]
Definition: symtab.h:892
static int mem_bfd_iovec_stat(struct bfd *abfd, void *stream, struct stat *sb)
Definition: jit.c:125
static struct gdb_reg_value * jit_unwind_reg_get_impl(struct gdb_unwind_callbacks *cb, int regnum)
Definition: jit.c:1125
static const char *const jit_break_name
Definition: jit.c:47
static const char *const jit_descriptor_name
Definition: jit.c:49
static int jit_read_descriptor(struct gdbarch *gdbarch, struct jit_descriptor *descriptor, struct jit_program_space_data *ps_data)
Definition: jit.c:339
struct block * real_block
Definition: jit.c:445
void xfree(void *)
Definition: common-utils.c:97
gdb_unwind_reg_get * reg_get
Definition: jit-reader.h:270
#define JIT_READER_DIR_RELOCATABLE
Definition: config.h:612
struct objfile * symbol_file_add_from_bfd(bfd *abfd, const char *name, int add_flags, struct section_addr_info *addrs, int flags, struct objfile *parent)
Definition: symfile.c:1276
CORE_ADDR relevant_entry
Definition: jit.h:63
#define BMSYMBOL_VALUE_ADDRESS(symbol)
Definition: symtab.h:393
static struct jit_reader * loaded_jit_reader
void warning(const char *fmt,...)
Definition: errors.c:26
void jit_breakpoint_re_set(void)
Definition: jit.c:1371
struct program_space * pspace
Definition: objfiles.h:286
void * gdb_dlopen(const char *filename)
Definition: gdb-dlfcn.c:68
static void jit_breakpoint_deleted(struct breakpoint *b)
Definition: jit.c:999
static struct bfd * bfd_open_from_target_memory(CORE_ADDR addr, ULONGEST size, char *target)
Definition: jit.c:137
struct gdb_block * blocks
Definition: jit.c:461
void * gdbarch_data(struct gdbarch *gdbarch, struct gdbarch_data *data)
Definition: gdbarch.c:4845
struct compunit_symtab * allocate_compunit_symtab(struct objfile *objfile, const char *name)
Definition: symfile.c:2954
const struct builtin_type * builtin_type(struct gdbarch *gdbarch)
Definition: gdbtypes.c:4766
static void jit_reader_unload_command(char *args, int from_tty)
Definition: jit.c:227
int sectindex
Definition: symfile.h:81
static void jit_register_code(struct gdbarch *gdbarch, CORE_ADDR entry_addr, struct jit_code_entry *code_entry)
Definition: jit.c:950
gdb_destroy_reader * destroy
Definition: jit-reader.h:339
gdb_target_read * target_read
Definition: jit-reader.h:272
Definition: jit.h:41
gdb_reg_value_free * free
Definition: jit-reader.h:208
struct observer * observer_attach_inferior_exit(observer_inferior_exit_ftype *f)
#define BLOCKVECTOR_BLOCK(blocklist, n)
Definition: block.h:136
#define OBJF_NOT_FILENAME
Definition: objfiles.h:460
struct gdbarch_data * gdbarch_data_register_pre_init(gdbarch_data_pre_init_ftype *pre_init)
Definition: gdbarch.c:4806
int gdbarch_num_regs(struct gdbarch *gdbarch)
Definition: gdbarch.c:1898
#define _(String)
Definition: gdb_locale.h:40
static void show_jit_debug(struct ui_file *file, int from_tty, struct cmd_list_element *c, const char *value)
Definition: jit.c:66
static void * jit_gdbarch_data_init(struct obstack *obstack)
Definition: jit.c:1459
#define BLOCK_START(bl)
Definition: block.h:116
#define COMPUNIT_DIRNAME(cust)
Definition: symtab.h:1098
static struct objfile * jit_find_objf_with_entry_addr(CORE_ADDR entry_addr)
Definition: jit.c:980
int is_dl_available(void)
Definition: gdb-dlfcn.c:132
#define END_CATCH
void frame_unwind_prepend_unwinder(struct gdbarch *gdbarch, const struct frame_unwind *unwinder)
Definition: frame-unwind.c:64
struct objfile_per_bfd_storage * per_bfd
Definition: objfiles.h:318
int gdbarch_long_long_align_bit(struct gdbarch *gdbarch)
Definition: gdbarch.c:1541
CORE_ADDR addr
Definition: symfile.h:77
static int mem_bfd_iovec_close(struct bfd *abfd, void *stream)
Definition: jit.c:89
const char * paddress(struct gdbarch *gdbarch, CORE_ADDR addr)
Definition: utils.c:2743
static void jit_dealloc_cache(struct frame_info *this_frame, void *cache)
Definition: jit.c:1149
static int jit_frame_sniffer(const struct frame_unwind *self, struct frame_info *this_frame, void **cache)
Definition: jit.c:1175
#define BLOCK_FUNCTION(bl)
Definition: block.h:118
static void jit_frame_this_id(struct frame_info *this_frame, void **cache, struct frame_id *this_id)
Definition: jit.c:1225
static void jit_read_code_entry(struct gdbarch *gdbarch, CORE_ADDR code_addr, struct jit_code_entry *code_entry)
Definition: jit.c:394
struct obstack objfile_obstack
Definition: objfiles.h:328
static void add_objfile_entry(struct objfile *objfile, CORE_ADDR entry)
Definition: jit.c:302
#define TRY
CORE_ADDR symfile_addr
Definition: jit.h:45
const char *const name
Definition: aarch64-tdep.c:68
#define ALL_OBJFILES(obj)
Definition: objfiles.h:579
gdb_get_frame_id * get_frame_id
Definition: jit-reader.h:338
#define SLASH_STRING
Definition: host-defs.h:58
ULONGEST symfile_size
Definition: jit.h:46
struct bp_location * next
Definition: breakpoint.h:307
#define SYMBOL_ACLASS_INDEX(symbol)
Definition: symtab.h:792
void * gdb_dlsym(void *handle, const char *symbol)
Definition: gdb-dlfcn.c:100
#define CATCH(EXCEPTION, MASK)
struct cleanup * make_cleanup_dlclose(void *handle)
Definition: gdb-dlfcn.c:126
static void reg_value_free_impl(struct gdb_reg_value *value)
Definition: jit.c:1117
unsigned long GDB_CORE_ADDR
Definition: jit-reader.h:59
void free_objfile(struct objfile *objfile)
Definition: objfiles.c:540
char * gnutarget
Definition: corefile.c:437
static struct gdb_symtab * jit_symtab_open_impl(struct gdb_symbol_callbacks *cb, struct gdb_object *object, const char *file_name)
Definition: jit.c:516
void gdb_bfd_unref(struct bfd *abfd)
Definition: gdb_bfd.c:475
#define SYMBOL_DOMAIN(symbol)
Definition: symtab.h:790
CORE_ADDR pc
Definition: symtab.h:865
struct program_space * pspace
Definition: breakpoint.h:404
static struct gdb_block * jit_block_open_impl(struct gdb_symbol_callbacks *cb, struct gdb_symtab *symtab, struct gdb_block *parent, GDB_CORE_ADDR begin, GDB_CORE_ADDR end, const char *name)
Definition: jit.c:558
void fprintf_filtered(struct ui_file *stream, const char *format,...)
Definition: utils.c:2351
CORE_ADDR cached_code_address
Definition: jit.c:253
void jit_inferior_created_hook(void)
Definition: jit.c:1362
gdb_read_debug_info * read
Definition: jit-reader.h:336
mach_port_t mach_port_t name mach_port_t mach_port_t name error_t err
Definition: gnu-nat.c:1816
struct bound_minimal_symbol lookup_minimal_symbol_and_objfile(const char *name)
Definition: minsyms.c:881
void fprintf_unfiltered(struct ui_file *stream, const char *format,...)
Definition: utils.c:2361
mach_port_t mach_port_t name mach_port_t mach_port_t name error_t int status
Definition: gnu-nat.c:1816
struct gdb_symtab * next
Definition: jit.c:471
block_type
Definition: mdebugread.c:236
enum bfd_endian gdbarch_byte_order(struct gdbarch *gdbarch)
Definition: gdbarch.c:1420
struct cleanup * make_cleanup(make_cleanup_ftype *function, void *arg)
Definition: cleanups.c:117
struct gdbarch * get_objfile_arch(const struct objfile *objfile)
Definition: objfiles.c:368
void add_compunit_symtab_to_objfile(struct compunit_symtab *cu)
Definition: symfile.c:2985
gdb_unwind_reg_set * reg_set
Definition: jit-reader.h:271
Definition: symtab.h:862
static void jit_unwind_reg_set_impl(struct gdb_unwind_callbacks *cb, int dwarf_regnum, struct gdb_reg_value *value)
Definition: jit.c:1093
Definition: gdbtypes.h:749
struct dictionary * dict_create_linear(struct obstack *obstack, const struct pending *symbol_list)
Definition: dictionary.c:420
void * handle
Definition: jit.c:157
#define BLOCK_SUPERBLOCK(bl)
Definition: block.h:119
uint32_t version
Definition: jit.h:59
Definition: gnu-nat.c:163
bfd * gdb_bfd_openr_iovec(const char *filename, const char *target, void *(*open_func)(struct bfd *nbfd, void *open_closure), void *open_closure, file_ptr(*pread_func)(struct bfd *nbfd, void *stream, void *buf, file_ptr nbytes, file_ptr offset), int(*close_func)(struct bfd *nbfd, void *stream), int(*stat_func)(struct bfd *abfd, void *stream, struct stat *sb))
Definition: gdb_bfd.c:715
#define gdb_assert(expr)
Definition: gdb_assert.h:33
CORE_ADDR jit_dbg_reader_data
Definition: jit.c:484
struct frame_info * this_frame
Definition: jit.c:1087
static void jit_symtab_close_impl(struct gdb_symbol_callbacks *cb, struct gdb_symtab *stab)
Definition: jit.c:624
#define BLOCK_END(bl)
Definition: block.h:117
static enum gdb_status jit_target_read_impl(GDB_CORE_ADDR target_mem, void *gdb_buf, int len)
Definition: jit.c:490
const char * name
Definition: jit.c:452
struct gdb_reader_funcs *( reader_init_fn_type)(void)
Definition: jit.c:160
static void jit_bfd_try_read_symtab(struct jit_code_entry *code_entry, CORE_ADDR entry_addr, struct gdbarch *gdbarch)
Definition: jit.c:873
static struct jit_program_space_data * get_jit_program_space_data(void)
Definition: jit.c:314
struct block * allocate_block(struct obstack *obstack)
Definition: block.c:401
CORE_ADDR prev_entry
Definition: jit.h:44
char * xstrprintf(const char *format,...)
Definition: common-utils.c:107
#define BLOCK_DICT(bl)
Definition: block.h:120
int regnum
Definition: aarch64-tdep.c:69
static void * mem_bfd_iovec_open(struct bfd *abfd, void *open_closure)
Definition: jit.c:81
void printf_unfiltered(const char *format,...)
Definition: utils.c:2399
struct cmd_list_element * setdebuglist
Definition: cli-cmds.c:173
Definition: symtab.h:925
static void jit_inferior_exit_hook(struct inferior *inf)
Definition: jit.c:1382
struct cleanup * make_cleanup_bfd_unref(bfd *abfd)
Definition: utils.c:189
void * xmalloc(YYSIZE_T)
struct ui_file * gdb_stdlog
Definition: main.c:73
static void jit_program_space_data_cleanup(struct program_space *ps, void *arg)
Definition: jit.c:330
const char * name
Definition: symtab.h:98
Definition: regdef.h:22
struct gdb_reg_value ** registers
Definition: jit.c:1084
Definition: block.h:60
Definition: value.c:172
enum bptype type
Definition: breakpoint.h:669
gdb_status
Definition: jit-reader.h:63
size_t num_sections
Definition: symfile.h:95
int gdbarch_dwarf2_reg_to_regnum(struct gdbarch *gdbarch, int dwarf2_regnr)
Definition: gdbarch.c:2100
uint32_t action_flag
Definition: jit.h:62
struct value * frame_unwind_got_optimized(struct frame_info *frame, int regnum)
Definition: frame-unwind.c:197
#define COMPUNIT_BLOCKVECTOR(cust)
Definition: symtab.h:1099
bfd_byte gdb_byte
Definition: common-types.h:38
static struct gdbarch_data * jit_gdbarch_data
Definition: jit.c:59
struct minimal_symbol * register_code
Definition: jit.c:270
GDB_CORE_ADDR stack_address
Definition: jit-reader.h:226
void discard_cleanups(struct cleanup *old_chain)
Definition: cleanups.c:213
static void jit_prepend_unwinder(struct gdbarch *gdbarch)
Definition: jit.c:1297
void puts_unfiltered(const char *string)
Definition: utils.c:2434
struct symbol * allocate_symbol(struct objfile *objfile)
Definition: symtab.c:6204
gdb_unwind_frame * unwind
Definition: jit-reader.h:337
static struct jit_objfile_data * get_jit_objfile_data(struct objfile *objf)
Definition: jit.c:284
int deprecated_frame_register_read(struct frame_info *frame, int regnum, gdb_byte *myaddr)
Definition: frame.c:1258
CORE_ADDR base
Definition: jit.c:74
#define SYMBOL_BLOCK_VALUE(symbol)
Definition: symtab.h:185
static unsigned int jit_debug
Definition: jit.c:63
struct objfile * objfile
Definition: jit.c:247
int target_read_memory(CORE_ADDR memaddr, gdb_byte *myaddr, ssize_t len)
Definition: target.c:1393
static void jit_symtab_line_mapping_add_impl(struct gdb_symbol_callbacks *cb, struct gdb_symtab *stab, int nlines, struct gdb_line_mapping *map)
Definition: jit.c:601
struct type * builtin_data_ptr
Definition: gdbtypes.h:1533
CORE_ADDR end
Definition: jit.c:448
struct minimal_symbol * minsym
Definition: minsyms.h:32
struct gdbarch * gdbarch
Definition: objfiles.h:191
struct bp_location * loc
Definition: breakpoint.h:678
static struct value * jit_frame_prev_register(struct frame_info *this_frame, void **cache, int reg)
Definition: jit.c:1254
int offset
Definition: agent.c:65
static void jit_inferior_init(struct gdbarch *gdbarch)
Definition: jit.c:1312
struct symtab * allocate_symtab(struct compunit_symtab *cust, const char *filename)
Definition: symfile.c:2898
struct general_symbol_info ginfo
Definition: symtab.h:708
Definition: buffer.h:23
struct gdb_block * next
Definition: jit.c:440
struct minimal_symbol * descriptor
Definition: jit.c:273
#define COMPUNIT_FILETABS(cust)
Definition: symtab.h:1095
#define ALL_OBJFILES_SAFE(obj, nxt)
Definition: objfiles.h:584
Definition: jit.c:435
static void finalize_symtab(struct gdb_symtab *stab, struct objfile *objfile)
Definition: jit.c:635
#define BLOCKVECTOR_NBLOCKS(blocklist)
Definition: block.h:135
struct objfile * allocate_objfile(bfd *abfd, const char *name, int flags)
Definition: objfiles.c:285
struct other_sections other[1]
Definition: symfile.h:97
void set_block_compunit_symtab(struct block *block, struct compunit_symtab *cu)
Definition: block.c:421
struct program_space * current_program_space
Definition: progspace.c:35
int nblocks
Definition: jit.c:464
unsigned long long ULONGEST
Definition: common-types.h:53
enum unwind_stop_reason default_frame_unwind_stop_reason(struct frame_info *this_frame, void **this_cache)
Definition: frame-unwind.c:180
int register_size(struct gdbarch *gdbarch, int regnum)
Definition: regcache.c:169
static int compare_block(const struct gdb_block *const old, const struct gdb_block *const newobj)
Definition: jit.c:535
static void jit_object_close_impl(struct gdb_symbol_callbacks *cb, struct gdb_object *obj)
Definition: jit.c:783
static void jit_reader_load_command(char *args, int from_tty)
Definition: jit.c:203
int nitems
Definition: symtab.h:887
#define SYMBOL_TYPE(symbol)
Definition: symtab.h:799
ULONGEST size
Definition: jit.c:75
Definition: symtab.h:703
const struct bfd_arch_info * gdbarch_bfd_arch_info(struct gdbarch *gdbarch)
Definition: gdbarch.c:1411
char * relocate_gdb_directory(const char *initial, int flag)
Definition: main.c:161
struct cmd_list_element * showdebuglist
Definition: cli-cmds.c:175
CORE_ADDR next_entry
Definition: jit.h:43
struct breakpoint * jit_breakpoint
Definition: jit.c:258
static void jit_unregister_code(struct objfile *objfile)
Definition: jit.c:972
#define BLOCKVECTOR_MAP(blocklist)
Definition: block.h:137
struct gdb_block * parent
Definition: jit.c:440
#define TYPE_LENGTH(thistype)
Definition: gdbtypes.h:1237
static int jit_reader_try_read_symtab(struct jit_code_entry *code_entry, CORE_ADDR entry_addr)
Definition: jit.c:813
struct objfile * objfile
Definition: minsyms.h:37
static const struct objfile_data * jit_objfile_data
Definition: jit.c:45
int unwinder_registered
Definition: jit.c:1291
struct block * allocate_global_block(struct obstack *obstack)
Definition: block.c:411
struct type * arch_type(struct gdbarch *gdbarch, enum type_code code, int length, char *name)
Definition: gdbtypes.c:4532
struct cleanup * make_cleanup_free_section_addr_info(struct section_addr_info *addrs)
Definition: utils.c:269
void terminate_minimal_symbol_table(struct objfile *objfile)
Definition: minsyms.c:1343
int line
Definition: symtab.h:864
struct gdb_symtab * symtabs
Definition: jit.c:478
CORE_ADDR first_entry
Definition: jit.h:64
struct bound_minimal_symbol lookup_minimal_symbol(const char *name, const char *sfile, struct objfile *objf)
Definition: minsyms.c:163
static struct gdb_object * jit_object_open_impl(struct gdb_symbol_callbacks *cb)
Definition: jit.c:504
static const char * jit_reader_dir
Definition: jit.c:43
CORE_ADDR addr
Definition: jit.c:277
struct breakpoint * owner
Definition: breakpoint.h:324
#define SYMTAB_LINETABLE(symtab)
Definition: symtab.h:966
void delete_breakpoint(struct breakpoint *bpt)
Definition: breakpoint.c:13539
void error(const char *fmt,...)
Definition: errors.c:38
size_t size
Definition: go32-nat.c:242
void jit_event_handler(struct gdbarch *gdbarch)
Definition: jit.c:1398
struct cmd_list_element * add_com(const char *name, enum command_class theclass, cmd_cfunc_ftype *fun, const char *doc)
Definition: cli-decode.c:873
struct gdbarch * get_frame_arch(struct frame_info *this_frame)
Definition: frame.c:2535
static int jit_breakpoint_re_set_internal(struct gdbarch *gdbarch, struct jit_program_space_data *ps_data)
Definition: jit.c:1023
void do_cleanups(struct cleanup *old_chain)
Definition: cleanups.c:175
#define MSYMBOL_VALUE_ADDRESS(objfile, symbol)
Definition: symtab.h:389
static struct block * new_block(enum block_type)
Definition: mdebugread.c:4833
struct type * lookup_function_type(struct type *type)
Definition: gdbtypes.c:482
struct section_addr_info * alloc_section_addr_info(size_t num_sections)
Definition: symfile.c:249
GDB_CORE_ADDR code_address
Definition: jit-reader.h:225
const ULONGEST const LONGEST len
Definition: target.h:309