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