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