/* GDB routines for manipulating objfiles.
Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001,
- 2002, 2003, 2004, 2007, 2008 Free Software Foundation, Inc.
+ 2002, 2003, 2004, 2007, 2008, 2009 Free Software Foundation, Inc.
Contributed by Cygnus Support, using pieces from other GDB modules.
#include "addrmap.h"
#include "arch-utils.h"
#include "exec.h"
+#include "observer.h"
/* Prototypes for local functions */
struct objfile *symfile_objfile; /* Main symbol table loaded from */
struct objfile *rt_common_objfile; /* For runtime common symbols */
+/* Records whether any objfiles appeared or disappeared since we last updated
+ address to obj section map. */
+
+static int objfiles_changed_p;
+
/* Locate all mappable sections of a BFD file.
objfile_p_char is a char * to get it through
bfd_map_over_sections; we cast it back to its proper type. */
-#ifndef TARGET_KEEP_SECTION
-#define TARGET_KEEP_SECTION(ASECT) 0
-#endif
-
/* Called via bfd_map_over_sections to build up the section table that
the objfile references. The objfile contains pointers to the start
of the table (objfile->sections) and to the first location after
aflag = bfd_get_section_flags (abfd, asect);
- if (!(aflag & SEC_ALLOC) && !(TARGET_KEEP_SECTION (asect)))
+ if (!(aflag & SEC_ALLOC))
return;
if (0 == bfd_section_size (abfd, asect))
return;
- section.offset = 0;
section.objfile = objfile;
section.the_bfd_section = asect;
section.ovly_mapped = 0;
- section.addr = bfd_section_vma (abfd, asect);
- section.endaddr = section.addr + bfd_section_size (abfd, asect);
obstack_grow (&objfile->objfile_obstack, (char *) §ion, sizeof (section));
- objfile->sections_end = (struct obj_section *) (((unsigned long) objfile->sections_end) + 1);
+ objfile->sections_end
+ = (struct obj_section *) (((size_t) objfile->sections_end) + 1);
}
/* Builds a section table for OBJFILE.
waste some memory. */
objfile->sections_end = 0;
- bfd_map_over_sections (objfile->obfd, add_to_objfile_sections, (char *) objfile);
- objfile->sections = (struct obj_section *)
- obstack_finish (&objfile->objfile_obstack);
- objfile->sections_end = objfile->sections + (unsigned long) objfile->sections_end;
+ bfd_map_over_sections (objfile->obfd,
+ add_to_objfile_sections, (void *) objfile);
+ objfile->sections = obstack_finish (&objfile->objfile_obstack);
+ objfile->sections_end = objfile->sections + (size_t) objfile->sections_end;
return (0);
}
{
objfile = (struct objfile *) xmalloc (sizeof (struct objfile));
memset (objfile, 0, sizeof (struct objfile));
- objfile->md = NULL;
objfile->psymbol_cache = bcache_xmalloc ();
objfile->macro_cache = bcache_xmalloc ();
/* We could use obstack_specify_allocation here instead, but
that any data that is reference is saved in the per-objfile data
region. */
- objfile->obfd = abfd;
+ objfile->obfd = gdb_bfd_ref (abfd);
if (objfile->name != NULL)
{
xfree (objfile->name);
/* Save passed in flag bits. */
objfile->flags |= flags;
+ objfiles_changed_p = 1; /* Rebuild section map next time we need it. */
+
return (objfile);
}
CORE_ADDR
entry_point_address (void)
{
- return symfile_objfile ? symfile_objfile->ei.entry_point : 0;
+ struct gdbarch *gdbarch;
+ CORE_ADDR entry_point;
+
+ if (symfile_objfile == NULL)
+ return 0;
+
+ gdbarch = get_objfile_arch (symfile_objfile);
+
+ entry_point = symfile_objfile->ei.entry_point;
+
+ /* Make certain that the address points at real code, and not a
+ function descriptor. */
+ entry_point = gdbarch_convert_from_func_ptr_addr (gdbarch, entry_point,
+ ¤t_target);
+
+ /* Remove any ISA markers, so that this matches entries in the
+ symbol table. */
+ entry_point = gdbarch_addr_bits_remove (gdbarch, entry_point);
+
+ return entry_point;
}
/* Create the terminating entry of OBJFILE's minimal symbol table.
(*objfile->sf->sym_finish) (objfile);
}
- /* We always close the bfd. */
+ /* Discard any data modules have associated with the objfile. */
+ objfile_free_data (objfile);
- if (objfile->obfd != NULL)
- {
- char *name = bfd_get_filename (objfile->obfd);
- if (!bfd_close (objfile->obfd))
- warning (_("cannot close \"%s\": %s"),
- name, bfd_errmsg (bfd_get_error ()));
- xfree (name);
- }
+ gdb_bfd_unref (objfile->obfd);
/* Remove it from the chain of all objfiles. */
/* The last thing we do is free the objfile struct itself. */
- objfile_free_data (objfile);
if (objfile->name != NULL)
{
xfree (objfile->name);
obstack_free (&objfile->objfile_obstack, 0);
xfree (objfile);
objfile = NULL;
+ objfiles_changed_p = 1; /* Rebuild section map next time we need it. */
}
static void
continue;
bv = BLOCKVECTOR (s);
+ if (BLOCKVECTOR_MAP (bv))
+ addrmap_relocate (BLOCKVECTOR_MAP (bv),
+ ANOFFSET (delta, s->block_line_section));
+
for (i = 0; i < BLOCKVECTOR_NBLOCKS (bv); ++i)
{
struct block *b;
b = BLOCKVECTOR_BLOCK (bv, i);
BLOCK_START (b) += ANOFFSET (delta, s->block_line_section);
BLOCK_END (b) += ANOFFSET (delta, s->block_line_section);
- if (BLOCKVECTOR_MAP (bv))
- addrmap_relocate (BLOCKVECTOR_MAP (bv),
- ANOFFSET (delta, s->block_line_section));
ALL_BLOCK_SYMBOLS (b, iter, sym)
{
to be out of order. */
msymbols_sort (objfile);
- {
- int i;
- for (i = 0; i < objfile->num_sections; ++i)
- (objfile->section_offsets)->offsets[i] = ANOFFSET (new_offsets, i);
- }
-
if (objfile->ei.entry_point != ~(CORE_ADDR) 0)
{
/* Relocate ei.entry_point with its section offset, use SECT_OFF_TEXT
}
{
- struct obj_section *s;
- bfd *abfd;
-
- abfd = objfile->obfd;
-
- ALL_OBJFILE_OSECTIONS (objfile, s)
- {
- int idx = s->the_bfd_section->index;
-
- s->addr += ANOFFSET (delta, idx);
- s->endaddr += ANOFFSET (delta, idx);
- }
+ int i;
+ for (i = 0; i < objfile->num_sections; ++i)
+ (objfile->section_offsets)->offsets[i] = ANOFFSET (new_offsets, i);
}
+ /* Rebuild section map next time we need it. */
+ objfiles_changed_p = 1;
+
/* Update the table in exec_ops, used to read memory. */
ALL_OBJFILE_OSECTIONS (objfile, s)
{
int idx = s->the_bfd_section->index;
exec_set_section_address (bfd_get_filename (objfile->obfd), idx,
- s->addr);
+ obj_section_addr (s));
}
/* Relocate breakpoints as necessary, after things are relocated. */
breakpoint_re_set ();
}
\f
+/* Return non-zero if OBJFILE has partial symbols. */
+
+int
+objfile_has_partial_symbols (struct objfile *objfile)
+{
+ return objfile->psymtabs != NULL;
+}
+
+/* Return non-zero if OBJFILE has full symbols. */
+
+int
+objfile_has_full_symbols (struct objfile *objfile)
+{
+ return objfile->symtabs != NULL;
+}
+
/* Many places in gdb want to test just to see if we have any partial
symbols available. This function returns zero if none are currently
available, nonzero otherwise. */
ALL_OBJFILES (ofp)
{
- if (ofp->psymtabs != NULL)
- {
- return 1;
- }
+ if (objfile_has_partial_symbols (ofp))
+ return 1;
}
return 0;
}
ALL_OBJFILES (ofp)
{
- if (ofp->symtabs != NULL)
- {
- return 1;
- }
+ if (objfile_has_full_symbols (ofp))
+ return 1;
}
return 0;
}
return 0;
}
-/* Returns a section whose range includes PC and SECTION, or NULL if
- none found. Note the distinction between the return type, struct
- obj_section (which is defined in gdb), and the input type "struct
- bfd_section" (which is a bfd-defined data type). The obj_section
- contains a pointer to the "struct bfd_section". */
+/* Qsort comparison function. */
-struct obj_section *
-find_pc_sect_section (CORE_ADDR pc, struct bfd_section *section)
+static int
+qsort_cmp (const void *a, const void *b)
{
- struct obj_section *s;
+ const struct obj_section *sect1 = *(const struct obj_section **) a;
+ const struct obj_section *sect2 = *(const struct obj_section **) b;
+ const CORE_ADDR sect1_addr = obj_section_addr (sect1);
+ const CORE_ADDR sect2_addr = obj_section_addr (sect2);
+
+ if (sect1_addr < sect2_addr)
+ {
+ gdb_assert (obj_section_endaddr (sect1) <= sect2_addr);
+ return -1;
+ }
+ else if (sect1_addr > sect2_addr)
+ {
+ gdb_assert (sect1_addr >= obj_section_endaddr (sect2));
+ return 1;
+ }
+
+ return 0;
+}
+
+/* Select "better" obj_section to keep. We prefer the one that came from
+ the real object, rather than the one from separate debuginfo.
+ Most of the time the two sections are exactly identical, but with
+ prelinking the .rel.dyn section in the real object may have different
+ size. */
+
+static struct obj_section *
+preferred_obj_section (struct obj_section *a, struct obj_section *b)
+{
+ gdb_assert (obj_section_addr (a) == obj_section_addr (b));
+ gdb_assert ((a->objfile->separate_debug_objfile == b->objfile)
+ || (b->objfile->separate_debug_objfile == a->objfile));
+ gdb_assert ((a->objfile->separate_debug_objfile_backlink == b->objfile)
+ || (b->objfile->separate_debug_objfile_backlink == a->objfile));
+
+ if (a->objfile->separate_debug_objfile != NULL)
+ return a;
+ return b;
+}
+
+/* Update PMAP, PMAP_SIZE with non-TLS sections from all objfiles. */
+
+static void
+update_section_map (struct obj_section ***pmap, int *pmap_size)
+{
+ int map_size, i, j;
+ struct obj_section *s, **map;
struct objfile *objfile;
+ gdb_assert (objfiles_changed_p != 0);
+
+ map = *pmap;
+ xfree (map);
+
+#define insert_p(objf, sec) \
+ ((bfd_get_section_flags ((objf)->obfd, (sec)->the_bfd_section) \
+ & SEC_THREAD_LOCAL) == 0)
+
+ map_size = 0;
ALL_OBJSECTIONS (objfile, s)
- if ((section == 0 || section == s->the_bfd_section) &&
- s->addr <= pc && pc < s->endaddr)
- return (s);
+ if (insert_p (objfile, s))
+ map_size += 1;
+
+ map = xmalloc (map_size * sizeof (*map));
+
+ i = 0;
+ ALL_OBJSECTIONS (objfile, s)
+ if (insert_p (objfile, s))
+ map[i++] = s;
+
+#undef insert_p
+
+ qsort (map, map_size, sizeof (*map), qsort_cmp);
+
+ /* With separate debuginfo files, we may have up to two (almost)
+ identical copies of some obj_sections in the map.
+ Filter out duplicates. */
+ for (i = 0, j = 0; i < map_size; ++i)
+ {
+ struct obj_section *sect1 = map[i];
+ struct obj_section *sect2 = (i + 1 < map_size) ? map[i + 1] : NULL;
+
+ if (sect2 == NULL
+ || obj_section_addr (sect1) != obj_section_addr (sect2))
+ map[j++] = sect1;
+ else
+ {
+ map[j++] = preferred_obj_section (sect1, sect2);
+ ++i;
+ }
+ }
+
+ if (j < map_size)
+ {
+ /* Some duplicates were eliminated.
+ The new size shouldn't be less than half of the original. */
+ gdb_assert (map_size / 2 <= j);
+ map_size = j;
+
+ map = xrealloc (map, map_size * sizeof (*map)); /* Trim excess space. */
+ }
+ else
+ gdb_assert (j == map_size);
- return (NULL);
+ *pmap = map;
+ *pmap_size = map_size;
}
-/* Returns a section whose range includes PC or NULL if none found.
- Backward compatibility, no section. */
+/* Bsearch comparison function. */
+
+static int
+bsearch_cmp (const void *key, const void *elt)
+{
+ const CORE_ADDR pc = *(CORE_ADDR *) key;
+ const struct obj_section *section = *(const struct obj_section **) elt;
+
+ if (pc < obj_section_addr (section))
+ return -1;
+ if (pc < obj_section_endaddr (section))
+ return 0;
+ return 1;
+}
+
+/* Returns a section whose range includes PC or NULL if none found. */
struct obj_section *
find_pc_section (CORE_ADDR pc)
{
- return find_pc_sect_section (pc, find_pc_mapped_section (pc));
+ static struct obj_section **sections;
+ static int num_sections;
+
+ struct obj_section *s, **sp;
+
+ /* Check for mapped overlay section first. */
+ s = find_pc_mapped_section (pc);
+ if (s)
+ return s;
+
+ if (objfiles_changed_p != 0)
+ {
+ update_section_map (§ions, &num_sections);
+
+ /* Don't need updates to section map until objfiles are added
+ or removed. */
+ objfiles_changed_p = 0;
+ }
+
+ sp = (struct obj_section **) bsearch (&pc, sections, num_sections,
+ sizeof (*sections), bsearch_cmp);
+ if (sp != NULL)
+ return *sp;
+ return NULL;
}
gdb_assert (data->index < objfile->num_data);
return objfile->data[data->index];
}
+
+/* Set objfiles_changed_p so section map will be rebuilt next time it
+ is used. Called by reread_symbols. */
+
+void
+objfiles_changed (void)
+{
+ objfiles_changed_p = 1; /* Rebuild section map next time we need it. */
+}
+
+/* Add reference to ABFD. Returns ABFD. */
+struct bfd *
+gdb_bfd_ref (struct bfd *abfd)
+{
+ int *p_refcount = bfd_usrdata (abfd);
+
+ if (p_refcount != NULL)
+ {
+ *p_refcount += 1;
+ return abfd;
+ }
+
+ p_refcount = xmalloc (sizeof (*p_refcount));
+ *p_refcount = 1;
+ bfd_usrdata (abfd) = p_refcount;
+
+ return abfd;
+}
+
+/* Unreference and possibly close ABFD. */
+void
+gdb_bfd_unref (struct bfd *abfd)
+{
+ int *p_refcount;
+ char *name;
+
+ if (abfd == NULL)
+ return;
+
+ p_refcount = bfd_usrdata (abfd);
+
+ /* Valid range for p_refcount: a pointer to int counter, which has a
+ value of 1 (single owner) or 2 (shared). */
+ gdb_assert (*p_refcount == 1 || *p_refcount == 2);
+
+ *p_refcount -= 1;
+ if (*p_refcount > 0)
+ return;
+
+ xfree (p_refcount);
+ bfd_usrdata (abfd) = NULL; /* Paranoia. */
+
+ name = bfd_get_filename (abfd);
+ if (!bfd_close (abfd))
+ warning (_("cannot close \"%s\": %s"),
+ name, bfd_errmsg (bfd_get_error ()));
+ xfree (name);
+}