readelf: -p option can take an argument like -x for one section,
or no argument (as before) for all SHF_STRINGS sections;
- new option --archive-index (or -c)
+ new option --archive-index (or -c);
+ improved -n output for core files, on many machines
libelf: new function elf_getdata_rawchunk, replaces gelf_rawchunk;
new functions gelf_getnote, gelf_getauxv, gelf_update_auxv
readelf, elflint: handle SHT_NOTE sections without requiring phdrs
+elflint: stricter checks on debug sections
+
libdwfl: new functions dwfl_build_id_find_elf, dwfl_build_id_find_debuginfo,
dwfl_module_build_id, dwfl_module_report_build_id;
support dynamic symbol tables found via phdrs;
unstrip: new option --list (or -n)
+libebl: backend improvements for sparc, alpha, powerpc
+
Version 0.129:
readelf: new options --hex-dump (or -x), --strings (or -p)
+2007-10-09 Roland McGrath <roland@redhat.com>
+
+ * sparc_auxv.c: New file.
+ * Makefile.am (sparc_SRCS): Add it.
+ * sparc_init.c (sparc_init): Initialize auxv_info hook.
+
+2007-10-08 Roland McGrath <roland@redhat.com>
+
+ * linux-core-note.c (TIMEVAL_FIELD): New macro.
+ (prstatus_items): Use it.
+ * sparc_corenote.c: New file.
+ * sparc64_corenote.c: New file.
+ * Makefile.am (sparc_SRCS): Add them.
+ * sparc_init.c (sparc_init): Initialize core_note hook.
+
+ * sparc_symbol.c (sparc_machine_flag_check): New function.
+ * sparc_init.c (sparc_init): Use it.
+
2007-09-27 Roland McGrath <roland@redhat.com>
* alpha_retval.c: Use dwarf_attr_integrate and dwarf_hasattr_integrate.
libebl_arm_pic_a_SOURCES = $(arm_SRCS)
am_libebl_arm_pic_a_OBJECTS = $(arm_SRCS:.c=.os)
-sparc_SRCS = sparc_init.c sparc_symbol.c sparc_regs.c sparc_retval.c
+sparc_SRCS = sparc_init.c sparc_symbol.c sparc_regs.c sparc_retval.c \
+ sparc_corenote.c sparc64_corenote.c sparc_auxv.c
libebl_sparc_pic_a_SOURCES = $(sparc_SRCS)
am_libebl_sparc_pic_a_OBJECTS = $(sparc_SRCS:.c=.os)
FIELD (ULONG, tv_usec);
};
+/* On sparc64, tv_usec (suseconds_t) is actually 32 bits with 32 bits padding.
+ The 'T'|0x80 value for .format indicates this as a special kludge. */
+#if SUSECONDS_HALF
+# define TIMEVAL_FIELD(name) FIELD (time, ULONG, name, 'T'|0x80, .count = 2)
+#else
+# define TIMEVAL_FIELD(name) FIELD (time, ULONG, name, 'T', .count = 2)
+#endif
+
+
struct EBLHOOK(prstatus)
{
struct EBLHOOK(siginfo) pr_info;
FIELD (identity, PID_T, ppid, 'd'),
FIELD (identity, PID_T, pgrp, 'd'),
FIELD (identity, PID_T, sid, 'd'),
- FIELD (time, ULONG, utime, 'T', .count = 2),
- FIELD (time, ULONG, stime, 'T', .count = 2),
- FIELD (time, ULONG, cutime, 'T', .count = 2),
- FIELD (time, ULONG, cstime, 'T', .count = 2),
+ TIMEVAL_FIELD (utime),
+ TIMEVAL_FIELD (stime),
+ TIMEVAL_FIELD (cutime),
+ TIMEVAL_FIELD (cstime),
#ifdef PRSTATUS_REGSET_ITEMS
PRSTATUS_REGSET_ITEMS,
#endif
--- /dev/null
+#define BITS 64
+#include "sparc_corenote.c"
--- /dev/null
+/* SPARC-specific auxv handling.
+ Copyright (C) 2007 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
+
+#define BACKEND sparc_
+#include "libebl_CPU.h"
+
+int
+EBLHOOK(auxv_info) (GElf_Xword a_type, const char **name, const char **format)
+{
+ if (a_type != AT_HWCAP)
+ return 0;
+
+ *name = "HWCAP";
+ *format = "b"
+ "flush\0" "stbar\0" "swap\0" "muldiv\0" "v9\0" "ultra3\0" "v9v\0" "\0";
+ return 1;
+}
--- /dev/null
+/* PowerPC specific core note handling.
+ Copyright (C) 2007 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 <elf.h>
+#include <inttypes.h>
+#include <stddef.h>
+#include <stdio.h>
+#include <sys/time.h>
+
+#ifndef BITS
+# define BITS 32
+# define BACKEND sparc_
+#else
+# define BITS 64
+# define BACKEND sparc64_
+#endif
+#include "libebl_CPU.h"
+
+#define GR(at, n, dwreg) \
+ { .offset = at * BITS/8, .regno = dwreg, .count = n, .bits = BITS }
+
+static const Ebl_Register_Location prstatus_regs[] =
+ {
+ GR (0, 32, 0), /* %g0-%g7, %o0-%o7, %i0-%i7 */
+#if BITS == 32
+ GR (32, 1, 65), /* %psr */
+ GR (33, 2, 68), /* %pc, %npc */
+ GR (35, 1, 64), /* %y */
+ GR (36, 1, 66), /* %wim, %tbr */
+#else
+ GR (32, 1, 82), /* %state */
+ GR (33, 2, 80), /* %pc, %npc */
+ GR (35, 1, 85), /* %y */
+#endif
+ };
+#define PRSTATUS_REGS_SIZE (BITS / 8 * (32 + (BITS == 32 ? 6 : 4)))
+
+static const Ebl_Register_Location fpregset_regs[] =
+ {
+#if BITS == 32
+ GR (0, 32, 32), /* %f0-%f31 */
+ /* padding word */
+ GR (33, 1, 70), /* %fsr */
+ /* qcnt, q_entrysize, en, q, padding */
+# define FPREGSET_SIZE (34 * 4 + 4 + 64 * 4 + 4)
+#else
+ GR (0, 32, 32), /* %f0-%f31 */
+ GR (32, 1, 83), /* %fsr */
+ /* 33, 1, %gsr */
+ GR (34, 1, 84), /* %fprs */
+# define FPREGSET_SIZE (35 * 8)
+#endif
+ };
+
+#if BITS == 32
+# define ULONG uint32_t
+# define ALIGN_ULONG 4
+# define TYPE_ULONG ELF_T_WORD
+# define TYPE_LONG ELF_T_SWORD
+# define UID_T uint16_t
+# define GID_T uint16_t
+# define ALIGN_UID_T 2
+# define ALIGN_GID_T 2
+# define TYPE_UID_T ELF_T_HALF
+# define TYPE_GID_T ELF_T_HALF
+#else
+# define ULONG uint64_t
+# define ALIGN_ULONG 8
+# define TYPE_ULONG ELF_T_XWORD
+# define TYPE_LONG ELF_T_SXWORD
+# define UID_T uint32_t
+# define GID_T uint32_t
+# define ALIGN_UID_T 4
+# define ALIGN_GID_T 4
+# define TYPE_UID_T ELF_T_WORD
+# define TYPE_GID_T ELF_T_WORD
+# define SUSECONDS_HALF 1
+#endif
+#define PID_T int32_t
+#define ALIGN_PID_T 4
+#define TYPE_PID_T ELF_T_SWORD
+
+#include "linux-core-note.c"
/* Initialization of SPARC specific backend library.
- Copyright (C) 2002, 2005, 2006 Red Hat, Inc.
+ Copyright (C) 2002, 2005, 2006, 2007 Red Hat, Inc.
This file is part of Red Hat elfutils.
Red Hat elfutils is free software; you can redistribute it and/or modify
/* This defines the common reloc hooks based on sparc_reloc.def. */
#include "common-reloc.c"
+extern __typeof (EBLHOOK (core_note)) sparc64_core_note attribute_hidden;
const char *
sparc_init (elf, machine, eh, ehlen)
eh->name = "SPARC";
sparc_init_reloc (eh);
HOOK (eh, reloc_simple_type);
- //HOOK (eh, core_note);
+ HOOK (eh, machine_flag_check);
+ if (eh->class == ELFCLASS64)
+ eh->core_note = sparc64_core_note;
+ else
+ HOOK (eh, core_note);
+ HOOK (eh, auxv_info);
HOOK (eh, register_info);
HOOK (eh, return_value_location);
/* SPARC specific symbolic name handling.
- Copyright (C) 2002, 2003, 2005 Red Hat, Inc.
+ Copyright (C) 2002, 2003, 2005, 2007 Red Hat, Inc.
This file is part of Red Hat elfutils.
Written by Jakub Jelinek <jakub@redhat.com>, 2002.
return ELF_T_NUM;
}
}
+
+/* Check whether machine flags are valid. */
+bool
+sparc_machine_flag_check (GElf_Word flags)
+{
+ return ((flags &~ (EF_SPARCV9_MM
+ | EF_SPARC_LEDATA
+ | EF_SPARC_32PLUS
+ | EF_SPARC_SUN_US1
+ | EF_SPARC_SUN_US3)) == 0);
+}
+2007-10-05 Roland McGrath <roland@redhat.com>
+
+ * dwarf_begin_elf.c (check_section): Punt on SHT_NOBITS sections.
+
+ * libdw.h (__extern_inline): Rename to __libdw_extern_inline.
+ [__OPTIMIZE__] (dwarf_whatattr, dwarf_whatform): Update uses.
+
2007-10-03 Roland McGrath <roland@redhat.com>
* libdw.map (ELFUTILS_0.130: Add dwfl_build_id_find_elf
wrong in the libelf library. */
abort ();
+ /* Ignore any SHT_NOBITS sections. Debugging sections should not
+ have been stripped, but in case of a corrupt file we won't try
+ to look at the missing data. */
+ 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
#endif
#ifdef __GNUC_STDC_INLINE__
-# define __extern_inline extern __inline __attribute__ ((__gnu_inline__))
+# define __libdw_extern_inline extern __inline __attribute__ ((__gnu_inline__))
#else
-# define __extern_inline extern __inline
+# define __libdw_extern_inline extern __inline
#endif
/* Inline optimizations. */
#ifdef __OPTIMIZE__
/* Return attribute code of given attribute. */
-__extern_inline unsigned int
+__libdw_extern_inline unsigned int
dwarf_whatattr (Dwarf_Attribute *attr)
{
return attr == NULL ? 0 : attr->code;
}
/* Return attribute code of given attribute. */
-__extern_inline unsigned int
+__libdw_extern_inline unsigned int
dwarf_whatform (Dwarf_Attribute *attr)
{
return attr == NULL ? 0 : attr->form;
+2007-10-09 Roland McGrath <roland@redhat.com>
+
+ * dwfl_report_elf.c (__libdwfl_report_elf): Clear SHDR->sh_offset when
+ caching SHDR->sh_addr = 0.
+ * offline.c (dwfl_offline_section_address): Never called for sh_addr
+ really at 0, don't check for it. Use MOD->debug directly, not symfile.
+
+ * dwfl_module_getdwarf.c (load_symtab): Return success properly when
+ we've found SHT_SYMTAB.
+
+ * relocate.c (relocate_getsym): New function.
+ (__libdwfl_relocate): Use it.
+ (__libdwfl_relocate_value): Take new Elf * argument. Make SYMSHSTRNDX
+ be a pointer instead of value; cache getshstrndx result there.
+ * libdwflP.h: Update decl.
+ * derelocate.c (cache_sections): Update caller.
+ Always work on the main file, not the symfile.
+ (dwfl_module_address_section): Likewise.
+ * dwfl_module_getsym.c (dwfl_module_getsym): Update caller.
+
+2007-10-07 Roland McGrath <roland@redhat.com>
+
+ * offline.c (process_archive): Initialize MOD.
+
+ * linux-kernel-modules.c (get_release): New function, broken out of ...
+ (report_kernel): ... here. Call it.
+ (try_kernel_name): Take new arg TRY_DEBUG, only try ".debug" if set.
+ (find_kernel_elf): Update caller.
+ (report_kernel_archive): New function.
+ (dwfl_linux_kernel_report_offline): Call it.
+
+ * offline.c (process_file): Take new arg PREDICATE, pass it down.
+ (process_archive): Likewise.
+ (process_archive_member): Likewise. When nonnull, let the predicate
+ decide whether to use this member.
+ (__libdwfl_report_offline): New function, broken out of ...
+ (dwfl_report_offline): ... here. Call it.
+ * libdwflP.h: Declare it.
+
+ * offline.c (process_archive, process_archive_member): New functions.
+ (process_elf, process_file): New functions, broken out of ...
+ (dwfl_report_offline): ... here. Call process_file, which recurses on
+ ELF_K_AR files.
+
+ * dwfl_report_elf.c (__libdwfl_report_elf): New, broken out of ...
+ (dwfl_report_elf): ... here. Call it.
+ * libdwflP.h: Declare it.
+
+2007-10-06 Roland McGrath <roland@redhat.com>
+
+ * derelocate.c (dwfl_module_relocations): Don't call
+ dwfl_module_getdwarf.
+
+ * derelocate.c (find_section): Use __libdwfl_seterrno, not
+ __libdw_seterrno.
+
+ * relocate.c (__libdwfl_relocate_value): Abuse sh_offset, not
+ SHF_ALLOC, to cache sh_addr resolved to 0.
+
+ * dwfl_report_elf.c (dwfl_report_elf): When an ET_REL file has sh_addr
+ values nonzero already, just use its existing layout.
+
+ * relocate.c (__libdwfl_relocate): Clear size of reloc section in its
+ in-core shdr after applying it.
+
2007-10-04 Ulrich Drepper <drepper@redhat.com>
* linux-kernel-modules.c (dwfl_linux_kernel_report_kernel): Fake
static int
cache_sections (Dwfl_Module *mod)
{
- size_t symshstrndx;
- if (elf_getshstrndx (mod->symfile->elf, &symshstrndx) < 0)
+ struct secref *refs = NULL;
+ size_t nrefs = 0;
+
+ size_t shstrndx;
+ if (unlikely (elf_getshstrndx (mod->main.elf, &shstrndx) < 0))
{
+ elf_error:
__libdwfl_seterrno (DWFL_E_LIBELF);
return -1;
}
- struct secref *refs = NULL;
- size_t nrefs = 0;
-
Elf_Scn *scn = NULL;
- while ((scn = elf_nextscn (mod->symfile->elf, scn)) != NULL)
+ while ((scn = elf_nextscn (mod->main.elf, scn)) != NULL)
{
GElf_Shdr shdr_mem;
GElf_Shdr *shdr = gelf_getshdr (scn, &shdr_mem);
if (shdr == NULL)
- return -1;
+ goto elf_error;
if ((shdr->sh_flags & SHF_ALLOC) && shdr->sh_addr == 0)
{
/* This section might not yet have been looked at. */
- if (__libdwfl_relocate_value (mod, symshstrndx, elf_ndxscn (scn),
+ if (__libdwfl_relocate_value (mod, mod->main.elf, &shstrndx,
+ elf_ndxscn (scn),
&shdr->sh_addr) != DWFL_E_NOERROR)
continue;
shdr = gelf_getshdr (scn, &shdr_mem);
- if (shdr == NULL)
- return -1;
+ if (unlikely (shdr == NULL))
+ goto elf_error;
}
if (shdr->sh_flags & SHF_ALLOC)
{
- const char *name = elf_strptr (mod->symfile->elf, symshstrndx,
+ const char *name = elf_strptr (mod->main.elf, shstrndx,
shdr->sh_name);
- if (name == NULL)
- return -1;
+ if (unlikely (name == NULL))
+ goto elf_error;
struct secref *newref = alloca (sizeof *newref);
newref->scn = scn;
newref->name = name;
- newref->start = shdr->sh_addr + mod->symfile->bias;
+ newref->start = shdr->sh_addr + mod->main.bias;
newref->end = newref->start + shdr->sh_size;
newref->next = refs;
refs = newref;
if (mod->reloc_info != NULL)
return mod->reloc_info->count;
- if (mod->dw == NULL)
- {
- Dwarf_Addr bias;
- if (INTUSE(dwfl_module_getdwarf) (mod, &bias) == NULL)
- return -1;
- }
-
switch (mod->e_type)
{
case ET_REL:
}
}
- __libdw_seterrno (DWARF_E_NO_MATCH);
+ __libdwfl_seterrno (DWFL_E (LIBDW, DWARF_E_NO_MATCH));
return -1;
}
if (idx < 0)
return NULL;
- *bias = mod->symfile->bias;
+ *bias = mod->main.bias;
return mod->reloc_info->refs[idx].scn;
}
}
-/* Try to find a symbol table in FILE. */
+/* Try to find a symbol table in FILE.
+ Returns DWFL_E_NOERROR if a proper one is found.
+ Returns DWFL_E_NO_SYMTAB if not, but still sets results for SHT_DYNSYM. */
static Dwfl_Error
load_symtab (struct dwfl_file *file, struct dwfl_file **symfile,
Elf_Scn **symscn, Elf_Scn **xndxscn,
*symfile = file;
*strshndx = shdr->sh_link;
*syments = shdr->sh_size / shdr->sh_entsize;
- if (*symscn != NULL && *xndxscn != NULL)
+ if (*xndxscn != NULL)
return DWFL_E_NOERROR;
break;
case SHT_SYMTAB_SHNDX:
*xndxscn = scn;
+ if (*symscn != NULL)
+ return DWFL_E_NOERROR;
break;
default:
break;
}
}
+
+ if (*symscn != NULL)
+ /* We found one, though no SHT_SYMTAB_SHNDX to go with it. */
+ return DWFL_E_NOERROR;
+
+ /* We found no SHT_SYMTAB, so any SHT_SYMTAB_SHNDX was bogus.
+ We might have found an SHT_DYNSYM and set *SYMSCN et al though. */
+ *xndxscn = NULL;
return DWFL_E_NO_SYMTAB;
}
/* Find debugging and symbol information for a module in libdwfl.
- Copyright (C) 2006 Red Hat, Inc.
+ Copyright (C) 2006,2007 Red Hat, Inc.
This file is part of Red Hat elfutils.
Red Hat elfutils is free software; you can redistribute it and/or modify
{
/* In an ET_REL file, the symbol table values are relative
to the section, not to the module's load base. */
- size_t symshstrndx;
- Dwfl_Error result = DWFL_E_LIBELF;
- if (elf_getshstrndx (mod->symfile->elf, &symshstrndx) == 0)
- result = __libdwfl_relocate_value (mod, symshstrndx,
- shndx, &sym->st_value);
+ size_t symshstrndx = SHN_UNDEF;
+ Dwfl_Error result = __libdwfl_relocate_value (mod, mod->symfile->elf,
+ &symshstrndx,
+ shndx, &sym->st_value);
if (unlikely (result != DWFL_E_NOERROR))
{
__libdwfl_seterrno (result);
/* Report a module to libdwfl based on ELF program headers.
- Copyright (C) 2005 Red Hat, Inc.
+ Copyright (C) 2005, 2007 Red Hat, Inc.
This file is part of Red Hat elfutils.
Red Hat elfutils is free software; you can redistribute it and/or modify
#include <fcntl.h>
#include <unistd.h>
-
Dwfl_Module *
-dwfl_report_elf (Dwfl *dwfl, const char *name,
- const char *file_name, int fd, GElf_Addr base)
+internal_function
+__libdwfl_report_elf (Dwfl *dwfl, const char *name, const char *file_name,
+ int fd, Elf *elf, GElf_Addr base)
{
- bool closefd = false;
-
- if (fd < 0)
- {
- fd = open64 (file_name, O_RDONLY);
- if (fd < 0)
- {
- __libdwfl_seterrno (DWFL_E_ERRNO);
- return NULL;
- }
- closefd = true;
- }
-
- Elf *elf = elf_begin (fd, ELF_C_READ_MMAP_PRIVATE, NULL);
-
GElf_Ehdr ehdr_mem, *ehdr = gelf_getehdr (elf, &ehdr_mem);
if (ehdr == NULL)
{
elf_error:
__libdwfl_seterrno (DWFL_E_LIBELF);
- if (closefd)
- close (fd);
return NULL;
}
if (shdr->sh_flags & SHF_ALLOC)
{
const GElf_Xword align = shdr->sh_addralign ?: 1;
- shdr->sh_addr = (end + align - 1) & -align;
- if (end == base)
- /* This is the first section assigned a location.
- Use its aligned address as the module's base. */
- start = shdr->sh_addr;
- end = shdr->sh_addr + shdr->sh_size;
- if (! gelf_update_shdr (scn, shdr))
- goto elf_error;
+ if (shdr->sh_addr == 0 || (bias == 0 && end > start))
+ {
+ shdr->sh_addr = (end + align - 1) & -align;
+ if (end == base)
+ /* This is the first section assigned a location.
+ Use its aligned address as the module's base. */
+ start = shdr->sh_addr;
+ end = shdr->sh_addr + shdr->sh_size;
+ if (shdr->sh_addr == 0)
+ /* This is a marker that this was resolved to zero,
+ to prevent a callback. */
+ shdr->sh_offset = 0;
+ if (! gelf_update_shdr (scn, shdr))
+ goto elf_error;
+ }
+ else
+ {
+ if (bias == 0 || end < shdr->sh_addr + shdr->sh_size)
+ end = shdr->sh_addr + shdr->sh_size;
+ if (bias == 0 || bias > shdr->sh_addr)
+ bias = shdr->sh_addr;
+ }
}
}
- if (end == start)
+ if (bias != 0)
{
- __libdwfl_seterrno (DWFL_E_BADELF);
- if (closefd)
- close (fd);
- return NULL;
+ /* The section headers had nonzero sh_addr values. The layout
+ was already done. We've just collected the total span.
+ Now just compute the bias from the requested base. */
+ start = base;
+ end = end - bias + start;
+ bias -= start;
}
break;
if (end == 0)
{
__libdwfl_seterrno (DWFL_E_NO_PHDR);
- if (closefd)
- close (fd);
return NULL;
}
break;
{
elf_end (elf);
overlap:
- if (closefd)
- close (fd);
m->gc = true;
__libdwfl_seterrno (DWFL_E_OVERLAP);
m = NULL;
}
return m;
}
+
+Dwfl_Module *
+dwfl_report_elf (Dwfl *dwfl, const char *name,
+ const char *file_name, int fd, GElf_Addr base)
+{
+ bool closefd = false;
+ if (fd < 0)
+ {
+ closefd = true;
+ fd = open64 (file_name, O_RDONLY);
+ if (fd < 0)
+ {
+ __libdwfl_seterrno (DWFL_E_ERRNO);
+ return NULL;
+ }
+ }
+
+ Elf *elf = elf_begin (fd, ELF_C_READ_MMAP_PRIVATE, NULL);
+ Dwfl_Module *mod = __libdwfl_report_elf (dwfl, name, file_name,
+ fd, elf, base);
+ if (mod == NULL)
+ {
+ elf_end (elf);
+ if (closefd)
+ close (fd);
+ }
+
+ return mod;
+}
INTDEF (dwfl_report_elf)
/* Adjust *VALUE from section-relative to absolute.
MOD->dwfl->callbacks->section_address is called to determine the actual
address of a loaded section. */
-extern Dwfl_Error __libdwfl_relocate_value (Dwfl_Module *mod,
- size_t m_shstrndx,
+extern Dwfl_Error __libdwfl_relocate_value (Dwfl_Module *mod, Elf *elf,
+ size_t *shstrndx_cache,
Elf32_Word shndx,
GElf_Addr *value)
internal_function;
extern int __libdwfl_crc32_file (int fd, uint32_t *resp) attribute_hidden;
+/* Meat of dwfl_report_elf, given elf_begin just called.
+ Consumes ELF on success, not on failure. */
+extern Dwfl_Module *__libdwfl_report_elf (Dwfl *dwfl, const char *name,
+ const char *file_name, int fd,
+ Elf *elf, GElf_Addr base)
+ internal_function;
+
+/* Meat of dwfl_report_offline. */
+extern Dwfl_Module *__libdwfl_report_offline (Dwfl *dwfl, const char *name,
+ const char *file_name,
+ int fd, bool closefd,
+ int (*predicate) (const char *,
+ const char *))
+ internal_function;
+
/* Avoid PLT entries. */
INTDECL (dwfl_begin)
/* Try to open the given file as it is or under the debuginfo directory. */
static int
-try_kernel_name (Dwfl *dwfl, char **fname)
+try_kernel_name (Dwfl *dwfl, char **fname, bool try_debug)
{
if (*fname == NULL)
return -1;
fd = INTUSE(dwfl_standard_find_debuginfo) (&fakemod, NULL, NULL, 0,
*fname, basename (*fname), 0,
&debugfname);
- if (fd < 0)
+ if (fd < 0 && try_debug)
/* Next, let the call use the default of basename + ".debug",
to look for "vmlinux.debug" files. */
fd = INTUSE(dwfl_standard_find_debuginfo) (&fakemod, NULL, NULL, 0,
: asprintf (fname, "/boot/vmlinux-%s", release)) < 0)
return -1;
- int fd = try_kernel_name (dwfl, fname);
+ int fd = try_kernel_name (dwfl, fname, true);
if (fd < 0 && release[0] != '/')
{
free (*fname);
if (asprintf (fname, MODULEDIRFMT "/vmlinux", release) < 0)
return -1;
- fd = try_kernel_name (dwfl, fname);
+ fd = try_kernel_name (dwfl, fname, true);
}
return fd;
}
static int
-report_kernel (Dwfl *dwfl, const char **release,
- int (*predicate) (const char *module, const char *file))
+get_release (Dwfl *dwfl, const char **release)
{
if (dwfl == NULL)
return -1;
*release = release_string;
}
+ return 0;
+}
+
+static int
+report_kernel (Dwfl *dwfl, const char **release,
+ int (*predicate) (const char *module, const char *file))
+{
+ int result = get_release (dwfl, release);
+ if (unlikely (result != 0))
+ return result;
+
char *fname;
- int fd = find_kernel_elf (dwfl, release_string, &fname);
+ int fd = find_kernel_elf (dwfl, *release, &fname);
- int result = 0;
if (fd < 0)
result = ((predicate != NULL && !(*predicate) (KERNEL_MODNAME, NULL))
? 0 : errno ?: ENOENT);
return result;
}
+/* Look for a kernel debug archive. If we find one, report all its modules.
+ If not, return ENOENT. */
+static int
+report_kernel_archive (Dwfl *dwfl, const char **release,
+ int (*predicate) (const char *module, const char *file))
+{
+ int result = get_release (dwfl, release);
+ if (unlikely (result != 0))
+ return result;
+
+ char *archive;
+ if (unlikely ((*release)[0] == '/'
+ ? asprintf (&archive, "%s/debug.a", *release)
+ : asprintf (&archive, MODULEDIRFMT "/debug.a", *release)) < 0)
+ return ENOMEM;
+
+ int fd = try_kernel_name (dwfl, &archive, false);
+ if (fd < 0)
+ result = errno ?: ENOENT;
+ else
+ /* We have the archive file open! */
+ result = __libdwfl_report_offline (dwfl, NULL, archive, fd, true,
+ predicate) == NULL ? -1 : 0;
+
+ free (archive);
+ return result;
+}
+
/* Report a kernel and all its modules found on disk, for offline use.
If RELEASE starts with '/', it names a directory to look in;
if not, it names a directory to find under /lib/modules/;
int (*predicate) (const char *module,
const char *file))
{
+ int result = report_kernel_archive (dwfl, &release, predicate);
+ if (result != ENOENT)
+ return result;
+
/* First report the kernel. */
- int result = report_kernel (dwfl, &release, predicate);
+ result = report_kernel (dwfl, &release, predicate);
if (result == 0)
{
/* Do "find /lib/modules/RELEASE -name *.ko". */
<http://www.openinventionnetwork.com>. */
#include "libdwflP.h"
+#include <fcntl.h>
#include <unistd.h>
/* Since dwfl_report_elf lays out the sections already, this will only be
called when the section headers of the debuginfo file are being
- consulted instead, or for a section located at zero. With binutils
- strip-to-debug, the symbol table is in the debuginfo file and relocation
- looks there. */
+ consulted instead. With binutils strip-to-debug, the symbol table is in
+ the debuginfo file and relocation looks there. */
int
dwfl_offline_section_address (Dwfl_Module *mod,
void **userdata __attribute__ ((unused)),
assert (shdr->sh_addr == 0);
assert (shdr->sh_flags & SHF_ALLOC);
- if (mod->symfile == &mod->main)
- {
- /* Because the actual address is zero, we failed to notice
- we in fact had the right address cached already. */
- *addr = 0;
- return 0;
- }
-
/* The section numbers might not match between the two files.
The best we can rely on is the order of SHF_ALLOC sections. */
- Elf_Scn *ourscn = elf_getscn (mod->symfile->elf, shndx);
+ Elf_Scn *ourscn = elf_getscn (mod->debug.elf, shndx);
Elf_Scn *scn = NULL;
uint_fast32_t skip_alloc = 0;
- while ((scn = elf_nextscn (mod->symfile->elf, scn)) != ourscn)
+ while ((scn = elf_nextscn (mod->debug.elf, scn)) != ourscn)
{
assert (scn != NULL);
GElf_Shdr shdr_mem;
while ((scn = elf_nextscn (mod->main.elf, scn)) != NULL)
{
GElf_Shdr shdr_mem;
- GElf_Shdr *main_shdr = gelf_getshdr (elf_getscn (mod->main.elf, shndx),
- &shdr_mem);
+ GElf_Shdr *main_shdr = gelf_getshdr (scn, &shdr_mem);
if (unlikely (main_shdr == NULL))
return -1;
if ((main_shdr->sh_flags & SHF_ALLOC) && skip_alloc-- == 0)
}
INTDEF (dwfl_offline_section_address)
-Dwfl_Module *
-dwfl_report_offline (Dwfl *dwfl, const char *name,
- const char *file_name, int fd)
+/* Forward declarations. */
+static Dwfl_Module *process_elf (Dwfl *dwfl, const char *name,
+ const char *file_name, int fd, Elf *elf);
+static Dwfl_Module *process_archive (Dwfl *dwfl, const char *name,
+ const char *file_name, int fd, Elf *elf,
+ int (*predicate) (const char *module,
+ const char *file));
+
+/* Report one module for an ELF file, or many for an archive. */
+static Dwfl_Module *
+process_file (Dwfl *dwfl, const char *name, const char *file_name, int fd,
+ Elf *elf, int (*predicate) (const char *module,
+ const char *file))
{
- if (dwfl == NULL)
- return NULL;
+ switch (elf_kind (elf))
+ {
+ default:
+ case ELF_K_NONE:
+ __libdwfl_seterrno (elf == NULL ? DWFL_E_LIBELF : DWFL_E_BADELF);
+ return NULL;
+
+ case ELF_K_ELF:
+ return process_elf (dwfl, name, file_name, fd, elf);
+
+ case ELF_K_AR:
+ return process_archive (dwfl, name, file_name, fd, elf, predicate);
+ }
+}
- Dwfl_Module *mod = INTUSE(dwfl_report_elf) (dwfl, name, file_name, fd,
- dwfl->offline_next_address);
+/* Report the open ELF file as a module. */
+static Dwfl_Module *
+process_elf (Dwfl *dwfl, const char *name, const char *file_name, int fd,
+ Elf *elf)
+{
+ Dwfl_Module *mod = __libdwfl_report_elf (dwfl, name, file_name, fd, elf,
+ dwfl->offline_next_address);
if (mod != NULL)
{
/* If this is an ET_EXEC file with fixed addresses, the address range
return mod;
}
+
+static bool
+process_archive_member (Dwfl *dwfl, const char *name, const char *file_name,
+ int (*predicate) (const char *module, const char *file),
+ Elf *member, Dwfl_Module **mod)
+{
+ const Elf_Arhdr *h = elf_getarhdr (member);
+ if (unlikely (h == NULL))
+ {
+ __libdwfl_seterrno (DWFL_E_LIBELF);
+ elf_end (member);
+ *mod = NULL;
+ return false;
+ }
+
+ if (!strcmp (h->ar_name, "/") || !strcmp (h->ar_name, "//"))
+ {
+ elf_end (member);
+ return true;
+ }
+
+ char *member_name;
+ if (unlikely (asprintf (&member_name, "%s(%s)", file_name, h->ar_name) < 0))
+ {
+ nomem:
+ __libdwfl_seterrno (DWFL_E_NOMEM);
+ elf_end (member);
+ *mod = NULL;
+ return false;
+ }
+
+ char *module_name = NULL;
+ if (name == NULL || name[0] == '\0')
+ name = h->ar_name;
+ else if (unlikely (asprintf (&module_name, "%s:%s", name, h->ar_name) < 0))
+ {
+ free (member_name);
+ goto nomem;
+ }
+ else
+ name = module_name;
+
+ if (predicate != NULL)
+ {
+ /* Let the predicate decide whether to use this one. */
+ int want = (*predicate) (name, member_name);
+ if (want <= 0)
+ {
+ free (member_name);
+ free (module_name);
+ if (unlikely (want < 0))
+ {
+ __libdwfl_seterrno (DWFL_E_CB);
+ elf_end (member);
+ *mod = NULL;
+ return false;
+ }
+ return true;
+ }
+ }
+
+ *mod = process_file (dwfl, name, member_name, -1, member, predicate);
+ free (member_name);
+ free (module_name);
+ return *mod != NULL;
+}
+
+/* Report each member of the archive as its own module. */
+static Dwfl_Module *
+process_archive (Dwfl *dwfl, const char *name, const char *file_name, int fd,
+ Elf *archive,
+ int (*predicate) (const char *module, const char *file))
+
+{
+ Dwfl_Module *mod = NULL;
+ bool more = true;
+ do
+ {
+ Elf *member = elf_begin (-1, ELF_C_READ_MMAP_PRIVATE, archive);
+ if (process_archive_member (dwfl, name, file_name, predicate,
+ member, &mod))
+ /* Advance the archive-reading offset for the next iteration. */
+ more = elf_next (member) != ELF_C_NULL;
+ else if (mod == NULL)
+ {
+ elf_end (member);
+ break;
+ }
+ }
+ while (more);
+ elf_end (archive);
+ if (likely (mod != NULL))
+ close (fd);
+ return mod;
+}
+
+Dwfl_Module *
+internal_function
+__libdwfl_report_offline (Dwfl *dwfl, const char *name,
+ const char *file_name, int fd, bool closefd,
+ int (*predicate) (const char *module,
+ const char *file))
+{
+ Elf *elf = elf_begin (fd, ELF_C_READ_MMAP_PRIVATE, NULL);
+ Dwfl_Module *mod = process_file (dwfl, name, file_name, fd, elf, predicate);
+ if (mod == NULL)
+ {
+ elf_end (elf);
+ if (closefd)
+ close (fd);
+ }
+ return mod;
+}
+
+Dwfl_Module *
+dwfl_report_offline (Dwfl *dwfl, const char *name,
+ const char *file_name, int fd)
+{
+ if (dwfl == NULL)
+ return NULL;
+
+ bool closefd = false;
+ if (fd < 0)
+ {
+ closefd = true;
+ fd = open64 (file_name, O_RDONLY);
+ if (fd < 0)
+ {
+ __libdwfl_seterrno (DWFL_E_ERRNO);
+ return NULL;
+ }
+ }
+
+ return __libdwfl_report_offline (dwfl, name, file_name, fd, closefd, NULL);
+}
INTDEF (dwfl_report_offline)
Dwfl_Error
internal_function
-__libdwfl_relocate_value (Dwfl_Module *mod, size_t symshstrndx,
+__libdwfl_relocate_value (Dwfl_Module *mod, Elf *elf, size_t *shstrndx,
Elf32_Word shndx, GElf_Addr *value)
{
- Elf_Scn *refscn = elf_getscn (mod->symfile->elf, shndx);
+ Elf_Scn *refscn = elf_getscn (elf, shndx);
GElf_Shdr refshdr_mem, *refshdr = gelf_getshdr (refscn, &refshdr_mem);
if (refshdr == NULL)
return DWFL_E_LIBELF;
- if ((refshdr->sh_flags & SHF_ALLOC) && refshdr->sh_addr == 0)
+ if (refshdr->sh_addr == 0
+ && (refshdr->sh_flags & SHF_ALLOC)
+ && refshdr->sh_offset != 0)
{
/* This is a loaded section. Find its actual
address and update the section header. */
- const char *name = elf_strptr (mod->symfile->elf, symshstrndx,
- refshdr->sh_name);
- if (name == NULL)
+
+ if (*shstrndx == SHN_UNDEF
+ && unlikely (elf_getshstrndx (elf, shstrndx) < 0))
+ return DWFL_E_LIBELF;
+
+ const char *name = elf_strptr (elf, *shstrndx, refshdr->sh_name);
+ if (unlikely (name == NULL))
return DWFL_E_LIBELF;
if ((*mod->dwfl->callbacks->section_address) (MODCB_ARGS (mod),
return CBFAIL;
if (refshdr->sh_addr == (Dwarf_Addr) -1l)
- {
- /* The callback indicated this section wasn't really loaded but we
- don't really care. Mark it so we don't check it again for the
- next relocation. */
- refshdr->sh_flags &= ~SHF_ALLOC;
- refshdr->sh_addr = 0; /* Make no adjustment below. */
- }
+ /* The callback indicated this section wasn't really loaded but we
+ don't really care. */
+ refshdr->sh_addr = 0; /* Make no adjustment below. */
+
+ /* Mark it so we don't check it again for the next relocation. */
+ refshdr->sh_offset = 0;
/* Update the in-core file's section header to show the final
load address (or unloadedness). This serves as a cache,
so we won't get here again for the same section. */
- if (! gelf_update_shdr (refscn, refshdr))
+ if (unlikely (! gelf_update_shdr (refscn, refshdr)))
return DWFL_E_LIBELF;
}
return DWFL_E_NOERROR;
}
+/* This is just doing dwfl_module_getsym, except that we must always use
+ the symbol table in RELOCATED itself when it has one, not MOD->symfile. */
+static Dwfl_Error
+relocate_getsym (Elf **symelf, Elf_Data **symdata, Elf_Data **symxndxdata,
+ size_t *symshstrndx,
+ Dwfl_Module *mod, Elf *relocated,
+ int symndx, GElf_Sym *sym, GElf_Word *shndx)
+{
+ if (*symdata == NULL)
+ {
+ if (mod->symfile->elf != relocated)
+ {
+ /* We have to look up the symbol table in the file we are
+ relocating, if it has its own. These reloc sections refer to
+ the symbol table in this file, and a symbol table in the main
+ file might not match. However, some tools did produce ET_REL
+ .debug files with relocs but no symtab of their own. */
+ Elf_Scn *scn = NULL;
+ while ((scn = elf_nextscn (relocated, scn)) != NULL)
+ {
+ GElf_Shdr shdr_mem, *shdr = gelf_getshdr (scn, &shdr_mem);
+ if (shdr != NULL)
+ switch (shdr->sh_type)
+ {
+ default:
+ continue;
+ case SHT_SYMTAB:
+ *symelf = relocated;
+ *symdata = elf_getdata (scn, NULL);
+ if (unlikely (*symdata == NULL))
+ return DWFL_E_LIBELF;
+ break;
+ case SHT_SYMTAB_SHNDX:
+ *symxndxdata = elf_getdata (scn, NULL);
+ if (unlikely (*symxndxdata == NULL))
+ return DWFL_E_LIBELF;
+ break;
+ }
+ if (*symdata != NULL && *symxndxdata != NULL)
+ break;
+ }
+ }
+ if (*symdata == NULL)
+ {
+ /* The symbol table we have already cached is the one from
+ the file being relocated, so it's what we need. Or else
+ this is an ET_REL .debug file with no .symtab of its own;
+ the symbols refer to the section indices in the main file. */
+ *symelf = mod->symfile->elf;
+ *symdata = mod->symdata;
+ *symxndxdata = mod->symxndxdata;
+ }
+ }
+
+ if (unlikely (gelf_getsymshndx (*symdata, *symxndxdata,
+ symndx, sym, shndx) == NULL))
+ return DWFL_E_LIBELF;
+
+ if (sym->st_shndx != SHN_XINDEX)
+ *shndx = sym->st_shndx;
+
+ switch (*shndx)
+ {
+ case SHN_ABS:
+ case SHN_UNDEF:
+ case SHN_COMMON:
+ return DWFL_E_NOERROR;
+ }
+
+ return __libdwfl_relocate_value (mod, *symelf, symshstrndx,
+ *shndx, &sym->st_value);
+}
+
Dwfl_Error
internal_function
__libdwfl_relocate (Dwfl_Module *mod, Elf *debugfile)
if (ehdr == NULL)
return DWFL_E_LIBELF;
- size_t symshstrndx, d_shstrndx;
- if (elf_getshstrndx (mod->symfile->elf, &symshstrndx) < 0)
+ /* Cache used by relocate_getsym. */
+ Elf *reloc_symelf = NULL;
+ Elf_Data *reloc_symdata = NULL;
+ Elf_Data *reloc_symxndxdata = NULL;
+ size_t reloc_symshstrndx = SHN_UNDEF;
+
+ size_t d_shstrndx;
+ if (elf_getshstrndx (debugfile, &d_shstrndx) < 0)
return DWFL_E_LIBELF;
if (mod->symfile->elf == debugfile)
- d_shstrndx = symshstrndx;
- else if (elf_getshstrndx (debugfile, &d_shstrndx) < 0)
- return DWFL_E_LIBELF;
+ reloc_symshstrndx = d_shstrndx;
/* Look at each section in the debuginfo file, and process the
relocation sections for debugging sections. */
GElf_Shdr shdr_mem;
GElf_Shdr *shdr = gelf_getshdr (scn, &shdr_mem);
- if (shdr->sh_type == SHT_REL || shdr->sh_type == SHT_RELA)
+ if ((shdr->sh_type == SHT_REL || shdr->sh_type == SHT_RELA)
+ && shdr->sh_size != 0)
{
/* It's a relocation section. First, fetch the name of the
section these relocations apply to. */
{
GElf_Sym sym;
GElf_Word shndx;
-
- if (INTUSE(dwfl_module_getsym) (mod, symndx,
- &sym, &shndx) == NULL)
- return dwfl_errno ();
+ Dwfl_Error error = relocate_getsym (&reloc_symelf,
+ &reloc_symdata,
+ &reloc_symxndxdata,
+ &reloc_symshstrndx,
+ mod, debugfile,
+ symndx, &sym, &shndx);
+ if (unlikely (error != DWFL_E_NOERROR))
+ return error;
if (shndx == SHN_UNDEF || shndx == SHN_COMMON)
return DWFL_E_RELUNDEF;
}
if (result != DWFL_E_NOERROR)
break;
+
+ /* Mark this relocation section as being empty now that we have
+ done its work. This affects unstrip -R, so e.g. it emits an
+ empty .rela.debug_info along with a .debug_info that has
+ already been fully relocated. */
+ shdr->sh_size = 0;
+ reldata->d_size = 0;
+ gelf_update_shdr (scn, shdr);
}
}
+2007-10-11 Roland McGrath <roland@redhat.com>
+
+ * eblobjnote.c (ebl_object_note): Translate target format (byte-swap)
+ for NT_GNU_ABI_TAG contents.
+
2007-08-22 Roland McGrath <roland@redhat.com>
* libebl.h (Ebl_Core_Item): New member `group'.
}
break;
- case NT_VERSION:
- if (strcmp (name, "GNU") == 0 && descsz >= 8)
+ case NT_GNU_ABI_TAG:
+ if (strcmp (name, "GNU") == 0 && descsz >= 8 && descsz % 4 == 0)
{
- struct
- {
- uint32_t os;
- uint32_t version[descsz / 4 - 1];
- } *tag = (__typeof (tag)) desc;
-
- const char *os;
- switch (tag->os)
+ Elf_Data in =
{
- case ELF_NOTE_OS_LINUX:
- os = "Linux";
- break;
-
- case ELF_NOTE_OS_GNU:
- os = "GNU";
- break;
-
- case ELF_NOTE_OS_SOLARIS2:
- os = "Solaris";
- break;
-
- case ELF_NOTE_OS_FREEBSD:
- os = "FreeBSD";
- break;
-
- default:
- os = "???";
- break;
- }
+ .d_version = EV_CURRENT,
+ .d_type = ELF_T_WORD,
+ .d_size = descsz,
+ .d_buf = (void *) desc
+ };
+ uint32_t buf[descsz / 4];
+ Elf_Data out =
+ {
+ .d_version = EV_CURRENT,
+ .d_type = ELF_T_WORD,
+ .d_size = descsz,
+ .d_buf = buf
+ };
- printf (gettext (" OS: %s, ABI: "), os);
- size_t cnt;
- for (cnt = 0; cnt < descsz / 4 - 1; ++cnt)
+ if (elf32_xlatetom (&out, &in, ebl->data) != NULL)
{
- if (cnt != 0)
- putchar_unlocked ('.');
- printf ("%" PRIu32, tag->version[cnt]);
+ const char *os;
+ switch (buf[0])
+ {
+ case ELF_NOTE_OS_LINUX:
+ os = "Linux";
+ break;
+
+ case ELF_NOTE_OS_GNU:
+ os = "GNU";
+ break;
+
+ case ELF_NOTE_OS_SOLARIS2:
+ os = "Solaris";
+ break;
+
+ case ELF_NOTE_OS_FREEBSD:
+ os = "FreeBSD";
+ break;
+
+ default:
+ os = "???";
+ break;
+ }
+
+ printf (gettext (" OS: %s, ABI: "), os);
+ for (size_t cnt = 1; cnt < descsz / 4; ++cnt)
+ {
+ if (cnt > 1)
+ putchar_unlocked ('.');
+ printf ("%" PRIu32, buf[cnt]);
+ }
+ putchar_unlocked ('\n');
}
- putchar_unlocked ('\n');
break;
}
/* FALLTHROUGH */
+2007-10-07 Roland McGrath <roland@redhat.com>
+
+ * elf_begin.c (__libelf_next_arhdr): Fix fencepost error and wrong
+ member access in terminating name with no trailing /. Trim trailing
+ spaces when there is no /.
+
2007-10-04 Roland McGrath <roland@redhat.com>
* elf_end.c (elf_end): Don't free ELF->state.ar.ar_sym when it's -1l.
if (endp != NULL)
endp[-1] = '\0';
else
- elf->state.ar.raw_name[16] = '\0';
+ {
+ /* In the old BSD style of archive, there is no / terminator.
+ Instead, there is space padding at the end of the name. */
+ size_t i = 15;
+ do
+ elf->state.ar.ar_name[i] = '\0';
+ while (i > 0 && elf->state.ar.ar_name[--i] == ' ');
+ }
elf_ar_hdr->ar_name = elf->state.ar.ar_name;
}
+2007-10-15 Roland McGrath <roland@redhat.com>
+
+ * make-debug-archive.in: New file.
+ * Makefile.am (EXTRA_DIST): Add it.
+ (make-debug-archive): New target.
+ (bin_SCRIPTS, CLEANFILES): Add it.
+
+2007-10-10 Roland McGrath <roland@redhat.com>
+
+ * elflint.c (special_sections): Add new attrflag value exact_or_gnuld.
+ Use it to check MERGE|STRINGS for .debug_str.
+ (check_sections): Handle exact_or_gnuld.
+
+2007-10-08 Roland McGrath <roland@redhat.com>
+
+ * readelf.c (handle_core_item): Handle 'T'|0x80 to indicate
+ 64-bit struct timeval with 32-bit tv_usec.
+
+2007-10-07 Roland McGrath <roland@redhat.com>
+
+ * readelf.c (check_archive_index): New function.
+ (process_file): Call it. Change signature to take only fd and name.
+ Use libdwfl to open the file, then iterate on its modules (multiple
+ for an archive) to print file name and call process_elf_file.
+ (main): Update caller. Let process_file do elf_begin.
+ (count_dwflmod, process_dwflmod, find_no_debuginfo): New functions.
+ (process_elf_file): Take only Dwfl_Module * argument.
+ Don't print the file name here.
+ (print_debug_*_section): Take Dwfl_Module * argument.
+ (print_debug): Likewise. Update caller.
+ (format_dwarf_addr): New function.
+ (print_debug_ranges_section): Use it.
+ (attr_callback): Likewise.
+ (print_debug_line_section, print_debug_loc_section): Likewise.
+
+ * readelf.c (print_debug_ranges_section): Translate all strings.
+ (print_debug_loc_section): Likewise.
+
+ * unstrip.c (copy_elided_sections): Initialize SEC.
+
+ * ar.c (do_oper_insert): Put trailing / on short names.
+
+ * arlib.h (MAX_AR_NAME_LEN): Decrease by one.
+
+ * arlib2.c (arlib_add_long_name): Adjust for header size.
+
+ * arlib.c (arlib_finalize): Pad long name table to keep size even.
+
+ * ar.c (do_oper_insert): Use write_retry for padding write.
+
+ * ar.c (do_oper_insert): Initialize CUR_OFF in no_old case.
+ Unconditionally set FOUND[CNT]->elf when setting ->mem.
+ (remember_long_name): New function.
+ (do_oper_insert): Call it. Correctly use length of basename,
+ not original name. Don't store long name twice for new member.
+
+2007-10-06 Roland McGrath <roland@redhat.com>
+
+ * elflint.c (check_note): Skip empty segment.
+ (check_note_section): Skip empty section.
+
+ * unstrip.c (options, parse_opt, struct arg_info): Grok -R/--relocate.
+ (handle_output_dir_module, handle_implicit_modules): Pass it down.
+ (handle_dwfl_module): When set, use ET_REL already loaded by Dwfl.
+ (compare_alloc_sections): Take new arg REL, ignore address if true.
+ (compare_sections): Likewise, pass it down.
+ (compare_sections_rel, compare_sections_nonrel): New functions.
+ (find_alloc_sections_prelink, copy_elided_sections): Use them
+ instead of compare_sections.
+ (sections_match): New function, broken out of ...
+ (find_alloc_section): ... here.
+ (copy_elided_sections): Reorganize section match-up logic.
+ Use sections_match for SHF_ALLOC in ET_REL.
+ For ET_REL, let the nonzero sh_addr from the debug file dominate.
+
+ * unstrip.c (add_new_section_symbols): Take new arg REL.
+ When true, do not update section symbol values.
+ (collect_symbols): Likewise. Update section symbols with address
+ of chosen output section, not original section.
+ (check_symtab_section_symbols, copy_elided_sections): Update callers.
+
+ * unstrip.c (compare_alloc_sections): At the same address, preserve
+ original section order.
+
+ * elflint.c (special_sections): Don't require MERGE|STRINGS for
+ .debug_str, it didn't always have them with older tools.
+
+ * elflint.c (check_symtab, check_one_reloc): Ignore sh_addr in ET_REL.
+
+2007-10-05 Roland McGrath <roland@redhat.com>
+
+ * elflint.c (check_symtab): Allow SHN_UNDEF _GLOBAL_OFFSET_TABLE_ in
+ ET_REL file.
+
+ * elflint.c (check_symtab): For _GLOBAL_OFFSET_TABLE_, diagnose
+ SHN_UNDEF as "bad section". Use shndx value in messages.
+
+ * elflint.c (special_sections): Add ".debug_str". Decrement namelen
+ for ".debug" so it matches as a prefix.
+ (IS_KNOWN_SPECIAL): New macro.
+ (check_sections): Use it for ".plt" match. Cite wrong SHT_NOBITS
+ type even under -d, for a .debug* or .shstrtab section.
+
+ * readelf.c (print_ops): Use hex for address operand.
+
+2007-10-04 Roland McGrath <roland@redhat.com>
+
+ * unstrip.c (copy_elided_sections): Initialize NDX_SECTION element for
+ .gnu_debuglink section to SHN_UNDEF. Drop STT_SECTION symbols for
+ sections mapped to SHN_UNDEF.
+
2007-10-04 Ulrich Drepper <drepper@redhat.com>
* readelf.c (dump_archive_index): Avoid warning about uninitialized
EXTRA_DIST = elf32-i386.script libld_elf_i386.map $(ld_modules) arlib.h
ld_modules = i386_ld.c
+bin_SCRIPTS = make-debug-archive
+EXTRA_DIST += make-debug-archive.in
+CLEANFILES = make-debug-archive
+
if MUDFLAP
libmudflap = -lmudflap
endif
done; \
done; rm -f c$${pid}_.???; exit $$bad
-CLEANFILES = none_ld.os $(ld_modules:.c=.os) *.gcno *.gcda *.gconv
+CLEANFILES += none_ld.os $(ld_modules:.c=.os) *.gcno *.gcda *.gconv
MAINTAINERCLEANFILES = ldlex.c ldscript.c ldscript.h
+
+
+make-debug-archive: $(srcdir)/make-debug-archive.in
+ UNSTRIP=$(bindir)/`echo unstrip | sed '$(transform)'`; \
+ AR=$(bindir)/`echo ar | sed '$(transform)'`; \
+ sed -e "s,@UNSTRIP@,$$UNSTRIP,g" -e "s,@AR@,$$AR,g" \
+ -e "s%[@]PACKAGE_NAME[@]%$(PACKAGE_NAME)%g" \
+ -e "s%[@]PACKAGE_VERSION[@]%$(PACKAGE_VERSION)%g" \
+ $(srcdir)/make-debug-archive.in > $@.new
+ chmod +x $@.new
+ mv -f $@.new $@
return 0;
}
+/* Store the name in the long name table if necessary.
+ Record its offset or -1 if we did not need to use the table. */
+static void
+remember_long_name (struct armem *mem, const char *name, size_t namelen)
+{
+ mem->long_name_off = (namelen > MAX_AR_NAME_LEN
+ ? arlib_add_long_name (name, namelen)
+ : -1l);
+}
static int
do_oper_delete (const char *arfname, char **argv, int argc,
arlib_add_symbols (subelf, arfname, arhdr->ar_name, newp->off);
/* Remember long file names. */
- size_t ar_namelen = strlen (arhdr->ar_name);
- if (ar_namelen > MAX_AR_NAME_LEN)
- newp->long_name_off = arlib_add_long_name (arhdr->ar_name,
- ar_namelen);
- else
- newp->long_name_off = -1l;
+ remember_long_name (newp, arhdr->ar_name, strlen (arhdr->ar_name));
}
next:
arlib_init ();
+ /* Initialize early for no_old case. */
+ off_t cur_off = SARMAG;
+
if (fd == -1)
{
if (!suppress_create_msg)
/* While iterating over the current content of the archive we must
determine a number of things: which archive members to keep,
which are replaced, and where to insert the new members. */
- off_t cur_off = SARMAG;
Elf_Cmd cmd = ELF_C_READ_MMAP;
Elf *subelf;
while ((subelf = elf_begin (fd, cmd, elf)) != NULL)
newp->mem = NULL;
/* Remember long file names. */
- size_t ar_namelen = strlen (arhdr->ar_name);
- if (ar_namelen > MAX_AR_NAME_LEN)
- newp->long_name_off = arlib_add_long_name (arhdr->ar_name, ar_namelen);
- else
- newp->long_name_off = -1l;
+ remember_long_name (newp, arhdr->ar_name, strlen (arhdr->ar_name));
/* Check whether this is a file we are looking for. */
if (oper != oper_qappend)
for (int cnt = 0; cnt < argc; ++cnt)
{
const char *bname = basename (argv[cnt]);
+ size_t bnamelen = strlen (bname);
if (found[cnt] == NULL)
{
found[cnt] = alloca (sizeof (struct armem));
found[cnt]->old_off = -1;
- size_t ar_namelen = strlen (argv[cnt]);
- if (ar_namelen > MAX_AR_NAME_LEN)
- found[cnt]->long_name_off = arlib_add_long_name (bname,
- ar_namelen);
- else
- found[cnt]->long_name_off = -1l;
+ remember_long_name (found[cnt], bname, bnamelen);
}
struct stat newst;
printf ("%c - %s\n",
found[cnt]->old_off == -1l ? 'a' : 'r', argv[cnt]);
-#ifdef DEBUG
found[cnt]->elf = newelf;
-#endif
found[cnt]->sec = newst.st_mtime;
found[cnt]->uid = newst.st_uid;
found[cnt]->gid = newst.st_gid;
found[cnt]->mode = newst.st_mode;
- found[cnt]->name = basename (argv[cnt]);
+ found[cnt]->name = bname;
found[cnt]->mem = elf_rawfile (newelf, &found[cnt]->size);
if (found[cnt] == NULL || elf_cntl (newelf, ELF_C_FDDONE) != 0)
close (newfd);
- /* Remember long file names. */
- size_t bnamelen = strlen (bname);
- if (bnamelen > MAX_AR_NAME_LEN)
- found[cnt]->long_name_off = arlib_add_long_name (bname,
- bnamelen);
- else
- found[cnt]->long_name_off = -1l;
+ if (found[cnt]->old_off != -1l)
+ /* Remember long file names. */
+ remember_long_name (found[cnt], bname, bnamelen);
}
}
}
if (all->long_name_off == -1)
{
size_t namelen = strlen (all->name);
- memset (mempcpy (arhdr.ar_name, all->name, namelen),
- ' ', sizeof (arhdr.ar_name) - namelen);
+ char *p = mempcpy (arhdr.ar_name, all->name, namelen);
+ *p++ = '/';
+ memset (p, ' ', sizeof (arhdr.ar_name) - namelen - 1);
}
else
{
/* Pad the file if its size is odd. */
if ((all->size & 1) != 0)
- if (write (newfd, "\n", 1) != 1)
+ if (unlikely (write_retry (newfd, "\n", 1) != 1))
goto nonew_unlink;
}
else
symtab.longnameslen = obstack_object_size (&symtab.longnamesob);
if (symtab.longnameslen != sizeof (struct ar_hdr))
{
+ if ((symtab.longnameslen & 1) != 0)
+ {
+ /* Add one more byte to make length even. */
+ obstack_grow (&symtab.longnamesob, "\n", 1);
+ ++symtab.longnameslen;
+ }
+
symtab.longnames = obstack_finish (&symtab.longnamesob);
memcpy (&((struct ar_hdr *) symtab.longnames)->ar_size, tmpbuf,
#include <sys/types.h>
-/* Maximum length of a file name that fits directly into the ar header. */
-#define MAX_AR_NAME_LEN (sizeof (((struct ar_hdr *) NULL)->ar_name))
+/* Maximum length of a file name that fits directly into the ar header.
+ We cannot use the final byte since a / goes there. */
+#define MAX_AR_NAME_LEN (sizeof (((struct ar_hdr *) NULL)->ar_name) - 1)
/* Words matching in size to archive header. */
long int
arlib_add_long_name (const char *filename, size_t filenamelen)
{
- int retval = obstack_object_size (&symtab.longnamesob);
+ size_t size = obstack_object_size (&symtab.longnamesob);
obstack_grow (&symtab.longnamesob, filename, filenamelen);
obstack_grow (&symtab.longnamesob, "/\n", 2);
- return retval;
+ return size - sizeof (struct ar_hdr);
}
destshdr = gelf_getshdr (elf_getscn (ebl->elf, xndx), &destshdr_mem);
if (destshdr != NULL)
{
+ GElf_Addr sh_addr = (ehdr->e_type == ET_REL ? 0
+ : destshdr->sh_addr);
if (GELF_ST_TYPE (sym->st_info) != STT_TLS)
{
if (! ebl_check_special_symbol (ebl, ehdr, sym, name,
destshdr))
{
- if ((sym->st_value - destshdr->sh_addr)
- > destshdr->sh_size)
+ if (sym->st_value - sh_addr > destshdr->sh_size)
{
/* GNU ld has severe bugs. When it decides to remove
empty sections it leaves symbols referencing them
section [%2d] '%s': symbol %zu: st_value out of bounds\n"),
idx, section_name (ebl, idx), cnt);
}
- else if ((sym->st_value - destshdr->sh_addr
+ else if ((sym->st_value - sh_addr
+ sym->st_size) > destshdr->sh_size)
ERROR (gettext ("\
section [%2d] '%s': symbol %zu does not fit completely in referenced section [%2d] '%s'\n"),
destshdr = gelf_getshdr (gotscn, &destshdr_mem);
}
- const char *sname = (destshdr == NULL ? NULL
+ const char *sname = ((destshdr == NULL || xndx == SHN_UNDEF)
+ ? NULL
: elf_strptr (ebl->elf, ehdr->e_shstrndx,
destshdr->sh_name));
if (sname == NULL)
- ERROR (gettext ("\
-section [%2d] '%s': _GLOBAL_OFFSET_TABLE_ symbol refers to bad section\n"),
- idx, section_name (ebl, idx));
+ {
+ if (xndx != SHN_UNDEF || ehdr->e_type != ET_REL)
+ ERROR (gettext ("\
+section [%2d] '%s': _GLOBAL_OFFSET_TABLE_ symbol refers to \
+bad section [%2d]\n"),
+ idx, section_name (ebl, idx), xndx);
+ }
else if (strcmp (sname, ".got.plt") != 0
&& strcmp (sname, ".got") != 0)
ERROR (gettext ("\
-section [%2d] '%s': _GLOBAL_OFFSET_TABLE_ symbol refers to '%s' section\n"),
- idx, section_name (ebl, idx), sname);
+section [%2d] '%s': _GLOBAL_OFFSET_TABLE_ symbol refers to \
+section [%2d] '%s'\n"),
+ idx, section_name (ebl, idx), xndx, sname);
if (destshdr != NULL)
{
if (!ebl_check_special_symbol (ebl, ehdr, sym, name,
destshdr))
{
- if (sym->st_value != destshdr->sh_addr)
+ if (ehdr->e_type != ET_REL
+ && sym->st_value != destshdr->sh_addr)
/* This test is more strict than the psABIs which
usually allow the symbol to be in the middle of
the .got section, allowing negative offsets. */
{
if (destshdr != NULL
&& GELF_R_TYPE (r_info) != 0
- && (r_offset - destshdr->sh_addr) >= destshdr->sh_size)
+ && (r_offset - (ehdr->e_type == ET_REL ? 0
+ : destshdr->sh_addr)) >= destshdr->sh_size)
ERROR (gettext ("\
section [%2d] '%s': relocation %zu: offset out of bounds\n"),
idx, section_name (ebl, idx), cnt);
const char *name;
size_t namelen;
GElf_Word type;
- enum { unused, exact, atleast } attrflag;
+ enum { unused, exact, atleast, exact_or_gnuld } attrflag;
GElf_Word attr;
GElf_Word attr2;
} special_sections[] =
{ ".comment", 8, SHT_PROGBITS, exact, 0, 0 },
{ ".data", 6, SHT_PROGBITS, exact, SHF_ALLOC | SHF_WRITE, 0 },
{ ".data1", 7, SHT_PROGBITS, exact, SHF_ALLOC | SHF_WRITE, 0 },
- { ".debug", 7, SHT_PROGBITS, exact, 0, 0 },
+ { ".debug_str", 11, SHT_PROGBITS, exact_or_gnuld, SHF_MERGE | SHF_STRINGS, 0 },
+ { ".debug", 6, SHT_PROGBITS, exact, 0, 0 },
{ ".dynamic", 9, SHT_DYNAMIC, atleast, SHF_ALLOC, SHF_WRITE },
{ ".dynstr", 8, SHT_STRTAB, exact, SHF_ALLOC, 0 },
{ ".dynsym", 8, SHT_DYNSYM, exact, SHF_ALLOC, 0 },
#define nspecial_sections \
(sizeof (special_sections) / sizeof (special_sections[0]))
+#define IS_KNOWN_SPECIAL(idx, string, prefix) \
+ (special_sections[idx].namelen == sizeof string - (prefix ? 1 : 0) \
+ && !memcmp (special_sections[idx].name, string, \
+ sizeof string - (prefix ? 1 : 0)))
static void
check_sections (Ebl *ebl, GElf_Ehdr *ehdr)
char stbuf3[100];
GElf_Word good_type = special_sections[s].type;
- if (special_sections[s].namelen == sizeof ".plt" &&
- !memcmp (special_sections[s].name, ".plt", sizeof ".plt")
+ if (IS_KNOWN_SPECIAL (s, ".plt", false)
&& ebl_bss_plt_p (ebl, ehdr))
good_type = SHT_NOBITS;
+ /* In a debuginfo file, any normal section can be SHT_NOBITS.
+ This is only invalid for DWARF sections and .shstrtab. */
if (shdr->sh_type != good_type
- && !(is_debuginfo && shdr->sh_type == SHT_NOBITS))
+ && (shdr->sh_type != SHT_NOBITS
+ || !is_debuginfo
+ || IS_KNOWN_SPECIAL (s, ".debug_str", false)
+ || IS_KNOWN_SPECIAL (s, ".debug", true)
+ || IS_KNOWN_SPECIAL (s, ".shstrtab", false)))
ERROR (gettext ("\
section [%2d] '%s' has wrong type: expected %s, is %s\n"),
(int) cnt, scnname,
ebl_section_type_name (ebl, shdr->sh_type,
stbuf2, sizeof (stbuf2)));
- if (special_sections[s].attrflag == exact)
+ if (special_sections[s].attrflag == exact
+ || special_sections[s].attrflag == exact_or_gnuld)
{
/* Except for the link order and group bit all the
other bits should match exactly. */
if ((shdr->sh_flags & ~(SHF_LINK_ORDER | SHF_GROUP))
- != special_sections[s].attr)
+ != special_sections[s].attr
+ && (special_sections[s].attrflag == exact || !gnuld))
ERROR (gettext ("\
section [%2zu] '%s' has wrong flags: expected %s, is %s\n"),
cnt, scnname,
/* The p_offset values in a separate debug file are bogus. */
return;
+ if (phdr->p_filesz == 0)
+ return;
+
GElf_Off notes_size = 0;
Elf_Data *data = elf_getdata_rawchunk (ebl->elf,
phdr->p_offset, phdr->p_filesz,
static void
check_note_section (Ebl *ebl, GElf_Ehdr *ehdr, GElf_Shdr *shdr, int idx)
{
+ if (shdr->sh_size == 0)
+ return;
+
Elf_Data *data = elf_getdata (elf_getscn (ebl->elf, idx), NULL);
if (data == NULL)
{
--- /dev/null
+#!/bin/sh
+#
+# Script to make an offline archive for debugging with libdwfl-based tools.
+#
+# make-debug-archive ARCHIVE {options}
+# make-debug-archive --kernel [--force] [RELEASE]
+#
+# Valid options are those listed under 'Input selection options'
+# by running @UNSTRIP@ --help.
+#
+# The archive installed by --kernel be used automatically by -K.
+# An offline archive can be used via -e in any tool that accepts those options.
+#
+
+UNSTRIP=${UNSTRIP:-@UNSTRIP@}
+AR=${AR:-@AR@}
+SUDO=${SUDO:-/usr/bin/sudo}
+
+LS=/bin/ls
+RM=/bin/rm
+MV=/bin/mv
+MKDIR=/bin/mkdir
+XARGS=/usr/bin/xargs
+
+outdir=${TMPDIR:-/tmp}/debugar$$
+
+usage()
+{
+ echo "Usage: $0 ARCHIVE {options}"
+ echo " or: $0 --kernel [--sudo] [--force] [RELEASE]"
+ echo
+ echo "Valid options are listed under 'Input selection options'"
+ echo "when running: $UNSTRIP --help"
+ echo
+ echo "The --kernel form updates the file used by -K if the"
+ echo "kernel installation has changed, or always with --force."
+ echo "With --sudo, touches the installed file via $SUDO."
+}
+
+fatal_usage()
+{
+ usage >&2
+ exit 2
+}
+
+script_version()
+{
+ echo "`basename $0` (@PACKAGE_NAME@) @PACKAGE_VERSION@"
+ echo "Copyright (C) 2007 Red Hat, Inc."
+ echo "This is free software; see the source for copying conditions."
+ echo "There is NO warranty; not even for MERCHANTABILITY or"
+ echo "FITNESS FOR A PARTICULAR PURPOSE."
+ echo "Written by Roland McGrath."
+}
+
+sudo=
+kernel=no
+force_kernel=no
+while [ $# -gt 0 ]; do
+ case "x$1" in
+ x--help) usage; exit 0 ;;
+ x--version) script_version; exit 0 ;;
+ x--kernel) kernel=yes ;;
+ x--force) force_kernel=yes ;;
+ x--sudo) sudo=$SUDO ;;
+ *) break ;;
+ esac
+ shift
+done
+
+if [ $kernel = no ] && [ $force_kernel = yes -o -n "$sudo" ]; then
+ usage
+fi
+
+if [ $kernel = yes ]; then
+ if [ $# -eq 0 ]; then
+ release=`uname -r`
+ elif [ $# -eq 1 ]; then
+ release=$1
+ else
+ fatal_usage
+ fi
+
+ dir=/usr/lib/debug/lib/modules/$release
+ archive=$dir/debug.a
+ dep=/lib/modules/$release/modules.dep
+
+ if [ ! -d $dir ]; then
+ echo >&2 "$0: $dir not installed"
+ exit 1
+ fi
+
+ # Without --force, bail if the kernel installation is not newer.
+ # This file is normally touched by installing new kernels or modules.
+ if [ $force_kernel = no -a "$archive" -nt "$dep" ]; then
+ exit 0
+ fi
+
+ # We have to kill the old one first, because our own -K would use it.
+ [ ! -e "$archive" ] || $sudo $RM -f "$archive" || exit
+
+ set "$archive" "-K$release"
+fi
+
+if [ $# -lt 2 ]; then
+ fatal_usage
+fi
+
+archive="$1"
+shift
+
+case "$archive" in
+/*) ;;
+*) archive="`/bin/pwd`/$archive" ;;
+esac
+
+if [ -z "$sudo" ]; then
+ new_archive="$archive.new"
+else
+ new_archive="$outdir.a"
+fi
+
+$RM -f "$new_archive" || exit
+
+trap '$RM -rf "$outdir" "$new_archive"' 0 1 2 15
+
+$MKDIR "$outdir" &&
+$UNSTRIP -d "$outdir" -m -a -R "$@" &&
+(cd "$outdir" && $LS | $XARGS $AR cq "$new_archive") &&
+$sudo $MV -f "$new_archive" "$archive"
+
+exit
#include <inttypes.h>
#include <langinfo.h>
#include <libdw.h>
+#include <libdwfl.h>
#include <libintl.h>
#include <locale.h>
#include <stdarg.h>
/* Declarations of local functions. */
-static void process_file (int fd, Elf *elf, const char *prefix,
- const char *fname, bool only_one,
- bool will_print_archive_index);
-static void process_elf_file (Elf *elf, const char *prefix, const char *fname,
- bool only_one);
+static void process_file (int fd, const char *fname, bool only_one);
+static void process_elf_file (Dwfl_Module *dwflmod);
static void print_ehdr (Ebl *ebl, GElf_Ehdr *ehdr);
static void print_shdr (Ebl *ebl, GElf_Ehdr *ehdr);
static void print_phdr (Ebl *ebl, GElf_Ehdr *ehdr);
static void handle_verdef (Ebl *ebl, Elf_Scn *scn, GElf_Shdr *shdr);
static void handle_versym (Ebl *ebl, Elf_Scn *scn,
GElf_Shdr *shdr);
-static void print_debug (Ebl *ebl, GElf_Ehdr *ehdr);
+static void print_debug (Dwfl_Module *dwflmod, Ebl *ebl, GElf_Ehdr *ehdr);
static void handle_hash (Ebl *ebl);
static void handle_notes (Ebl *ebl, GElf_Ehdr *ehdr);
static void print_liblist (Ebl *ebl);
continue;
}
- /* Create an `Elf' descriptor. */
- Elf *elf = elf_begin (fd, ELF_C_READ_MMAP, NULL);
- if (elf == NULL)
- error (0, 0, gettext ("cannot generate Elf descriptor: %s\n"),
- elf_errmsg (-1));
- else
- {
- process_file (fd, elf, NULL, argv[remaining], only_one,
- print_archive_index);
-
- /* Now we can close the descriptor. */
- if (elf_end (elf) != 0)
- error (0, 0, gettext ("error while closing Elf descriptor: %s"),
- elf_errmsg (-1));
- }
+ process_file (fd, argv[remaining], only_one);
close (fd);
}
}
-/* Process one file. */
+/* Check if the file is an archive, and if so dump its index. */
static void
-process_file (int fd, Elf *elf, const char *prefix, const char *fname,
- bool only_one, bool will_print_archive_index)
+check_archive_index (int fd, const char *fname, bool only_one)
{
- /* We can handle two types of files: ELF files and archives. */
- Elf_Kind kind = elf_kind (elf);
- struct stat64 st;
-
- switch (kind)
+ /* Create an `Elf' descriptor. */
+ Elf *elf = elf_begin (fd, ELF_C_READ_MMAP, NULL);
+ if (elf == NULL)
+ error (0, 0, gettext ("cannot generate Elf descriptor: %s"),
+ elf_errmsg (-1));
+ else
{
- case ELF_K_ELF:
- if (unlikely (will_print_archive_index))
+ if (elf_kind (elf) == ELF_K_AR)
+ {
+ if (!only_one)
+ printf ("\n%s:\n\n", fname);
+ dump_archive_index (elf, fname);
+ }
+ else
error (0, 0,
gettext ("'%s' is not an archive, cannot print archive index"),
fname);
- /* Yes! It's an ELF file. */
- if (any_control_option)
- process_elf_file (elf, prefix, fname, only_one);
- break;
- case ELF_K_AR:
- {
- size_t prefix_len = prefix == NULL ? 0 : strlen (prefix);
- size_t fname_len = strlen (fname) + 1;
- char new_prefix[prefix_len + 1 + fname_len];
- char *cp = new_prefix;
+ /* Now we can close the descriptor. */
+ if (elf_end (elf) != 0)
+ error (0, 0, gettext ("error while closing Elf descriptor: %s"),
+ elf_errmsg (-1));
+ }
+}
- /* Create the full name of the file. */
- if (prefix != NULL)
- {
- cp = mempcpy (cp, prefix, prefix_len);
- *cp++ = ':';
- }
- memcpy (cp, fname, fname_len);
+/* Trivial callback used for checking if we opened an archive. */
+static int
+count_dwflmod (Dwfl_Module *dwflmod __attribute__ ((unused)),
+ void **userdata __attribute__ ((unused)),
+ const char *name __attribute__ ((unused)),
+ Dwarf_Addr base __attribute__ ((unused)),
+ void *arg)
+{
+ *(bool *) arg = false;
+ return DWARF_CB_ABORT;
+}
- if (will_print_archive_index)
- dump_archive_index (elf, new_prefix);
+static int
+process_dwflmod (Dwfl_Module *dwflmod,
+ void **userdata __attribute__ ((unused)),
+ const char *name __attribute__ ((unused)),
+ Dwarf_Addr base __attribute__ ((unused)),
+ void *arg)
+{
+ bool only_one = *(bool *) arg;
- /* It's an archive. We process each file in it. */
- Elf *subelf;
- Elf_Cmd cmd = ELF_C_READ_MMAP;
- while ((subelf = elf_begin (fd, cmd, elf)) != NULL)
- {
- kind = elf_kind (subelf);
+ /* Print the file name. */
+ if (!only_one)
+ {
+ const char *fname;
+ dwfl_module_info (dwflmod, NULL, NULL, NULL, NULL, NULL, &fname, NULL);
- /* Call this function recursively. */
- if (kind == ELF_K_ELF || kind == ELF_K_AR)
- {
- Elf_Arhdr *arhdr = elf_getarhdr (subelf);
- assert (arhdr != NULL);
+ printf ("\n%s:\n\n", fname);
+ }
- process_file (fd, subelf, new_prefix, arhdr->ar_name, false,
- kind == ELF_K_AR && will_print_archive_index);
- }
+ process_elf_file (dwflmod);
- /* Get next archive element. */
- cmd = elf_next (subelf);
- if (elf_end (subelf) != 0)
- error (0, 0,
- gettext (" error while freeing sub-ELF descriptor: %s\n"),
- elf_errmsg (-1));
- }
- }
- break;
+ return DWARF_CB_OK;
+}
- default:
+/* Stub libdwfl callback, only the ELF handle already open is ever used. */
+static int
+find_no_debuginfo (Dwfl_Module *mod __attribute__ ((unused)),
+ void **userdata __attribute__ ((unused)),
+ const char *modname __attribute__ ((unused)),
+ Dwarf_Addr base __attribute__ ((unused)),
+ const char *file_name __attribute__ ((unused)),
+ const char *debuglink_file __attribute__ ((unused)),
+ GElf_Word debuglink_crc __attribute__ ((unused)),
+ char **debuginfo_file_name __attribute__ ((unused)))
+{
+ return -1;
+}
+
+/* Process one input file. */
+static void
+process_file (int fd, const char *fname, bool only_one)
+{
+ if (print_archive_index)
+ check_archive_index (fd, fname, only_one);
+
+ if (!any_control_option)
+ return;
+
+ /* Use libdwfl in a trivial way to open the libdw handle for us.
+ This takes care of applying relocations to DWARF data in ET_REL files. */
+ static const Dwfl_Callbacks callbacks =
+ {
+ .section_address = dwfl_offline_section_address,
+ .find_debuginfo = find_no_debuginfo
+ };
+ Dwfl *dwfl = dwfl_begin (&callbacks);
+ if (dwfl_report_offline (dwfl, fname, fname, fd) == NULL)
+ {
+ struct stat64 st;
if (fstat64 (fd, &st) != 0)
error (0, errno, gettext ("cannot stat input file"));
else if (st.st_size == 0)
error (0, 0, gettext ("input file is empty"));
else
- /* We cannot do anything. */
- error (0, 0, gettext ("\
-Not an ELF file - it has the wrong magic bytes at the start"));
- break;
+ error (0, 0, gettext ("failed reading '%s': %s"),
+ fname, dwfl_errmsg (-1));
+ }
+ else
+ {
+ dwfl_report_end (dwfl, NULL, NULL);
+
+ if (only_one)
+ /* Clear ONLY_ONE if we have multiple modules, from an archive. */
+ dwfl_getmodules (dwfl, &count_dwflmod, &only_one, 1);
+
+ /* Process the one or more modules gleaned from this file. */
+ dwfl_getmodules (dwfl, &process_dwflmod, &only_one, 0);
}
+ dwfl_end (dwfl);
}
-/* Process one file. */
+/* Process one ELF file. */
static void
-process_elf_file (Elf *elf, const char *prefix, const char *fname,
- bool only_one)
+process_elf_file (Dwfl_Module *dwflmod)
{
+ GElf_Addr dwflbias;
+ Elf *elf = dwfl_module_getelf (dwflmod, &dwflbias);
+
GElf_Ehdr ehdr_mem;
GElf_Ehdr *ehdr = gelf_getehdr (elf, &ehdr_mem);
- /* Print the file name. */
- if (!only_one)
- {
- if (prefix != NULL)
- printf ("\n%s(%s):\n\n", prefix, fname);
- else
- printf ("\n%s:\n\n", fname);
- }
-
if (ehdr == NULL)
{
error (0, 0, gettext ("cannot read ELF header: %s"), elf_errmsg (-1));
if (string_sections != NULL)
dump_strings (ebl);
if (print_debug_sections != 0)
- print_debug (ebl, ehdr);
+ print_debug (dwflmod, ebl, ehdr);
if (print_notes)
handle_notes (ebl, ehdr);
if (print_string_sections)
}
+static char *
+format_dwarf_addr (Dwfl_Module *dwflmod,
+ int address_size, Dwarf_Addr address)
+{
+ /* See if there is a name we can give for this address. */
+ GElf_Sym sym;
+ const char *name = dwfl_module_addrsym (dwflmod, address, &sym, NULL);
+ if (name != NULL)
+ sym.st_value = address - sym.st_value;
+
+ /* Relativize the address. */
+ int n = dwfl_module_relocations (dwflmod);
+ int i = n < 1 ? -1 : dwfl_module_relocate_address (dwflmod, &address);
+
+ /* In an ET_REL file there is a section name to refer to. */
+ const char *scn = (i < 0 ? NULL
+ : dwfl_module_relocation_info (dwflmod, i, NULL));
+
+ char *result;
+ if ((name != NULL
+ ? (sym.st_value != 0
+ ? (scn != NULL
+ ? (address_size == 0
+ ? asprintf (&result,
+ gettext ("%s+%#" PRIx64 " <%s+%#" PRIx64 ">"),
+ scn, address, name, sym.st_value)
+ : asprintf (&result,
+ gettext ("%s+%#0*" PRIx64 " <%s+%#" PRIx64 ">"),
+ scn, 2 + address_size * 2, address,
+ name, sym.st_value))
+ : (address_size == 0
+ ? asprintf (&result,
+ gettext ("%#" PRIx64 " <%s+%#" PRIx64 ">"),
+ address, name, sym.st_value)
+ : asprintf (&result,
+ gettext ("%#0*" PRIx64 " <%s+%#" PRIx64 ">"),
+ 2 + address_size * 2, address,
+ name, sym.st_value)))
+ : (scn != NULL
+ ? (address_size == 0
+ ? asprintf (&result,
+ gettext ("%s+%#" PRIx64 " <%s>"),
+ scn, address, name)
+ : asprintf (&result,
+ gettext ("%s+%#0*" PRIx64 " <%s>"),
+ scn, 2 + address_size * 2, address, name))
+ : (address_size == 0
+ ? asprintf (&result,
+ gettext ("%#" PRIx64 " <%s>"),
+ address, name)
+ : asprintf (&result,
+ gettext ("%#0*" PRIx64 " <%s>"),
+ 2 + address_size * 2, address, name))))
+ : (scn != NULL
+ ? (address_size == 0
+ ? asprintf (&result,
+ gettext ("%s+%#" PRIx64),
+ scn, address)
+ : asprintf (&result,
+ gettext ("%s+%#0*" PRIx64),
+ scn, 2 + address_size * 2, address))
+ : (address_size == 0
+ ? asprintf (&result,
+ "%#" PRIx64,
+ address)
+ : asprintf (&result,
+ "%#0*" PRIx64,
+ 2 + address_size * 2, address)))) < 0)
+ error (EXIT_FAILURE, 0, _("memory exhausted"));
+
+ return result;
+}
+
static const char *
dwarf_tag_string (unsigned int tag)
{
static void
-print_ops (Dwarf *dbg, int indent, int indentrest,
+print_ops (Dwfl_Module *dwflmod, Dwarf *dbg, int indent, int indentrest,
unsigned int addrsize, Dwarf_Word len, const unsigned char *data)
{
static const char *const known[] =
data += addrsize;
len -= addrsize;
- printf ("%*s[%4" PRIuMAX "] %s %" PRIuMAX "\n",
- indent, "", (uintmax_t) offset,
- known[op] ?: "???", (uintmax_t) addr);
+ if (op == DW_OP_addr)
+ {
+ char *a = format_dwarf_addr (dwflmod, 0, addr);
+ printf ("%*s[%4" PRIuMAX "] %s %s\n",
+ indent, "", (uintmax_t) offset,
+ known[op] ?: "???", a);
+ free (a);
+ }
+ else
+ printf ("%*s[%4" PRIuMAX "] %s %#" PRIxMAX "\n",
+ indent, "", (uintmax_t) offset,
+ known[op] ?: "???", (uintmax_t) addr);
offset += 1 + addrsize;
break;
static void
-print_debug_abbrev_section (Ebl *ebl __attribute__ ((unused)),
+print_debug_abbrev_section (Dwfl_Module *dwflmod __attribute__ ((unused)),
+ Ebl *ebl __attribute__ ((unused)),
GElf_Ehdr *ehdr __attribute__ ((unused)),
Elf_Scn *scn __attribute__ ((unused)),
GElf_Shdr *shdr, Dwarf *dbg)
not have to know a bit about the structure of the section, libdwarf
takes care of it. */
static void
-print_debug_aranges_section (Ebl *ebl __attribute__ ((unused)),
+print_debug_aranges_section (Dwfl_Module *dwflmod __attribute__ ((unused)),
+ Ebl *ebl __attribute__ ((unused)),
GElf_Ehdr *ehdr __attribute__ ((unused)),
Elf_Scn *scn __attribute__ ((unused)),
GElf_Shdr *shdr, Dwarf *dbg)
/* Print content of DWARF .debug_ranges section. */
static void
-print_debug_ranges_section (Ebl *ebl __attribute__ ((unused)),
+print_debug_ranges_section (Dwfl_Module *dwflmod,
+ Ebl *ebl __attribute__ ((unused)),
GElf_Ehdr *ehdr, Elf_Scn *scn, GElf_Shdr *shdr,
Dwarf *dbg)
{
if (data->d_size - offset < address_size * 2)
{
- printf (" [%6tx] <INVALID DATA>\n", offset);
+ printf (gettext (" [%6tx] <INVALID DATA>\n"), offset);
break;
}
}
if (begin == (Dwarf_Addr) -1l) /* Base address entry. */
- printf (" [%6tx] base address %#0*" PRIxMAX "\n", offset,
- 2 + (int) (address_size * 2), (uintmax_t) end);
+ {
+ char *b = format_dwarf_addr (dwflmod, address_size, end);
+ printf (gettext (" [%6tx] base address %s\n"), offset, b);
+ free (b);
+ }
else if (begin == 0 && end == 0) /* End of list entry. */
first = true;
else
{
+ char *b = format_dwarf_addr (dwflmod, address_size, begin);
+ char *e = format_dwarf_addr (dwflmod, address_size, end);
/* We have an address range entry. */
if (first) /* First address range entry in a list. */
- printf (" [%6tx] %#0*" PRIxMAX "..%#0*" PRIxMAX "\n", offset,
- 2 + (int) (address_size * 2), (uintmax_t) begin,
- 2 + (int) (address_size * 2), (uintmax_t) end);
+ printf (gettext (" [%6tx] %s..%s\n"), offset, b, e);
else
- printf (" %#0*" PRIxMAX "..%#0*" PRIxMAX "\n",
- 2 + (int) (address_size * 2), (uintmax_t) begin,
- 2 + (int) (address_size * 2), (uintmax_t) end);
+ printf (gettext (" %s..%s\n"), b, e);
+ free (b);
+ free (e);
first = false;
}
static void
-print_debug_frame_section (Ebl *ebl __attribute__ ((unused)),
+print_debug_frame_section (Dwfl_Module *dwflmod __attribute__ ((unused)),
+ Ebl *ebl __attribute__ ((unused)),
GElf_Ehdr *ehdr __attribute__ ((unused)),
Elf_Scn *scn __attribute__ ((unused)),
GElf_Shdr *shdr __attribute__ ((unused)),
struct attrcb_args
{
+ Dwfl_Module *dwflmod;
Dwarf *dbg;
int level;
unsigned int addrsize;
switch (form)
{
- case DW_FORM_addr:;
- Dwarf_Addr addr;
- if (unlikely (dwarf_formaddr (attrp, &addr) != 0))
- {
- attrval_out:
- error (0, 0, gettext ("cannot get attribute value: %s"),
- dwarf_errmsg (-1));
- return DWARF_CB_ABORT;
- }
- printf (" %*s%-20s %#0*" PRIxMAX "\n",
- (int) (level * 2), "", dwarf_attr_string (attr),
- 2 + (int) (cbargs->addrsize * 2), (uintmax_t) addr);
+ case DW_FORM_addr:
+ {
+ Dwarf_Addr addr;
+ if (unlikely (dwarf_formaddr (attrp, &addr) != 0))
+ {
+ attrval_out:
+ error (0, 0, gettext ("cannot get attribute value: %s"),
+ dwarf_errmsg (-1));
+ return DWARF_CB_ABORT;
+ }
+ char *a = format_dwarf_addr (cbargs->dwflmod, cbargs->addrsize, addr);
+ printf (" %*s%-20s %s\n",
+ (int) (level * 2), "", dwarf_attr_string (attr), a);
+ free (a);
+ }
break;
case DW_FORM_indirect:
case DW_AT_frame_base:
case DW_AT_return_addr:
case DW_AT_static_link:
- print_ops (cbargs->dbg, 12 + level * 2, 12 + level * 2,
+ print_ops (cbargs->dwflmod, cbargs->dbg,
+ 12 + level * 2, 12 + level * 2,
cbargs->addrsize, block.length, block.data);
break;
}
static void
-print_debug_info_section (Ebl *ebl __attribute__ ((unused)),
+print_debug_info_section (Dwfl_Module *dwflmod,
+ Ebl *ebl __attribute__ ((unused)),
GElf_Ehdr *ehdr __attribute__ ((unused)),
Elf_Scn *scn __attribute__ ((unused)),
GElf_Shdr *shdr, Dwarf *dbg)
struct attrcb_args args;
+ args.dwflmod = dwflmod;
args.dbg = dbg;
args.addrsize = addrsize;
args.cu_offset = offset;
static void
-print_debug_line_section (Ebl *ebl, GElf_Ehdr *ehdr __attribute__ ((unused)),
+print_debug_line_section (Dwfl_Module *dwflmod, Ebl *ebl,
+ GElf_Ehdr *ehdr __attribute__ ((unused)),
Elf_Scn *scn, GElf_Shdr *shdr, Dwarf *dbg)
{
printf (gettext ("\
line += line_increment;
address += address_increment;
+ char *a = format_dwarf_addr (dwflmod, 0, address);
printf (gettext ("\
- special opcode %u: address+%u = %#" PRIx64 ", line%+d = %zu\n"),
- opcode, address_increment, (uint64_t) address,
- line_increment, line);
+ special opcode %u: address+%u = %s, line%+d = %zu\n"),
+ opcode, address_increment, a, line_increment, line);
+ free (a);
}
else if (opcode == 0)
{
address = read_4ubyte_unaligned_inc (dbg, linep);
else
address = read_8ubyte_unaligned_inc (dbg, linep);
- printf (gettext ("set address to %#" PRIx64 "\n"),
- (uint64_t) address);
+ {
+ char *a = format_dwarf_addr (dwflmod, 0, address);
+ printf (gettext ("set address to %s\n"), a);
+ free (a);
+ }
break;
case DW_LNE_define_file:
address. */
get_uleb128 (u128, linep);
address += minimum_instr_len * u128;
- printf (gettext ("\
- advance address by %u to %#" PRIx64 "\n"),
- u128, (uint64_t) address);
+ {
+ char *a = format_dwarf_addr (dwflmod, 0, address);
+ printf (gettext ("advance address by %u to %s\n"),
+ u128, a);
+ free (a);
+ }
break;
case DW_LNS_advance_line:
u128 = (minimum_instr_len
* ((255 - opcode_base) / line_range));
address += u128;
- printf (gettext ("\
- advance address by constant %u to %#" PRIx64 "\n"),
- u128, (uint64_t) address);
+ {
+ char *a = format_dwarf_addr (dwflmod, 0, address);
+ printf (gettext ("advance address by constant %u to %s\n"),
+ u128, a);
+ free (a);
+ }
break;
case DW_LNS_fixed_advance_pc:
u128 = read_2ubyte_unaligned_inc (dbg, linep);
address += u128;
- printf (gettext ("\
- advance address by fixed value %u to %#" PRIx64 "\n"),
- u128, (uint64_t) address);
+ {
+ char *a = format_dwarf_addr (dwflmod, 0, address);
+ printf (gettext ("\
+advance address by fixed value %u to %s\n"),
+ u128, a);
+ free (a);
+ }
break;
case DW_LNS_set_prologue_end:
static void
-print_debug_loc_section (Ebl *ebl __attribute__ ((unused)),
+print_debug_loc_section (Dwfl_Module *dwflmod,
+ Ebl *ebl __attribute__ ((unused)),
GElf_Ehdr *ehdr __attribute__ ((unused)),
Elf_Scn *scn __attribute__ ((unused)),
GElf_Shdr *shdr,
if (data->d_size - offset < address_size * 2)
{
- printf (" [%6tx] <INVALID DATA>\n", offset);
+ printf (gettext (" [%6tx] <INVALID DATA>\n"), offset);
break;
}
}
if (begin == (Dwarf_Addr) -1l) /* Base address entry. */
- printf (" [%6tx] base address %#0*" PRIxMAX "\n", offset,
- 2 + (int) (address_size * 2), (uintmax_t) end);
+ {
+ char *b = format_dwarf_addr (dwflmod, address_size, end);
+ printf (gettext (" [%6tx] base address %s\n"), offset, b);
+ free (b);
+ }
else if (begin == 0 && end == 0) /* End of list entry. */
first = true;
else
/* We have a location expression entry. */
uint_fast16_t len = read_2ubyte_unaligned_inc (dbg, readp);
+ char *b = format_dwarf_addr (dwflmod, address_size, begin);
+ char *e = format_dwarf_addr (dwflmod, address_size, end);
+
if (first) /* First entry in a list. */
- printf (" [%6tx] %#0*" PRIxMAX "..%#0*" PRIxMAX,
- offset,
- 2 + (int) (address_size * 2), (uintmax_t) begin,
- 2 + (int) (address_size * 2), (uintmax_t) end);
+ printf (gettext (" [%6tx] %s..%s"), offset, b, e);
else
- printf (" %#0*" PRIxMAX "..%#0*" PRIxMAX,
- 2 + (int) (address_size * 2), (uintmax_t) begin,
- 2 + (int) (address_size * 2), (uintmax_t) end);
+ printf (gettext (" %s..%s"), b, e);
- print_ops (dbg, 1, 18 + (address_size * 4),
+ free (b);
+ free (e);
+
+ print_ops (dwflmod, dbg, 1, 18 + (address_size * 4),
address_size, len, readp);
first = false;
static void
-print_debug_macinfo_section (Ebl *ebl __attribute__ ((unused)),
+print_debug_macinfo_section (Dwfl_Module *dwflmod __attribute__ ((unused)),
+ Ebl *ebl __attribute__ ((unused)),
GElf_Ehdr *ehdr __attribute__ ((unused)),
Elf_Scn *scn, GElf_Shdr *shdr, Dwarf *dbg)
{
/* Print the known exported symbols in the DWARF section '.debug_pubnames'. */
static void
-print_debug_pubnames_section (Ebl *ebl __attribute__ ((unused)),
+print_debug_pubnames_section (Dwfl_Module *dwflmod __attribute__ ((unused)),
+ Ebl *ebl __attribute__ ((unused)),
GElf_Ehdr *ehdr __attribute__ ((unused)),
Elf_Scn *scn __attribute__ ((unused)),
GElf_Shdr *shdr, Dwarf *dbg)
/* Print the content of the DWARF string section '.debug_str'. */
static void
-print_debug_str_section (Ebl *ebl __attribute__ ((unused)),
+print_debug_str_section (Dwfl_Module *dwflmod __attribute__ ((unused)),
+ Ebl *ebl __attribute__ ((unused)),
GElf_Ehdr *ehdr __attribute__ ((unused)),
Elf_Scn *scn __attribute__ ((unused)),
GElf_Shdr *shdr, Dwarf *dbg)
}
}
-
static void
-print_debug (Ebl *ebl, GElf_Ehdr *ehdr)
+print_debug (Dwfl_Module *dwflmod, Ebl *ebl, GElf_Ehdr *ehdr)
{
- /* Find the version information sections. For this we have to
- search through the section table. */
- Dwarf *dbg;
- Elf_Scn *scn;
- size_t shstrndx;
-
/* Before we start the real work get a debug context descriptor. */
- dbg = dwarf_begin_elf (ebl->elf, DWARF_C_READ, NULL);
+ Dwarf_Addr dwbias;
+ Dwarf *dbg = dwfl_module_getdwarf (dwflmod, &dwbias);
if (dbg == NULL)
{
error (0, 0, gettext ("cannot get debug context descriptor: %s"),
- dwarf_errmsg (-1));
+ dwfl_errmsg (-1));
return;
}
/* Get the section header string table index. */
+ size_t shstrndx;
if (elf_getshstrndx (ebl->elf, &shstrndx) < 0)
error (EXIT_FAILURE, 0,
gettext ("cannot get section header string table index"));
- scn = NULL;
+ /* Look through all the sections for the debugging sections to print. */
+ Elf_Scn *scn = NULL;
while ((scn = elf_nextscn (ebl->elf, scn)) != NULL)
{
- /* Handle the section if it is part of the versioning handling. */
GElf_Shdr shdr_mem;
GElf_Shdr *shdr = gelf_getshdr (scn, &shdr_mem);
{
const char *name;
enum section_e bitmask;
- void (*fp) (Ebl *, GElf_Ehdr *, Elf_Scn *, GElf_Shdr *, Dwarf *);
+ void (*fp) (Dwfl_Module *, Ebl *,
+ GElf_Ehdr *, Elf_Scn *, GElf_Shdr *, Dwarf *);
} debug_sections[] =
{
#define NEW_SECTION(name) \
if (strcmp (name, debug_sections[n].name) == 0)
{
if (print_debug_sections & debug_sections[n].bitmask)
- debug_sections[n].fp (ebl, ehdr, scn, shdr, dbg);
+ debug_sections[n].fp (dwflmod, ebl, ehdr, scn, shdr, dbg);
break;
}
}
}
-
- /* We are done with the DWARF handling. */
- dwarf_end (dbg);
}
break;
case 'T':
+ case (char) ('T'|0x80):
assert (count == 2);
Dwarf_Word sec;
Dwarf_Word usec;
default:
abort ();
}
+ if (unlikely (item->format == (char) ('T'|0x80)))
+ {
+ /* This is a hack for an ill-considered 64-bit ABI where
+ tv_usec is actually a 32-bit field with 32 bits of padding
+ rounding out struct timeval. We've already converted it as
+ a 64-bit field. For little-endian, this just means the
+ high half is the padding; it's presumably zero, but should
+ be ignored anyway. For big-endian, it means the 32-bit
+ field went into the high half of USEC. */
+ GElf_Ehdr ehdr_mem;
+ GElf_Ehdr *ehdr = gelf_getehdr (core, &ehdr_mem);
+ if (likely (ehdr->e_ident[EI_DATA] == ELFDATA2MSB))
+ usec >>= 32;
+ else
+ usec &= UINT32_MAX;
+ }
colno = print_core_item (colno, ',', ITEM_WRAP_COLUMN, 0, item->name,
maxfmt, "%" PRIu64 ".%.6" PRIu64, sec, usec);
break;
* prelink vs .debug_* linked addresses
- * merge many inputs? -> ET_EXEC with union phdrs + new phdrs for ET_REL mods
- ** with applied relocs to ET_REL mods, use data modified by dwfl
- *** still must apply relocs to SHF_ALLOC
- ** useless unless merge all symtabs and dwarf sections
-
*/
#ifdef HAVE_CONFIG_H
{ "all", 'a', NULL, 0,
N_("Create output for modules that have no separate debug information"),
0 },
+ { "relocate", 'R', NULL, 0,
+ N_("Apply relocations to DWARF sections in ET_REL files"), 0 },
{ "list-only", 'n', NULL, 0,
N_("Only list module and file names, build IDs"), 0 },
{ NULL, 0, NULL, 0, NULL, 0 }
bool ignore;
bool modnames;
bool match_files;
+ bool relocate;
};
/* Handle program arguments. */
case 'n':
info->list = true;
break;
+ case 'R':
+ info->relocate = true;
+ break;
case ARGP_KEY_ARGS:
case ARGP_KEY_NO_ARGS:
return EINVAL;
}
- if (info->ignore || info->all || info->modnames)
+ if (info->ignore || info->all || info->modnames || info->relocate)
{
argp_error (state, _("\
--m, -a, and -i options not allowed with explicit files"));
+-m, -a, -R, and -i options not allowed with explicit files"));
return EINVAL;
}
possible, add in section symbols for the added sections. */
static Elf_Data *
add_new_section_symbols (Elf_Scn *old_symscn, size_t old_shnum,
- Elf *elf, Elf_Scn *symscn, size_t shnum)
+ Elf *elf, bool rel, Elf_Scn *symscn, size_t shnum)
{
const size_t added = shnum - old_shnum;
ELF_CHECK (i_shdr != NULL, _("cannot get section header: %s"));
GElf_Sym sym =
{
- .st_value = i_shdr->sh_addr,
+ .st_value = rel ? 0 : i_shdr->sh_addr,
.st_info = GELF_ST_INFO (STB_LOCAL, STT_SECTION),
.st_shndx = i < SHN_LORESERVE ? i : SHN_XINDEX
};
/* This has the side effect of updating STT_SECTION symbols' values,
in case of prelink adjustments. */
static Elf_Data *
-check_symtab_section_symbols (Elf *elf, Elf_Scn *scn,
+check_symtab_section_symbols (Elf *elf, bool rel, Elf_Scn *scn,
size_t shnum, size_t shstrndx,
Elf_Scn *oscn, size_t oshnum, size_t oshstrndx,
size_t debuglink)
elf_getdata (scn, NULL));
if (n == oshnum)
- return add_new_section_symbols (oscn, n, elf, scn, shnum);
+ return add_new_section_symbols (oscn, n, elf, rel, scn, shnum);
if (n == oshstrndx || (n == debuglink && n == oshstrndx - 1))
- return add_new_section_symbols (oscn, n, elf, scn, shstrndx);
+ return add_new_section_symbols (oscn, n, elf, rel, scn, shstrndx);
return NULL;
}
};
static int
-compare_alloc_sections (const struct section *s1, const struct section *s2)
+compare_alloc_sections (const struct section *s1, const struct section *s2,
+ bool rel)
{
- /* Sort by address. */
- if (s1->shdr.sh_addr < s2->shdr.sh_addr)
- return -1;
- if (s1->shdr.sh_addr > s2->shdr.sh_addr)
- return 1;
+ if (!rel)
+ {
+ /* Sort by address. */
+ if (s1->shdr.sh_addr < s2->shdr.sh_addr)
+ return -1;
+ if (s1->shdr.sh_addr > s2->shdr.sh_addr)
+ return 1;
+ }
- return 0;
+ /* At the same address, preserve original section order. */
+ return (ssize_t) elf_ndxscn (s1->scn) - (ssize_t) elf_ndxscn (s2->scn);
}
static int
}
static int
-compare_sections (const void *a, const void *b)
+compare_sections (const void *a, const void *b, bool rel)
{
const struct section *s1 = a;
const struct section *s2 = b;
return (s1->shdr.sh_flags & SHF_ALLOC) ? -1 : 1;
return ((s1->shdr.sh_flags & SHF_ALLOC)
- ? compare_alloc_sections (s1, s2)
+ ? compare_alloc_sections (s1, s2, rel)
: compare_unalloc_sections (&s1->shdr, &s2->shdr,
s1->name, s2->name));
}
+static int
+compare_sections_rel (const void *a, const void *b)
+{
+ return compare_sections (a, b, true);
+}
+
+int
+compare_sections_nonrel (const void *a, const void *b)
+{
+ return compare_sections (a, b, false);
+}
+
struct symbol
{
/* Collect input symbols into our internal form. */
static void
-collect_symbols (Elf *outelf, Elf_Scn *symscn, Elf_Scn *strscn,
+collect_symbols (Elf *outelf, bool rel, Elf_Scn *symscn, Elf_Scn *strscn,
const size_t nent, const GElf_Addr bias,
const size_t scnmap[], struct symbol *table, size_t *map,
struct section *split_bss)
if (scnmap != NULL && shndx != SHN_UNDEF && shndx < SHN_LORESERVE)
s->shndx = scnmap[shndx - 1];
- if (GELF_ST_TYPE (s->info.info) == STT_SECTION)
+ if (GELF_ST_TYPE (s->info.info) == STT_SECTION && !rel)
{
+ /* Update the value to match the output section. */
GElf_Shdr shdr_mem;
- GElf_Shdr *shdr = gelf_getshdr (elf_getscn (outelf, shndx),
+ GElf_Shdr *shdr = gelf_getshdr (elf_getscn (outelf, s->shndx),
&shdr_mem);
ELF_CHECK (shdr != NULL, _("cannot get section header: %s"));
-
- if (GELF_ST_TYPE (s->info.info) == STT_SECTION)
- /* Update the value to match the output section. */
- s->value = shdr->sh_addr;
+ s->value = shdr->sh_addr;
}
else if (split_bss != NULL
&& s->value < split_bss->shdr.sh_addr
#undef CMP
+/* Return true iff the flags, size, and name match. */
+static bool
+sections_match (const struct section *sections, size_t i,
+ const GElf_Shdr *shdr, const char *name)
+{
+ return (sections[i].shdr.sh_flags == shdr->sh_flags
+ && (sections[i].shdr.sh_size == shdr->sh_size
+ || (sections[i].shdr.sh_size < shdr->sh_size
+ && section_can_shrink (§ions[i].shdr)))
+ && !strcmp (sections[i].name, name));
+}
+
/* Locate a matching allocated section in SECTIONS. */
static struct section *
find_alloc_section (const GElf_Shdr *shdr, GElf_Addr bias, const char *name,
--i;
for (; i < nalloc && sections[i].shdr.sh_addr == addr;
++i)
- if (sections[i].shdr.sh_flags == shdr->sh_flags
- && (sections[i].shdr.sh_size == shdr->sh_size
- || (sections[i].shdr.sh_size < shdr->sh_size
- && section_can_shrink (§ions[i].shdr)))
- && !strcmp (sections[i].name, name))
+ if (sections_match (sections, i, shdr, name))
return §ions[i];
break;
}
}
}
qsort (undo_sections, undo_nalloc,
- sizeof undo_sections[0], compare_sections);
+ sizeof undo_sections[0], compare_sections_nonrel);
}
bool fail = false;
const struct section *stripped_symtab = NULL;
/* Sort the sections, allocated by address and others after. */
- qsort (sections, stripped_shnum - 1, sizeof sections[0], compare_sections);
+ qsort (sections, stripped_shnum - 1, sizeof sections[0],
+ stripped_ehdr->e_type == ET_REL
+ ? compare_sections_rel : compare_sections_nonrel);
size_t nalloc = stripped_shnum - 1;
while (nalloc > 0 && !(sections[nalloc - 1].shdr.sh_flags & SHF_ALLOC))
{
bool check_prelink = false;
Elf_Scn *unstripped_symtab = NULL;
size_t unstripped_strtab_ndx = SHN_UNDEF;
+ size_t alloc_avail = 0;
scn = NULL;
while ((scn = elf_nextscn (unstripped, scn)) != NULL)
{
const char *name = get_section_name (ndx, shdr, shstrtab);
- /* Look for the section that matches. */
- struct section *sec = ((shdr->sh_flags & SHF_ALLOC)
- ? find_alloc_section (shdr, bias, name,
- sections, nalloc)
- : find_unalloc_section (shdr, name));
- if (sec == NULL)
+ struct section *sec = NULL;
+ if (shdr->sh_flags & SHF_ALLOC)
{
- if ((shdr->sh_flags & SHF_ALLOC) && stripped_ehdr->e_type != ET_REL)
+ if (stripped_ehdr->e_type != ET_REL)
{
- /* If we couldn't figure it out, it may be a prelink issue. */
- check_prelink = true;
- continue;
+ /* Look for the section that matches. */
+ sec = find_alloc_section (shdr, bias, name, sections, nalloc);
+ if (sec == NULL)
+ {
+ /* We couldn't figure it out. It may be a prelink issue. */
+ check_prelink = true;
+ continue;
+ }
+ }
+ else
+ {
+ /* The sh_addr of allocated sections does not help us,
+ but the order usually matches. */
+ if (likely (sections_match (sections, alloc_avail, shdr, name)))
+ sec = §ions[alloc_avail++];
+ else
+ for (size_t i = alloc_avail + 1; i < nalloc; ++i)
+ if (sections_match (sections, i, shdr, name))
+ {
+ sec = §ions[i];
+ break;
+ }
+ }
+ }
+ else
+ {
+ /* Look for the section that matches. */
+ sec = find_unalloc_section (shdr, name);
+ if (sec == NULL)
+ {
+ /* An additional unallocated section is fine if not SHT_NOBITS.
+ We looked it up anyway in case it's an unallocated section
+ copied in both files (e.g. SHT_NOTE), and don't keep both. */
+ if (shdr->sh_type != SHT_NOBITS)
+ continue;
+
+ /* Somehow some old .debug files wound up with SHT_NOBITS
+ .comment sections, so let those pass. */
+ if (!strcmp (name, ".comment"))
+ continue;
}
-
- /* An additional unallocated section is fine if not SHT_NOBITS.
- We looked it up anyway in case it's an unallocated section
- copied in both files (e.g. SHT_NOTE), so we don't keep both. */
- if (shdr->sh_type != SHT_NOBITS && !(shdr->sh_flags & SHF_ALLOC))
- continue;
-
- /* Somehow some old .debug files wound up with SHT_NOBITS
- .comment sections, so let those pass. */
- if (!(shdr->sh_flags & SHF_ALLOC) && !strcmp (name, ".comment"))
- continue;
-
- error (EXIT_FAILURE, 0,
- _("cannot find matching section for [%Zu] '%s'"),
- elf_ndxscn (scn), name);
}
+ if (sec == NULL)
+ error (EXIT_FAILURE, 0,
+ _("cannot find matching section for [%Zu] '%s'"),
+ elf_ndxscn (scn), name);
+
sec->outscn = scn;
}
{
/* This was created by stripping. We don't want it. */
debuglink = secndx;
+ ndx_section[secndx - 1] = SHN_UNDEF;
continue;
}
GElf_Shdr *shdr = gelf_getshdr (sec->outscn, &shdr_mem);
ELF_CHECK (shdr != NULL, _("cannot get section header: %s"));
- shdr_mem.sh_addr = sec->shdr.sh_addr;
+ /* In an ET_REL file under --relocate, the sh_addr of SHF_ALLOC
+ sections will have been set nonzero by relocation. This
+ touched the shdrs of whichever file had the symtab. sh_addr
+ is still zero in the corresponding shdr. The relocated
+ address is what we want to use. */
+ if (stripped_ehdr->e_type != ET_REL
+ || !(shdr_mem.sh_flags & SHF_ALLOC)
+ || shdr_mem.sh_addr == 0)
+ shdr_mem.sh_addr = sec->shdr.sh_addr;
+
shdr_mem.sh_type = sec->shdr.sh_type;
shdr_mem.sh_size = sec->shdr.sh_size;
shdr_mem.sh_info = sec->shdr.sh_info;
size_t symndx_map[total_syms];
if (stripped_symtab != NULL)
- collect_symbols (unstripped, stripped_symtab->scn,
+ collect_symbols (unstripped, stripped_ehdr->e_type == ET_REL,
+ stripped_symtab->scn,
elf_getscn (stripped, stripped_symtab->shdr.sh_link),
stripped_nsym, 0, ndx_section,
symbols, symndx_map, NULL);
Elf_Scn *unstripped_strtab = elf_getscn (unstripped, shdr->sh_link);
- collect_symbols (unstripped,
+ collect_symbols (unstripped, stripped_ehdr->e_type == ET_REL,
unstripped_symtab, unstripped_strtab, unstripped_nsym,
stripped_ehdr->e_type == ET_REL ? 0 : bias, NULL,
&symbols[stripped_nsym - 1],
/* Now we can weed out the duplicates. Assign remaining symbols
new slots, collecting a map from old indices to new. */
- size_t nsym = *symbols[0].map = 1;
- for (size_t i = 1; i < total_syms; ++i)
- *symbols[i].map = (!compare_symbols (&symbols[i - 1], &symbols[i])
- ? 0 /* This is a duplicate. */
- : ++nsym); /* Allocate the next slot. */
+ size_t nsym = 0;
+ for (struct symbol *s = symbols; s < &symbols[total_syms]; ++s)
+ /* Skip a section symbol for a removed section, or a duplicate. */
+ *s->map = (((s->shndx == SHN_UNDEF
+ && GELF_ST_TYPE (s->info.info) == STT_SECTION)
+ || (s + 1 < &symbols[total_syms]
+ && !compare_symbols (s, s + 1))) ? 0
+ /* Allocate the next slot. */
+ : ++nsym);
/* Now we sort again, to determine the order in the output. */
qsort (symbols, total_syms, sizeof symbols[0], compare_symbols_output);
&symndx_map[stripped_nsym - 1]);
}
else if (stripped_symtab != NULL && stripped_shnum != unstripped_shnum)
- check_symtab_section_symbols (unstripped, stripped_symtab->scn,
+ check_symtab_section_symbols (unstripped,
+ stripped_ehdr->e_type == ET_REL,
+ stripped_symtab->scn,
unstripped_shnum, unstripped_shstrndx,
stripped_symtab->outscn,
stripped_shnum, stripped_shstrndx,
debuglink);
if (stripped_dynsym != NULL)
- (void) check_symtab_section_symbols (unstripped, stripped_dynsym->outscn,
+ (void) check_symtab_section_symbols (unstripped,
+ stripped_ehdr->e_type == ET_REL,
+ stripped_dynsym->outscn,
unstripped_shnum,
unstripped_shstrndx,
stripped_dynsym->scn, stripped_shnum,
/* Handle a pair of files opened implicitly by libdwfl for one module. */
static void
handle_dwfl_module (const char *output_file, bool create_dirs,
- Dwfl_Module *mod, bool all, bool ignore)
+ Dwfl_Module *mod, bool all, bool ignore, bool relocate)
{
GElf_Addr bias;
Elf *stripped = dwfl_module_getelf (mod, &bias);
if (stripped_ehdr.e_type == ET_REL)
{
- /* We can't use the Elf handles already open,
- because the DWARF sections have been relocated. */
+ if (!relocate)
+ {
+ /* We can't use the Elf handles already open,
+ because the DWARF sections have been relocated. */
- const char *stripped_file = NULL;
- const char *unstripped_file = NULL;
- (void) dwfl_module_info (mod, NULL, NULL, NULL, NULL, NULL,
- &stripped_file, &unstripped_file);
+ const char *stripped_file = NULL;
+ const char *unstripped_file = NULL;
+ (void) dwfl_module_info (mod, NULL, NULL, NULL, NULL, NULL,
+ &stripped_file, &unstripped_file);
- handle_explicit_files (output_file, create_dirs,
- stripped_file, unstripped_file);
+ handle_explicit_files (output_file, create_dirs,
+ stripped_file, unstripped_file);
+ return;
+ }
+
+ /* Relocation is what we want! This ensures that all sections that can
+ get sh_addr values assigned have them, even ones not used in DWARF.
+ They might still be used in the symbol table. */
+ if (dwfl_module_relocations (mod) < 0)
+ error (EXIT_FAILURE, 0,
+ _("cannot cache section addresses for module '%s': %s"),
+ dwfl_module_info (mod, NULL, NULL, NULL, NULL, NULL, NULL, NULL),
+ dwfl_errmsg (-1));
}
- else
- handle_file (output_file, create_dirs, stripped, &stripped_ehdr, debug);
+
+ handle_file (output_file, create_dirs, stripped, &stripped_ehdr, debug);
}
/* Handle one module being written to the output directory. */
static void
handle_output_dir_module (const char *output_dir, Dwfl_Module *mod,
- bool all, bool ignore, bool modnames)
+ bool all, bool ignore, bool modnames, bool relocate)
{
if (! modnames)
{
if (asprintf (&output_file, "%s/%s", output_dir, modnames ? name : file) < 0)
error (EXIT_FAILURE, 0, _("memory exhausted"));
- handle_dwfl_module (output_file, true, mod, all, ignore);
+ handle_dwfl_module (output_file, true, mod, all, ignore, relocate);
}
if (next (offset) != 0)
error (EXIT_FAILURE, 0, _("matched more than one module"));
handle_dwfl_module (info->output_file, false, mmi.found,
- info->all, info->ignore);
+ info->all, info->ignore, info->relocate);
}
else
do
handle_output_dir_module (info->output_dir, mmi.found,
- info->all, info->ignore, info->modnames);
+ info->all, info->ignore,
+ info->modnames, info->relocate);
while ((offset = next (offset)) > 0);
}
\f
+2007-10-09 Roland McGrath <roland@redhat.com>
+
+ * dwflmodtest.c (print_module): Don't use %p in output.
+ * run-dwfl-bug-offline-rel.sh: Updated expected output.
+
+2007-10-08 Roland McGrath <roland@redhat.com>
+
+ * testfile42.bz2: New data file.
+ * Makefile.am (EXTRA_DIST): Add it.
+ * run-elflint-test.sh: New test on that file.
+
2007-10-04 Roland McGrath <roland@redhat.com>
* run-readelf-test4.sh: New file.
testfile36.bz2 testfile36.debug.bz2 \
testfile37.bz2 testfile37.debug.bz2 \
testfile38.bz2 testfile39.bz2 testfile40.bz2 testfile40.debug.bz2 \
- testfile41.bz2
+ testfile41.bz2 testfile42.bz2
installed_TESTS_ENVIRONMENT = libdir=$(DESTDIR)$(libdir) \
bindir=$(DESTDIR)$(bindir) \
Dwarf *dw, Dwarf_Addr bias,
void *arg)
{
- printf ("module: %30s %08" PRIx64 " %12p %" PRIx64 " (%s)\n",
- name, base, dw, bias, dwfl_errmsg (-1));
+ printf ("module: %30s %08" PRIx64 " %s %" PRIx64 " (%s)\n",
+ name, base, dw == NULL ? "no" : "DWARF", bias, dwfl_errmsg (-1));
if (dw != NULL && *(const bool *) arg)
{
testrun_compare ./dwflmodtest -e testfile36 <<\EOF
module: 00000000..00002308 testfile36 (null)
-module: 00000000 (nil) 0 (Callback returned failure)
+module: 00000000 DWARF 0 (no error)
module: 00000000..00002308 testfile36 testfile36.debug
EOF
testfiles testfile33
testrun ../src/elflint -q testfile33
+testfiles testfile42
+testrun ../src/elflint -q --gnu-ld testfile42
+
exit 0
projects / thirdparty / elfutils.git / commitdiff
