start change to progspace independence
[external/binutils.git] / gdb / jit.c
1 /* Handle JIT code generation in the inferior for GDB, the GNU Debugger.
2
3    Copyright (C) 2009-2014 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 "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 program_space_data *jit_program_space_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
94   /* Zero means success.  */
95   return 0;
96 }
97
98 /* For reading the file, we just need to pass through to target_read_memory and
99    fix up the arguments and return values.  */
100
101 static file_ptr
102 mem_bfd_iovec_pread (struct bfd *abfd, void *stream, void *buf,
103                      file_ptr nbytes, file_ptr offset)
104 {
105   int err;
106   struct target_buffer *buffer = (struct target_buffer *) stream;
107
108   /* If this read will read all of the file, limit it to just the rest.  */
109   if (offset + nbytes > buffer->size)
110     nbytes = buffer->size - offset;
111
112   /* If there are no more bytes left, we've reached EOF.  */
113   if (nbytes == 0)
114     return 0;
115
116   err = target_read_memory (buffer->base + offset, (gdb_byte *) buf, nbytes);
117   if (err)
118     return -1;
119
120   return nbytes;
121 }
122
123 /* For statting the file, we only support the st_size attribute.  */
124
125 static int
126 mem_bfd_iovec_stat (struct bfd *abfd, void *stream, struct stat *sb)
127 {
128   struct target_buffer *buffer = (struct target_buffer*) stream;
129
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 *
137 bfd_open_from_target_memory (CORE_ADDR addr, ULONGEST size, char *target)
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,
144                               mem_bfd_iovec_open,
145                               buffer,
146                               mem_bfd_iovec_pread,
147                               mem_bfd_iovec_close,
148                               mem_bfd_iovec_stat);
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 {
156   struct gdb_reader_funcs *functions;
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 ();
189   if (funcs->reader_version != GDB_READER_INTERFACE_VERSION)
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
220   loaded_jit_reader = jit_reader_load (so_name);
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
232   loaded_jit_reader->functions->destroy (loaded_jit_reader->functions);
233
234   gdb_dlclose (loaded_jit_reader->handle);
235   xfree (loaded_jit_reader);
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
253   CORE_ADDR cached_code_address;
254
255   /* This is the JIT event breakpoint, or NULL if it has not been
256      set.  */
257
258   struct breakpoint *jit_breakpoint;
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.  */
270   struct minimal_symbol *register_code;
271
272   /* Symbol for __jit_debug_descriptor.  */
273   struct minimal_symbol *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.  */
277   CORE_ADDR addr;
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 *
284 get_jit_objfile_data (struct objfile *objf)
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
302 add_objfile_entry (struct objfile *objfile, CORE_ADDR entry)
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 *
314 get_jit_program_space_data (void)
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
330 jit_program_space_data_cleanup (struct program_space *ps, void *arg)
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
339 jit_read_descriptor (struct gdbarch *gdbarch,
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)
358     fprintf_unfiltered (gdb_stdlog,
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.  */
370   err = target_read_memory (MSYMBOL_VALUE_ADDRESS (ps_data->objfile,
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
394 jit_read_code_entry (struct gdbarch *gdbarch,
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.  */
448   CORE_ADDR begin, end;
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
457 struct gdb_symtab
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.  */
467   struct linetable *linetable;
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
476 struct gdb_object
477 {
478   struct gdb_symtab *symtabs;
479 };
480
481 /* The type of the `private' data passed around by the callback
482    functions.  */
483
484 typedef CORE_ADDR jit_dbg_reader_data;
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 *
504 jit_object_open_impl (struct gdb_symbol_callbacks *cb)
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 *
516 jit_symtab_open_impl (struct gdb_symbol_callbacks *cb,
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 new)
537 {
538   if (old == NULL)
539     return 1;
540   if (old->begin < new->begin)
541     return 1;
542   else if (old->begin == new->begin)
543     {
544       if (old->end > new->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 *
558 jit_block_open_impl (struct gdb_symbol_callbacks *cb,
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
601 jit_symtab_line_mapping_add_impl (struct gdb_symbol_callbacks *cb,
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
624 jit_symtab_close_impl (struct gdb_symbol_callbacks *cb,
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 symtab *symtab;
638   struct gdb_block *gdb_block_iter, *gdb_block_iter_tmp;
639   struct block *block_iter;
640   int actual_nblocks, i, blockvector_size;
641   CORE_ADDR begin, end;
642
643   actual_nblocks = FIRST_LOCAL_BLOCK + stab->nblocks;
644
645   symtab = allocate_symtab (stab->file_name, objfile);
646   /* JIT compilers compile in memory.  */
647   symtab->dirname = NULL;
648
649   /* Copy over the linetable entry if one was provided.  */
650   if (stab->linetable)
651     {
652       int size = ((stab->linetable->nitems - 1)
653                   * sizeof (struct linetable_entry)
654                   + sizeof (struct linetable));
655       LINETABLE (symtab) = obstack_alloc (&objfile->objfile_obstack, size);
656       memcpy (LINETABLE (symtab), stab->linetable, size);
657     }
658   else
659     {
660       LINETABLE (symtab) = NULL;
661     }
662
663   blockvector_size = (sizeof (struct blockvector)
664                       + (actual_nblocks - 1) * sizeof (struct block *));
665   symtab->blockvector = obstack_alloc (&objfile->objfile_obstack,
666                                        blockvector_size);
667
668   /* (begin, end) will contain the PC range this entire blockvector
669      spans.  */
670   set_symtab_primary (symtab, 1);
671   BLOCKVECTOR_MAP (symtab->blockvector) = NULL;
672   begin = stab->blocks->begin;
673   end = stab->blocks->end;
674   BLOCKVECTOR_NBLOCKS (symtab->blockvector) = actual_nblocks;
675
676   /* First run over all the gdb_block objects, creating a real block
677      object for each.  Simultaneously, keep setting the real_block
678      fields.  */
679   for (i = (actual_nblocks - 1), gdb_block_iter = stab->blocks;
680        i >= FIRST_LOCAL_BLOCK;
681        i--, gdb_block_iter = gdb_block_iter->next)
682     {
683       struct block *new_block = allocate_block (&objfile->objfile_obstack);
684       struct symbol *block_name = allocate_symbol (objfile);
685       struct type *block_type = arch_type (get_objfile_arch (objfile),
686                                            TYPE_CODE_VOID,
687                                            1,
688                                            "void");
689
690       BLOCK_DICT (new_block) = dict_create_linear (&objfile->objfile_obstack,
691                                                    NULL);
692       /* The address range.  */
693       BLOCK_START (new_block) = (CORE_ADDR) gdb_block_iter->begin;
694       BLOCK_END (new_block) = (CORE_ADDR) gdb_block_iter->end;
695
696       /* The name.  */
697       SYMBOL_DOMAIN (block_name) = VAR_DOMAIN;
698       SYMBOL_ACLASS_INDEX (block_name) = LOC_BLOCK;
699       SYMBOL_SYMTAB (block_name) = symtab;
700       SYMBOL_TYPE (block_name) = lookup_function_type (block_type);
701       SYMBOL_BLOCK_VALUE (block_name) = new_block;
702
703       block_name->ginfo.name = obstack_copy0 (&objfile->objfile_obstack,
704                                               gdb_block_iter->name,
705                                               strlen (gdb_block_iter->name));
706
707       BLOCK_FUNCTION (new_block) = block_name;
708
709       BLOCKVECTOR_BLOCK (symtab->blockvector, i) = new_block;
710       if (begin > BLOCK_START (new_block))
711         begin = BLOCK_START (new_block);
712       if (end < BLOCK_END (new_block))
713         end = BLOCK_END (new_block);
714
715       gdb_block_iter->real_block = new_block;
716     }
717
718   /* Now add the special blocks.  */
719   block_iter = NULL;
720   for (i = 0; i < FIRST_LOCAL_BLOCK; i++)
721     {
722       struct block *new_block;
723
724       new_block = (i == GLOBAL_BLOCK
725                    ? allocate_global_block (&objfile->objfile_obstack)
726                    : allocate_block (&objfile->objfile_obstack));
727       BLOCK_DICT (new_block) = dict_create_linear (&objfile->objfile_obstack,
728                                                    NULL);
729       BLOCK_SUPERBLOCK (new_block) = block_iter;
730       block_iter = new_block;
731
732       BLOCK_START (new_block) = (CORE_ADDR) begin;
733       BLOCK_END (new_block) = (CORE_ADDR) end;
734
735       BLOCKVECTOR_BLOCK (symtab->blockvector, i) = new_block;
736
737       if (i == GLOBAL_BLOCK)
738         set_block_symtab (new_block, symtab);
739     }
740
741   /* Fill up the superblock fields for the real blocks, using the
742      real_block fields populated earlier.  */
743   for (gdb_block_iter = stab->blocks;
744        gdb_block_iter;
745        gdb_block_iter = gdb_block_iter->next)
746     {
747       if (gdb_block_iter->parent != NULL)
748         {
749           /* If the plugin specifically mentioned a parent block, we
750              use that.  */
751           BLOCK_SUPERBLOCK (gdb_block_iter->real_block) =
752             gdb_block_iter->parent->real_block;
753         }
754       else
755         {
756           /* And if not, we set a default parent block.  */
757           BLOCK_SUPERBLOCK (gdb_block_iter->real_block) =
758             BLOCKVECTOR_BLOCK (symtab->blockvector, STATIC_BLOCK);
759         }
760     }
761
762   /* Free memory.  */
763   gdb_block_iter = stab->blocks;
764
765   for (gdb_block_iter = stab->blocks, gdb_block_iter_tmp = gdb_block_iter->next;
766        gdb_block_iter;
767        gdb_block_iter = gdb_block_iter_tmp)
768     {
769       xfree ((void *) gdb_block_iter->name);
770       xfree (gdb_block_iter);
771     }
772   xfree (stab->linetable);
773   xfree ((char *) stab->file_name);
774   xfree (stab);
775 }
776
777 /* Called when closing a gdb_objfile.  Converts OBJ to a proper
778    objfile.  */
779
780 static void
781 jit_object_close_impl (struct gdb_symbol_callbacks *cb,
782                        struct gdb_object *obj)
783 {
784   struct gdb_symtab *i, *j;
785   struct objfile *objfile;
786   jit_dbg_reader_data *priv_data;
787
788   priv_data = cb->priv_data;
789
790   objfile = allocate_objfile (NULL, "<< JIT compiled code >>",
791                               OBJF_NOT_FILENAME);
792   objfile->per_bfd->gdbarch = target_gdbarch ();
793
794   terminate_minimal_symbol_table (objfile);
795
796   j = NULL;
797   for (i = obj->symtabs; i; i = j)
798     {
799       j = i->next;
800       finalize_symtab (i, objfile);
801     }
802   add_objfile_entry (objfile, *priv_data);
803   xfree (obj);
804 }
805
806 /* Try to read CODE_ENTRY using the loaded jit reader (if any).
807    ENTRY_ADDR is the address of the struct jit_code_entry in the
808    inferior address space.  */
809
810 static int
811 jit_reader_try_read_symtab (struct jit_code_entry *code_entry,
812                             CORE_ADDR entry_addr)
813 {
814   void *gdb_mem;
815   int status;
816   jit_dbg_reader_data priv_data;
817   struct gdb_reader_funcs *funcs;
818   volatile struct gdb_exception e;
819   struct gdb_symbol_callbacks callbacks =
820     {
821       jit_object_open_impl,
822       jit_symtab_open_impl,
823       jit_block_open_impl,
824       jit_symtab_close_impl,
825       jit_object_close_impl,
826
827       jit_symtab_line_mapping_add_impl,
828       jit_target_read_impl,
829
830       &priv_data
831     };
832
833   priv_data = entry_addr;
834
835   if (!loaded_jit_reader)
836     return 0;
837
838   gdb_mem = xmalloc (code_entry->symfile_size);
839
840   status = 1;
841   TRY_CATCH (e, RETURN_MASK_ALL)
842     if (target_read_memory (code_entry->symfile_addr, gdb_mem,
843                             code_entry->symfile_size))
844       status = 0;
845   if (e.reason < 0)
846     status = 0;
847
848   if (status)
849     {
850       funcs = loaded_jit_reader->functions;
851       if (funcs->read (funcs, &callbacks, gdb_mem, code_entry->symfile_size)
852           != GDB_SUCCESS)
853         status = 0;
854     }
855
856   xfree (gdb_mem);
857   if (jit_debug && status == 0)
858     fprintf_unfiltered (gdb_stdlog,
859                         "Could not read symtab using the loaded JIT reader.\n");
860   return status;
861 }
862
863 /* Try to read CODE_ENTRY using BFD.  ENTRY_ADDR is the address of the
864    struct jit_code_entry in the inferior address space.  */
865
866 static void
867 jit_bfd_try_read_symtab (struct jit_code_entry *code_entry,
868                          CORE_ADDR entry_addr,
869                          struct gdbarch *gdbarch)
870 {
871   bfd *nbfd;
872   struct section_addr_info *sai;
873   struct bfd_section *sec;
874   struct objfile *objfile;
875   struct cleanup *old_cleanups;
876   int i;
877   const struct bfd_arch_info *b;
878
879   if (jit_debug)
880     fprintf_unfiltered (gdb_stdlog,
881                         "jit_register_code, symfile_addr = %s, "
882                         "symfile_size = %s\n",
883                         paddress (gdbarch, code_entry->symfile_addr),
884                         pulongest (code_entry->symfile_size));
885
886   nbfd = bfd_open_from_target_memory (code_entry->symfile_addr,
887                                       code_entry->symfile_size, gnutarget);
888   if (nbfd == NULL)
889     {
890       puts_unfiltered (_("Error opening JITed symbol file, ignoring it.\n"));
891       return;
892     }
893
894   /* Check the format.  NOTE: This initializes important data that GDB uses!
895      We would segfault later without this line.  */
896   if (!bfd_check_format (nbfd, bfd_object))
897     {
898       printf_unfiltered (_("\
899 JITed symbol file is not an object file, ignoring it.\n"));
900       gdb_bfd_unref (nbfd);
901       return;
902     }
903
904   /* Check bfd arch.  */
905   b = gdbarch_bfd_arch_info (gdbarch);
906   if (b->compatible (b, bfd_get_arch_info (nbfd)) != b)
907     warning (_("JITed object file architecture %s is not compatible "
908                "with target architecture %s."), bfd_get_arch_info
909              (nbfd)->printable_name, b->printable_name);
910
911   /* Read the section address information out of the symbol file.  Since the
912      file is generated by the JIT at runtime, it should all of the absolute
913      addresses that we care about.  */
914   sai = alloc_section_addr_info (bfd_count_sections (nbfd));
915   old_cleanups = make_cleanup_free_section_addr_info (sai);
916   i = 0;
917   for (sec = nbfd->sections; sec != NULL; sec = sec->next)
918     if ((bfd_get_section_flags (nbfd, sec) & (SEC_ALLOC|SEC_LOAD)) != 0)
919       {
920         /* We assume that these virtual addresses are absolute, and do not
921            treat them as offsets.  */
922         sai->other[i].addr = bfd_get_section_vma (nbfd, sec);
923         sai->other[i].name = xstrdup (bfd_get_section_name (nbfd, sec));
924         sai->other[i].sectindex = sec->index;
925         ++i;
926       }
927   sai->num_sections = i;
928
929   /* This call does not take ownership of SAI.  */
930   make_cleanup_bfd_unref (nbfd);
931   objfile = symbol_file_add_from_bfd (nbfd, bfd_get_filename (nbfd), 0, sai,
932                                       OBJF_SHARED | OBJF_NOT_FILENAME, NULL);
933
934   do_cleanups (old_cleanups);
935   add_objfile_entry (objfile, entry_addr);
936 }
937
938 /* This function registers code associated with a JIT code entry.  It uses the
939    pointer and size pair in the entry to read the symbol file from the remote
940    and then calls symbol_file_add_from_local_memory to add it as though it were
941    a symbol file added by the user.  */
942
943 static void
944 jit_register_code (struct gdbarch *gdbarch,
945                    CORE_ADDR entry_addr, struct jit_code_entry *code_entry)
946 {
947   int success;
948
949   if (jit_debug)
950     fprintf_unfiltered (gdb_stdlog,
951                         "jit_register_code, symfile_addr = %s, "
952                         "symfile_size = %s\n",
953                         paddress (gdbarch, code_entry->symfile_addr),
954                         pulongest (code_entry->symfile_size));
955
956   success = jit_reader_try_read_symtab (code_entry, entry_addr);
957
958   if (!success)
959     jit_bfd_try_read_symtab (code_entry, entry_addr, gdbarch);
960 }
961
962 /* This function unregisters JITed code and frees the corresponding
963    objfile.  */
964
965 static void
966 jit_unregister_code (struct objfile *objfile)
967 {
968   free_objfile (objfile);
969 }
970
971 /* Look up the objfile with this code entry address.  */
972
973 static struct objfile *
974 jit_find_objf_with_entry_addr (CORE_ADDR entry_addr)
975 {
976   struct objfile *objf;
977
978   ALL_OBJFILES (objf)
979     {
980       struct jit_objfile_data *objf_data;
981
982       objf_data = objfile_data (objf, jit_objfile_data);
983       if (objf_data != NULL && objf_data->addr == entry_addr)
984         return objf;
985     }
986   return NULL;
987 }
988
989 /* This is called when a breakpoint is deleted.  It updates the
990    inferior's cache, if needed.  */
991
992 static void
993 jit_breakpoint_deleted (struct breakpoint *b)
994 {
995   struct bp_location *iter;
996
997   if (b->type != bp_jit_event)
998     return;
999
1000   for (iter = b->loc; iter != NULL; iter = iter->next)
1001     {
1002       struct jit_program_space_data *ps_data;
1003
1004       ps_data = program_space_data (iter->pspace, jit_program_space_data);
1005       if (ps_data != NULL && ps_data->jit_breakpoint == iter->owner)
1006         {
1007           ps_data->cached_code_address = 0;
1008           ps_data->jit_breakpoint = NULL;
1009         }
1010     }
1011 }
1012
1013 /* (Re-)Initialize the jit breakpoint if necessary.
1014    Return 0 on success.  */
1015
1016 static int
1017 jit_breakpoint_re_set_internal (struct gdbarch *gdbarch,
1018                                 struct jit_program_space_data *ps_data)
1019 {
1020   struct bound_minimal_symbol reg_symbol;
1021   struct bound_minimal_symbol desc_symbol;
1022   struct jit_objfile_data *objf_data;
1023   CORE_ADDR addr;
1024
1025   if (ps_data->objfile == NULL)
1026     {
1027       /* Lookup the registration symbol.  If it is missing, then we
1028          assume we are not attached to a JIT.  */
1029       reg_symbol = lookup_minimal_symbol_and_objfile (jit_break_name);
1030       if (reg_symbol.minsym == NULL
1031           || BMSYMBOL_VALUE_ADDRESS (reg_symbol) == 0)
1032         return 1;
1033
1034       desc_symbol = lookup_minimal_symbol (jit_descriptor_name, NULL,
1035                                            reg_symbol.objfile);
1036       if (desc_symbol.minsym == NULL
1037           || BMSYMBOL_VALUE_ADDRESS (desc_symbol) == 0)
1038         return 1;
1039
1040       objf_data = get_jit_objfile_data (reg_symbol.objfile);
1041       objf_data->register_code = reg_symbol.minsym;
1042       objf_data->descriptor = desc_symbol.minsym;
1043
1044       ps_data->objfile = reg_symbol.objfile;
1045     }
1046   else
1047     objf_data = get_jit_objfile_data (ps_data->objfile);
1048
1049   addr = MSYMBOL_VALUE_ADDRESS (ps_data->objfile, objf_data->register_code);
1050
1051   if (jit_debug)
1052     fprintf_unfiltered (gdb_stdlog,
1053                         "jit_breakpoint_re_set_internal, "
1054                         "breakpoint_addr = %s\n",
1055                         paddress (gdbarch, addr));
1056
1057   if (ps_data->cached_code_address == addr)
1058     return 1;
1059
1060   /* Delete the old breakpoint.  */
1061   if (ps_data->jit_breakpoint != NULL)
1062     delete_breakpoint (ps_data->jit_breakpoint);
1063
1064   /* Put a breakpoint in the registration symbol.  */
1065   ps_data->cached_code_address = addr;
1066   ps_data->jit_breakpoint = create_jit_event_breakpoint (gdbarch, addr);
1067
1068   return 0;
1069 }
1070
1071 /* The private data passed around in the frame unwind callback
1072    functions.  */
1073
1074 struct jit_unwind_private
1075 {
1076   /* Cached register values.  See jit_frame_sniffer to see how this
1077      works.  */
1078   struct gdb_reg_value **registers;
1079
1080   /* The frame being unwound.  */
1081   struct frame_info *this_frame;
1082 };
1083
1084 /* Sets the value of a particular register in this frame.  */
1085
1086 static void
1087 jit_unwind_reg_set_impl (struct gdb_unwind_callbacks *cb, int dwarf_regnum,
1088                          struct gdb_reg_value *value)
1089 {
1090   struct jit_unwind_private *priv;
1091   int gdb_reg;
1092
1093   priv = cb->priv_data;
1094
1095   gdb_reg = gdbarch_dwarf2_reg_to_regnum (get_frame_arch (priv->this_frame),
1096                                           dwarf_regnum);
1097   if (gdb_reg == -1)
1098     {
1099       if (jit_debug)
1100         fprintf_unfiltered (gdb_stdlog,
1101                             _("Could not recognize DWARF regnum %d"),
1102                             dwarf_regnum);
1103       return;
1104     }
1105
1106   gdb_assert (priv->registers);
1107   priv->registers[gdb_reg] = value;
1108 }
1109
1110 static void
1111 reg_value_free_impl (struct gdb_reg_value *value)
1112 {
1113   xfree (value);
1114 }
1115
1116 /* Get the value of register REGNUM in the previous frame.  */
1117
1118 static struct gdb_reg_value *
1119 jit_unwind_reg_get_impl (struct gdb_unwind_callbacks *cb, int regnum)
1120 {
1121   struct jit_unwind_private *priv;
1122   struct gdb_reg_value *value;
1123   int gdb_reg, size;
1124   struct gdbarch *frame_arch;
1125
1126   priv = cb->priv_data;
1127   frame_arch = get_frame_arch (priv->this_frame);
1128
1129   gdb_reg = gdbarch_dwarf2_reg_to_regnum (frame_arch, regnum);
1130   size = register_size (frame_arch, gdb_reg);
1131   value = xmalloc (sizeof (struct gdb_reg_value) + size - 1);
1132   value->defined = deprecated_frame_register_read (priv->this_frame, gdb_reg,
1133                                                    value->value);
1134   value->size = size;
1135   value->free = reg_value_free_impl;
1136   return value;
1137 }
1138
1139 /* gdb_reg_value has a free function, which must be called on each
1140    saved register value.  */
1141
1142 static void
1143 jit_dealloc_cache (struct frame_info *this_frame, void *cache)
1144 {
1145   struct jit_unwind_private *priv_data = cache;
1146   struct gdbarch *frame_arch;
1147   int i;
1148
1149   gdb_assert (priv_data->registers);
1150   frame_arch = get_frame_arch (priv_data->this_frame);
1151
1152   for (i = 0; i < gdbarch_num_regs (frame_arch); i++)
1153     if (priv_data->registers[i] && priv_data->registers[i]->free)
1154       priv_data->registers[i]->free (priv_data->registers[i]);
1155
1156   xfree (priv_data->registers);
1157   xfree (priv_data);
1158 }
1159
1160 /* The frame sniffer for the pseudo unwinder.
1161
1162    While this is nominally a frame sniffer, in the case where the JIT
1163    reader actually recognizes the frame, it does a lot more work -- it
1164    unwinds the frame and saves the corresponding register values in
1165    the cache.  jit_frame_prev_register simply returns the saved
1166    register values.  */
1167
1168 static int
1169 jit_frame_sniffer (const struct frame_unwind *self,
1170                    struct frame_info *this_frame, void **cache)
1171 {
1172   struct jit_unwind_private *priv_data;
1173   struct gdb_unwind_callbacks callbacks;
1174   struct gdb_reader_funcs *funcs;
1175
1176   callbacks.reg_get = jit_unwind_reg_get_impl;
1177   callbacks.reg_set = jit_unwind_reg_set_impl;
1178   callbacks.target_read = jit_target_read_impl;
1179
1180   if (loaded_jit_reader == NULL)
1181     return 0;
1182
1183   funcs = loaded_jit_reader->functions;
1184
1185   gdb_assert (!*cache);
1186
1187   *cache = XCNEW (struct jit_unwind_private);
1188   priv_data = *cache;
1189   priv_data->registers =
1190     XCNEWVEC (struct gdb_reg_value *,         
1191               gdbarch_num_regs (get_frame_arch (this_frame)));
1192   priv_data->this_frame = this_frame;
1193
1194   callbacks.priv_data = priv_data;
1195
1196   /* Try to coax the provided unwinder to unwind the stack */
1197   if (funcs->unwind (funcs, &callbacks) == GDB_SUCCESS)
1198     {
1199       if (jit_debug)
1200         fprintf_unfiltered (gdb_stdlog, _("Successfully unwound frame using "
1201                                           "JIT reader.\n"));
1202       return 1;
1203     }
1204   if (jit_debug)
1205     fprintf_unfiltered (gdb_stdlog, _("Could not unwind frame using "
1206                                       "JIT reader.\n"));
1207
1208   jit_dealloc_cache (this_frame, *cache);
1209   *cache = NULL;
1210
1211   return 0;
1212 }
1213
1214
1215 /* The frame_id function for the pseudo unwinder.  Relays the call to
1216    the loaded plugin.  */
1217
1218 static void
1219 jit_frame_this_id (struct frame_info *this_frame, void **cache,
1220                    struct frame_id *this_id)
1221 {
1222   struct jit_unwind_private private;
1223   struct gdb_frame_id frame_id;
1224   struct gdb_reader_funcs *funcs;
1225   struct gdb_unwind_callbacks callbacks;
1226
1227   private.registers = NULL;
1228   private.this_frame = this_frame;
1229
1230   /* We don't expect the frame_id function to set any registers, so we
1231      set reg_set to NULL.  */
1232   callbacks.reg_get = jit_unwind_reg_get_impl;
1233   callbacks.reg_set = NULL;
1234   callbacks.target_read = jit_target_read_impl;
1235   callbacks.priv_data = &private;
1236
1237   gdb_assert (loaded_jit_reader);
1238   funcs = loaded_jit_reader->functions;
1239
1240   frame_id = funcs->get_frame_id (funcs, &callbacks);
1241   *this_id = frame_id_build (frame_id.stack_address, frame_id.code_address);
1242 }
1243
1244 /* Pseudo unwinder function.  Reads the previously fetched value for
1245    the register from the cache.  */
1246
1247 static struct value *
1248 jit_frame_prev_register (struct frame_info *this_frame, void **cache, int reg)
1249 {
1250   struct jit_unwind_private *priv = *cache;
1251   struct gdb_reg_value *value;
1252
1253   if (priv == NULL)
1254     return frame_unwind_got_optimized (this_frame, reg);
1255
1256   gdb_assert (priv->registers);
1257   value = priv->registers[reg];
1258   if (value && value->defined)
1259     return frame_unwind_got_bytes (this_frame, reg, value->value);
1260   else
1261     return frame_unwind_got_optimized (this_frame, reg);
1262 }
1263
1264 /* Relay everything back to the unwinder registered by the JIT debug
1265    info reader.*/
1266
1267 static const struct frame_unwind jit_frame_unwind =
1268 {
1269   NORMAL_FRAME,
1270   default_frame_unwind_stop_reason,
1271   jit_frame_this_id,
1272   jit_frame_prev_register,
1273   NULL,
1274   jit_frame_sniffer,
1275   jit_dealloc_cache
1276 };
1277
1278
1279 /* This is the information that is stored at jit_gdbarch_data for each
1280    architecture.  */
1281
1282 struct jit_gdbarch_data_type
1283 {
1284   /* Has the (pseudo) unwinder been prepended? */
1285   int unwinder_registered;
1286 };
1287
1288 /* Check GDBARCH and prepend the pseudo JIT unwinder if needed.  */
1289
1290 static void
1291 jit_prepend_unwinder (struct gdbarch *gdbarch)
1292 {
1293   struct jit_gdbarch_data_type *data;
1294
1295   data = gdbarch_data (gdbarch, jit_gdbarch_data);
1296   if (!data->unwinder_registered)
1297     {
1298       frame_unwind_prepend_unwinder (gdbarch, &jit_frame_unwind);
1299       data->unwinder_registered = 1;
1300     }
1301 }
1302
1303 /* Register any already created translations.  */
1304
1305 static void
1306 jit_inferior_init (struct gdbarch *gdbarch)
1307 {
1308   struct jit_descriptor descriptor;
1309   struct jit_code_entry cur_entry;
1310   struct jit_program_space_data *ps_data;
1311   CORE_ADDR cur_entry_addr;
1312
1313   if (jit_debug)
1314     fprintf_unfiltered (gdb_stdlog, "jit_inferior_init\n");
1315
1316   jit_prepend_unwinder (gdbarch);
1317
1318   ps_data = get_jit_program_space_data ();
1319   if (jit_breakpoint_re_set_internal (gdbarch, ps_data) != 0)
1320     return;
1321
1322   /* Read the descriptor so we can check the version number and load
1323      any already JITed functions.  */
1324   if (!jit_read_descriptor (gdbarch, &descriptor, ps_data))
1325     return;
1326
1327   /* Check that the version number agrees with that we support.  */
1328   if (descriptor.version != 1)
1329     {
1330       printf_unfiltered (_("Unsupported JIT protocol version %ld "
1331                            "in descriptor (expected 1)\n"),
1332                          (long) descriptor.version);
1333       return;
1334     }
1335
1336   /* If we've attached to a running program, we need to check the descriptor
1337      to register any functions that were already generated.  */
1338   for (cur_entry_addr = descriptor.first_entry;
1339        cur_entry_addr != 0;
1340        cur_entry_addr = cur_entry.next_entry)
1341     {
1342       jit_read_code_entry (gdbarch, cur_entry_addr, &cur_entry);
1343
1344       /* This hook may be called many times during setup, so make sure we don't
1345          add the same symbol file twice.  */
1346       if (jit_find_objf_with_entry_addr (cur_entry_addr) != NULL)
1347         continue;
1348
1349       jit_register_code (gdbarch, cur_entry_addr, &cur_entry);
1350     }
1351 }
1352
1353 /* Exported routine to call when an inferior has been created.  */
1354
1355 void
1356 jit_inferior_created_hook (void)
1357 {
1358   jit_inferior_init (target_gdbarch ());
1359 }
1360
1361 /* Exported routine to call to re-set the jit breakpoints,
1362    e.g. when a program is rerun.  */
1363
1364 void
1365 jit_breakpoint_re_set (void)
1366 {
1367   jit_breakpoint_re_set_internal (target_gdbarch (),
1368                                   get_jit_program_space_data ());
1369 }
1370
1371 /* This function cleans up any code entries left over when the
1372    inferior exits.  We get left over code when the inferior exits
1373    without unregistering its code, for example when it crashes.  */
1374
1375 static void
1376 jit_inferior_exit_hook (struct inferior *inf)
1377 {
1378   struct objfile *objf;
1379   struct objfile *temp;
1380
1381   ALL_OBJFILES_SAFE (objf, temp)
1382     {
1383       struct jit_objfile_data *objf_data = objfile_data (objf,
1384                                                          jit_objfile_data);
1385
1386       if (objf_data != NULL && objf_data->addr != 0)
1387         jit_unregister_code (objf);
1388     }
1389 }
1390
1391 void
1392 jit_event_handler (struct gdbarch *gdbarch)
1393 {
1394   struct jit_descriptor descriptor;
1395   struct jit_code_entry code_entry;
1396   CORE_ADDR entry_addr;
1397   struct objfile *objf;
1398
1399   /* Read the descriptor from remote memory.  */
1400   if (!jit_read_descriptor (gdbarch, &descriptor,
1401                             get_jit_program_space_data ()))
1402     return;
1403   entry_addr = descriptor.relevant_entry;
1404
1405   /* Do the corresponding action.  */
1406   switch (descriptor.action_flag)
1407     {
1408     case JIT_NOACTION:
1409       break;
1410     case JIT_REGISTER:
1411       jit_read_code_entry (gdbarch, entry_addr, &code_entry);
1412       jit_register_code (gdbarch, entry_addr, &code_entry);
1413       break;
1414     case JIT_UNREGISTER:
1415       objf = jit_find_objf_with_entry_addr (entry_addr);
1416       if (objf == NULL)
1417         printf_unfiltered (_("Unable to find JITed code "
1418                              "entry at address: %s\n"),
1419                            paddress (gdbarch, entry_addr));
1420       else
1421         jit_unregister_code (objf);
1422
1423       break;
1424     default:
1425       error (_("Unknown action_flag value in JIT descriptor!"));
1426       break;
1427     }
1428 }
1429
1430 /* Called to free the data allocated to the jit_program_space_data slot.  */
1431
1432 static void
1433 free_objfile_data (struct objfile *objfile, void *data)
1434 {
1435   struct jit_objfile_data *objf_data = data;
1436
1437   if (objf_data->register_code != NULL)
1438     {
1439       struct jit_program_space_data *ps_data;
1440
1441       ps_data = program_space_data (objfile->pspace, jit_program_space_data);
1442       if (ps_data != NULL && ps_data->objfile == objfile)
1443         ps_data->objfile = NULL;
1444     }
1445
1446   xfree (data);
1447 }
1448
1449 /* Initialize the jit_gdbarch_data slot with an instance of struct
1450    jit_gdbarch_data_type */
1451
1452 static void *
1453 jit_gdbarch_data_init (struct obstack *obstack)
1454 {
1455   struct jit_gdbarch_data_type *data;
1456
1457   data = obstack_alloc (obstack, sizeof (struct jit_gdbarch_data_type));
1458   data->unwinder_registered = 0;
1459   return data;
1460 }
1461
1462 /* Provide a prototype to silence -Wmissing-prototypes.  */
1463
1464 extern void _initialize_jit (void);
1465
1466 void
1467 _initialize_jit (void)
1468 {
1469   jit_reader_dir = relocate_gdb_directory (JIT_READER_DIR,
1470                                            JIT_READER_DIR_RELOCATABLE);
1471   add_setshow_zuinteger_cmd ("jit", class_maintenance, &jit_debug,
1472                              _("Set JIT debugging."),
1473                              _("Show JIT debugging."),
1474                              _("When non-zero, JIT debugging is enabled."),
1475                              NULL,
1476                              show_jit_debug,
1477                              &setdebuglist, &showdebuglist);
1478
1479   observer_attach_inferior_exit (jit_inferior_exit_hook);
1480   observer_attach_breakpoint_deleted (jit_breakpoint_deleted);
1481
1482   jit_objfile_data =
1483     register_objfile_data_with_cleanup (NULL, free_objfile_data);
1484   jit_program_space_data =
1485     register_program_space_data_with_cleanup (NULL,
1486                                               jit_program_space_data_cleanup);
1487   jit_gdbarch_data = gdbarch_data_register_pre_init (jit_gdbarch_data_init);
1488   if (is_dl_available ())
1489     {
1490       add_com ("jit-reader-load", no_class, jit_reader_load_command, _("\
1491 Load FILE as debug info reader and unwinder for JIT compiled code.\n\
1492 Usage: jit-reader-load FILE\n\
1493 Try to load file FILE as a debug info reader (and unwinder) for\n\
1494 JIT compiled code.  The file is loaded from " JIT_READER_DIR ",\n\
1495 relocated relative to the GDB executable if required."));
1496       add_com ("jit-reader-unload", no_class, jit_reader_unload_command, _("\
1497 Unload the currently loaded JIT debug info reader.\n\
1498 Usage: jit-reader-unload FILE\n\n\
1499 Do \"help jit-reader-load\" for info on loading debug info readers."));
1500     }
1501 }