/* Handle JIT code generation in the inferior for GDB, the GNU Debugger.
- Copyright (C) 2009-2021 Free Software Foundation, Inc.
+ Copyright (C) 2009-2022 Free Software Foundation, Inc.
This file is part of GDB.
show_jit_debug (struct ui_file *file, int from_tty,
struct cmd_list_element *c, const char *value)
{
- fprintf_filtered (file, _("JIT debugging is %s.\n"), value);
+ gdb_printf (file, _("JIT debugging is %s.\n"), value);
}
/* Implementation of the "maintenance info jit" command. */
inferior *inf = current_inferior ();
bool printed_header = false;
+ gdb::optional<ui_out_emit_table> table_emitter;
+
/* Print a line for each JIT-ed objfile. */
for (objfile *obj : inf->pspace->objfiles ())
{
if (!printed_header)
{
- printf_filtered ("Base address of known JIT-ed objfiles:\n");
+ table_emitter.emplace (current_uiout, 3, -1, "jit-created-objfiles");
+
+ /* The +2 allows for the leading '0x', then one character for
+ every 4-bits. */
+ int addr_width = 2 + (gdbarch_ptr_bit (obj->arch ()) / 4);
+
+ /* The std::max here selects between the width of an address (as
+ a string) and the width of the column header string. */
+ current_uiout->table_header (std::max (addr_width, 22), ui_left,
+ "jit_code_entry-address",
+ "jit_code_entry address");
+ current_uiout->table_header (std::max (addr_width, 15), ui_left,
+ "symfile-address", "symfile address");
+ current_uiout->table_header (20, ui_left,
+ "symfile-size", "symfile size");
+ current_uiout->table_body ();
+
printed_header = true;
}
- printf_filtered (" %s\n", paddress (obj->arch (), obj->jited_data->addr));
+ ui_out_emit_tuple tuple_emitter (current_uiout, "jit-objfile");
+
+ current_uiout->field_core_addr ("jit_code_entry-address", obj->arch (),
+ obj->jited_data->addr);
+ current_uiout->field_core_addr ("symfile-address", obj->arch (),
+ obj->jited_data->symfile_addr);
+ current_uiout->field_unsigned ("symfile-size",
+ obj->jited_data->symfile_size);
+ current_uiout->text ("\n");
}
}
at inferior address ENTRY. */
static void
-add_objfile_entry (struct objfile *objfile, CORE_ADDR entry)
+add_objfile_entry (struct objfile *objfile, CORE_ADDR entry,
+ CORE_ADDR symfile_addr, ULONGEST symfile_size)
{
gdb_assert (objfile->jited_data == nullptr);
- objfile->jited_data.reset (new jited_objfile_data (entry));
+ objfile->jited_data.reset (new jited_objfile_data (entry, symfile_addr,
+ symfile_size));
}
/* Helper function for reading the global JIT descriptor from remote
jiter_objfile_data *objf_data = jiter->jiter_data.get ();
gdb_assert (objf_data != nullptr);
- CORE_ADDR addr = MSYMBOL_VALUE_ADDRESS (jiter, objf_data->descriptor);
+ CORE_ADDR addr = objf_data->descriptor->value_address (jiter);
jit_debug_printf ("descriptor_addr = %s", paddress (gdbarch, addr));
err = target_read_memory (addr, desc_buf, desc_size);
if (err)
{
- printf_unfiltered (_("Unable to read JIT descriptor from "
- "remote memory\n"));
+ gdb_printf (gdb_stderr, _("Unable to read JIT descriptor from "
+ "remote memory\n"));
return false;
}
/* The type of the `private' data passed around by the callback
functions. */
-typedef CORE_ADDR jit_dbg_reader_data;
+struct jit_dbg_reader_data
+{
+ /* Address of the jit_code_entry in the inferior's address space. */
+ CORE_ADDR entry_addr;
+
+ /* The code entry, copied in our address space. */
+ const jit_code_entry &entry;
+
+ struct gdbarch *gdbarch;
+};
/* The reader calls into this function to read data off the targets
address space. */
});
cust = allocate_compunit_symtab (objfile, stab->file_name.c_str ());
- allocate_symtab (cust, stab->file_name.c_str ());
+ symtab *filetab = allocate_symtab (cust, stab->file_name.c_str ());
add_compunit_symtab_to_objfile (cust);
/* JIT compilers compile in memory. */
- COMPUNIT_DIRNAME (cust) = NULL;
+ cust->set_dirname (nullptr);
/* Copy over the linetable entry if one was provided. */
if (stab->linetable)
size_t size = ((stab->linetable->nitems - 1)
* sizeof (struct linetable_entry)
+ sizeof (struct linetable));
- SYMTAB_LINETABLE (COMPUNIT_FILETABS (cust))
- = (struct linetable *) obstack_alloc (&objfile->objfile_obstack, size);
- memcpy (SYMTAB_LINETABLE (COMPUNIT_FILETABS (cust)),
- stab->linetable.get (), size);
+ filetab->set_linetable ((struct linetable *)
+ obstack_alloc (&objfile->objfile_obstack, size));
+ memcpy (filetab->linetable (), stab->linetable.get (), size);
}
blockvector_size = (sizeof (struct blockvector)
+ (actual_nblocks - 1) * sizeof (struct block *));
bv = (struct blockvector *) obstack_alloc (&objfile->objfile_obstack,
blockvector_size);
- COMPUNIT_BLOCKVECTOR (cust) = bv;
+ cust->set_blockvector (bv);
/* At the end of this function, (begin, end) will contain the PC range this
entire blockvector spans. */
- BLOCKVECTOR_MAP (bv) = NULL;
+ bv->set_map (nullptr);
begin = stab->blocks.front ().begin;
end = stab->blocks.front ().end;
- BLOCKVECTOR_NBLOCKS (bv) = actual_nblocks;
+ bv->set_num_blocks (actual_nblocks);
/* First run over all the gdb_block objects, creating a real block
object for each. Simultaneously, keep setting the real_block
TARGET_CHAR_BIT,
"void");
- BLOCK_MULTIDICT (new_block)
- = mdict_create_linear (&objfile->objfile_obstack, NULL);
+ new_block->set_multidict
+ (mdict_create_linear (&objfile->objfile_obstack, NULL));
/* The address range. */
- BLOCK_START (new_block) = (CORE_ADDR) gdb_block_iter.begin;
- BLOCK_END (new_block) = (CORE_ADDR) gdb_block_iter.end;
+ new_block->set_start (gdb_block_iter.begin);
+ new_block->set_end (gdb_block_iter.end);
/* The name. */
- SYMBOL_DOMAIN (block_name) = VAR_DOMAIN;
- SYMBOL_ACLASS_INDEX (block_name) = LOC_BLOCK;
- symbol_set_symtab (block_name, COMPUNIT_FILETABS (cust));
- SYMBOL_TYPE (block_name) = lookup_function_type (block_type);
- SYMBOL_BLOCK_VALUE (block_name) = new_block;
+ block_name->set_domain (VAR_DOMAIN);
+ block_name->set_aclass_index (LOC_BLOCK);
+ block_name->set_symtab (filetab);
+ block_name->set_type (lookup_function_type (block_type));
+ block_name->set_value_block (new_block);
block_name->m_name = obstack_strdup (&objfile->objfile_obstack,
gdb_block_iter.name.get ());
- BLOCK_FUNCTION (new_block) = block_name;
+ new_block->set_function (block_name);
- BLOCKVECTOR_BLOCK (bv, block_idx) = new_block;
- if (begin > BLOCK_START (new_block))
- begin = BLOCK_START (new_block);
- if (end < BLOCK_END (new_block))
- end = BLOCK_END (new_block);
+ bv->set_block (block_idx, new_block);
+ if (begin > new_block->start ())
+ begin = new_block->start ();
+ if (end < new_block->end ())
+ end = new_block->end ();
gdb_block_iter.real_block = new_block;
new_block = (i == GLOBAL_BLOCK
? allocate_global_block (&objfile->objfile_obstack)
: allocate_block (&objfile->objfile_obstack));
- BLOCK_MULTIDICT (new_block)
- = mdict_create_linear (&objfile->objfile_obstack, NULL);
- BLOCK_SUPERBLOCK (new_block) = block_iter;
+ new_block->set_multidict
+ (mdict_create_linear (&objfile->objfile_obstack, NULL));
+ new_block->set_superblock (block_iter);
block_iter = new_block;
- BLOCK_START (new_block) = (CORE_ADDR) begin;
- BLOCK_END (new_block) = (CORE_ADDR) end;
+ new_block->set_start (begin);
+ new_block->set_end (end);
- BLOCKVECTOR_BLOCK (bv, i) = new_block;
+ bv->set_block (i, new_block);
if (i == GLOBAL_BLOCK)
set_block_compunit_symtab (new_block, cust);
{
/* If the plugin specifically mentioned a parent block, we
use that. */
- BLOCK_SUPERBLOCK (gdb_block_iter.real_block) =
- gdb_block_iter.parent->real_block;
+ gdb_block_iter.real_block->set_superblock
+ (gdb_block_iter.parent->real_block);
+
}
else
{
/* And if not, we set a default parent block. */
- BLOCK_SUPERBLOCK (gdb_block_iter.real_block) =
- BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK);
+ gdb_block_iter.real_block->set_superblock (bv->static_block ());
}
}
}
jit_object_close_impl (struct gdb_symbol_callbacks *cb,
struct gdb_object *obj)
{
- struct objfile *objfile;
- jit_dbg_reader_data *priv_data;
+ jit_dbg_reader_data *priv_data = (jit_dbg_reader_data *) cb->priv_data;
+ std::string objfile_name
+ = string_printf ("<< JIT compiled code at %s >>",
+ paddress (priv_data->gdbarch,
+ priv_data->entry.symfile_addr));
- priv_data = (jit_dbg_reader_data *) cb->priv_data;
-
- objfile = objfile::make (nullptr, "<< JIT compiled code >>",
- OBJF_NOT_FILENAME);
- objfile->per_bfd->gdbarch = target_gdbarch ();
+ objfile *objfile = objfile::make (nullptr, objfile_name.c_str (),
+ OBJF_NOT_FILENAME);
+ objfile->per_bfd->gdbarch = priv_data->gdbarch;
for (gdb_symtab &symtab : obj->symtabs)
finalize_symtab (&symtab, objfile);
- add_objfile_entry (objfile, *priv_data);
+ add_objfile_entry (objfile, priv_data->entry_addr,
+ priv_data->entry.symfile_addr,
+ priv_data->entry.symfile_size);
delete obj;
}
inferior address space. */
static int
-jit_reader_try_read_symtab (struct jit_code_entry *code_entry,
+jit_reader_try_read_symtab (gdbarch *gdbarch, jit_code_entry *code_entry,
CORE_ADDR entry_addr)
{
int status;
- jit_dbg_reader_data priv_data;
+ jit_dbg_reader_data priv_data
+ {
+ entry_addr,
+ *code_entry,
+ gdbarch
+ };
struct gdb_reader_funcs *funcs;
struct gdb_symbol_callbacks callbacks =
{
&priv_data
};
- priv_data = entry_addr;
-
if (!loaded_jit_reader)
return 0;
(code_entry->symfile_addr, code_entry->symfile_size, gnutarget));
if (nbfd == NULL)
{
- puts_unfiltered (_("Error opening JITed symbol file, ignoring it.\n"));
+ gdb_puts (_("Error opening JITed symbol file, ignoring it.\n"),
+ gdb_stderr);
return;
}
We would segfault later without this line. */
if (!bfd_check_format (nbfd.get (), bfd_object))
{
- printf_unfiltered (_("\
+ gdb_printf (gdb_stderr, _("\
JITed symbol file is not an object file, ignoring it.\n"));
return;
}
&sai,
OBJF_SHARED | OBJF_NOT_FILENAME, NULL);
- add_objfile_entry (objfile, entry_addr);
+ add_objfile_entry (objfile, entry_addr, code_entry->symfile_addr,
+ code_entry->symfile_size);
}
/* This function registers code associated with a JIT code entry. It uses the
paddress (gdbarch, code_entry->symfile_addr),
pulongest (code_entry->symfile_size));
- success = jit_reader_try_read_symtab (code_entry, entry_addr);
+ success = jit_reader_try_read_symtab (gdbarch, code_entry, entry_addr);
if (!success)
jit_bfd_try_read_symtab (code_entry, entry_addr, gdbarch);
bound_minimal_symbol reg_symbol
= lookup_minimal_symbol (jit_break_name, nullptr, the_objfile);
if (reg_symbol.minsym == NULL
- || BMSYMBOL_VALUE_ADDRESS (reg_symbol) == 0)
+ || reg_symbol.value_address () == 0)
{
/* No need to repeat the lookup the next time. */
the_objfile->skip_jit_symbol_lookup = true;
bound_minimal_symbol desc_symbol
= lookup_minimal_symbol (jit_descriptor_name, NULL, the_objfile);
if (desc_symbol.minsym == NULL
- || BMSYMBOL_VALUE_ADDRESS (desc_symbol) == 0)
+ || desc_symbol.value_address () == 0)
{
/* No need to repeat the lookup the next time. */
the_objfile->skip_jit_symbol_lookup = true;
objf_data->register_code = reg_symbol.minsym;
objf_data->descriptor = desc_symbol.minsym;
- CORE_ADDR addr = MSYMBOL_VALUE_ADDRESS (the_objfile,
- objf_data->register_code);
-
+ CORE_ADDR addr = objf_data->register_code->value_address (the_objfile);
jit_debug_printf ("breakpoint_addr = %s", paddress (gdbarch, addr));
/* Check if we need to re-create the breakpoint. */
{
/* Cached register values. See jit_frame_sniffer to see how this
works. */
- detached_regcache *regcache;
+ std::unique_ptr<detached_regcache> regcache;
/* The frame being unwound. */
struct frame_info *this_frame;
jit_dealloc_cache (struct frame_info *this_frame, void *cache)
{
struct jit_unwind_private *priv_data = (struct jit_unwind_private *) cache;
-
- gdb_assert (priv_data->regcache != NULL);
- delete priv_data->regcache;
- xfree (priv_data);
+ delete priv_data;
}
/* The frame sniffer for the pseudo unwinder.
gdb_assert (!*cache);
- *cache = XCNEW (struct jit_unwind_private);
- priv_data = (struct jit_unwind_private *) *cache;
+ priv_data = new struct jit_unwind_private;
+ *cache = priv_data;
/* Take a snapshot of current regcache. */
- priv_data->regcache = new detached_regcache (get_frame_arch (this_frame),
- true);
+ priv_data->regcache.reset
+ (new detached_regcache (get_frame_arch (this_frame), true));
priv_data->this_frame = this_frame;
callbacks.priv_data = priv_data;
struct gdb_reader_funcs *funcs;
struct gdb_unwind_callbacks callbacks;
- priv.regcache = NULL;
+ priv.regcache.reset ();
priv.this_frame = this_frame;
/* We don't expect the frame_id function to set any registers, so we
/* Check that the version number agrees with that we support. */
if (descriptor.version != 1)
{
- printf_unfiltered (_("Unsupported JIT protocol version %ld "
- "in descriptor (expected 1)\n"),
- (long) descriptor.version);
+ gdb_printf (gdb_stderr,
+ _("Unsupported JIT protocol version %ld "
+ "in descriptor (expected 1)\n"),
+ (long) descriptor.version);
continue;
}
{
objfile *jited = jit_find_objf_with_entry_addr (entry_addr);
if (jited == nullptr)
- printf_unfiltered (_("Unable to find JITed code "
- "entry at address: %s\n"),
- paddress (gdbarch, entry_addr));
+ gdb_printf (gdb_stderr,
+ _("Unable to find JITed code "
+ "entry at address: %s\n"),
+ paddress (gdbarch, entry_addr));
else
jited->unlink ();
projects / binutils-gdb.git / blobdiff