gmane.comp.sysutils.elfutils.devel

FYI small test environment tweak

Mark Wielaard — 2012-05-11T11:08:56

I pushed the following:

commit dbbc67a97ace66c3adc299f26261fdec99d0c0d6
Author: Mark Wielaard <mjw< at >redhat.com>
Date:   Fri May 11 12:57:57 2012 +0200

    TESTS_ENVIRONMENT set LC_ALL and LANG to C.
    
    Some tests rely on sort order and output of tools that might be localized.
    
    Reported-by: Paweł Sikora <pluto< at >pld-linux.org>

diff --git a/tests/ChangeLog b/tests/ChangeLog
index 4c6e9f7..841742d 100644
--- a/tests/ChangeLog
+++ b/tests/ChangeLog
< at >< at > -1,3 +1,7 < at >< at >
+2012-05-11  Mark Wielaard  <mjw< at >redhat.com>
+
+       * Makefile.am (TESTS_ENVIRONMENT): Set LC_ALL and LANG to C.
+
 2012-05-07  Mark Wielaard  <mjw< at >redhat.com>
 
        * low_high_pc.c: Allow highpc == lowpc for CU DIEs for buggy GCC.
diff --git a/tests/Makefile.am b/tests/Makefile.am
index 61247e4..660791c 100644
--- a/tests/Makefile.am
+++ b/tests/Makefile.am
< at >< at > -169,13 +169,14 < at >< at > EXTRA_DIST = run-arextract.sh run-arsymtest.sh \
 
 installed_TESTS_ENVIRONMENT = libdir=$(DESTDIR)$(libdir) \
                              bindir=$(DESTDIR)$(bindir) \
+                             LC_ALL=C LANG=C \
                              $(srcdir)/test-wrapper.sh \
                              installed $(tests_rpath) \
                              $(program_transform_name)
 if STANDALONE
 TESTS_ENVIRONMENT = $(installed_TESTS_ENVIRONMENT)
 else !STANDALONE
-TESTS_ENVIRONMENT = $(srcdir)/test-wrapper.sh \
+TESTS_ENVIRONMENT = LC_ALL=C LANG=C $(srcdir)/test-wrapper.sh \
                    ../libdw:../backends:../libelf:../libasm
 
 installcheck-local:

_______________________________________________
elfutils-devel mailing list
elfutils-devel< at >lists.fedorahosted.org
https://fedorahosted.org/mailman/listinfo/elfutils-devel

Function symbol retention after stripping

Douglas, William — 2012-05-07T18:51:24

Hi all,

I'm trying to get gbd backtraces to give function names without having
a package's debuginfo installed. Would elfutils take a patch allowing
strip to take an option for keeping the minimal amount of information
needed to do this?

I'm still trying to figure out how to do this exactly but right now I
think I would be keeping SHT_SYMTAB and SHT_DYNSYM function symbols
but I haven't looked at this code before and I'm still trying to
figure out how it all comes together. Any advice would be appreciated
if you'd be okay with this functionality in elfutils.


Thanks,
William
_______________________________________________
elfutils-devel mailing list
elfutils-devel< at >lists.fedorahosted.org
https://fedorahosted.org/mailman/listinfo/elfutils-devel

FYI: tests/low_high_pc.c: Allow highpc == lowpc for CU DIEs forbuggy GCC.

Mark Wielaard — 2012-05-07T11:34:59

I pushed the following. Although the bug is fixed in GCC 4.7 that has
only been released last month. Most distros are still based on 4.6 or
lower.

commit d9bc75fc20f0ce5064cac192a518af3c7192e96d
Author: Mark Wielaard <mjw< at >redhat.com>
Date:   Mon May 7 13:29:52 2012 +0200

    tests/low_high_pc.c: Allow highpc == lowpc for CU DIEs for buggy GCC.
    
    GCC < 4.7 had a bug where no code CUs got a highpc == lowpc.
    Allow that, because it is not the main purpose of this test.

diff --git a/tests/ChangeLog b/tests/ChangeLog
index abc7340..4c6e9f7 100644
--- a/tests/ChangeLog
+++ b/tests/ChangeLog
< at >< at > -1,3 +1,7 < at >< at >
+2012-05-07  Mark Wielaard  <mjw< at >redhat.com>
+
+* low_high_pc.c: Allow highpc == lowpc for CU DIEs for buggy GCC.
+
 2012-04-27  Mark Wielaard  <mjw< at >redhat.com>
 
 * Makefile.am (TESTS): Add run-low_high_pc.sh
diff --git a/tests/low_high_pc.c b/tests/low_high_pc.c
index 3054046..6fc8b15 100644
--- a/tests/low_high_pc.c
+++ b/tests/low_high_pc.c
< at >< at > -72,9 +72,12 < at >< at > handle_die (Dwarf_Die *die, void *arg)
   if (dwarf_highpc (die, &highpc) != 0 && dwarf_hasattr (die, DW_AT_high_pc))
     fail (off, name, "has DW_AT_high_pc but dwarf_highpc fails");
 
