/* Handle JIT code generation in the inferior for GDB, the GNU Debugger.
- Copyright (C) 2009-2016 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"
#include "completer.h"
-static const char *jit_reader_dir = NULL;
+static std::string jit_reader_dir;
static const struct objfile_data *jit_objfile_data;
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);
ULONGEST size;
};
-/* Openning the file is a no-op. */
+/* Opening the file is a no-op. */
static void *
mem_bfd_iovec_open (struct bfd *abfd, void *open_closure)
static file_ptr
mem_bfd_iovec_pread (struct bfd *abfd, void *stream, void *buf,
- file_ptr nbytes, file_ptr offset)
+ file_ptr nbytes, file_ptr offset)
{
int err;
struct target_buffer *buffer = (struct target_buffer *) stream;
/* Open a BFD from the target's memory. */
-static struct bfd *
+static gdb_bfd_ref_ptr
bfd_open_from_target_memory (CORE_ADDR addr, ULONGEST size, char *target)
{
struct target_buffer *buffer = XNEW (struct target_buffer);
mem_bfd_iovec_stat);
}
+struct jit_reader
+{
+ jit_reader (struct gdb_reader_funcs *f, gdb_dlhandle_up &&h)
+ : functions (f), handle (std::move (h))
+ {
+ }
+
+ ~jit_reader ()
+ {
+ functions->destroy (functions);
+ }
+
+ DISABLE_COPY_AND_ASSIGN (jit_reader);
+
+ struct gdb_reader_funcs *functions;
+ gdb_dlhandle_up handle;
+};
+
/* One reader that has been loaded successfully, and can potentially be used to
parse debug info. */
-static struct jit_reader
-{
- struct gdb_reader_funcs *functions;
- void *handle;
-} *loaded_jit_reader = NULL;
+static struct jit_reader *loaded_jit_reader = NULL;
typedef struct gdb_reader_funcs * (reader_init_fn_type) (void);
static const char *reader_init_fn_sym = "gdb_init_reader";
static struct jit_reader *
jit_reader_load (const char *file_name)
{
- void *so;
reader_init_fn_type *init_fn;
- struct jit_reader *new_reader = NULL;
struct gdb_reader_funcs *funcs = NULL;
- struct cleanup *old_cleanups;
if (jit_debug)
fprintf_unfiltered (gdb_stdlog, _("Opening shared object %s.\n"),
- file_name);
- so = gdb_dlopen (file_name);
- old_cleanups = make_cleanup_dlclose (so);
+ file_name);
+ gdb_dlhandle_up so = gdb_dlopen (file_name);
init_fn = (reader_init_fn_type *) gdb_dlsym (so, reader_init_fn_sym);
if (!init_fn)
error (_("Could not locate initialization function: %s."),
- reader_init_fn_sym);
+ reader_init_fn_sym);
if (gdb_dlsym (so, "plugin_is_GPL_compatible") == NULL)
error (_("Reader not GPL compatible."));
if (funcs->reader_version != GDB_READER_INTERFACE_VERSION)
error (_("Reader version does not match GDB version."));
- new_reader = XCNEW (struct jit_reader);
- new_reader->functions = funcs;
- new_reader->handle = so;
-
- discard_cleanups (old_cleanups);
- return new_reader;
+ return new jit_reader (funcs, std::move (so));
}
/* 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)
{
- char *so_name;
- struct cleanup *prev_cleanup;
-
if (args == NULL)
error (_("No reader name provided."));
- args = tilde_expand (args);
- prev_cleanup = make_cleanup (xfree, args);
+ gdb::unique_xmalloc_ptr<char> file (tilde_expand (args));
if (loaded_jit_reader != NULL)
error (_("JIT reader already loaded. Run jit-reader-unload first."));
- if (IS_ABSOLUTE_PATH (args))
- so_name = args;
- else
- {
- so_name = xstrprintf ("%s%s%s", jit_reader_dir, SLASH_STRING, args);
- make_cleanup (xfree, so_name);
- }
+ if (!IS_ABSOLUTE_PATH (file.get ()))
+ file.reset (xstrprintf ("%s%s%s", jit_reader_dir.c_str (), SLASH_STRING,
+ file.get ()));
- loaded_jit_reader = jit_reader_load (so_name);
+ loaded_jit_reader = jit_reader_load (file.get ());
reinit_frame_cache ();
jit_inferior_created_hook ();
- do_cleanups (prev_cleanup);
}
/* 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."));
reinit_frame_cache ();
jit_inferior_exit_hook (current_inferior ());
- loaded_jit_reader->functions->destroy (loaded_jit_reader->functions);
- gdb_dlclose (loaded_jit_reader->handle);
- xfree (loaded_jit_reader);
+ delete loaded_jit_reader;
loaded_jit_reader = NULL;
}
/* 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);
static struct gdb_symtab *
jit_symtab_open_impl (struct gdb_symbol_callbacks *cb,
- struct gdb_object *object,
- const char *file_name)
+ struct gdb_object *object,
+ const char *file_name)
{
struct gdb_symtab *ret;
static int
compare_block (const struct gdb_block *const old,
- const struct gdb_block *const newobj)
+ const struct gdb_block *const newobj)
{
if (old == NULL)
return 1;
else if (old->begin == newobj->begin)
{
if (old->end > newobj->end)
- return 1;
+ return 1;
else
- return 0;
+ return 0;
}
else
return 0;
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)
+ struct gdb_symtab *symtab, struct gdb_block *parent,
+ GDB_CORE_ADDR begin, GDB_CORE_ADDR end, const char *name)
{
struct gdb_block *block = XCNEW (struct gdb_block);
struct gdb_block *i = symtab->blocks;
for (;; i = i->next)
- {
- /* Guaranteed to terminate, since compare_block (NULL, _)
- returns 1. */
- if (compare_block (i->next, block))
- {
- block->next = i->next;
- i->next = block;
- break;
- }
- }
+ {
+ /* Guaranteed to terminate, since compare_block (NULL, _)
+ returns 1. */
+ if (compare_block (i->next, block))
+ {
+ block->next = i->next;
+ i->next = block;
+ break;
+ }
+ }
}
symtab->nblocks++;
static void
jit_symtab_line_mapping_add_impl (struct gdb_symbol_callbacks *cb,
- struct gdb_symtab *stab, int nlines,
- struct gdb_line_mapping *map)
+ struct gdb_symtab *stab, int nlines,
+ struct gdb_line_mapping *map)
{
int i;
int alloc_len;
static void
jit_symtab_close_impl (struct gdb_symbol_callbacks *cb,
- struct gdb_symtab *stab)
+ struct gdb_symtab *stab)
{
/* Right now nothing needs to be done here. We may need to do some
cleanup here in the future (again, without breaking the plugin
}
blockvector_size = (sizeof (struct blockvector)
- + (actual_nblocks - 1) * sizeof (struct block *));
+ + (actual_nblocks - 1) * sizeof (struct block *));
bv = (struct blockvector *) obstack_alloc (&objfile->objfile_obstack,
blockvector_size);
COMPUNIT_BLOCKVECTOR (cust) = bv;
struct symbol *block_name = allocate_symbol (objfile);
struct type *block_type = arch_type (get_objfile_arch (objfile),
TYPE_CODE_VOID,
- 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->name = obstack_strdup (&objfile->objfile_obstack,
+ gdb_block_iter->name);
BLOCK_FUNCTION (new_block) = block_name;
BLOCKVECTOR_BLOCK (bv, i) = new_block;
if (begin > BLOCK_START (new_block))
- begin = BLOCK_START (new_block);
+ begin = BLOCK_START (new_block);
if (end < BLOCK_END (new_block))
- end = BLOCK_END (new_block);
+ end = BLOCK_END (new_block);
gdb_block_iter->real_block = new_block;
}
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;
static void
jit_object_close_impl (struct gdb_symbol_callbacks *cb,
- struct gdb_object *obj)
+ struct gdb_object *obj)
{
struct gdb_symtab *i, *j;
struct objfile *objfile;
priv_data = (jit_dbg_reader_data *) cb->priv_data;
- objfile = allocate_objfile (NULL, "<< JIT compiled code >>",
- OBJF_NOT_FILENAME);
+ objfile = objfile::make (nullptr, "<< JIT compiled code >>",
+ OBJF_NOT_FILENAME);
objfile->per_bfd->gdbarch = target_gdbarch ();
- terminate_minimal_symbol_table (objfile);
-
j = NULL;
for (i = obj->symtabs; i; i = j)
{
static int
jit_reader_try_read_symtab (struct jit_code_entry *code_entry,
- CORE_ADDR entry_addr)
+ CORE_ADDR entry_addr)
{
- gdb_byte *gdb_mem;
int status;
jit_dbg_reader_data priv_data;
struct gdb_reader_funcs *funcs;
if (!loaded_jit_reader)
return 0;
- gdb_mem = (gdb_byte *) xmalloc (code_entry->symfile_size);
+ gdb::byte_vector gdb_mem (code_entry->symfile_size);
status = 1;
- TRY
+ try
{
- if (target_read_memory (code_entry->symfile_addr, gdb_mem,
+ if (target_read_memory (code_entry->symfile_addr, gdb_mem.data (),
code_entry->symfile_size))
status = 0;
}
- CATCH (e, RETURN_MASK_ALL)
+ catch (const gdb_exception &e)
{
status = 0;
}
- END_CATCH
if (status)
{
funcs = loaded_jit_reader->functions;
- if (funcs->read (funcs, &callbacks, gdb_mem, code_entry->symfile_size)
- != GDB_SUCCESS)
- status = 0;
+ if (funcs->read (funcs, &callbacks, gdb_mem.data (),
+ code_entry->symfile_size)
+ != GDB_SUCCESS)
+ status = 0;
}
- xfree (gdb_mem);
if (jit_debug && status == 0)
fprintf_unfiltered (gdb_stdlog,
- "Could not read symtab using the loaded JIT reader.\n");
+ "Could not read symtab using the loaded JIT reader.\n");
return status;
}
static void
jit_bfd_try_read_symtab (struct jit_code_entry *code_entry,
- CORE_ADDR entry_addr,
- struct gdbarch *gdbarch)
+ CORE_ADDR entry_addr,
+ struct gdbarch *gdbarch)
{
- bfd *nbfd;
- 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)
fprintf_unfiltered (gdb_stdlog,
- "jit_register_code, symfile_addr = %s, "
+ "jit_bfd_try_read_symtab, symfile_addr = %s, "
"symfile_size = %s\n",
paddress (gdbarch, code_entry->symfile_addr),
pulongest (code_entry->symfile_size));
- nbfd = bfd_open_from_target_memory (code_entry->symfile_addr,
- code_entry->symfile_size, gnutarget);
+ gdb_bfd_ref_ptr nbfd (bfd_open_from_target_memory (code_entry->symfile_addr,
+ code_entry->symfile_size,
+ gnutarget));
if (nbfd == NULL)
{
puts_unfiltered (_("Error opening JITed symbol file, ignoring it.\n"));
/* Check the format. NOTE: This initializes important data that GDB uses!
We would segfault later without this line. */
- if (!bfd_check_format (nbfd, bfd_object))
+ if (!bfd_check_format (nbfd.get (), bfd_object))
{
printf_unfiltered (_("\
JITed symbol file is not an object file, ignoring it.\n"));
- gdb_bfd_unref (nbfd);
return;
}
/* Check bfd arch. */
b = gdbarch_bfd_arch_info (gdbarch);
- if (b->compatible (b, bfd_get_arch_info (nbfd)) != b)
+ if (b->compatible (b, bfd_get_arch_info (nbfd.get ())) != b)
warning (_("JITed object file architecture %s is not compatible "
- "with target architecture %s."), bfd_get_arch_info
- (nbfd)->printable_name, b->printable_name);
+ "with target architecture %s."),
+ bfd_get_arch_info (nbfd.get ())->printable_name,
+ b->printable_name);
/* 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));
- 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, sec) & (SEC_ALLOC|SEC_LOAD)) != 0)
+ if ((bfd_section_flags (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, sec);
- sai->other[i].name = xstrdup (bfd_get_section_name (nbfd, sec));
- sai->other[i].sectindex = sec->index;
- ++i;
+ /* We assume that these virtual addresses are absolute, and do not
+ treat them as offsets. */
+ sai.emplace_back (bfd_section_vma (sec),
+ bfd_section_name (sec),
+ sec->index);
}
- sai->num_sections = i;
/* This call does not take ownership of SAI. */
- make_cleanup_bfd_unref (nbfd);
- objfile = symbol_file_add_from_bfd (nbfd, bfd_get_filename (nbfd), 0, sai,
+ objfile = symbol_file_add_from_bfd (nbfd.get (),
+ bfd_get_filename (nbfd.get ()), 0,
+ &sai,
OBJF_SHARED | OBJF_NOT_FILENAME, NULL);
- do_cleanups (old_cleanups);
add_objfile_entry (objfile, entry_addr);
}
static void
jit_register_code (struct gdbarch *gdbarch,
- CORE_ADDR entry_addr, struct jit_code_entry *code_entry)
+ CORE_ADDR entry_addr, struct jit_code_entry *code_entry)
{
int success;
if (jit_debug)
fprintf_unfiltered (gdb_stdlog,
- "jit_register_code, symfile_addr = %s, "
- "symfile_size = %s\n",
- paddress (gdbarch, code_entry->symfile_addr),
- pulongest (code_entry->symfile_size));
+ "jit_register_code, symfile_addr = %s, "
+ "symfile_size = %s\n",
+ paddress (gdbarch, code_entry->symfile_addr),
+ pulongest (code_entry->symfile_size));
success = jit_reader_try_read_symtab (code_entry, entry_addr);
jit_bfd_try_read_symtab (code_entry, entry_addr, gdbarch);
}
-/* This function unregisters JITed code and frees the corresponding
- objfile. */
-
-static void
-jit_unregister_code (struct objfile *objfile)
-{
- free_objfile (objfile);
-}
-
/* Look up the objfile with this code entry address. */
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;
objf_data
= (struct jit_objfile_data *) objfile_data (objf, jit_objfile_data);
if (objf_data != NULL && objf_data->addr == entry_addr)
- return objf;
+ return objf;
}
return NULL;
}
{
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;
static void
jit_unwind_reg_set_impl (struct gdb_unwind_callbacks *cb, int dwarf_regnum,
- struct gdb_reg_value *value)
+ struct gdb_reg_value *value)
{
struct jit_unwind_private *priv;
int gdb_reg;
priv = (struct jit_unwind_private *) cb->priv_data;
gdb_reg = gdbarch_dwarf2_reg_to_regnum (get_frame_arch (priv->this_frame),
- dwarf_regnum);
+ dwarf_regnum);
if (gdb_reg == -1)
{
if (jit_debug)
- fprintf_unfiltered (gdb_stdlog,
- _("Could not recognize DWARF regnum %d"),
- dwarf_regnum);
+ fprintf_unfiltered (gdb_stdlog,
+ _("Could not recognize DWARF regnum %d"),
+ dwarf_regnum);
value->free (value);
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 jit_unwind_private *) cache;
gdb_assert (priv_data->regcache != NULL);
- regcache_xfree (priv_data->regcache);
+ delete priv_data->regcache;
xfree (priv_data);
}
static int
jit_frame_sniffer (const struct frame_unwind *self,
- struct frame_info *this_frame, void **cache)
+ struct frame_info *this_frame, void **cache)
{
struct jit_unwind_private *priv_data;
struct gdb_unwind_callbacks callbacks;
struct gdb_reader_funcs *funcs;
- struct address_space *aspace;
- struct gdbarch *gdbarch;
callbacks.reg_get = jit_unwind_reg_get_impl;
callbacks.reg_set = jit_unwind_reg_set_impl;
gdb_assert (!*cache);
- aspace = get_frame_address_space (this_frame);
- gdbarch = get_frame_arch (this_frame);
-
*cache = XCNEW (struct jit_unwind_private);
priv_data = (struct jit_unwind_private *) *cache;
- priv_data->regcache = regcache_xmalloc (gdbarch, aspace);
+ /* 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;
if (funcs->unwind (funcs, &callbacks) == GDB_SUCCESS)
{
if (jit_debug)
- fprintf_unfiltered (gdb_stdlog, _("Successfully unwound frame using "
- "JIT reader.\n"));
+ fprintf_unfiltered (gdb_stdlog, _("Successfully unwound frame using "
+ "JIT reader.\n"));
return 1;
}
if (jit_debug)
fprintf_unfiltered (gdb_stdlog, _("Could not unwind frame using "
- "JIT reader.\n"));
+ "JIT reader.\n"));
jit_dealloc_cache (this_frame, *cache);
*cache = NULL;
static void
jit_frame_this_id (struct frame_info *this_frame, void **cache,
- struct frame_id *this_id)
+ struct frame_id *this_id)
{
struct jit_unwind_private priv;
struct gdb_frame_id frame_id;
if (priv == NULL)
return frame_unwind_got_optimized (this_frame, reg);
- gdbarch = get_regcache_arch (priv->regcache);
- if (reg < gdbarch_num_regs (gdbarch))
- {
- gdb_byte *buf = (gdb_byte *) alloca (register_size (gdbarch, reg));
- enum register_status status;
+ gdbarch = priv->regcache->arch ();
+ 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
jit_read_code_entry (gdbarch, cur_entry_addr, &cur_entry);
/* This hook may be called many times during setup, so make sure we don't
- add the same symbol file twice. */
+ add the same symbol file twice. */
if (jit_find_objf_with_entry_addr (cur_entry_addr) != NULL)
- continue;
+ continue;
jit_register_code (gdbarch, cur_entry_addr, &cur_entry);
}
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);
if (objf_data != NULL && objf_data->addr != 0)
- jit_unregister_code (objf);
+ objf->unlink ();
}
}
"entry at address: %s\n"),
paddress (gdbarch, entry_addr));
else
- jit_unregister_code (objf);
+ objf->unlink ();
break;
default:
{
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;
+ {
+ ps_data->objfile = NULL;
+ if (ps_data->jit_breakpoint != NULL)
+ delete_breakpoint (ps_data->jit_breakpoint);
+ ps_data->cached_code_address = 0;
+ }
}
xfree (data);
return data;
}
-/* Provide a prototype to silence -Wmissing-prototypes. */
-
-extern void _initialize_jit (void);
-
void
_initialize_jit (void)
{
jit_reader_dir = relocate_gdb_directory (JIT_READER_DIR,
- JIT_READER_DIR_RELOCATABLE);
+ JIT_READER_DIR_RELOCATABLE);
add_setshow_zuinteger_cmd ("jit", class_maintenance, &jit_debug,
_("Set JIT debugging."),
_("Show JIT debugging."),
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