X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=gdb%2Fjit.c;h=0dd11e14d2f82c4732213351aaccdb8c6776716a;hb=0394eed15c5bf24943850f356785152c3d65ab94;hp=576daf23520634a4aeabc7415b672cd69bbf0e25;hpb=42a4f53d2bf8938c2aeda9f52be7a20534b214a9;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/jit.c b/gdb/jit.c index 576daf2352..0dd11e14d2 100644 --- a/gdb/jit.c +++ b/gdb/jit.c @@ -36,13 +36,14 @@ #include "symfile.h" #include "symtab.h" #include "target.h" -#include "gdb-dlfcn.h" +#include "gdbsupport/gdb-dlfcn.h" #include #include "gdb_bfd.h" #include "readline/tilde.h" #include "completer.h" +#include -static const char *jit_reader_dir = NULL; +static std::string jit_reader_dir; static const struct objfile_data *jit_objfile_data; @@ -50,8 +51,6 @@ static const char *const jit_break_name = "__jit_debug_register_code"; 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); @@ -78,7 +77,7 @@ struct target_buffer 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) @@ -102,7 +101,7 @@ mem_bfd_iovec_close (struct bfd *abfd, void *stream) 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; @@ -187,13 +186,13 @@ jit_reader_load (const char *file_name) if (jit_debug) fprintf_unfiltered (gdb_stdlog, _("Opening shared object %s.\n"), - file_name); + 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.")); @@ -218,7 +217,7 @@ jit_reader_load_command (const char *args, int from_tty) error (_("JIT reader already loaded. Run jit-reader-unload first.")); if (!IS_ABSOLUTE_PATH (file.get ())) - file.reset (xstrprintf ("%s%s%s", jit_reader_dir, SLASH_STRING, + file.reset (xstrprintf ("%s%s%s", jit_reader_dir.c_str (), SLASH_STRING, file.get ())); loaded_jit_reader = jit_reader_load (file.get ()); @@ -249,20 +248,22 @@ struct jit_program_space_data /* 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_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 @@ -316,29 +317,16 @@ add_objfile_entry (struct objfile *objfile, CORE_ADDR entry) 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. */ @@ -441,48 +429,68 @@ jit_read_code_entry (struct gdbarch *gdbarch, struct gdb_block { - /* gdb_blocks are linked into a tree structure. Next points to the - next node at the same depth as this block and parent to the - parent gdb_block. */ - struct gdb_block *next, *parent; + gdb_block (gdb_block *parent, CORE_ADDR begin, CORE_ADDR end, + const char *name) + : parent (parent), + begin (begin), + end (end), + name (name != nullptr ? xstrdup (name) : nullptr) + {} + + /* The parent of this block. */ + struct gdb_block *parent; /* Points to the "real" block that is being built out of this instance. This block will be added to a blockvector, which will then be added to a symtab. */ - struct block *real_block; + struct block *real_block = nullptr; /* The first and last code address corresponding to this block. */ CORE_ADDR begin, end; /* The name of this block (if any). If this is non-NULL, the FUNCTION symbol symbol is set to this value. */ - const char *name; + gdb::unique_xmalloc_ptr name; }; /* Proxy object for building a symtab. */ struct gdb_symtab { + explicit gdb_symtab (const char *file_name) + : file_name (file_name != nullptr ? file_name : "") + {} + /* The list of blocks in this symtab. These will eventually be - converted to real blocks. */ - struct gdb_block *blocks; + converted to real blocks. + + This is specifically a linked list, instead of, for example, a vector, + because the pointers are returned to the user's debug info reader. So + it's important that the objects don't change location during their + lifetime (which would happen with a vector of objects getting resized). */ + std::forward_list blocks; /* The number of blocks inserted. */ - int nblocks; + int nblocks = 0; /* A mapping between line numbers to PC. */ - struct linetable *linetable; + gdb::unique_xmalloc_ptr linetable; /* The source file for this symtab. */ - const char *file_name; - struct gdb_symtab *next; + std::string file_name; }; /* Proxy object for building an object. */ struct gdb_object { - struct gdb_symtab *symtabs; + /* Symtabs of this object. + + This is specifically a linked list, instead of, for example, a vector, + because the pointers are returned to the user's debug info reader. So + it's important that the objects don't change location during their + lifetime (which would happen with a vector of objects getting resized). */ + std::forward_list symtabs; }; /* The type of the `private' data passed around by the callback @@ -514,7 +522,7 @@ jit_object_open_impl (struct gdb_symbol_callbacks *cb) /* CB is not required right now, but sometime in the future we might need a handle to it, and we'd like to do that without breaking the ABI. */ - return XCNEW (struct gdb_object); + return new gdb_object; } /* Readers call into this function to open a new gdb_symtab, which, @@ -522,40 +530,13 @@ jit_object_open_impl (struct gdb_symbol_callbacks *cb) 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; - /* CB stays unused. See comment in jit_object_open_impl. */ - ret = XCNEW (struct gdb_symtab); - ret->file_name = file_name ? xstrdup (file_name) : xstrdup (""); - ret->next = object->symtabs; - object->symtabs = ret; - return ret; -} - -/* Returns true if the block corresponding to old should be placed - before the block corresponding to new in the final blockvector. */ - -static int -compare_block (const struct gdb_block *const old, - const struct gdb_block *const newobj) -{ - if (old == NULL) - return 1; - if (old->begin < newobj->begin) - return 1; - else if (old->begin == newobj->begin) - { - if (old->end > newobj->end) - return 1; - else - return 0; - } - else - return 0; + object->symtabs.emplace_front (file_name); + return &object->symtabs.front (); } /* Called by readers to open a new gdb_block. This function also @@ -564,42 +545,15 @@ compare_block (const struct gdb_block *const old, 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); - - block->next = symtab->blocks; - block->begin = (CORE_ADDR) begin; - block->end = (CORE_ADDR) end; - block->name = name ? xstrdup (name) : NULL; - block->parent = parent; - - /* Ensure that the blocks are inserted in the correct (reverse of - the order expected by blockvector). */ - if (compare_block (symtab->blocks, block)) - { - symtab->blocks = block; - } - else - { - 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; - } - } - } + /* Place the block at the beginning of the list, it will be sorted when the + symtab is finalized. */ + symtab->blocks.emplace_front (parent, begin, end, name); symtab->nblocks++; - return block; + return &symtab->blocks.front (); } /* Readers call this to add a line mapping (from PC to line number) to @@ -607,8 +561,8 @@ jit_block_open_impl (struct gdb_symbol_callbacks *cb, 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; @@ -618,7 +572,7 @@ jit_symtab_line_mapping_add_impl (struct gdb_symbol_callbacks *cb, alloc_len = sizeof (struct linetable) + (nlines - 1) * sizeof (struct linetable_entry); - stab->linetable = (struct linetable *) xmalloc (alloc_len); + stab->linetable.reset (XNEWVAR (struct linetable, alloc_len)); stab->linetable->nitems = nlines; for (i = 0; i < nlines; i++) { @@ -632,7 +586,7 @@ jit_symtab_line_mapping_add_impl (struct gdb_symbol_callbacks *cb, 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 @@ -645,20 +599,24 @@ static void finalize_symtab (struct gdb_symtab *stab, struct objfile *objfile) { struct compunit_symtab *cust; - struct gdb_block *gdb_block_iter, *gdb_block_iter_tmp; - struct block *block_iter; - int actual_nblocks, i; size_t blockvector_size; CORE_ADDR begin, end; struct blockvector *bv; - enum language language; - actual_nblocks = FIRST_LOCAL_BLOCK + stab->nblocks; + int actual_nblocks = FIRST_LOCAL_BLOCK + stab->nblocks; + + /* Sort the blocks in the order they should appear in the blockvector. */ + stab->blocks.sort([] (const gdb_block &a, const gdb_block &b) + { + if (a.begin != b.begin) + return a.begin < b.begin; + + return a.end > b.end; + }); - cust = allocate_compunit_symtab (objfile, stab->file_name); - allocate_symtab (cust, stab->file_name); + cust = allocate_compunit_symtab (objfile, stab->file_name.c_str ()); + allocate_symtab (cust, stab->file_name.c_str ()); add_compunit_symtab_to_objfile (cust); - language = compunit_language (cust); /* JIT compilers compile in memory. */ COMPUNIT_DIRNAME (cust) = NULL; @@ -671,29 +629,28 @@ finalize_symtab (struct gdb_symtab *stab, struct objfile *objfile) + sizeof (struct linetable)); SYMTAB_LINETABLE (COMPUNIT_FILETABS (cust)) = (struct linetable *) obstack_alloc (&objfile->objfile_obstack, size); - memcpy (SYMTAB_LINETABLE (COMPUNIT_FILETABS (cust)), stab->linetable, - size); + memcpy (SYMTAB_LINETABLE (COMPUNIT_FILETABS (cust)), + stab->linetable.get (), size); } 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; - /* (begin, end) will contain the PC range this entire blockvector - spans. */ + /* At the end of this function, (begin, end) will contain the PC range this + entire blockvector spans. */ BLOCKVECTOR_MAP (bv) = NULL; - begin = stab->blocks->begin; - end = stab->blocks->end; + begin = stab->blocks.front ().begin; + end = stab->blocks.front ().end; BLOCKVECTOR_NBLOCKS (bv) = actual_nblocks; /* First run over all the gdb_block objects, creating a real block object for each. Simultaneously, keep setting the real_block fields. */ - for (i = (actual_nblocks - 1), gdb_block_iter = stab->blocks; - i >= FIRST_LOCAL_BLOCK; - i--, gdb_block_iter = gdb_block_iter->next) + int block_idx = FIRST_LOCAL_BLOCK; + for (gdb_block &gdb_block_iter : stab->blocks) { struct block *new_block = allocate_block (&objfile->objfile_obstack); struct symbol *block_name = allocate_symbol (objfile); @@ -702,11 +659,11 @@ finalize_symtab (struct gdb_symtab *stab, struct objfile *objfile) TARGET_CHAR_BIT, "void"); - BLOCK_DICT (new_block) = dict_create_linear (&objfile->objfile_obstack, - language, 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; + BLOCK_START (new_block) = (CORE_ADDR) gdb_block_iter.begin; + BLOCK_END (new_block) = (CORE_ADDR) gdb_block_iter.end; /* The name. */ SYMBOL_DOMAIN (block_name) = VAR_DOMAIN; @@ -715,33 +672,33 @@ finalize_symtab (struct gdb_symtab *stab, struct objfile *objfile) 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.get ()); BLOCK_FUNCTION (new_block) = block_name; - BLOCKVECTOR_BLOCK (bv, i) = new_block; + BLOCKVECTOR_BLOCK (bv, block_idx) = 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; + gdb_block_iter.real_block = new_block; + + block_idx++; } /* Now add the special blocks. */ - block_iter = NULL; - for (i = 0; i < FIRST_LOCAL_BLOCK; i++) + struct block *block_iter = NULL; + for (enum block_enum i : { GLOBAL_BLOCK, STATIC_BLOCK }) { struct 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, - language, NULL); + BLOCK_MULTIDICT (new_block) + = mdict_create_linear (&objfile->objfile_obstack, NULL); BLOCK_SUPERBLOCK (new_block) = block_iter; block_iter = new_block; @@ -756,38 +713,22 @@ finalize_symtab (struct gdb_symtab *stab, struct objfile *objfile) /* Fill up the superblock fields for the real blocks, using the real_block fields populated earlier. */ - for (gdb_block_iter = stab->blocks; - gdb_block_iter; - gdb_block_iter = gdb_block_iter->next) + for (gdb_block &gdb_block_iter : stab->blocks) { - if (gdb_block_iter->parent != NULL) + if (gdb_block_iter.parent != NULL) { /* If the plugin specifically mentioned a parent block, we use that. */ - BLOCK_SUPERBLOCK (gdb_block_iter->real_block) = - gdb_block_iter->parent->real_block; + BLOCK_SUPERBLOCK (gdb_block_iter.real_block) = + gdb_block_iter.parent->real_block; } else { /* And if not, we set a default parent block. */ - BLOCK_SUPERBLOCK (gdb_block_iter->real_block) = + BLOCK_SUPERBLOCK (gdb_block_iter.real_block) = BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK); } } - - /* Free memory. */ - gdb_block_iter = stab->blocks; - - for (gdb_block_iter = stab->blocks, gdb_block_iter_tmp = gdb_block_iter->next; - gdb_block_iter; - gdb_block_iter = gdb_block_iter_tmp) - { - xfree ((void *) gdb_block_iter->name); - xfree (gdb_block_iter); - } - xfree (stab->linetable); - xfree ((char *) stab->file_name); - xfree (stab); } /* Called when closing a gdb_objfile. Converts OBJ to a proper @@ -795,28 +736,23 @@ finalize_symtab (struct gdb_symtab *stab, struct objfile *objfile) 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; jit_dbg_reader_data *priv_data; priv_data = (jit_dbg_reader_data *) cb->priv_data; - objfile = new struct 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); + for (gdb_symtab &symtab : obj->symtabs) + finalize_symtab (&symtab, objfile); - j = NULL; - for (i = obj->symtabs; i; i = j) - { - j = i->next; - finalize_symtab (i, objfile); - } add_objfile_entry (objfile, *priv_data); - xfree (obj); + + delete obj; } /* Try to read CODE_ENTRY using the loaded jit reader (if any). @@ -825,9 +761,8 @@ jit_object_close_impl (struct gdb_symbol_callbacks *cb, 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; @@ -850,33 +785,32 @@ jit_reader_try_read_symtab (struct jit_code_entry *code_entry, 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; } @@ -885,8 +819,8 @@ jit_reader_try_read_symtab (struct jit_code_entry *code_entry, 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) { struct bfd_section *sec; struct objfile *objfile; @@ -894,7 +828,7 @@ jit_bfd_try_read_symtab (struct jit_code_entry *code_entry, 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)); @@ -921,7 +855,7 @@ JITed symbol file is not an object file, ignoring it.\n")); b = gdbarch_bfd_arch_info (gdbarch); if (b->compatible (b, bfd_get_arch_info (nbfd.get ())) != b) warning (_("JITed object file architecture %s is not compatible " - "with target architecture %s."), + "with target architecture %s."), bfd_get_arch_info (nbfd.get ())->printable_name, b->printable_name); @@ -930,12 +864,12 @@ JITed symbol file is not an object file, ignoring it.\n")); addresses that we care about. */ 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) + 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.emplace_back (bfd_get_section_vma (nbfd.get (), sec), - bfd_get_section_name (nbfd.get (), sec), + /* 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); } @@ -955,16 +889,16 @@ JITed symbol file is not an object file, ignoring it.\n")); 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); @@ -972,30 +906,19 @@ jit_register_code (struct gdbarch *gdbarch, 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) -{ - delete 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; } @@ -1015,8 +938,7 @@ jit_breakpoint_deleted (struct breakpoint *b) { 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; @@ -1100,7 +1022,7 @@ struct jit_unwind_private 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; @@ -1108,13 +1030,13 @@ jit_unwind_reg_set_impl (struct gdb_unwind_callbacks *cb, int dwarf_regnum, 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; } @@ -1176,7 +1098,7 @@ jit_dealloc_cache (struct frame_info *this_frame, void *cache) 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; @@ -1206,13 +1128,13 @@ jit_frame_sniffer (const struct frame_unwind *self, 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; @@ -1226,7 +1148,7 @@ jit_frame_sniffer (const struct frame_unwind *self, 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; @@ -1354,9 +1276,9 @@ jit_inferior_init (struct gdbarch *gdbarch) 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); } @@ -1395,16 +1317,13 @@ jit_breakpoint_re_set (void) 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 (); } } @@ -1438,7 +1357,7 @@ jit_event_handler (struct gdbarch *gdbarch) "entry at address: %s\n"), paddress (gdbarch, entry_addr)); else - jit_unregister_code (objf); + objf->unlink (); break; default: @@ -1458,9 +1377,7 @@ free_objfile_data (struct objfile *objfile, void *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; @@ -1491,7 +1408,7 @@ 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."), @@ -1506,9 +1423,6 @@ _initialize_jit (void) 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 ()) {