+  /* GCC < 4.7 had a bug where no code CUs got a highpc == lowpc.
+     Allow that, because it is not the main purpose of this test.  */
   if (dwarf_hasattr (die, DW_AT_low_pc)
       && dwarf_hasattr (die, DW_AT_high_pc)
-      && highpc <= lowpc)
+      && highpc <= lowpc
+      && ! (dwarf_tag (die) == DW_TAG_compile_unit && highpc == lowpc))
     {
       printf("lowpc: %lx, highpc: %lx\n", lowpc, highpc);
       fail (off, name, "highpc <= lowpc");

_______________________________________________
elfutils-devel mailing list
elfutils-devel< at >lists.fedorahosted.org
https://fedorahosted.org/mailman/listinfo/elfutils-devel

PATCH: dwarf_highpc: Handle DW_AT_high_pc being a constant offsetfrom DW_AT_low_pc.

Mark Wielaard — 2012-04-27T11:11:27

Hi,

The DWARF spec says (since version 4) that DW_AT_high_pc can be
represented by a constant form.

        If the value of the DW_AT_high_pc is of class address, it is the
        relocated address of the first location past the last
        instruction associated with the entity; if it is of class
        constant, the value is an unsigned integer offset which when
        added to the low PC gives the address of the first location past
        the last instruction associated with the entity.

I have a patch for gcc to encode DW_AT_high_pc this way (which saves a
lot of relocations) and jakub has a patch for dwz to encode
DW_AT_high_pc in the smallest possible constant form, which can save ~1%
on the size of debuginfo.

The attached patch adds a testcase for this and makes dwarf_highpc ()
handle the constant form.

Does this look OK?

Thanks,

Mark
_______________________________________________
elfutils-devel mailing list
elfutils-devel< at >lists.fedorahosted.org
https://fedorahosted.org/mailman/listinfo/elfutils-devel

FYI: Removed old libdwarf test show-ciefde.

Mark Wielaard — 2012-04-26T10:28:10

Hi,

elfutils libdwarf was removed a long time ago and this testcase was
never actually ran anyway (which is why nobody noticed it was broken).
I just removed it.

commit bdad8e39aede889dbac95944a07eaebdebe4ad89
Author: Mark Wielaard <mjw< at >redhat.com>
Date:   Thu Apr 26 12:24:33 2012 +0200

    Removed old libdwarf test show-ciefde.

diff --git a/tests/ChangeLog b/tests/ChangeLog
index c38ede5..ffe61d5 100644
--- a/tests/ChangeLog
+++ b/tests/ChangeLog
< at >< at > -1,3 +1,9 < at >< at >
+2012-04-26  Mark Wielaard  <mjw< at >redhat.com>
+
+       * Makefile.am (EXTRA_DIST): Remove run-show-ciefde.sh.
+       * run-show-ciefde.sh: Removed old libdwarf test.
+       * show-ciefde.c: Likewise.

_______________________________________________
elfutils-devel mailing list
elfutils-devel< at >lists.fedorahosted.org
https://fedorahosted.org/mailman/listinfo/elfutils-devel

elflint: (zero sized section) alloc flag set but section not in anyloaded segment

Mark Wielaard — 2012-04-26T09:58:52

Hi,

Against development versions of gcc/binutils elflint gives some
complaints like:

section [24] '.tm_clone_table': alloc flag set but section not in any
loaded segment

This is because that section's size is zero. So it is somewhat
reasonable IMHO that the linker doesn't put it in any segment.

Is the following patch to elflint OK?

Thanks,

Mark
_______________________________________________
elfutils-devel mailing list
elfutils-devel< at >lists.fedorahosted.org
https://fedorahosted.org/mailman/listinfo/elfutils-devel

FYI: readelf.c (print_ops): Add missing DW_OP_GNU operands.

Mark Wielaard — 2012-04-24T10:00:24

Pushed the following commit as obvious.

commit 716486d5a15bdfb528c5d011dc623fa0f6fdc2af
Author: Mark Wielaard <mjw< at >redhat.com>
Date:   Tue Apr 24 11:56:42 2012 +0200

    readelf.c (print_ops): Add missing DW_OP_GNU operands.
    
    DW_OP_GNU_push_tls_address, DW_OP_GNU_uinit and DW_OP_GNU_encoded_addr.

diff --git a/src/ChangeLog b/src/ChangeLog
index 642df1b..cae5e6b 100644
--- a/src/ChangeLog
+++ b/src/ChangeLog
< at >< at > -1,3 +1,8 < at >< at >
+2012-04-24  Mark Wielaard  <mjw< at >redhat.com>
+
+* readelf.c (print_ops): Add DW_OP_GNU_push_tls_address,
+DW_OP_GNU_uinit and DW_OP_GNU_encoded_addr.
+
 2012-03-28  Roland McGrath  <roland< at >hack.frob.com>
 
 * elflint.c (special_sections): Accept SHF_INFO_LINK for reloc sections.
diff --git a/src/readelf.c b/src/readelf.c
index b70779d..b4e9fc8 100644
--- a/src/readelf.c
+++ b/src/readelf.c
< at >< at > -4065,6 +4065,9 < at >< at > print_ops (Dwfl_Module *dwflmod, Dwarf *dbg, int indent, int indentrest,
       [DW_OP_bit_piece] = "bit_piece",
       [DW_OP_implicit_value] = "implicit_value",
       [DW_OP_stack_value] = "stack_value",
+      [DW_OP_GNU_push_tls_address] = "GNU_push_tls_address",
+      [DW_OP_GNU_uninit] = "GNU_uninit",
+      [DW_OP_GNU_encoded_addr] = "GNU_encoded_addr",
       [DW_OP_GNU_implicit_pointer] = "GNU_implicit_pointer",
       [DW_OP_GNU_entry_value] = "GNU_entry_value",
       [DW_OP_GNU_const_type] = "GNU_const_type",

_______________________________________________
elfutils-devel mailing list
elfutils-devel< at >lists.fedorahosted.org
https://fedorahosted.org/mailman/listinfo/elfutils-devel

Elfutils 0.153 build problem

Zachary McGrew — 2012-04-13T00:54:22

I'm trying (and failing) to build elfutils 0.153 on my i686 Linux box.

The lines around the error are:

gcc -std=gnu99 -Wall -Wshadow -Werror -Wunused -Wextra -Wformat=2
-g -O2   -o libdw.so -shared -o libdw.so
-Wl,--soname,libdw.so.1,-z,defs \
-Wl,--enable-new-dtags,-rpath,/usr/lib/elfutils \
-Wl,--version-script,libdw.map,--no-undefined \
-Wl,--whole-archive libdw_pic.a ../libdwfl/libdwfl_pic.a
../libebl/libebl.a ../libelf/libelf.so -Wl,--no-whole-archive\
-ldl -llzma -lbz2 -lz
if readelf -d libdw.so | fgrep -q TEXTREL; then exit 1; fi
make[1]: *** [libdw.so] Error 1

For good measure I ran "readelf -d | fgrep TEXTREL" on libdl.so,
liblzma.so, libbz2.so, and libz.so, but they all come back clean.

Running readelf -d libdw.so gets me:

Dynamic section at offset 0x49a60 contains 32 entries:
  Tag        Type                         Name/Value
 0x00000001 (NEEDED)                     Shared library: [libelf.so.1]
 0x00000001 (NEEDED)                     Shared library: [libdl.so.2]
 0x00000001 (NEEDED)                     Shared library: [liblzma.so.5]
 0x00000001 (NEEDED)                     Shared library: [libbz2.so.1.0]
 0x00000001 (NEEDED)                     Shared library: [libc.so.6]
 0x00000001 (NEEDED)                     Shared library: [ld-linux.so.2]
 0x0000000e (SONAME)                     Library soname: [libdw.so.1]
 0x0000000f (RPATH)                      Library rpath: [/usr/lib/elfutils]
 0x0000001d (RUNPATH)                    Library runpath: [/usr/lib/elfutils]
 0x0000000c (INIT)                       0x542c
 0x0000000d (FINI)                       0x39f58
 0x00000004 (HASH)                       0xf4
 0x00000005 (STRTAB)                     0x1df0
 0x00000006 (SYMTAB)                     0xa10
 0x0000000a (STRSZ)                      4725 (bytes)
 0x0000000b (SYMENT)                     16 (bytes)
 0x00000003 (PLTGOT)                     0x4abb0
 0x00000002 (PLTRELSZ)                   992 (bytes)
 0x00000014 (PLTREL)                     REL
 0x00000017 (JMPREL)                     0x504c
 0x00000011 (REL)                        0x35bc
 0x00000012 (RELSZ)                      6800 (bytes)
 0x00000013 (RELENT)                     8 (bytes)
 0x00000016 (TEXTREL)                    0x0
 0x6ffffffc (VERDEF)                     0x32e4
 0x6ffffffd (VERDEFNUM)                  14
 0x0000001e (FLAGS)                      TEXTREL
 0x6ffffffe (VERNEED)                    0x34cc
 0x6fffffff (VERNEEDNUM)                 4
 0x6ffffff0 (VERSYM)                     0x3066
 0x6ffffffa (RELCOUNT)                   764
 0x00000000 (NULL)                       0x0


Here's the following versions of packages installed:
gcc 4.6.3
binutils 2.22
glibc 2.15
Linux 3.3.1

Any ideas? I'm stumped.

[Patch] gelf_offscn vs SHT_NOBITS

Mark Wielaard — 2012-04-02T15:34:41

Hi,

While coming up with a test case for rhbz#807823 "elflint doesn't
recognize SHF_INFO_LINK on relocation sections", I came across another
issue. Not just with elflint, but also with readelf -d. If there is a
SHT_NOBITS section before the .dynamic section then gelf_offscn will
miss it. The solution is similar to commit e9c4e8 (Do not match empty
sections at OFFSET), skip SHT_NOBITS sections too if there is a "real"
section at the same offset that does have content. Does the solution
look sane?

The test binary is a testcase for both this issue and the original
rhbz#807823. Both tests fail before and succeed after the fixes.

Patch attached and in git on the mjw/offscn_nobits branch for those that
want to check out the test binary.

Cheers,

Mark
commit 191d1f0b9163593eee8c4f5cbe3e95cabf6ae9a9
Author: Mark Wielaard <mjw< at >redhat.com>
Date:   Mon Apr 2 17:11:25 2012 +0200

    elf32_offscn.c: Do not match SHT_NOBITS sections at OFFSET.
    
    readelf -d doesn't work if a SHT_NOBITS section is right before the actual
    .dynamic section at the same offset. elflint also fails on such binaries.
    So skip SHT_NOBITS sections at the same offset in [g]elf[32|64]_offscn().

diff --git a/libelf/ChangeLog b/libelf/ChangeLog
index 19b76e8..89dd35f 100644
--- a/libelf/ChangeLog
+++ b/libelf/ChangeLog
< at >< at > -1,3 +1,8 < at >< at >
+2012-04-02  Mark Wielaard  <mjw< at >redhat.com>
+
+* elf32_offscn.c: Do not match SHT_NOBITS sections at OFFSET unless
+there are no nonempty sections at that offset.
+
 2012-03-21  Roland McGrath  <roland< at >hack.frob.com>
 
 * elf-knowledge.h (SECTION_STRIP_P): Remove < SHT_NUM check.
diff --git a/libelf/elf32_offscn.c b/libelf/elf32_offscn.c
index 86eff8b..5dcfc4a 100644
--- a/libelf/elf32_offscn.c
+++ b/libelf/elf32_offscn.c
< at >< at > -101,7 +101,8 < at >< at > elfw2(LIBELFBITS,offscn) (elf, offset)
     /* If this section is empty, the following one has the same
        sh_offset.  We presume the caller is looking for a nonempty
        section, so keep looking if this one is empty.  */
-    if (runp->data[i].shdr.ELFW(e,LIBELFBITS)->sh_size != 0)
+    if (runp->data[i].shdr.ELFW(e,LIBELFBITS)->sh_size != 0
+&& runp->data[i].shdr.ELFW(e,LIBELFBITS)->sh_type != SHT_NOBITS)
       goto out;
   }
 
diff --git a/tests/ChangeLog b/tests/ChangeLog
index 8d2b83f..6f6c592 100644
--- a/tests/ChangeLog
+++ b/tests/ChangeLog
< at >< at > -1,3 +1,10 < at >< at >
+2012-04-02  Mark Wielaard  <mjw< at >redhat.com>
+
+* Makefile.am (TESTS): Add run-readelf-d.sh.
+(EXTRA_DIST): Add testlib_dynseg.so.bz2 and run-readelf-d.sh.
+* run-readelf-d.sh: New test.
+* run-elflint-test.sh: Check new testfile.
+
 2012-03-21  Tom Tromey  <tromey< at >redhat.com>
 
 * typeiter.c: New file.
diff --git a/tests/Makefile.am b/tests/Makefile.am
index f2c211b..980aa12 100644
--- a/tests/Makefile.am
+++ b/tests/Makefile.am
< at >< at > -86,7 +86,8 < at >< at > TESTS = run-arextract.sh run-arsymtest.sh newfile test-nlist \
 run-disasm-x86.sh run-disasm-x86-64.sh \
 run-early-offscn.sh run-dwarf-getmacros.sh \
 run-test-flag-nobits.sh run-prelink-addr-test.sh \
-run-dwarf-getstring.sh run-rerequest_tag.sh run-typeiter.sh
+run-dwarf-getstring.sh run-rerequest_tag.sh run-typeiter.sh \
+run-readelf-d.sh
 # run-show-ciefde.sh
 
 if !STANDALONE
< at >< at > -162,7 +163,8 < at >< at > EXTRA_DIST = run-arextract.sh run-arsymtest.sh \
      testfile55-32.prelink.bz2 testfile55-64.bz2 \
      testfile55-64.debug.bz2 testfile55-64.prelink.bz2 \
      testfile56.bz2 testfile57.bz2 testfile58.bz2 \
-     run-typeiter.sh testfile59.bz2
+     run-typeiter.sh testfile59.bz2 \
+     run-readelf-d.sh testlib_dynseg.so.bz2
 
 installed_TESTS_ENVIRONMENT = libdir=$(DESTDIR)$(libdir) \
       bindir=$(DESTDIR)$(bindir) \
diff --git a/tests/run-elflint-test.sh b/tests/run-elflint-test.sh
index e0e1c54..0c872fe 100755
--- a/tests/run-elflint-test.sh
+++ b/tests/run-elflint-test.sh
< at >< at > -44,4 +44,8 < at >< at > testrun ../src/elflint -q --gnu-ld testfile42
 testfiles testfile46
 testrun ../src/elflint -q testfile46
 
+# see also run-readelf-d.sh
+testfiles testlib_dynseg.so
+testrun ../src/elflint -q --gnu-ld testlib_dynseg.so
+
 exit 0
diff --git a/tests/run-readelf-d.sh b/tests/run-readelf-d.sh
new file mode 100755
index 0000000..9022e70
--- /dev/null
+++ b/tests/run-readelf-d.sh
< at >< at > -0,0 +1,78 < at >< at >
+#! /bin/sh
+# Copyright (C) 2012 Red Hat, Inc.
+# This file is part of Red Hat elfutils.
+#
+# Red Hat elfutils is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by the
+# Free Software Foundation; version 2 of the License.
+#
+# Red Hat elfutils is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License along
+# with Red Hat elfutils; if not, write to the Free Software Foundation,
+# Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301 USA.
+#
+# Red Hat elfutils is an included package of the Open Invention Network.
+# An included package of the Open Invention Network is a package for which
+# Open Invention Network licensees cross-license their patents.  No patent
+# license is granted, either expressly or impliedly, by designation as an
+# included package.  Should you wish to participate in the Open Invention
+# Network licensing program, please visit www.openinventionnetwork.com
+# <http://www.openinventionnetwork.com>.
+
+. $srcdir/test-subr.sh
+
+# #include <stdio.h>
+# 
+# __thread int i;
+# 
+# void print_i ()
+# {
+#   printf("%d\n", i);
+# }
+#
+# gcc -fPIC -shared -o testlib_dynseg.so testlib_dynseg.c
+# With ld --version
+# GNU gold (GNU Binutils 2.22.52.20120402) 1.11
+
+testfiles testlib_dynseg.so
+
+testrun_compare ../src/readelf -d testlib_dynseg.so <<\EOF
+
+Dynamic segment contains 28 entries:
+ Addr: 0x00000000000017e0  Offset: 0x0007e0  Link to section: [ 3] '.dynstr'
+  Type              Value
+  PLTGOT            0x00000000000019c8
+  PLTRELSZ          72 (bytes)
+  JMPREL            0x0000000000000568
+  PLTREL            RELA
+  RELA              0x00000000000004d8
+  RELASZ            144 (bytes)
+  RELAENT           24 (bytes)
+  RELACOUNT         1
+  SYMTAB            0x0000000000000228
+  SYMENT            24 (bytes)
+  STRTAB            0x0000000000000360
+  STRSZ             190 (bytes)
+  GNU_HASH          0x0000000000000420
+  NEEDED            Shared library: [libc.so.6]
+  NEEDED            Shared library: [ld-linux-x86-64.so.2]
+  INIT              0x00000000000005b0
+  FINI              0x0000000000000748
+  VERSYM            0x0000000000000460
+  VERDEF            0x000000000000047c
+  VERDEFNUM         1
+  VERNEED           0x0000000000000498
+  VERNEEDNUM        2
+  NULL              
+  NULL              
+  NULL              
+  NULL              
+  NULL              
+  NULL              
+EOF
+
+exit 0
diff --git a/tests/testlib_dynseg.so.bz2 b/tests/testlib_dynseg.so.bz2
new file mode 100755
index 0000000..94296a4
Binary files /dev/null and b/tests/testlib_dynseg.so.bz2 differ
_______________________________________________
elfutils-devel mailing list
elfutils-devel< at >lists.fedorahosted.org
https://fedorahosted.org/mailman/listinfo/elfutils-devel

[Patch] Don't relocate compressed sections

Mark Wielaard — 2012-03-28T09:44:52

Hi,

As pointed out in https://bugzilla.redhat.com/show_bug.cgi?id=807053
relocating a compressed section will corrupt it. To more properly
support compressed sections we should finish the roland/relocate branch
for lazy relocations work. The best we can do for now is to not corrupt
the contents of the compressed sections and not crash when we don't have
all Dwarf debug section data. The attached two patches do that.

Cheers,

Mark
_______________________________________________
elfutils-devel mailing list
elfutils-devel< at >lists.fedorahosted.org
https://fedorahosted.org/mailman/listinfo/elfutils-devel

FYI: readelf.c (print_gdb_index_section): Accept version 6.

Mark Wielaard — 2012-03-21T15:13:32

Hi,

Just applied the following to accept a newer version number
for .gdb_index in readelf. No real change in the format, the updated
version is just a marker that there are more symbols in the index
available.

Cheers,

Mark
_______________________________________________
elfutils-devel mailing list
elfutils-devel< at >lists.fedorahosted.org
https://fedorahosted.org/mailman/listinfo/elfutils-devel

Strip on mips

Kurt Roeckx — 2012-03-20T23:13:41

Hi,

I'm trying to debug why strip on mips isn't working properly.
What I see is that for the debug sections, sh_type is not set to
SHT_PROGBITS but to SHT_MIPS_DWARF.

The stripped file still ends up with the debug information it it,
and the file that is supposed to have the debug symbols in it
has it set to SHT_NOBITS, and is rather small.

I'm assuming this is because of the SHT_MIPS_DWARF.  I'm not sure
how to find where it's going wrong.


Kurt

_______________________________________________
elfutils-devel mailing list
elfutils-devel< at >lists.fedorahosted.org
https://fedorahosted.org/mailman/listinfo/elfutils-devel

[PATCH 5/5] Make it possible to read multiple .debug_types sections.Each new .debug_types section is added to the end ofthe section vector. Various internal APIs were updatedto understand multiple .debug_types sections. A newfunction, dwarf_next_unit_or_section, was added toallow iteration over multiple type sections.

Tom Tromey — 2012-03-20T19:45:06

 libdw/ChangeLog                            |   29 +++++++++++
 libdw/dwarf_begin_elf.c                    |   53 ++++++++++++++++----
 libdw/dwarf_formref_die.c                  |    4 +-
 libdw/dwarf_getlocation_implicit_pointer.c |    4 +-
 libdw/dwarf_nextcu.c                       |   67 +++++++++++++++++++++++---
 libdw/dwarf_offdie.c                       |   19 +++++---
 libdw/libdw.h                              |   21 ++++++++-
 libdw/libdw.map                            |    5 ++
 libdw/libdwP.h                             |    9 +++-
 libdw/libdw_findcu.c                       |   34 ++++++++-----
 tests/ChangeLog                            |   10 ++++
 tests/Makefile.am                          |   10 ++--
 tests/debugtypes.c                         |   72 ++++++++++++++++++++++++++++
 tests/run-debugtypes.sh                    |   35 +++++++++++++
 tests/testfile59.bz2                       |  Bin 0 -> 1424 bytes
 15 files changed, 325 insertions(+), 47 deletions(-)
 create mode 100644 tests/debugtypes.c
 create mode 100755 tests/run-debugtypes.sh
 create mode 100644 tests/testfile59.bz2

diff --git a/libdw/ChangeLog b/libdw/ChangeLog
index 60f9ae0..c9e78a9 100644
--- a/libdw/ChangeLog
+++ b/libdw/ChangeLog
< at >< at > -1,5 +1,34 < at >< at >
 2012-03-20  Tom Tromey  <tromey< at >redhat.com>
 
+* libdw_findcu.c (__libdw_intern_next_unit): Use
+dwarf_next_unit_or_section.  Initialize CU's section index.
+(findcu_cb): Compare section indices.
+(__libdw_findcu): Remove 'debug_type' argument, add 'sec_index'
+argument.  Update.
+* libdwP.h (struct Dwarf) [next_tu_cu]: New field.
+(struct Dwarf_CU) [sec_index]: New field.
+(__libdw_findcu, __libdw_offdie): Update.
+(dwarf_next_unit_or_section): Add INTDECL.
+* libdw.map: Add dwarf_next_unit_or_section.
+* libdw.h (dwarf_next_unit_or_section): Declare.
+* dwarf_offdie.c (__libdw_offdie): Remove 'debug_types' argument,
+add 'sec_index' argument.  Validate section index.
+(dwarf_offdie): Update.
+(dwarf_offdie_types): Update.
+* dwarf_nextcu.c (dwarf_next_unit_or_section): New function.
+(dwarf_next_unit): Rewrite to use dwarf_next_unit_or_section.
+(dwarf_nextcu): Likewise.
+* dwarf_getlocation_implicit_pointer.c
+(dwarf_getlocation_implicit_pointer): Pass CU's section index to
+__libdw_offdie.
+* dwarf_formref_die.c (dwarf_formref_die): Use CU's section
+index.
+* dwarf_begin_elf.c (add_section): New function.
+(check_section): Use it.
+(dwarf_begin_elf): Initialize next_tu_cu.
+
+2012-03-20  Tom Tromey  <tromey< at >redhat.com>
+
 * dwarf_begin_elf.c (check_section): Remove 'inscngrp' argument.
 (global_read, scngrp_read): Update.
 
diff --git a/libdw/dwarf_begin_elf.c b/libdw/dwarf_begin_elf.c
index 4a726ce..ad253ec 100644
--- a/libdw/dwarf_begin_elf.c
+++ b/libdw/dwarf_begin_elf.c
< at >< at > -87,6 +87,36 < at >< at > static const char dwarf_scnnames[IDX_last][17] =
 #define ndwarf_scnnames (sizeof (dwarf_scnnames) / sizeof (dwarf_scnnames[0]))
 
 
+static bool
+add_section (Dwarf *result, size_t cnt, Elf_Data *data, bool gzipped)
+{
+  if (unlikely (result->sectiondata[cnt].data != NULL))
+    {
+      /* Allocate a new entry for .debug_types.  */
+      ++result->n_sections;
+      result->sectiondata = realloc (result->sectiondata,
+     result->n_sections
+     * sizeof (struct Dwarf_Section));
+      if (result->sectiondata == NULL)
+{
+  __libdw_free_zdata (result);
+  __libdw_seterrno (DWARF_E_NOMEM);
+  free (result->sectiondata);
+  free (result);
+  return false;
+}
+
+      cnt = result->n_sections - 1;
+    }
+
+  result->sectiondata[cnt].data = data;
+#if USE_ZLIB
+  result->sectiondata[cnt].gzipped = gzipped;
+#endif
+
+  return true;
+}
+
 static Dwarf *
 check_section (Dwarf *result, GElf_Ehdr *ehdr, Elf_Scn *scn)
 {
< at >< at > -128,15 +158,18 < at >< at > check_section (Dwarf *result, GElf_Ehdr *ehdr, Elf_Scn *scn)
     if (strcmp (scnname, dwarf_scnnames[cnt]) == 0)
       {
 /* Found it.  Remember where the data is.  */
-if (unlikely (result->sectiondata[cnt].data != NULL))
-  /* A section appears twice.  That's bad.  We ignore the section.  */
+if (unlikely (result->sectiondata[cnt].data != NULL
+      && cnt != IDX_debug_types))
+  /* A section appears twice.  That's bad.  We ignore the
+     section, unless it is a .debug_types section.  */
   break;
 
 /* Get the section data.  */
 Elf_Data *data = elf_getdata (scn, NULL);
 if (data != NULL && data->d_size != 0)
   /* Yep, there is actually data available.  */
-  result->sectiondata[cnt].data = data;
+  if (!add_section (result, cnt, data, false))
+    return NULL;
 
 break;
       }
< at >< at > -146,8 +179,10 < at >< at > check_section (Dwarf *result, GElf_Ehdr *ehdr, Elf_Scn *scn)
       {
 /* A compressed section.  */
 
-if (unlikely (result->sectiondata[cnt].data != NULL))
-  /* A section appears twice.  That's bad.  We ignore the section.  */
+if (unlikely (result->sectiondata[cnt].data != NULL
+      && cnt != IDX_debug_types))
+  /* A section appears twice.  That's bad.  We ignore the
+     section, unless it is a .debug_types section.  */
   break;
 
 /* Get the section data.  */
< at >< at > -200,11 +235,8 < at >< at > check_section (Dwarf *result, GElf_Ehdr *ehdr, Elf_Scn *scn)
 
     if (unlikely (zrc != Z_OK) || unlikely (z.avail_out != 0))
       free (zdata);
-    else
-      {
-result->sectiondata[cnt].data = zdata;
-result->sectiondata[cnt].gzipped = 1;
-      }
+    else if (!add_section (result, cnt, data, true))
+      return NULL;
   }
 
 break;
< at >< at > -345,6 +377,7 < at >< at > dwarf_begin_elf (elf, cmd, scngrp)
   result->mem_tail->remaining = result->mem_tail->size;
   result->mem_tail->prev = NULL;
 
+  result->next_tu_cu = IDX_debug_types;
   result->n_sections = IDX_last;
   result->sectiondata = calloc (result->n_sections, sizeof (Dwarf_Section));
   if (unlikely (result->sectiondata == NULL))
diff --git a/libdw/dwarf_formref_die.c b/libdw/dwarf_formref_die.c
index 88dc065..f2cfa10 100644
--- a/libdw/dwarf_formref_die.c
+++ b/libdw/dwarf_formref_die.c
< at >< at > -1,5 +1,5 < at >< at >
 /* Look up the DIE in a reference-form attribute.
-   Copyright (C) 2005-2010 Red Hat, Inc.
+   Copyright (C) 2005-2010, 2012 Red Hat, Inc.
    This file is part of Red Hat elfutils.
 
    Red Hat elfutils is free software; you can redistribute it and/or modify
< at >< at > -105,7 +105,7 < at >< at > dwarf_formref_die (attr, result)
   }
 while (cu->type_sig8 != sig);
 
-      data = cu->dbg->sectiondata[IDX_debug_types].data;
+      data = cu->dbg->sectiondata[cu->sec_index].data;
       offset = cu->type_offset;
     }
   else
diff --git a/libdw/dwarf_getlocation_implicit_pointer.c b/libdw/dwarf_getlocation_implicit_pointer.c
index 4d9f6b9..9385038 100644
--- a/libdw/dwarf_getlocation_implicit_pointer.c
+++ b/libdw/dwarf_getlocation_implicit_pointer.c
< at >< at > -1,5 +1,5 < at >< at >
 /* Return associated attribute for DW_OP_GNU_implicit_pointer.
-   Copyright (C) 2010 Red Hat, Inc.
+   Copyright (C) 2010, 2012 Red Hat, Inc.
    This file is part of Red Hat elfutils.
 
    Red Hat elfutils is free software; you can redistribute it and/or modify
< at >< at > -72,7 +72,7 < at >< at > dwarf_getlocation_implicit_pointer (attr, op, result)
 
   Dwarf_Die die;
   if (__libdw_offdie (attr->cu->dbg, op->number, &die,
-      attr->cu->type_offset != 0) == NULL)
+      attr->cu->sec_index) == NULL)
     return -1;
 
   if (INTUSE(dwarf_attr) (&die, DW_AT_location, result) == NULL
diff --git a/libdw/dwarf_nextcu.c b/libdw/dwarf_nextcu.c
index 66dd191..a765a29 100644
--- a/libdw/dwarf_nextcu.c
+++ b/libdw/dwarf_nextcu.c
< at >< at > -1,5 +1,5 < at >< at >
 /* Advance to next CU header.
-   Copyright (C) 2002-2010 Red Hat, Inc.
+   Copyright (C) 2002-2010, 2012 Red Hat, Inc.
    This file is part of Red Hat elfutils.
    Written by Ulrich Drepper <drepper< at >redhat.com>, 2002.
 
< at >< at > -57,10 +57,14 < at >< at >
 
 
 int
-dwarf_next_unit (dwarf, off, next_off, header_sizep, versionp, abbrev_offsetp,
- address_sizep, offset_sizep, type_signaturep, type_offsetp)
+dwarf_next_unit_or_section (dwarf, off, real_off, next_off, header_sizep,
+    versionp, abbrev_offsetp,
+    address_sizep, offset_sizep,
+    type_signaturep, type_offsetp,
+    type_sectionp)
      Dwarf *dwarf;
      Dwarf_Off off;
+     Dwarf_Off *real_off;
      Dwarf_Off *next_off;
      size_t *header_sizep;
      Dwarf_Half *versionp;
< at >< at > -69,16 +73,37 < at >< at > dwarf_next_unit (dwarf, off, next_off, header_sizep, versionp, abbrev_offsetp,
      uint8_t *offset_sizep;
      uint64_t *type_signaturep;
      Dwarf_Off *type_offsetp;
+     size_t *type_sectionp;
 {
   const bool debug_types = type_signaturep != NULL;
-  const size_t sec_idx = debug_types ? IDX_debug_types : IDX_debug_info;
+  size_t sec_idx = (type_sectionp != NULL ? *type_sectionp
+    : debug_types ? IDX_debug_types : IDX_debug_info);
 
   /* Maybe there has been an error before.  */
   if (dwarf == NULL)
     return -1;
 
+  /* Initialize the section if needed.  */
+  if (type_sectionp != NULL && sec_idx == 0)
+    {
+      *type_sectionp = IDX_debug_types;
+      sec_idx = IDX_debug_types;
+    }
+
+  /* If we are looking at all type sections, and we went off the end,
+     move to the next one.  */
+  if (debug_types && type_sectionp != NULL
+      && dwarf->sectiondata[sec_idx].data != NULL
+      && unlikely (off + 4 >= dwarf->sectiondata[sec_idx].data->d_size))
+    {
+      off = 0;
+      ++*type_sectionp;
+      ++sec_idx;
+    }
+
   /* If we reached the end before don't do anything.  */
   if (off == (Dwarf_Off) -1l
+      || unlikely (sec_idx >= dwarf->n_sections)
       || unlikely (dwarf->sectiondata[sec_idx].data == NULL)
       /* Make sure there is enough space in the .debug_info section
  for at least the initial word.  We cannot test the rest since
< at >< at > -89,6 +114,9 < at >< at > dwarf_next_unit (dwarf, off, next_off, header_sizep, versionp, abbrev_offsetp,
       return 1;
     }
 
+  if (real_off)
+    *real_off = off;
+
   /* This points into the .debug_info section to the beginning of the
      CU entry.  */
   const unsigned char *data = dwarf->sectiondata[sec_idx].data->d_buf;
< at >< at > -200,6 +228,29 < at >< at > dwarf_next_unit (dwarf, off, next_off, header_sizep, versionp, abbrev_offsetp,
 
   return 0;
 }
+INTDEF(dwarf_next_unit_or_section)
+
+int
+dwarf_next_unit (dwarf, off, next_off, header_sizep, versionp, abbrev_offsetp,
+ address_sizep, offset_sizep, type_signaturep, type_offsetp)
+     Dwarf *dwarf;
+     Dwarf_Off off;
+     Dwarf_Off *next_off;
+     size_t *header_sizep;
+     Dwarf_Half *versionp;
+     Dwarf_Off *abbrev_offsetp;
+     uint8_t *address_sizep;
+     uint8_t *offset_sizep;
+     uint64_t *type_signaturep;
+     Dwarf_Off *type_offsetp;
+{
+  return INTUSE(dwarf_next_unit_or_section) (dwarf, off, NULL, next_off,
+     header_sizep, versionp,
+     abbrev_offsetp, address_sizep,
+     offset_sizep,
+     type_signaturep,
+     type_offsetp, NULL);
+}
 INTDEF(dwarf_next_unit)
 
 int
< at >< at > -213,8 +264,10 < at >< at > dwarf_nextcu (dwarf, off, next_off, header_sizep, abbrev_offsetp,
      uint8_t *address_sizep;
      uint8_t *offset_sizep;
 {
-  return INTUSE(dwarf_next_unit) (dwarf, off, next_off, header_sizep, NULL,
-  abbrev_offsetp, address_sizep, offset_sizep,
-  NULL, NULL);
+  return INTUSE(dwarf_next_unit_or_section) (dwarf, off, NULL, next_off,
+     header_sizep, NULL,
+     abbrev_offsetp, address_sizep,
+     offset_sizep,
+     NULL, NULL, NULL);
 }
 INTDEF(dwarf_nextcu)
diff --git a/libdw/dwarf_offdie.c b/libdw/dwarf_offdie.c
index 90ada60..f426723 100644
--- a/libdw/dwarf_offdie.c
+++ b/libdw/dwarf_offdie.c
< at >< at > -1,5 +1,5 < at >< at >
 /* Return DIE at given offset.
-   Copyright (C) 2002-2010 Red Hat, Inc.
+   Copyright (C) 2002-2010, 2012 Red Hat, Inc.
    This file is part of Red Hat elfutils.
    Written by Ulrich Drepper <drepper< at >redhat.com>, 2002.
 
< at >< at > -59,13 +59,18 < at >< at >
 Dwarf_Die *
 internal_function
 __libdw_offdie (Dwarf *dbg, Dwarf_Off offset, Dwarf_Die *result,
-bool debug_types)
+size_t sec_index)
 {
   if (dbg == NULL)
     return NULL;
 
-  Elf_Data *const data = dbg->sectiondata[debug_types ? IDX_debug_types
-  : IDX_debug_info].data;
+  if (sec_index >= dbg->n_sections)
+    {
+      __libdw_seterrno (DWARF_E_INVALID_DWARF);
+      return NULL;
+    }
+
+  Elf_Data *const data = dbg->sectiondata[sec_index].data;
   if (offset >= data->d_size)
     {
       __libdw_seterrno (DWARF_E_INVALID_DWARF);
< at >< at > -79,7 +84,7 < at >< at > __libdw_offdie (Dwarf *dbg, Dwarf_Off offset, Dwarf_Die *result,
   result->addr = (char *) data->d_buf + offset;
 
   /* Get the CU.  */
-  result->cu = __libdw_findcu (dbg, offset, debug_types);
+  result->cu = __libdw_findcu (dbg, offset, sec_index);
   if (result->cu == NULL)
     {
       /* This should never happen.  The input file is malformed.  */
< at >< at > -97,7 +102,7 < at >< at > dwarf_offdie (dbg, offset, result)
      Dwarf_Off offset;
      Dwarf_Die *result;
 {
-  return __libdw_offdie (dbg, offset, result, false);
+  return __libdw_offdie (dbg, offset, result, IDX_debug_info);
 }
 INTDEF(dwarf_offdie)
 
< at >< at > -107,5 +112,5 < at >< at > dwarf_offdie_types (dbg, offset, result)
      Dwarf_Off offset;
      Dwarf_Die *result;
 {
-  return __libdw_offdie (dbg, offset, result, true);
+  return __libdw_offdie (dbg, offset, result, IDX_debug_types);
 }
diff --git a/libdw/libdw.h b/libdw/libdw.h
index e001b7a..ef82636 100644
--- a/libdw/libdw.h
+++ b/libdw/libdw.h
< at >< at > -1,5 +1,5 < at >< at >
 /* Interfaces for libdw.
-   Copyright (C) 2002-2010 Red Hat, Inc.
+   Copyright (C) 2002-2010, 2012 Red Hat, Inc.
    This file is part of Red Hat elfutils.
 
    Red Hat elfutils is free software; you can redistribute it and/or modify
< at >< at > -304,6 +304,25 < at >< at > extern int dwarf_next_unit (Dwarf *dwarf, Dwarf_Off off, Dwarf_Off *next_off,
     uint64_t *type_signaturep, Dwarf_Off *type_offsetp)
      __nonnull_attribute__ (3);
 
+/* Read the header of a DWARF CU or type unit.  If TYPE_SIGNATUREP is
+   not null, this reads a type unit from the .debug_types section;
+   otherwise this reads a CU from the .debug_info section.  If
+   iterating over .debug_types sections, *TYPE_SECTIONP should be
+   initialized to zero before the first call.  *REAL_OFF is set to the
+   real offset of the returned unit; when iterating, the previous
+   offset used in the loop may not point anywhere useful.  */
+extern int dwarf_next_unit_or_section (Dwarf *dwarf, Dwarf_Off off,
+       Dwarf_Off *real_off, Dwarf_Off *next_off,
+       size_t *header_sizep,
+       Dwarf_Half *versionp,
+       Dwarf_Off *abbrev_offsetp,
+       uint8_t *address_sizep,
+       uint8_t *offset_sizep,
+       uint64_t *type_signaturep,
+       Dwarf_Off *type_offsetp,
+       size_t *type_sectionp)
+     __nonnull_attribute__ (4);
+
 
 /* Decode one DWARF CFI entry (CIE or FDE) from the raw section data.
    The E_IDENT from the originating ELF file indicates the address
diff --git a/libdw/libdw.map b/libdw/libdw.map
index 1f71d03..4217f29 100644
--- a/libdw/libdw.map
+++ b/libdw/libdw.map
< at >< at > -254,3 +254,8 < at >< at > ELFUTILS_0.149 {
 
     dwfl_dwarf_line;
 } ELFUTILS_0.148;
+
+ELFUTILS_0.153 {
+  global:
+    dwarf_next_unit_or_section;
+} ELFUTILS_0.149;
diff --git a/libdw/libdwP.h b/libdw/libdwP.h
index fee0bac..de60399 100644
--- a/libdw/libdwP.h
+++ b/libdw/libdwP.h
< at >< at > -191,6 +191,7 < at >< at > struct Dwarf
   /* Search tree and sig8 hash table for .debug_types type units.  */
   void *tu_tree;
   Dwarf_Off next_tu_offset;
+  size_t next_tu_cu;
   Dwarf_Sig8_Hash sig8_hash;
 
   /* Address ranges.  */
< at >< at > -303,6 +304,8 < at >< at > struct Dwarf_CU
   uint8_t offset_size;
   uint16_t version;
 
+  size_t sec_index;
+
   /* Zero if this is a normal CU.  Nonzero if it is a type unit.  */
   size_t type_offset;
   uint64_t type_sig8;
< at >< at > -413,7 +416,8 < at >< at > extern struct Dwarf_CU *__libdw_intern_next_unit (Dwarf *dbg, bool debug_types)
      __nonnull_attribute__ (1) internal_function;
 
 /* Find CU for given offset.  */
-extern struct Dwarf_CU *__libdw_findcu (Dwarf *dbg, Dwarf_Off offset, bool tu)
+extern struct Dwarf_CU *__libdw_findcu (Dwarf *dbg, Dwarf_Off offset,
+size_t sec_idx)
      __nonnull_attribute__ (1) internal_function;
 
 /* Return tag of given DIE.  */
< at >< at > -480,7 +484,7 < at >< at > extern int __libdw_intern_expression (Dwarf *dbg,
   __nonnull_attribute__ (5, 6, 9, 10) internal_function;
 
 extern Dwarf_Die *__libdw_offdie (Dwarf *dbg, Dwarf_Off offset,
-  Dwarf_Die *result, bool debug_types)
+  Dwarf_Die *result, size_t sec_index)
   internal_function;
 
 
< at >< at > -680,6 +684,7 < at >< at > INTDECL (dwarf_highpc)
 INTDECL (dwarf_lowpc)
 INTDECL (dwarf_nextcu)
 INTDECL (dwarf_next_unit)
+INTDECL (dwarf_next_unit_or_section)
 INTDECL (dwarf_offdie)
 INTDECL (dwarf_ranges)
 INTDECL (dwarf_siblingof)
diff --git a/libdw/libdw_findcu.c b/libdw/libdw_findcu.c
index 8e5f9e9..2b8a005 100644
--- a/libdw/libdw_findcu.c
+++ b/libdw/libdw_findcu.c
< at >< at > -1,5 +1,5 < at >< at >
 /* Find CU for given offset.
-   Copyright (C) 2003-2010 Red Hat, Inc.
+   Copyright (C) 2003-2010, 2012 Red Hat, Inc.
    This file is part of Red Hat elfutils.
    Written by Ulrich Drepper <drepper< at >redhat.com>, 2003.
 
< at >< at > -67,6 +67,7 < at >< at > __libdw_intern_next_unit (dbg, debug_types)
     = debug_types ? &dbg->next_tu_offset : &dbg->next_cu_offset;
 
   Dwarf_Off oldoff = *offsetp;
+  Dwarf_Off real_off;
   uint16_t version;
   uint8_t address_size;
   uint8_t offset_size;
< at >< at > -74,11 +75,13 < at >< at > __libdw_intern_next_unit (dbg, debug_types)
   uint64_t type_sig8 = 0;
   Dwarf_Off type_offset = 0;
 
-  if (INTUSE(dwarf_next_unit) (dbg, oldoff, offsetp, NULL,
-       &version, &abbrev_offset,
-       &address_size, &offset_size,
-       debug_types ? &type_sig8 : NULL,
-       debug_types ? &type_offset : NULL) != 0)
+  if (INTUSE(dwarf_next_unit_or_section) (dbg, oldoff, &real_off, offsetp, NULL,
+  &version, &abbrev_offset,
+  &address_size, &offset_size,
+  debug_types ? &type_sig8 : NULL,
+  debug_types ? &type_offset : NULL,
+  debug_types ? &dbg->next_tu_cu : NULL)
+      != 0)
     /* No more entries.  */
     return NULL;
 
< at >< at > -93,11 +96,12 < at >< at > __libdw_intern_next_unit (dbg, debug_types)
   struct Dwarf_CU *newp = libdw_typed_alloc (dbg, struct Dwarf_CU);
 
   newp->dbg = dbg;
-  newp->start = oldoff;
+  newp->start = real_off;
   newp->end = *offsetp;
   newp->address_size = address_size;
   newp->offset_size = offset_size;
   newp->version = version;
+  newp->sec_index = debug_types ? dbg->next_tu_cu : IDX_debug_info;
   newp->type_sig8 = type_sig8;
   newp->type_offset = type_offset;
   Dwarf_Abbrev_Hash_init (&newp->abbrev_hash, 41);
< at >< at > -115,6 +119,11 < at >< at > findcu_cb (const void *arg1, const void *arg2)
   struct Dwarf_CU *cu1 = (struct Dwarf_CU *) arg1;
   struct Dwarf_CU *cu2 = (struct Dwarf_CU *) arg2;
 
+  if (cu1->sec_index < cu2->sec_index)
+    return -1;
+  if (cu1->sec_index > cu2->sec_index)
+    return 1;
+
   /* Find out which of the two arguments is the search value.  It has
      end offset 0.  */
   if (cu1->end == 0)
< at >< at > -136,22 +145,23 < at >< at > findcu_cb (const void *arg1, const void *arg2)
 }
 
 struct Dwarf_CU *
-__libdw_findcu (dbg, start, debug_types)
+__libdw_findcu (dbg, start, sec_index)
      Dwarf *dbg;
      Dwarf_Off start;
-     bool debug_types;
+     size_t sec_index;
 {
+  const bool debug_types = sec_index != IDX_debug_info;
   void **tree = debug_types ? &dbg->tu_tree : &dbg->cu_tree;
   Dwarf_Off *next_offset
     = debug_types ? &dbg->next_tu_offset : &dbg->next_cu_offset;
 
   /* Maybe we already know that CU.  */
-  struct Dwarf_CU fake = { .start = start, .end = 0 };
+  struct Dwarf_CU fake = { .start = start, .end = 0, .sec_index = sec_index };
   struct Dwarf_CU **found = tfind (&fake, tree, findcu_cb);
   if (found != NULL)
     return *found;
 
-  if (start < *next_offset)
+  if (!debug_types && start < *next_offset)
     {
       __libdw_seterrno (DWARF_E_INVALID_DWARF);
       return NULL;
< at >< at > -175,7 +185,7 < at >< at > __libdw_findcu (dbg, start, debug_types)
 }
 
       /* Is this the one we are looking for?  */
-      if (start < *next_offset)
+      if (!debug_types && start < *next_offset)
 // XXX Match exact offset.
 return newp;
     }
diff --git a/tests/ChangeLog b/tests/ChangeLog
index a782591..17523b3 100644
--- a/tests/ChangeLog
+++ b/tests/ChangeLog
< at >< at > -1,3 +1,13 < at >< at >
+2012-03-20  Tom Tromey  <tromey< at >redhat.com>
+
+* debugtypes.c: New file.
+* run-debugtypes.sh: New file.
+* testfile59.bz2: New file.
+* Makefile.am (noinst_PROGRAMS): Add debugtypes.
+(TESTS): Add run-debugtypes.sh.
+(EXTRA_DIST): Add run-debugtypes.sh, testfile59.bz2.
+(debugtypes_LDADD): New variable.
+
 2012-02-21  Kurt Roeckx  <kurt< at >roeckx.be>
 
 * run-alldts.sh: testrun ./alldts.
diff --git a/tests/Makefile.am b/tests/Makefile.am
index 3074c89..1b5ebf3 100644
--- a/tests/Makefile.am
+++ b/tests/Makefile.am
< at >< at > -1,6 +1,6 < at >< at >
 ## Process this file with automake to create Makefile.in
 ##
-## Copyright (C) 1996-2011 Red Hat, Inc.
+## Copyright (C) 1996-2012 Red Hat, Inc.
 ## This file is part of Red Hat elfutils.
 ##
 ## Red Hat elfutils is free software; you can redistribute it and/or modify
< at >< at > -58,7 +58,7 < at >< at > noinst_PROGRAMS = arextract arsymtest newfile saridx scnnames sectiondump \
   dwfl-addr-sect dwfl-bug-report early-offscn \
   dwfl-bug-getmodules dwarf-getmacros addrcfi \
   test-flag-nobits dwarf-getstring rerequest_tag \
-  alldts md5-sha1-test
+  alldts md5-sha1-test debugtypes
 asm_TESTS = asm-tst1 asm-tst2 asm-tst3 asm-tst4 asm-tst5 \
     asm-tst6 asm-tst7 asm-tst8 asm-tst9
 
< at >< at > -86,7 +86,7 < at >< at > TESTS = run-arextract.sh run-arsymtest.sh newfile test-nlist \
 run-disasm-x86.sh run-disasm-x86-64.sh \
 run-early-offscn.sh run-dwarf-getmacros.sh \
 run-test-flag-nobits.sh run-prelink-addr-test.sh \
-run-dwarf-getstring.sh run-rerequest_tag.sh
+run-dwarf-getstring.sh run-rerequest_tag.sh run-debugtypes.sh
 # run-show-ciefde.sh
 
 if !STANDALONE
< at >< at > -161,7 +161,8 < at >< at > EXTRA_DIST = run-arextract.sh run-arsymtest.sh \
      testfile55-32.bz2 testfile55-32.debug.bz2 \
      testfile55-32.prelink.bz2 testfile55-64.bz2 \
      testfile55-64.debug.bz2 testfile55-64.prelink.bz2 \
-     testfile56.bz2 testfile57.bz2 testfile58.bz2
+     testfile56.bz2 testfile57.bz2 testfile58.bz2 \
+     run-debugtypes.sh testfile59.bz2
 
 installed_TESTS_ENVIRONMENT = libdir=$(DESTDIR)$(libdir) \
       bindir=$(DESTDIR)$(bindir) \
< at >< at > -258,6 +259,7 < at >< at > test_flag_nobits_LDADD = $(libelf) $(libmudflap)
 rerequest_tag_LDADD = $(libdw) $(libmudflap)
 alldts_LDADD = $(libebl) $(libelf) $(libmudflap)
 md5_sha1_test_LDADD = $(libeu)
+debugtypes_LDADD = $(libdw) $(libelf) $(libmudflap)
 
 if GCOV
 check: check-am coverage
diff --git a/tests/debugtypes.c b/tests/debugtypes.c
new file mode 100644
index 0000000..3022a9a
--- /dev/null
+++ b/tests/debugtypes.c
< at >< at > -0,0 +1,72 < at >< at >
+/* Copyright (C) 2012 Red Hat, Inc.
+   This file is part of Red Hat elfutils.
+
+   Red Hat elfutils is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by the
+   Free Software Foundation; version 2 of the License.
+
+   Red Hat elfutils is distributed in the hope that it will be useful, but
+   WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   General Public License for more details.
+
+   You should have received a copy of the GNU General Public License along
+   with Red Hat elfutils; if not, write to the Free Software Foundation,
+   Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301 USA.
+
+   Red Hat elfutils is an included package of the Open Invention Network.
+   An included package of the Open Invention Network is a package for which
+   Open Invention Network licensees cross-license their patents.  No patent
+   license is granted, either expressly or impliedly, by designation as an
+   included package.  Should you wish to participate in the Open Invention
+   Network licensing program, please visit www.openinventionnetwork.com
+   <http://www.openinventionnetwork.com>.  */
+
+#ifdef HAVE_CONFIG_H
+# include <config.h>
+#endif
+
+#include <fcntl.h>
+#include ELFUTILS_HEADER(dw)
+#include <stdio.h>
+#include <unistd.h>
+
+int
+main (int argc, char *argv[])
+{
+  for (int i = 1; i < argc; ++i)
+    {
+      int fd = open (argv[i], O_RDONLY);
+
+      Dwarf *dbg = dwarf_begin (fd, DWARF_C_READ);
+      if (dbg != NULL)
+{
+  Dwarf_Off off = 0;
+  Dwarf_Off real_off;
+  size_t cuhl;
+  Dwarf_Off noff;
+  size_t section = 0;
+  uint64_t signature;
+  Dwarf_Off type_off;
+
+  while (dwarf_next_unit_or_section (dbg, off, &real_off, &noff, &cuhl,
+     NULL, NULL, NULL, NULL,
+     &signature, &type_off, &section)
+ == 0)
+    {
+      Dwarf_Die die_mem;
+      Dwarf_Die *die = dwarf_offdie (dbg, real_off + cuhl, &die_mem);
+
+      printf ("section %d, off %ld, type off %ld, ok = %d\n",
+      (int) section, (long) real_off, (long) type_off,
+      die != NULL);
+
+      off = noff;
+    }
+
+  dwarf_end (dbg);
+}
+
+      close (fd);
+    }
+}
diff --git a/tests/run-debugtypes.sh b/tests/run-debugtypes.sh
new file mode 100755
index 0000000..7c98515
--- /dev/null
+++ b/tests/run-debugtypes.sh
< at >< at > -0,0 +1,35 < at >< at >
+#! /bin/sh
+# Copyright (C) 2012 Red Hat, Inc.
+# This file is part of Red Hat elfutils.
+#
+# Red Hat elfutils is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by the
+# Free Software Foundation; version 2 of the License.
+#
+# Red Hat elfutils is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License along
+# with Red Hat elfutils; if not, write to the Free Software Foundation,
+# Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301 USA.
+#
+# Red Hat elfutils is an included package of the Open Invention Network.
+# An included package of the Open Invention Network is a package for which
+# Open Invention Network licensees cross-license their patents.  No patent
+# license is granted, either expressly or impliedly, by designation as an
+# included package.  Should you wish to participate in the Open Invention
+# Network licensing program, please visit www.openinventionnetwork.com
+# <http://www.openinventionnetwork.com>.
+
+. $srcdir/test-subr.sh
+
+testfiles testfile59
+
+testrun_compare ./debugtypes testfile59 <<\EOF
+section 10, off 0, type off 29, ok = 1
+section 11, off 0, type off 29, ok = 1
+EOF
+
+exit 0
diff --git a/tests/testfile59.bz2 b/tests/testfile59.bz2
new file mode 100644
index 0000000000000000000000000000000000000000..aa1616d24d1e10bb3f82f97d2d8f9fc47247bf9a
GIT binary patch
literal 1424
zcmV;B1#kL7T4*^jL0KkKSz-fU7XSsPfB*mg|L=b1|Nr~#+GfB1|MI<W)$eb~6I=)Z
zKmZCMa0$=^lxgh^n60kq-G&Vinom)xHc7B)BRwQE$>}_!Ks3;3dWVz%$a*26lTTAj
zfMfvlo}sixCdxD#0BI8< at >L84^SO&Ug%$`4RzXlMr1dWL`iWB>pF0000001SXKCX-2u
zpQ=4Zng^+)L6bqD>H{DHKzcxWfChoJ00w{qKmY(54^u=K6GoaEX{IJ7hMH(#BLIvb
zGGHc}Fc1a+6C(hcWCI`uA*Mi)MNbtp< at >}85$GgBs-00Tg113{nw4FCXWG&BG`KmalT
z&;SK3pfI;ilcebwjN3jAxfPZylWgGQ4aLe85zeYdSTk=a4JBz4EZKc)f#1q{-T=lH
z6ZR4S+E)wPN!a<j9Gwn~u6#`Sy{dLte$CbdxcM2wX2Vc2F9XtLn^|aWKHOwdwQl4o
zX2#o=8(NhE6KmevKYoV< at >12VALU0fJpZ!XOM_wS=9X7Ve0s^{3!!or6Wr>Jx&8NP=Y
zIMGJMEH4yi1R8< at >mLZTo{8j8(IDY4f&>X>XMK1(rSII<o?zZEg)&h;-xk9`uIMf8E+
znE`_c3lxL_+_^|133b_uA|e8X1P}v5GPMgz?<vx&3JeNo< at >_Xl2$)PCg84yDTB0xzP
z11oKdvy%yy=GNeKmGdd=k)R-Ah9sgi#*l0;w}tmv;GV)wcBN>0?;5Sr{3BSx3lyS2
z2uX4fOo&MVV!%P6X(%+Y?J1fCBMYX0N< at >j!7(2R3NorghzX=MWQBYkaqA$rS!TvdtX
zX%rYGu3-isq1=EZh_I^AL6&SssW6KW4T5YCRV`qEh{V_lum;m%(r|W7bs1c7OtU0F
zqreEAAg?Ee8%PnJ^dzuxV5By;HF8=f&)ZBUkU+k>ose*p{OxY7#US-3D6jxIfK^bn
z5U4}M-YJU7RVyK;h2;t0A(aLcB-|xEwpYU1P}8Pa9FhI-eOsr3B8^H<(d&i< at >G_6>^
zEJxojIEbm3HVOg?`VashR>1*i&=T0oqp+h1rI`T*7$!%*5}7*;MJXDjwrT<=)~U)c
zWcGlbqzlR9YXoQHnjv&FD77< at >fNp$K1kW39HvmjX< at >ihv^)n%< at >0|{1n6jAS7u6rvh|p
zUDhOB>I#u5u!BV_(1Zr%P(>CM=VynN_EB-5(Md8#?i!c=l;uSREJrXw1^~;`z13+v
zvWq0xEGBtG3yq-QOVFW0pDGR!GY5SF0UIq<aDowR3?LZ;4Isj<68w1D(F$9N7S`Hf
znIZDVxv{0r7o5qU_47p2VFwWm_MsQ~ifMc&Hd1Q< at >2y9(OF!$~d*)BZNK$r<N>{< at >GL
zn=2p+z< at >bIOR}< at >N;Qofw~q< at >k< at >Z?qrqRg+fyPP8+u$rm!w!p?bm?0_w7iKd~r$(_c``
z;~aUFFK-2$6ab}qA4TDXL)yQzlSX8N;yiV_8TL*my^f9qkbv;LpaWDM`LK?je1X|n
zku>A-Ri&$_kiR< at >EPzrW;q$$8p(7h06bn9J>9mMx1cQG5B<w>^$4mpfk_^eY)GYzI$
zf>< at >qwj(XnAM_q6#7$I+zAh!%;Abrj|Mgb4PcQhIoV|7*AYGNb)no<hu2lypDAoMed
zpwkubkx!glu>6H~s7P0SX3}c&MOzyVDr^KAqz7qrS|k`g%5k9i3f5<0t1WISIEYPw
z6pA>EgvX;|l7-x<5f}{cnyc-;iP2QmO4*8mPm%{cGea8Z>x< at >*AnFOU9u>umFjV!%r
z42`4bphL~XR5tdHM^fUbey)1d-y%q2+6fj`FLt%=z-Xgb8C?cTR*k{T<W2HIydAF*
e`50Fcb?c8Pe5Q5(V2kQM< at >pmLsg$V{AHSuuonq< at >2i

literal 0
HcmV?d00001

[PATCH 4/5] remove section-group code from check_section

Tom Tromey — 2012-03-20T19:28:40

 libdw/ChangeLog         |    5 +++++
 libdw/dwarf_begin_elf.c |   16 +++-------------
 2 files changed, 8 insertions(+), 13 deletions(-)

diff --git a/libdw/ChangeLog b/libdw/ChangeLog
index c3dbda9..60f9ae0 100644
--- a/libdw/ChangeLog
+++ b/libdw/ChangeLog
< at >< at > -1,5 +1,10 < at >< at >
 2012-03-20  Tom Tromey  <tromey< at >redhat.com>
 
+* dwarf_begin_elf.c (check_section): Remove 'inscngrp' argument.
+(global_read, scngrp_read): Update.
+
+2012-03-20  Tom Tromey  <tromey< at >redhat.com>
+
 * libdwP.h (struct Dwarf) [n_sections]: New field.
 [sectiondata]: Change type.
 * dwarf_end.c (__libdw_free_zdata): Use n_sections.
diff --git a/libdw/dwarf_begin_elf.c b/libdw/dwarf_begin_elf.c
index def8ed6..4a726ce 100644
--- a/libdw/dwarf_begin_elf.c
+++ b/libdw/dwarf_begin_elf.c
< at >< at > -88,7 +88,7 < at >< at > static const char dwarf_scnnames[IDX_last][17] =
 
 
 static Dwarf *
-check_section (Dwarf *result, GElf_Ehdr *ehdr, Elf_Scn *scn, bool inscngrp)
+check_section (Dwarf *result, GElf_Ehdr *ehdr, Elf_Scn *scn)
 {
   GElf_Shdr shdr_mem;
   GElf_Shdr *shdr;
< at >< at > -106,16 +106,6 < at >< at > check_section (Dwarf *result, GElf_Ehdr *ehdr, Elf_Scn *scn, bool inscngrp)
   if (unlikely (shdr->sh_type == SHT_NOBITS))
     return result;
 
-  /* Make sure the section is part of a section group only iff we
-     really need it.  If we are looking for the global (= non-section
-     group debug info) we have to ignore all the info in section
-     groups.  If we are looking into a section group we cannot look at
-     a section which isn't part of the section group.  */
-  if (! inscngrp && (shdr->sh_flags & SHF_GROUP) != 0)
-    /* Ignore the section.  */
-    return result;
-
-
   /* We recognize the DWARF section by their names.  This is not very
      safe and stable but the best we can do.  */
   const char *scnname = elf_strptr (result->elf, ehdr->e_shstrndx,
< at >< at > -255,7 +245,7 < at >< at > global_read (Dwarf *result, Elf *elf, GElf_Ehdr *ehdr)
   Elf_Scn *scn = NULL;
 
   while (result != NULL && (scn = elf_nextscn (elf, scn)) != NULL)
-    result = check_section (result, ehdr, scn, false);
+    result = check_section (result, ehdr, scn);
 
   return valid_p (result);
 }
< at >< at > -294,7 +284,7 < at >< at > scngrp_read (Dwarf *result, Elf *elf, GElf_Ehdr *ehdr, Elf_Scn *scngrp)
   return NULL;
 }
 
-      result = check_section (result, ehdr, scn, true);
+      result = check_section (result, ehdr, scn);
       if (result == NULL)
 break;
     }

[PATCH 3/5] Change sectiondata to be dynamically allocated. Thisallows us to later add multiple .debug_types sectionsto the section data vector.

Tom Tromey — 2012-03-20T19:20:36

 libdw/ChangeLog         |   10 ++++++++++
 libdw/dwarf_begin_elf.c |   13 +++++++++++++
 libdw/dwarf_end.c       |    4 +++-
 libdw/libdwP.h          |    5 ++++-
 4 files changed, 30 insertions(+), 2 deletions(-)

diff --git a/libdw/ChangeLog b/libdw/ChangeLog
index 6fb5d8d..c3dbda9 100644
--- a/libdw/ChangeLog
+++ b/libdw/ChangeLog
< at >< at > -1,5 +1,15 < at >< at >
 2012-03-20  Tom Tromey  <tromey< at >redhat.com>
 
+* libdwP.h (struct Dwarf) [n_sections]: New field.
+[sectiondata]: Change type.
+* dwarf_end.c (__libdw_free_zdata): Use n_sections.
+(dwarf_end): Free the section data.
+* dwarf_begin_elf.c (check_section, valid_p, scngrp_read): Free
+the section data.
+(dwarf_begin_elf): Allocate the section data.
+
+2012-03-20  Tom Tromey  <tromey< at >redhat.com>
+
 * libdwP.h (IDX_debug_types): Move just before IDX_last.
 * dwarf_begin_elf.c (dwarf_scnnames): Move .debug_types to the
 end.
diff --git a/libdw/dwarf_begin_elf.c b/libdw/dwarf_begin_elf.c
index e62ef07..def8ed6 100644
--- a/libdw/dwarf_begin_elf.c
+++ b/libdw/dwarf_begin_elf.c
< at >< at > -126,6 +126,7 < at >< at > check_section (Dwarf *result, GElf_Ehdr *ehdr, Elf_Scn *scn, bool inscngrp)
  invalid.  */
       __libdw_free_zdata (result);
       __libdw_seterrno (DWARF_E_INVALID_ELF);
+      free (result->sectiondata);
       free (result);
       return NULL;
     }
< at >< at > -239,6 +240,7 < at >< at > valid_p (Dwarf *result)
     {
       __libdw_free_zdata (result);
       __libdw_seterrno (DWARF_E_NO_DWARF);
+      free (result->sectiondata);
       free (result);
       result = NULL;
     }
< at >< at > -269,6 +271,7 < at >< at > scngrp_read (Dwarf *result, Elf *elf, GElf_Ehdr *ehdr, Elf_Scn *scngrp)
     {
       /* We cannot read the section content.  Fail!  */
       __libdw_free_zdata (result);
+      free (result->sectiondata);
       free (result);
       return NULL;
     }
< at >< at > -286,6 +289,7 < at >< at > scngrp_read (Dwarf *result, Elf *elf, GElf_Ehdr *ehdr, Elf_Scn *scngrp)
      never happen.  */
   __libdw_free_zdata (result);
   __libdw_seterrno (DWARF_E_INVALID_ELF);
+  free (result->sectiondata);
   free (result);
   return NULL;
 }
< at >< at > -351,6 +355,15 < at >< at > dwarf_begin_elf (elf, cmd, scngrp)
   result->mem_tail->remaining = result->mem_tail->size;
   result->mem_tail->prev = NULL;
 
+  result->n_sections = IDX_last;
+  result->sectiondata = calloc (result->n_sections, sizeof (Dwarf_Section));
+  if (unlikely (result->sectiondata == NULL))
+    {
+      free (result);
+      __libdw_seterrno (DWARF_E_NOMEM);
+      return NULL;
+    }
+
   if (cmd == DWARF_C_READ || cmd == DWARF_C_RDWR)
     {
       /* If the caller provides a section group we get the DWARF
diff --git a/libdw/dwarf_end.c b/libdw/dwarf_end.c
index 2636c69..a2ee8d6 100644
--- a/libdw/dwarf_end.c
+++ b/libdw/dwarf_end.c
< at >< at > -85,7 +85,7 < at >< at > __libdw_free_zdata (Dwarf *dwarf)
 {
   size_t i;
 
-  for (i = 0; i < IDX_last; ++i)
+  for (i = 0; i < dwarf->n_sections; ++i)
     {
       if (dwarf->sectiondata[i].gzipped)
 free (dwarf->sectiondata[i].data);
< at >< at > -125,6 +125,8 < at >< at > dwarf_end (dwarf)
 
       __libdw_free_zdata (dwarf);
 
+      free (dwarf->sectiondata);
+
       /* Free the ELF descriptor if necessary.  */
       if (dwarf->free_elf)
 elf_end (dwarf->elf);
diff --git a/libdw/libdwP.h b/libdw/libdwP.h
index b24ac0b..fee0bac 100644
--- a/libdw/libdwP.h
+++ b/libdw/libdwP.h
< at >< at > -161,8 +161,11 < at >< at > struct Dwarf
   /* The underlying ELF file.  */
   Elf *elf;
 
+  /* The number of sections in SECTIONDATA.  */
+  size_t n_sections;
+ 
   /* The section data.  */
-  struct Dwarf_Section sectiondata[IDX_last];
+  struct Dwarf_Section *sectiondata;
 
   /* True if the file has a byte order different from the host.  */
   bool other_byte_order;

[PATCH 2/5] Make IDX_debug_types come last. In a subsequent patch wewill put all .debug_types sections at the end the ofthe section array. This change arranges for them toappear sequentially.

Tom Tromey — 2012-03-20T19:10:30

 libdw/ChangeLog         |    6 ++++++
 libdw/dwarf_begin_elf.c |    6 +++---
 libdw/libdwP.h          |    2 +-
 3 files changed, 10 insertions(+), 4 deletions(-)

diff --git a/libdw/ChangeLog b/libdw/ChangeLog
index 8a556ec..6fb5d8d 100644
--- a/libdw/ChangeLog
+++ b/libdw/ChangeLog
< at >< at > -1,5 +1,11 < at >< at >
 2012-03-20  Tom Tromey  <tromey< at >redhat.com>
 
+* libdwP.h (IDX_debug_types): Move just before IDX_last.
+* dwarf_begin_elf.c (dwarf_scnnames): Move .debug_types to the
+end.
+
+2012-03-20  Tom Tromey  <tromey< at >redhat.com>
+
 * libdwP.h (struct Dwarf_Section): New.
 (Dwarf_Section): New typedef.
 (struct Dwarf) [sectiondata]: Change type.
diff --git a/libdw/dwarf_begin_elf.c b/libdw/dwarf_begin_elf.c
index f7ae8ab..e62ef07 100644
--- a/libdw/dwarf_begin_elf.c
+++ b/libdw/dwarf_begin_elf.c
< at >< at > -1,5 +1,5 < at >< at >
 /* Create descriptor from ELF descriptor for processing file.
-   Copyright (C) 2002-2011 Red Hat, Inc.
+   Copyright (C) 2002-2012 Red Hat, Inc.
    This file is part of Red Hat elfutils.
    Written by Ulrich Drepper <drepper< at >redhat.com>, 2002.
 
< at >< at > -73,7 +73,6 < at >< at >
 static const char dwarf_scnnames[IDX_last][17] =
 {
   [IDX_debug_info] = ".debug_info",
-  [IDX_debug_types] = ".debug_types",
   [IDX_debug_abbrev] = ".debug_abbrev",
   [IDX_debug_aranges] = ".debug_aranges",
   [IDX_debug_line] = ".debug_line",
< at >< at > -82,7 +81,8 < at >< at > static const char dwarf_scnnames[IDX_last][17] =
   [IDX_debug_pubnames] = ".debug_pubnames",
   [IDX_debug_str] = ".debug_str",
   [IDX_debug_macinfo] = ".debug_macinfo",
-  [IDX_debug_ranges] = ".debug_ranges"
+  [IDX_debug_ranges] = ".debug_ranges",
+  [IDX_debug_types] = ".debug_types"
 };
 #define ndwarf_scnnames (sizeof (dwarf_scnnames) / sizeof (dwarf_scnnames[0]))
 
diff --git a/libdw/libdwP.h b/libdw/libdwP.h
index 1505512..b24ac0b 100644
--- a/libdw/libdwP.h
+++ b/libdw/libdwP.h
< at >< at > -83,7 +83,6 < at >< at > struct loc_block_s
 enum
   {
     IDX_debug_info = 0,
-    IDX_debug_types,
     IDX_debug_abbrev,
     IDX_debug_aranges,
     IDX_debug_line,
< at >< at > -93,6 +92,7 < at >< at > enum
     IDX_debug_str,
     IDX_debug_macinfo,
     IDX_debug_ranges,
+    IDX_debug_types,/* Must be just before IDX_last */
     IDX_last
   };

[PATCH 1/5] Change representation of section data. This is justpreparation for a subsequent patch that makes thenumber of sections dynamic.

Tom Tromey — 2012-03-20T19:06:06

 libdw/ChangeLog           |   24 ++++++++++++++++++++++++
 libdw/dwarf_begin_elf.c   |   12 ++++++------
 libdw/dwarf_child.c       |    6 +++---
 libdw/dwarf_end.c         |   15 ++++++---------
 libdw/dwarf_formref_die.c |    2 +-
 libdw/dwarf_formstring.c  |    4 ++--
 libdw/dwarf_formudata.c   |    2 +-
 libdw/dwarf_getabbrev.c   |    6 +++---
 libdw/dwarf_getaranges.c  |   12 ++++++------
 libdw/dwarf_getattrs.c    |    4 ++--
 libdw/dwarf_getcfi.c      |    4 ++--
 libdw/dwarf_getmacros.c   |    2 +-
 libdw/dwarf_getpubnames.c |   20 ++++++++++++--------
 libdw/dwarf_getstring.c   |   12 +++++++-----
 libdw/dwarf_nextcu.c      |    8 ++++----
 libdw/dwarf_offdie.c      |    2 +-
 libdw/dwarf_ranges.c      |    2 +-
 libdw/libdwP.h            |   27 ++++++++++++++++++---------
 libdwfl/ChangeLog         |    4 ++++
 libdwfl/cu.c              |    3 ++-
 src/ChangeLog             |    6 ++++++
 src/readelf.c             |    4 ++--
 22 files changed, 114 insertions(+), 67 deletions(-)

diff --git a/libdw/ChangeLog b/libdw/ChangeLog
index 98b67f4..8a556ec 100644
--- a/libdw/ChangeLog
+++ b/libdw/ChangeLog
< at >< at > -1,3 +1,27 < at >< at >
+2012-03-20  Tom Tromey  <tromey< at >redhat.com>
+
+* libdwP.h (struct Dwarf_Section): New.
+(Dwarf_Section): New typedef.
+(struct Dwarf) [sectiondata]: Change type.
+[sectiondata_gzip_mask]: Remove.
+(__libdw_checked_get_data, cu_data): Update.
+* dwarf_ranges.c (dwarf_ranges): Update.
+* dwarf_offdie.c (__libdw_offdie): Update.
+* dwarf_nextcu.c (dwarf_next_unit): Update.
+* dwarf_getstring.c (dwarf_getstring): Update.
+* dwarf_getpubnames.c (get_offsets, dwarf_getpubnames): Update.
+* dwarf_getmacros.c (dwarf_getmacros): Update.
+* dwarf_getcfi.c (dwarf_getcfi): Update
+* dwarf_getattrs.c (dwarf_getattrs): Update.
+* dwarf_getaranges.c (dwarf_getaranges): Update.
+* dwarf_getabbrev.c (__libdw_getabbrev): Update.
+* dwarf_formudata.c (__libdw_formptr): Update.
+* dwarf_formstring.c (dwarf_formstring): Update.
+* dwarf_formref_die.c (dwarf_formref_die): Update.
+* dwarf_end.c (__libdw_free_zdata): Rewrite.
+* dwarf_child.c (__libdw_find_attr): Update.
+* dwarf_begin_elf.c (check_section, valid_p): Update.
+
 2012-01-31  Mark Wielaard  <mjw< at >redhat.com>
 
 * dwarf_formudata.c (dwarf_formudata): Handle DW_FORM_sec_offset.
diff --git a/libdw/dwarf_begin_elf.c b/libdw/dwarf_begin_elf.c
index 9ec7d51..f7ae8ab 100644
--- a/libdw/dwarf_begin_elf.c
+++ b/libdw/dwarf_begin_elf.c
< at >< at > -137,7 +137,7 < at >< at > check_section (Dwarf *result, GElf_Ehdr *ehdr, Elf_Scn *scn, bool inscngrp)
     if (strcmp (scnname, dwarf_scnnames[cnt]) == 0)
       {
 /* Found it.  Remember where the data is.  */
-if (unlikely (result->sectiondata[cnt] != NULL))
+if (unlikely (result->sectiondata[cnt].data != NULL))
   /* A section appears twice.  That's bad.  We ignore the section.  */
   break;
 
< at >< at > -145,7 +145,7 < at >< at > check_section (Dwarf *result, GElf_Ehdr *ehdr, Elf_Scn *scn, bool inscngrp)
 Elf_Data *data = elf_getdata (scn, NULL);
 if (data != NULL && data->d_size != 0)
   /* Yep, there is actually data available.  */
-  result->sectiondata[cnt] = data;
+  result->sectiondata[cnt].data = data;
 
 break;
       }
< at >< at > -155,7 +155,7 < at >< at > check_section (Dwarf *result, GElf_Ehdr *ehdr, Elf_Scn *scn, bool inscngrp)
       {
 /* A compressed section.  */
 
-if (unlikely (result->sectiondata[cnt] != NULL))
+if (unlikely (result->sectiondata[cnt].data != NULL))
   /* A section appears twice.  That's bad.  We ignore the section.  */
   break;
 
< at >< at > -211,8 +211,8 < at >< at > check_section (Dwarf *result, GElf_Ehdr *ehdr, Elf_Scn *scn, bool inscngrp)
       free (zdata);
     else
       {
-result->sectiondata[cnt] = zdata;
-result->sectiondata_gzip_mask |= 1U << cnt;
+result->sectiondata[cnt].data = zdata;
+result->sectiondata[cnt].gzipped = 1;
       }
   }
 
< at >< at > -235,7 +235,7 < at >< at > valid_p (Dwarf *result)
      necessary.  For now we require only .debug_info.  Hopefully this
      is correct.  */
   if (likely (result != NULL)
-      && unlikely (result->sectiondata[IDX_debug_info] == NULL))
+      && unlikely (result->sectiondata[IDX_debug_info].data == NULL))
     {
       __libdw_free_zdata (result);
       __libdw_seterrno (DWARF_E_NO_DWARF);
diff --git a/libdw/dwarf_child.c b/libdw/dwarf_child.c
index 0c2df00..2a4cf12 100644
--- a/libdw/dwarf_child.c
+++ b/libdw/dwarf_child.c
< at >< at > -1,5 +1,5 < at >< at >
 /* Return child of current DIE.
-   Copyright (C) 2003-2011 Red Hat, Inc.
+   Copyright (C) 2003-2012 Red Hat, Inc.
    This file is part of Red Hat elfutils.
    Written by Ulrich Drepper <drepper< at >redhat.com>, 2003.
 
< at >< at > -88,8 +88,8 < at >< at > __libdw_find_attr (Dwarf_Die *die, unsigned int search_name,
 
   /* Search the name attribute.  */
   unsigned char *const endp
-    = ((unsigned char *) dbg->sectiondata[IDX_debug_abbrev]->d_buf
-       + dbg->sectiondata[IDX_debug_abbrev]->d_size);
+    = ((unsigned char *) dbg->sectiondata[IDX_debug_abbrev].data->d_buf
+       + dbg->sectiondata[IDX_debug_abbrev].data->d_size);
 
   const unsigned char *attrp = die->abbrev->attrp;
   while (1)
diff --git a/libdw/dwarf_end.c b/libdw/dwarf_end.c
index 1e733ca..2636c69 100644
--- a/libdw/dwarf_end.c
+++ b/libdw/dwarf_end.c
< at >< at > -1,5 +1,5 < at >< at >
 /* Release debugging handling context.
-   Copyright (C) 2002-2011 Red Hat, Inc.
+   Copyright (C) 2002-2012 Red Hat, Inc.
    This file is part of Red Hat elfutils.
    Written by Ulrich Drepper <drepper< at >redhat.com>, 2002.
 
< at >< at > -83,15 +83,12 < at >< at > void
 internal_function
 __libdw_free_zdata (Dwarf *dwarf)
 {
-  unsigned int gzip_mask = dwarf->sectiondata_gzip_mask;
-  while (gzip_mask != 0)
+  size_t i;
+
+  for (i = 0; i < IDX_last; ++i)
     {
-      int i = ffs (gzip_mask);
-      assert (i > 0);
-      --i;
-      assert (i < IDX_last);
-      free (dwarf->sectiondata[i]);
-      gzip_mask &= ~(1U << i);
+      if (dwarf->sectiondata[i].gzipped)
+free (dwarf->sectiondata[i].data);
     }
 }
 #endif
diff --git a/libdw/dwarf_formref_die.c b/libdw/dwarf_formref_die.c
index 3ec770d..88dc065 100644
--- a/libdw/dwarf_formref_die.c
+++ b/libdw/dwarf_formref_die.c
< at >< at > -105,7 +105,7 < at >< at > dwarf_formref_die (attr, result)
   }
 while (cu->type_sig8 != sig);
 
-      data = cu->dbg->sectiondata[IDX_debug_types];
+      data = cu->dbg->sectiondata[IDX_debug_types].data;
       offset = cu->type_offset;
     }
   else
diff --git a/libdw/dwarf_formstring.c b/libdw/dwarf_formstring.c
index 1dee9b2..85dbae4 100644
--- a/libdw/dwarf_formstring.c
+++ b/libdw/dwarf_formstring.c
< at >< at > -72,7 +72,7 < at >< at > dwarf_formstring (attrp)
   Dwarf *dbg = attrp->cu->dbg;
 
   if (unlikely (attrp->form != DW_FORM_strp)
-      || dbg->sectiondata[IDX_debug_str] == NULL)
+      || dbg->sectiondata[IDX_debug_str].data == NULL)
     {
       __libdw_seterrno (DWARF_E_NO_STRING);
       return NULL;
< at >< at > -83,6 +83,6 < at >< at > dwarf_formstring (attrp)
    attrp->cu->offset_size, &off, IDX_debug_str, 1))
     return NULL;
 
-  return (const char *) dbg->sectiondata[IDX_debug_str]->d_buf + off;
+  return (const char *) dbg->sectiondata[IDX_debug_str].data->d_buf + off;
 }
 INTDEF(dwarf_formstring)
diff --git a/libdw/dwarf_formudata.c b/libdw/dwarf_formudata.c
index 07efbe0..b3a7520 100644
--- a/libdw/dwarf_formudata.c
+++ b/libdw/dwarf_formudata.c
< at >< at > -63,7 +63,7 < at >< at > __libdw_formptr (Dwarf_Attribute *attr, int sec_index,
   if (attr == NULL)
     return NULL;
 
-  const Elf_Data *d = attr->cu->dbg->sectiondata[sec_index];
+  const Elf_Data *d = attr->cu->dbg->sectiondata[sec_index].data;
   if (unlikely (d == NULL))
     {
       __libdw_seterrno (err_nodata);
diff --git a/libdw/dwarf_getabbrev.c b/libdw/dwarf_getabbrev.c
index 07bf6df..7b632c0 100644
--- a/libdw/dwarf_getabbrev.c
+++ b/libdw/dwarf_getabbrev.c
< at >< at > -67,17 +67,17 < at >< at > __libdw_getabbrev (dbg, cu, offset, lengthp, result)
      Dwarf_Abbrev *result;
 {
   /* Don't fail if there is not .debug_abbrev section.  */
-  if (dbg->sectiondata[IDX_debug_abbrev] == NULL)
+  if (dbg->sectiondata[IDX_debug_abbrev].data == NULL)
     return NULL;
 
-  if (offset >= dbg->sectiondata[IDX_debug_abbrev]->d_size)
+  if (offset >= dbg->sectiondata[IDX_debug_abbrev].data->d_size)
     {
       __libdw_seterrno (DWARF_E_INVALID_OFFSET);
       return NULL;
     }
 
   const unsigned char *abbrevp
-    = (unsigned char *) dbg->sectiondata[IDX_debug_abbrev]->d_buf + offset;
+    = (unsigned char *) dbg->sectiondata[IDX_debug_abbrev].data->d_buf + offset;
 
   if (*abbrevp == '\0')
     /* We are past the last entry.  */
diff --git a/libdw/dwarf_getaranges.c b/libdw/dwarf_getaranges.c
index f18d63d..e8f377e 100644
--- a/libdw/dwarf_getaranges.c
+++ b/libdw/dwarf_getaranges.c
< at >< at > -89,7 +89,7 < at >< at > dwarf_getaranges (dbg, aranges, naranges)
       return 0;
     }
 
-  if (dbg->sectiondata[IDX_debug_aranges] == NULL)
+  if (dbg->sectiondata[IDX_debug_aranges].data == NULL)
     {
       /* No such section.  */
       *aranges = NULL;
< at >< at > -98,15 +98,15 < at >< at > dwarf_getaranges (dbg, aranges, naranges)
       return 0;
     }
 
-  if (dbg->sectiondata[IDX_debug_aranges]->d_buf == NULL)
+  if (dbg->sectiondata[IDX_debug_aranges].data->d_buf == NULL)
     return -1;
 
   struct arangelist *arangelist = NULL;
   unsigned int narangelist = 0;
 
-  const unsigned char *readp = dbg->sectiondata[IDX_debug_aranges]->d_buf;
+  const unsigned char *readp = dbg->sectiondata[IDX_debug_aranges].data->d_buf;
   const unsigned char *readendp
-    = readp + dbg->sectiondata[IDX_debug_aranges]->d_size;
+    = readp + dbg->sectiondata[IDX_debug_aranges].data->d_size;
 
   while (readp < readendp)
     {
< at >< at > -204,7 +204,7 < at >< at > dwarf_getaranges (dbg, aranges, naranges)
   new_arange->arange.length = range_length;
 
   /* We store the actual CU DIE offset, not the CU header offset.  */
-  const char *cu_header = (dbg->sectiondata[IDX_debug_info]->d_buf
+  const char *cu_header = (dbg->sectiondata[IDX_debug_info].data->d_buf
    + offset);
   unsigned int offset_size;
   if (read_4ubyte_unaligned_noncvt (cu_header) == DWARF3_LENGTH_64_BIT)
< at >< at > -221,7 +221,7 < at >< at > dwarf_getaranges (dbg, aranges, naranges)
 
   /* Sanity-check the data.  */
   if (unlikely (new_arange->arange.offset
->= dbg->sectiondata[IDX_debug_info]->d_size))
+>= dbg->sectiondata[IDX_debug_info].data->d_size))
     goto invalid;
 }
     }
