/* Handle JIT code generation in the inferior for GDB, the GNU Debugger.
- Copyright (C) 2009-2017 Free Software Foundation, Inc.
+ Copyright (C) 2009-2019 Free Software Foundation, Inc.
This file is part of GDB.
#include "gdbcmd.h"
#include "gdbcore.h"
#include "inferior.h"
-#include "observer.h"
+#include "observable.h"
#include "objfiles.h"
#include "regcache.h"
#include "symfile.h"
#include "symtab.h"
#include "target.h"
-#include "gdb-dlfcn.h"
+#include "gdbsupport/gdb-dlfcn.h"
#include <sys/stat.h>
#include "gdb_bfd.h"
#include "readline/tilde.h"
static const char *const jit_descriptor_name = "__jit_debug_descriptor";
-static const struct program_space_data *jit_program_space_data = NULL;
-
static void jit_inferior_init (struct gdbarch *gdbarch);
static void jit_inferior_exit_hook (struct inferior *inf);
/* Provides the jit-reader-load command. */
static void
-jit_reader_load_command (char *args, int from_tty)
+jit_reader_load_command (const char *args, int from_tty)
{
if (args == NULL)
error (_("No reader name provided."));
/* Provides the jit-reader-unload command. */
static void
-jit_reader_unload_command (char *args, int from_tty)
+jit_reader_unload_command (const char *args, int from_tty)
{
if (!loaded_jit_reader)
error (_("No JIT reader loaded."));
/* The objfile. This is NULL if no objfile holds the JIT
symbols. */
- struct objfile *objfile;
+ struct objfile *objfile = nullptr;
/* If this program space has __jit_debug_register_code, this is the
cached address from the minimal symbol. This is used to detect
relocations requiring the breakpoint to be re-created. */
- CORE_ADDR cached_code_address;
+ CORE_ADDR cached_code_address = 0;
/* This is the JIT event breakpoint, or NULL if it has not been
set. */
- struct breakpoint *jit_breakpoint;
+ struct breakpoint *jit_breakpoint = nullptr;
};
+static program_space_key<jit_program_space_data> jit_program_space_key;
+
/* Per-objfile structure recording the addresses in the program space.
This object serves two purposes: for ordinary objfiles, it may
cache some symbols related to the JIT interface; and for
if not already present. */
static struct jit_program_space_data *
-get_jit_program_space_data (void)
+get_jit_program_space_data ()
{
struct jit_program_space_data *ps_data;
- ps_data
- = ((struct jit_program_space_data *)
- program_space_data (current_program_space, jit_program_space_data));
+ ps_data = jit_program_space_key.get (current_program_space);
if (ps_data == NULL)
- {
- ps_data = XCNEW (struct jit_program_space_data);
- set_program_space_data (current_program_space, jit_program_space_data,
- ps_data);
- }
-
+ ps_data = jit_program_space_key.emplace (current_program_space);
return ps_data;
}
-static void
-jit_program_space_data_cleanup (struct program_space *ps, void *arg)
-{
- xfree (arg);
-}
-
/* Helper function for reading the global JIT descriptor from remote
memory. Returns 1 if all went well, 0 otherwise. */
ptr_type = builtin_type (gdbarch)->builtin_data_ptr;
ptr_size = TYPE_LENGTH (ptr_type);
- /* Figure out where the longlong value will be. */
- align_bytes = gdbarch_long_long_align_bit (gdbarch) / 8;
+ /* Figure out where the uint64_t value will be. */
+ align_bytes = type_align (builtin_type (gdbarch)->builtin_uint64);
off = 3 * ptr_size;
off = (off + (align_bytes - 1)) & ~(align_bytes - 1);
TARGET_CHAR_BIT,
"void");
- BLOCK_DICT (new_block) = dict_create_linear (&objfile->objfile_obstack,
- NULL);
+ BLOCK_MULTIDICT (new_block)
+ = 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;
SYMBOL_TYPE (block_name) = lookup_function_type (block_type);
SYMBOL_BLOCK_VALUE (block_name) = new_block;
- block_name->ginfo.name
- = (const char *) obstack_copy0 (&objfile->objfile_obstack,
- gdb_block_iter->name,
- strlen (gdb_block_iter->name));
+ block_name->ginfo.name = obstack_strdup (&objfile->objfile_obstack,
+ gdb_block_iter->name);
BLOCK_FUNCTION (new_block) = block_name;
new_block = (i == GLOBAL_BLOCK
? allocate_global_block (&objfile->objfile_obstack)
: allocate_block (&objfile->objfile_obstack));
- BLOCK_DICT (new_block) = dict_create_linear (&objfile->objfile_obstack,
- NULL);
+ BLOCK_MULTIDICT (new_block)
+ = mdict_create_linear (&objfile->objfile_obstack, NULL);
BLOCK_SUPERBLOCK (new_block) = block_iter;
block_iter = new_block;
OBJF_NOT_FILENAME);
objfile->per_bfd->gdbarch = target_gdbarch ();
- terminate_minimal_symbol_table (objfile);
-
j = NULL;
for (i = obj->symtabs; i; i = j)
{
gdb_mem = (gdb_byte *) xmalloc (code_entry->symfile_size);
status = 1;
- TRY
+ try
{
if (target_read_memory (code_entry->symfile_addr, gdb_mem,
code_entry->symfile_size))
status = 0;
}
- CATCH (e, RETURN_MASK_ALL)
+ catch (const gdb_exception &e)
{
status = 0;
}
- END_CATCH
if (status)
{
CORE_ADDR entry_addr,
struct gdbarch *gdbarch)
{
- struct section_addr_info *sai;
struct bfd_section *sec;
struct objfile *objfile;
- struct cleanup *old_cleanups;
- int i;
const struct bfd_arch_info *b;
if (jit_debug)
/* Read the section address information out of the symbol file. Since the
file is generated by the JIT at runtime, it should all of the absolute
addresses that we care about. */
- sai = alloc_section_addr_info (bfd_count_sections (nbfd.get ()));
- old_cleanups = make_cleanup_free_section_addr_info (sai);
- i = 0;
+ section_addr_info sai;
for (sec = nbfd->sections; sec != NULL; sec = sec->next)
if ((bfd_get_section_flags (nbfd.get (), sec) & (SEC_ALLOC|SEC_LOAD)) != 0)
{
/* We assume that these virtual addresses are absolute, and do not
treat them as offsets. */
- sai->other[i].addr = bfd_get_section_vma (nbfd.get (), sec);
- sai->other[i].name = xstrdup (bfd_get_section_name (nbfd.get (), sec));
- sai->other[i].sectindex = sec->index;
- ++i;
+ sai.emplace_back (bfd_get_section_vma (nbfd.get (), sec),
+ bfd_get_section_name (nbfd.get (), sec),
+ sec->index);
}
- sai->num_sections = i;
/* This call does not take ownership of SAI. */
objfile = symbol_file_add_from_bfd (nbfd.get (),
- bfd_get_filename (nbfd.get ()), 0, sai,
+ bfd_get_filename (nbfd.get ()), 0,
+ &sai,
OBJF_SHARED | OBJF_NOT_FILENAME, NULL);
- do_cleanups (old_cleanups);
add_objfile_entry (objfile, entry_addr);
}
static struct objfile *
jit_find_objf_with_entry_addr (CORE_ADDR entry_addr)
{
- struct objfile *objf;
-
- ALL_OBJFILES (objf)
+ for (objfile *objf : current_program_space->objfiles ())
{
struct jit_objfile_data *objf_data;
{
struct jit_program_space_data *ps_data;
- ps_data = ((struct jit_program_space_data *)
- program_space_data (iter->pspace, jit_program_space_data));
+ ps_data = jit_program_space_key.get (iter->pspace);
if (ps_data != NULL && ps_data->jit_breakpoint == iter->owner)
{
ps_data->cached_code_address = 0;
{
/* Lookup the registration symbol. If it is missing, then we
assume we are not attached to a JIT. */
- reg_symbol = lookup_minimal_symbol_and_objfile (jit_break_name);
+ reg_symbol = lookup_bound_minimal_symbol (jit_break_name);
if (reg_symbol.minsym == NULL
|| BMSYMBOL_VALUE_ADDRESS (reg_symbol) == 0)
return 1;
{
/* Cached register values. See jit_frame_sniffer to see how this
works. */
- struct regcache *regcache;
+ detached_regcache *regcache;
/* The frame being unwound. */
struct frame_info *this_frame;
return;
}
- regcache_raw_set_cached_value (priv->regcache, gdb_reg, value->value);
+ priv->regcache->raw_supply (gdb_reg, value->value);
value->free (value);
}
struct jit_unwind_private *priv_data;
struct gdb_unwind_callbacks callbacks;
struct gdb_reader_funcs *funcs;
- struct gdbarch *gdbarch;
callbacks.reg_get = jit_unwind_reg_get_impl;
callbacks.reg_set = jit_unwind_reg_set_impl;
gdb_assert (!*cache);
- gdbarch = get_frame_arch (this_frame);
-
*cache = XCNEW (struct jit_unwind_private);
priv_data = (struct jit_unwind_private *) *cache;
- priv_data->regcache = new regcache (gdbarch);
+ /* Take a snapshot of current regcache. */
+ priv_data->regcache = new detached_regcache (get_frame_arch (this_frame),
+ true);
priv_data->this_frame = this_frame;
callbacks.priv_data = priv_data;
return frame_unwind_got_optimized (this_frame, reg);
gdbarch = priv->regcache->arch ();
- if (reg < gdbarch_num_regs (gdbarch))
- {
- gdb_byte *buf = (gdb_byte *) alloca (register_size (gdbarch, reg));
- enum register_status status;
+ gdb_byte *buf = (gdb_byte *) alloca (register_size (gdbarch, reg));
+ enum register_status status = priv->regcache->cooked_read (reg, buf);
- status = regcache_raw_read (priv->regcache, reg, buf);
- if (status == REG_VALID)
- return frame_unwind_got_bytes (this_frame, reg, buf);
- else
- return frame_unwind_got_optimized (this_frame, reg);
- }
+ if (status == REG_VALID)
+ return frame_unwind_got_bytes (this_frame, reg, buf);
else
- return gdbarch_pseudo_register_read_value (gdbarch, priv->regcache, reg);
+ return frame_unwind_got_optimized (this_frame, reg);
}
/* Relay everything back to the unwinder registered by the JIT debug
static void
jit_inferior_exit_hook (struct inferior *inf)
{
- struct objfile *objf;
- struct objfile *temp;
-
- ALL_OBJFILES_SAFE (objf, temp)
+ for (objfile *objf : current_program_space->objfiles_safe ())
{
struct jit_objfile_data *objf_data
= (struct jit_objfile_data *) objfile_data (objf, jit_objfile_data);
{
struct jit_program_space_data *ps_data;
- ps_data
- = ((struct jit_program_space_data *)
- program_space_data (objfile->pspace, jit_program_space_data));
+ ps_data = jit_program_space_key.get (objfile->pspace);
if (ps_data != NULL && ps_data->objfile == objfile)
{
ps_data->objfile = NULL;
- delete_breakpoint (ps_data->jit_breakpoint);
+ if (ps_data->jit_breakpoint != NULL)
+ delete_breakpoint (ps_data->jit_breakpoint);
ps_data->cached_code_address = 0;
}
}
show_jit_debug,
&setdebuglist, &showdebuglist);
- observer_attach_inferior_created (jit_inferior_created);
- observer_attach_inferior_exit (jit_inferior_exit_hook);
- observer_attach_breakpoint_deleted (jit_breakpoint_deleted);
+ gdb::observers::inferior_created.attach (jit_inferior_created);
+ gdb::observers::inferior_exit.attach (jit_inferior_exit_hook);
+ gdb::observers::breakpoint_deleted.attach (jit_breakpoint_deleted);
jit_objfile_data =
register_objfile_data_with_cleanup (NULL, free_objfile_data);
- jit_program_space_data =
- register_program_space_data_with_cleanup (NULL,
- jit_program_space_data_cleanup);
jit_gdbarch_data = gdbarch_data_register_pre_init (jit_gdbarch_data_init);
if (is_dl_available ())
{
projects / deliverable / binutils-gdb.git / blobdiff