GDB (xrefs)
Loading...
Searching...
No Matches
jit.c
Go to the documentation of this file.
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
46static std::string jit_reader_dir;
47
48static const char jit_break_name[] = "__jit_debug_register_code";
49
50static const char jit_descriptor_name[] = "__jit_debug_descriptor";
51
53static void jit_inferior_exit_hook (struct inferior *inf);
54
55/* True if we want to see trace of jit level stuff. */
56
57static 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
64static void
65show_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
73static void
74maint_info_jit_cmd (const char *args, int from_tty)
75{
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
122{
123 jit_reader (struct gdb_reader_funcs *f, gdb_dlhandle_up &&h)
124 : functions (f), handle (std::move (h))
125 {
126 }
127
129 {
131 }
132
134
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
142static struct jit_reader *loaded_jit_reader = NULL;
143
144typedef struct gdb_reader_funcs * (reader_init_fn_type) (void);
145static const char reader_init_fn_sym[] = "gdb_init_reader";
146
147/* Try to load FILE_NAME as a JIT debug info reader. */
148
149static struct jit_reader *
150jit_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."),
163
164 if (gdb_dlsym (so, "plugin_is_GPL_compatible") == NULL)
165 error (_("Reader not GPL compatible."));
166
167 funcs = init_fn ();
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
176static void
177jit_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 ());
193}
194
195/* Provides the jit-reader-unload command. */
196
197static void
198jit_reader_unload_command (const char *args, int from_tty)
199{
201 error (_("No JIT reader loaded."));
202
205
206 delete loaded_jit_reader;
207 loaded_jit_reader = NULL;
208}
209
210/* Destructor for jiter_objfile_data. */
211
217
218/* Fetch the jiter_objfile_data associated with OBJF. If no data exists
219 yet, make a new structure and attach it. */
220
221static jiter_objfile_data *
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
233static void
234add_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
246static bool
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. */
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
294static void
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. */
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. */
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
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. */
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
365{
366 explicit gdb_symtab (const char *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
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
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. */
412
414};
415
416/* The reader calls into this function to read data off the targets
417 address space. */
418
419static enum gdb_status
420jit_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
434static struct gdb_object *
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
446static struct gdb_symtab *
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
461static struct gdb_block *
463 struct gdb_symtab *symtab, struct gdb_block *parent,
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
477static void
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].set_unrelocated_pc
495 (unrelocated_addr (map[i].pc));
496 stab->linetable->item[i].line = map[i].line;
497 stab->linetable->item[i].is_stmt = true;
498 }
499}
500
501/* Called by readers to close a gdb_symtab. Does not need to do
502 anything as of now. */
503
504static void
506 struct gdb_symtab *stab)
507{
508 /* Right now nothing needs to be done here. We may need to do some
509 cleanup here in the future (again, without breaking the plugin
510 ABI). */
511}
512
513/* Transform STAB to a proper symtab, and add it it OBJFILE. */
514
515static void
517{
518 struct compunit_symtab *cust;
519 size_t blockvector_size;
520 CORE_ADDR begin, end;
521 struct blockvector *bv;
522
523 int actual_nblocks = FIRST_LOCAL_BLOCK + stab->nblocks;
524
525 /* Sort the blocks in the order they should appear in the blockvector. */
526 stab->blocks.sort([] (const gdb_block &a, const gdb_block &b)
527 {
528 if (a.begin != b.begin)
529 return a.begin < b.begin;
530
531 return a.end > b.end;
532 });
533
534 cust = allocate_compunit_symtab (objfile, stab->file_name.c_str ());
535 symtab *filetab = allocate_symtab (cust, stab->file_name.c_str ());
537
538 /* JIT compilers compile in memory. */
539 cust->set_dirname (nullptr);
540
541 /* Copy over the linetable entry if one was provided. */
542 if (stab->linetable)
543 {
544 size_t size = ((stab->linetable->nitems - 1)
545 * sizeof (struct linetable_entry)
546 + sizeof (struct linetable));
547 struct linetable *new_table
548 = (struct linetable *) obstack_alloc (&objfile->objfile_obstack,
549 size);
550 memcpy (new_table, stab->linetable.get (), size);
551 filetab->set_linetable (new_table);
552 }
553
554 blockvector_size = (sizeof (struct blockvector)
555 + (actual_nblocks - 1) * sizeof (struct block *));
556 bv = (struct blockvector *) obstack_alloc (&objfile->objfile_obstack,
557 blockvector_size);
558 cust->set_blockvector (bv);
559
560 /* At the end of this function, (begin, end) will contain the PC range this
561 entire blockvector spans. */
562 bv->set_map (nullptr);
563 begin = stab->blocks.front ().begin;
564 end = stab->blocks.front ().end;
565 bv->set_num_blocks (actual_nblocks);
566
567 /* First run over all the gdb_block objects, creating a real block
568 object for each. Simultaneously, keep setting the real_block
569 fields. */
570 int block_idx = FIRST_LOCAL_BLOCK;
571 for (gdb_block &gdb_block_iter : stab->blocks)
572 {
573 struct block *new_block = new (&objfile->objfile_obstack) block;
574 struct symbol *block_name = new (&objfile->objfile_obstack) symbol;
576
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);
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 if (i == GLOBAL_BLOCK)
614 else
618 new_block->set_superblock (block_iter);
619 block_iter = new_block;
620
621 new_block->set_start (begin);
623
624 bv->set_block (i, new_block);
625
626 if (i == GLOBAL_BLOCK)
628 }
629
630 /* Fill up the superblock fields for the real blocks, using the
631 real_block fields populated earlier. */
632 for (gdb_block &gdb_block_iter : stab->blocks)
633 {
634 if (gdb_block_iter.parent != NULL)
635 {
636 /* If the plugin specifically mentioned a parent block, we
637 use that. */
638 gdb_block_iter.real_block->set_superblock
639 (gdb_block_iter.parent->real_block);
640
641 }
642 else
643 {
644 /* And if not, we set a default parent block. */
645 gdb_block_iter.real_block->set_superblock (bv->static_block ());
646 }
647 }
648}
649
650/* Called when closing a gdb_objfile. Converts OBJ to a proper
651 objfile. */
652
653static void
655 struct gdb_object *obj)
656{
658 std::string objfile_name
659 = string_printf ("<< JIT compiled code at %s >>",
660 paddress (priv_data->gdbarch,
661 priv_data->entry.symfile_addr));
662
663 objfile *objfile = objfile::make (nullptr, objfile_name.c_str (),
665 objfile->per_bfd->gdbarch = priv_data->gdbarch;
666
667 for (gdb_symtab &symtab : obj->symtabs)
669
671 priv_data->entry.symfile_addr,
672 priv_data->entry.symfile_size);
673
674 delete obj;
675}
676
677/* Try to read CODE_ENTRY using the loaded jit reader (if any).
678 ENTRY_ADDR is the address of the struct jit_code_entry in the
679 inferior address space. */
680
681static int
683 CORE_ADDR entry_addr)
684{
685 int status;
686 jit_dbg_reader_data priv_data
687 {
688 entry_addr,
689 *code_entry,
690 gdbarch
691 };
692 struct gdb_reader_funcs *funcs;
693 struct gdb_symbol_callbacks callbacks =
694 {
700
703
704 &priv_data
705 };
706
708 return 0;
709
710 gdb::byte_vector gdb_mem (code_entry->symfile_size);
711
712 status = 1;
713 try
714 {
715 if (target_read_memory (code_entry->symfile_addr, gdb_mem.data (),
716 code_entry->symfile_size))
717 status = 0;
718 }
719 catch (const gdb_exception_error &e)
720 {
721 status = 0;
722 }
723
724 if (status)
725 {
727 if (funcs->read (funcs, &callbacks, gdb_mem.data (),
728 code_entry->symfile_size)
729 != GDB_SUCCESS)
730 status = 0;
731 }
732
733 if (status == 0)
734 jit_debug_printf ("Could not read symtab using the loaded JIT reader.");
735
736 return status;
737}
738
739/* Try to read CODE_ENTRY using BFD. ENTRY_ADDR is the address of the
740 struct jit_code_entry in the inferior address space. */
741
742static void
744 CORE_ADDR entry_addr,
745 struct gdbarch *gdbarch)
746{
747 struct bfd_section *sec;
748 struct objfile *objfile;
749 const struct bfd_arch_info *b;
750
751 jit_debug_printf ("symfile_addr = %s, symfile_size = %s",
752 paddress (gdbarch, code_entry->symfile_addr),
753 pulongest (code_entry->symfile_size));
754
756 (code_entry->symfile_addr, code_entry->symfile_size, gnutarget));
757 if (nbfd == NULL)
758 {
759 gdb_puts (_("Error opening JITed symbol file, ignoring it.\n"),
760 gdb_stderr);
761 return;
762 }
763
764 /* Check the format. NOTE: This initializes important data that GDB uses!
765 We would segfault later without this line. */
766 if (!bfd_check_format (nbfd.get (), bfd_object))
767 {
769JITed symbol file is not an object file, ignoring it.\n"));
770 return;
771 }
772
773 /* Check bfd arch. */
775 if (b->compatible (b, bfd_get_arch_info (nbfd.get ())) != b)
776 warning (_("JITed object file architecture %s is not compatible "
777 "with target architecture %s."),
778 bfd_get_arch_info (nbfd.get ())->printable_name,
779 b->printable_name);
780
781 /* Read the section address information out of the symbol file. Since the
782 file is generated by the JIT at runtime, it should all of the absolute
783 addresses that we care about. */
785 for (sec = nbfd->sections; sec != NULL; sec = sec->next)
786 if ((bfd_section_flags (sec) & (SEC_ALLOC|SEC_LOAD)) != 0)
787 {
788 /* We assume that these virtual addresses are absolute, and do not
789 treat them as offsets. */
790 sai.emplace_back (bfd_section_vma (sec),
791 bfd_section_name (sec),
792 sec->index);
793 }
794
795 /* This call does not take ownership of SAI. */
797 bfd_get_filename (nbfd.get ()), 0,
798 &sai,
800
801 add_objfile_entry (objfile, entry_addr, code_entry->symfile_addr,
802 code_entry->symfile_size);
803}
804
805/* This function registers code associated with a JIT code entry. It uses the
806 pointer and size pair in the entry to read the symbol file from the remote
807 and then calls symbol_file_add_from_local_memory to add it as though it were
808 a symbol file added by the user. */
809
810static void
812 CORE_ADDR entry_addr, struct jit_code_entry *code_entry)
813{
814 int success;
815
816 jit_debug_printf ("symfile_addr = %s, symfile_size = %s",
817 paddress (gdbarch, code_entry->symfile_addr),
818 pulongest (code_entry->symfile_size));
819
820 success = jit_reader_try_read_symtab (gdbarch, code_entry, entry_addr);
821
822 if (!success)
823 jit_bfd_try_read_symtab (code_entry, entry_addr, gdbarch);
824}
825
826/* Look up the objfile with this code entry address. */
827
828static struct objfile *
829jit_find_objf_with_entry_addr (CORE_ADDR entry_addr)
830{
831 for (objfile *objf : current_program_space->objfiles ())
832 {
833 if (objf->jited_data != nullptr && objf->jited_data->addr == entry_addr)
834 return objf;
835 }
836
837 return NULL;
838}
839
840/* This is called when a breakpoint is deleted. It updates the
841 inferior's cache, if needed. */
842
843static void
845{
846 if (b->type != bp_jit_event)
847 return;
848
849 for (bp_location &iter : b->locations ())
850 {
851 for (objfile *objf : iter.pspace->objfiles ())
852 {
853 jiter_objfile_data *jiter_data = objf->jiter_data.get ();
854
855 if (jiter_data != nullptr
856 && jiter_data->jit_breakpoint == iter.owner)
857 {
859 jiter_data->jit_breakpoint = nullptr;
860 }
861 }
862 }
863}
864
865/* (Re-)Initialize the jit breakpoints for JIT-producing objfiles in
866 PSPACE. */
867
868static void
870{
871 for (objfile *the_objfile : pspace->objfiles ())
872 {
873 /* Skip separate debug objects. */
874 if (the_objfile->separate_debug_objfile_backlink != nullptr)
875 continue;
876
877 if (the_objfile->skip_jit_symbol_lookup)
878 continue;
879
880 /* Lookup the registration symbol. If it is missing, then we
881 assume we are not attached to a JIT. */
882 bound_minimal_symbol reg_symbol
883 = lookup_minimal_symbol (jit_break_name, nullptr, the_objfile);
884 if (reg_symbol.minsym == NULL
885 || reg_symbol.value_address () == 0)
886 {
887 /* No need to repeat the lookup the next time. */
888 the_objfile->skip_jit_symbol_lookup = true;
889 continue;
890 }
891
892 bound_minimal_symbol desc_symbol
893 = lookup_minimal_symbol (jit_descriptor_name, NULL, the_objfile);
894 if (desc_symbol.minsym == NULL
895 || desc_symbol.value_address () == 0)
896 {
897 /* No need to repeat the lookup the next time. */
898 the_objfile->skip_jit_symbol_lookup = true;
899 continue;
900 }
901
902 jiter_objfile_data *objf_data
903 = get_jiter_objfile_data (the_objfile);
904 objf_data->register_code = reg_symbol.minsym;
905 objf_data->descriptor = desc_symbol.minsym;
906
907 CORE_ADDR addr = objf_data->register_code->value_address (the_objfile);
908 jit_debug_printf ("breakpoint_addr = %s", paddress (gdbarch, addr));
909
910 /* Check if we need to re-create the breakpoint. */
911 if (objf_data->cached_code_address == addr)
912 continue;
913
914 /* Delete the old breakpoint. */
915 if (objf_data->jit_breakpoint != nullptr)
917
918 /* Put a breakpoint in the registration symbol. */
919 objf_data->cached_code_address = addr;
921 }
922}
923
924/* The private data passed around in the frame unwind callback
925 functions. */
926
928{
929 /* Cached register values. See jit_frame_sniffer to see how this
930 works. */
931 std::unique_ptr<detached_regcache> regcache;
932
933 /* The frame being unwound. */
935};
936
937/* Sets the value of a particular register in this frame. */
938
939static void
940jit_unwind_reg_set_impl (struct gdb_unwind_callbacks *cb, int dwarf_regnum,
941 struct gdb_reg_value *value)
942{
943 struct jit_unwind_private *priv;
944 int gdb_reg;
945
946 priv = (struct jit_unwind_private *) cb->priv_data;
947
949 dwarf_regnum);
950 if (gdb_reg == -1)
951 {
952 jit_debug_printf ("Could not recognize DWARF regnum %d", dwarf_regnum);
953 value->free (value);
954 return;
955 }
956
957 priv->regcache->raw_supply (gdb_reg, value->value);
958 value->free (value);
959}
960
961static void
966
967/* Get the value of register REGNUM in the previous frame. */
968
969static struct gdb_reg_value *
971{
972 struct jit_unwind_private *priv;
973 struct gdb_reg_value *value;
974 int gdb_reg, size;
975 struct gdbarch *frame_arch;
976
977 priv = (struct jit_unwind_private *) cb->priv_data;
978 frame_arch = get_frame_arch (priv->this_frame);
979
980 gdb_reg = gdbarch_dwarf2_reg_to_regnum (frame_arch, regnum);
981 size = register_size (frame_arch, gdb_reg);
982 value = ((struct gdb_reg_value *)
983 xmalloc (sizeof (struct gdb_reg_value) + size - 1));
984 value->defined = deprecated_frame_register_read (priv->this_frame, gdb_reg,
985 value->value);
986 value->size = size;
988 return value;
989}
990
991/* gdb_reg_value has a free function, which must be called on each
992 saved register value. */
993
994static void
995jit_dealloc_cache (frame_info *this_frame, void *cache)
996{
997 struct jit_unwind_private *priv_data = (struct jit_unwind_private *) cache;
998 delete priv_data;
999}
1000
1001/* The frame sniffer for the pseudo unwinder.
1002
1003 While this is nominally a frame sniffer, in the case where the JIT
1004 reader actually recognizes the frame, it does a lot more work -- it
1005 unwinds the frame and saves the corresponding register values in
1006 the cache. jit_frame_prev_register simply returns the saved
1007 register values. */
1008
1009static int
1011 frame_info_ptr this_frame, void **cache)
1012{
1013 struct jit_unwind_private *priv_data;
1014 struct gdb_unwind_callbacks callbacks;
1015 struct gdb_reader_funcs *funcs;
1016
1017 callbacks.reg_get = jit_unwind_reg_get_impl;
1018 callbacks.reg_set = jit_unwind_reg_set_impl;
1020
1021 if (loaded_jit_reader == NULL)
1022 return 0;
1023
1025
1026 gdb_assert (!*cache);
1027
1028 priv_data = new struct jit_unwind_private;
1029 *cache = priv_data;
1030 /* Take a snapshot of current regcache. */
1031 priv_data->regcache.reset
1033 priv_data->this_frame = this_frame;
1034
1035 callbacks.priv_data = priv_data;
1036
1037 /* Try to coax the provided unwinder to unwind the stack */
1038 if (funcs->unwind (funcs, &callbacks) == GDB_SUCCESS)
1039 {
1040 jit_debug_printf ("Successfully unwound frame using JIT reader.");
1041 return 1;
1042 }
1043
1044 jit_debug_printf ("Could not unwind frame using JIT reader.");
1045
1046 jit_dealloc_cache (this_frame.get (), *cache);
1047 *cache = NULL;
1048
1049 return 0;
1050}
1051
1052
1053/* The frame_id function for the pseudo unwinder. Relays the call to
1054 the loaded plugin. */
1055
1056static void
1058 struct frame_id *this_id)
1059{
1060 struct jit_unwind_private priv;
1061 struct gdb_frame_id frame_id;
1062 struct gdb_reader_funcs *funcs;
1063 struct gdb_unwind_callbacks callbacks;
1064
1065 priv.regcache.reset ();
1066 priv.this_frame = this_frame;
1067
1068 /* We don't expect the frame_id function to set any registers, so we
1069 set reg_set to NULL. */
1070 callbacks.reg_get = jit_unwind_reg_get_impl;
1071 callbacks.reg_set = NULL;
1073 callbacks.priv_data = &priv;
1074
1075 gdb_assert (loaded_jit_reader);
1077
1078 frame_id = funcs->get_frame_id (funcs, &callbacks);
1079 *this_id = frame_id_build (frame_id.stack_address, frame_id.code_address);
1080}
1081
1082/* Pseudo unwinder function. Reads the previously fetched value for
1083 the register from the cache. */
1084
1085static struct value *
1086jit_frame_prev_register (frame_info_ptr this_frame, void **cache, int reg)
1087{
1088 struct jit_unwind_private *priv = (struct jit_unwind_private *) *cache;
1089 struct gdbarch *gdbarch;
1090
1091 if (priv == NULL)
1092 return frame_unwind_got_optimized (this_frame, reg);
1093
1094 gdbarch = priv->regcache->arch ();
1095 gdb_byte *buf = (gdb_byte *) alloca (register_size (gdbarch, reg));
1096 enum register_status status = priv->regcache->cooked_read (reg, buf);
1097
1098 if (status == REG_VALID)
1099 return frame_unwind_got_bytes (this_frame, reg, buf);
1100 else
1101 return frame_unwind_got_optimized (this_frame, reg);
1102}
1103
1104/* Relay everything back to the unwinder registered by the JIT debug
1105 info reader.*/
1106
1107static const struct frame_unwind jit_frame_unwind =
1108{
1109 "jit",
1114 NULL,
1117};
1118
1119
1120/* This is the information that is stored at jit_gdbarch_data for each
1121 architecture. */
1122
1124{
1125 /* Has the (pseudo) unwinder been pretended? */
1127};
1128
1129/* An unwinder is registered for every gdbarch. This key is used to
1130 remember if the unwinder has been registered for a particular
1131 gdbarch. */
1132
1134
1135/* Check GDBARCH and prepend the pseudo JIT unwinder if needed. */
1136
1137static void
1139{
1141 if (data == nullptr)
1142 data = jit_gdbarch_data.emplace (gdbarch);
1143
1144 if (!data->unwinder_registered)
1145 {
1147 data->unwinder_registered = 1;
1148 }
1149}
1150
1151/* Looks for the descriptor and registration symbols and breakpoints
1152 the registration function. If it finds both, it registers all the
1153 already JITed code. If it has already found the symbols, then it
1154 doesn't try again. */
1155
1156static void
1158{
1159 struct jit_descriptor descriptor;
1160 struct jit_code_entry cur_entry;
1161 CORE_ADDR cur_entry_addr;
1162 struct gdbarch *gdbarch = inf->gdbarch;
1163 program_space *pspace = inf->pspace;
1164
1165 jit_debug_printf ("called");
1166
1168
1170
1171 for (objfile *jiter : pspace->objfiles ())
1172 {
1173 if (jiter->jiter_data == nullptr)
1174 continue;
1175
1176 /* Read the descriptor so we can check the version number and load
1177 any already JITed functions. */
1178 if (!jit_read_descriptor (gdbarch, &descriptor, jiter))
1179 continue;
1180
1181 /* Check that the version number agrees with that we support. */
1182 if (descriptor.version != 1)
1183 {
1185 _("Unsupported JIT protocol version %ld "
1186 "in descriptor (expected 1)\n"),
1187 (long) descriptor.version);
1188 continue;
1189 }
1190
1191 /* If we've attached to a running program, we need to check the
1192 descriptor to register any functions that were already
1193 generated. */
1194 for (cur_entry_addr = descriptor.first_entry;
1195 cur_entry_addr != 0;
1196 cur_entry_addr = cur_entry.next_entry)
1197 {
1198 jit_read_code_entry (gdbarch, cur_entry_addr, &cur_entry);
1199
1200 /* This hook may be called many times during setup, so make sure
1201 we don't add the same symbol file twice. */
1202 if (jit_find_objf_with_entry_addr (cur_entry_addr) != NULL)
1203 continue;
1204
1205 jit_register_code (gdbarch, cur_entry_addr, &cur_entry);
1206 }
1207 }
1208}
1209
1210/* inferior_created observer. */
1211
1212static void
1217
1218/* inferior_execd observer. */
1219
1220static void
1222{
1223 jit_inferior_init (follow_inf);
1224}
1225
1226/* Exported routine to call to re-set the jit breakpoints,
1227 e.g. when a program is rerun. */
1228
1229void
1234
1235/* This function cleans up any code entries left over when the
1236 inferior exits. We get left over code when the inferior exits
1237 without unregistering its code, for example when it crashes. */
1238
1239static void
1241{
1243 {
1244 if (objf->jited_data != nullptr && objf->jited_data->addr != 0)
1245 objf->unlink ();
1246 }
1247}
1248
1249void
1251{
1252 struct jit_descriptor descriptor;
1253
1254 /* If we get a JIT breakpoint event for this objfile, it is necessarily a
1255 JITer. */
1256 gdb_assert (jiter->jiter_data != nullptr);
1257
1258 /* Read the descriptor from remote memory. */
1259 if (!jit_read_descriptor (gdbarch, &descriptor, jiter))
1260 return;
1261 CORE_ADDR entry_addr = descriptor.relevant_entry;
1262
1263 /* Do the corresponding action. */
1264 switch (descriptor.action_flag)
1265 {
1266 case JIT_NOACTION:
1267 break;
1268
1269 case JIT_REGISTER:
1270 {
1271 jit_code_entry code_entry;
1272 jit_read_code_entry (gdbarch, entry_addr, &code_entry);
1273 jit_register_code (gdbarch, entry_addr, &code_entry);
1274 break;
1275 }
1276
1277 case JIT_UNREGISTER:
1278 {
1279 objfile *jited = jit_find_objf_with_entry_addr (entry_addr);
1280 if (jited == nullptr)
1282 _("Unable to find JITed code "
1283 "entry at address: %s\n"),
1284 paddress (gdbarch, entry_addr));
1285 else
1286 jited->unlink ();
1287
1288 break;
1289 }
1290
1291 default:
1292 error (_("Unknown action_flag value in JIT descriptor!"));
1293 break;
1294 }
1295}
1296
1297void _initialize_jit ();
1298void
1300{
1304 _("Set JIT debugging."),
1305 _("Show JIT debugging."),
1306 _("When set, JIT debugging is enabled."),
1307 NULL,
1310
1312 _("Print information about JIT-ed code objects."),
1314
1319
1320 if (is_dl_available ())
1321 {
1322 struct cmd_list_element *c;
1323
1324 c = add_com ("jit-reader-load", no_class, jit_reader_load_command, _("\
1325Load FILE as debug info reader and unwinder for JIT compiled code.\n\
1326Usage: jit-reader-load FILE\n\
1327Try to load file FILE as a debug info reader (and unwinder) for\n\
1328JIT compiled code. The file is loaded from " JIT_READER_DIR ",\n\
1329relocated relative to the GDB executable if required."));
1331
1332 c = add_com ("jit-reader-unload", no_class,
1334Unload the currently loaded JIT debug info reader.\n\
1335Usage: jit-reader-unload\n\n\
1336Do \"help jit-reader-load\" for info on loading debug info readers."));
1338 }
1339}
int regnum
const char *const name
void * xmalloc(YYSIZE_T)
void xfree(void *)
struct gdbarch * target_gdbarch(void)
void f()
Definition 1.cc:36
void delete_breakpoint(struct breakpoint *bpt)
struct breakpoint * create_jit_event_breakpoint(struct gdbarch *gdbarch, CORE_ADDR address)
@ bp_jit_event
Definition breakpoint.h:198
frame_info * get() const
Definition frame.h:294
void * get(unsigned key)
Definition registry.h:211
struct cmd_list_element * showdebuglist
Definition cli-cmds.c:167
struct cmd_list_element * maintenanceinfolist
Definition cli-cmds.c:147
struct cmd_list_element * setdebuglist
Definition cli-cmds.c:165
struct cmd_list_element * add_cmd(const char *name, enum command_class theclass, const char *doc, struct cmd_list_element **list)
Definition cli-decode.c:233
void set_cmd_completer(struct cmd_list_element *cmd, completer_ftype *completer)
Definition cli-decode.c:117
struct cmd_list_element * add_com(const char *name, enum command_class theclass, cmd_simple_func_ftype *fun, const char *doc)
set_show_commands add_setshow_boolean_cmd(const char *name, enum command_class theclass, bool *var, const char *set_doc, const char *show_doc, const char *help_doc, cmd_func_ftype *set_func, show_value_ftype *show_func, struct cmd_list_element **set_list, struct cmd_list_element **show_list)
Definition cli-decode.c:809
@ class_maintenance
Definition command.h:65
@ no_class
Definition command.h:53
void noop_completer(struct cmd_list_element *ignore, completion_tracker &tracker, const char *text, const char *prefix)
Definition completer.c:195
void filename_completer(struct cmd_list_element *ignore, completion_tracker &tracker, const char *text, const char *word)
Definition completer.c:204
#define JIT_READER_DIR_RELOCATABLE
Definition config.h:619
#define JIT_READER_DIR
Definition config.h:615
const char * gnutarget
Definition corefile.c:405
std::string relocate_gdb_directory(const char *initial, bool relocatable)
Definition main.c:160
CORE_ADDR extract_typed_address(const gdb_byte *buf, struct type *type)
Definition findvar.c:152
block_enum
Definition defs.h:584
@ STATIC_BLOCK
Definition defs.h:586
@ GLOBAL_BLOCK
Definition defs.h:585
@ FIRST_LOCAL_BLOCK
Definition defs.h:587
static ULONGEST extract_unsigned_integer(gdb::array_view< const gdb_byte > buf, enum bfd_endian byte_order)
Definition defs.h:480
struct multidictionary * mdict_create_linear(struct obstack *obstack, const struct pending *symbol_list)
struct value * frame_unwind_got_optimized(frame_info_ptr frame, int regnum)
void frame_unwind_prepend_unwinder(struct gdbarch *gdbarch, const struct frame_unwind *unwinder)
enum unwind_stop_reason default_frame_unwind_stop_reason(frame_info_ptr this_frame, void **this_cache)
struct value * frame_unwind_got_bytes(frame_info_ptr frame, int regnum, const gdb_byte *buf)
void reinit_frame_cache(void)
Definition frame.c:2107
struct frame_id frame_id_build(CORE_ADDR stack_addr, CORE_ADDR code_addr)
Definition frame.c:736
struct gdbarch * get_frame_arch(frame_info_ptr this_frame)
Definition frame.c:3027
bool deprecated_frame_register_read(frame_info_ptr frame, int regnum, gdb_byte *myaddr)
Definition frame.c:1464
@ NORMAL_FRAME
Definition frame.h:187
gdb_bfd_ref_ptr gdb_bfd_open_from_target_memory(CORE_ADDR addr, ULONGEST size, const char *target)
Definition gdb_bfd.c:301
gdb::ref_ptr< struct bfd, gdb_bfd_ref_policy > gdb_bfd_ref_ptr
Definition gdb_bfd.h:79
int gdbarch_dwarf2_reg_to_regnum(struct gdbarch *gdbarch, int dwarf2_regnr)
Definition gdbarch.c:2156
enum bfd_endian gdbarch_byte_order(struct gdbarch *gdbarch)
Definition gdbarch.c:1396
const struct bfd_arch_info * gdbarch_bfd_arch_info(struct gdbarch *gdbarch)
Definition gdbarch.c:1387
int gdbarch_ptr_bit(struct gdbarch *gdbarch)
Definition gdbarch.c:1722
struct type * lookup_function_type(struct type *type)
Definition gdbtypes.c:567
const struct builtin_type * builtin_type(struct gdbarch *gdbarch)
Definition gdbtypes.c:6168
unsigned type_align(struct type *type)
Definition gdbtypes.c:3527
mach_port_t mach_port_t name mach_port_t mach_port_t name kern_return_t err
Definition gnu-nat.c:1789
mach_port_t mach_port_t name mach_port_t mach_port_t name kern_return_t int status
Definition gnu-nat.c:1790
size_t size
Definition go32-nat.c:239
struct inferior * current_inferior(void)
Definition inferior.c:55
gdb_status
Definition jit-reader.h:63
@ GDB_SUCCESS
Definition jit-reader.h:65
@ GDB_FAIL
Definition jit-reader.h:64
unsigned long GDB_CORE_ADDR
Definition jit-reader.h:59
#define GDB_READER_INTERFACE_VERSION
Definition jit-reader.h:29
static const char jit_descriptor_name[]
Definition jit.c:50
static void jit_inferior_created_hook(inferior *inf)
Definition jit.c:1213
static void add_objfile_entry(struct objfile *objfile, CORE_ADDR entry, CORE_ADDR symfile_addr, ULONGEST symfile_size)
Definition jit.c:234
static void jit_breakpoint_re_set_internal(struct gdbarch *gdbarch, program_space *pspace)
Definition jit.c:869
static struct gdb_block * jit_block_open_impl(struct gdb_symbol_callbacks *cb, struct gdb_symtab *symtab, struct gdb_block *parent, GDB_CORE_ADDR begin, GDB_CORE_ADDR end, const char *name)
Definition jit.c:462
static int jit_frame_sniffer(const struct frame_unwind *self, frame_info_ptr this_frame, void **cache)
Definition jit.c:1010
static const registry< gdbarch >::key< jit_gdbarch_data_type > jit_gdbarch_data
Definition jit.c:1133
static void reg_value_free_impl(struct gdb_reg_value *value)
Definition jit.c:962
void _initialize_jit()
Definition jit.c:1299
static struct gdb_reg_value * jit_unwind_reg_get_impl(struct gdb_unwind_callbacks *cb, int regnum)
Definition jit.c:970
static void jit_inferior_init(inferior *inf)
Definition jit.c:1157
static void jit_bfd_try_read_symtab(struct jit_code_entry *code_entry, CORE_ADDR entry_addr, struct gdbarch *gdbarch)
Definition jit.c:743
static struct gdb_symtab * jit_symtab_open_impl(struct gdb_symbol_callbacks *cb, struct gdb_object *object, const char *file_name)
Definition jit.c:447
static const struct frame_unwind jit_frame_unwind
Definition jit.c:1107
void jit_event_handler(gdbarch *gdbarch, objfile *jiter)
Definition jit.c:1250
static std::string jit_reader_dir
Definition jit.c:46
static struct jit_reader * loaded_jit_reader
Definition jit.c:142
static void jit_breakpoint_deleted(struct breakpoint *b)
Definition jit.c:844
static void jit_read_code_entry(struct gdbarch *gdbarch, CORE_ADDR code_addr, struct jit_code_entry *code_entry)
Definition jit.c:295
static void jit_reader_load_command(const char *args, int from_tty)
Definition jit.c:177
void jit_breakpoint_re_set(void)
Definition jit.c:1230
static void jit_symtab_close_impl(struct gdb_symbol_callbacks *cb, struct gdb_symtab *stab)
Definition jit.c:505
static void jit_register_code(struct gdbarch *gdbarch, CORE_ADDR entry_addr, struct jit_code_entry *code_entry)
Definition jit.c:811
static void jit_prepend_unwinder(struct gdbarch *gdbarch)
Definition jit.c:1138
static void jit_inferior_execd_hook(inferior *exec_inf, inferior *follow_inf)
Definition jit.c:1221
static const char jit_break_name[]
Definition jit.c:48
static jiter_objfile_data * get_jiter_objfile_data(objfile *objf)
Definition jit.c:222
static struct jit_reader * jit_reader_load(const char *file_name)
Definition jit.c:150
static void jit_frame_this_id(frame_info_ptr this_frame, void **cache, struct frame_id *this_id)
Definition jit.c:1057
static struct gdb_object * jit_object_open_impl(struct gdb_symbol_callbacks *cb)
Definition jit.c:435
static void jit_reader_unload_command(const char *args, int from_tty)
Definition jit.c:198
static void jit_inferior_exit_hook(struct inferior *inf)
Definition jit.c:1240
static void jit_unwind_reg_set_impl(struct gdb_unwind_callbacks *cb, int dwarf_regnum, struct gdb_reg_value *value)
Definition jit.c:940
struct gdb_reader_funcs * reader_init_fn_type(void)
Definition jit.c:144
#define jit_debug_printf(fmt,...)
Definition jit.c:61
static struct value * jit_frame_prev_register(frame_info_ptr this_frame, void **cache, int reg)
Definition jit.c:1086
static void jit_dealloc_cache(frame_info *this_frame, void *cache)
Definition jit.c:995
static int jit_reader_try_read_symtab(gdbarch *gdbarch, jit_code_entry *code_entry, CORE_ADDR entry_addr)
Definition jit.c:682
static const char reader_init_fn_sym[]
Definition jit.c:145
static enum gdb_status jit_target_read_impl(GDB_CORE_ADDR target_mem, void *gdb_buf, int len)
Definition jit.c:420
static void jit_symtab_line_mapping_add_impl(struct gdb_symbol_callbacks *cb, struct gdb_symtab *stab, int nlines, struct gdb_line_mapping *map)
Definition jit.c:478
static void finalize_symtab(struct gdb_symtab *stab, struct objfile *objfile)
Definition jit.c:516
static bool jit_read_descriptor(gdbarch *gdbarch, jit_descriptor *descriptor, objfile *jiter)
Definition jit.c:247
static void jit_object_close_impl(struct gdb_symbol_callbacks *cb, struct gdb_object *obj)
Definition jit.c:654
static void show_jit_debug(struct ui_file *file, int from_tty, struct cmd_list_element *c, const char *value)
Definition jit.c:65
static bool jit_debug
Definition jit.c:57
static struct objfile * jit_find_objf_with_entry_addr(CORE_ADDR entry_addr)
Definition jit.c:829
static void maint_info_jit_cmd(const char *args, int from_tty)
Definition jit.c:74
@ JIT_REGISTER
Definition jit.h:34
@ JIT_UNREGISTER
Definition jit.h:35
@ JIT_NOACTION
Definition jit.h:33
static struct block * new_block(struct objfile *objfile, enum block_type, enum language)
block_type
Definition mdebugread.c:237
struct bound_minimal_symbol lookup_minimal_symbol(const char *name, const char *sfile, struct objfile *objf)
Definition minsyms.c:363
observable< struct inferior * > inferior_exit
observable< struct breakpoint * > breakpoint_deleted
observable< inferior *, inferior * > inferior_execd
observable< inferior * > inferior_created
Definition aarch64.h:67
@ OBJF_SHARED
@ OBJF_NOT_FILENAME
const char * objfile_name(const struct objfile *objfile)
Definition objfiles.c:1259
struct program_space * current_program_space
Definition progspace.c:40
int value
Definition py-param.c:79
int register_size(struct gdbarch *gdbarch, int regnum)
Definition regcache.c:170
Definition block.h:109
void set_start(CORE_ADDR start)
Definition block.h:115
CORE_ADDR start() const
Definition block.h:111
void set_multidict(multidictionary *multidict)
Definition block.h:151
void set_compunit_symtab(struct compunit_symtab *)
Definition block.c:395
void set_end(CORE_ADDR end)
Definition block.h:123
CORE_ADDR end() const
Definition block.h:119
void set_superblock(const block *superblock)
Definition block.h:139
void set_function(symbol *function)
Definition block.h:131
struct block * static_block()
Definition block.h:405
void set_map(addrmap *map)
Definition block.h:421
void set_block(int i, struct block *block)
Definition block.h:382
void set_num_blocks(int num_blocks)
Definition block.h:389
CORE_ADDR value_address() const
Definition minsyms.h:41
struct minimal_symbol * minsym
Definition minsyms.h:49
bptype type
Definition breakpoint.h:798
bp_location_range locations() const
struct type * builtin_data_ptr
Definition gdbtypes.h:2135
struct type * builtin_void
Definition gdbtypes.h:2077
void set_blockvector(struct blockvector *blockvector)
Definition symtab.h:1857
void set_dirname(const char *dirname)
Definition symtab.h:1842
struct gdb_block * parent
Definition jit.c:347
CORE_ADDR begin
Definition jit.c:355
CORE_ADDR end
Definition jit.c:355
struct block * real_block
Definition jit.c:352
gdb_block(gdb_block *parent, CORE_ADDR begin, CORE_ADDR end, const char *name)
Definition jit.c:338
gdb::unique_xmalloc_ptr< char > name
Definition jit.c:359
std::forward_list< gdb_symtab > symtabs
Definition jit.c:399
gdb_read_debug_info * read
Definition jit-reader.h:336
gdb_destroy_reader * destroy
Definition jit-reader.h:339
gdb_unwind_frame * unwind
Definition jit-reader.h:337
gdb_get_frame_id * get_frame_id
Definition jit-reader.h:338
int nblocks
Definition jit.c:380
gdb::unique_xmalloc_ptr< struct linetable > linetable
Definition jit.c:383
std::forward_list< gdb_block > blocks
Definition jit.c:377
std::string file_name
Definition jit.c:386
gdb_symtab(const char *file_name)
Definition jit.c:366
gdb_unwind_reg_set * reg_set
Definition jit-reader.h:271
gdb_target_read * target_read
Definition jit-reader.h:272
gdb_unwind_reg_get * reg_get
Definition jit-reader.h:270
const char * m_name
Definition symtab.h:545
Definition gnu-nat.c:153
Definition jit.h:46
CORE_ADDR symfile_addr
Definition jit.h:49
CORE_ADDR next_entry
Definition jit.h:47
CORE_ADDR prev_entry
Definition jit.h:48
ULONGEST symfile_size
Definition jit.h:50
struct gdbarch * gdbarch
Definition jit.c:413
const jit_code_entry & entry
Definition jit.c:411
CORE_ADDR entry_addr
Definition jit.c:408
uint32_t action_flag
Definition jit.h:66
CORE_ADDR first_entry
Definition jit.h:68
uint32_t version
Definition jit.h:63
CORE_ADDR relevant_entry
Definition jit.h:67
gdb_dlhandle_up handle
Definition jit.c:136
~jit_reader()
Definition jit.c:128
DISABLE_COPY_AND_ASSIGN(jit_reader)
struct gdb_reader_funcs * functions
Definition jit.c:135
jit_reader(struct gdb_reader_funcs *f, gdb_dlhandle_up &&h)
Definition jit.c:123
frame_info_ptr this_frame
Definition jit.c:934
std::unique_ptr< detached_regcache > regcache
Definition jit.c:931
~jiter_objfile_data()
Definition jit.c:212
breakpoint * jit_breakpoint
Definition jit.h:90
CORE_ADDR cached_code_address
Definition jit.h:87
minimal_symbol * register_code
Definition jit.h:79
minimal_symbol * descriptor
Definition jit.h:82
Definition symtab.h:1596
CORE_ADDR pc(const struct objfile *objfile) const
Definition symtab.c:336
CORE_ADDR value_address(objfile *objfile) const
Definition symtab.c:439
struct gdbarch * gdbarch
Definition objfiles.h:267
std::unique_ptr< jiter_objfile_data > jiter_data
Definition objfiles.h:863
struct program_space * pspace
Definition objfiles.h:728
struct gdbarch * arch() const
Definition objfiles.h:507
struct objfile_per_bfd_storage * per_bfd
Definition objfiles.h:744
static objfile * make(gdb_bfd_ref_ptr bfd_, const char *name_, objfile_flags flags_, objfile *parent=nullptr)
Definition objfiles.c:449
objfile(gdb_bfd_ref_ptr, const char *, objfile_flags)
Definition objfiles.c:313
std::unique_ptr< jited_objfile_data > jited_data
Definition objfiles.h:867
auto_obstack objfile_obstack
Definition objfiles.h:760
void unlink()
Definition objfiles.c:468
objfiles_safe_range objfiles_safe()
Definition progspace.h:225
objfiles_range objfiles()
Definition progspace.h:209
void set_value_block(const block *block)
Definition symtab.h:1396
void set_aclass_index(unsigned int aclass_index)
Definition symtab.h:1264
void set_type(struct type *type)
Definition symtab.h:1336
void set_domain(domain_enum domain)
Definition symtab.h:1291
void set_symtab(struct symtab *symtab)
Definition symtab.c:6510
void set_linetable(const struct linetable *linetable)
Definition symtab.h:1692
ULONGEST length() const
Definition gdbtypes.h:983
Definition value.h:130
value(struct type *type_)
Definition value.h:134
struct value::@203::@204 reg
void add_compunit_symtab_to_objfile(struct compunit_symtab *cu)
Definition symfile.c:2894
struct symtab * allocate_symtab(struct compunit_symtab *cust, const char *filename, const char *filename_for_id)
Definition symfile.c:2821
struct compunit_symtab * allocate_compunit_symtab(struct objfile *objfile, const char *name)
Definition symfile.c:2868
struct objfile * symbol_file_add_from_bfd(const gdb_bfd_ref_ptr &abfd, const char *name, symfile_add_flags add_flags, section_addr_info *addrs, objfile_flags flags, struct objfile *parent)
Definition symfile.c:1155
std::vector< other_sections > section_addr_info
Definition symfile.h:74
@ LOC_BLOCK
Definition symtab.h:1028
@ VAR_DOMAIN
Definition symtab.h:910
int target_read_memory(CORE_ADDR memaddr, gdb_byte *myaddr, ssize_t len)
Definition target.c:1785
@ ui_left
Definition ui-out.h:45
#define current_uiout
Definition ui-out.h:40
const char * paddress(struct gdbarch *gdbarch, CORE_ADDR addr)
Definition utils.c:3166
void gdb_printf(struct ui_file *stream, const char *format,...)
Definition utils.c:1886
void gdb_puts(const char *linebuffer, struct ui_file *stream)
Definition utils.c:1809
#define gdb_stderr
Definition utils.h:187
#define nullptr
Definition x86-cpuid.h:28