diff --git a/libdw/dwarf_getattrs.c b/libdw/dwarf_getattrs.c
index 051dc25..f7b913e 100644
--- a/libdw/dwarf_getattrs.c
+++ b/libdw/dwarf_getattrs.c
< at >< at > -92,8 +92,8 < at >< at > dwarf_getattrs (Dwarf_Die *die, int (*callback) (Dwarf_Attribute *, void *),
     {
       /* Are we still in bounds?  */
       if (unlikely (attrp
-    >= ((unsigned char *) dbg->sectiondata[IDX_debug_abbrev]->d_buf
-+ dbg->sectiondata[IDX_debug_abbrev]->d_size)))
+    >= ((unsigned char *) dbg->sectiondata[IDX_debug_abbrev].data->d_buf
++ dbg->sectiondata[IDX_debug_abbrev].data->d_size)))
 goto invalid_dwarf;
 
       /* Get attribute name and form.  */
diff --git a/libdw/dwarf_getcfi.c b/libdw/dwarf_getcfi.c
index c935631..f161b20 100644
--- a/libdw/dwarf_getcfi.c
+++ b/libdw/dwarf_getcfi.c
< at >< at > -62,12 +62,12 < at >< at > dwarf_getcfi (dbg)
   if (dbg == NULL)
     return NULL;
 
