X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=gdb%2Fobjfiles.c;h=d8fe88b1367c7d618b3d79d071622fa5462d9bee;hb=412294daf8786fd9060059b8be7fc59a35e13922;hp=73847bdf64b18faff1dbbc9971d550bfd0f0d518;hpb=ecd75fc8eed3bde86036141228074a20e55dcfc9;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/objfiles.c b/gdb/objfiles.c index 73847bdf64..d8fe88b136 100644 --- a/gdb/objfiles.c +++ b/gdb/objfiles.c @@ -1,6 +1,6 @@ /* GDB routines for manipulating objfiles. - Copyright (C) 1992-2014 Free Software Foundation, Inc. + Copyright (C) 1992-2017 Free Software Foundation, Inc. Contributed by Cygnus Support, using pieces from other GDB modules. @@ -33,12 +33,10 @@ #include "expression.h" #include "parser-defs.h" -#include "gdb_assert.h" #include #include #include #include "gdb_obstack.h" -#include #include "hashtab.h" #include "breakpoint.h" @@ -55,6 +53,8 @@ #include "gdb_bfd.h" #include "btrace.h" +#include + /* Keep a registry of per-objfile data-pointers required by other GDB modules. */ @@ -85,7 +85,7 @@ static const struct program_space_data *objfiles_pspace_data; static void objfiles_pspace_data_cleanup (struct program_space *pspace, void *arg) { - struct objfile_pspace_info *info = arg; + struct objfile_pspace_info *info = (struct objfile_pspace_info *) arg; xfree (info->sections); xfree (info); @@ -99,10 +99,11 @@ get_objfile_pspace_data (struct program_space *pspace) { struct objfile_pspace_info *info; - info = program_space_data (pspace, objfiles_pspace_data); + info = ((struct objfile_pspace_info *) + program_space_data (pspace, objfiles_pspace_data)); if (info == NULL) { - info = XZALLOC (struct objfile_pspace_info); + info = XCNEW (struct objfile_pspace_info); set_program_space_data (pspace, objfiles_pspace_data, info); } @@ -129,7 +130,8 @@ get_objfile_bfd_data (struct objfile *objfile, struct bfd *abfd) struct objfile_per_bfd_storage *storage = NULL; if (abfd != NULL) - storage = bfd_data (abfd, objfiles_bfd_data); + storage = ((struct objfile_per_bfd_storage *) + bfd_data (abfd, objfiles_bfd_data)); if (storage == NULL) { @@ -138,20 +140,29 @@ get_objfile_bfd_data (struct objfile *objfile, struct bfd *abfd) enough that this seems reasonable. */ if (abfd != NULL && !gdb_bfd_requires_relocations (abfd)) { - storage = bfd_zalloc (abfd, sizeof (struct objfile_per_bfd_storage)); + storage + = ((struct objfile_per_bfd_storage *) + bfd_alloc (abfd, sizeof (struct objfile_per_bfd_storage))); set_bfd_data (abfd, objfiles_bfd_data, storage); } else - storage = OBSTACK_ZALLOC (&objfile->objfile_obstack, - struct objfile_per_bfd_storage); + { + storage = (objfile_per_bfd_storage *) + obstack_alloc (&objfile->objfile_obstack, + sizeof (objfile_per_bfd_storage)); + } + + /* objfile_per_bfd_storage is not trivially constructible, must + call the ctor manually. */ + storage = new (storage) objfile_per_bfd_storage (); /* Look up the gdbarch associated with the BFD. */ if (abfd != NULL) storage->gdbarch = gdbarch_from_bfd (abfd); - obstack_init (&storage->storage_obstack); storage->filename_cache = bcache_xmalloc (NULL, NULL); storage->macro_cache = bcache_xmalloc (NULL, NULL); + storage->language_of_main = language_unknown; } return storage; @@ -166,7 +177,7 @@ free_objfile_per_bfd_storage (struct objfile_per_bfd_storage *storage) bcache_xfree (storage->macro_cache); if (storage->demangled_names_hash) htab_delete (storage->demangled_names_hash); - obstack_free (&storage->storage_obstack, 0); + storage->~objfile_per_bfd_storage (); } /* A wrapper for free_objfile_per_bfd_storage that can be passed as a @@ -175,7 +186,7 @@ free_objfile_per_bfd_storage (struct objfile_per_bfd_storage *storage) static void objfile_bfd_data_free (struct bfd *unused, void *d) { - free_objfile_per_bfd_storage (d); + free_objfile_per_bfd_storage ((struct objfile_per_bfd_storage *) d); } /* See objfiles.h. */ @@ -186,6 +197,107 @@ set_objfile_per_bfd (struct objfile *objfile) objfile->per_bfd = get_objfile_bfd_data (objfile, objfile->obfd); } +/* Set the objfile's per-BFD notion of the "main" name and + language. */ + +void +set_objfile_main_name (struct objfile *objfile, + const char *name, enum language lang) +{ + if (objfile->per_bfd->name_of_main == NULL + || strcmp (objfile->per_bfd->name_of_main, name) != 0) + objfile->per_bfd->name_of_main + = (const char *) obstack_copy0 (&objfile->per_bfd->storage_obstack, name, + strlen (name)); + objfile->per_bfd->language_of_main = lang; +} + +/* Helper structure to map blocks to static link properties in hash tables. */ + +struct static_link_htab_entry +{ + const struct block *block; + const struct dynamic_prop *static_link; +}; + +/* Return a hash code for struct static_link_htab_entry *P. */ + +static hashval_t +static_link_htab_entry_hash (const void *p) +{ + const struct static_link_htab_entry *e + = (const struct static_link_htab_entry *) p; + + return htab_hash_pointer (e->block); +} + +/* Return whether P1 an P2 (pointers to struct static_link_htab_entry) are + mappings for the same block. */ + +static int +static_link_htab_entry_eq (const void *p1, const void *p2) +{ + const struct static_link_htab_entry *e1 + = (const struct static_link_htab_entry *) p1; + const struct static_link_htab_entry *e2 + = (const struct static_link_htab_entry *) p2; + + return e1->block == e2->block; +} + +/* Register STATIC_LINK as the static link for BLOCK, which is part of OBJFILE. + Must not be called more than once for each BLOCK. */ + +void +objfile_register_static_link (struct objfile *objfile, + const struct block *block, + const struct dynamic_prop *static_link) +{ + void **slot; + struct static_link_htab_entry lookup_entry; + struct static_link_htab_entry *entry; + + if (objfile->static_links == NULL) + objfile->static_links = htab_create_alloc + (1, &static_link_htab_entry_hash, static_link_htab_entry_eq, NULL, + xcalloc, xfree); + + /* Create a slot for the mapping, make sure it's the first mapping for this + block and then create the mapping itself. */ + lookup_entry.block = block; + slot = htab_find_slot (objfile->static_links, &lookup_entry, INSERT); + gdb_assert (*slot == NULL); + + entry = (struct static_link_htab_entry *) obstack_alloc + (&objfile->objfile_obstack, sizeof (*entry)); + entry->block = block; + entry->static_link = static_link; + *slot = (void *) entry; +} + +/* Look for a static link for BLOCK, which is part of OBJFILE. Return NULL if + none was found. */ + +const struct dynamic_prop * +objfile_lookup_static_link (struct objfile *objfile, + const struct block *block) +{ + struct static_link_htab_entry *entry; + struct static_link_htab_entry lookup_entry; + + if (objfile->static_links == NULL) + return NULL; + lookup_entry.block = block; + entry + = (struct static_link_htab_entry *) htab_find (objfile->static_links, + &lookup_entry); + if (entry == NULL) + return NULL; + + gdb_assert (entry->block == block); + return entry->static_link; +} + /* Called via bfd_map_over_sections to build up the section table that @@ -218,7 +330,7 @@ static void add_to_objfile_sections (struct bfd *abfd, struct bfd_section *asect, void *objfilep) { - add_to_objfile_sections_full (abfd, asect, objfilep, 0); + add_to_objfile_sections_full (abfd, asect, (struct objfile *) objfilep, 0); } /* Builds a section table for OBJFILE. @@ -245,10 +357,9 @@ build_objfile_section_table (struct objfile *objfile) add_to_objfile_sections_full (objfile->obfd, bfd_ind_section_ptr, objfile, 1); } -/* Given a pointer to an initialized bfd (ABFD) and some flag bits - allocate a new objfile struct, fill it in as best we can, link it - into the list of all known objfiles, and return a pointer to the - new objfile struct. +/* Given a pointer to an initialized bfd (ABFD) and some flag bits, + initialize the new objfile as best we can and link it into the list + of all known objfiles. NAME should contain original non-canonicalized filename or other identifier as entered by user. If there is no better source use @@ -259,79 +370,61 @@ build_objfile_section_table (struct objfile *objfile) requests for specific operations. Other bits like OBJF_SHARED are simply copied through to the new objfile flags member. */ -/* NOTE: carlton/2003-02-04: This function is called with args NULL, 0 - by jv-lang.c, to create an artificial objfile used to hold - information about dynamically-loaded Java classes. Unfortunately, - that branch of this function doesn't get tested very frequently, so - it's prone to breakage. (E.g. at one time the name was set to NULL - in that situation, which broke a loop over all names in the dynamic - library loader.) If you change this function, please try to leave - things in a consistent state even if abfd is NULL. */ - -struct objfile * -allocate_objfile (bfd *abfd, const char *name, int flags) +objfile::objfile (bfd *abfd, const char *name, objfile_flags flags_) + : flags (flags_), + pspace (current_program_space), + obfd (abfd), + psymbol_cache (psymbol_bcache_init ()) { - struct objfile *objfile; - char *expanded_name; + const char *expanded_name; - objfile = (struct objfile *) xzalloc (sizeof (struct objfile)); - objfile->psymbol_cache = psymbol_bcache_init (); /* We could use obstack_specify_allocation here instead, but gdb_obstack.h specifies the alloc/dealloc functions. */ - obstack_init (&objfile->objfile_obstack); - terminate_minimal_symbol_table (objfile); + obstack_init (&objfile_obstack); - objfile_alloc_data (objfile); + objfile_alloc_data (this); + gdb::unique_xmalloc_ptr name_holder; if (name == NULL) { gdb_assert (abfd == NULL); gdb_assert ((flags & OBJF_NOT_FILENAME) != 0); - expanded_name = xstrdup ("<>"); + expanded_name = "<>"; } - else if ((flags & OBJF_NOT_FILENAME) != 0) - expanded_name = xstrdup (name); + else if ((flags & OBJF_NOT_FILENAME) != 0 + || is_target_filename (name)) + expanded_name = name; else - expanded_name = gdb_abspath (name); - objfile->original_name = obstack_copy0 (&objfile->objfile_obstack, - expanded_name, - strlen (expanded_name)); - xfree (expanded_name); - - /* Update the per-objfile information that comes from the bfd, ensuring - that any data that is reference is saved in the per-objfile data - region. */ + { + name_holder = gdb_abspath (name); + expanded_name = name_holder.get (); + } + original_name + = (char *) obstack_copy0 (&objfile_obstack, + expanded_name, + strlen (expanded_name)); /* Update the per-objfile information that comes from the bfd, ensuring that any data that is reference is saved in the per-objfile data region. */ - objfile->obfd = abfd; gdb_bfd_ref (abfd); if (abfd != NULL) { - objfile->mtime = bfd_get_mtime (abfd); + mtime = bfd_get_mtime (abfd); /* Build section table. */ - build_objfile_section_table (objfile); + build_objfile_section_table (this); } - objfile->per_bfd = get_objfile_bfd_data (objfile, abfd); - objfile->pspace = current_program_space; - - /* Initialize the section indexes for this objfile, so that we can - later detect if they are used w/o being properly assigned to. */ + per_bfd = get_objfile_bfd_data (this, abfd); - objfile->sect_index_text = -1; - objfile->sect_index_data = -1; - objfile->sect_index_bss = -1; - objfile->sect_index_rodata = -1; + terminate_minimal_symbol_table (this); /* Add this file onto the tail of the linked list of other such files. */ - objfile->next = NULL; if (object_files == NULL) - object_files = objfile; + object_files = this; else { struct objfile *last_one; @@ -339,21 +432,17 @@ allocate_objfile (bfd *abfd, const char *name, int flags) for (last_one = object_files; last_one->next; last_one = last_one->next); - last_one->next = objfile; + last_one->next = this; } - /* Save passed in flag bits. */ - objfile->flags |= flags; - /* Rebuild section map next time we need it. */ - get_objfile_pspace_data (objfile->pspace)->new_objfiles_available = 1; - - return objfile; + get_objfile_pspace_data (pspace)->new_objfiles_available = 1; } /* Retrieve the gdbarch associated with OBJFILE. */ + struct gdbarch * -get_objfile_arch (struct objfile *objfile) +get_objfile_arch (const struct objfile *objfile) { return objfile->per_bfd->gdbarch; } @@ -364,10 +453,12 @@ get_objfile_arch (struct objfile *objfile) int entry_point_address_query (CORE_ADDR *entry_p) { - if (symfile_objfile == NULL || !symfile_objfile->ei.entry_point_p) + if (symfile_objfile == NULL || !symfile_objfile->per_bfd->ei.entry_point_p) return 0; - *entry_p = symfile_objfile->ei.entry_point; + *entry_p = (symfile_objfile->per_bfd->ei.entry_point + + ANOFFSET (symfile_objfile->section_offsets, + symfile_objfile->per_bfd->ei.the_bfd_section_index)); return 1; } @@ -515,45 +606,44 @@ free_objfile_separate_debug (struct objfile *objfile) for (child = objfile->separate_debug_objfile; child;) { struct objfile *next_child = child->separate_debug_objfile_link; - free_objfile (child); + delete child; child = next_child; } } /* Destroy an objfile and all the symtabs and psymtabs under it. */ -void -free_objfile (struct objfile *objfile) +objfile::~objfile () { /* First notify observers that this objfile is about to be freed. */ - observer_notify_free_objfile (objfile); + observer_notify_free_objfile (this); /* Free all separate debug objfiles. */ - free_objfile_separate_debug (objfile); + free_objfile_separate_debug (this); - if (objfile->separate_debug_objfile_backlink) + if (separate_debug_objfile_backlink) { /* We freed the separate debug file, make sure the base objfile doesn't reference it. */ struct objfile *child; - child = objfile->separate_debug_objfile_backlink->separate_debug_objfile; + child = separate_debug_objfile_backlink->separate_debug_objfile; - if (child == objfile) + if (child == this) { - /* OBJFILE is the first child. */ - objfile->separate_debug_objfile_backlink->separate_debug_objfile = - objfile->separate_debug_objfile_link; + /* THIS is the first child. */ + separate_debug_objfile_backlink->separate_debug_objfile = + separate_debug_objfile_link; } else { - /* Find OBJFILE in the list. */ + /* Find THIS in the list. */ while (1) { - if (child->separate_debug_objfile_link == objfile) + if (child->separate_debug_objfile_link == this) { child->separate_debug_objfile_link = - objfile->separate_debug_objfile_link; + separate_debug_objfile_link; break; } child = child->separate_debug_objfile_link; @@ -561,17 +651,17 @@ free_objfile (struct objfile *objfile) } } } - + /* Remove any references to this objfile in the global value lists. */ - preserve_values (objfile); + preserve_values (this); /* It still may reference data modules have associated with the objfile and the symbol file data. */ - forget_cached_source_info_for_objfile (objfile); + forget_cached_source_info_for_objfile (this); - breakpoint_free_objfile (objfile); - btrace_free_objfile (objfile); + breakpoint_free_objfile (this); + btrace_free_objfile (this); /* First do any symbol file specific actions required when we are finished with a particular symbol file. Note that if the objfile @@ -580,25 +670,23 @@ free_objfile (struct objfile *objfile) freeing things which are valid only during this particular gdb execution, or leaving them to be reused during the next one. */ - if (objfile->sf != NULL) - { - (*objfile->sf->sym_finish) (objfile); - } + if (sf != NULL) + (*sf->sym_finish) (this); /* Discard any data modules have associated with the objfile. The function - still may reference objfile->obfd. */ - objfile_free_data (objfile); + still may reference obfd. */ + objfile_free_data (this); - if (objfile->obfd) - gdb_bfd_unref (objfile->obfd); + if (obfd) + gdb_bfd_unref (obfd); else - free_objfile_per_bfd_storage (objfile->per_bfd); + free_objfile_per_bfd_storage (per_bfd); /* Remove it from the chain of all objfiles. */ - unlink_objfile (objfile); + unlink_objfile (this); - if (objfile == symfile_objfile) + if (this == symfile_objfile) symfile_objfile = NULL; /* Before the symbol table code was redone to make it easier to @@ -624,29 +712,27 @@ free_objfile (struct objfile *objfile) { struct symtab_and_line cursal = get_current_source_symtab_and_line (); - if (cursal.symtab && cursal.symtab->objfile == objfile) + if (cursal.symtab && SYMTAB_OBJFILE (cursal.symtab) == this) clear_current_source_symtab_and_line (); } - if (objfile->global_psymbols.list) - xfree (objfile->global_psymbols.list); - if (objfile->static_psymbols.list) - xfree (objfile->static_psymbols.list); /* Free the obstacks for non-reusable objfiles. */ - psymbol_bcache_free (objfile->psymbol_cache); - obstack_free (&objfile->objfile_obstack, 0); + psymbol_bcache_free (psymbol_cache); + obstack_free (&objfile_obstack, 0); /* Rebuild section map next time we need it. */ - get_objfile_pspace_data (objfile->pspace)->section_map_dirty = 1; + get_objfile_pspace_data (pspace)->section_map_dirty = 1; - /* The last thing we do is free the objfile struct itself. */ - xfree (objfile); + /* Free the map for static links. There's no need to free static link + themselves since they were allocated on the objstack. */ + if (static_links != NULL) + htab_delete (static_links); } static void do_free_objfile_cleanup (void *obj) { - free_objfile (obj); + delete (struct objfile *) obj; } struct cleanup * @@ -669,7 +755,7 @@ free_all_objfiles (void) ALL_OBJFILES_SAFE (objfile, temp) { - free_objfile (objfile); + delete objfile; } clear_symtab_users (0); } @@ -723,30 +809,33 @@ objfile_relocate1 (struct objfile *objfile, /* OK, get all the symtabs. */ { + struct compunit_symtab *cust; struct symtab *s; - ALL_OBJFILE_SYMTABS (objfile, s) + ALL_OBJFILE_FILETABS (objfile, cust, s) { struct linetable *l; - struct blockvector *bv; int i; /* First the line table. */ - l = LINETABLE (s); + l = SYMTAB_LINETABLE (s); if (l) { for (i = 0; i < l->nitems; ++i) - l->item[i].pc += ANOFFSET (delta, s->block_line_section); + l->item[i].pc += ANOFFSET (delta, + COMPUNIT_BLOCK_LINE_SECTION + (cust)); } + } - /* Don't relocate a shared blockvector more than once. */ - if (!s->primary) - continue; + ALL_OBJFILE_COMPUNITS (objfile, cust) + { + const struct blockvector *bv = COMPUNIT_BLOCKVECTOR (cust); + int block_line_section = COMPUNIT_BLOCK_LINE_SECTION (cust); - bv = BLOCKVECTOR (s); if (BLOCKVECTOR_MAP (bv)) addrmap_relocate (BLOCKVECTOR_MAP (bv), - ANOFFSET (delta, s->block_line_section)); + ANOFFSET (delta, block_line_section)); for (i = 0; i < BLOCKVECTOR_NBLOCKS (bv); ++i) { @@ -755,8 +844,8 @@ objfile_relocate1 (struct objfile *objfile, struct dict_iterator iter; b = BLOCKVECTOR_BLOCK (bv, i); - BLOCK_START (b) += ANOFFSET (delta, s->block_line_section); - BLOCK_END (b) += ANOFFSET (delta, s->block_line_section); + BLOCK_START (b) += ANOFFSET (delta, block_line_section); + BLOCK_END (b) += ANOFFSET (delta, block_line_section); /* We only want to iterate over the local symbols, not any symbols in included symtabs. */ @@ -783,33 +872,6 @@ objfile_relocate1 (struct objfile *objfile, if (objfile->sf) objfile->sf->qf->relocate (objfile, new_offsets, delta); - { - struct minimal_symbol *msym; - - ALL_OBJFILE_MSYMBOLS (objfile, msym) - if (SYMBOL_SECTION (msym) >= 0) - SYMBOL_VALUE_ADDRESS (msym) += ANOFFSET (delta, SYMBOL_SECTION (msym)); - } - /* Relocating different sections by different amounts may cause the symbols - to be out of order. */ - msymbols_sort (objfile); - - if (objfile->ei.entry_point_p) - { - /* Relocate ei.entry_point with its section offset, use SECT_OFF_TEXT - only as a fallback. */ - struct obj_section *s; - s = find_pc_section (objfile->ei.entry_point); - if (s) - { - int idx = gdb_bfd_section_index (objfile->obfd, s->the_bfd_section); - - objfile->ei.entry_point += ANOFFSET (delta, idx); - } - else - objfile->ei.entry_point += ANOFFSET (delta, SECT_OFF_TEXT (objfile)); - } - { int i; @@ -829,11 +891,6 @@ objfile_relocate1 (struct objfile *objfile, obj_section_addr (s)); } - /* Relocating probes. */ - if (objfile->sf && objfile->sf->sym_probe_fns) - objfile->sf->sym_probe_fns->sym_relocate_probe (objfile, - new_offsets, delta); - /* Data changed. */ return 1; } @@ -861,7 +918,6 @@ objfile_relocate (struct objfile *objfile, debug_objfile = objfile_separate_debug_iterate (objfile, debug_objfile)) { struct section_addr_info *objfile_addrs; - struct section_offsets *new_debug_offsets; struct cleanup *my_cleanups; objfile_addrs = build_section_addr_info_from_objfile (objfile); @@ -874,14 +930,13 @@ objfile_relocate (struct objfile *objfile, gdb_assert (debug_objfile->num_sections == gdb_bfd_count_sections (debug_objfile->obfd)); - new_debug_offsets = - xmalloc (SIZEOF_N_SECTION_OFFSETS (debug_objfile->num_sections)); - make_cleanup (xfree, new_debug_offsets); - relative_addr_info_to_section_offsets (new_debug_offsets, + std::vector + new_debug_offsets (SIZEOF_N_SECTION_OFFSETS (debug_objfile->num_sections)); + relative_addr_info_to_section_offsets (new_debug_offsets.data (), debug_objfile->num_sections, objfile_addrs); - changed |= objfile_relocate1 (debug_objfile, new_debug_offsets); + changed |= objfile_relocate1 (debug_objfile, new_debug_offsets.data ()); do_cleanups (my_cleanups); } @@ -954,7 +1009,7 @@ objfile_has_partial_symbols (struct objfile *objfile) int objfile_has_full_symbols (struct objfile *objfile) { - return objfile->symtabs != NULL; + return objfile->compunit_symtabs != NULL; } /* Return non-zero if OBJFILE has full or partial symbols, either directly @@ -1023,7 +1078,7 @@ objfile_purge_solibs (void) be soon. */ if (!(objf->flags & OBJF_USERLOADED) && (objf->flags & OBJF_SHARED)) - free_objfile (objf); + delete objf; } } @@ -1039,7 +1094,7 @@ have_minimal_symbols (void) ALL_OBJFILES (ofp) { - if (ofp->minimal_symbol_count > 0) + if (ofp->per_bfd->minimal_symbol_count > 0) { return 1; } @@ -1309,7 +1364,7 @@ update_section_map (struct program_space *pspace, return; } - map = xmalloc (alloc_size * sizeof (*map)); + map = XNEWVEC (struct obj_section *, alloc_size); i = 0; ALL_PSPACE_OBJFILES (pspace, objfile) @@ -1323,7 +1378,7 @@ update_section_map (struct program_space *pspace, if (map_size < alloc_size) /* Some sections were eliminated. Trim excess space. */ - map = xrealloc (map, map_size * sizeof (*map)); + map = XRESIZEVEC (struct obj_section *, map, map_size); else gdb_assert (alloc_size == map_size); @@ -1396,7 +1451,7 @@ find_pc_section (CORE_ADDR pc) /* Return non-zero if PC is in a section called NAME. */ int -pc_in_section (CORE_ADDR pc, char *name) +pc_in_section (CORE_ADDR pc, const char *name) { struct obj_section *s; int retval = 0; @@ -1441,7 +1496,7 @@ resume_section_map_updates (struct program_space *pspace) void resume_section_map_updates_cleanup (void *arg) { - resume_section_map_updates (arg); + resume_section_map_updates ((struct program_space *) arg); } /* Return 1 if ADDR maps into one of the sections of OBJFILE and 0 @@ -1467,6 +1522,22 @@ is_addr_in_objfile (CORE_ADDR addr, const struct objfile *objfile) return 0; } +int +shared_objfile_contains_address_p (struct program_space *pspace, + CORE_ADDR address) +{ + struct objfile *objfile; + + ALL_PSPACE_OBJFILES (pspace, objfile) + { + if ((objfile->flags & OBJF_SHARED) != 0 + && is_addr_in_objfile (address, objfile)) + return 1; + } + + return 0; +} + /* The default implementation for the "iterate_over_objfiles_in_search_order" gdbarch method. It is equivalent to use the ALL_OBJFILES macro, searching the objfiles in the order they are stored internally, @@ -1492,7 +1563,7 @@ default_iterate_over_objfiles_in_search_order } } -/* Return canonical name for OBJFILE. */ +/* See objfiles.h. */ const char * objfile_name (const struct objfile *objfile) @@ -1503,8 +1574,34 @@ objfile_name (const struct objfile *objfile) return objfile->original_name; } -/* Provide a prototype to silence -Wmissing-prototypes. */ -extern initialize_file_ftype _initialize_objfiles; +/* See objfiles.h. */ + +const char * +objfile_filename (const struct objfile *objfile) +{ + if (objfile->obfd != NULL) + return bfd_get_filename (objfile->obfd); + + return NULL; +} + +/* See objfiles.h. */ + +const char * +objfile_debug_name (const struct objfile *objfile) +{ + return lbasename (objfile->original_name); +} + +/* See objfiles.h. */ + +const char * +objfile_flavour_name (struct objfile *objfile) +{ + if (objfile->obfd != NULL) + return bfd_flavour_name (bfd_get_flavour (objfile->obfd)); + return NULL; +} void _initialize_objfiles (void)