GDB (xrefs)

/tmp/gdb-8.1/gdb/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-2018 Free Software Foundation, Inc.
4
5 This file is part of GDB.
6
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
11
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
19
20 #include "defs.h"
21
22 #include "jit.h"
23 #include "jit-reader.h"
24 #include "block.h"
25 #include "breakpoint.h"
26 #include "command.h"
27 #include "dictionary.h"
28 #include "filenames.h"
29 #include "frame-unwind.h"
30 #include "gdbcmd.h"
31 #include "gdbcore.h"
32 #include "inferior.h"
33 #include "observer.h"
34 #include "objfiles.h"
35 #include "regcache.h"
36 #include "symfile.h"
37 #include "symtab.h"
38 #include "target.h"
39 #include "gdb-dlfcn.h"
40 #include <sys/stat.h>
41 #include "gdb_bfd.h"
42 #include "readline/tilde.h"
43 #include "completer.h"
44
45 static const char *jit_reader_dir = NULL;
46
47 static const struct objfile_data *jit_objfile_data;
48
49 static const char *const jit_break_name = "__jit_debug_register_code";
50
51 static const char *const jit_descriptor_name = "__jit_debug_descriptor";
52
53 static const struct program_space_data *jit_program_space_data = NULL;
54
55 static void jit_inferior_init (struct gdbarch *gdbarch);
56 static void jit_inferior_exit_hook (struct inferior *inf);
57
58 /* An unwinder is registered for every gdbarch. This key is used to
59 remember if the unwinder has been registered for a particular
60 gdbarch. */
61
62 static struct gdbarch_data *jit_gdbarch_data;
63
64 /* Non-zero if we want to see trace of jit level stuff. */
65
66 static unsigned int jit_debug = 0;
67
68 static void
69 show_jit_debug (struct ui_file *file, int from_tty,
70 struct cmd_list_element *c, const char *value)
71 {
72 fprintf_filtered (file, _("JIT debugging is %s.\n"), value);
73 }
74
75 struct target_buffer
76 {
77 CORE_ADDR base;
78 ULONGEST size;
79 };
80
81 /* Openning the file is a no-op. */
82
83 static void *
84 mem_bfd_iovec_open (struct bfd *abfd, void *open_closure)
85 {
86 return open_closure;
87 }
88
89 /* Closing the file is just freeing the base/size pair on our side. */
90
91 static int
92 mem_bfd_iovec_close (struct bfd *abfd, void *stream)
93 {
94 xfree (stream);
95
96 /* Zero means success. */
97 return 0;
98 }
99
100 /* For reading the file, we just need to pass through to target_read_memory and
101 fix up the arguments and return values. */
102
103 static file_ptr
104 mem_bfd_iovec_pread (struct bfd *abfd, void *stream, void *buf,
105 file_ptr nbytes, file_ptr offset)
106 {
107 int err;
108 struct target_buffer *buffer = (struct target_buffer *) stream;
109
110 /* If this read will read all of the file, limit it to just the rest. */
111 if (offset + nbytes > buffer->size)
112 nbytes = buffer->size - offset;
113
114 /* If there are no more bytes left, we've reached EOF. */
115 if (nbytes == 0)
116 return 0;
117
118 err = target_read_memory (buffer->base + offset, (gdb_byte *) buf, nbytes);
119 if (err)
120 return -1;
121
122 return nbytes;
123 }
124
125 /* For statting the file, we only support the st_size attribute. */
126
127 static int
128 mem_bfd_iovec_stat (struct bfd *abfd, void *stream, struct stat *sb)
129 {
130 struct target_buffer *buffer = (struct target_buffer*) stream;
131
132 memset (sb, 0, sizeof (struct stat));
133 sb->st_size = buffer->size;
134 return 0;
135 }
136
137 /* Open a BFD from the target's memory. */
138
139 static gdb_bfd_ref_ptr
140 bfd_open_from_target_memory (CORE_ADDR addr, ULONGEST size, char *target)
141 {
142 struct target_buffer *buffer = XNEW (struct target_buffer);
143
144 buffer->base = addr;
145 buffer->size = size;
146 return gdb_bfd_openr_iovec ("<in-memory>", target,
147 mem_bfd_iovec_open,
148 buffer,
149 mem_bfd_iovec_pread,
150 mem_bfd_iovec_close,
151 mem_bfd_iovec_stat);
152 }
153
154 struct jit_reader
155 {
156 jit_reader (struct gdb_reader_funcs *f, gdb_dlhandle_up &&h)
157 : functions (f), handle (std::move (h))
158 {
159 }
160
161 ~jit_reader ()
162 {
163 functions->destroy (functions);
164 }
165
166 DISABLE_COPY_AND_ASSIGN (jit_reader);
167
168 struct gdb_reader_funcs *functions;
169 gdb_dlhandle_up handle;
170 };
171
172 /* One reader that has been loaded successfully, and can potentially be used to
173 parse debug info. */
174
175 static struct jit_reader *loaded_jit_reader = NULL;
176
177 typedef struct gdb_reader_funcs * (reader_init_fn_type) (void);
178 static const char *reader_init_fn_sym = "gdb_init_reader";
179
180 /* Try to load FILE_NAME as a JIT debug info reader. */
181
182 static struct jit_reader *
183 jit_reader_load (const char *file_name)
184 {
185 reader_init_fn_type *init_fn;
186 struct gdb_reader_funcs *funcs = NULL;
187
188 if (jit_debug)
189 fprintf_unfiltered (gdb_stdlog, _("Opening shared object %s.\n"),
190 file_name);
191 gdb_dlhandle_up so = gdb_dlopen (file_name);
192
193 init_fn = (reader_init_fn_type *) gdb_dlsym (so, reader_init_fn_sym);
194 if (!init_fn)
195 error (_("Could not locate initialization function: %s."),
196 reader_init_fn_sym);
197
198 if (gdb_dlsym (so, "plugin_is_GPL_compatible") == NULL)
199 error (_("Reader not GPL compatible."));
200
201 funcs = init_fn ();
202 if (funcs->reader_version != GDB_READER_INTERFACE_VERSION)
203 error (_("Reader version does not match GDB version."));
204
205 return new jit_reader (funcs, std::move (so));
206 }
207
208 /* Provides the jit-reader-load command. */
209
210 static void
211 jit_reader_load_command (const char *args, int from_tty)
212 {
213 if (args == NULL)
214 error (_("No reader name provided."));
215 gdb::unique_xmalloc_ptr<char> file (tilde_expand (args));
216
217 if (loaded_jit_reader != NULL)
218 error (_("JIT reader already loaded. Run jit-reader-unload first."));
219
220 if (!IS_ABSOLUTE_PATH (file.get ()))
221 file.reset (xstrprintf ("%s%s%s", jit_reader_dir, SLASH_STRING,
222 file.get ()));
223
224 loaded_jit_reader = jit_reader_load (file.get ());
225 reinit_frame_cache ();
226 jit_inferior_created_hook ();
227 }
228
229 /* Provides the jit-reader-unload command. */
230
231 static void
232 jit_reader_unload_command (const char *args, int from_tty)
233 {
234 if (!loaded_jit_reader)
235 error (_("No JIT reader loaded."));
236
237 reinit_frame_cache ();
238 jit_inferior_exit_hook (current_inferior ());
239
240 delete loaded_jit_reader;
241 loaded_jit_reader = NULL;
242 }
243
244 /* Per-program space structure recording which objfile has the JIT
245 symbols. */
246
247 struct jit_program_space_data
248 {
249 /* The objfile. This is NULL if no objfile holds the JIT
250 symbols. */
251
252 struct objfile *objfile;
253
254 /* If this program space has __jit_debug_register_code, this is the
255 cached address from the minimal symbol. This is used to detect
256 relocations requiring the breakpoint to be re-created. */
257
258 CORE_ADDR cached_code_address;
259
260 /* This is the JIT event breakpoint, or NULL if it has not been
261 set. */
262
263 struct breakpoint *jit_breakpoint;
264 };
265
266 /* Per-objfile structure recording the addresses in the program space.
267 This object serves two purposes: for ordinary objfiles, it may
268 cache some symbols related to the JIT interface; and for
269 JIT-created objfiles, it holds some information about the
270 jit_code_entry. */
271
272 struct jit_objfile_data
273 {
274 /* Symbol for __jit_debug_register_code. */
275 struct minimal_symbol *register_code;
276
277 /* Symbol for __jit_debug_descriptor. */
278 struct minimal_symbol *descriptor;
279
280 /* Address of struct jit_code_entry in this objfile. This is only
281 non-zero for objfiles that represent code created by the JIT. */
282 CORE_ADDR addr;
283 };
284
285 /* Fetch the jit_objfile_data associated with OBJF. If no data exists
286 yet, make a new structure and attach it. */
287
288 static struct jit_objfile_data *
289 get_jit_objfile_data (struct objfile *objf)
290 {
291 struct jit_objfile_data *objf_data;
292
293 objf_data = (struct jit_objfile_data *) objfile_data (objf, jit_objfile_data);
294 if (objf_data == NULL)
295 {
296 objf_data = XCNEW (struct jit_objfile_data);
297 set_objfile_data (objf, jit_objfile_data, objf_data);
298 }
299
300 return objf_data;
301 }
302
303 /* Remember OBJFILE has been created for struct jit_code_entry located
304 at inferior address ENTRY. */
305
306 static void
307 add_objfile_entry (struct objfile *objfile, CORE_ADDR entry)
308 {
309 struct jit_objfile_data *objf_data;
310
311 objf_data = get_jit_objfile_data (objfile);
312 objf_data->addr = entry;
313 }
314
315 /* Return jit_program_space_data for current program space. Allocate
316 if not already present. */
317
318 static struct jit_program_space_data *
319 get_jit_program_space_data (void)
320 {
321 struct jit_program_space_data *ps_data;
322
323 ps_data
324 = ((struct jit_program_space_data *)
325 program_space_data (current_program_space, jit_program_space_data));
326 if (ps_data == NULL)
327 {
328 ps_data = XCNEW (struct jit_program_space_data);
329 set_program_space_data (current_program_space, jit_program_space_data,
330 ps_data);
331 }
332
333 return ps_data;
334 }
335
336 static void
337 jit_program_space_data_cleanup (struct program_space *ps, void *arg)
338 {
339 xfree (arg);
340 }
341
342 /* Helper function for reading the global JIT descriptor from remote
343 memory. Returns 1 if all went well, 0 otherwise. */
344
345 static int
346 jit_read_descriptor (struct gdbarch *gdbarch,
347 struct jit_descriptor *descriptor,
348 struct jit_program_space_data *ps_data)
349 {
350 int err;
351 struct type *ptr_type;
352 int ptr_size;
353 int desc_size;
354 gdb_byte *desc_buf;
355 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
356 struct jit_objfile_data *objf_data;
357
358 if (ps_data->objfile == NULL)
359 return 0;
360 objf_data = get_jit_objfile_data (ps_data->objfile);
361 if (objf_data->descriptor == NULL)
362 return 0;
363
364 if (jit_debug)
365 fprintf_unfiltered (gdb_stdlog,
366 "jit_read_descriptor, descriptor_addr = %s\n",
367 paddress (gdbarch, MSYMBOL_VALUE_ADDRESS (ps_data->objfile,
368 objf_data->descriptor)));
369
370 /* Figure out how big the descriptor is on the remote and how to read it. */
371 ptr_type = builtin_type (gdbarch)->builtin_data_ptr;
372 ptr_size = TYPE_LENGTH (ptr_type);
373 desc_size = 8 + 2 * ptr_size; /* Two 32-bit ints and two pointers. */
374 desc_buf = (gdb_byte *) alloca (desc_size);
375
376 /* Read the descriptor. */
377 err = target_read_memory (MSYMBOL_VALUE_ADDRESS (ps_data->objfile,
378 objf_data->descriptor),
379 desc_buf, desc_size);
380 if (err)
381 {
382 printf_unfiltered (_("Unable to read JIT descriptor from "
383 "remote memory\n"));
384 return 0;
385 }
386
387 /* Fix the endianness to match the host. */
388 descriptor->version = extract_unsigned_integer (&desc_buf[0], 4, byte_order);
389 descriptor->action_flag =
390 extract_unsigned_integer (&desc_buf[4], 4, byte_order);
391 descriptor->relevant_entry = extract_typed_address (&desc_buf[8], ptr_type);
392 descriptor->first_entry =
393 extract_typed_address (&desc_buf[8 + ptr_size], ptr_type);
394
395 return 1;
396 }
397
398 /* Helper function for reading a JITed code entry from remote memory. */
399
400 static void
401 jit_read_code_entry (struct gdbarch *gdbarch,
402 CORE_ADDR code_addr, struct jit_code_entry *code_entry)
403 {
404 int err, off;
405 struct type *ptr_type;
406 int ptr_size;
407 int entry_size;
408 int align_bytes;
409 gdb_byte *entry_buf;
410 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
411
412 /* Figure out how big the entry is on the remote and how to read it. */
413 ptr_type = builtin_type (gdbarch)->builtin_data_ptr;
414 ptr_size = TYPE_LENGTH (ptr_type);
415
416 /* Figure out where the longlong value will be. */
417 align_bytes = gdbarch_long_long_align_bit (gdbarch) / 8;
418 off = 3 * ptr_size;
419 off = (off + (align_bytes - 1)) & ~(align_bytes - 1);
420
421 entry_size = off + 8; /* Three pointers and one 64-bit int. */
422 entry_buf = (gdb_byte *) alloca (entry_size);
423
424 /* Read the entry. */
425 err = target_read_memory (code_addr, entry_buf, entry_size);
426 if (err)
427 error (_("Unable to read JIT code entry from remote memory!"));
428
429 /* Fix the endianness to match the host. */
430 ptr_type = builtin_type (gdbarch)->builtin_data_ptr;
431 code_entry->next_entry = extract_typed_address (&entry_buf[0], ptr_type);
432 code_entry->prev_entry =
433 extract_typed_address (&entry_buf[ptr_size], ptr_type);
434 code_entry->symfile_addr =
435 extract_typed_address (&entry_buf[2 * ptr_size], ptr_type);
436 code_entry->symfile_size =
437 extract_unsigned_integer (&entry_buf[off], 8, byte_order);
438 }
439
440 /* Proxy object for building a block. */
441
442 struct gdb_block
443 {
444 /* gdb_blocks are linked into a tree structure. Next points to the
445 next node at the same depth as this block and parent to the
446 parent gdb_block. */
447 struct gdb_block *next, *parent;
448
449 /* Points to the "real" block that is being built out of this
450 instance. This block will be added to a blockvector, which will
451 then be added to a symtab. */
452 struct block *real_block;
453
454 /* The first and last code address corresponding to this block. */
455 CORE_ADDR begin, end;
456
457 /* The name of this block (if any). If this is non-NULL, the
458 FUNCTION symbol symbol is set to this value. */
459 const char *name;
460 };
461
462 /* Proxy object for building a symtab. */
463
464 struct gdb_symtab
465 {
466 /* The list of blocks in this symtab. These will eventually be
467 converted to real blocks. */
468 struct gdb_block *blocks;
469
470 /* The number of blocks inserted. */
471 int nblocks;
472
473 /* A mapping between line numbers to PC. */
474 struct linetable *linetable;
475
476 /* The source file for this symtab. */
477 const char *file_name;
478 struct gdb_symtab *next;
479 };
480
481 /* Proxy object for building an object. */
482
483 struct gdb_object
484 {
485 struct gdb_symtab *symtabs;
486 };
487
488 /* The type of the `private' data passed around by the callback
489 functions. */
490
491 typedef CORE_ADDR jit_dbg_reader_data;
492
493 /* The reader calls into this function to read data off the targets
494 address space. */
495
496 static enum gdb_status
497 jit_target_read_impl (GDB_CORE_ADDR target_mem, void *gdb_buf, int len)
498 {
499 int result = target_read_memory ((CORE_ADDR) target_mem,
500 (gdb_byte *) gdb_buf, len);
501 if (result == 0)
502 return GDB_SUCCESS;
503 else
504 return GDB_FAIL;
505 }
506
507 /* The reader calls into this function to create a new gdb_object
508 which it can then pass around to the other callbacks. Right now,
509 all that is required is allocating the memory. */
510
511 static struct gdb_object *
512 jit_object_open_impl (struct gdb_symbol_callbacks *cb)
513 {
514 /* CB is not required right now, but sometime in the future we might
515 need a handle to it, and we'd like to do that without breaking
516 the ABI. */
517 return XCNEW (struct gdb_object);
518 }
519
520 /* Readers call into this function to open a new gdb_symtab, which,
521 again, is passed around to other callbacks. */
522
523 static struct gdb_symtab *
524 jit_symtab_open_impl (struct gdb_symbol_callbacks *cb,
525 struct gdb_object *object,
526 const char *file_name)
527 {
528 struct gdb_symtab *ret;
529
530 /* CB stays unused. See comment in jit_object_open_impl. */
531
532 ret = XCNEW (struct gdb_symtab);
533 ret->file_name = file_name ? xstrdup (file_name) : xstrdup ("");
534 ret->next = object->symtabs;
535 object->symtabs = ret;
536 return ret;
537 }
538
539 /* Returns true if the block corresponding to old should be placed
540 before the block corresponding to new in the final blockvector. */
541
542 static int
543 compare_block (const struct gdb_block *const old,
544 const struct gdb_block *const newobj)
545 {
546 if (old == NULL)
547 return 1;
548 if (old->begin < newobj->begin)
549 return 1;
550 else if (old->begin == newobj->begin)
551 {
552 if (old->end > newobj->end)
553 return 1;
554 else
555 return 0;
556 }
557 else
558 return 0;
559 }
560
561 /* Called by readers to open a new gdb_block. This function also
562 inserts the new gdb_block in the correct place in the corresponding
563 gdb_symtab. */
564
565 static struct gdb_block *
566 jit_block_open_impl (struct gdb_symbol_callbacks *cb,
567 struct gdb_symtab *symtab, struct gdb_block *parent,
568 GDB_CORE_ADDR begin, GDB_CORE_ADDR end, const char *name)
569 {
570 struct gdb_block *block = XCNEW (struct gdb_block);
571
572 block->next = symtab->blocks;
573 block->begin = (CORE_ADDR) begin;
574 block->end = (CORE_ADDR) end;
575 block->name = name ? xstrdup (name) : NULL;
576 block->parent = parent;
577
578 /* Ensure that the blocks are inserted in the correct (reverse of
579 the order expected by blockvector). */
580 if (compare_block (symtab->blocks, block))
581 {
582 symtab->blocks = block;
583 }
584 else
585 {
586 struct gdb_block *i = symtab->blocks;
587
588 for (;; i = i->next)
589 {
590 /* Guaranteed to terminate, since compare_block (NULL, _)
591 returns 1. */
592 if (compare_block (i->next, block))
593 {
594 block->next = i->next;
595 i->next = block;
596 break;
597 }
598 }
599 }
600 symtab->nblocks++;
601
602 return block;
603 }
604
605 /* Readers call this to add a line mapping (from PC to line number) to
606 a gdb_symtab. */
607
608 static void
609 jit_symtab_line_mapping_add_impl (struct gdb_symbol_callbacks *cb,
610 struct gdb_symtab *stab, int nlines,
611 struct gdb_line_mapping *map)
612 {
613 int i;
614 int alloc_len;
615
616 if (nlines < 1)
617 return;
618
619 alloc_len = sizeof (struct linetable)
620 + (nlines - 1) * sizeof (struct linetable_entry);
621 stab->linetable = (struct linetable *) xmalloc (alloc_len);
622 stab->linetable->nitems = nlines;
623 for (i = 0; i < nlines; i++)
624 {
625 stab->linetable->item[i].pc = (CORE_ADDR) map[i].pc;
626 stab->linetable->item[i].line = map[i].line;
627 }
628 }
629
630 /* Called by readers to close a gdb_symtab. Does not need to do
631 anything as of now. */
632
633 static void
634 jit_symtab_close_impl (struct gdb_symbol_callbacks *cb,
635 struct gdb_symtab *stab)
636 {
637 /* Right now nothing needs to be done here. We may need to do some
638 cleanup here in the future (again, without breaking the plugin
639 ABI). */
640 }
641
642 /* Transform STAB to a proper symtab, and add it it OBJFILE. */
643
644 static void
645 finalize_symtab (struct gdb_symtab *stab, struct objfile *objfile)
646 {
647 struct compunit_symtab *cust;
648 struct gdb_block *gdb_block_iter, *gdb_block_iter_tmp;
649 struct block *block_iter;
650 int actual_nblocks, i;
651 size_t blockvector_size;
652 CORE_ADDR begin, end;
653 struct blockvector *bv;
654 enum language language;
655
656 actual_nblocks = FIRST_LOCAL_BLOCK + stab->nblocks;
657
658 cust = allocate_compunit_symtab (objfile, stab->file_name);
659 allocate_symtab (cust, stab->file_name);
660 add_compunit_symtab_to_objfile (cust);
661 language = compunit_language (cust);
662
663 /* JIT compilers compile in memory. */
664 COMPUNIT_DIRNAME (cust) = NULL;
665
666 /* Copy over the linetable entry if one was provided. */
667 if (stab->linetable)
668 {
669 size_t size = ((stab->linetable->nitems - 1)
670 * sizeof (struct linetable_entry)
671 + sizeof (struct linetable));
672 SYMTAB_LINETABLE (COMPUNIT_FILETABS (cust))
673 = (struct linetable *) obstack_alloc (&objfile->objfile_obstack, size);
674 memcpy (SYMTAB_LINETABLE (COMPUNIT_FILETABS (cust)), stab->linetable,
675 size);
676 }
677
678 blockvector_size = (sizeof (struct blockvector)
679 + (actual_nblocks - 1) * sizeof (struct block *));
680 bv = (struct blockvector *) obstack_alloc (&objfile->objfile_obstack,
681 blockvector_size);
682 COMPUNIT_BLOCKVECTOR (cust) = bv;
683
684 /* (begin, end) will contain the PC range this entire blockvector
685 spans. */
686 BLOCKVECTOR_MAP (bv) = NULL;
687 begin = stab->blocks->begin;
688 end = stab->blocks->end;
689 BLOCKVECTOR_NBLOCKS (bv) = actual_nblocks;
690
691 /* First run over all the gdb_block objects, creating a real block
692 object for each. Simultaneously, keep setting the real_block
693 fields. */
694 for (i = (actual_nblocks - 1), gdb_block_iter = stab->blocks;
695 i >= FIRST_LOCAL_BLOCK;
696 i--, gdb_block_iter = gdb_block_iter->next)
697 {
698 struct block *new_block = allocate_block (&objfile->objfile_obstack);
699 struct symbol *block_name = allocate_symbol (objfile);
700 struct type *block_type = arch_type (get_objfile_arch (objfile),
701 TYPE_CODE_VOID,
702 TARGET_CHAR_BIT,
703 "void");
704
705 BLOCK_DICT (new_block) = dict_create_linear (&objfile->objfile_obstack,
706 language, NULL);
707 /* The address range. */
708 BLOCK_START (new_block) = (CORE_ADDR) gdb_block_iter->begin;
709 BLOCK_END (new_block) = (CORE_ADDR) gdb_block_iter->end;
710
711 /* The name. */
712 SYMBOL_DOMAIN (block_name) = VAR_DOMAIN;
713 SYMBOL_ACLASS_INDEX (block_name) = LOC_BLOCK;
714 symbol_set_symtab (block_name, COMPUNIT_FILETABS (cust));
715 SYMBOL_TYPE (block_name) = lookup_function_type (block_type);
716 SYMBOL_BLOCK_VALUE (block_name) = new_block;
717
718 block_name->ginfo.name
719 = (const char *) obstack_copy0 (&objfile->objfile_obstack,
720 gdb_block_iter->name,
721 strlen (gdb_block_iter->name));
722
723 BLOCK_FUNCTION (new_block) = block_name;
724
725 BLOCKVECTOR_BLOCK (bv, i) = new_block;
726 if (begin > BLOCK_START (new_block))
727 begin = BLOCK_START (new_block);
728 if (end < BLOCK_END (new_block))
729 end = BLOCK_END (new_block);
730
731 gdb_block_iter->real_block = new_block;
732 }
733
734 /* Now add the special blocks. */
735 block_iter = NULL;
736 for (i = 0; i < FIRST_LOCAL_BLOCK; i++)
737 {
738 struct block *new_block;
739
740 new_block = (i == GLOBAL_BLOCK
741 ? allocate_global_block (&objfile->objfile_obstack)
742 : allocate_block (&objfile->objfile_obstack));
743 BLOCK_DICT (new_block) = dict_create_linear (&objfile->objfile_obstack,
744 language, NULL);
745 BLOCK_SUPERBLOCK (new_block) = block_iter;
746 block_iter = new_block;
747
748 BLOCK_START (new_block) = (CORE_ADDR) begin;
749 BLOCK_END (new_block) = (CORE_ADDR) end;
750
751 BLOCKVECTOR_BLOCK (bv, i) = new_block;
752
753 if (i == GLOBAL_BLOCK)
754 set_block_compunit_symtab (new_block, cust);
755 }
756
757 /* Fill up the superblock fields for the real blocks, using the
758 real_block fields populated earlier. */
759 for (gdb_block_iter = stab->blocks;
760 gdb_block_iter;
761 gdb_block_iter = gdb_block_iter->next)
762 {
763 if (gdb_block_iter->parent != NULL)
764 {
765 /* If the plugin specifically mentioned a parent block, we
766 use that. */
767 BLOCK_SUPERBLOCK (gdb_block_iter->real_block) =
768 gdb_block_iter->parent->real_block;
769 }
770 else
771 {
772 /* And if not, we set a default parent block. */
773 BLOCK_SUPERBLOCK (gdb_block_iter->real_block) =
774 BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK);
775 }
776 }
777
778 /* Free memory. */
779 gdb_block_iter = stab->blocks;
780
781 for (gdb_block_iter = stab->blocks, gdb_block_iter_tmp = gdb_block_iter->next;
782 gdb_block_iter;
783 gdb_block_iter = gdb_block_iter_tmp)
784 {
785 xfree ((void *) gdb_block_iter->name);
786 xfree (gdb_block_iter);
787 }
788 xfree (stab->linetable);
789 xfree ((char *) stab->file_name);
790 xfree (stab);
791 }
792
793 /* Called when closing a gdb_objfile. Converts OBJ to a proper
794 objfile. */
795
796 static void
797 jit_object_close_impl (struct gdb_symbol_callbacks *cb,
798 struct gdb_object *obj)
799 {
800 struct gdb_symtab *i, *j;
801 struct objfile *objfile;
802 jit_dbg_reader_data *priv_data;
803
804 priv_data = (jit_dbg_reader_data *) cb->priv_data;
805
806 objfile = new struct objfile (NULL, "<< JIT compiled code >>",
807 OBJF_NOT_FILENAME);
808 objfile->per_bfd->gdbarch = target_gdbarch ();
809
810 terminate_minimal_symbol_table (objfile);
811
812 j = NULL;
813 for (i = obj->symtabs; i; i = j)
814 {
815 j = i->next;
816 finalize_symtab (i, objfile);
817 }
818 add_objfile_entry (objfile, *priv_data);
819 xfree (obj);
820 }
821
822 /* Try to read CODE_ENTRY using the loaded jit reader (if any).
823 ENTRY_ADDR is the address of the struct jit_code_entry in the
824 inferior address space. */
825
826 static int
827 jit_reader_try_read_symtab (struct jit_code_entry *code_entry,
828 CORE_ADDR entry_addr)
829 {
830 gdb_byte *gdb_mem;
831 int status;
832 jit_dbg_reader_data priv_data;
833 struct gdb_reader_funcs *funcs;
834 struct gdb_symbol_callbacks callbacks =
835 {
836 jit_object_open_impl,
837 jit_symtab_open_impl,
838 jit_block_open_impl,
839 jit_symtab_close_impl,
840 jit_object_close_impl,
841
842 jit_symtab_line_mapping_add_impl,
843 jit_target_read_impl,
844
845 &priv_data
846 };
847
848 priv_data = entry_addr;
849
850 if (!loaded_jit_reader)
851 return 0;
852
853 gdb_mem = (gdb_byte *) xmalloc (code_entry->symfile_size);
854
855 status = 1;
856 TRY
857 {
858 if (target_read_memory (code_entry->symfile_addr, gdb_mem,
859 code_entry->symfile_size))
860 status = 0;
861 }
862 CATCH (e, RETURN_MASK_ALL)
863 {
864 status = 0;
865 }
866 END_CATCH
867
868 if (status)
869 {
870 funcs = loaded_jit_reader->functions;
871 if (funcs->read (funcs, &callbacks, gdb_mem, code_entry->symfile_size)
872 != GDB_SUCCESS)
873 status = 0;
874 }
875
876 xfree (gdb_mem);
877 if (jit_debug && status == 0)
878 fprintf_unfiltered (gdb_stdlog,
879 "Could not read symtab using the loaded JIT reader.\n");
880 return status;
881 }
882
883 /* Try to read CODE_ENTRY using BFD. ENTRY_ADDR is the address of the
884 struct jit_code_entry in the inferior address space. */
885
886 static void
887 jit_bfd_try_read_symtab (struct jit_code_entry *code_entry,
888 CORE_ADDR entry_addr,
889 struct gdbarch *gdbarch)
890 {
891 struct section_addr_info *sai;
892 struct bfd_section *sec;
893 struct objfile *objfile;
894 struct cleanup *old_cleanups;
895 int i;
896 const struct bfd_arch_info *b;
897
898 if (jit_debug)
899 fprintf_unfiltered (gdb_stdlog,
900 "jit_register_code, symfile_addr = %s, "
901 "symfile_size = %s\n",
902 paddress (gdbarch, code_entry->symfile_addr),
903 pulongest (code_entry->symfile_size));
904
905 gdb_bfd_ref_ptr nbfd (bfd_open_from_target_memory (code_entry->symfile_addr,
906 code_entry->symfile_size,
907 gnutarget));
908 if (nbfd == NULL)
909 {
910 puts_unfiltered (_("Error opening JITed symbol file, ignoring it.\n"));
911 return;
912 }
913
914 /* Check the format. NOTE: This initializes important data that GDB uses!
915 We would segfault later without this line. */
916 if (!bfd_check_format (nbfd.get (), bfd_object))
917 {
918 printf_unfiltered (_("\
919 JITed symbol file is not an object file, ignoring it.\n"));
920 return;
921 }
922
923 /* Check bfd arch. */
924 b = gdbarch_bfd_arch_info (gdbarch);
925 if (b->compatible (b, bfd_get_arch_info (nbfd.get ())) != b)
926 warning (_("JITed object file architecture %s is not compatible "
927 "with target architecture %s."),
928 bfd_get_arch_info (nbfd.get ())->printable_name,
929 b->printable_name);
930
931 /* Read the section address information out of the symbol file. Since the
932 file is generated by the JIT at runtime, it should all of the absolute
933 addresses that we care about. */
934 sai = alloc_section_addr_info (bfd_count_sections (nbfd.get ()));
935 old_cleanups = make_cleanup_free_section_addr_info (sai);
936 i = 0;
937 for (sec = nbfd->sections; sec != NULL; sec = sec->next)
938 if ((bfd_get_section_flags (nbfd.get (), sec) & (SEC_ALLOC|SEC_LOAD)) != 0)
939 {
940 /* We assume that these virtual addresses are absolute, and do not
941 treat them as offsets. */
942 sai->other[i].addr = bfd_get_section_vma (nbfd.get (), sec);
943 sai->other[i].name = xstrdup (bfd_get_section_name (nbfd.get (), sec));
944 sai->other[i].sectindex = sec->index;
945 ++i;
946 }
947 sai->num_sections = i;
948
949 /* This call does not take ownership of SAI. */
950 objfile = symbol_file_add_from_bfd (nbfd.get (),
951 bfd_get_filename (nbfd.get ()), 0, sai,
952 OBJF_SHARED | OBJF_NOT_FILENAME, NULL);
953
954 do_cleanups (old_cleanups);
955 add_objfile_entry (objfile, entry_addr);
956 }
957
958 /* This function registers code associated with a JIT code entry. It uses the
959 pointer and size pair in the entry to read the symbol file from the remote
960 and then calls symbol_file_add_from_local_memory to add it as though it were
961 a symbol file added by the user. */
962
963 static void
964 jit_register_code (struct gdbarch *gdbarch,
965 CORE_ADDR entry_addr, struct jit_code_entry *code_entry)
966 {
967 int success;
968
969 if (jit_debug)
970 fprintf_unfiltered (gdb_stdlog,
971 "jit_register_code, symfile_addr = %s, "
972 "symfile_size = %s\n",
973 paddress (gdbarch, code_entry->symfile_addr),
974 pulongest (code_entry->symfile_size));
975
976 success = jit_reader_try_read_symtab (code_entry, entry_addr);
977
978 if (!success)
979 jit_bfd_try_read_symtab (code_entry, entry_addr, gdbarch);
980 }
981
982 /* This function unregisters JITed code and frees the corresponding
983 objfile. */
984
985 static void
986 jit_unregister_code (struct objfile *objfile)
987 {
988 delete objfile;
989 }
990
991 /* Look up the objfile with this code entry address. */
992
993 static struct objfile *
994 jit_find_objf_with_entry_addr (CORE_ADDR entry_addr)
995 {
996 struct objfile *objf;
997
998 ALL_OBJFILES (objf)
999 {
1000 struct jit_objfile_data *objf_data;
1001
1002 objf_data
1003 = (struct jit_objfile_data *) objfile_data (objf, jit_objfile_data);
1004 if (objf_data != NULL && objf_data->addr == entry_addr)
1005 return objf;
1006 }
1007 return NULL;
1008 }
1009
1010 /* This is called when a breakpoint is deleted. It updates the
1011 inferior's cache, if needed. */
1012
1013 static void
1014 jit_breakpoint_deleted (struct breakpoint *b)
1015 {
1016 struct bp_location *iter;
1017
1018 if (b->type != bp_jit_event)
1019 return;
1020
1021 for (iter = b->loc; iter != NULL; iter = iter->next)
1022 {
1023 struct jit_program_space_data *ps_data;
1024
1025 ps_data = ((struct jit_program_space_data *)
1026 program_space_data (iter->pspace, jit_program_space_data));
1027 if (ps_data != NULL && ps_data->jit_breakpoint == iter->owner)
1028 {
1029 ps_data->cached_code_address = 0;
1030 ps_data->jit_breakpoint = NULL;
1031 }
1032 }
1033 }
1034
1035 /* (Re-)Initialize the jit breakpoint if necessary.
1036 Return 0 if the jit breakpoint has been successfully initialized. */
1037
1038 static int
1039 jit_breakpoint_re_set_internal (struct gdbarch *gdbarch,
1040 struct jit_program_space_data *ps_data)
1041 {
1042 struct bound_minimal_symbol reg_symbol;
1043 struct bound_minimal_symbol desc_symbol;
1044 struct jit_objfile_data *objf_data;
1045 CORE_ADDR addr;
1046
1047 if (ps_data->objfile == NULL)
1048 {
1049 /* Lookup the registration symbol. If it is missing, then we
1050 assume we are not attached to a JIT. */
1051 reg_symbol = lookup_minimal_symbol_and_objfile (jit_break_name);
1052 if (reg_symbol.minsym == NULL
1053 || BMSYMBOL_VALUE_ADDRESS (reg_symbol) == 0)
1054 return 1;
1055
1056 desc_symbol = lookup_minimal_symbol (jit_descriptor_name, NULL,
1057 reg_symbol.objfile);
1058 if (desc_symbol.minsym == NULL
1059 || BMSYMBOL_VALUE_ADDRESS (desc_symbol) == 0)
1060 return 1;
1061
1062 objf_data = get_jit_objfile_data (reg_symbol.objfile);
1063 objf_data->register_code = reg_symbol.minsym;
1064 objf_data->descriptor = desc_symbol.minsym;
1065
1066 ps_data->objfile = reg_symbol.objfile;
1067 }
1068 else
1069 objf_data = get_jit_objfile_data (ps_data->objfile);
1070
1071 addr = MSYMBOL_VALUE_ADDRESS (ps_data->objfile, objf_data->register_code);
1072
1073 if (jit_debug)
1074 fprintf_unfiltered (gdb_stdlog,
1075 "jit_breakpoint_re_set_internal, "
1076 "breakpoint_addr = %s\n",
1077 paddress (gdbarch, addr));
1078
1079 if (ps_data->cached_code_address == addr)
1080 return 0;
1081
1082 /* Delete the old breakpoint. */
1083 if (ps_data->jit_breakpoint != NULL)
1084 delete_breakpoint (ps_data->jit_breakpoint);
1085
1086 /* Put a breakpoint in the registration symbol. */
1087 ps_data->cached_code_address = addr;
1088 ps_data->jit_breakpoint = create_jit_event_breakpoint (gdbarch, addr);
1089
1090 return 0;
1091 }
1092
1093 /* The private data passed around in the frame unwind callback
1094 functions. */
1095
1096 struct jit_unwind_private
1097 {
1098 /* Cached register values. See jit_frame_sniffer to see how this
1099 works. */
1100 struct regcache *regcache;
1101
1102 /* The frame being unwound. */
1103 struct frame_info *this_frame;
1104 };
1105
1106 /* Sets the value of a particular register in this frame. */
1107
1108 static void
1109 jit_unwind_reg_set_impl (struct gdb_unwind_callbacks *cb, int dwarf_regnum,
1110 struct gdb_reg_value *value)
1111 {
1112 struct jit_unwind_private *priv;
1113 int gdb_reg;
1114
1115 priv = (struct jit_unwind_private *) cb->priv_data;
1116
1117 gdb_reg = gdbarch_dwarf2_reg_to_regnum (get_frame_arch (priv->this_frame),
1118 dwarf_regnum);
1119 if (gdb_reg == -1)
1120 {
1121 if (jit_debug)
1122 fprintf_unfiltered (gdb_stdlog,
1123 _("Could not recognize DWARF regnum %d"),
1124 dwarf_regnum);
1125 value->free (value);
1126 return;
1127 }
1128
1129 regcache_raw_set_cached_value (priv->regcache, gdb_reg, value->value);
1130 value->free (value);
1131 }
1132
1133 static void
1134 reg_value_free_impl (struct gdb_reg_value *value)
1135 {
1136 xfree (value);
1137 }
1138
1139 /* Get the value of register REGNUM in the previous frame. */
1140
1141 static struct gdb_reg_value *
1142 jit_unwind_reg_get_impl (struct gdb_unwind_callbacks *cb, int regnum)
1143 {
1144 struct jit_unwind_private *priv;
1145 struct gdb_reg_value *value;
1146 int gdb_reg, size;
1147 struct gdbarch *frame_arch;
1148
1149 priv = (struct jit_unwind_private *) cb->priv_data;
1150 frame_arch = get_frame_arch (priv->this_frame);
1151
1152 gdb_reg = gdbarch_dwarf2_reg_to_regnum (frame_arch, regnum);
1153 size = register_size (frame_arch, gdb_reg);
1154 value = ((struct gdb_reg_value *)
1155 xmalloc (sizeof (struct gdb_reg_value) + size - 1));
1156 value->defined = deprecated_frame_register_read (priv->this_frame, gdb_reg,
1157 value->value);
1158 value->size = size;
1159 value->free = reg_value_free_impl;
1160 return value;
1161 }
1162
1163 /* gdb_reg_value has a free function, which must be called on each
1164 saved register value. */
1165
1166 static void
1167 jit_dealloc_cache (struct frame_info *this_frame, void *cache)
1168 {
1169 struct jit_unwind_private *priv_data = (struct jit_unwind_private *) cache;
1170
1171 gdb_assert (priv_data->regcache != NULL);
1172 delete priv_data->regcache;
1173 xfree (priv_data);
1174 }
1175
1176 /* The frame sniffer for the pseudo unwinder.
1177
1178 While this is nominally a frame sniffer, in the case where the JIT
1179 reader actually recognizes the frame, it does a lot more work -- it
1180 unwinds the frame and saves the corresponding register values in
1181 the cache. jit_frame_prev_register simply returns the saved
1182 register values. */
1183
1184 static int
1185 jit_frame_sniffer (const struct frame_unwind *self,
1186 struct frame_info *this_frame, void **cache)
1187 {
1188 struct jit_unwind_private *priv_data;
1189 struct gdb_unwind_callbacks callbacks;
1190 struct gdb_reader_funcs *funcs;
1191 struct gdbarch *gdbarch;
1192
1193 callbacks.reg_get = jit_unwind_reg_get_impl;
1194 callbacks.reg_set = jit_unwind_reg_set_impl;
1195 callbacks.target_read = jit_target_read_impl;
1196
1197 if (loaded_jit_reader == NULL)
1198 return 0;
1199
1200 funcs = loaded_jit_reader->functions;
1201
1202 gdb_assert (!*cache);
1203
1204 gdbarch = get_frame_arch (this_frame);
1205
1206 *cache = XCNEW (struct jit_unwind_private);
1207 priv_data = (struct jit_unwind_private *) *cache;
1208 priv_data->regcache = new regcache (gdbarch);
1209 priv_data->this_frame = this_frame;
1210
1211 callbacks.priv_data = priv_data;
1212
1213 /* Try to coax the provided unwinder to unwind the stack */
1214 if (funcs->unwind (funcs, &callbacks) == GDB_SUCCESS)
1215 {
1216 if (jit_debug)
1217 fprintf_unfiltered (gdb_stdlog, _("Successfully unwound frame using "
1218 "JIT reader.\n"));
1219 return 1;
1220 }
1221 if (jit_debug)
1222 fprintf_unfiltered (gdb_stdlog, _("Could not unwind frame using "
1223 "JIT reader.\n"));
1224
1225 jit_dealloc_cache (this_frame, *cache);
1226 *cache = NULL;
1227
1228 return 0;
1229 }
1230
1231
1232 /* The frame_id function for the pseudo unwinder. Relays the call to
1233 the loaded plugin. */
1234
1235 static void
1236 jit_frame_this_id (struct frame_info *this_frame, void **cache,
1237 struct frame_id *this_id)
1238 {
1239 struct jit_unwind_private priv;
1240 struct gdb_frame_id frame_id;
1241 struct gdb_reader_funcs *funcs;
1242 struct gdb_unwind_callbacks callbacks;
1243
1244 priv.regcache = NULL;
1245 priv.this_frame = this_frame;
1246
1247 /* We don't expect the frame_id function to set any registers, so we
1248 set reg_set to NULL. */
1249 callbacks.reg_get = jit_unwind_reg_get_impl;
1250 callbacks.reg_set = NULL;
1251 callbacks.target_read = jit_target_read_impl;
1252 callbacks.priv_data = &priv;
1253
1254 gdb_assert (loaded_jit_reader);
1255 funcs = loaded_jit_reader->functions;
1256
1257 frame_id = funcs->get_frame_id (funcs, &callbacks);
1258 *this_id = frame_id_build (frame_id.stack_address, frame_id.code_address);
1259 }
1260
1261 /* Pseudo unwinder function. Reads the previously fetched value for
1262 the register from the cache. */
1263
1264 static struct value *
1265 jit_frame_prev_register (struct frame_info *this_frame, void **cache, int reg)
1266 {
1267 struct jit_unwind_private *priv = (struct jit_unwind_private *) *cache;
1268 struct gdbarch *gdbarch;
1269
1270 if (priv == NULL)
1271 return frame_unwind_got_optimized (this_frame, reg);
1272
1273 gdbarch = priv->regcache->arch ();
1274 if (reg < gdbarch_num_regs (gdbarch))
1275 {
1276 gdb_byte *buf = (gdb_byte *) alloca (register_size (gdbarch, reg));
1277 enum register_status status;
1278
1279 status = regcache_raw_read (priv->regcache, reg, buf);
1280 if (status == REG_VALID)
1281 return frame_unwind_got_bytes (this_frame, reg, buf);
1282 else
1283 return frame_unwind_got_optimized (this_frame, reg);
1284 }
1285 else
1286 return gdbarch_pseudo_register_read_value (gdbarch, priv->regcache, reg);
1287 }
1288
1289 /* Relay everything back to the unwinder registered by the JIT debug
1290 info reader.*/
1291
1292 static const struct frame_unwind jit_frame_unwind =
1293 {
1294 NORMAL_FRAME,
1295 default_frame_unwind_stop_reason,
1296 jit_frame_this_id,
1297 jit_frame_prev_register,
1298 NULL,
1299 jit_frame_sniffer,
1300 jit_dealloc_cache
1301 };
1302
1303
1304 /* This is the information that is stored at jit_gdbarch_data for each
1305 architecture. */
1306
1307 struct jit_gdbarch_data_type
1308 {
1309 /* Has the (pseudo) unwinder been prepended? */
1310 int unwinder_registered;
1311 };
1312
1313 /* Check GDBARCH and prepend the pseudo JIT unwinder if needed. */
1314
1315 static void
1316 jit_prepend_unwinder (struct gdbarch *gdbarch)
1317 {
1318 struct jit_gdbarch_data_type *data;
1319
1320 data
1321 = (struct jit_gdbarch_data_type *) gdbarch_data (gdbarch, jit_gdbarch_data);
1322 if (!data->unwinder_registered)
1323 {
1324 frame_unwind_prepend_unwinder (gdbarch, &jit_frame_unwind);
1325 data->unwinder_registered = 1;
1326 }
1327 }
1328
1329 /* Register any already created translations. */
1330
1331 static void
1332 jit_inferior_init (struct gdbarch *gdbarch)
1333 {
1334 struct jit_descriptor descriptor;
1335 struct jit_code_entry cur_entry;
1336 struct jit_program_space_data *ps_data;
1337 CORE_ADDR cur_entry_addr;
1338
1339 if (jit_debug)
1340 fprintf_unfiltered (gdb_stdlog, "jit_inferior_init\n");
1341
1342 jit_prepend_unwinder (gdbarch);
1343
1344 ps_data = get_jit_program_space_data ();
1345 if (jit_breakpoint_re_set_internal (gdbarch, ps_data) != 0)
1346 return;
1347
1348 /* Read the descriptor so we can check the version number and load
1349 any already JITed functions. */
1350 if (!jit_read_descriptor (gdbarch, &descriptor, ps_data))
1351 return;
1352
1353 /* Check that the version number agrees with that we support. */
1354 if (descriptor.version != 1)
1355 {
1356 printf_unfiltered (_("Unsupported JIT protocol version %ld "
1357 "in descriptor (expected 1)\n"),
1358 (long) descriptor.version);
1359 return;
1360 }
1361
1362 /* If we've attached to a running program, we need to check the descriptor
1363 to register any functions that were already generated. */
1364 for (cur_entry_addr = descriptor.first_entry;
1365 cur_entry_addr != 0;
1366 cur_entry_addr = cur_entry.next_entry)
1367 {
1368 jit_read_code_entry (gdbarch, cur_entry_addr, &cur_entry);
1369
1370 /* This hook may be called many times during setup, so make sure we don't
1371 add the same symbol file twice. */
1372 if (jit_find_objf_with_entry_addr (cur_entry_addr) != NULL)
1373 continue;
1374
1375 jit_register_code (gdbarch, cur_entry_addr, &cur_entry);
1376 }
1377 }
1378
1379 /* inferior_created observer. */
1380
1381 static void
1382 jit_inferior_created (struct target_ops *ops, int from_tty)
1383 {
1384 jit_inferior_created_hook ();
1385 }
1386
1387 /* Exported routine to call when an inferior has been created. */
1388
1389 void
1390 jit_inferior_created_hook (void)
1391 {
1392 jit_inferior_init (target_gdbarch ());
1393 }
1394
1395 /* Exported routine to call to re-set the jit breakpoints,
1396 e.g. when a program is rerun. */
1397
1398 void
1399 jit_breakpoint_re_set (void)
1400 {
1401 jit_breakpoint_re_set_internal (target_gdbarch (),
1402 get_jit_program_space_data ());
1403 }
1404
1405 /* This function cleans up any code entries left over when the
1406 inferior exits. We get left over code when the inferior exits
1407 without unregistering its code, for example when it crashes. */
1408
1409 static void
1410 jit_inferior_exit_hook (struct inferior *inf)
1411 {
1412 struct objfile *objf;
1413 struct objfile *temp;
1414
1415 ALL_OBJFILES_SAFE (objf, temp)
1416 {
1417 struct jit_objfile_data *objf_data
1418 = (struct jit_objfile_data *) objfile_data (objf, jit_objfile_data);
1419
1420 if (objf_data != NULL && objf_data->addr != 0)
1421 jit_unregister_code (objf);
1422 }
1423 }
1424
1425 void
1426 jit_event_handler (struct gdbarch *gdbarch)
1427 {
1428 struct jit_descriptor descriptor;
1429 struct jit_code_entry code_entry;
1430 CORE_ADDR entry_addr;
1431 struct objfile *objf;
1432
1433 /* Read the descriptor from remote memory. */
1434 if (!jit_read_descriptor (gdbarch, &descriptor,
1435 get_jit_program_space_data ()))
1436 return;
1437 entry_addr = descriptor.relevant_entry;
1438
1439 /* Do the corresponding action. */
1440 switch (descriptor.action_flag)
1441 {
1442 case JIT_NOACTION:
1443 break;
1444 case JIT_REGISTER:
1445 jit_read_code_entry (gdbarch, entry_addr, &code_entry);
1446 jit_register_code (gdbarch, entry_addr, &code_entry);
1447 break;
1448 case JIT_UNREGISTER:
1449 objf = jit_find_objf_with_entry_addr (entry_addr);
1450 if (objf == NULL)
1451 printf_unfiltered (_("Unable to find JITed code "
1452 "entry at address: %s\n"),
1453 paddress (gdbarch, entry_addr));
1454 else
1455 jit_unregister_code (objf);
1456
1457 break;
1458 default:
1459 error (_("Unknown action_flag value in JIT descriptor!"));
1460 break;
1461 }
1462 }
1463
1464 /* Called to free the data allocated to the jit_program_space_data slot. */
1465
1466 static void
1467 free_objfile_data (struct objfile *objfile, void *data)
1468 {
1469 struct jit_objfile_data *objf_data = (struct jit_objfile_data *) data;
1470
1471 if (objf_data->register_code != NULL)
1472 {
1473 struct jit_program_space_data *ps_data;
1474
1475 ps_data
1476 = ((struct jit_program_space_data *)
1477 program_space_data (objfile->pspace, jit_program_space_data));
1478 if (ps_data != NULL && ps_data->objfile == objfile)
1479 {
1480 ps_data->objfile = NULL;
1481 delete_breakpoint (ps_data->jit_breakpoint);
1482 ps_data->cached_code_address = 0;
1483 }
1484 }
1485
1486 xfree (data);
1487 }
1488
1489 /* Initialize the jit_gdbarch_data slot with an instance of struct
1490 jit_gdbarch_data_type */
1491
1492 static void *
1493 jit_gdbarch_data_init (struct obstack *obstack)
1494 {
1495 struct jit_gdbarch_data_type *data =
1496 XOBNEW (obstack, struct jit_gdbarch_data_type);
1497
1498 data->unwinder_registered = 0;
1499
1500 return data;
1501 }
1502
1503 void
1504 _initialize_jit (void)
1505 {
1506 jit_reader_dir = relocate_gdb_directory (JIT_READER_DIR,
1507 JIT_READER_DIR_RELOCATABLE);
1508 add_setshow_zuinteger_cmd ("jit", class_maintenance, &jit_debug,
1509 _("Set JIT debugging."),
1510 _("Show JIT debugging."),
1511 _("When non-zero, JIT debugging is enabled."),
1512 NULL,
1513 show_jit_debug,
1514 &setdebuglist, &showdebuglist);
1515
1516 observer_attach_inferior_created (jit_inferior_created);
1517 observer_attach_inferior_exit (jit_inferior_exit_hook);
1518 observer_attach_breakpoint_deleted (jit_breakpoint_deleted);
1519
1520 jit_objfile_data =
1521 register_objfile_data_with_cleanup (NULL, free_objfile_data);
1522 jit_program_space_data =
1523 register_program_space_data_with_cleanup (NULL,
1524 jit_program_space_data_cleanup);
1525 jit_gdbarch_data = gdbarch_data_register_pre_init (jit_gdbarch_data_init);
1526 if (is_dl_available ())
1527 {
1528 struct cmd_list_element *c;
1529
1530 c = add_com ("jit-reader-load", no_class, jit_reader_load_command, _("\
1531 Load FILE as debug info reader and unwinder for JIT compiled code.\n\
1532 Usage: jit-reader-load FILE\n\
1533 Try to load file FILE as a debug info reader (and unwinder) for\n\
1534 JIT compiled code. The file is loaded from " JIT_READER_DIR ",\n\
1535 relocated relative to the GDB executable if required."));
1536 set_cmd_completer (c, filename_completer);
1537
1538 c = add_com ("jit-reader-unload", no_class,
1539 jit_reader_unload_command, _("\
1540 Unload the currently loaded JIT debug info reader.\n\
1541 Usage: jit-reader-unload\n\n\
1542 Do \"help jit-reader-load\" for info on loading debug info readers."));
1543 set_cmd_completer (c, noop_completer);
1544 }
1545 }
gdb_reg_value::value
unsigned char value[1]
Definition: jit-reader.h:211
target_gdbarch
struct gdbarch * target_gdbarch(void)
Definition: gdbarch.c:5467
err
mach_port_t mach_port_t name mach_port_t mach_port_t name kern_return_t err
Definition: gnu-nat.c:1822
gdbarch
Definition: gdbarch.c:127
gdb_symtab::linetable
struct linetable * linetable
Definition: jit.c:474
other_sections::name
char * name
Definition: symfile.h:51
breakpoint::loc
bp_location * loc
Definition: breakpoint.h:702
gdb_line_mapping
Definition: jit-reader.h:76
create_jit_event_breakpoint
struct breakpoint * create_jit_event_breakpoint(struct gdbarch *gdbarch, CORE_ADDR address)
Definition: breakpoint.c:7500
gdb_reader_funcs::reader_version
int reader_version
Definition: jit-reader.h:331
jit_reader::functions
struct gdb_reader_funcs * functions
Definition: jit.c:168
completer.h
free_objfile_data
static void free_objfile_data(struct objfile *objfile, void *data)
Definition: jit.c:1467
observer_attach_breakpoint_deleted
struct observer * observer_attach_breakpoint_deleted(observer_breakpoint_deleted_ftype *f)
frame_id_build
struct frame_id frame_id_build(CORE_ADDR stack_addr, CORE_ADDR code_addr)
Definition: frame.c:624
extract_typed_address
CORE_ADDR extract_typed_address(const gdb_byte *buf, struct type *type)
Definition: findvar.c:154
frame_unwind_got_bytes
struct value * frame_unwind_got_bytes(struct frame_info *frame, int regnum, gdb_byte *buf)
Definition: frame-unwind.c:260
arch_type
struct type * arch_type(struct gdbarch *gdbarch, enum type_code code, int bit, const char *name)
Definition: gdbtypes.c:4941
GDB_READER_INTERFACE_VERSION
#define GDB_READER_INTERFACE_VERSION
Definition: jit-reader.h:29
JIT_READER_DIR
#define JIT_READER_DIR
Definition: config.h:596
REG_VALID
Definition: common-regcache.h:32
mem_bfd_iovec_pread
static file_ptr mem_bfd_iovec_pread(struct bfd *abfd, void *stream, void *buf, file_ptr nbytes, file_ptr offset)
Definition: jit.c:104
jit_reader_load
static struct jit_reader * jit_reader_load(const char *file_name)
Definition: jit.c:183
_initialize_jit
void _initialize_jit(void)
Definition: jit.c:1504
symbol_set_symtab
void symbol_set_symtab(struct symbol *symbol, struct symtab *symtab)
Definition: symtab.c:5812
gdb_symtab::file_name
const char * file_name
Definition: jit.c:477
gdb_block::begin
CORE_ADDR begin
Definition: jit.c:455
CORE_ADDR
bfd_vma CORE_ADDR
Definition: common-types.h:41
linetable::item
struct linetable_entry item[1]
Definition: symtab.h:1258
mem_bfd_iovec_stat
static int mem_bfd_iovec_stat(struct bfd *abfd, void *stream, struct stat *sb)
Definition: jit.c:128
jit_reader_load_command
static void jit_reader_load_command(const char *args, int from_tty)
Definition: jit.c:211
RETURN_MASK_ALL
Definition: common-exceptions.h:44
jit_unwind_reg_get_impl
static struct gdb_reg_value * jit_unwind_reg_get_impl(struct gdb_unwind_callbacks *cb, int regnum)
Definition: jit.c:1142
command.h
jit_break_name
static const char *const jit_break_name
Definition: jit.c:49
jit_descriptor_name
static const char *const jit_descriptor_name
Definition: jit.c:51
jit_read_descriptor
static int jit_read_descriptor(struct gdbarch *gdbarch, struct jit_descriptor *descriptor, struct jit_program_space_data *ps_data)
Definition: jit.c:346
gdb_block::real_block
struct block * real_block
Definition: jit.c:452
xfree
void xfree(void *)
LOC_BLOCK
Definition: symtab.h:854
gdb_unwind_callbacks::reg_get
gdb_unwind_reg_get * reg_get
Definition: jit-reader.h:270
no_class
Definition: command.h:41
gdb_unwind_callbacks
Definition: jit-reader.h:268
JIT_READER_DIR_RELOCATABLE
#define JIT_READER_DIR_RELOCATABLE
Definition: config.h:600
cmd_list_element
Definition: cli-decode.h:46
jit_descriptor::relevant_entry
CORE_ADDR relevant_entry
Definition: jit.h:63
BMSYMBOL_VALUE_ADDRESS
#define BMSYMBOL_VALUE_ADDRESS(symbol)
Definition: symtab.h:691
warning
void warning(const char *fmt,...)
Definition: errors.c:26
jit_breakpoint_re_set
void jit_breakpoint_re_set(void)
Definition: jit.c:1399
objfile::pspace
struct program_space * pspace
Definition: objfiles.h:315
jit_breakpoint_deleted
static void jit_breakpoint_deleted(struct breakpoint *b)
Definition: jit.c:1014
jit_unwind_private
Definition: jit.c:1096
gdb_symtab
Definition: jit.c:464
dict_create_linear
struct dictionary * dict_create_linear(struct obstack *obstack, enum language language, const struct pending *symbol_list)
Definition: dictionary.c:409
gdb_symtab::blocks
struct gdb_block * blocks
Definition: jit.c:468
allocate_compunit_symtab
struct compunit_symtab * allocate_compunit_symtab(struct objfile *objfile, const char *name)
Definition: symfile.c:2842
builtin_type
const struct builtin_type * builtin_type(struct gdbarch *gdbarch)
Definition: gdbtypes.c:5217
memset
void * memset(T *s, int c, size_t n)=delete
OBJF_NOT_FILENAME
Definition: objfile-flags.h:66
other_sections::sectindex
int sectindex
Definition: symfile.h:54
jit_register_code
static void jit_register_code(struct gdbarch *gdbarch, CORE_ADDR entry_addr, struct jit_code_entry *code_entry)
Definition: jit.c:964
inferior
Definition: inferior.h:310
gdb_reader_funcs::destroy
gdb_destroy_reader * destroy
Definition: jit-reader.h:339
bp_location::pspace
program_space * pspace
Definition: breakpoint.h:421
gdb_unwind_callbacks::target_read
gdb_target_read * target_read
Definition: jit-reader.h:272
jit_code_entry
Definition: jit.h:41
frame_info
Definition: frame.c:85
jit_reader::jit_reader
jit_reader(struct gdb_reader_funcs *f, gdb_dlhandle_up &&h)
Definition: jit.c:156
filename_completer
void filename_completer(struct cmd_list_element *ignore, completion_tracker &tracker, const char *text, const char *word)
Definition: completer.c:152
compunit_symtab
Definition: symtab.h:1380
JIT_UNREGISTER
Definition: jit.h:31
observer_attach_inferior_exit
struct observer * observer_attach_inferior_exit(observer_inferior_exit_ftype *f)
register_status
register_status
Definition: common-regcache.h:25
BLOCKVECTOR_BLOCK
#define BLOCKVECTOR_BLOCK(blocklist, n)
Definition: block.h:125
gdbarch_data_register_pre_init
struct gdbarch_data * gdbarch_data_register_pre_init(gdbarch_data_pre_init_ftype *pre_init)
Definition: gdbarch.c:5130
gdbarch_num_regs
int gdbarch_num_regs(struct gdbarch *gdbarch)
Definition: gdbarch.c:2039
OBJF_SHARED
Definition: objfile-flags.h:42
cleanup
Definition: cleanups.c:38
_
#define _(String)
Definition: gdb_locale.h:35
gdb_bfd.h
ui_file
Definition: ui-file.h:26
show_jit_debug
static void show_jit_debug(struct ui_file *file, int from_tty, struct cmd_list_element *c, const char *value)
Definition: jit.c:69
jit_gdbarch_data_init
static void * jit_gdbarch_data_init(struct obstack *obstack)
Definition: jit.c:1493
defs.h
BLOCK_START
#define BLOCK_START(bl)
Definition: block.h:105
COMPUNIT_DIRNAME
#define COMPUNIT_DIRNAME(cust)
Definition: symtab.h:1464
jit_find_objf_with_entry_addr
static struct objfile * jit_find_objf_with_entry_addr(CORE_ADDR entry_addr)
Definition: jit.c:994
is_dl_available
int is_dl_available(void)
Definition: gdb-dlfcn.c:113
reader_init_fn_sym
static const char * reader_init_fn_sym
Definition: jit.c:178
END_CATCH
#define END_CATCH
Definition: common-exceptions.h:259
frame_unwind_prepend_unwinder
void frame_unwind_prepend_unwinder(struct gdbarch *gdbarch, const struct frame_unwind *unwinder)
Definition: frame-unwind.c:64
objfile::per_bfd
struct objfile_per_bfd_storage * per_bfd
Definition: objfiles.h:347
cleanup_check.ps
ps
Definition: cleanup_check.py:333
gdbarch_long_long_align_bit
int gdbarch_long_long_align_bit(struct gdbarch *gdbarch)
Definition: gdbarch.c:1630
jit_reader_unload_command
static void jit_reader_unload_command(const char *args, int from_tty)
Definition: jit.c:232
jit_objfile_data
Definition: jit.c:272
other_sections::addr
CORE_ADDR addr
Definition: symfile.h:50
mem_bfd_iovec_close
static int mem_bfd_iovec_close(struct bfd *abfd, void *stream)
Definition: jit.c:92
paddress
const char * paddress(struct gdbarch *gdbarch, CORE_ADDR addr)
Definition: utils.c:2745
objfiles.h
jit_dealloc_cache
static void jit_dealloc_cache(struct frame_info *this_frame, void *cache)
Definition: jit.c:1167
jit_frame_sniffer
static int jit_frame_sniffer(const struct frame_unwind *self, struct frame_info *this_frame, void **cache)
Definition: jit.c:1185
XNEW
#define XNEW(T)
Definition: poison.h:109
BLOCK_FUNCTION
#define BLOCK_FUNCTION(bl)
Definition: block.h:107
gdb_symbol_callbacks
Definition: jit-reader.h:157
observer.h
jit_frame_this_id
static void jit_frame_this_id(struct frame_info *this_frame, void **cache, struct frame_id *this_id)
Definition: jit.c:1236
jit_read_code_entry
static void jit_read_code_entry(struct gdbarch *gdbarch, CORE_ADDR code_addr, struct jit_code_entry *code_entry)
Definition: jit.c:401
jit_reader::DISABLE_COPY_AND_ASSIGN
DISABLE_COPY_AND_ASSIGN(jit_reader)
GLOBAL_BLOCK
Definition: defs.h:686
add_setshow_zuinteger_cmd
void add_setshow_zuinteger_cmd(const char *name, enum command_class theclass, unsigned int *var, const char *set_doc, const char *show_doc, const char *help_doc, cmd_const_sfunc_ftype *set_func, show_value_ftype *show_func, struct cmd_list_element **set_list, struct cmd_list_element **show_list)
Definition: cli-decode.c:792
observer_attach_inferior_created
struct observer * observer_attach_inferior_created(observer_inferior_created_ftype *f)
add_objfile_entry
static void add_objfile_entry(struct objfile *objfile, CORE_ADDR entry)
Definition: jit.c:307
TRY
#define TRY
Definition: common-exceptions.h:246
gdb_symbol_callbacks::priv_data
void * priv_data
Definition: jit-reader.h:169
TYPE_CODE_VOID
Definition: gdbtypes.h:124
symtab.h
jit_code_entry::symfile_addr
CORE_ADDR symfile_addr
Definition: jit.h:45
name
const char *const name
Definition: aarch64-tdep.c:76
gdb_reader_funcs::get_frame_id
gdb_get_frame_id * get_frame_id
Definition: jit-reader.h:338
SLASH_STRING
#define SLASH_STRING
Definition: host-defs.h:58
symbol_file_add_from_bfd
struct objfile * symbol_file_add_from_bfd(bfd *abfd, const char *name, symfile_add_flags add_flags, struct section_addr_info *addrs, objfile_flags flags, struct objfile *parent)
Definition: symfile.c:1257
jit_code_entry::symfile_size
ULONGEST symfile_size
Definition: jit.h:46
SYMBOL_ACLASS_INDEX
#define SYMBOL_ACLASS_INDEX(symbol)
Definition: symtab.h:1154
gdb::ref_ptr
Definition: gdb_ref_ptr.h:49
NORMAL_FRAME
Definition: frame.h:244
CATCH
#define CATCH(EXCEPTION, MASK)
Definition: common-exceptions.h:254
gdb_dlopen
gdb_dlhandle_up gdb_dlopen(const char *filename)
Definition: gdb-dlfcn.c:61
noop_completer
void noop_completer(struct cmd_list_element *ignore, completion_tracker &tracker, const char *text, const char *prefix)
Definition: completer.c:143
reg_value_free_impl
static void reg_value_free_impl(struct gdb_reg_value *value)
Definition: jit.c:1134
GDB_CORE_ADDR
unsigned long GDB_CORE_ADDR
Definition: jit-reader.h:59
breakpoint::type
bptype type
Definition: breakpoint.h:693
gdb::unique_xmalloc_ptr
std::unique_ptr< T, xfree_deleter< T > > unique_xmalloc_ptr
Definition: gdb_unique_ptr.h:48
jit_reader::handle
gdb_dlhandle_up handle
Definition: jit.c:169
gnutarget
char * gnutarget
Definition: corefile.c:442
jit_symtab_open_impl
static struct gdb_symtab * jit_symtab_open_impl(struct gdb_symbol_callbacks *cb, struct gdb_object *object, const char *file_name)
Definition: jit.c:524
SYMBOL_DOMAIN
#define SYMBOL_DOMAIN(symbol)
Definition: symtab.h:1152
linetable_entry::pc
CORE_ADDR pc
Definition: symtab.h:1231
objfile::objfile
objfile(bfd *, const char *, objfile_flags)
Definition: objfiles.c:373
target_ops
Definition: target.h:412
jit_block_open_impl
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:566
fprintf_filtered
void fprintf_filtered(struct ui_file *stream, const char *format,...)
Definition: utils.c:2008
jit_program_space_data::cached_code_address
CORE_ADDR cached_code_address
Definition: jit.c:258
jit_inferior_created_hook
void jit_inferior_created_hook(void)
Definition: jit.c:1390
gdb_reader_funcs::read
gdb_read_debug_info * read
Definition: jit-reader.h:336
set_cmd_completer
void set_cmd_completer(struct cmd_list_element *cmd, completer_ftype *completer)
Definition: cli-decode.c:160
extract_unsigned_integer
static ULONGEST extract_unsigned_integer(const gdb_byte *addr, int len, enum bfd_endian byte_order)
Definition: defs.h:577
lookup_minimal_symbol_and_objfile
struct bound_minimal_symbol lookup_minimal_symbol_and_objfile(const char *name)
Definition: minsyms.c:1008
regcache.h
bound_minimal_symbol
Definition: minsyms.h:29
gdb_line_mapping::line
int line
Definition: jit-reader.h:78
bfd_open_from_target_memory
static gdb_bfd_ref_ptr bfd_open_from_target_memory(CORE_ADDR addr, ULONGEST size, char *target)
Definition: jit.c:140
fprintf_unfiltered
void fprintf_unfiltered(struct ui_file *stream, const char *format,...)
Definition: utils.c:2018
linetable
Definition: symtab.h:1251
GDB_FAIL
Definition: jit-reader.h:64
gdb_symtab::next
struct gdb_symtab * next
Definition: jit.c:478
jit_unwind_private::regcache
struct regcache * regcache
Definition: jit.c:1100
block_type
block_type
Definition: mdebugread.c:235
gdbarch_byte_order
enum bfd_endian gdbarch_byte_order(struct gdbarch *gdbarch)
Definition: gdbarch.c:1509
breakpoint
Definition: breakpoint.h:684
inferior.h
JIT_NOACTION
Definition: jit.h:29
get_objfile_arch
struct gdbarch * get_objfile_arch(const struct objfile *objfile)
Definition: objfiles.c:445
pulongest
char * pulongest(ULONGEST u)
Definition: print-utils.c:129
TARGET_CHAR_BIT
#define TARGET_CHAR_BIT
Definition: host-defs.h:29
add_compunit_symtab_to_objfile
void add_compunit_symtab_to_objfile(struct compunit_symtab *cu)
Definition: symfile.c:2874
gdb_unwind_callbacks::reg_set
gdb_unwind_reg_set * reg_set
Definition: jit-reader.h:271
linetable_entry
Definition: symtab.h:1228
jit_unwind_reg_set_impl
static void jit_unwind_reg_set_impl(struct gdb_unwind_callbacks *cb, int dwarf_regnum, struct gdb_reg_value *value)
Definition: jit.c:1109
type
Definition: gdbtypes.h:749
target_buffer
Definition: jit.c:75
BLOCK_SUPERBLOCK
#define BLOCK_SUPERBLOCK(bl)
Definition: block.h:108
frame-unwind.h
bp_location::next
bp_location * next
Definition: breakpoint.h:324
jit_descriptor::version
uint32_t version
Definition: jit.h:59
inf
Definition: gnu-nat.c:174
jit_dbg_reader_data
CORE_ADDR jit_dbg_reader_data
Definition: jit.c:491
jit_unwind_private::this_frame
struct frame_info * this_frame
Definition: jit.c:1103
jit_program_space_data
Definition: jit.c:247
status
mach_port_t mach_port_t name mach_port_t mach_port_t name kern_return_t int status
Definition: gnu-nat.c:1822
gdb_unwind_callbacks::priv_data
void * priv_data
Definition: jit-reader.h:275
jit_symtab_close_impl
static void jit_symtab_close_impl(struct gdb_symbol_callbacks *cb, struct gdb_symtab *stab)
Definition: jit.c:634
BLOCK_END
#define BLOCK_END(bl)
Definition: block.h:106
jit_target_read_impl
static enum gdb_status jit_target_read_impl(GDB_CORE_ADDR target_mem, void *gdb_buf, int len)
Definition: jit.c:497
gdb_block::name
const char * name
Definition: jit.c:459
bp_jit_event
Definition: breakpoint.h:180
jit_bfd_try_read_symtab
static void jit_bfd_try_read_symtab(struct jit_code_entry *code_entry, CORE_ADDR entry_addr, struct gdbarch *gdbarch)
Definition: jit.c:887
get_jit_program_space_data
static struct jit_program_space_data * get_jit_program_space_data(void)
Definition: jit.c:319
allocate_block
struct block * allocate_block(struct obstack *obstack)
Definition: block.c:400
jit_code_entry::prev_entry
CORE_ADDR prev_entry
Definition: jit.h:44
xstrprintf
char * xstrprintf(const char *format,...)
Definition: common-utils.c:107
BLOCK_DICT
#define BLOCK_DICT(bl)
Definition: block.h:109
breakpoint.h
regnum
int regnum
Definition: aarch64-tdep.c:77
mem_bfd_iovec_open
static void * mem_bfd_iovec_open(struct bfd *abfd, void *open_closure)
Definition: jit.c:84
printf_unfiltered
void printf_unfiltered(const char *format,...)
Definition: utils.c:2056
setdebuglist
struct cmd_list_element * setdebuglist
Definition: cli-cmds.c:153
symtab
Definition: symtab.h:1291
jit_inferior_exit_hook
static void jit_inferior_exit_hook(struct inferior *inf)
Definition: jit.c:1410
xmalloc
void * xmalloc(YYSIZE_T)
gdbarch_pseudo_register_read_value
struct value * gdbarch_pseudo_register_read_value(struct gdbarch *gdbarch, struct regcache *regcache, int cookednum)
Definition: gdbarch.c:1998
jit_descriptor
Definition: jit.h:57
jit_program_space_data_cleanup
static void jit_program_space_data_cleanup(struct program_space *ps, void *arg)
Definition: jit.c:337
section_addr_info
Definition: symfile.h:64
gdb_reader_funcs
Definition: jit-reader.h:328
general_symbol_info::name
const char * name
Definition: symtab.h:384
reg
Definition: regdef.h:22
gdb_assert
#define gdb_assert(expr)
Definition: gdb_assert.h:32
block
Definition: block.h:60
JIT_REGISTER
Definition: jit.h:30
value
Definition: value.c:169
jit_frame_unwind
static const struct frame_unwind jit_frame_unwind
Definition: jit.c:1292
blockvector
Definition: block.h:112
gdb_status
gdb_status
Definition: jit-reader.h:63
gdb-dlfcn.h
section_addr_info::num_sections
size_t num_sections
Definition: symfile.h:68
gdbarch_dwarf2_reg_to_regnum
int gdbarch_dwarf2_reg_to_regnum(struct gdbarch *gdbarch, int dwarf2_regnr)
Definition: gdbarch.c:2265
jit_descriptor::action_flag
uint32_t action_flag
Definition: jit.h:62
objfile
Definition: objfiles.h:286
frame_unwind_got_optimized
struct value * frame_unwind_got_optimized(struct frame_info *frame, int regnum)
Definition: frame-unwind.c:201
jit.h
COMPUNIT_BLOCKVECTOR
#define COMPUNIT_BLOCKVECTOR(cust)
Definition: symtab.h:1465
gdb_byte
bfd_byte gdb_byte
Definition: common-types.h:38
gdb_frame_id
Definition: jit-reader.h:223
jit_gdbarch_data
static struct gdbarch_data * jit_gdbarch_data
Definition: jit.c:62
jit_objfile_data::register_code
struct minimal_symbol * register_code
Definition: jit.c:275
regcache_raw_set_cached_value
void regcache_raw_set_cached_value(struct regcache *regcache, int regnum, const gdb_byte *buf)
Definition: regcache.c:816
jit_prepend_unwinder
static void jit_prepend_unwinder(struct gdbarch *gdbarch)
Definition: jit.c:1316
puts_unfiltered
void puts_unfiltered(const char *string)
Definition: utils.c:2091
allocate_symbol
struct symbol * allocate_symbol(struct objfile *objfile)
Definition: symtab.c:5757
gdb_reader_funcs::unwind
gdb_unwind_frame * unwind
Definition: jit-reader.h:337
get_jit_objfile_data
static struct jit_objfile_data * get_jit_objfile_data(struct objfile *objf)
Definition: jit.c:289
deprecated_frame_register_read
int deprecated_frame_register_read(struct frame_info *frame, int regnum, gdb_byte *myaddr)
Definition: frame.c:1372
XCNEW
#define XCNEW(T)
Definition: poison.h:121
gdbcore.h
target_buffer::base
CORE_ADDR base
Definition: jit.c:77
SYMBOL_BLOCK_VALUE
#define SYMBOL_BLOCK_VALUE(symbol)
Definition: symtab.h:467
jit_debug
static unsigned int jit_debug
Definition: jit.c:66
jit_program_space_data::objfile
struct objfile * objfile
Definition: jit.c:252
regcache_raw_read
enum register_status regcache_raw_read(struct regcache *regcache, int regnum, gdb_byte *buf)
Definition: regcache.c:565
gdb_bfd_openr_iovec
gdb_bfd_ref_ptr gdb_bfd_openr_iovec(const char *filename, const char *target, void *(*open_func)(struct bfd *nbfd, void *open_closure), void *open_closure, file_ptr(*pread_func)(struct bfd *nbfd, void *stream, void *buf, file_ptr nbytes, file_ptr offset), int(*close_func)(struct bfd *nbfd, void *stream), int(*stat_func)(struct bfd *abfd, void *stream, struct stat *sb))
Definition: gdb_bfd.c:804
target_read_memory
int target_read_memory(CORE_ADDR memaddr, gdb_byte *myaddr, ssize_t len)
Definition: target.c:1370
jit_symtab_line_mapping_add_impl
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:609
builtin_type::builtin_data_ptr
struct type * builtin_data_ptr
Definition: gdbtypes.h:1554
gdb_block::end
CORE_ADDR end
Definition: jit.c:455
bound_minimal_symbol::minsym
struct minimal_symbol * minsym
Definition: minsyms.h:34
objfile_per_bfd_storage::gdbarch
struct gdbarch * gdbarch
Definition: objfiles.h:210
jit_frame_prev_register
static struct value * jit_frame_prev_register(struct frame_info *this_frame, void **cache, int reg)
Definition: jit.c:1265
offset
int offset
Definition: agent.c:65
jit_inferior_init
static void jit_inferior_init(struct gdbarch *gdbarch)
Definition: jit.c:1332
allocate_symtab
struct symtab * allocate_symtab(struct compunit_symtab *cust, const char *filename)
Definition: symfile.c:2785
symbol::ginfo
struct general_symbol_info ginfo
Definition: symtab.h:1054
buffer
Definition: buffer.h:23
gdb_block::next
struct gdb_block * next
Definition: jit.c:447
regcache::arch
gdbarch * arch() const
Definition: regcache.c:221
compunit_language
enum language compunit_language(const struct compunit_symtab *cust)
Definition: symtab.c:303
jit_objfile_data::descriptor
struct minimal_symbol * descriptor
Definition: jit.c:278
COMPUNIT_FILETABS
#define COMPUNIT_FILETABS(cust)
Definition: symtab.h:1461
ALL_OBJFILES_SAFE
#define ALL_OBJFILES_SAFE(obj, nxt)
Definition: objfiles.h:587
gdb_block
Definition: jit.c:442
jit-reader.h
finalize_symtab
static void finalize_symtab(struct gdb_symtab *stab, struct objfile *objfile)
Definition: jit.c:645
target.h
gdb::ref_ptr::get
T * get() const
Definition: gdb_ref_ptr.h:130
BLOCKVECTOR_NBLOCKS
#define BLOCKVECTOR_NBLOCKS(blocklist)
Definition: block.h:124
VAR_DOMAIN
Definition: symtab.h:739
frame_unwind
Definition: frame-unwind.h:144
gdb_reg_value
Definition: jit-reader.h:183
section_addr_info::other
struct other_sections other[1]
Definition: symfile.h:70
current_inferior
struct inferior * current_inferior(void)
Definition: inferior.c:58
set_block_compunit_symtab
void set_block_compunit_symtab(struct block *block, struct compunit_symtab *cu)
Definition: block.c:420
GDB_SUCCESS
Definition: jit-reader.h:65
current_program_space
struct program_space * current_program_space
Definition: progspace.c:35
reader_init_fn_type
struct gdb_reader_funcs *() reader_init_fn_type(void)
Definition: jit.c:177
gdb_symtab::nblocks
int nblocks
Definition: jit.c:471
ULONGEST
unsigned long long ULONGEST
Definition: common-types.h:53
gdb_dlhandle_up
std::unique_ptr< void, dlclose_deleter > gdb_dlhandle_up
Definition: gdb-dlfcn.h:32
default_frame_unwind_stop_reason
enum unwind_stop_reason default_frame_unwind_stop_reason(struct frame_info *this_frame, void **this_cache)
Definition: frame-unwind.c:184
STATIC_BLOCK
Definition: defs.h:687
language
language
Definition: defs.h:203
gdb_dlsym
void * gdb_dlsym(const gdb_dlhandle_up &handle, const char *symbol)
Definition: gdb-dlfcn.c:93
register_size
int register_size(struct gdbarch *gdbarch, int regnum)
Definition: regcache.c:164
regcache
Definition: regcache.h:232
compare_block
static int compare_block(const struct gdb_block *const old, const struct gdb_block *const newobj)
Definition: jit.c:543
gdb_object
Definition: jit.c:483
jit_inferior_created
static void jit_inferior_created(struct target_ops *ops, int from_tty)
Definition: jit.c:1382
gdb_stdlog
#define gdb_stdlog
Definition: utils.h:349
jit_object_close_impl
static void jit_object_close_impl(struct gdb_symbol_callbacks *cb, struct gdb_object *obj)
Definition: jit.c:797
linetable::nitems
int nitems
Definition: symtab.h:1253
SYMBOL_TYPE
#define SYMBOL_TYPE(symbol)
Definition: symtab.h:1161
target_buffer::size
ULONGEST size
Definition: jit.c:78
symbol
Definition: symtab.h:1049
gdbarch_bfd_arch_info
const struct bfd_arch_info * gdbarch_bfd_arch_info(struct gdbarch *gdbarch)
Definition: gdbarch.c:1500
relocate_gdb_directory
char * relocate_gdb_directory(const char *initial, int flag)
Definition: main.c:159
showdebuglist
struct cmd_list_element * showdebuglist
Definition: cli-cmds.c:155
jit_code_entry::next_entry
CORE_ADDR next_entry
Definition: jit.h:43
jit_program_space_data::jit_breakpoint
struct breakpoint * jit_breakpoint
Definition: jit.c:263
jit_unregister_code
static void jit_unregister_code(struct objfile *objfile)
Definition: jit.c:986
BLOCKVECTOR_MAP
#define BLOCKVECTOR_MAP(blocklist)
Definition: block.h:126
gdb_block::parent
struct gdb_block * parent
Definition: jit.c:447
TYPE_LENGTH
#define TYPE_LENGTH(thistype)
Definition: gdbtypes.h:1235
minimal_symbol
Definition: symtab.h:623
jit_reader_try_read_symtab
static int jit_reader_try_read_symtab(struct jit_code_entry *code_entry, CORE_ADDR entry_addr)
Definition: jit.c:827
jit_gdbarch_data_type
Definition: jit.c:1307
bound_minimal_symbol::objfile
struct objfile * objfile
Definition: minsyms.h:39
jit_objfile_data
static const struct objfile_data * jit_objfile_data
Definition: jit.c:47
jit_gdbarch_data_type::unwinder_registered
int unwinder_registered
Definition: jit.c:1310
reinit_frame_cache
void reinit_frame_cache(void)
Definition: frame.c:1809
class_maintenance
Definition: command.h:43
allocate_global_block
struct block * allocate_global_block(struct obstack *obstack)
Definition: block.c:410
bp_location::owner
breakpoint * owner
Definition: breakpoint.h:341
make_cleanup_free_section_addr_info
struct cleanup * make_cleanup_free_section_addr_info(struct section_addr_info *addrs)
Definition: utils.c:150
terminate_minimal_symbol_table
void terminate_minimal_symbol_table(struct objfile *objfile)
Definition: minsyms.c:1441
linetable_entry::line
int line
Definition: symtab.h:1230
objfile::objfile_obstack
Definition: objfiles.h:357
ALL_OBJFILES
#define ALL_OBJFILES(obj)
Definition: objfiles.h:582
gdb_object::symtabs
struct gdb_symtab * symtabs
Definition: jit.c:485
add_com
struct cmd_list_element * add_com(const char *name, enum command_class theclass, cmd_const_cfunc_ftype *fun, const char *doc)
Definition: cli-decode.c:902
gdbarch_data
Definition: gdbarch.c:5084
jit_descriptor::first_entry
CORE_ADDR first_entry
Definition: jit.h:64
lookup_minimal_symbol
struct bound_minimal_symbol lookup_minimal_symbol(const char *name, const char *sfile, struct objfile *objf)
Definition: minsyms.c:311
jit_object_open_impl
static struct gdb_object * jit_object_open_impl(struct gdb_symbol_callbacks *cb)
Definition: jit.c:512
jit_reader_dir
static const char * jit_reader_dir
Definition: jit.c:45
jit_objfile_data::addr
CORE_ADDR addr
Definition: jit.c:282
gdbcmd.h
SYMTAB_LINETABLE
#define SYMTAB_LINETABLE(symtab)
Definition: symtab.h:1332
delete_breakpoint
void delete_breakpoint(struct breakpoint *bpt)
Definition: breakpoint.c:13226
error
void error(const char *fmt,...)
Definition: errors.c:38
size
size_t size
Definition: go32-nat.c:242
jit_event_handler
void jit_event_handler(struct gdbarch *gdbarch)
Definition: jit.c:1426
FIRST_LOCAL_BLOCK
Definition: defs.h:688
frame_id
Definition: frame.h:111
dictionary.h
get_frame_arch
struct gdbarch * get_frame_arch(struct frame_info *this_frame)
Definition: frame.c:2691
block.h
jit_breakpoint_re_set_internal
static int jit_breakpoint_re_set_internal(struct gdbarch *gdbarch, struct jit_program_space_data *ps_data)
Definition: jit.c:1039
jit_reader
Definition: jit.c:154
do_cleanups
void do_cleanups(struct cleanup *old_chain)
Definition: cleanups.c:174
MSYMBOL_VALUE_ADDRESS
#define MSYMBOL_VALUE_ADDRESS(objfile, symbol)
Definition: symtab.h:687
loaded_jit_reader
static struct jit_reader * loaded_jit_reader
Definition: jit.c:175
program_space
Definition: progspace.h:137
lookup_function_type
struct type * lookup_function_type(struct type *type)
Definition: gdbtypes.c:519
symfile.h
bp_location
Definition: breakpoint.h:315
alloc_section_addr_info
struct section_addr_info * alloc_section_addr_info(size_t num_sections)
Definition: symfile.c:223
jit_reader::~jit_reader
~jit_reader()
Definition: jit.c:161
new_block
static struct block * new_block(enum block_type, enum language)
Definition: mdebugread.c:4821