230 lines
6.7 KiB
Diff
230 lines
6.7 KiB
Diff
Index: objfiles.c
|
|
===================================================================
|
|
RCS file: /cvs/src/src/gdb/objfiles.c,v
|
|
retrieving revision 1.93
|
|
diff -p -u -r1.93 objfiles.c
|
|
--- ./gdb/objfiles.c 21 Aug 2009 17:57:17 -0000 1.93
|
|
+++ ./gdb/objfiles.c 26 Aug 2009 07:07:04 -0000
|
|
@@ -790,15 +790,9 @@ qsort_cmp (const void *a, const void *b)
|
|
const CORE_ADDR sect2_addr = obj_section_addr (sect2);
|
|
|
|
if (sect1_addr < sect2_addr)
|
|
- {
|
|
- gdb_assert (obj_section_endaddr (sect1) <= sect2_addr);
|
|
- return -1;
|
|
- }
|
|
+ return -1;
|
|
else if (sect1_addr > sect2_addr)
|
|
- {
|
|
- gdb_assert (sect1_addr >= obj_section_endaddr (sect2));
|
|
- return 1;
|
|
- }
|
|
+ return 1;
|
|
|
|
return 0;
|
|
}
|
|
@@ -823,12 +817,133 @@ preferred_obj_section (struct obj_sectio
|
|
return b;
|
|
}
|
|
|
|
+/* Return 1 if SECTION should be inserted into the section map.
|
|
+ We want to insert only non-overlay and non-TLS section. */
|
|
+
|
|
+static int
|
|
+insert_section_p (const struct bfd *abfd,
|
|
+ const struct bfd_section *section)
|
|
+{
|
|
+ const bfd_vma lma = bfd_section_lma (abfd, section);
|
|
+
|
|
+ if (lma != 0 && lma != bfd_section_vma (abfd, section)
|
|
+ && (bfd_get_file_flags (abfd) & BFD_IN_MEMORY) == 0)
|
|
+ /* This is an overlay section. IN_MEMORY check is needed to avoid
|
|
+ discarding sections from the "system supplied DSO" (aka vdso)
|
|
+ on Linux. */
|
|
+ return 0;
|
|
+ if ((bfd_get_section_flags (abfd, section) & SEC_THREAD_LOCAL) != 0)
|
|
+ /* This is a TLS section. */
|
|
+ return 0;
|
|
+
|
|
+ return 1;
|
|
+}
|
|
+
|
|
+/* Filter out overlapping sections where one section came from the real
|
|
+ objfile, and the other from a separate debuginfo file.
|
|
+ Return the size of table after redundant sections have been eliminated. */
|
|
+
|
|
+static int
|
|
+filter_debuginfo_sections (struct obj_section **map, int map_size)
|
|
+{
|
|
+ int i, j;
|
|
+
|
|
+ for (i = 0, j = 0; i < map_size - 1; i++)
|
|
+ {
|
|
+ struct obj_section *const sect1 = map[i];
|
|
+ struct obj_section *const sect2 = map[i + 1];
|
|
+ const struct objfile *const objfile1 = sect1->objfile;
|
|
+ const struct objfile *const objfile2 = sect2->objfile;
|
|
+ const CORE_ADDR sect1_addr = obj_section_addr (sect1);
|
|
+ const CORE_ADDR sect2_addr = obj_section_addr (sect2);
|
|
+
|
|
+ if (sect1_addr == sect2_addr
|
|
+ && (objfile1->separate_debug_objfile == objfile2
|
|
+ || objfile2->separate_debug_objfile == objfile1))
|
|
+ {
|
|
+ map[j++] = preferred_obj_section (sect1, sect2);
|
|
+ ++i;
|
|
+ }
|
|
+ else
|
|
+ map[j++] = sect1;
|
|
+ }
|
|
+
|
|
+ if (i < map_size)
|
|
+ map[j++] = map[i];
|
|
+
|
|
+ /* The map should not have shrunk to less than half the original size. */
|
|
+ gdb_assert (map_size / 2 <= j);
|
|
+
|
|
+ return j;
|
|
+}
|
|
+
|
|
+/* Filter out overlapping sections, issuing a warning if any are found.
|
|
+ Overlapping sections could really be overlay sections which we didn't
|
|
+ classify as such in insert_section_p, or we could be dealing with a
|
|
+ corrupt binary. */
|
|
+
|
|
+static int
|
|
+filter_overlapping_sections (struct obj_section **map, int map_size)
|
|
+{
|
|
+ int i, j;
|
|
+
|
|
+ for (i = 0, j = 0; i < map_size - 1; )
|
|
+ {
|
|
+ int k;
|
|
+
|
|
+ map[j++] = map[i];
|
|
+ for (k = i + 1; k < map_size; k++)
|
|
+ {
|
|
+ struct obj_section *const sect1 = map[i];
|
|
+ struct obj_section *const sect2 = map[k];
|
|
+ const CORE_ADDR sect1_addr = obj_section_addr (sect1);
|
|
+ const CORE_ADDR sect2_addr = obj_section_addr (sect2);
|
|
+ const CORE_ADDR sect1_endaddr = obj_section_endaddr (sect1);
|
|
+
|
|
+ gdb_assert (sect1_addr <= sect2_addr);
|
|
+
|
|
+ if (sect1_endaddr <= sect2_addr)
|
|
+ break;
|
|
+ else
|
|
+ {
|
|
+ /* We have an overlap. Report it. */
|
|
+
|
|
+ struct objfile *const objf1 = sect1->objfile;
|
|
+ struct objfile *const objf2 = sect2->objfile;
|
|
+
|
|
+ const struct bfd *const abfd1 = objf1->obfd;
|
|
+ const struct bfd *const abfd2 = objf2->obfd;
|
|
+
|
|
+ const struct bfd_section *const bfds1 = sect1->the_bfd_section;
|
|
+ const struct bfd_section *const bfds2 = sect2->the_bfd_section;
|
|
+
|
|
+ const CORE_ADDR sect2_endaddr = obj_section_endaddr (sect2);
|
|
+
|
|
+ struct gdbarch *const gdbarch = get_objfile_arch (objf1);
|
|
+
|
|
+ warning (_("Unexpected overlap between "
|
|
+ "section `%s' from `%s' [%s, %s) and "
|
|
+ "section `%s' from `%s' [%s, %s)"),
|
|
+ bfd_section_name (abfd1, bfds1), objf1->name,
|
|
+ paddress (gdbarch, sect1_addr),
|
|
+ paddress (gdbarch, sect1_endaddr),
|
|
+ bfd_section_name (abfd2, bfds2), objf2->name,
|
|
+ paddress (gdbarch, sect2_addr),
|
|
+ paddress (gdbarch, sect2_endaddr));
|
|
+ }
|
|
+ }
|
|
+ i = k;
|
|
+ }
|
|
+ return map_size;
|
|
+}
|
|
+
|
|
+
|
|
/* 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;
|
|
+ int alloc_size, map_size, i;
|
|
struct obj_section *s, **map;
|
|
struct objfile *objfile;
|
|
|
|
@@ -837,55 +952,27 @@ update_section_map (struct obj_section *
|
|
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;
|
|
+ alloc_size = 0;
|
|
ALL_OBJSECTIONS (objfile, s)
|
|
- if (insert_p (objfile, s))
|
|
- map_size += 1;
|
|
+ if (insert_section_p (objfile->obfd, s->the_bfd_section))
|
|
+ alloc_size += 1;
|
|
|
|
- map = xmalloc (map_size * sizeof (*map));
|
|
+ map = xmalloc (alloc_size * sizeof (*map));
|
|
|
|
i = 0;
|
|
ALL_OBJSECTIONS (objfile, s)
|
|
- if (insert_p (objfile, s))
|
|
+ if (insert_section_p (objfile->obfd, s->the_bfd_section))
|
|
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. */
|
|
- }
|
|
+ qsort (map, alloc_size, sizeof (*map), qsort_cmp);
|
|
+ map_size = filter_debuginfo_sections(map, alloc_size);
|
|
+ map_size = filter_overlapping_sections(map, map_size);
|
|
+
|
|
+ if (map_size < alloc_size)
|
|
+ /* Some sections were eliminated. Trim excess space. */
|
|
+ map = xrealloc (map, map_size * sizeof (*map));
|
|
else
|
|
- gdb_assert (j == map_size);
|
|
+ gdb_assert (alloc_size == map_size);
|
|
|
|
*pmap = map;
|
|
*pmap_size = map_size;
|