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