-  if (dbg->cfi == NULL && dbg->sectiondata[IDX_debug_frame] != NULL)
+  if (dbg->cfi == NULL && dbg->sectiondata[IDX_debug_frame].data != NULL)
     {
       Dwarf_CFI *cfi = libdw_typed_alloc (dbg, Dwarf_CFI);
 
       cfi->dbg = dbg;
-      cfi->data = (Elf_Data_Scn *) dbg->sectiondata[IDX_debug_frame];
+      cfi->data = (Elf_Data_Scn *) dbg->sectiondata[IDX_debug_frame].data;
 
       cfi->search_table = NULL;
       cfi->search_table_vaddr = 0;
diff --git a/libdw/dwarf_getmacros.c b/libdw/dwarf_getmacros.c
index b9ec34b..21750ef 100644
--- a/libdw/dwarf_getmacros.c
+++ b/libdw/dwarf_getmacros.c
< at >< at > -68,7 +68,7 < at >< at > dwarf_getmacros (die, callback, arg, offset)
   if (die == NULL)
     return -1;
 
-  Elf_Data *d = die->cu->dbg->sectiondata[IDX_debug_macinfo];
+  Elf_Data *d = die->cu->dbg->sectiondata[IDX_debug_macinfo].data;
   if (unlikely (d == NULL) || unlikely (d->d_buf == NULL))
     {
       __libdw_seterrno (DWARF_E_NO_ENTRY);
diff --git a/libdw/dwarf_getpubnames.c b/libdw/dwarf_getpubnames.c
index 5560a75..c5fdfef 100644
--- a/libdw/dwarf_getpubnames.c
+++ b/libdw/dwarf_getpubnames.c
< at >< at > -68,9 +68,11 < at >< at > get_offsets (Dwarf *dbg)
   size_t cnt = 0;
   struct pubnames_s *mem = NULL;
   const size_t entsize = sizeof (struct pubnames_s);
-  unsigned char *const startp = dbg->sectiondata[IDX_debug_pubnames]->d_buf;
+  unsigned char *const startp
+    = dbg->sectiondata[IDX_debug_pubnames].data->d_buf;
   unsigned char *readp = startp;
-  unsigned char *endp = readp + dbg->sectiondata[IDX_debug_pubnames]->d_size;
+  unsigned char *endp
+    = readp + dbg->sectiondata[IDX_debug_pubnames].data->d_size;
 
   while (readp + 14 < endp)
     {
< at >< at > -109,7 +111,8 < at >< at > get_offsets (Dwarf *dbg)
       /* Now we know the offset of the first offset/name pair.  */
       mem[cnt].set_start = readp + 2 + 2 * len_bytes - startp;
       mem[cnt].address_len = len_bytes;
-      if (mem[cnt].set_start >= dbg->sectiondata[IDX_debug_pubnames]->d_size)
+      if (mem[cnt].set_start
+  >= dbg->sectiondata[IDX_debug_pubnames].data->d_size)
 /* Something wrong, the first entry is beyond the end of
    the section.  */
 break;
< at >< at > -130,7 +133,7 < at >< at > get_offsets (Dwarf *dbg)
 
       /* Determine the size of the CU header.  */
       unsigned char *infop
-= ((unsigned char *) dbg->sectiondata[IDX_debug_info]->d_buf
+= ((unsigned char *) dbg->sectiondata[IDX_debug_info].data->d_buf
    + mem[cnt].cu_offset);
       if (read_4ubyte_unaligned_noncvt (infop) == DWARF3_LENGTH_64_BIT)
 mem[cnt].cu_header_size = 23;
< at >< at > -173,9 +176,9 < at >< at > dwarf_getpubnames (dbg, callback, arg, offset)
     }
 
   /* Make sure it is a valid offset.  */
-  if (unlikely (dbg->sectiondata[IDX_debug_pubnames] == NULL
+  if (unlikely (dbg->sectiondata[IDX_debug_pubnames].data == NULL
 || ((size_t) offset
-    >= dbg->sectiondata[IDX_debug_pubnames]->d_size)))
+    >= dbg->sectiondata[IDX_debug_pubnames].data->d_size)))
     /* No (more) entry.  */
     return 0;
 
< at >< at > -203,7 +206,7 < at >< at > dwarf_getpubnames (dbg, callback, arg, offset)
     }
 
   unsigned char *startp
-    = (unsigned char *) dbg->sectiondata[IDX_debug_pubnames]->d_buf;
+    = (unsigned char *) dbg->sectiondata[IDX_debug_pubnames].data->d_buf;
   unsigned char *readp = startp + offset;
   while (1)
     {
< at >< at > -243,7 +246,8 < at >< at > dwarf_getpubnames (dbg, callback, arg, offset)
 /* This was the last set.  */
 break;
 
-      startp = (unsigned char *) dbg->sectiondata[IDX_debug_pubnames]->d_buf;
+      startp
+= (unsigned char *) dbg->sectiondata[IDX_debug_pubnames].data->d_buf;
       readp = startp + dbg->pubnames_sets[cnt].set_start;
     }
 
diff --git a/libdw/dwarf_getstring.c b/libdw/dwarf_getstring.c
index d5e7abf..04e6295 100644
--- a/libdw/dwarf_getstring.c
+++ b/libdw/dwarf_getstring.c
< at >< at > -65,18 +65,20 < at >< at > dwarf_getstring (dbg, offset, lenp)
   if (dbg == NULL)
     return NULL;
 
-  if (dbg->sectiondata[IDX_debug_str] == NULL
-      || offset >= dbg->sectiondata[IDX_debug_str]->d_size)
+  if (dbg->sectiondata[IDX_debug_str].data == NULL
+      || offset >= dbg->sectiondata[IDX_debug_str].data->d_size)
     {
     no_string:
       __libdw_seterrno (DWARF_E_NO_STRING);
       return NULL;
     }
 
-  const char *result = ((const char *) dbg->sectiondata[IDX_debug_str]->d_buf
-+ offset);
+  const char *result
+    = ((const char *) dbg->sectiondata[IDX_debug_str].data->d_buf
+       + offset);
   const char *endp = memchr (result, '\0',
-     dbg->sectiondata[IDX_debug_str]->d_size - offset);
+     dbg->sectiondata[IDX_debug_str].data->d_size
+     - offset);
   if (endp == NULL)
     goto no_string;
 
