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