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