diff --git a/libdw/dwarf_nextcu.c b/libdw/dwarf_nextcu.c
index 2e8f4d7..66dd191 100644
--- a/libdw/dwarf_nextcu.c
+++ b/libdw/dwarf_nextcu.c
< at >< at > -79,11 +79,11 < at >< at > dwarf_next_unit (dwarf, off, next_off, header_sizep, versionp, abbrev_offsetp,
 
   /* If we reached the end before don't do anything.  */
   if (off == (Dwarf_Off) -1l
-      || unlikely (dwarf->sectiondata[sec_idx] == NULL)
+      || unlikely (dwarf->sectiondata[sec_idx].data == NULL)
       /* Make sure there is enough space in the .debug_info section
  for at least the initial word.  We cannot test the rest since
  we don't know yet whether this is a 64-bit object or not.  */
-      || unlikely (off + 4 >= dwarf->sectiondata[sec_idx]->d_size))
+      || unlikely (off + 4 >= dwarf->sectiondata[sec_idx].data->d_size))
     {
       *next_off = (Dwarf_Off) -1l;
       return 1;
< at >< at > -91,7 +91,7 < at >< at > dwarf_next_unit (dwarf, off, next_off, header_sizep, versionp, abbrev_offsetp,
 
   /* This points into the .debug_info section to the beginning of the
      CU entry.  */
-  const unsigned char *data = dwarf->sectiondata[sec_idx]->d_buf;
+  const unsigned char *data = dwarf->sectiondata[sec_idx].data->d_buf;
   const unsigned char *bytes = data + off;
 
   /* The format of the CU header is described in dwarf2p1 7.5.1:
< at >< at > -136,7 +136,7 < at >< at > dwarf_next_unit (dwarf, off, next_off, header_sizep, versionp, abbrev_offsetp,
 
   /* Now we know how large the header is.  */
   if (unlikely (DIE_OFFSET_FROM_CU_OFFSET (off, offset_size, debug_types)
->= dwarf->sectiondata[sec_idx]->d_size))
+>= dwarf->sectiondata[sec_idx].data->d_size))
     {
       *next_off = -1;
       return 1;
diff --git a/libdw/dwarf_offdie.c b/libdw/dwarf_offdie.c
index 4c650cf..90ada60 100644
--- a/libdw/dwarf_offdie.c
+++ b/libdw/dwarf_offdie.c
< at >< at > -65,7 +65,7 < at >< at > __libdw_offdie (Dwarf *dbg, Dwarf_Off offset, Dwarf_Die *result,
     return NULL;
 
   Elf_Data *const data = dbg->sectiondata[debug_types ? IDX_debug_types
-  : IDX_debug_info];
+  : IDX_debug_info].data;
   if (offset >= data->d_size)
     {
       __libdw_seterrno (DWARF_E_INVALID_DWARF);
diff --git a/libdw/dwarf_ranges.c b/libdw/dwarf_ranges.c
index 50fb6ba..035f4c4 100644
--- a/libdw/dwarf_ranges.c
+++ b/libdw/dwarf_ranges.c
< at >< at > -123,7 +123,7 < at >< at > dwarf_ranges (Dwarf_Die *die, ptrdiff_t offset, Dwarf_Addr *basep,
 
   /* We have to look for a noncontiguous range.  */
 
-  const Elf_Data *d = die->cu->dbg->sectiondata[IDX_debug_ranges];
+  const Elf_Data *d = die->cu->dbg->sectiondata[IDX_debug_ranges].data;
   if (d == NULL && offset != 0)
     {
       __libdw_seterrno (DWARF_E_NO_DEBUG_RANGES);
diff --git a/libdw/libdwP.h b/libdw/libdwP.h
index b84bf02..1505512 100644
--- a/libdw/libdwP.h
+++ b/libdw/libdwP.h
< at >< at > -1,5 +1,5 < at >< at >
 /* Internal definitions for libdwarf.
-   Copyright (C) 2002-2011 Red Hat, Inc.
+   Copyright (C) 2002-2012 Red Hat, Inc.
    This file is part of Red Hat elfutils.
    Written by Ulrich Drepper <drepper< at >redhat.com>, 2002.
 
< at >< at > -141,6 +141,20 < at >< at > enum
 
 #include "dwarf_sig8_hash.h"
 
+/* This represents a single DWARF section.  */
+struct Dwarf_Section
+{
+  /* The section data.  */
+  Elf_Data *data;
+
+#if USE_ZLIB
+  /* True if the section data is malloc'd decompressed data.  */
+  unsigned int gzipped : 1;
+#endif
+};
+
+typedef struct Dwarf_Section Dwarf_Section;
+
 /* This is the structure representing the debugging state.  */
 struct Dwarf
 {
< at >< at > -148,12 +162,7 < at >< at > struct Dwarf
   Elf *elf;
 
   /* The section data.  */
-  Elf_Data *sectiondata[IDX_last];
-
-#if USE_ZLIB
-  /* The 1 << N bit is set if sectiondata[N] is malloc'd decompressed data.  */
-  unsigned int sectiondata_gzip_mask:IDX_last;
-#endif
+  struct Dwarf_Section sectiondata[IDX_last];
 
   /* True if the file has a byte order different from the host.  */
   bool other_byte_order;
< at >< at > -506,7 +515,7 < at >< at > __libdw_relocate_offset (Dwarf *dbg __attribute__ ((unused)),
 static inline Elf_Data *
 __libdw_checked_get_data (Dwarf *dbg, int sec_index)
 {
-  Elf_Data *data = dbg->sectiondata[sec_index];
+  Elf_Data *data = dbg->sectiondata[sec_index].data;
   if (unlikely (data == NULL)
       || unlikely (data->d_buf == NULL))
     {
< at >< at > -618,7 +627,7 < at >< at > cu_sec_idx (struct Dwarf_CU *cu)
 static inline Elf_Data *
 cu_data (struct Dwarf_CU *cu)
 {
-  return cu->dbg->sectiondata[cu_sec_idx (cu)];
+  return cu->dbg->sectiondata[cu_sec_idx (cu)].data;
 }
 
 /* Read up begin/end pair and increment read pointer.
diff --git a/libdwfl/ChangeLog b/libdwfl/ChangeLog
index 87a0555..b25d87d 100644
--- a/libdwfl/ChangeLog
+++ b/libdwfl/ChangeLog
< at >< at > -1,3 +1,7 < at >< at >
+2012-03-20  Tom Tromey  <tromey< at >redhat.com>
+
+* cu.c (intern_cu): Update for change to sectiondata.
+
 2011-12-02  Roland McGrath  <roland< at >hack.frob.com>
 
 * elf-from-memory.c (elf_from_remote_memory): Fix ELFCLASS64 case
diff --git a/libdwfl/cu.c b/libdwfl/cu.c
index 515aff3..353b915 100644
--- a/libdwfl/cu.c
+++ b/libdwfl/cu.c
< at >< at > -197,7 +197,8 < at >< at > intern_cu (Dwfl_Module *mod, Dwarf_Off cuoff, struct dwfl_cu **result)
 
   if (*found == &key || *found == NULL)
     {
-      if (unlikely (cuoff + 4 >= mod->dw->sectiondata[IDX_debug_info]->d_size))
+      if (unlikely (cuoff + 4
+    >= mod->dw->sectiondata[IDX_debug_info].data->d_size))
 {
   /* This is the EOF marker.  Now we have interned all the CUs.
      One increment in MOD->lazycu counts not having hit EOF yet.  */
diff --git a/src/ChangeLog b/src/ChangeLog
index ff19b48..7f9a9d3 100644
--- a/src/ChangeLog
+++ b/src/ChangeLog
< at >< at > -1,3 +1,9 < at >< at >
+2012-03-20  Tom Tromey  <tromey< at >redhat.com>
+
+* readelf.c (print_debug_abbrev_section): Update for change to
+sectiondata.
+(print_debug_str_section): Likewise.
+
 2012-01-31  Mark Wielaard  <mjw< at >redhat.com>
 
 * readelf.c (attr_callback): Don't special case DW_FORM_sec_offset.
diff --git a/src/readelf.c b/src/readelf.c
index 8876688..bea90b7 100644
--- a/src/readelf.c
+++ b/src/readelf.c
< at >< at > -4572,7 +4572,7 < at >< at > print_debug_abbrev_section (Dwfl_Module *dwflmod __attribute__ ((unused)),
   (uint64_t) shdr->sh_offset);
 
   Dwarf_Off offset = 0;
-  while (offset < dbg->sectiondata[IDX_debug_abbrev]->d_size)
+  while (offset < dbg->sectiondata[IDX_debug_abbrev].data->d_size)
     {
       printf (gettext ("\nAbbreviation section at offset %" PRIu64 ":\n"),
       offset);
< at >< at > -6781,7 +6781,7 < at >< at > print_debug_str_section (Dwfl_Module *dwflmod __attribute__ ((unused)),
  Ebl *ebl, GElf_Ehdr *ehdr,
  Elf_Scn *scn, GElf_Shdr *shdr, Dwarf *dbg)
 {
-  const size_t sh_size = dbg->sectiondata[IDX_debug_str]->d_size;
+  const size_t sh_size = dbg->sectiondata[IDX_debug_str].data->d_size;
 
   /* Compute floor(log16(shdr->sh_size)).  */
   GElf_Addr tmp = sh_size;

[0/5] handle multiple .debug_types sections

Tom Tromey — 2012-03-20T19:57:26

I added support for multiple .debug_types sections to libdw.

I consider this a WIP patch.  There is one definitely bad patch (#4) and
of course the usual stylistic things; in particular the new CU-iterating
function (in patch #5) is pretty ugly.

I'd appreciate feedback on this.

Tom
_______________________________________________
elfutils-devel mailing list
elfutils-devel< at >lists.fedorahosted.org
https://fedorahosted.org/mailman/listinfo/elfutils-devel

libdw patch for .debug_types iteration

Tom Tromey — 2012-03-19T17:54:12

Tom

From 1b85426f7a1fa39cfb9ff83b864e825072115847 Mon Sep 17 00:00:00 2001
From: Tom Tromey <tromey< at >redhat.com>
Date: Mon, 19 Mar 2012 11:46:45 -0600
Subject: [PATCH] Fix bug using dwarf_next_unit to iterate over .debug_types

* libdw_findcu.c (findcu_cb): Move earlier.
(__libdw_intern_next_unit): Add new CU to search tree here...
(__libdw_findcu): ... not here.

If you call dwarf_next_unit to iterate over .debug_types, then call
dwarf_offdie_types, you can see a failure if some earlier call
happened to call __libdw_intern_next_unit via dwarf_formref_die.

What happens is that __libdw_intern_next_unit updates the Dwarf's
next_tu_offset, but does not add the TU to the TU search tree.  So,
the call to dwarf_offdie_types does not find the TU in the tree, and
will not search any more, causing a failure.

This fix changes __libdw_intern_next_unit to add the TU to the search
tree, rather than relying on __libdw_findcu to do it.
---
 libdw/ChangeLog      |    6 ++++
 libdw/libdw_findcu.c |   68 ++++++++++++++++++++++++-------------------------
 2 files changed, 39 insertions(+), 35 deletions(-)

diff --git a/libdw/ChangeLog b/libdw/ChangeLog
index 98b67f4..f96c0d1 100644
--- a/libdw/ChangeLog
+++ b/libdw/ChangeLog
< at >< at > -1,3 +1,9 < at >< at >
+2012-03-19  Tom Tromey  <tromey< at >redhat.com>
+
+* libdw_findcu.c (findcu_cb): Move earlier.
+(__libdw_intern_next_unit): Add new CU to search tree here...
+(__libdw_findcu): ... not here.
+
 2012-01-31  Mark Wielaard  <mjw< at >redhat.com>
 
 * dwarf_formudata.c (dwarf_formudata): Handle DW_FORM_sec_offset.
diff --git a/libdw/libdw_findcu.c b/libdw/libdw_findcu.c
index 8e5f9e9..83c96ba 100644
--- a/libdw/libdw_findcu.c
+++ b/libdw/libdw_findcu.c
< at >< at > -56,6 +56,31 < at >< at >
 #include <search.h>
 #include "libdwP.h"
 
+static int
+findcu_cb (const void *arg1, const void *arg2)
+{
+  struct Dwarf_CU *cu1 = (struct Dwarf_CU *) arg1;
+  struct Dwarf_CU *cu2 = (struct Dwarf_CU *) arg2;
+
+  /* Find out which of the two arguments is the search value.  It has
+     end offset 0.  */
+  if (cu1->end == 0)
+    {
+      if (cu1->start < cu2->start)
+return -1;
+      if (cu1->start >= cu2->end)
+return 1;
+    }
+  else
+    {
+      if (cu2->start < cu1->start)
+return 1;
+      if (cu2->start >= cu1->end)
+return -1;
+    }
+
+  return 0;
+}
 
 struct Dwarf_CU *
 internal_function
< at >< at > -65,6 +90,7 < at >< at > __libdw_intern_next_unit (dbg, debug_types)
 {
   Dwarf_Off *const offsetp
     = debug_types ? &dbg->next_tu_offset : &dbg->next_cu_offset;
+  void **tree = debug_types ? &dbg->tu_tree : &dbg->cu_tree;
 
   Dwarf_Off oldoff = *offsetp;
   uint16_t version;
< at >< at > -105,34 +131,16 < at >< at > __libdw_intern_next_unit (dbg, debug_types)
   newp->lines = NULL;
   newp->locs = NULL;
 
-  return newp;
-}
-
-
-static int
-findcu_cb (const void *arg1, const void *arg2)
-{
-  struct Dwarf_CU *cu1 = (struct Dwarf_CU *) arg1;
-  struct Dwarf_CU *cu2 = (struct Dwarf_CU *) arg2;
-
-  /* Find out which of the two arguments is the search value.  It has
-     end offset 0.  */
-  if (cu1->end == 0)
+  /* Add the new entry to the search tree.  */
+  if (tsearch (newp, tree, findcu_cb) == NULL)
     {
-      if (cu1->start < cu2->start)
-return -1;
-      if (cu1->start >= cu2->end)
-return 1;
-    }
-  else
-    {
-      if (cu2->start < cu1->start)
-return 1;
-      if (cu2->start >= cu1->end)
-return -1;
+      /* Something went wrong.  Undo the operation.  */
+      *offsetp = oldoff;
+      __libdw_seterrno (DWARF_E_NOMEM);
+      return NULL;
     }
 
-  return 0;
+  return newp;
 }
 
 struct Dwarf_CU *
< at >< at > -160,20 +168,10 < at >< at > __libdw_findcu (dbg, start, debug_types)
   /* No.  Then read more CUs.  */
   while (1)
     {
-      Dwarf_Off oldoff = *next_offset;
       struct Dwarf_CU *newp = __libdw_intern_next_unit (dbg, debug_types);
       if (newp == NULL)
 return NULL;
 
-      /* Add the new entry to the search tree.  */
-      if (tsearch (newp, tree, findcu_cb) == NULL)
-{
-  /* Something went wrong.  Undo the operation.  */
-  *next_offset = oldoff;
-  __libdw_seterrno (DWARF_E_NOMEM);
-  return NULL;
-}
-
       /* Is this the one we are looking for?  */
       if (start < *next_offset)
 // XXX Match exact offset.

elf_end(): rwlock_fini() with a locked object

Kurt Roeckx — 2012-02-25T23:11:43

Hi,

In libelf/elf_end.c:244 you have:
  rwlock_fini (elf->lock);

But this lock is always still held when you get there.

I see this:
[...]
 
And I get this on Debian's kfreebsd port, resulting in an
assertion failure.  I wonder why I'm not getting it on other
ports.

Adding a "rwlock_unlock (elf->lock);" just in front of that
line fixes the problem.


Kurt

_______________________________________________
elfutils-devel mailing list
elfutils-devel< at >lists.fedorahosted.org
https://fedorahosted.org/mailman/listinfo/elfutils-devel

addr2line format specifiers

Kurt Roeckx — 2012-02-24T21:36:32

Hi,

addr2line.c:457 has:
      char *name = NULL;
      if (sscanf (string, "(%m[^)])%" PRIiMAX "%n", &name, &addr, &i) == 2
          && string[i] == '\0')
        parsed = adjust_to_section (name, &addr, dwfl);
      switch (sscanf (string, "%m[^-+]%n%" PRIiMAX "%n", &name, &i, &addr, &j))

And in the portability branch that got changed to:
      char *name = NULL;
      if (sscanf (string, "(%a[^)])%" PRIiMAX "%n", &name, &addr, &i) == 2
          && string[i] == '\0')
        parsed = adjust_to_section (name, &addr, dwfl);
      switch (sscanf (string, "%a[^-+]%n%" PRIiMAX "%n", &name, &i, &addr, &j))

But I think that that doesn't make sense.  Isn't %m the gnu extention,
and that %a now follows the C99 standard and expects a float *?


Kurt

_______________________________________________
elfutils-devel mailing list
elfutils-devel< at >lists.fedorahosted.org
https://fedorahosted.org/mailman/listinfo/elfutils-devel