Automatic date update in version.in
[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 "observable.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 uint64_t value will be.  */
417   align_bytes = type_align (builtin_type (gdbarch)->builtin_uint64);
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 bfd_section *sec;
892   struct objfile *objfile;
893   const struct bfd_arch_info *b;
894
895   if (jit_debug)
896     fprintf_unfiltered (gdb_stdlog,
897                         "jit_register_code, symfile_addr = %s, "
898                         "symfile_size = %s\n",
899                         paddress (gdbarch, code_entry->symfile_addr),
900                         pulongest (code_entry->symfile_size));
901
902   gdb_bfd_ref_ptr nbfd (bfd_open_from_target_memory (code_entry->symfile_addr,
903                                                      code_entry->symfile_size,
904                                                      gnutarget));
905   if (nbfd == NULL)
906     {
907       puts_unfiltered (_("Error opening JITed symbol file, ignoring it.\n"));
908       return;
909     }
910
911   /* Check the format.  NOTE: This initializes important data that GDB uses!
912      We would segfault later without this line.  */
913   if (!bfd_check_format (nbfd.get (), bfd_object))
914     {
915       printf_unfiltered (_("\
916 JITed symbol file is not an object file, ignoring it.\n"));
917       return;
918     }
919
920   /* Check bfd arch.  */
921   b = gdbarch_bfd_arch_info (gdbarch);
922   if (b->compatible (b, bfd_get_arch_info (nbfd.get ())) != b)
923     warning (_("JITed object file architecture %s is not compatible "
924                "with target architecture %s."),
925              bfd_get_arch_info (nbfd.get ())->printable_name,
926              b->printable_name);
927
928   /* Read the section address information out of the symbol file.  Since the
929      file is generated by the JIT at runtime, it should all of the absolute
930      addresses that we care about.  */
931   section_addr_info sai;
932   for (sec = nbfd->sections; sec != NULL; sec = sec->next)
933     if ((bfd_get_section_flags (nbfd.get (), sec) & (SEC_ALLOC|SEC_LOAD)) != 0)
934       {
935         /* We assume that these virtual addresses are absolute, and do not
936            treat them as offsets.  */
937         sai.emplace_back (bfd_get_section_vma (nbfd.get (), sec),
938                           bfd_get_section_name (nbfd.get (), sec),
939                           sec->index);
940       }
941
942   /* This call does not take ownership of SAI.  */
943   objfile = symbol_file_add_from_bfd (nbfd.get (),
944                                       bfd_get_filename (nbfd.get ()), 0,
945                                       &sai,
946                                       OBJF_SHARED | OBJF_NOT_FILENAME, NULL);
947
948   add_objfile_entry (objfile, entry_addr);
949 }
950
951 /* This function registers code associated with a JIT code entry.  It uses the
952    pointer and size pair in the entry to read the symbol file from the remote
953    and then calls symbol_file_add_from_local_memory to add it as though it were
954    a symbol file added by the user.  */
955
956 static void
957 jit_register_code (struct gdbarch *gdbarch,
958                    CORE_ADDR entry_addr, struct jit_code_entry *code_entry)
959 {
960   int success;
961
962   if (jit_debug)
963     fprintf_unfiltered (gdb_stdlog,
964                         "jit_register_code, symfile_addr = %s, "
965                         "symfile_size = %s\n",
966                         paddress (gdbarch, code_entry->symfile_addr),
967                         pulongest (code_entry->symfile_size));
968
969   success = jit_reader_try_read_symtab (code_entry, entry_addr);
970
971   if (!success)
972     jit_bfd_try_read_symtab (code_entry, entry_addr, gdbarch);
973 }
974
975 /* This function unregisters JITed code and frees the corresponding
976    objfile.  */
977
978 static void
979 jit_unregister_code (struct objfile *objfile)
980 {
981   delete objfile;
982 }
983
984 /* Look up the objfile with this code entry address.  */
985
986 static struct objfile *
987 jit_find_objf_with_entry_addr (CORE_ADDR entry_addr)
988 {
989   struct objfile *objf;
990
991   ALL_OBJFILES (objf)
992     {
993       struct jit_objfile_data *objf_data;
994
995       objf_data
996         = (struct jit_objfile_data *) objfile_data (objf, jit_objfile_data);
997       if (objf_data != NULL && objf_data->addr == entry_addr)
998         return objf;
999     }
1000   return NULL;
1001 }
1002
1003 /* This is called when a breakpoint is deleted.  It updates the
1004    inferior's cache, if needed.  */
1005
1006 static void
1007 jit_breakpoint_deleted (struct breakpoint *b)
1008 {
1009   struct bp_location *iter;
1010
1011   if (b->type != bp_jit_event)
1012     return;
1013
1014   for (iter = b->loc; iter != NULL; iter = iter->next)
1015     {
1016       struct jit_program_space_data *ps_data;
1017
1018       ps_data = ((struct jit_program_space_data *)
1019                  program_space_data (iter->pspace, jit_program_space_data));
1020       if (ps_data != NULL && ps_data->jit_breakpoint == iter->owner)
1021         {
1022           ps_data->cached_code_address = 0;
1023           ps_data->jit_breakpoint = NULL;
1024         }
1025     }
1026 }
1027
1028 /* (Re-)Initialize the jit breakpoint if necessary.
1029    Return 0 if the jit breakpoint has been successfully initialized.  */
1030
1031 static int
1032 jit_breakpoint_re_set_internal (struct gdbarch *gdbarch,
1033                                 struct jit_program_space_data *ps_data)
1034 {
1035   struct bound_minimal_symbol reg_symbol;
1036   struct bound_minimal_symbol desc_symbol;
1037   struct jit_objfile_data *objf_data;
1038   CORE_ADDR addr;
1039
1040   if (ps_data->objfile == NULL)
1041     {
1042       /* Lookup the registration symbol.  If it is missing, then we
1043          assume we are not attached to a JIT.  */
1044       reg_symbol = lookup_bound_minimal_symbol (jit_break_name);
1045       if (reg_symbol.minsym == NULL
1046           || BMSYMBOL_VALUE_ADDRESS (reg_symbol) == 0)
1047         return 1;
1048
1049       desc_symbol = lookup_minimal_symbol (jit_descriptor_name, NULL,
1050                                            reg_symbol.objfile);
1051       if (desc_symbol.minsym == NULL
1052           || BMSYMBOL_VALUE_ADDRESS (desc_symbol) == 0)
1053         return 1;
1054
1055       objf_data = get_jit_objfile_data (reg_symbol.objfile);
1056       objf_data->register_code = reg_symbol.minsym;
1057       objf_data->descriptor = desc_symbol.minsym;
1058
1059       ps_data->objfile = reg_symbol.objfile;
1060     }
1061   else
1062     objf_data = get_jit_objfile_data (ps_data->objfile);
1063
1064   addr = MSYMBOL_VALUE_ADDRESS (ps_data->objfile, objf_data->register_code);
1065
1066   if (jit_debug)
1067     fprintf_unfiltered (gdb_stdlog,
1068                         "jit_breakpoint_re_set_internal, "
1069                         "breakpoint_addr = %s\n",
1070                         paddress (gdbarch, addr));
1071
1072   if (ps_data->cached_code_address == addr)
1073     return 0;
1074
1075   /* Delete the old breakpoint.  */
1076   if (ps_data->jit_breakpoint != NULL)
1077     delete_breakpoint (ps_data->jit_breakpoint);
1078
1079   /* Put a breakpoint in the registration symbol.  */
1080   ps_data->cached_code_address = addr;
1081   ps_data->jit_breakpoint = create_jit_event_breakpoint (gdbarch, addr);
1082
1083   return 0;
1084 }
1085
1086 /* The private data passed around in the frame unwind callback
1087    functions.  */
1088
1089 struct jit_unwind_private
1090 {
1091   /* Cached register values.  See jit_frame_sniffer to see how this
1092      works.  */
1093   detached_regcache *regcache;
1094
1095   /* The frame being unwound.  */
1096   struct frame_info *this_frame;
1097 };
1098
1099 /* Sets the value of a particular register in this frame.  */
1100
1101 static void
1102 jit_unwind_reg_set_impl (struct gdb_unwind_callbacks *cb, int dwarf_regnum,
1103                          struct gdb_reg_value *value)
1104 {
1105   struct jit_unwind_private *priv;
1106   int gdb_reg;
1107
1108   priv = (struct jit_unwind_private *) cb->priv_data;
1109
1110   gdb_reg = gdbarch_dwarf2_reg_to_regnum (get_frame_arch (priv->this_frame),
1111                                           dwarf_regnum);
1112   if (gdb_reg == -1)
1113     {
1114       if (jit_debug)
1115         fprintf_unfiltered (gdb_stdlog,
1116                             _("Could not recognize DWARF regnum %d"),
1117                             dwarf_regnum);
1118       value->free (value);
1119       return;
1120     }
1121
1122   priv->regcache->raw_supply (gdb_reg, value->value);
1123   value->free (value);
1124 }
1125
1126 static void
1127 reg_value_free_impl (struct gdb_reg_value *value)
1128 {
1129   xfree (value);
1130 }
1131
1132 /* Get the value of register REGNUM in the previous frame.  */
1133
1134 static struct gdb_reg_value *
1135 jit_unwind_reg_get_impl (struct gdb_unwind_callbacks *cb, int regnum)
1136 {
1137   struct jit_unwind_private *priv;
1138   struct gdb_reg_value *value;
1139   int gdb_reg, size;
1140   struct gdbarch *frame_arch;
1141
1142   priv = (struct jit_unwind_private *) cb->priv_data;
1143   frame_arch = get_frame_arch (priv->this_frame);
1144
1145   gdb_reg = gdbarch_dwarf2_reg_to_regnum (frame_arch, regnum);
1146   size = register_size (frame_arch, gdb_reg);
1147   value = ((struct gdb_reg_value *)
1148            xmalloc (sizeof (struct gdb_reg_value) + size - 1));
1149   value->defined = deprecated_frame_register_read (priv->this_frame, gdb_reg,
1150                                                    value->value);
1151   value->size = size;
1152   value->free = reg_value_free_impl;
1153   return value;
1154 }
1155
1156 /* gdb_reg_value has a free function, which must be called on each
1157    saved register value.  */
1158
1159 static void
1160 jit_dealloc_cache (struct frame_info *this_frame, void *cache)
1161 {
1162   struct jit_unwind_private *priv_data = (struct jit_unwind_private *) cache;
1163
1164   gdb_assert (priv_data->regcache != NULL);
1165   delete priv_data->regcache;
1166   xfree (priv_data);
1167 }
1168
1169 /* The frame sniffer for the pseudo unwinder.
1170
1171    While this is nominally a frame sniffer, in the case where the JIT
1172    reader actually recognizes the frame, it does a lot more work -- it
1173    unwinds the frame and saves the corresponding register values in
1174    the cache.  jit_frame_prev_register simply returns the saved
1175    register values.  */
1176
1177 static int
1178 jit_frame_sniffer (const struct frame_unwind *self,
1179                    struct frame_info *this_frame, void **cache)
1180 {
1181   struct jit_unwind_private *priv_data;
1182   struct gdb_unwind_callbacks callbacks;
1183   struct gdb_reader_funcs *funcs;
1184
1185   callbacks.reg_get = jit_unwind_reg_get_impl;
1186   callbacks.reg_set = jit_unwind_reg_set_impl;
1187   callbacks.target_read = jit_target_read_impl;
1188
1189   if (loaded_jit_reader == NULL)
1190     return 0;
1191
1192   funcs = loaded_jit_reader->functions;
1193
1194   gdb_assert (!*cache);
1195
1196   *cache = XCNEW (struct jit_unwind_private);
1197   priv_data = (struct jit_unwind_private *) *cache;
1198   /* Take a snapshot of current regcache.  */
1199   priv_data->regcache = new detached_regcache (get_frame_arch (this_frame),
1200                                                true);
1201   priv_data->this_frame = this_frame;
1202
1203   callbacks.priv_data = priv_data;
1204
1205   /* Try to coax the provided unwinder to unwind the stack */
1206   if (funcs->unwind (funcs, &callbacks) == GDB_SUCCESS)
1207     {
1208       if (jit_debug)
1209         fprintf_unfiltered (gdb_stdlog, _("Successfully unwound frame using "
1210                                           "JIT reader.\n"));
1211       return 1;
1212     }
1213   if (jit_debug)
1214     fprintf_unfiltered (gdb_stdlog, _("Could not unwind frame using "
1215                                       "JIT reader.\n"));
1216
1217   jit_dealloc_cache (this_frame, *cache);
1218   *cache = NULL;
1219
1220   return 0;
1221 }
1222
1223
1224 /* The frame_id function for the pseudo unwinder.  Relays the call to
1225    the loaded plugin.  */
1226
1227 static void
1228 jit_frame_this_id (struct frame_info *this_frame, void **cache,
1229                    struct frame_id *this_id)
1230 {
1231   struct jit_unwind_private priv;
1232   struct gdb_frame_id frame_id;
1233   struct gdb_reader_funcs *funcs;
1234   struct gdb_unwind_callbacks callbacks;
1235
1236   priv.regcache = NULL;
1237   priv.this_frame = this_frame;
1238
1239   /* We don't expect the frame_id function to set any registers, so we
1240      set reg_set to NULL.  */
1241   callbacks.reg_get = jit_unwind_reg_get_impl;
1242   callbacks.reg_set = NULL;
1243   callbacks.target_read = jit_target_read_impl;
1244   callbacks.priv_data = &priv;
1245
1246   gdb_assert (loaded_jit_reader);
1247   funcs = loaded_jit_reader->functions;
1248
1249   frame_id = funcs->get_frame_id (funcs, &callbacks);
1250   *this_id = frame_id_build (frame_id.stack_address, frame_id.code_address);
1251 }
1252
1253 /* Pseudo unwinder function.  Reads the previously fetched value for
1254    the register from the cache.  */
1255
1256 static struct value *
1257 jit_frame_prev_register (struct frame_info *this_frame, void **cache, int reg)
1258 {
1259   struct jit_unwind_private *priv = (struct jit_unwind_private *) *cache;
1260   struct gdbarch *gdbarch;
1261
1262   if (priv == NULL)
1263     return frame_unwind_got_optimized (this_frame, reg);
1264
1265   gdbarch = priv->regcache->arch ();
1266   gdb_byte *buf = (gdb_byte *) alloca (register_size (gdbarch, reg));
1267   enum register_status status = priv->regcache->cooked_read (reg, buf);
1268
1269   if (status == REG_VALID)
1270     return frame_unwind_got_bytes (this_frame, reg, buf);
1271   else
1272     return frame_unwind_got_optimized (this_frame, reg);
1273 }
1274
1275 /* Relay everything back to the unwinder registered by the JIT debug
1276    info reader.*/
1277
1278 static const struct frame_unwind jit_frame_unwind =
1279 {
1280   NORMAL_FRAME,
1281   default_frame_unwind_stop_reason,
1282   jit_frame_this_id,
1283   jit_frame_prev_register,
1284   NULL,
1285   jit_frame_sniffer,
1286   jit_dealloc_cache
1287 };
1288
1289
1290 /* This is the information that is stored at jit_gdbarch_data for each
1291    architecture.  */
1292
1293 struct jit_gdbarch_data_type
1294 {
1295   /* Has the (pseudo) unwinder been prepended? */
1296   int unwinder_registered;
1297 };
1298
1299 /* Check GDBARCH and prepend the pseudo JIT unwinder if needed.  */
1300
1301 static void
1302 jit_prepend_unwinder (struct gdbarch *gdbarch)
1303 {
1304   struct jit_gdbarch_data_type *data;
1305
1306   data
1307     = (struct jit_gdbarch_data_type *) gdbarch_data (gdbarch, jit_gdbarch_data);
1308   if (!data->unwinder_registered)
1309     {
1310       frame_unwind_prepend_unwinder (gdbarch, &jit_frame_unwind);
1311       data->unwinder_registered = 1;
1312     }
1313 }
1314
1315 /* Register any already created translations.  */
1316
1317 static void
1318 jit_inferior_init (struct gdbarch *gdbarch)
1319 {
1320   struct jit_descriptor descriptor;
1321   struct jit_code_entry cur_entry;
1322   struct jit_program_space_data *ps_data;
1323   CORE_ADDR cur_entry_addr;
1324
1325   if (jit_debug)
1326     fprintf_unfiltered (gdb_stdlog, "jit_inferior_init\n");
1327
1328   jit_prepend_unwinder (gdbarch);
1329
1330   ps_data = get_jit_program_space_data ();
1331   if (jit_breakpoint_re_set_internal (gdbarch, ps_data) != 0)
1332     return;
1333
1334   /* Read the descriptor so we can check the version number and load
1335      any already JITed functions.  */
1336   if (!jit_read_descriptor (gdbarch, &descriptor, ps_data))
1337     return;
1338
1339   /* Check that the version number agrees with that we support.  */
1340   if (descriptor.version != 1)
1341     {
1342       printf_unfiltered (_("Unsupported JIT protocol version %ld "
1343                            "in descriptor (expected 1)\n"),
1344                          (long) descriptor.version);
1345       return;
1346     }
1347
1348   /* If we've attached to a running program, we need to check the descriptor
1349      to register any functions that were already generated.  */
1350   for (cur_entry_addr = descriptor.first_entry;
1351        cur_entry_addr != 0;
1352        cur_entry_addr = cur_entry.next_entry)
1353     {
1354       jit_read_code_entry (gdbarch, cur_entry_addr, &cur_entry);
1355
1356       /* This hook may be called many times during setup, so make sure we don't
1357          add the same symbol file twice.  */
1358       if (jit_find_objf_with_entry_addr (cur_entry_addr) != NULL)
1359         continue;
1360
1361       jit_register_code (gdbarch, cur_entry_addr, &cur_entry);
1362     }
1363 }
1364
1365 /* inferior_created observer.  */
1366
1367 static void
1368 jit_inferior_created (struct target_ops *ops, int from_tty)
1369 {
1370   jit_inferior_created_hook ();
1371 }
1372
1373 /* Exported routine to call when an inferior has been created.  */
1374
1375 void
1376 jit_inferior_created_hook (void)
1377 {
1378   jit_inferior_init (target_gdbarch ());
1379 }
1380
1381 /* Exported routine to call to re-set the jit breakpoints,
1382    e.g. when a program is rerun.  */
1383
1384 void
1385 jit_breakpoint_re_set (void)
1386 {
1387   jit_breakpoint_re_set_internal (target_gdbarch (),
1388                                   get_jit_program_space_data ());
1389 }
1390
1391 /* This function cleans up any code entries left over when the
1392    inferior exits.  We get left over code when the inferior exits
1393    without unregistering its code, for example when it crashes.  */
1394
1395 static void
1396 jit_inferior_exit_hook (struct inferior *inf)
1397 {
1398   struct objfile *objf;
1399   struct objfile *temp;
1400
1401   ALL_OBJFILES_SAFE (objf, temp)
1402     {
1403       struct jit_objfile_data *objf_data
1404         = (struct jit_objfile_data *) objfile_data (objf, jit_objfile_data);
1405
1406       if (objf_data != NULL && objf_data->addr != 0)
1407         jit_unregister_code (objf);
1408     }
1409 }
1410
1411 void
1412 jit_event_handler (struct gdbarch *gdbarch)
1413 {
1414   struct jit_descriptor descriptor;
1415   struct jit_code_entry code_entry;
1416   CORE_ADDR entry_addr;
1417   struct objfile *objf;
1418
1419   /* Read the descriptor from remote memory.  */
1420   if (!jit_read_descriptor (gdbarch, &descriptor,
1421                             get_jit_program_space_data ()))
1422     return;
1423   entry_addr = descriptor.relevant_entry;
1424
1425   /* Do the corresponding action.  */
1426   switch (descriptor.action_flag)
1427     {
1428     case JIT_NOACTION:
1429       break;
1430     case JIT_REGISTER:
1431       jit_read_code_entry (gdbarch, entry_addr, &code_entry);
1432       jit_register_code (gdbarch, entry_addr, &code_entry);
1433       break;
1434     case JIT_UNREGISTER:
1435       objf = jit_find_objf_with_entry_addr (entry_addr);
1436       if (objf == NULL)
1437         printf_unfiltered (_("Unable to find JITed code "
1438                              "entry at address: %s\n"),
1439                            paddress (gdbarch, entry_addr));
1440       else
1441         jit_unregister_code (objf);
1442
1443       break;
1444     default:
1445       error (_("Unknown action_flag value in JIT descriptor!"));
1446       break;
1447     }
1448 }
1449
1450 /* Called to free the data allocated to the jit_program_space_data slot.  */
1451
1452 static void
1453 free_objfile_data (struct objfile *objfile, void *data)
1454 {
1455   struct jit_objfile_data *objf_data = (struct jit_objfile_data *) data;
1456
1457   if (objf_data->register_code != NULL)
1458     {
1459       struct jit_program_space_data *ps_data;
1460
1461       ps_data
1462         = ((struct jit_program_space_data *)
1463            program_space_data (objfile->pspace, jit_program_space_data));
1464       if (ps_data != NULL && ps_data->objfile == objfile)
1465         {
1466           ps_data->objfile = NULL;
1467           delete_breakpoint (ps_data->jit_breakpoint);
1468           ps_data->cached_code_address = 0;
1469         }
1470     }
1471
1472   xfree (data);
1473 }
1474
1475 /* Initialize the jit_gdbarch_data slot with an instance of struct
1476    jit_gdbarch_data_type */
1477
1478 static void *
1479 jit_gdbarch_data_init (struct obstack *obstack)
1480 {
1481   struct jit_gdbarch_data_type *data =
1482     XOBNEW (obstack, struct jit_gdbarch_data_type);
1483
1484   data->unwinder_registered = 0;
1485
1486   return data;
1487 }
1488
1489 void
1490 _initialize_jit (void)
1491 {
1492   jit_reader_dir = relocate_gdb_directory (JIT_READER_DIR,
1493                                            JIT_READER_DIR_RELOCATABLE);
1494   add_setshow_zuinteger_cmd ("jit", class_maintenance, &jit_debug,
1495                              _("Set JIT debugging."),
1496                              _("Show JIT debugging."),
1497                              _("When non-zero, JIT debugging is enabled."),
1498                              NULL,
1499                              show_jit_debug,
1500                              &setdebuglist, &showdebuglist);
1501
1502   gdb::observers::inferior_created.attach (jit_inferior_created);
1503   gdb::observers::inferior_exit.attach (jit_inferior_exit_hook);
1504   gdb::observers::breakpoint_deleted.attach (jit_breakpoint_deleted);
1505
1506   jit_objfile_data =
1507     register_objfile_data_with_cleanup (NULL, free_objfile_data);
1508   jit_program_space_data =
1509     register_program_space_data_with_cleanup (NULL,
1510                                               jit_program_space_data_cleanup);
1511   jit_gdbarch_data = gdbarch_data_register_pre_init (jit_gdbarch_data_init);
1512   if (is_dl_available ())
1513     {
1514       struct cmd_list_element *c;
1515
1516       c = add_com ("jit-reader-load", no_class, jit_reader_load_command, _("\
1517 Load FILE as debug info reader and unwinder for JIT compiled code.\n\
1518 Usage: jit-reader-load FILE\n\
1519 Try to load file FILE as a debug info reader (and unwinder) for\n\
1520 JIT compiled code.  The file is loaded from " JIT_READER_DIR ",\n\
1521 relocated relative to the GDB executable if required."));
1522       set_cmd_completer (c, filename_completer);
1523
1524       c = add_com ("jit-reader-unload", no_class,
1525                    jit_reader_unload_command, _("\
1526 Unload the currently loaded JIT debug info reader.\n\
1527 Usage: jit-reader-unload\n\n\
1528 Do \"help jit-reader-load\" for info on loading debug info readers."));
1529       set_cmd_completer (c, noop_completer);
1530     }
1531 }