/* readelf.c -- display contents of an ELF format file
Copyright 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007,
- 2008 Free Software Foundation, Inc.
+ 2008, 2009, 2010
+ Free Software Foundation, Inc.
Originally developed by Eric Youngdale <eric@andante.jic.com>
Modifications by Nick Clifton <nickc@redhat.com>
#include <zlib.h>
#endif
-/* for PATH_MAX */
-#ifdef HAVE_LIMITS_H
-#include <limits.h>
-#endif
-
-#ifndef PATH_MAX
-/* for MAXPATHLEN */
-# ifdef HAVE_SYS_PARAM_H
-# include <sys/param.h>
-# endif
-# ifndef PATH_MAX
-# ifdef MAXPATHLEN
-# define PATH_MAX MAXPATHLEN
-# else
-# define PATH_MAX 1024
-# endif
-# endif
-#endif
-
#if __GNUC__ >= 2
/* Define BFD64 here, even if our default architecture is 32 bit ELF
as this will allow us to read in and parse 64bit and 32bit ELF files.
#include "elf/i960.h"
#include "elf/ia64.h"
#include "elf/ip2k.h"
+#include "elf/lm32.h"
#include "elf/iq2000.h"
#include "elf/m32c.h"
#include "elf/m32r.h"
#include "elf/m68hc11.h"
#include "elf/mcore.h"
#include "elf/mep.h"
+#include "elf/microblaze.h"
#include "elf/mips.h"
#include "elf/mmix.h"
#include "elf/mn10200.h"
#include "elf/pj.h"
#include "elf/ppc.h"
#include "elf/ppc64.h"
+#include "elf/rx.h"
#include "elf/s390.h"
#include "elf/score.h"
#include "elf/sh.h"
#include "elf/sparc.h"
#include "elf/spu.h"
+#include "elf/tic6x.h"
#include "elf/v850.h"
#include "elf/vax.h"
#include "elf/x86-64.h"
+#include "elf/xc16x.h"
#include "elf/xstormy16.h"
#include "elf/xtensa.h"
#include "getopt.h"
#include "libiberty.h"
#include "safe-ctype.h"
+#include "filenames.h"
-char *program_name = "readelf";
-int do_wide;
+char * program_name = "readelf";
static long archive_file_offset;
static unsigned long archive_file_size;
static unsigned long dynamic_addr;
static bfd_size_type dynamic_size;
static unsigned int dynamic_nent;
-static char *dynamic_strings;
+static char * dynamic_strings;
static unsigned long dynamic_strings_length;
-static char *string_table;
+static char * string_table;
static unsigned long string_table_length;
static unsigned long num_dynamic_syms;
-static Elf_Internal_Sym *dynamic_symbols;
-static Elf_Internal_Syminfo *dynamic_syminfo;
+static Elf_Internal_Sym * dynamic_symbols;
+static Elf_Internal_Syminfo * dynamic_syminfo;
static unsigned long dynamic_syminfo_offset;
static unsigned int dynamic_syminfo_nent;
static char program_interpreter[PATH_MAX];
-static bfd_vma dynamic_info[DT_JMPREL + 1];
+static bfd_vma dynamic_info[DT_ENCODING];
static bfd_vma dynamic_info_DT_GNU_HASH;
static bfd_vma version_info[16];
static Elf_Internal_Ehdr elf_header;
-static Elf_Internal_Shdr *section_headers;
-static Elf_Internal_Phdr *program_headers;
-static Elf_Internal_Dyn *dynamic_section;
-static Elf_Internal_Shdr *symtab_shndx_hdr;
+static Elf_Internal_Shdr * section_headers;
+static Elf_Internal_Phdr * program_headers;
+static Elf_Internal_Dyn * dynamic_section;
+static Elf_Internal_Shdr * symtab_shndx_hdr;
static int show_name;
static int do_dynamic;
static int do_syms;
+static int do_dyn_syms;
static int do_reloc;
static int do_sections;
static int do_section_groups;
struct group_list
{
- struct group_list *next;
+ struct group_list * next;
unsigned int section_index;
};
struct group
{
- struct group_list *root;
+ struct group_list * root;
unsigned int group_index;
};
static size_t group_count;
-static struct group *section_groups;
-static struct group **section_headers_groups;
+static struct group * section_groups;
+static struct group ** section_headers_groups;
/* Flag bits indicating particular types of dump. */
#define DISASS_DUMP (1 << 1) /* The -i command line switch. */
#define DEBUG_DUMP (1 << 2) /* The -w command line switch. */
#define STRING_DUMP (1 << 3) /* The -p command line switch. */
+#define RELOC_DUMP (1 << 4) /* The -R command line switch. */
typedef unsigned char dump_type;
/* A linked list of the section names for which dumps were requested. */
struct dump_list_entry
{
- char *name;
+ char * name;
dump_type type;
- struct dump_list_entry *next;
+ struct dump_list_entry * next;
};
-static struct dump_list_entry *dump_sects_byname;
+static struct dump_list_entry * dump_sects_byname;
/* A dynamic array of flags indicating for which sections a dump
has been requested via command line switches. */
}
print_mode;
-static void (*byte_put) (unsigned char *, bfd_vma, int);
+static void (* byte_put) (unsigned char *, bfd_vma, int);
#define UNKNOWN -1
-#define SECTION_NAME(X) \
- ((X) == NULL ? "<none>" \
- : string_table == NULL ? "<no-name>" \
- : ((X)->sh_name >= string_table_length ? "<corrupt>" \
+#define SECTION_NAME(X) \
+ ((X) == NULL ? _("<none>") \
+ : string_table == NULL ? _("<no-name>") \
+ : ((X)->sh_name >= string_table_length ? _("<corrupt>") \
: string_table + (X)->sh_name))
#define DT_VERSIONTAGIDX(tag) (DT_VERNEEDNUM - (tag)) /* Reverse order! */
#define streq(a,b) (strcmp ((a), (b)) == 0)
#define strneq(a,b,n) (strncmp ((a), (b), (n)) == 0)
#define const_strneq(a,b) (strncmp ((a), (b), sizeof (b) - 1) == 0)
+
+#define REMOVE_ARCH_BITS(ADDR) do { \
+ if (elf_header.e_machine == EM_ARM) \
+ (ADDR) &= ~1; \
+ } while (0)
\f
static void *
-get_data (void *var, FILE *file, long offset, size_t size, size_t nmemb,
- const char *reason)
+get_data (void * var, FILE * file, long offset, size_t size, size_t nmemb,
+ const char * reason)
{
- void *mvar;
+ void * mvar;
if (size == 0 || nmemb == 0)
return NULL;
if (fseek (file, archive_file_offset + offset, SEEK_SET))
{
error (_("Unable to seek to 0x%lx for %s\n"),
- archive_file_offset + offset, reason);
+ (unsigned long) archive_file_offset + offset, reason);
return NULL;
}
}
static void
-byte_put_little_endian (unsigned char *field, bfd_vma value, int size)
+byte_put_little_endian (unsigned char * field, bfd_vma value, int size)
{
switch (size)
{
/* Fall through. */
case 4:
field[3] = (value >> 24) & 0xff;
+ /* Fall through. */
+ case 3:
field[2] = (value >> 16) & 0xff;
/* Fall through. */
case 2:
}
}
-#if defined BFD64 && !BFD_HOST_64BIT_LONG && !BFD_HOST_64BIT_LONG_LONG
-static int
-print_dec_vma (bfd_vma vma, int is_signed)
-{
- char buf[40];
- char *bufp = buf;
- int nc = 0;
-
- if (is_signed && (bfd_signed_vma) vma < 0)
- {
- vma = -vma;
- putchar ('-');
- nc = 1;
- }
-
- do
- {
- *bufp++ = '0' + vma % 10;
- vma /= 10;
- }
- while (vma != 0);
- nc += bufp - buf;
-
- while (bufp > buf)
- putchar (*--bufp);
- return nc;
-}
+/* Print a VMA value. */
static int
-print_hex_vma (bfd_vma vma)
+print_vma (bfd_vma vma, print_mode mode)
{
- char buf[32];
- char *bufp = buf;
- int nc;
+ int nc = 0;
- do
+ switch (mode)
{
- char digit = '0' + (vma & 0x0f);
- if (digit > '9')
- digit += 'a' - '0' - 10;
- *bufp++ = digit;
- vma >>= 4;
- }
- while (vma != 0);
- nc = bufp - buf;
-
- while (bufp > buf)
- putchar (*--bufp);
- return nc;
-}
-#endif
+ case FULL_HEX:
+ nc = printf ("0x");
+ /* Drop through. */
-/* Print a VMA value. */
-static int
-print_vma (bfd_vma vma, print_mode mode)
-{
+ case LONG_HEX:
#ifdef BFD64
- if (is_32bit_elf)
+ if (is_32bit_elf)
+ return nc + printf ("%8.8" BFD_VMA_FMT "x", vma);
#endif
- {
- switch (mode)
- {
- case FULL_HEX:
- return printf ("0x%8.8lx", (unsigned long) vma);
+ printf_vma (vma);
+ return nc + 16;
- case LONG_HEX:
- return printf ("%8.8lx", (unsigned long) vma);
+ case DEC_5:
+ if (vma <= 99999)
+ return printf ("%5" BFD_VMA_FMT "d", vma);
+ /* Drop through. */
- case DEC_5:
- if (vma <= 99999)
- return printf ("%5ld", (long) vma);
- /* Drop through. */
-
- case PREFIX_HEX:
- return printf ("0x%lx", (unsigned long) vma);
-
- case HEX:
- return printf ("%lx", (unsigned long) vma);
-
- case DEC:
- return printf ("%ld", (unsigned long) vma);
-
- case UNSIGNED:
- return printf ("%lu", (unsigned long) vma);
- }
- }
-#ifdef BFD64
- else
- {
- int nc = 0;
-
- switch (mode)
- {
- case FULL_HEX:
- nc = printf ("0x");
- /* Drop through. */
-
- case LONG_HEX:
- printf_vma (vma);
- return nc + 16;
-
- case PREFIX_HEX:
- nc = printf ("0x");
- /* Drop through. */
+ case PREFIX_HEX:
+ nc = printf ("0x");
+ /* Drop through. */
- case HEX:
-#if BFD_HOST_64BIT_LONG
- return nc + printf ("%lx", vma);
-#elif BFD_HOST_64BIT_LONG_LONG
-#ifndef __MSVCRT__
- return nc + printf ("%llx", vma);
-#else
- return nc + printf ("%I64x", vma);
-#endif
-#else
- return nc + print_hex_vma (vma);
-#endif
-
- case DEC:
-#if BFD_HOST_64BIT_LONG
- return printf ("%ld", vma);
-#elif BFD_HOST_64BIT_LONG_LONG
-#ifndef __MSVCRT__
- return printf ("%lld", vma);
-#else
- return printf ("%I64d", vma);
-#endif
-#else
- return print_dec_vma (vma, 1);
-#endif
+ case HEX:
+ return nc + printf ("%" BFD_VMA_FMT "x", vma);
- case DEC_5:
-#if BFD_HOST_64BIT_LONG
- if (vma <= 99999)
- return printf ("%5ld", vma);
- else
- return printf ("%#lx", vma);
-#elif BFD_HOST_64BIT_LONG_LONG
-#ifndef __MSVCRT__
- if (vma <= 99999)
- return printf ("%5lld", vma);
- else
- return printf ("%#llx", vma);
-#else
- if (vma <= 99999)
- return printf ("%5I64d", vma);
- else
- return printf ("%#I64x", vma);
-#endif
-#else
- if (vma <= 99999)
- return printf ("%5ld", _bfd_int64_low (vma));
- else
- return print_hex_vma (vma);
-#endif
+ case DEC:
+ return printf ("%" BFD_VMA_FMT "d", vma);
- case UNSIGNED:
-#if BFD_HOST_64BIT_LONG
- return printf ("%lu", vma);
-#elif BFD_HOST_64BIT_LONG_LONG
-#ifndef __MSVCRT__
- return printf ("%llu", vma);
-#else
- return printf ("%I64u", vma);
-#endif
-#else
- return print_dec_vma (vma, 0);
-#endif
- }
+ case UNSIGNED:
+ return printf ("%" BFD_VMA_FMT "u", vma);
}
-#endif
return 0;
}
-/* Display a symbol on stdout. Handles the display of
- non-printing characters.
- If DO_WIDE is not true then format the symbol to be
- at most WIDTH characters, truncating as necessary.
- If WIDTH is negative then format the string to be
- exactly - WIDTH characters, truncating or padding
- as necessary. */
+/* Display a symbol on stdout. Handles the display of non-printing characters.
-static void
-print_symbol (int width, const char *symbol)
+ If DO_WIDE is not true then format the symbol to be at most WIDTH characters,
+ truncating as necessary. If WIDTH is negative then format the string to be
+ exactly - WIDTH characters, truncating or padding as necessary.
+
+ Returns the number of emitted characters. */
+
+static unsigned int
+print_symbol (int width, const char * symbol)
{
- const char * format_string;
const char * c;
+ bfd_boolean extra_padding = FALSE;
+ unsigned int num_printed = 0;
if (do_wide)
{
- format_string = "%.*s";
/* Set the width to a very large value. This simplifies the code below. */
width = INT_MAX;
}
else if (width < 0)
{
- format_string = "%-*.*2s";
/* Keep the width positive. This also helps. */
width = - width;
- }
- else
- {
- format_string = "%-.*s";
+ extra_padding = TRUE;
}
while (width)
{
if (len > width)
len = width;
-
- printf (format_string, len, symbol);
+
+ printf ("%.*s", len, symbol);
width -= len;
+ num_printed += len;
}
if (* c == 0 || width == 0)
printf ("^%c", *c + 0x40);
width -= 2;
+ num_printed += 2;
}
else
{
if (width < 6)
break;
-
+
printf ("<0x%.2x>", *c);
width -= 6;
+ num_printed += 6;
}
symbol = c + 1;
}
+
+ if (extra_padding && width > 0)
+ {
+ /* Fill in the remaining spaces. */
+ printf ("%-*s", width, " ");
+ num_printed += 2;
+ }
+
+ return num_printed;
}
static void
-byte_put_big_endian (unsigned char *field, bfd_vma value, int size)
+byte_put_big_endian (unsigned char * field, bfd_vma value, int size)
{
switch (size)
{
/* Fall through. */
case 4:
field[3] = value & 0xff;
- field[2] = (value >> 8) & 0xff;
- value >>= 16;
+ value >>= 8;
+ /* Fall through. */
+ case 3:
+ field[2] = value & 0xff;
+ value >>= 8;
/* Fall through. */
case 2:
field[1] = value & 0xff;
/* Return a pointer to section NAME, or NULL if no such section exists. */
static Elf_Internal_Shdr *
-find_section (const char *name)
+find_section (const char * name)
{
unsigned int i;
return NULL;
}
+/* Return a pointer to a section containing ADDR, or NULL if no such
+ section exists. */
+
+static Elf_Internal_Shdr *
+find_section_by_address (bfd_vma addr)
+{
+ unsigned int i;
+
+ for (i = 0; i < elf_header.e_shnum; i++)
+ {
+ Elf_Internal_Shdr *sec = section_headers + i;
+ if (addr >= sec->sh_addr && addr < sec->sh_addr + sec->sh_size)
+ return sec;
+ }
+
+ return NULL;
+}
+
+/* Read an unsigned LEB128 encoded value from p. Set *PLEN to the number of
+ bytes read. */
+
+static unsigned long
+read_uleb128 (unsigned char *data, unsigned int *length_return)
+{
+ return read_leb128 (data, length_return, 0);
+}
+
/* Guess the relocation size commonly used by the specific machines. */
static int
case EM_IP2K:
case EM_IP2K_OLD:
case EM_IQ2000:
+ case EM_LATTICEMICO32:
case EM_M32C_OLD:
case EM_M32C:
case EM_M32R:
case EM_NIOS32:
case EM_PPC64:
case EM_PPC:
+ case EM_RX:
case EM_S390:
case EM_S390_OLD:
case EM_SH:
case EM_SPARC32PLUS:
case EM_SPARCV9:
case EM_SPU:
+ case EM_TI_C6000:
case EM_V850:
case EM_CYGNUS_V850:
case EM_VAX:
case EM_X86_64:
+ case EM_L1OM:
case EM_XSTORMY16:
case EM_XTENSA:
case EM_XTENSA_OLD:
+ case EM_MICROBLAZE:
+ case EM_MICROBLAZE_OLD:
return TRUE;
case EM_68HC05:
}
static int
-slurp_rela_relocs (FILE *file,
+slurp_rela_relocs (FILE * file,
unsigned long rel_offset,
unsigned long rel_size,
- Elf_Internal_Rela **relasp,
- unsigned long *nrelasp)
+ Elf_Internal_Rela ** relasp,
+ unsigned long * nrelasp)
{
- Elf_Internal_Rela *relas;
+ Elf_Internal_Rela * relas;
unsigned long nrelas;
unsigned int i;
if (is_32bit_elf)
{
- Elf32_External_Rela *erelas;
+ Elf32_External_Rela * erelas;
- erelas = get_data (NULL, file, rel_offset, 1, rel_size, _("relocs"));
+ erelas = (Elf32_External_Rela *) get_data (NULL, file, rel_offset, 1,
+ rel_size, _("relocs"));
if (!erelas)
return 0;
nrelas = rel_size / sizeof (Elf32_External_Rela);
- relas = cmalloc (nrelas, sizeof (Elf_Internal_Rela));
+ relas = (Elf_Internal_Rela *) cmalloc (nrelas,
+ sizeof (Elf_Internal_Rela));
if (relas == NULL)
{
}
else
{
- Elf64_External_Rela *erelas;
+ Elf64_External_Rela * erelas;
- erelas = get_data (NULL, file, rel_offset, 1, rel_size, _("relocs"));
+ erelas = (Elf64_External_Rela *) get_data (NULL, file, rel_offset, 1,
+ rel_size, _("relocs"));
if (!erelas)
return 0;
nrelas = rel_size / sizeof (Elf64_External_Rela);
- relas = cmalloc (nrelas, sizeof (Elf_Internal_Rela));
+ relas = (Elf_Internal_Rela *) cmalloc (nrelas,
+ sizeof (Elf_Internal_Rela));
if (relas == NULL)
{
relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
relas[i].r_info = BYTE_GET (erelas[i].r_info);
relas[i].r_addend = BYTE_GET (erelas[i].r_addend);
+
+ /* The #ifdef BFD64 below is to prevent a compile time
+ warning. We know that if we do not have a 64 bit data
+ type that we will never execute this code anyway. */
+#ifdef BFD64
+ if (elf_header.e_machine == EM_MIPS
+ && elf_header.e_ident[EI_DATA] != ELFDATA2MSB)
+ {
+ /* In little-endian objects, r_info isn't really a
+ 64-bit little-endian value: it has a 32-bit
+ little-endian symbol index followed by four
+ individual byte fields. Reorder INFO
+ accordingly. */
+ bfd_vma inf = relas[i].r_info;
+ inf = (((inf & 0xffffffff) << 32)
+ | ((inf >> 56) & 0xff)
+ | ((inf >> 40) & 0xff00)
+ | ((inf >> 24) & 0xff0000)
+ | ((inf >> 8) & 0xff000000));
+ relas[i].r_info = inf;
+ }
+#endif /* BFD64 */
}
free (erelas);
}
static int
-slurp_rel_relocs (FILE *file,
+slurp_rel_relocs (FILE * file,
unsigned long rel_offset,
unsigned long rel_size,
- Elf_Internal_Rela **relsp,
- unsigned long *nrelsp)
+ Elf_Internal_Rela ** relsp,
+ unsigned long * nrelsp)
{
- Elf_Internal_Rela *rels;
+ Elf_Internal_Rela * rels;
unsigned long nrels;
unsigned int i;
if (is_32bit_elf)
{
- Elf32_External_Rel *erels;
+ Elf32_External_Rel * erels;
- erels = get_data (NULL, file, rel_offset, 1, rel_size, _("relocs"));
+ erels = (Elf32_External_Rel *) get_data (NULL, file, rel_offset, 1,
+ rel_size, _("relocs"));
if (!erels)
return 0;
nrels = rel_size / sizeof (Elf32_External_Rel);
- rels = cmalloc (nrels, sizeof (Elf_Internal_Rela));
+ rels = (Elf_Internal_Rela *) cmalloc (nrels, sizeof (Elf_Internal_Rela));
if (rels == NULL)
{
}
else
{
- Elf64_External_Rel *erels;
+ Elf64_External_Rel * erels;
- erels = get_data (NULL, file, rel_offset, 1, rel_size, _("relocs"));
+ erels = (Elf64_External_Rel *) get_data (NULL, file, rel_offset, 1,
+ rel_size, _("relocs"));
if (!erels)
return 0;
nrels = rel_size / sizeof (Elf64_External_Rel);
- rels = cmalloc (nrels, sizeof (Elf_Internal_Rela));
+ rels = (Elf_Internal_Rela *) cmalloc (nrels, sizeof (Elf_Internal_Rela));
if (rels == NULL)
{
rels[i].r_offset = BYTE_GET (erels[i].r_offset);
rels[i].r_info = BYTE_GET (erels[i].r_info);
rels[i].r_addend = 0;
+
+ /* The #ifdef BFD64 below is to prevent a compile time
+ warning. We know that if we do not have a 64 bit data
+ type that we will never execute this code anyway. */
+#ifdef BFD64
+ if (elf_header.e_machine == EM_MIPS
+ && elf_header.e_ident[EI_DATA] != ELFDATA2MSB)
+ {
+ /* In little-endian objects, r_info isn't really a
+ 64-bit little-endian value: it has a 32-bit
+ little-endian symbol index followed by four
+ individual byte fields. Reorder INFO
+ accordingly. */
+ bfd_vma inf = rels[i].r_info;
+ inf = (((inf & 0xffffffff) << 32)
+ | ((inf >> 56) & 0xff)
+ | ((inf >> 40) & 0xff00)
+ | ((inf >> 24) & 0xff0000)
+ | ((inf >> 8) & 0xff000000));
+ rels[i].r_info = inf;
+ }
+#endif /* BFD64 */
}
free (erels);
offset. */
static void
-dump_relocations (FILE *file,
+dump_relocations (FILE * file,
unsigned long rel_offset,
unsigned long rel_size,
- Elf_Internal_Sym *symtab,
+ Elf_Internal_Sym * symtab,
unsigned long nsyms,
- char *strtab,
+ char * strtab,
unsigned long strtablen,
int is_rela)
{
unsigned int i;
- Elf_Internal_Rela *rels;
-
+ Elf_Internal_Rela * rels;
if (is_rela == UNKNOWN)
is_rela = guess_is_rela (elf_header.e_machine);
for (i = 0; i < rel_size; i++)
{
- const char *rtype;
+ const char * rtype;
bfd_vma offset;
- bfd_vma info;
+ bfd_vma inf;
bfd_vma symtab_index;
bfd_vma type;
offset = rels[i].r_offset;
- info = rels[i].r_info;
-
- /* The #ifdef BFD64 below is to prevent a compile time warning.
- We know that if we do not have a 64 bit data type that we
- will never execute this code anyway. */
-#ifdef BFD64
- if (!is_32bit_elf
- && elf_header.e_machine == EM_MIPS
- && elf_header.e_ident[EI_DATA] != ELFDATA2MSB)
- {
- /* In little-endian objects, r_info isn't really a 64-bit
- little-endian value: it has a 32-bit little-endian
- symbol index followed by four individual byte fields.
- Reorder INFO accordingly. */
- info = (((info & 0xffffffff) << 32)
- | ((info >> 56) & 0xff)
- | ((info >> 40) & 0xff00)
- | ((info >> 24) & 0xff0000)
- | ((info >> 8) & 0xff000000));
- }
-#endif /* BFD64 */
+ inf = rels[i].r_info;
- type = get_reloc_type (info);
- symtab_index = get_reloc_symindex (info);
+ type = get_reloc_type (inf);
+ symtab_index = get_reloc_symindex (inf);
if (is_32bit_elf)
{
printf ("%8.8lx %8.8lx ",
(unsigned long) offset & 0xffffffff,
- (unsigned long) info & 0xffffffff);
+ (unsigned long) inf & 0xffffffff);
}
else
{
printf (do_wide
? "%16.16lx %16.16lx "
: "%12.12lx %12.12lx ",
- offset, info);
+ offset, inf);
#elif BFD_HOST_64BIT_LONG_LONG
#ifndef __MSVCRT__
printf (do_wide
? "%16.16llx %16.16llx "
: "%12.12llx %12.12llx ",
- offset, info);
+ offset, inf);
#else
printf (do_wide
? "%16.16I64x %16.16I64x "
: "%12.12I64x %12.12I64x ",
- offset, info);
+ offset, inf);
#endif
#else
printf (do_wide
: "%4.4lx%8.8lx %4.4lx%8.8lx ",
_bfd_int64_high (offset),
_bfd_int64_low (offset),
- _bfd_int64_high (info),
- _bfd_int64_low (info));
+ _bfd_int64_high (inf),
+ _bfd_int64_low (inf));
#endif
}
break;
case EM_X86_64:
+ case EM_L1OM:
rtype = elf_x86_64_reloc_type (type);
break;
rtype = elf_xtensa_reloc_type (type);
break;
+ case EM_LATTICEMICO32:
+ rtype = elf_lm32_reloc_type (type);
+ break;
+
case EM_M32C_OLD:
case EM_M32C:
rtype = elf_m32c_reloc_type (type);
case EM_CR16_OLD:
rtype = elf_cr16_reloc_type (type);
break;
+
+ case EM_MICROBLAZE:
+ case EM_MICROBLAZE_OLD:
+ rtype = elf_microblaze_reloc_type (type);
+ break;
+
+ case EM_RX:
+ rtype = elf_rx_reloc_type (type);
+ break;
+
+ case EM_XC16X:
+ case EM_C166:
+ rtype = elf_xc16x_reloc_type (type);
+ break;
+
+ case EM_TI_C6000:
+ rtype = elf_tic6x_reloc_type (type);
+ break;
}
if (rtype == NULL)
else if (symtab_index)
{
if (symtab == NULL || symtab_index >= nsyms)
- printf (" bad symbol index: %08lx", (unsigned long) symtab_index);
+ printf (_(" bad symbol index: %08lx"), (unsigned long) symtab_index);
else
{
- Elf_Internal_Sym *psym;
+ Elf_Internal_Sym * psym;
psym = symtab + symtab_index;
printf (" ");
- print_vma (psym->st_value, LONG_HEX);
- printf (is_32bit_elf ? " " : " ");
+
+ if (ELF_ST_TYPE (psym->st_info) == STT_GNU_IFUNC)
+ {
+ const char * name;
+ unsigned int len;
+ unsigned int width = is_32bit_elf ? 8 : 14;
+
+ /* Relocations against GNU_IFUNC symbols do not use the value
+ of the symbol as the address to relocate against. Instead
+ they invoke the function named by the symbol and use its
+ result as the address for relocation.
+
+ To indicate this to the user, do not display the value of
+ the symbol in the "Symbols's Value" field. Instead show
+ its name followed by () as a hint that the symbol is
+ invoked. */
+
+ if (strtab == NULL
+ || psym->st_name == 0
+ || psym->st_name >= strtablen)
+ name = "??";
+ else
+ name = strtab + psym->st_name;
+
+ len = print_symbol (width, name);
+ printf ("()%-*s", len <= width ? (width + 1) - len : 1, " ");
+ }
+ else
+ {
+ print_vma (psym->st_value, LONG_HEX);
+
+ printf (is_32bit_elf ? " " : " ");
+ }
if (psym->st_name == 0)
{
- const char *sec_name = "<null>";
+ const char * sec_name = "<null>";
char name_buf[40];
if (ELF_ST_TYPE (psym->st_info) == STT_SECTION)
else if (elf_header.e_machine == EM_MIPS
&& psym->st_shndx == SHN_MIPS_SUNDEFINED)
sec_name = "SUNDEF";
- else if (elf_header.e_machine == EM_X86_64
+ else if ((elf_header.e_machine == EM_X86_64
+ || elf_header.e_machine == EM_L1OM)
&& psym->st_shndx == SHN_X86_64_LCOMMON)
sec_name = "LARGE_COMMON";
else if (elf_header.e_machine == EM_IA_64
&& psym->st_shndx == SHN_IA_64_ANSI_COMMON)
sec_name = "ANSI_COM";
else if (elf_header.e_machine == EM_IA_64
- && (elf_header.e_ident[EI_OSABI]
+ && (elf_header.e_ident[EI_OSABI]
== ELFOSABI_OPENVMS)
&& psym->st_shndx == SHN_IA_64_VMS_SYMVEC)
sec_name = "VMS_SYMVEC";
print_symbol (22, strtab + psym->st_name);
if (is_rela)
- printf (" + %lx", (unsigned long) rels[i].r_addend);
+ {
+ long off = (long) (bfd_signed_vma) rels[i].r_addend;
+
+ if (off < 0)
+ printf (" - %lx", - off);
+ else
+ printf (" + %lx", off);
+ }
}
}
else if (is_rela)
if (elf_header.e_machine == EM_SPARCV9
&& rtype != NULL
&& streq (rtype, "R_SPARC_OLO10"))
- printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (info));
+ printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (inf));
putchar ('\n');
#ifdef BFD64
if (! is_32bit_elf && elf_header.e_machine == EM_MIPS)
{
- bfd_vma type2 = ELF64_MIPS_R_TYPE2 (info);
- bfd_vma type3 = ELF64_MIPS_R_TYPE3 (info);
- const char *rtype2 = elf_mips_reloc_type (type2);
- const char *rtype3 = elf_mips_reloc_type (type3);
+ bfd_vma type2 = ELF64_MIPS_R_TYPE2 (inf);
+ bfd_vma type3 = ELF64_MIPS_R_TYPE3 (inf);
+ const char * rtype2 = elf_mips_reloc_type (type2);
+ const char * rtype3 = elf_mips_reloc_type (type3);
printf (" Type2: ");
case DT_MIPS_COMPACT_SIZE: return "MIPS_COMPACT_SIZE";
case DT_MIPS_GP_VALUE: return "MIPS_GP_VALUE";
case DT_MIPS_AUX_DYNAMIC: return "MIPS_AUX_DYNAMIC";
+ case DT_MIPS_PLTGOT: return "MIPS_PLTGOT";
+ case DT_MIPS_RWPLT: return "MIPS_RWPLT";
default:
return NULL;
}
{
switch (type)
{
- case DT_PPC_GOT: return "PPC_GOT";
+ case DT_PPC_GOT: return "PPC_GOT";
+ case DT_PPC_TLSOPT: return "PPC_TLSOPT";
default:
return NULL;
}
{
switch (type)
{
- case DT_PPC64_GLINK: return "PPC64_GLINK";
- case DT_PPC64_OPD: return "PPC64_OPD";
- case DT_PPC64_OPDSZ: return "PPC64_OPDSZ";
+ case DT_PPC64_GLINK: return "PPC64_GLINK";
+ case DT_PPC64_OPD: return "PPC64_OPD";
+ case DT_PPC64_OPDSZ: return "PPC64_OPDSZ";
+ case DT_PPC64_TLSOPT: return "PPC64_TLSOPT";
default:
return NULL;
}
}
}
+static const char *
+get_tic6x_dynamic_type (unsigned long type)
+{
+ switch (type)
+ {
+ case DT_C6000_GSYM_OFFSET: return "C6000_GSYM_OFFSET";
+ case DT_C6000_GSTR_OFFSET: return "C6000_GSTR_OFFSET";
+ case DT_C6000_DSBT_BASE: return "C6000_DSBT_BASE";
+ case DT_C6000_DSBT_SIZE: return "C6000_DSBT_SIZE";
+ case DT_C6000_PREEMPTMAP: return "C6000_PREEMPTMAP";
+ case DT_C6000_DSBT_INDEX: return "C6000_DSBT_INDEX";
+ default:
+ return NULL;
+ }
+}
static const char *
get_dynamic_type (unsigned long type)
default:
if ((type >= DT_LOPROC) && (type <= DT_HIPROC))
{
- const char *result;
+ const char * result;
switch (elf_header.e_machine)
{
case EM_SCORE:
result = get_score_dynamic_type (type);
break;
+ case EM_TI_C6000:
+ result = get_tic6x_dynamic_type (type);
+ break;
default:
result = NULL;
break;
|| (elf_header.e_machine == EM_PARISC
&& (type >= OLD_DT_LOOS) && (type <= OLD_DT_HIOS)))
{
- const char *result;
+ const char * result;
switch (elf_header.e_machine)
{
case EM_ME16: return "Toyota ME16 processor";
case EM_ST100: return "STMicroelectronics ST100 processor";
case EM_TINYJ: return "Advanced Logic Corp. TinyJ embedded processor";
+ case EM_PDSP: return "Sony DSP processor";
+ case EM_PDP10: return "Digital Equipment Corp. PDP-10";
+ case EM_PDP11: return "Digital Equipment Corp. PDP-11";
case EM_FX66: return "Siemens FX66 microcontroller";
case EM_ST9PLUS: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
case EM_ST7: return "STMicroelectronics ST7 8-bit microcontroller";
case EM_HUANY: return "Harvard Universitys's machine-independent object format";
case EM_PRISM: return "Vitesse Prism";
case EM_X86_64: return "Advanced Micro Devices X86-64";
+ case EM_L1OM: return "Intel L1OM";
case EM_S390_OLD:
case EM_S390: return "IBM S/390";
case EM_SCORE: return "SUNPLUS S+Core";
case EM_XSTORMY16: return "Sanyo Xstormy16 CPU core";
case EM_OPENRISC:
case EM_OR32: return "OpenRISC";
+ case EM_ARC_A5: return "ARC International ARCompact processor";
case EM_CRX: return "National Semiconductor CRX microprocessor";
case EM_DLX: return "OpenDLX";
case EM_IP2K_OLD:
case EM_IQ2000: return "Vitesse IQ2000";
case EM_XTENSA_OLD:
case EM_XTENSA: return "Tensilica Xtensa Processor";
+ case EM_VIDEOCORE: return "Alphamosaic VideoCore processor";
+ case EM_TMM_GPP: return "Thompson Multimedia General Purpose Processor";
+ case EM_NS32K: return "National Semiconductor 32000 series";
+ case EM_TPC: return "Tenor Network TPC processor";
+ case EM_ST200: return "STMicroelectronics ST200 microcontroller";
+ case EM_MAX: return "MAX Processor";
+ case EM_CR: return "National Semiconductor CompactRISC";
+ case EM_F2MC16: return "Fujitsu F2MC16";
+ case EM_MSP430: return "Texas Instruments msp430 microcontroller";
+ case EM_LATTICEMICO32: return "Lattice Mico32";
case EM_M32C_OLD:
case EM_M32C: return "Renesas M32c";
case EM_MT: return "Morpho Techologies MT processor";
case EM_BLACKFIN: return "Analog Devices Blackfin";
+ case EM_SE_C33: return "S1C33 Family of Seiko Epson processors";
+ case EM_SEP: return "Sharp embedded microprocessor";
+ case EM_ARCA: return "Arca RISC microprocessor";
+ case EM_UNICORE: return "Unicore";
+ case EM_EXCESS: return "eXcess 16/32/64-bit configurable embedded CPU";
+ case EM_DXP: return "Icera Semiconductor Inc. Deep Execution Processor";
case EM_NIOS32: return "Altera Nios";
case EM_ALTERA_NIOS2: return "Altera Nios II";
+ case EM_C166:
case EM_XC16X: return "Infineon Technologies xc16x";
+ case EM_M16C: return "Renesas M16C series microprocessors";
+ case EM_DSPIC30F: return "Microchip Technology dsPIC30F Digital Signal Controller";
+ case EM_CE: return "Freescale Communication Engine RISC core";
+ case EM_TSK3000: return "Altium TSK3000 core";
+ case EM_RS08: return "Freescale RS08 embedded processor";
+ case EM_ECOG2: return "Cyan Technology eCOG2 microprocessor";
+ case EM_DSP24: return "New Japan Radio (NJR) 24-bit DSP Processor";
+ case EM_VIDEOCORE3: return "Broadcom VideoCore III processor";
+ case EM_SE_C17: return "Seiko Epson C17 family";
+ case EM_TI_C6000: return "Texas Instruments TMS320C6000 DSP family";
+ case EM_TI_C2000: return "Texas Instruments TMS320C2000 DSP family";
+ case EM_TI_C5500: return "Texas Instruments TMS320C55x DSP family";
+ case EM_MMDSP_PLUS: return "STMicroelectronics 64bit VLIW Data Signal Processor";
+ case EM_CYPRESS_M8C: return "Cypress M8C microprocessor";
+ case EM_R32C: return "Renesas R32C series microprocessors";
+ case EM_TRIMEDIA: return "NXP Semiconductors TriMedia architecture family";
+ case EM_QDSP6: return "QUALCOMM DSP6 Processor";
+ case EM_8051: return "Intel 8051 and variants";
+ case EM_STXP7X: return "STMicroelectronics STxP7x family";
+ case EM_NDS32: return "Andes Technology compact code size embedded RISC processor family";
+ case EM_ECOG1X: return "Cyan Technology eCOG1X family";
+ case EM_MAXQ30: return "Dallas Semiconductor MAXQ30 Core microcontrollers";
+ case EM_XIMO16: return "New Japan Radio (NJR) 16-bit DSP Processor";
+ case EM_MANIK: return "M2000 Reconfigurable RISC Microprocessor";
+ case EM_CRAYNV2: return "Cray Inc. NV2 vector architecture";
case EM_CYGNUS_MEP: return "Toshiba MeP Media Engine";
- case EM_CR16:
+ case EM_CR16:
case EM_CR16_OLD: return "National Semiconductor's CR16";
+ case EM_MICROBLAZE: return "Xilinx MicroBlaze";
+ case EM_MICROBLAZE_OLD: return "Xilinx MicroBlaze";
+ case EM_RX: return "Renesas RX";
+ case EM_METAG: return "Imagination Technologies META processor architecture";
+ case EM_MCST_ELBRUS: return "MCST Elbrus general purpose hardware architecture";
+ case EM_ECOG16: return "Cyan Technology eCOG16 family";
+ case EM_ETPU: return "Freescale Extended Time Processing Unit";
+ case EM_SLE9X: return "Infineon Technologies SLE9X core";
+ case EM_AVR32: return "Atmel Corporation 32-bit microprocessor family";
+ case EM_STM8: return "STMicroeletronics STM8 8-bit microcontroller";
+ case EM_TILE64: return "Tilera TILE64 multicore architecture family";
+ case EM_TILEPRO: return "Tilera TILEPro multicore architecture family";
+ case EM_CUDA: return "NVIDIA CUDA architecture";
default:
snprintf (buff, sizeof (buff), _("<unknown>: 0x%x"), e_machine);
return buff;
}
if (unknown)
- strcat (buf,", <unknown>");
+ strcat (buf,_(", <unknown>"));
}
static char *
strcat (buf, ", fido_a");
else
{
- char const *isa = _("unknown");
- char const *mac = _("unknown mac");
- char const *additional = NULL;
+ char const * isa = _("unknown");
+ char const * mac = _("unknown mac");
+ char const * additional = NULL;
switch (e_flags & EF_M68K_CF_ISA_MASK)
{
strcat (buf, ", emb");
if (e_flags & EF_PPC_RELOCATABLE)
- strcat (buf, ", relocatable");
+ strcat (buf, _(", relocatable"));
if (e_flags & EF_PPC_RELOCATABLE_LIB)
- strcat (buf, ", relocatable-lib");
+ strcat (buf, _(", relocatable-lib"));
break;
case EM_V850:
strcat (buf, ", v850");
break;
default:
- strcat (buf, ", unknown v850 architecture variant");
+ strcat (buf, _(", unknown v850 architecture variant"));
break;
}
break;
case E_MIPS_MACH_LS2E: strcat (buf, ", loongson-2e"); break;
case E_MIPS_MACH_LS2F: strcat (buf, ", loongson-2f"); break;
case E_MIPS_MACH_OCTEON: strcat (buf, ", octeon"); break;
+ case E_MIPS_MACH_OCTEON2: strcat (buf, ", octeon2"); break;
+ case E_MIPS_MACH_XLR: strcat (buf, ", xlr"); break;
case 0:
/* We simply ignore the field in this case to avoid confusion:
MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
extension. */
break;
- default: strcat (buf, ", unknown CPU"); break;
+ default: strcat (buf, _(", unknown CPU")); break;
}
switch ((e_flags & EF_MIPS_ABI))
This means it is likely to be an o32 file, but not for
sure. */
break;
- default: strcat (buf, ", unknown ABI"); break;
+ default: strcat (buf, _(", unknown ABI")); break;
}
if (e_flags & EF_MIPS_ARCH_ASE_MDMX)
case E_MIPS_ARCH_32R2: strcat (buf, ", mips32r2"); break;
case E_MIPS_ARCH_64: strcat (buf, ", mips64"); break;
case E_MIPS_ARCH_64R2: strcat (buf, ", mips64r2"); break;
- default: strcat (buf, ", unknown ISA"); break;
+ default: strcat (buf, _(", unknown ISA")); break;
}
break;
case EF_SH2A_SH3_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh3-nommu"); break;
case EF_SH2A_SH4: strcat (buf, ", sh2a-or-sh4"); break;
case EF_SH2A_SH3E: strcat (buf, ", sh2a-or-sh3e"); break;
- default: strcat (buf, ", unknown ISA"); break;
+ default: strcat (buf, _(", unknown ISA")); break;
}
break;
if ((e_flags & EF_VAX_GFLOAT))
strcat (buf, ", G-Float");
break;
+
+ case EM_RX:
+ if (e_flags & E_FLAG_RX_64BIT_DOUBLES)
+ strcat (buf, ", 64-bit doubles");
+ if (e_flags & E_FLAG_RX_DSP)
+ strcat (buf, ", dsp");
+
+ case EM_S390:
+ if (e_flags & EF_S390_HIGH_GPRS)
+ strcat (buf, ", highgprs");
+
+ case EM_TI_C6000:
+ if ((e_flags & EF_C6000_REL))
+ strcat (buf, ", relocatable module");
}
}
case ELFOSABI_OPENBSD: return "UNIX - OpenBSD";
case ELFOSABI_OPENVMS: return "VMS - OpenVMS";
case ELFOSABI_NSK: return "HP - Non-Stop Kernel";
- case ELFOSABI_AROS: return "Amiga Research OS";
- case ELFOSABI_STANDALONE: return _("Standalone App");
- case ELFOSABI_ARM: return "ARM";
+ case ELFOSABI_AROS: return "AROS";
+ case ELFOSABI_FENIXOS: return "FenixOS";
default:
+ if (osabi >= 64)
+ switch (elf_header.e_machine)
+ {
+ case EM_ARM:
+ switch (osabi)
+ {
+ case ELFOSABI_ARM: return "ARM";
+ default:
+ break;
+ }
+ break;
+
+ case EM_MSP430:
+ case EM_MSP430_OLD:
+ switch (osabi)
+ {
+ case ELFOSABI_STANDALONE: return _("Standalone App");
+ default:
+ break;
+ }
+ break;
+
+ case EM_TI_C6000:
+ switch (osabi)
+ {
+ case ELFOSABI_C6000_ELFABI: return _("Bare-metal C6000");
+ case ELFOSABI_C6000_LINUX: return "Linux C6000";
+ default:
+ break;
+ }
+ break;
+
+ default:
+ break;
+ }
snprintf (buff, sizeof (buff), _("<unknown: %x>"), osabi);
return buff;
}
return NULL;
}
+static const char *
+get_tic6x_segment_type (unsigned long type)
+{
+ switch (type)
+ {
+ case PT_C6000_PHATTR: return "C6000_PHATTR";
+ default:
+ break;
+ }
+
+ return NULL;
+}
+
static const char *
get_segment_type (unsigned long p_type)
{
default:
if ((p_type >= PT_LOPROC) && (p_type <= PT_HIPROC))
{
- const char *result;
+ const char * result;
switch (elf_header.e_machine)
{
case EM_IA_64:
result = get_ia64_segment_type (p_type);
break;
+ case EM_TI_C6000:
+ result = get_tic6x_segment_type (p_type);
+ break;
default:
result = NULL;
break;
}
else if ((p_type >= PT_LOOS) && (p_type <= PT_HIOS))
{
- const char *result;
+ const char * result;
switch (elf_header.e_machine)
{
{
switch (sh_type)
{
- case SHT_ARM_EXIDX:
- return "ARM_EXIDX";
- case SHT_ARM_PREEMPTMAP:
- return "ARM_PREEMPTMAP";
- case SHT_ARM_ATTRIBUTES:
- return "ARM_ATTRIBUTES";
+ case SHT_ARM_EXIDX: return "ARM_EXIDX";
+ case SHT_ARM_PREEMPTMAP: return "ARM_PREEMPTMAP";
+ case SHT_ARM_ATTRIBUTES: return "ARM_ATTRIBUTES";
+ case SHT_ARM_DEBUGOVERLAY: return "ARM_DEBUGOVERLAY";
+ case SHT_ARM_OVERLAYSECTION: return "ARM_OVERLAYSECTION";
+ default:
+ break;
+ }
+ return NULL;
+}
+
+static const char *
+get_tic6x_section_type_name (unsigned int sh_type)
+{
+ switch (sh_type)
+ {
+ case SHT_C6000_UNWIND:
+ return "C6000_UNWIND";
+ case SHT_C6000_PREEMPTMAP:
+ return "C6000_PREEMPTMAP";
+ case SHT_C6000_ATTRIBUTES:
+ return "C6000_ATTRIBUTES";
+ case SHT_TI_ICODE:
+ return "TI_ICODE";
+ case SHT_TI_XREF:
+ return "TI_XREF";
+ case SHT_TI_HANDLER:
+ return "TI_HANDLER";
+ case SHT_TI_INITINFO:
+ return "TI_INITINFO";
+ case SHT_TI_PHATTRS:
+ return "TI_PHATTRS";
default:
break;
}
default:
if ((sh_type >= SHT_LOPROC) && (sh_type <= SHT_HIPROC))
{
- const char *result;
+ const char * result;
switch (elf_header.e_machine)
{
result = get_ia64_section_type_name (sh_type);
break;
case EM_X86_64:
+ case EM_L1OM:
result = get_x86_64_section_type_name (sh_type);
break;
case EM_ARM:
result = get_arm_section_type_name (sh_type);
break;
+ case EM_TI_C6000:
+ result = get_tic6x_section_type_name (sh_type);
+ break;
default:
result = NULL;
break;
}
else if ((sh_type >= SHT_LOOS) && (sh_type <= SHT_HIOS))
{
- const char *result;
+ const char * result;
switch (elf_header.e_machine)
{
}
#define OPTION_DEBUG_DUMP 512
+#define OPTION_DYN_SYMS 513
static struct option options[] =
{
{"full-section-name",no_argument, 0, 'N'},
{"symbols", no_argument, 0, 's'},
{"syms", no_argument, 0, 's'},
+ {"dyn-syms", no_argument, 0, OPTION_DYN_SYMS},
{"relocs", no_argument, 0, 'r'},
{"notes", no_argument, 0, 'n'},
{"dynamic", no_argument, 0, 'd'},
{"unwind", no_argument, 0, 'u'},
{"archive-index", no_argument, 0, 'c'},
{"hex-dump", required_argument, 0, 'x'},
- {"debug-dump", optional_argument, 0, OPTION_DEBUG_DUMP},
+ {"relocated-dump", required_argument, 0, 'R'},
{"string-dump", required_argument, 0, 'p'},
#ifdef SUPPORT_DISASSEMBLY
{"instruction-dump", required_argument, 0, 'i'},
#endif
+ {"debug-dump", optional_argument, 0, OPTION_DEBUG_DUMP},
{"version", no_argument, 0, 'v'},
{"wide", no_argument, 0, 'W'},
};
static void
-usage (FILE *stream)
+usage (FILE * stream)
{
fprintf (stream, _("Usage: readelf <option(s)> elf-file(s)\n"));
fprintf (stream, _(" Display information about the contents of ELF format files\n"));
-t --section-details Display the section details\n\
-e --headers Equivalent to: -h -l -S\n\
-s --syms Display the symbol table\n\
- --symbols An alias for --syms\n\
+ --symbols An alias for --syms\n\
+ --dyn-syms Display the dynamic symbol table\n\
-n --notes Display the core notes (if present)\n\
-r --relocs Display the relocations (if present)\n\
-u --unwind Display the unwind info (if present)\n\
Dump the contents of section <number|name> as bytes\n\
-p --string-dump=<number|name>\n\
Dump the contents of section <number|name> as strings\n\
- -w[lLiaprmfFsoR] or\n\
- --debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,=str,=loc,=Ranges]\n\
+ -R --relocated-dump=<number|name>\n\
+ Dump the contents of section <number|name> as relocated bytes\n\
+ -w[lLiaprmfFsoRt] or\n\
+ --debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
+ =frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
+ =trace_info,=trace_abbrev,=trace_aranges]\n\
Display the contents of DWARF2 debug sections\n"));
#ifdef SUPPORT_DISASSEMBLY
fprintf (stream, _("\
{
if (section >= num_dump_sects)
{
- dump_type *new_dump_sects;
+ dump_type * new_dump_sects;
- new_dump_sects = calloc (section + 1, sizeof (* dump_sects));
+ new_dump_sects = (dump_type *) calloc (section + 1,
+ sizeof (* dump_sects));
if (new_dump_sects == NULL)
error (_("Out of memory allocating dump request table.\n"));
/* Request a dump by section name. */
static void
-request_dump_byname (const char *section, dump_type type)
+request_dump_byname (const char * section, dump_type type)
{
- struct dump_list_entry *new_request;
+ struct dump_list_entry * new_request;
- new_request = malloc (sizeof (struct dump_list_entry));
+ new_request = (struct dump_list_entry *)
+ malloc (sizeof (struct dump_list_entry));
if (!new_request)
error (_("Out of memory allocating dump request table.\n"));
dump_sects_byname = new_request;
}
+static inline void
+request_dump (dump_type type)
+{
+ int section;
+ char * cp;
+
+ do_dump++;
+ section = strtoul (optarg, & cp, 0);
+
+ if (! *cp && section >= 0)
+ request_dump_bynumber (section, type);
+ else
+ request_dump_byname (optarg, type);
+}
+
+
static void
-parse_args (int argc, char **argv)
+parse_args (int argc, char ** argv)
{
int c;
usage (stderr);
while ((c = getopt_long
- (argc, argv, "ADHINSVWacdeghi:lnp:rstuvw::x:", options, NULL)) != EOF)
+ (argc, argv, "ADHINR:SVWacdeghi:lnp:rstuvw::x:", options, NULL)) != EOF)
{
- char *cp;
- int section;
-
switch (c)
{
case 0:
do_archive_index++;
break;
case 'x':
- do_dump++;
- section = strtoul (optarg, & cp, 0);
- if (! *cp && section >= 0)
- request_dump_bynumber (section, HEX_DUMP);
- else
- request_dump_byname (optarg, HEX_DUMP);
+ request_dump (HEX_DUMP);
break;
case 'p':
+ request_dump (STRING_DUMP);
+ break;
+ case 'R':
+ request_dump (RELOC_DUMP);
+ break;
+ case 'w':
do_dump++;
- section = strtoul (optarg, & cp, 0);
- if (! *cp && section >= 0)
- request_dump_bynumber (section, STRING_DUMP);
+ if (optarg == 0)
+ {
+ do_debugging = 1;
+ dwarf_select_sections_all ();
+ }
else
- request_dump_byname (optarg, STRING_DUMP);
+ {
+ do_debugging = 0;
+ dwarf_select_sections_by_letters (optarg);
+ }
break;
- case 'w':
+ case OPTION_DEBUG_DUMP:
do_dump++;
if (optarg == 0)
do_debugging = 1;
else
{
- unsigned int index = 0;
-
do_debugging = 0;
-
- while (optarg[index])
- switch (optarg[index++])
- {
- case 'i':
- do_debug_info = 1;
- break;
-
- case 'a':
- do_debug_abbrevs = 1;
- break;
-
- case 'l':
- do_debug_lines = 1;
- break;
-
- case 'L':
- do_debug_lines_decoded = 1;
- break;
-
- case 'p':
- do_debug_pubnames = 1;
- break;
-
- case 'r':
- do_debug_aranges = 1;
- break;
-
- case 'R':
- do_debug_ranges = 1;
- break;
-
- case 'F':
- do_debug_frames_interp = 1;
- case 'f':
- do_debug_frames = 1;
- break;
-
- case 'm':
- do_debug_macinfo = 1;
- break;
-
- case 's':
- do_debug_str = 1;
- break;
-
- case 'o':
- do_debug_loc = 1;
- break;
-
- default:
- warn (_("Unrecognized debug option '%s'\n"), optarg);
- break;
- }
+ dwarf_select_sections_by_names (optarg);
}
break;
- case OPTION_DEBUG_DUMP:
- do_dump++;
- if (optarg == 0)
- do_debugging = 1;
- else
- {
- typedef struct
- {
- const char * option;
- int * variable;
- }
- debug_dump_long_opts;
-
- debug_dump_long_opts opts_table [] =
- {
- /* Please keep this table alpha- sorted. */
- { "Ranges", & do_debug_ranges },
- { "abbrev", & do_debug_abbrevs },
- { "aranges", & do_debug_aranges },
- { "frames", & do_debug_frames },
- { "frames-interp", & do_debug_frames_interp },
- { "info", & do_debug_info },
- { "line", & do_debug_lines }, /* For backwards compatibility. */
- { "rawline", & do_debug_lines },
- { "decodedline", & do_debug_lines_decoded },
- { "loc", & do_debug_loc },
- { "macro", & do_debug_macinfo },
- { "pubnames", & do_debug_pubnames },
- /* This entry is for compatability
- with earlier versions of readelf. */
- { "ranges", & do_debug_aranges },
- { "str", & do_debug_str },
- { NULL, NULL }
- };
-
- const char *p;
-
- do_debugging = 0;
-
- p = optarg;
- while (*p)
- {
- debug_dump_long_opts * entry;
-
- for (entry = opts_table; entry->option; entry++)
- {
- size_t len = strlen (entry->option);
-
- if (strneq (p, entry->option, len)
- && (p[len] == ',' || p[len] == '\0'))
- {
- * entry->variable = 1;
-
- /* The --debug-dump=frames-interp option also
- enables the --debug-dump=frames option. */
- if (do_debug_frames_interp)
- do_debug_frames = 1;
-
- p += len;
- break;
- }
- }
-
- if (entry->option == NULL)
- {
- warn (_("Unrecognized debug option '%s'\n"), p);
- p = strchr (p, ',');
- if (p == NULL)
- break;
- }
-
- if (*p == ',')
- p++;
- }
- }
+ case OPTION_DYN_SYMS:
+ do_dyn_syms++;
break;
#ifdef SUPPORT_DISASSEMBLY
case 'i':
- do_dump++;
- section = strtoul (optarg, & cp, 0);
- if (! *cp && section >= 0)
- request_dump_bynumber (section, DISASS_DUMP);
- else
- request_dump_byname (optarg, DISASS_DUMP);
+ request_dump (DISASS_DUMP);
+ break;
#endif
case 'v':
print_version (program_name);
if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
&& !do_segments && !do_header && !do_dump && !do_version
&& !do_histogram && !do_debugging && !do_arch && !do_notes
- && !do_section_groups && !do_archive_index)
+ && !do_section_groups && !do_archive_index
+ && !do_dyn_syms)
usage (stderr);
else if (argc < 3)
{
(elf_header.e_ident[EI_VERSION] == EV_CURRENT
? "(current)"
: (elf_header.e_ident[EI_VERSION] != EV_NONE
- ? "<unknown: %lx>"
+ ? _("<unknown: %lx>")
: "")));
printf (_(" OS/ABI: %s\n"),
get_osabi_name (elf_header.e_ident[EI_OSABI]));
(long) elf_header.e_ehsize);
printf (_(" Size of program headers: %ld (bytes)\n"),
(long) elf_header.e_phentsize);
- printf (_(" Number of program headers: %ld\n"),
+ printf (_(" Number of program headers: %ld"),
(long) elf_header.e_phnum);
+ if (section_headers != NULL
+ && elf_header.e_phnum == PN_XNUM
+ && section_headers[0].sh_info != 0)
+ printf (_(" (%ld)"), (long) section_headers[0].sh_info);
+ putc ('\n', stdout);
printf (_(" Size of section headers: %ld (bytes)\n"),
(long) elf_header.e_shentsize);
printf (_(" Number of section headers: %ld"),
if (section_headers != NULL
&& elf_header.e_shstrndx == (SHN_XINDEX & 0xffff))
printf (" (%u)", section_headers[0].sh_link);
- else if (elf_header.e_shstrndx >= elf_header.e_shnum)
- printf (" <corrupt: out of range>");
+ else if (elf_header.e_shstrndx != SHN_UNDEF
+ && elf_header.e_shstrndx >= elf_header.e_shnum)
+ printf (_(" <corrupt: out of range>"));
putc ('\n', stdout);
}
if (section_headers != NULL)
{
+ if (elf_header.e_phnum == PN_XNUM
+ && section_headers[0].sh_info != 0)
+ elf_header.e_phnum = section_headers[0].sh_info;
if (elf_header.e_shnum == SHN_UNDEF)
elf_header.e_shnum = section_headers[0].sh_size;
if (elf_header.e_shstrndx == (SHN_XINDEX & 0xffff))
static int
-get_32bit_program_headers (FILE *file, Elf_Internal_Phdr *program_headers)
+get_32bit_program_headers (FILE * file, Elf_Internal_Phdr * pheaders)
{
- Elf32_External_Phdr *phdrs;
- Elf32_External_Phdr *external;
- Elf_Internal_Phdr *internal;
+ Elf32_External_Phdr * phdrs;
+ Elf32_External_Phdr * external;
+ Elf_Internal_Phdr * internal;
unsigned int i;
- phdrs = get_data (NULL, file, elf_header.e_phoff,
- elf_header.e_phentsize, elf_header.e_phnum,
- _("program headers"));
+ phdrs = (Elf32_External_Phdr *) get_data (NULL, file, elf_header.e_phoff,
+ elf_header.e_phentsize,
+ elf_header.e_phnum,
+ _("program headers"));
if (!phdrs)
return 0;
- for (i = 0, internal = program_headers, external = phdrs;
+ for (i = 0, internal = pheaders, external = phdrs;
i < elf_header.e_phnum;
i++, internal++, external++)
{
}
static int
-get_64bit_program_headers (FILE *file, Elf_Internal_Phdr *program_headers)
+get_64bit_program_headers (FILE * file, Elf_Internal_Phdr * pheaders)
{
- Elf64_External_Phdr *phdrs;
- Elf64_External_Phdr *external;
- Elf_Internal_Phdr *internal;
+ Elf64_External_Phdr * phdrs;
+ Elf64_External_Phdr * external;
+ Elf_Internal_Phdr * internal;
unsigned int i;
- phdrs = get_data (NULL, file, elf_header.e_phoff,
- elf_header.e_phentsize, elf_header.e_phnum,
- _("program headers"));
+ phdrs = (Elf64_External_Phdr *) get_data (NULL, file, elf_header.e_phoff,
+ elf_header.e_phentsize,
+ elf_header.e_phnum,
+ _("program headers"));
if (!phdrs)
return 0;
- for (i = 0, internal = program_headers, external = phdrs;
+ for (i = 0, internal = pheaders, external = phdrs;
i < elf_header.e_phnum;
i++, internal++, external++)
{
/* Returns 1 if the program headers were read into `program_headers'. */
static int
-get_program_headers (FILE *file)
+get_program_headers (FILE * file)
{
- Elf_Internal_Phdr *phdrs;
+ Elf_Internal_Phdr * phdrs;
/* Check cache of prior read. */
if (program_headers != NULL)
return 1;
- phdrs = cmalloc (elf_header.e_phnum, sizeof (Elf_Internal_Phdr));
+ phdrs = (Elf_Internal_Phdr *) cmalloc (elf_header.e_phnum,
+ sizeof (Elf_Internal_Phdr));
if (phdrs == NULL)
{
/* Returns 1 if the program headers were loaded. */
static int
-process_program_headers (FILE *file)
+process_program_headers (FILE * file)
{
- Elf_Internal_Phdr *segment;
+ Elf_Internal_Phdr * segment;
unsigned int i;
if (elf_header.e_phnum == 0)
a section header table, we can easily locate it. */
if (section_headers != NULL)
{
- Elf_Internal_Shdr *sec;
+ Elf_Internal_Shdr * sec;
sec = find_section (".dynamic");
if (sec == NULL || sec->sh_size == 0)
for (i = 0; i < elf_header.e_phnum; i++)
{
unsigned int j;
- Elf_Internal_Shdr *section;
+ Elf_Internal_Shdr * section;
segment = program_headers + i;
section = section_headers + 1;
for (j = 1; j < elf_header.e_shnum; j++, section++)
{
- if (ELF_IS_SECTION_IN_SEGMENT_MEMORY(section, segment))
+ if (ELF_SECTION_SIZE (section, segment) != 0
+ && ELF_SECTION_IN_SEGMENT (section, segment))
printf ("%s ", SECTION_NAME (section));
}
/* Find the file offset corresponding to VMA by using the program headers. */
static long
-offset_from_vma (FILE *file, bfd_vma vma, bfd_size_type size)
+offset_from_vma (FILE * file, bfd_vma vma, bfd_size_type size)
{
- Elf_Internal_Phdr *seg;
+ Elf_Internal_Phdr * seg;
if (! get_program_headers (file))
{
}
warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
- (long) vma);
+ (unsigned long) vma);
return (long) vma;
}
static int
-get_32bit_section_headers (FILE *file, unsigned int num)
+get_32bit_section_headers (FILE * file, unsigned int num)
{
- Elf32_External_Shdr *shdrs;
- Elf_Internal_Shdr *internal;
+ Elf32_External_Shdr * shdrs;
+ Elf_Internal_Shdr * internal;
unsigned int i;
- shdrs = get_data (NULL, file, elf_header.e_shoff,
- elf_header.e_shentsize, num, _("section headers"));
+ shdrs = (Elf32_External_Shdr *) get_data (NULL, file, elf_header.e_shoff,
+ elf_header.e_shentsize, num,
+ _("section headers"));
if (!shdrs)
return 0;
- section_headers = cmalloc (num, sizeof (Elf_Internal_Shdr));
+ section_headers = (Elf_Internal_Shdr *) cmalloc (num,
+ sizeof (Elf_Internal_Shdr));
if (section_headers == NULL)
{
}
static int
-get_64bit_section_headers (FILE *file, unsigned int num)
+get_64bit_section_headers (FILE * file, unsigned int num)
{
- Elf64_External_Shdr *shdrs;
- Elf_Internal_Shdr *internal;
+ Elf64_External_Shdr * shdrs;
+ Elf_Internal_Shdr * internal;
unsigned int i;
- shdrs = get_data (NULL, file, elf_header.e_shoff,
- elf_header.e_shentsize, num, _("section headers"));
+ shdrs = (Elf64_External_Shdr *) get_data (NULL, file, elf_header.e_shoff,
+ elf_header.e_shentsize, num,
+ _("section headers"));
if (!shdrs)
return 0;
- section_headers = cmalloc (num, sizeof (Elf_Internal_Shdr));
+ section_headers = (Elf_Internal_Shdr *) cmalloc (num,
+ sizeof (Elf_Internal_Shdr));
if (section_headers == NULL)
{
}
static Elf_Internal_Sym *
-get_32bit_elf_symbols (FILE *file, Elf_Internal_Shdr *section)
+get_32bit_elf_symbols (FILE * file, Elf_Internal_Shdr * section)
{
unsigned long number;
- Elf32_External_Sym *esyms;
- Elf_External_Sym_Shndx *shndx;
- Elf_Internal_Sym *isyms;
- Elf_Internal_Sym *psym;
+ Elf32_External_Sym * esyms;
+ Elf_External_Sym_Shndx * shndx;
+ Elf_Internal_Sym * isyms;
+ Elf_Internal_Sym * psym;
unsigned int j;
- esyms = get_data (NULL, file, section->sh_offset, 1, section->sh_size,
- _("symbols"));
+ esyms = (Elf32_External_Sym *) get_data (NULL, file, section->sh_offset, 1,
+ section->sh_size, _("symbols"));
if (!esyms)
return NULL;
&& (symtab_shndx_hdr->sh_link
== (unsigned long) (section - section_headers)))
{
- shndx = get_data (NULL, file, symtab_shndx_hdr->sh_offset,
- 1, symtab_shndx_hdr->sh_size, _("symtab shndx"));
+ shndx = (Elf_External_Sym_Shndx *) get_data (NULL, file,
+ symtab_shndx_hdr->sh_offset,
+ 1, symtab_shndx_hdr->sh_size,
+ _("symtab shndx"));
if (!shndx)
{
free (esyms);
}
number = section->sh_size / section->sh_entsize;
- isyms = cmalloc (number, sizeof (Elf_Internal_Sym));
+ isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
if (isyms == NULL)
{
}
static Elf_Internal_Sym *
-get_64bit_elf_symbols (FILE *file, Elf_Internal_Shdr *section)
+get_64bit_elf_symbols (FILE * file, Elf_Internal_Shdr * section)
{
unsigned long number;
- Elf64_External_Sym *esyms;
- Elf_External_Sym_Shndx *shndx;
- Elf_Internal_Sym *isyms;
- Elf_Internal_Sym *psym;
+ Elf64_External_Sym * esyms;
+ Elf_External_Sym_Shndx * shndx;
+ Elf_Internal_Sym * isyms;
+ Elf_Internal_Sym * psym;
unsigned int j;
- esyms = get_data (NULL, file, section->sh_offset, 1, section->sh_size,
- _("symbols"));
+ esyms = (Elf64_External_Sym *) get_data (NULL, file, section->sh_offset, 1,
+ section->sh_size, _("symbols"));
if (!esyms)
return NULL;
&& (symtab_shndx_hdr->sh_link
== (unsigned long) (section - section_headers)))
{
- shndx = get_data (NULL, file, symtab_shndx_hdr->sh_offset,
- 1, symtab_shndx_hdr->sh_size, _("symtab shndx"));
+ shndx = (Elf_External_Sym_Shndx *) get_data (NULL, file,
+ symtab_shndx_hdr->sh_offset,
+ 1, symtab_shndx_hdr->sh_size,
+ _("symtab shndx"));
if (!shndx)
{
free (esyms);
}
number = section->sh_size / section->sh_entsize;
- isyms = cmalloc (number, sizeof (Elf_Internal_Sym));
+ isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
if (isyms == NULL)
{
get_elf_section_flags (bfd_vma sh_flags)
{
static char buff[1024];
- char *p = buff;
+ char * p = buff;
int field_size = is_32bit_elf ? 8 : 16;
- int index, size = sizeof (buff) - (field_size + 4 + 1);
+ int sindex;
+ int size = sizeof (buff) - (field_size + 4 + 1);
bfd_vma os_flags = 0;
bfd_vma proc_flags = 0;
bfd_vma unknown_flags = 0;
static const struct
{
- const char *str;
+ const char * str;
int len;
}
flags [] =
{
- { "WRITE", 5 },
- { "ALLOC", 5 },
- { "EXEC", 4 },
- { "MERGE", 5 },
- { "STRINGS", 7 },
- { "INFO LINK", 9 },
- { "LINK ORDER", 10 },
- { "OS NONCONF", 10 },
- { "GROUP", 5 },
- { "TLS", 3 },
- /* IA-64 specific. */
- { "SHORT", 5 },
- { "NORECOV", 7 },
- /* IA-64 OpenVMS specific. */
- { "VMS_GLOBAL", 10 },
- { "VMS_OVERLAID", 12 },
- { "VMS_SHARED", 10 },
- { "VMS_VECTOR", 10 },
- { "VMS_ALLOC_64BIT", 15 },
- { "VMS_PROTECTED", 13}
+ /* 0 */ { STRING_COMMA_LEN ("WRITE") },
+ /* 1 */ { STRING_COMMA_LEN ("ALLOC") },
+ /* 2 */ { STRING_COMMA_LEN ("EXEC") },
+ /* 3 */ { STRING_COMMA_LEN ("MERGE") },
+ /* 4 */ { STRING_COMMA_LEN ("STRINGS") },
+ /* 5 */ { STRING_COMMA_LEN ("INFO LINK") },
+ /* 6 */ { STRING_COMMA_LEN ("LINK ORDER") },
+ /* 7 */ { STRING_COMMA_LEN ("OS NONCONF") },
+ /* 8 */ { STRING_COMMA_LEN ("GROUP") },
+ /* 9 */ { STRING_COMMA_LEN ("TLS") },
+ /* IA-64 specific. */
+ /* 10 */ { STRING_COMMA_LEN ("SHORT") },
+ /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
+ /* IA-64 OpenVMS specific. */
+ /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
+ /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
+ /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
+ /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
+ /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
+ /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
+ /* Generic. */
+ /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
+ /* SPARC specific. */
+ /* 19 */ { STRING_COMMA_LEN ("ORDERED") }
};
if (do_section_details)
{
switch (flag)
{
- case SHF_WRITE: index = 0; break;
- case SHF_ALLOC: index = 1; break;
- case SHF_EXECINSTR: index = 2; break;
- case SHF_MERGE: index = 3; break;
- case SHF_STRINGS: index = 4; break;
- case SHF_INFO_LINK: index = 5; break;
- case SHF_LINK_ORDER: index = 6; break;
- case SHF_OS_NONCONFORMING: index = 7; break;
- case SHF_GROUP: index = 8; break;
- case SHF_TLS: index = 9; break;
+ case SHF_WRITE: sindex = 0; break;
+ case SHF_ALLOC: sindex = 1; break;
+ case SHF_EXECINSTR: sindex = 2; break;
+ case SHF_MERGE: sindex = 3; break;
+ case SHF_STRINGS: sindex = 4; break;
+ case SHF_INFO_LINK: sindex = 5; break;
+ case SHF_LINK_ORDER: sindex = 6; break;
+ case SHF_OS_NONCONFORMING: sindex = 7; break;
+ case SHF_GROUP: sindex = 8; break;
+ case SHF_TLS: sindex = 9; break;
+ case SHF_EXCLUDE: sindex = 18; break;
default:
- index = -1;
- if (elf_header.e_machine == EM_IA_64)
+ sindex = -1;
+ switch (elf_header.e_machine)
{
+ case EM_IA_64:
if (flag == SHF_IA_64_SHORT)
- index = 10;
+ sindex = 10;
else if (flag == SHF_IA_64_NORECOV)
- index = 11;
+ sindex = 11;
#ifdef BFD64
else if (elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
switch (flag)
{
- case SHF_IA_64_VMS_GLOBAL: index = 12; break;
- case SHF_IA_64_VMS_OVERLAID: index = 13; break;
- case SHF_IA_64_VMS_SHARED: index = 14; break;
- case SHF_IA_64_VMS_VECTOR: index = 15; break;
- case SHF_IA_64_VMS_ALLOC_64BIT: index = 16; break;
- case SHF_IA_64_VMS_PROTECTED: index = 17; break;
+ case SHF_IA_64_VMS_GLOBAL: sindex = 12; break;
+ case SHF_IA_64_VMS_OVERLAID: sindex = 13; break;
+ case SHF_IA_64_VMS_SHARED: sindex = 14; break;
+ case SHF_IA_64_VMS_VECTOR: sindex = 15; break;
+ case SHF_IA_64_VMS_ALLOC_64BIT: sindex = 16; break;
+ case SHF_IA_64_VMS_PROTECTED: sindex = 17; break;
default: break;
}
#endif
+ break;
+
+ case EM_386:
+ case EM_486:
+ case EM_X86_64:
+ case EM_L1OM:
+ case EM_OLD_SPARCV9:
+ case EM_SPARC32PLUS:
+ case EM_SPARCV9:
+ case EM_SPARC:
+ if (flag == SHF_ORDERED)
+ sindex = 19;
+ break;
+ default:
+ break;
}
- break;
}
- if (index != -1)
+ if (sindex != -1)
{
if (p != buff + field_size + 4)
{
*p++ = ' ';
}
- size -= flags [index].len;
- p = stpcpy (p, flags [index].str);
+ size -= flags [sindex].len;
+ p = stpcpy (p, flags [sindex].str);
}
else if (flag & SHF_MASKOS)
os_flags |= flag;
case SHF_OS_NONCONFORMING: *p = 'O'; break;
case SHF_GROUP: *p = 'G'; break;
case SHF_TLS: *p = 'T'; break;
+ case SHF_EXCLUDE: *p = 'E'; break;
default:
- if (elf_header.e_machine == EM_X86_64
+ if ((elf_header.e_machine == EM_X86_64
+ || elf_header.e_machine == EM_L1OM)
&& flag == SHF_X86_64_LARGE)
*p = 'l';
else if (flag & SHF_MASKOS)
*p++ = ',';
*p++ = ' ';
}
- sprintf (p, "UNKNOWN (%*.*lx)", field_size, field_size,
+ sprintf (p, _("UNKNOWN (%*.*lx)"), field_size, field_size,
(unsigned long) unknown_flags);
p += 10 + field_size;
}
}
static int
-process_section_headers (FILE *file)
+process_section_headers (FILE * file)
{
- Elf_Internal_Shdr *section;
+ Elf_Internal_Shdr * section;
unsigned int i;
section_headers = NULL;
if (section->sh_size != 0)
{
- string_table = get_data (NULL, file, section->sh_offset,
- 1, section->sh_size, _("string table"));
+ string_table = (char *) get_data (NULL, file, section->sh_offset,
+ 1, section->sh_size,
+ _("string table"));
string_table_length = string_table != NULL ? section->sh_size : 0;
}
i < elf_header.e_shnum;
i++, section++)
{
- char *name = SECTION_NAME (section);
+ char * name = SECTION_NAME (section);
if (section->sh_type == SHT_DYNSYM)
{
continue;
}
- dynamic_strings = get_data (NULL, file, section->sh_offset,
- 1, section->sh_size, _("dynamic strings"));
+ dynamic_strings = (char *) get_data (NULL, file, section->sh_offset,
+ 1, section->sh_size,
+ _("dynamic strings"));
dynamic_strings_length = section->sh_size;
}
else if (section->sh_type == SHT_SYMTAB_SHNDX)
else if (section->sh_type == SHT_RELA)
CHECK_ENTSIZE (section, i, Rela);
else if ((do_debugging || do_debug_info || do_debug_abbrevs
- || do_debug_lines || do_debug_lines_decoded || do_debug_pubnames
- || do_debug_aranges || do_debug_frames || do_debug_macinfo
+ || do_debug_lines || do_debug_pubnames || do_debug_pubtypes
+ || do_debug_aranges || do_debug_frames || do_debug_macinfo
|| do_debug_str || do_debug_loc || do_debug_ranges)
&& (const_strneq (name, ".debug_")
|| const_strneq (name, ".zdebug_")))
if (do_debugging
|| (do_debug_info && streq (name, "info"))
+ || (do_debug_info && streq (name, "types"))
|| (do_debug_abbrevs && streq (name, "abbrev"))
- || ((do_debug_lines || do_debug_lines_decoded)
- && streq (name, "line"))
+ || (do_debug_lines && streq (name, "line"))
|| (do_debug_pubnames && streq (name, "pubnames"))
+ || (do_debug_pubtypes && streq (name, "pubtypes"))
|| (do_debug_aranges && streq (name, "aranges"))
|| (do_debug_ranges && streq (name, "ranges"))
|| (do_debug_frames && streq (name, "frame"))
request_dump_bynumber (i, DEBUG_DUMP);
else if (do_debug_frames && streq (name, ".eh_frame"))
request_dump_bynumber (i, DEBUG_DUMP);
+ /* Trace sections for Itanium VMS. */
+ else if ((do_debugging || do_trace_info || do_trace_abbrevs
+ || do_trace_aranges)
+ && const_strneq (name, ".trace_"))
+ {
+ name += sizeof (".trace_") - 1;
+
+ if (do_debugging
+ || (do_trace_info && streq (name, "info"))
+ || (do_trace_abbrevs && streq (name, "abbrev"))
+ || (do_trace_aranges && streq (name, "aranges"))
+ )
+ request_dump_bynumber (i, DEBUG_DUMP);
+ }
+
}
if (! do_sections)
get_section_type_name (section->sh_type));
}
else
- printf (" [%2u] %-17.17s %-15.15s ",
+ printf ((do_wide ? " [%2u] %-17s %-15s "
+ : " [%2u] %-17.17s %-15.15s "),
i,
SECTION_NAME (section),
get_section_type_name (section->sh_type));
if (is_32bit_elf)
{
+ const char * link_too_big = NULL;
+
print_vma (section->sh_addr, LONG_HEX);
printf ( " %6.6lx %6.6lx %2.2lx",
else
printf (" %3s ", get_elf_section_flags (section->sh_flags));
- printf ("%2u %3u %2lu\n",
- section->sh_link,
- section->sh_info,
- (unsigned long) section->sh_addralign);
+ if (section->sh_link >= elf_header.e_shnum)
+ {
+ link_too_big = "";
+ /* The sh_link value is out of range. Normally this indicates
+ an error but it can have special values in Solaris binaries. */
+ switch (elf_header.e_machine)
+ {
+ case EM_386:
+ case EM_486:
+ case EM_X86_64:
+ case EM_L1OM:
+ case EM_OLD_SPARCV9:
+ case EM_SPARC32PLUS:
+ case EM_SPARCV9:
+ case EM_SPARC:
+ if (section->sh_link == (SHN_BEFORE & 0xffff))
+ link_too_big = "BEFORE";
+ else if (section->sh_link == (SHN_AFTER & 0xffff))
+ link_too_big = "AFTER";
+ break;
+ default:
+ break;
+ }
+ }
+
+ if (do_section_details)
+ {
+ if (link_too_big != NULL && * link_too_big)
+ printf ("<%s> ", link_too_big);
+ else
+ printf ("%2u ", section->sh_link);
+ printf ("%3u %2lu\n", section->sh_info,
+ (unsigned long) section->sh_addralign);
+ }
+ else
+ printf ("%2u %3u %2lu\n",
+ section->sh_link,
+ section->sh_info,
+ (unsigned long) section->sh_addralign);
+
+ if (link_too_big && ! * link_too_big)
+ warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
+ i, section->sh_link);
}
else if (do_wide)
{
static char buff[32];
switch (flags)
{
+ case 0:
+ return "";
+
case GRP_COMDAT:
- return "COMDAT";
+ return "COMDAT ";
default:
- snprintf (buff, sizeof (buff), _("[<unknown>: 0x%x]"), flags);
+ snprintf (buff, sizeof (buff), _("[<unknown>: 0x%x] "), flags);
break;
}
return buff;
}
static int
-process_section_groups (FILE *file)
+process_section_groups (FILE * file)
{
- Elf_Internal_Shdr *section;
+ Elf_Internal_Shdr * section;
unsigned int i;
- struct group *group;
- Elf_Internal_Shdr *symtab_sec, *strtab_sec;
- Elf_Internal_Sym *symtab;
- char *strtab;
+ struct group * group;
+ Elf_Internal_Shdr * symtab_sec;
+ Elf_Internal_Shdr * strtab_sec;
+ Elf_Internal_Sym * symtab;
+ char * strtab;
size_t strtab_size;
/* Don't process section groups unless needed. */
abort ();
}
- section_headers_groups = calloc (elf_header.e_shnum,
- sizeof (struct group *));
+ section_headers_groups = (struct group **) calloc (elf_header.e_shnum,
+ sizeof (struct group *));
if (section_headers_groups == NULL)
{
return 1;
}
- section_groups = calloc (group_count, sizeof (struct group));
+ section_groups = (struct group *) calloc (group_count, sizeof (struct group));
if (section_groups == NULL)
{
{
if (section->sh_type == SHT_GROUP)
{
- char *name = SECTION_NAME (section);
- char *group_name;
- unsigned char *start, *indices;
+ char * name = SECTION_NAME (section);
+ char * group_name;
+ unsigned char * start;
+ unsigned char * indices;
unsigned int entry, j, size;
- Elf_Internal_Shdr *sec;
- Elf_Internal_Sym *sym;
+ Elf_Internal_Shdr * sec;
+ Elf_Internal_Sym * sym;
/* Get the symbol table. */
if (section->sh_link >= elf_header.e_shnum
strtab_sec = sec;
if (strtab)
free (strtab);
- strtab = get_data (NULL, file, strtab_sec->sh_offset,
- 1, strtab_sec->sh_size,
- _("string table"));
+ strtab = (char *) get_data (NULL, file, strtab_sec->sh_offset,
+ 1, strtab_sec->sh_size,
+ _("string table"));
strtab_size = strtab != NULL ? strtab_sec->sh_size : 0;
}
group_name = sym->st_name < strtab_size
- ? strtab + sym->st_name : "<corrupt>";
+ ? strtab + sym->st_name : _("<corrupt>");
}
- start = get_data (NULL, file, section->sh_offset,
- 1, section->sh_size, _("section data"));
+ start = (unsigned char *) get_data (NULL, file, section->sh_offset,
+ 1, section->sh_size,
+ _("section data"));
indices = start;
size = (section->sh_size / section->sh_entsize) - 1;
if (do_section_groups)
{
- printf ("\n%s group section [%5u] `%s' [%s] contains %u sections:\n",
+ printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
get_group_flags (entry), i, name, group_name, size);
printf (_(" [Index] Name\n"));
for (j = 0; j < size; j++)
{
- struct group_list *g;
+ struct group_list * g;
entry = byte_get (indices, 4);
indices += 4;
printf (" [%5u] %s\n", entry, SECTION_NAME (sec));
}
- g = xmalloc (sizeof (struct group_list));
+ g = (struct group_list *) xmalloc (sizeof (struct group_list));
g->section_index = entry;
g->next = group->root;
group->root = g;
static struct
{
- const char *name;
+ const char * name;
int reloc;
int size;
int rela;
/* Process the reloc section. */
static int
-process_relocs (FILE *file)
+process_relocs (FILE * file)
{
unsigned long rel_size;
unsigned long rel_offset;
if (do_using_dynamic)
{
int is_rela;
- const char *name;
+ const char * name;
int has_dynamic_reloc;
unsigned int i;
}
else
{
- Elf_Internal_Shdr *section;
+ Elf_Internal_Shdr * section;
unsigned long i;
int found = 0;
if (rel_size)
{
- Elf_Internal_Shdr *strsec;
+ Elf_Internal_Shdr * strsec;
int is_rela;
printf (_("\nRelocation section "));
if (section->sh_link != 0
&& section->sh_link < elf_header.e_shnum)
{
- Elf_Internal_Shdr *symsec;
- Elf_Internal_Sym *symtab;
+ Elf_Internal_Shdr * symsec;
+ Elf_Internal_Sym * symtab;
unsigned long nsyms;
unsigned long strtablen = 0;
- char *strtab = NULL;
+ char * strtab = NULL;
symsec = section_headers + section->sh_link;
if (symsec->sh_type != SHT_SYMTAB
{
strsec = section_headers + symsec->sh_link;
- strtab = get_data (NULL, file, strsec->sh_offset,
- 1, strsec->sh_size,
- _("string table"));
+ strtab = (char *) get_data (NULL, file, strsec->sh_offset,
+ 1, strsec->sh_size,
+ _("string table"));
strtablen = strtab == NULL ? 0 : strsec->sh_size;
}
? section_headers [(a).section].sh_addr + (a).offset \
: (a).offset)
+struct ia64_unw_table_entry
+ {
+ struct absaddr start;
+ struct absaddr end;
+ struct absaddr info;
+ };
+
struct ia64_unw_aux_info
{
- struct ia64_unw_table_entry
- {
- struct absaddr start;
- struct absaddr end;
- struct absaddr info;
- }
- *table; /* Unwind table. */
+
+ struct ia64_unw_table_entry *table; /* Unwind table. */
unsigned long table_len; /* Length of unwind table. */
- unsigned char *info; /* Unwind info. */
+ unsigned char * info; /* Unwind info. */
unsigned long info_size; /* Size of unwind info. */
bfd_vma info_addr; /* starting address of unwind info. */
bfd_vma seg_base; /* Starting address of segment. */
- Elf_Internal_Sym *symtab; /* The symbol table. */
+ Elf_Internal_Sym * symtab; /* The symbol table. */
unsigned long nsyms; /* Number of symbols. */
- char *strtab; /* The string table. */
+ char * strtab; /* The string table. */
unsigned long strtab_size; /* Size of string table. */
};
static void
-find_symbol_for_address (Elf_Internal_Sym *symtab,
+find_symbol_for_address (Elf_Internal_Sym * symtab,
unsigned long nsyms,
- const char *strtab,
+ const char * strtab,
unsigned long strtab_size,
struct absaddr addr,
- const char **symname,
- bfd_vma *offset)
+ const char ** symname,
+ bfd_vma * offset)
{
bfd_vma dist = 0x100000;
- Elf_Internal_Sym *sym, *best = NULL;
+ Elf_Internal_Sym * sym;
+ Elf_Internal_Sym * best = NULL;
unsigned long i;
+ REMOVE_ARCH_BITS (addr.offset);
+
for (i = 0, sym = symtab; i < nsyms; ++i, ++sym)
{
+ bfd_vma value = sym->st_value;
+
+ REMOVE_ARCH_BITS (value);
+
if (ELF_ST_TYPE (sym->st_info) == STT_FUNC
&& sym->st_name != 0
&& (addr.section == SHN_UNDEF || addr.section == sym->st_shndx)
- && addr.offset >= sym->st_value
- && addr.offset - sym->st_value < dist)
+ && addr.offset >= value
+ && addr.offset - value < dist)
{
best = sym;
- dist = addr.offset - sym->st_value;
+ dist = addr.offset - value;
if (!dist)
break;
}
if (best)
{
*symname = (best->st_name >= strtab_size
- ? "<corrupt>" : strtab + best->st_name);
+ ? _("<corrupt>") : strtab + best->st_name);
*offset = dist;
return;
}
}
static void
-dump_ia64_unwind (struct ia64_unw_aux_info *aux)
+dump_ia64_unwind (struct ia64_unw_aux_info * aux)
{
- struct ia64_unw_table_entry *tp;
+ struct ia64_unw_table_entry * tp;
int in_body;
for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
{
bfd_vma stamp;
bfd_vma offset;
- const unsigned char *dp;
- const unsigned char *head;
- const char *procname;
+ const unsigned char * dp;
+ const unsigned char * head;
+ const char * procname;
find_symbol_for_address (aux->symtab, aux->nsyms, aux->strtab,
aux->strtab_size, tp->start, &procname, &offset);
if (UNW_VER (stamp) != 1)
{
- printf ("\tUnknown version.\n");
+ printf (_("\tUnknown version.\n"));
continue;
}
}
static int
-slurp_ia64_unwind_table (FILE *file,
- struct ia64_unw_aux_info *aux,
- Elf_Internal_Shdr *sec)
+slurp_ia64_unwind_table (FILE * file,
+ struct ia64_unw_aux_info * aux,
+ Elf_Internal_Shdr * sec)
{
unsigned long size, nrelas, i;
- Elf_Internal_Phdr *seg;
- struct ia64_unw_table_entry *tep;
- Elf_Internal_Shdr *relsec;
- Elf_Internal_Rela *rela, *rp;
- unsigned char *table, *tp;
- Elf_Internal_Sym *sym;
- const char *relname;
+ Elf_Internal_Phdr * seg;
+ struct ia64_unw_table_entry * tep;
+ Elf_Internal_Shdr * relsec;
+ Elf_Internal_Rela * rela;
+ Elf_Internal_Rela * rp;
+ unsigned char * table;
+ unsigned char * tp;
+ Elf_Internal_Sym * sym;
+ const char * relname;
/* First, find the starting address of the segment that includes
this section: */
/* Second, build the unwind table from the contents of the unwind section: */
size = sec->sh_size;
- table = get_data (NULL, file, sec->sh_offset, 1, size, _("unwind table"));
+ table = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1, size,
+ _("unwind table"));
if (!table)
return 0;
- aux->table = xcmalloc (size / (3 * eh_addr_size), sizeof (aux->table[0]));
+ aux->table = (struct ia64_unw_table_entry *)
+ xcmalloc (size / (3 * eh_addr_size), sizeof (aux->table[0]));
tep = aux->table;
- for (tp = table; tp < table + size; tp += 3 * eh_addr_size, ++tep)
+ for (tp = table; tp < table + size; ++tep)
{
tep->start.section = SHN_UNDEF;
tep->end.section = SHN_UNDEF;
tep->info.section = SHN_UNDEF;
- if (is_32bit_elf)
- {
- tep->start.offset = byte_get ((unsigned char *) tp + 0, 4);
- tep->end.offset = byte_get ((unsigned char *) tp + 4, 4);
- tep->info.offset = byte_get ((unsigned char *) tp + 8, 4);
- }
- else
- {
- tep->start.offset = BYTE_GET ((unsigned char *) tp + 0);
- tep->end.offset = BYTE_GET ((unsigned char *) tp + 8);
- tep->info.offset = BYTE_GET ((unsigned char *) tp + 16);
- }
+ tep->start.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
+ tep->end.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
+ tep->info.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
tep->start.offset += aux->seg_base;
tep->end.offset += aux->seg_base;
tep->info.offset += aux->seg_base;
}
static int
-ia64_process_unwind (FILE *file)
+ia64_process_unwind (FILE * file)
{
- Elf_Internal_Shdr *sec, *unwsec = NULL, *strsec;
+ Elf_Internal_Shdr * sec;
+ Elf_Internal_Shdr * unwsec = NULL;
+ Elf_Internal_Shdr * strsec;
unsigned long i, unwcount = 0, unwstart = 0;
struct ia64_unw_aux_info aux;
aux.symtab = GET_ELF_SYMBOLS (file, sec);
strsec = section_headers + sec->sh_link;
- aux.strtab = get_data (NULL, file, strsec->sh_offset,
- 1, strsec->sh_size, _("string table"));
+ aux.strtab = (char *) get_data (NULL, file, strsec->sh_offset,
+ 1, strsec->sh_size,
+ _("string table"));
aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
}
else if (sec->sh_type == SHT_IA_64_UNWIND)
while (unwcount-- > 0)
{
- char *suffix;
+ char * suffix;
size_t len, len2;
for (i = unwstart, sec = section_headers + unwstart;
if ((unwsec->sh_flags & SHF_GROUP) != 0)
{
/* We need to find which section group it is in. */
- struct group_list *g = section_headers_groups [i]->root;
+ struct group_list * g = section_headers_groups [i]->root;
for (; g != NULL; g = g->next)
{
{
aux.info_size = sec->sh_size;
aux.info_addr = sec->sh_addr;
- aux.info = get_data (NULL, file, sec->sh_offset, 1, aux.info_size,
- _("unwind info"));
+ aux.info = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1,
+ aux.info_size,
+ _("unwind info"));
printf (_("\nUnwind section "));
return 1;
}
+struct hppa_unw_table_entry
+ {
+ struct absaddr start;
+ struct absaddr end;
+ unsigned int Cannot_unwind:1; /* 0 */
+ unsigned int Millicode:1; /* 1 */
+ unsigned int Millicode_save_sr0:1; /* 2 */
+ unsigned int Region_description:2; /* 3..4 */
+ unsigned int reserved1:1; /* 5 */
+ unsigned int Entry_SR:1; /* 6 */
+ unsigned int Entry_FR:4; /* number saved */ /* 7..10 */
+ unsigned int Entry_GR:5; /* number saved */ /* 11..15 */
+ unsigned int Args_stored:1; /* 16 */
+ unsigned int Variable_Frame:1; /* 17 */
+ unsigned int Separate_Package_Body:1; /* 18 */
+ unsigned int Frame_Extension_Millicode:1; /* 19 */
+ unsigned int Stack_Overflow_Check:1; /* 20 */
+ unsigned int Two_Instruction_SP_Increment:1; /* 21 */
+ unsigned int Ada_Region:1; /* 22 */
+ unsigned int cxx_info:1; /* 23 */
+ unsigned int cxx_try_catch:1; /* 24 */
+ unsigned int sched_entry_seq:1; /* 25 */
+ unsigned int reserved2:1; /* 26 */
+ unsigned int Save_SP:1; /* 27 */
+ unsigned int Save_RP:1; /* 28 */
+ unsigned int Save_MRP_in_frame:1; /* 29 */
+ unsigned int extn_ptr_defined:1; /* 30 */
+ unsigned int Cleanup_defined:1; /* 31 */
+
+ unsigned int MPE_XL_interrupt_marker:1; /* 0 */
+ unsigned int HP_UX_interrupt_marker:1; /* 1 */
+ unsigned int Large_frame:1; /* 2 */
+ unsigned int Pseudo_SP_Set:1; /* 3 */
+ unsigned int reserved4:1; /* 4 */
+ unsigned int Total_frame_size:27; /* 5..31 */
+ };
+
struct hppa_unw_aux_info
{
- struct hppa_unw_table_entry
- {
- struct absaddr start;
- struct absaddr end;
- unsigned int Cannot_unwind:1; /* 0 */
- unsigned int Millicode:1; /* 1 */
- unsigned int Millicode_save_sr0:1; /* 2 */
- unsigned int Region_description:2; /* 3..4 */
- unsigned int reserved1:1; /* 5 */
- unsigned int Entry_SR:1; /* 6 */
- unsigned int Entry_FR:4; /* number saved */ /* 7..10 */
- unsigned int Entry_GR:5; /* number saved */ /* 11..15 */
- unsigned int Args_stored:1; /* 16 */
- unsigned int Variable_Frame:1; /* 17 */
- unsigned int Separate_Package_Body:1; /* 18 */
- unsigned int Frame_Extension_Millicode:1; /* 19 */
- unsigned int Stack_Overflow_Check:1; /* 20 */
- unsigned int Two_Instruction_SP_Increment:1; /* 21 */
- unsigned int Ada_Region:1; /* 22 */
- unsigned int cxx_info:1; /* 23 */
- unsigned int cxx_try_catch:1; /* 24 */
- unsigned int sched_entry_seq:1; /* 25 */
- unsigned int reserved2:1; /* 26 */
- unsigned int Save_SP:1; /* 27 */
- unsigned int Save_RP:1; /* 28 */
- unsigned int Save_MRP_in_frame:1; /* 29 */
- unsigned int extn_ptr_defined:1; /* 30 */
- unsigned int Cleanup_defined:1; /* 31 */
-
- unsigned int MPE_XL_interrupt_marker:1; /* 0 */
- unsigned int HP_UX_interrupt_marker:1; /* 1 */
- unsigned int Large_frame:1; /* 2 */
- unsigned int Pseudo_SP_Set:1; /* 3 */
- unsigned int reserved4:1; /* 4 */
- unsigned int Total_frame_size:27; /* 5..31 */
- }
- *table; /* Unwind table. */
+ struct hppa_unw_table_entry *table; /* Unwind table. */
unsigned long table_len; /* Length of unwind table. */
bfd_vma seg_base; /* Starting address of segment. */
- Elf_Internal_Sym *symtab; /* The symbol table. */
+ Elf_Internal_Sym * symtab; /* The symbol table. */
unsigned long nsyms; /* Number of symbols. */
- char *strtab; /* The string table. */
+ char * strtab; /* The string table. */
unsigned long strtab_size; /* Size of string table. */
};
static void
-dump_hppa_unwind (struct hppa_unw_aux_info *aux)
+dump_hppa_unwind (struct hppa_unw_aux_info * aux)
{
- struct hppa_unw_table_entry *tp;
+ struct hppa_unw_table_entry * tp;
for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
{
bfd_vma offset;
- const char *procname;
+ const char * procname;
find_symbol_for_address (aux->symtab, aux->nsyms, aux->strtab,
aux->strtab_size, tp->start, &procname,
}
static int
-slurp_hppa_unwind_table (FILE *file,
- struct hppa_unw_aux_info *aux,
- Elf_Internal_Shdr *sec)
+slurp_hppa_unwind_table (FILE * file,
+ struct hppa_unw_aux_info * aux,
+ Elf_Internal_Shdr * sec)
{
unsigned long size, unw_ent_size, nentries, nrelas, i;
- Elf_Internal_Phdr *seg;
- struct hppa_unw_table_entry *tep;
- Elf_Internal_Shdr *relsec;
- Elf_Internal_Rela *rela, *rp;
- unsigned char *table, *tp;
- Elf_Internal_Sym *sym;
- const char *relname;
+ Elf_Internal_Phdr * seg;
+ struct hppa_unw_table_entry * tep;
+ Elf_Internal_Shdr * relsec;
+ Elf_Internal_Rela * rela;
+ Elf_Internal_Rela * rp;
+ unsigned char * table;
+ unsigned char * tp;
+ Elf_Internal_Sym * sym;
+ const char * relname;
/* First, find the starting address of the segment that includes
this section. */
/* Second, build the unwind table from the contents of the unwind
section. */
size = sec->sh_size;
- table = get_data (NULL, file, sec->sh_offset, 1, size, _("unwind table"));
+ table = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1, size,
+ _("unwind table"));
if (!table)
return 0;
nentries = size / unw_ent_size;
size = unw_ent_size * nentries;
- tep = aux->table = xcmalloc (nentries, sizeof (aux->table[0]));
+ tep = aux->table = (struct hppa_unw_table_entry *)
+ xcmalloc (nentries, sizeof (aux->table[0]));
for (tp = table; tp < table + size; tp += unw_ent_size, ++tep)
{
{
case 0:
aux->table[i].start.section = sym->st_shndx;
- aux->table[i].start.offset += sym->st_value + rp->r_addend;
+ aux->table[i].start.offset = sym->st_value + rp->r_addend;
break;
case 1:
aux->table[i].end.section = sym->st_shndx;
- aux->table[i].end.offset += sym->st_value + rp->r_addend;
+ aux->table[i].end.offset = sym->st_value + rp->r_addend;
break;
default:
break;
}
static int
-hppa_process_unwind (FILE *file)
+hppa_process_unwind (FILE * file)
{
struct hppa_unw_aux_info aux;
- Elf_Internal_Shdr *unwsec = NULL;
- Elf_Internal_Shdr *strsec;
- Elf_Internal_Shdr *sec;
+ Elf_Internal_Shdr * unwsec = NULL;
+ Elf_Internal_Shdr * strsec;
+ Elf_Internal_Shdr * sec;
unsigned long i;
memset (& aux, 0, sizeof (aux));
aux.symtab = GET_ELF_SYMBOLS (file, sec);
strsec = section_headers + sec->sh_link;
- aux.strtab = get_data (NULL, file, strsec->sh_offset,
- 1, strsec->sh_size, _("string table"));
+ aux.strtab = (char *) get_data (NULL, file, strsec->sh_offset,
+ 1, strsec->sh_size,
+ _("string table"));
aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
}
else if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
return 1;
}
-static int
-process_unwind (FILE *file)
+struct arm_section
{
- struct unwind_handler {
- int machtype;
- int (*handler)(FILE *file);
- } handlers[] = {
- { EM_IA_64, ia64_process_unwind },
- { EM_PARISC, hppa_process_unwind },
- { 0, 0 }
- };
- int i;
+ unsigned char *data;
- if (!do_unwind)
- return 1;
+ Elf_Internal_Shdr *sec;
+ Elf_Internal_Rela *rela;
+ unsigned long nrelas;
+ unsigned int rel_type;
- for (i = 0; handlers[i].handler != NULL; i++)
- if (elf_header.e_machine == handlers[i].machtype)
- return handlers[i].handler (file);
+ Elf_Internal_Rela *next_rela;
+};
- printf (_("\nThere are no unwind sections in this file.\n"));
- return 1;
-}
+struct arm_unw_aux_info
+{
+ FILE *file;
-static void
-dynamic_section_mips_val (Elf_Internal_Dyn *entry)
+ Elf_Internal_Sym *symtab; /* The symbol table. */
+ unsigned long nsyms; /* Number of symbols. */
+ char *strtab; /* The string table. */
+ unsigned long strtab_size; /* Size of string table. */
+};
+
+static const char *
+arm_print_vma_and_name (struct arm_unw_aux_info *aux,
+ bfd_vma fn, struct absaddr addr)
{
- switch (entry->d_tag)
- {
- case DT_MIPS_FLAGS:
- if (entry->d_un.d_val == 0)
- printf ("NONE\n");
- else
- {
- static const char * opts[] =
- {
- "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
- "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
- "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
- "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
- "RLD_ORDER_SAFE"
- };
- unsigned int cnt;
- int first = 1;
- for (cnt = 0; cnt < ARRAY_SIZE (opts); ++cnt)
- if (entry->d_un.d_val & (1 << cnt))
- {
- printf ("%s%s", first ? "" : " ", opts[cnt]);
- first = 0;
- }
- puts ("");
- }
- break;
+ const char *procname;
+ bfd_vma sym_offset;
- case DT_MIPS_IVERSION:
- if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
- printf ("Interface Version: %s\n", GET_DYNAMIC_NAME (entry->d_un.d_val));
- else
- printf ("<corrupt: %ld>\n", (long) entry->d_un.d_ptr);
- break;
+ if (addr.section == SHN_UNDEF)
+ addr.offset = fn;
- case DT_MIPS_TIME_STAMP:
- {
- char timebuf[20];
- struct tm *tmp;
+ find_symbol_for_address (aux->symtab, aux->nsyms, aux->strtab,
+ aux->strtab_size, addr, &procname,
+ &sym_offset);
- time_t time = entry->d_un.d_val;
- tmp = gmtime (&time);
- snprintf (timebuf, sizeof (timebuf), "%04u-%02u-%02uT%02u:%02u:%02u",
- tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
- tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
- printf ("Time Stamp: %s\n", timebuf);
- }
- break;
+ print_vma (fn, PREFIX_HEX);
- case DT_MIPS_RLD_VERSION:
- case DT_MIPS_LOCAL_GOTNO:
- case DT_MIPS_CONFLICTNO:
- case DT_MIPS_LIBLISTNO:
- case DT_MIPS_SYMTABNO:
- case DT_MIPS_UNREFEXTNO:
- case DT_MIPS_HIPAGENO:
- case DT_MIPS_DELTA_CLASS_NO:
- case DT_MIPS_DELTA_INSTANCE_NO:
- case DT_MIPS_DELTA_RELOC_NO:
- case DT_MIPS_DELTA_SYM_NO:
- case DT_MIPS_DELTA_CLASSSYM_NO:
- case DT_MIPS_COMPACT_SIZE:
- printf ("%ld\n", (long) entry->d_un.d_ptr);
- break;
+ if (procname)
+ {
+ fputs (" <", stdout);
+ fputs (procname, stdout);
- default:
- printf ("%#lx\n", (long) entry->d_un.d_ptr);
+ if (sym_offset)
+ printf ("+0x%lx", (unsigned long) sym_offset);
+ fputc ('>', stdout);
}
-}
+ return procname;
+}
static void
-dynamic_section_parisc_val (Elf_Internal_Dyn *entry)
+arm_free_section (struct arm_section *arm_sec)
{
- switch (entry->d_tag)
+ if (arm_sec->data != NULL)
+ free (arm_sec->data);
+
+ if (arm_sec->rela != NULL)
+ free (arm_sec->rela);
+}
+
+static int
+arm_section_get_word (struct arm_unw_aux_info *aux,
+ struct arm_section *arm_sec,
+ Elf_Internal_Shdr *sec, bfd_vma word_offset,
+ unsigned int *wordp, struct absaddr *addr)
+{
+ Elf_Internal_Rela *rp;
+ Elf_Internal_Sym *sym;
+ const char * relname;
+ unsigned int word;
+ bfd_boolean wrapped;
+
+ addr->section = SHN_UNDEF;
+ addr->offset = 0;
+
+ if (sec != arm_sec->sec)
{
- case DT_HP_DLD_FLAGS:
- {
- static struct
- {
- long int bit;
- const char *str;
- }
- flags[] =
+ Elf_Internal_Shdr *relsec;
+
+ arm_free_section (arm_sec);
+
+ arm_sec->sec = sec;
+ arm_sec->data = get_data (NULL, aux->file, sec->sh_offset, 1,
+ sec->sh_size, _("unwind data"));
+
+ arm_sec->rela = NULL;
+ arm_sec->nrelas = 0;
+
+ for (relsec = section_headers;
+ relsec < section_headers + elf_header.e_shnum;
+ ++relsec)
{
- { DT_HP_DEBUG_PRIVATE, "HP_DEBUG_PRIVATE" },
- { DT_HP_DEBUG_CALLBACK, "HP_DEBUG_CALLBACK" },
- { DT_HP_DEBUG_CALLBACK_BOR, "HP_DEBUG_CALLBACK_BOR" },
- { DT_HP_NO_ENVVAR, "HP_NO_ENVVAR" },
- { DT_HP_BIND_NOW, "HP_BIND_NOW" },
- { DT_HP_BIND_NONFATAL, "HP_BIND_NONFATAL" },
- { DT_HP_BIND_VERBOSE, "HP_BIND_VERBOSE" },
- { DT_HP_BIND_RESTRICTED, "HP_BIND_RESTRICTED" },
- { DT_HP_BIND_SYMBOLIC, "HP_BIND_SYMBOLIC" },
- { DT_HP_RPATH_FIRST, "HP_RPATH_FIRST" },
- { DT_HP_BIND_DEPTH_FIRST, "HP_BIND_DEPTH_FIRST" },
- { DT_HP_GST, "HP_GST" },
- { DT_HP_SHLIB_FIXED, "HP_SHLIB_FIXED" },
- { DT_HP_MERGE_SHLIB_SEG, "HP_MERGE_SHLIB_SEG" },
- { DT_HP_NODELETE, "HP_NODELETE" },
- { DT_HP_GROUP, "HP_GROUP" },
- { DT_HP_PROTECT_LINKAGE_TABLE, "HP_PROTECT_LINKAGE_TABLE" }
- };
- int first = 1;
- size_t cnt;
- bfd_vma val = entry->d_un.d_val;
+ if (relsec->sh_info >= elf_header.e_shnum
+ || section_headers + relsec->sh_info != sec)
+ continue;
- for (cnt = 0; cnt < ARRAY_SIZE (flags); ++cnt)
- if (val & flags[cnt].bit)
+ if (relsec->sh_type == SHT_REL)
{
- if (! first)
- putchar (' ');
- fputs (flags[cnt].str, stdout);
- first = 0;
- val ^= flags[cnt].bit;
+ if (!slurp_rel_relocs (aux->file, relsec->sh_offset,
+ relsec->sh_size,
+ & arm_sec->rela, & arm_sec->nrelas))
+ return 0;
+ break;
}
+ else if (relsec->sh_type == SHT_RELA)
+ {
+ if (!slurp_rela_relocs (aux->file, relsec->sh_offset,
+ relsec->sh_size,
+ & arm_sec->rela, & arm_sec->nrelas))
+ return 0;
+ break;
+ }
+ }
- if (val != 0 || first)
- {
- if (! first)
- putchar (' ');
- print_vma (val, HEX);
- }
- }
- break;
-
- default:
- print_vma (entry->d_un.d_ptr, PREFIX_HEX);
- break;
+ arm_sec->next_rela = arm_sec->rela;
}
- putchar ('\n');
-}
-
-static void
-dynamic_section_ia64_val (Elf_Internal_Dyn *entry)
-{
- switch (entry->d_tag)
- {
- case DT_IA_64_PLT_RESERVE:
- /* First 3 slots reserved. */
- print_vma (entry->d_un.d_ptr, PREFIX_HEX);
- printf (" -- ");
- print_vma (entry->d_un.d_ptr + (3 * 8), PREFIX_HEX);
- break;
-
- default:
- print_vma (entry->d_un.d_ptr, PREFIX_HEX);
- break;
- }
- putchar ('\n');
-}
-
-static int
-get_32bit_dynamic_section (FILE *file)
-{
- Elf32_External_Dyn *edyn, *ext;
- Elf_Internal_Dyn *entry;
- edyn = get_data (NULL, file, dynamic_addr, 1, dynamic_size,
- _("dynamic section"));
- if (!edyn)
+ if (arm_sec->data == NULL)
return 0;
-/* SGI's ELF has more than one section in the DYNAMIC segment, and we
- might not have the luxury of section headers. Look for the DT_NULL
- terminator to determine the number of entries. */
- for (ext = edyn, dynamic_nent = 0;
- (char *) ext < (char *) edyn + dynamic_size;
- ext++)
+ word = byte_get (arm_sec->data + word_offset, 4);
+
+ wrapped = FALSE;
+ for (rp = arm_sec->next_rela; rp != arm_sec->rela + arm_sec->nrelas; rp++)
{
- dynamic_nent++;
- if (BYTE_GET (ext->d_tag) == DT_NULL)
+ bfd_vma prelval, offset;
+
+ if (rp->r_offset > word_offset && !wrapped)
+ {
+ rp = arm_sec->rela;
+ wrapped = TRUE;
+ }
+ if (rp->r_offset > word_offset)
break;
- }
- dynamic_section = cmalloc (dynamic_nent, sizeof (*entry));
- if (dynamic_section == NULL)
- {
- error (_("Out of memory\n"));
- free (edyn);
- return 0;
- }
+ if (rp->r_offset & 3)
+ {
+ warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
+ (unsigned long) rp->r_offset);
+ continue;
+ }
- for (ext = edyn, entry = dynamic_section;
- entry < dynamic_section + dynamic_nent;
- ext++, entry++)
- {
- entry->d_tag = BYTE_GET (ext->d_tag);
- entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
- }
+ if (rp->r_offset < word_offset)
+ continue;
- free (edyn);
+ relname = elf_arm_reloc_type (ELF32_R_TYPE (rp->r_info));
- return 1;
-}
+ if (streq (relname, "R_ARM_NONE"))
+ continue;
-static int
-get_64bit_dynamic_section (FILE *file)
-{
- Elf64_External_Dyn *edyn, *ext;
- Elf_Internal_Dyn *entry;
+ if (! streq (relname, "R_ARM_PREL31"))
+ {
+ warn (_("Skipping unexpected relocation type %s\n"), relname);
+ continue;
+ }
- edyn = get_data (NULL, file, dynamic_addr, 1, dynamic_size,
- _("dynamic section"));
- if (!edyn)
- return 0;
+ sym = aux->symtab + ELF32_R_SYM (rp->r_info);
-/* SGI's ELF has more than one section in the DYNAMIC segment, and we
- might not have the luxury of section headers. Look for the DT_NULL
- terminator to determine the number of entries. */
- for (ext = edyn, dynamic_nent = 0;
- (char *) ext < (char *) edyn + dynamic_size;
- ext++)
- {
- dynamic_nent++;
- if (BYTE_GET (ext->d_tag) == DT_NULL)
- break;
- }
+ if (arm_sec->rel_type == SHT_REL)
+ {
+ offset = word & 0x7fffffff;
+ if (offset & 0x40000000)
+ offset |= ~ (bfd_vma) 0x7fffffff;
+ }
+ else
+ offset = rp->r_addend;
- dynamic_section = cmalloc (dynamic_nent, sizeof (*entry));
- if (dynamic_section == NULL)
- {
- error (_("Out of memory\n"));
- free (edyn);
- return 0;
- }
+ offset += sym->st_value;
+ prelval = offset - (arm_sec->sec->sh_addr + rp->r_offset);
- for (ext = edyn, entry = dynamic_section;
- entry < dynamic_section + dynamic_nent;
- ext++, entry++)
- {
- entry->d_tag = BYTE_GET (ext->d_tag);
- entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
+ word = (word & ~ (bfd_vma) 0x7fffffff) | (prelval & 0x7fffffff);
+ addr->section = sym->st_shndx;
+ addr->offset = offset;
+ break;
}
- free (edyn);
+ *wordp = word;
+ arm_sec->next_rela = rp;
return 1;
}
static void
-print_dynamic_flags (bfd_vma flags)
-{
- int first = 1;
+decode_arm_unwind (struct arm_unw_aux_info *aux,
+ unsigned int word, unsigned int remaining,
+ bfd_vma data_offset, Elf_Internal_Shdr *data_sec,
+ struct arm_section *data_arm_sec)
+{
+ int per_index;
+ unsigned int more_words;
+ struct absaddr addr;
+
+#define ADVANCE \
+ if (remaining == 0 && more_words) \
+ { \
+ data_offset += 4; \
+ if (!arm_section_get_word (aux, data_arm_sec, data_sec, \
+ data_offset, &word, &addr)) \
+ return; \
+ remaining = 4; \
+ more_words--; \
+ } \
+
+#define GET_OP(OP) \
+ ADVANCE; \
+ if (remaining) \
+ { \
+ remaining--; \
+ (OP) = word >> 24; \
+ word <<= 8; \
+ } \
+ else \
+ { \
+ printf (_("[Truncated opcode]\n")); \
+ return; \
+ } \
+ printf (_("0x%02x "), OP)
+
+ if (remaining == 0)
+ {
+ /* Fetch the first word. */
+ if (!arm_section_get_word (aux, data_arm_sec, data_sec, data_offset,
+ &word, &addr))
+ return;
+ remaining = 4;
+ }
- while (flags)
+ if ((word & 0x80000000) == 0)
{
- bfd_vma flag;
-
- flag = flags & - flags;
- flags &= ~ flag;
+ /* Expand prel31 for personality routine. */
+ bfd_vma fn;
+ const char *procname;
- if (first)
- first = 0;
+ fn = word;
+ if (fn & 0x40000000)
+ fn |= ~ (bfd_vma) 0x7fffffff;
+ fn = fn + data_sec->sh_addr + data_offset;
+
+ printf (_(" Personality routine: "));
+ procname = arm_print_vma_and_name (aux, fn, addr);
+ fputc ('\n', stdout);
+
+ /* The GCC personality routines use the standard compact
+ encoding, starting with one byte giving the number of
+ words. */
+ if (procname != NULL
+ && (const_strneq (procname, "__gcc_personality_v0")
+ || const_strneq (procname, "__gxx_personality_v0")
+ || const_strneq (procname, "__gcj_personality_v0")
+ || const_strneq (procname, "__gnu_objc_personality_v0")))
+ {
+ remaining = 0;
+ more_words = 1;
+ ADVANCE;
+ if (!remaining)
+ {
+ printf (_(" [Truncated data]\n"));
+ return;
+ }
+ more_words = word >> 24;
+ word <<= 8;
+ remaining--;
+ }
else
- putc (' ', stdout);
+ return;
+ }
+ else
+ {
+
+ per_index = (word >> 24) & 0x7f;
+ if (per_index != 0 && per_index != 1 && per_index != 2)
+ {
+ printf (_(" [reserved compact index %d]\n"), per_index);
+ return;
+ }
- switch (flag)
+ printf (_(" Compact model %d\n"), per_index);
+ if (per_index == 0)
{
- case DF_ORIGIN: fputs ("ORIGIN", stdout); break;
- case DF_SYMBOLIC: fputs ("SYMBOLIC", stdout); break;
- case DF_TEXTREL: fputs ("TEXTREL", stdout); break;
- case DF_BIND_NOW: fputs ("BIND_NOW", stdout); break;
- case DF_STATIC_TLS: fputs ("STATIC_TLS", stdout); break;
- default: fputs ("unknown", stdout); break;
+ more_words = 0;
+ word <<= 8;
+ remaining--;
+ }
+ else
+ {
+ more_words = (word >> 16) & 0xff;
+ word <<= 16;
+ remaining -= 2;
}
}
- puts ("");
-}
-
-/* Parse and display the contents of the dynamic section. */
-static int
-process_dynamic_section (FILE *file)
-{
- Elf_Internal_Dyn *entry;
-
- if (dynamic_size == 0)
+ /* Decode the unwinding instructions. */
+ while (1)
{
- if (do_dynamic)
- printf (_("\nThere is no dynamic section in this file.\n"));
+ unsigned int op, op2;
- return 1;
- }
+ ADVANCE;
+ if (remaining == 0)
+ break;
+ remaining--;
+ op = word >> 24;
+ word <<= 8;
- if (is_32bit_elf)
- {
- if (! get_32bit_dynamic_section (file))
- return 0;
- }
- else if (! get_64bit_dynamic_section (file))
- return 0;
+ printf (_(" 0x%02x "), op);
- /* Find the appropriate symbol table. */
- if (dynamic_symbols == NULL)
- {
- for (entry = dynamic_section;
- entry < dynamic_section + dynamic_nent;
- ++entry)
+ if ((op & 0xc0) == 0x00)
{
- Elf_Internal_Shdr section;
-
- if (entry->d_tag != DT_SYMTAB)
- continue;
-
- dynamic_info[DT_SYMTAB] = entry->d_un.d_val;
-
- /* Since we do not know how big the symbol table is,
- we default to reading in the entire file (!) and
- processing that. This is overkill, I know, but it
- should work. */
- section.sh_offset = offset_from_vma (file, entry->d_un.d_val, 0);
-
- if (archive_file_offset != 0)
- section.sh_size = archive_file_size - section.sh_offset;
+ int offset = ((op & 0x3f) << 2) + 4;
+ printf (_(" vsp = vsp + %d"), offset);
+ }
+ else if ((op & 0xc0) == 0x40)
+ {
+ int offset = ((op & 0x3f) << 2) + 4;
+ printf (_(" vsp = vsp - %d"), offset);
+ }
+ else if ((op & 0xf0) == 0x80)
+ {
+ GET_OP (op2);
+ if (op == 0x80 && op2 == 0)
+ printf (_("Refuse to unwind"));
else
{
- if (fseek (file, 0, SEEK_END))
- error (_("Unable to seek to end of file!\n"));
+ unsigned int mask = ((op & 0x0f) << 8) | op2;
+ int first = 1;
+ int i;
- section.sh_size = ftell (file) - section.sh_offset;
+ printf ("pop {");
+ for (i = 0; i < 12; i++)
+ if (mask & (1 << i))
+ {
+ if (first)
+ first = 0;
+ else
+ printf (", ");
+ printf ("r%d", 4 + i);
+ }
+ printf ("}");
}
-
- if (is_32bit_elf)
- section.sh_entsize = sizeof (Elf32_External_Sym);
+ }
+ else if ((op & 0xf0) == 0x90)
+ {
+ if (op == 0x9d || op == 0x9f)
+ printf (_(" [Reserved]"));
else
- section.sh_entsize = sizeof (Elf64_External_Sym);
-
- num_dynamic_syms = section.sh_size / section.sh_entsize;
- if (num_dynamic_syms < 1)
+ printf (_(" vsp = r%d"), op & 0x0f);
+ }
+ else if ((op & 0xf0) == 0xa0)
+ {
+ int end = 4 + (op & 0x07);
+ int first = 1;
+ int i;
+ printf (" pop {");
+ for (i = 4; i <= end; i++)
{
- error (_("Unable to determine the number of symbols to load\n"));
- continue;
+ if (first)
+ first = 0;
+ else
+ printf (", ");
+ printf ("r%d", i);
+ }
+ if (op & 0x08)
+ {
+ if (first)
+ printf (", ");
+ printf ("r14");
+ }
+ printf ("}");
+ }
+ else if (op == 0xb0)
+ printf (_(" finish"));
+ else if (op == 0xb1)
+ {
+ GET_OP (op2);
+ if (op2 == 0 || (op2 & 0xf0) != 0)
+ printf (_("[Spare]"));
+ else
+ {
+ unsigned int mask = op2 & 0x0f;
+ int first = 1;
+ int i;
+ printf ("pop {");
+ for (i = 0; i < 12; i++)
+ if (mask & (1 << i))
+ {
+ if (first)
+ first = 0;
+ else
+ printf (", ");
+ printf ("r%d", i);
+ }
+ printf ("}");
+ }
+ }
+ else if (op == 0xb2)
+ {
+ unsigned char buf[9];
+ unsigned int i, len;
+ unsigned long offset;
+ for (i = 0; i < sizeof (buf); i++)
+ {
+ GET_OP (buf[i]);
+ if ((buf[i] & 0x80) == 0)
+ break;
+ }
+ assert (i < sizeof (buf));
+ offset = read_uleb128 (buf, &len);
+ assert (len == i + 1);
+ offset = offset * 4 + 0x204;
+ printf (_("vsp = vsp + %ld"), offset);
+ }
+ else
+ {
+ if (op == 0xb3 || op == 0xc6 || op == 0xc7 || op == 0xc8 || op == 0xc9)
+ {
+ GET_OP (op2);
+ printf (_("[unsupported two-byte opcode]"));
+ }
+ else
+ {
+ printf (_(" [unsupported opcode]"));
}
-
- dynamic_symbols = GET_ELF_SYMBOLS (file, §ion);
}
+ printf ("\n");
}
- /* Similarly find a string table. */
- if (dynamic_strings == NULL)
+ /* Decode the descriptors. Not implemented. */
+}
+
+static void
+dump_arm_unwind (struct arm_unw_aux_info *aux, Elf_Internal_Shdr *exidx_sec)
+{
+ struct arm_section exidx_arm_sec, extab_arm_sec;
+ unsigned int i, exidx_len;
+
+ memset (&exidx_arm_sec, 0, sizeof (exidx_arm_sec));
+ memset (&extab_arm_sec, 0, sizeof (extab_arm_sec));
+ exidx_len = exidx_sec->sh_size / 8;
+
+ for (i = 0; i < exidx_len; i++)
{
- for (entry = dynamic_section;
- entry < dynamic_section + dynamic_nent;
- ++entry)
+ unsigned int exidx_fn, exidx_entry;
+ struct absaddr fn_addr, entry_addr;
+ bfd_vma fn;
+
+ fputc ('\n', stdout);
+
+ if (!arm_section_get_word (aux, &exidx_arm_sec, exidx_sec,
+ 8 * i, &exidx_fn, &fn_addr)
+ || !arm_section_get_word (aux, &exidx_arm_sec, exidx_sec,
+ 8 * i + 4, &exidx_entry, &entry_addr))
{
- unsigned long offset;
- long str_tab_len;
+ arm_free_section (&exidx_arm_sec);
+ arm_free_section (&extab_arm_sec);
+ return;
+ }
- if (entry->d_tag != DT_STRTAB)
- continue;
+ fn = exidx_fn & 0x7fffffff;
+ if (fn & 0x40000000)
+ fn |= ~ (bfd_vma) 0x7fffffff;
+ fn = fn + exidx_sec->sh_addr + 8 * i;
- dynamic_info[DT_STRTAB] = entry->d_un.d_val;
+ arm_print_vma_and_name (aux, fn, entry_addr);
+ fputs (": ", stdout);
- /* Since we do not know how big the string table is,
- we default to reading in the entire file (!) and
- processing that. This is overkill, I know, but it
- should work. */
+ if (exidx_entry == 1)
+ {
+ print_vma (exidx_entry, PREFIX_HEX);
+ fputs (" [cantunwind]\n", stdout);
+ }
+ else if (exidx_entry & 0x80000000)
+ {
+ print_vma (exidx_entry, PREFIX_HEX);
+ fputc ('\n', stdout);
+ decode_arm_unwind (aux, exidx_entry, 4, 0, NULL, NULL);
+ }
+ else
+ {
+ bfd_vma table, table_offset = 0;
+ Elf_Internal_Shdr *table_sec;
- offset = offset_from_vma (file, entry->d_un.d_val, 0);
+ fputs ("@", stdout);
+ table = exidx_entry;
+ if (table & 0x40000000)
+ table |= ~ (bfd_vma) 0x7fffffff;
+ table = table + exidx_sec->sh_addr + 8 * i + 4;
+ print_vma (table, PREFIX_HEX);
+ printf ("\n");
- if (archive_file_offset != 0)
- str_tab_len = archive_file_size - offset;
- else
+ /* Locate the matching .ARM.extab. */
+ if (entry_addr.section != SHN_UNDEF
+ && entry_addr.section < elf_header.e_shnum)
{
- if (fseek (file, 0, SEEK_END))
- error (_("Unable to seek to end of file\n"));
- str_tab_len = ftell (file) - offset;
+ table_sec = section_headers + entry_addr.section;
+ table_offset = entry_addr.offset;
}
-
- if (str_tab_len < 1)
+ else
{
- error
- (_("Unable to determine the length of the dynamic string table\n"));
+ table_sec = find_section_by_address (table);
+ if (table_sec != NULL)
+ table_offset = table - table_sec->sh_addr;
+ }
+ if (table_sec == NULL)
+ {
+ warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
+ (unsigned long) table);
continue;
}
-
- dynamic_strings = get_data (NULL, file, offset, 1, str_tab_len,
- _("dynamic string table"));
- dynamic_strings_length = str_tab_len;
- break;
+ decode_arm_unwind (aux, 0, 0, table_offset, table_sec,
+ &extab_arm_sec);
}
}
- /* And find the syminfo section if available. */
- if (dynamic_syminfo == NULL)
- {
- unsigned long syminsz = 0;
+ printf ("\n");
- for (entry = dynamic_section;
- entry < dynamic_section + dynamic_nent;
- ++entry)
- {
- if (entry->d_tag == DT_SYMINENT)
- {
- /* Note: these braces are necessary to avoid a syntax
- error from the SunOS4 C compiler. */
- assert (sizeof (Elf_External_Syminfo) == entry->d_un.d_val);
- }
- else if (entry->d_tag == DT_SYMINSZ)
- syminsz = entry->d_un.d_val;
- else if (entry->d_tag == DT_SYMINFO)
- dynamic_syminfo_offset = offset_from_vma (file, entry->d_un.d_val,
- syminsz);
- }
+ arm_free_section (&exidx_arm_sec);
+ arm_free_section (&extab_arm_sec);
+}
- if (dynamic_syminfo_offset != 0 && syminsz != 0)
- {
- Elf_External_Syminfo *extsyminfo, *extsym;
- Elf_Internal_Syminfo *syminfo;
+static int
+arm_process_unwind (FILE *file)
+{
+ struct arm_unw_aux_info aux;
+ Elf_Internal_Shdr *unwsec = NULL;
+ Elf_Internal_Shdr *strsec;
+ Elf_Internal_Shdr *sec;
+ unsigned long i;
- /* There is a syminfo section. Read the data. */
- extsyminfo = get_data (NULL, file, dynamic_syminfo_offset, 1,
- syminsz, _("symbol information"));
- if (!extsyminfo)
- return 0;
+ memset (& aux, 0, sizeof (aux));
+ aux.file = file;
- dynamic_syminfo = malloc (syminsz);
- if (dynamic_syminfo == NULL)
- {
- error (_("Out of memory\n"));
- return 0;
- }
+ if (string_table == NULL)
+ return 1;
- dynamic_syminfo_nent = syminsz / sizeof (Elf_External_Syminfo);
- for (syminfo = dynamic_syminfo, extsym = extsyminfo;
- syminfo < dynamic_syminfo + dynamic_syminfo_nent;
- ++syminfo, ++extsym)
- {
- syminfo->si_boundto = BYTE_GET (extsym->si_boundto);
- syminfo->si_flags = BYTE_GET (extsym->si_flags);
- }
+ for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
+ {
+ if (sec->sh_type == SHT_SYMTAB && sec->sh_link < elf_header.e_shnum)
+ {
+ aux.nsyms = sec->sh_size / sec->sh_entsize;
+ aux.symtab = GET_ELF_SYMBOLS (file, sec);
- free (extsyminfo);
+ strsec = section_headers + sec->sh_link;
+ aux.strtab = get_data (NULL, file, strsec->sh_offset,
+ 1, strsec->sh_size, _("string table"));
+ aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
}
+ else if (sec->sh_type == SHT_ARM_EXIDX)
+ unwsec = sec;
}
- if (do_dynamic && dynamic_addr)
- printf (_("\nDynamic section at offset 0x%lx contains %u entries:\n"),
- dynamic_addr, dynamic_nent);
- if (do_dynamic)
- printf (_(" Tag Type Name/Value\n"));
+ if (!unwsec)
+ printf (_("\nThere are no unwind sections in this file.\n"));
- for (entry = dynamic_section;
- entry < dynamic_section + dynamic_nent;
- entry++)
+ for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
{
- if (do_dynamic)
+ if (sec->sh_type == SHT_ARM_EXIDX)
{
- const char *dtype;
+ printf (_("\nUnwind table index '%s' at offset 0x%lx contains %lu entries:\n"),
+ SECTION_NAME (sec),
+ (unsigned long) sec->sh_offset,
+ (unsigned long) (sec->sh_size / (2 * eh_addr_size)));
- putchar (' ');
- print_vma (entry->d_tag, FULL_HEX);
- dtype = get_dynamic_type (entry->d_tag);
- printf (" (%s)%*s", dtype,
- ((is_32bit_elf ? 27 : 19)
- - (int) strlen (dtype)),
- " ");
+ dump_arm_unwind (&aux, sec);
}
+ }
- switch (entry->d_tag)
- {
- case DT_FLAGS:
- if (do_dynamic)
- print_dynamic_flags (entry->d_un.d_val);
- break;
+ if (aux.symtab)
+ free (aux.symtab);
+ if (aux.strtab)
+ free ((char *) aux.strtab);
- case DT_AUXILIARY:
- case DT_FILTER:
- case DT_CONFIG:
- case DT_DEPAUDIT:
- case DT_AUDIT:
- if (do_dynamic)
- {
- switch (entry->d_tag)
- {
- case DT_AUXILIARY:
- printf (_("Auxiliary library"));
- break;
+ return 1;
+}
- case DT_FILTER:
- printf (_("Filter library"));
- break;
+static int
+process_unwind (FILE * file)
+{
+ struct unwind_handler
+ {
+ int machtype;
+ int (* handler)(FILE *);
+ } handlers[] =
+ {
+ { EM_ARM, arm_process_unwind },
+ { EM_IA_64, ia64_process_unwind },
+ { EM_PARISC, hppa_process_unwind },
+ { 0, 0 }
+ };
+ int i;
- case DT_CONFIG:
- printf (_("Configuration file"));
- break;
+ if (!do_unwind)
+ return 1;
- case DT_DEPAUDIT:
- printf (_("Dependency audit library"));
- break;
+ for (i = 0; handlers[i].handler != NULL; i++)
+ if (elf_header.e_machine == handlers[i].machtype)
+ return handlers[i].handler (file);
- case DT_AUDIT:
- printf (_("Audit library"));
- break;
- }
+ printf (_("\nThere are no unwind sections in this file.\n"));
+ return 1;
+}
- if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
- printf (": [%s]\n", GET_DYNAMIC_NAME (entry->d_un.d_val));
- else
- {
- printf (": ");
- print_vma (entry->d_un.d_val, PREFIX_HEX);
- putchar ('\n');
- }
- }
- break;
+static void
+dynamic_section_mips_val (Elf_Internal_Dyn * entry)
+{
+ switch (entry->d_tag)
+ {
+ case DT_MIPS_FLAGS:
+ if (entry->d_un.d_val == 0)
+ printf (_("NONE\n"));
+ else
+ {
+ static const char * opts[] =
+ {
+ "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
+ "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
+ "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
+ "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
+ "RLD_ORDER_SAFE"
+ };
+ unsigned int cnt;
+ int first = 1;
- case DT_FEATURE:
- if (do_dynamic)
- {
- printf (_("Flags:"));
+ for (cnt = 0; cnt < ARRAY_SIZE (opts); ++cnt)
+ if (entry->d_un.d_val & (1 << cnt))
+ {
+ printf ("%s%s", first ? "" : " ", opts[cnt]);
+ first = 0;
+ }
+ puts ("");
+ }
+ break;
- if (entry->d_un.d_val == 0)
- printf (_(" None\n"));
- else
- {
- unsigned long int val = entry->d_un.d_val;
+ case DT_MIPS_IVERSION:
+ if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
+ printf (_("Interface Version: %s\n"), GET_DYNAMIC_NAME (entry->d_un.d_val));
+ else
+ printf (_("<corrupt: %ld>\n"), (long) entry->d_un.d_ptr);
+ break;
- if (val & DTF_1_PARINIT)
- {
- printf (" PARINIT");
- val ^= DTF_1_PARINIT;
- }
- if (val & DTF_1_CONFEXP)
- {
- printf (" CONFEXP");
- val ^= DTF_1_CONFEXP;
- }
- if (val != 0)
- printf (" %lx", val);
- puts ("");
- }
- }
- break;
+ case DT_MIPS_TIME_STAMP:
+ {
+ char timebuf[20];
+ struct tm * tmp;
- case DT_POSFLAG_1:
- if (do_dynamic)
- {
- printf (_("Flags:"));
+ time_t atime = entry->d_un.d_val;
+ tmp = gmtime (&atime);
+ snprintf (timebuf, sizeof (timebuf), "%04u-%02u-%02uT%02u:%02u:%02u",
+ tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
+ tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
+ printf (_("Time Stamp: %s\n"), timebuf);
+ }
+ break;
- if (entry->d_un.d_val == 0)
- printf (_(" None\n"));
- else
- {
- unsigned long int val = entry->d_un.d_val;
+ case DT_MIPS_RLD_VERSION:
+ case DT_MIPS_LOCAL_GOTNO:
+ case DT_MIPS_CONFLICTNO:
+ case DT_MIPS_LIBLISTNO:
+ case DT_MIPS_SYMTABNO:
+ case DT_MIPS_UNREFEXTNO:
+ case DT_MIPS_HIPAGENO:
+ case DT_MIPS_DELTA_CLASS_NO:
+ case DT_MIPS_DELTA_INSTANCE_NO:
+ case DT_MIPS_DELTA_RELOC_NO:
+ case DT_MIPS_DELTA_SYM_NO:
+ case DT_MIPS_DELTA_CLASSSYM_NO:
+ case DT_MIPS_COMPACT_SIZE:
+ printf ("%ld\n", (long) entry->d_un.d_ptr);
+ break;
- if (val & DF_P1_LAZYLOAD)
- {
- printf (" LAZYLOAD");
- val ^= DF_P1_LAZYLOAD;
- }
- if (val & DF_P1_GROUPPERM)
- {
- printf (" GROUPPERM");
- val ^= DF_P1_GROUPPERM;
- }
- if (val != 0)
- printf (" %lx", val);
- puts ("");
- }
- }
- break;
+ default:
+ printf ("%#lx\n", (unsigned long) entry->d_un.d_ptr);
+ }
+}
- case DT_FLAGS_1:
- if (do_dynamic)
- {
- printf (_("Flags:"));
- if (entry->d_un.d_val == 0)
- printf (_(" None\n"));
- else
- {
- unsigned long int val = entry->d_un.d_val;
+static void
+dynamic_section_parisc_val (Elf_Internal_Dyn * entry)
+{
+ switch (entry->d_tag)
+ {
+ case DT_HP_DLD_FLAGS:
+ {
+ static struct
+ {
+ long int bit;
+ const char * str;
+ }
+ flags[] =
+ {
+ { DT_HP_DEBUG_PRIVATE, "HP_DEBUG_PRIVATE" },
+ { DT_HP_DEBUG_CALLBACK, "HP_DEBUG_CALLBACK" },
+ { DT_HP_DEBUG_CALLBACK_BOR, "HP_DEBUG_CALLBACK_BOR" },
+ { DT_HP_NO_ENVVAR, "HP_NO_ENVVAR" },
+ { DT_HP_BIND_NOW, "HP_BIND_NOW" },
+ { DT_HP_BIND_NONFATAL, "HP_BIND_NONFATAL" },
+ { DT_HP_BIND_VERBOSE, "HP_BIND_VERBOSE" },
+ { DT_HP_BIND_RESTRICTED, "HP_BIND_RESTRICTED" },
+ { DT_HP_BIND_SYMBOLIC, "HP_BIND_SYMBOLIC" },
+ { DT_HP_RPATH_FIRST, "HP_RPATH_FIRST" },
+ { DT_HP_BIND_DEPTH_FIRST, "HP_BIND_DEPTH_FIRST" },
+ { DT_HP_GST, "HP_GST" },
+ { DT_HP_SHLIB_FIXED, "HP_SHLIB_FIXED" },
+ { DT_HP_MERGE_SHLIB_SEG, "HP_MERGE_SHLIB_SEG" },
+ { DT_HP_NODELETE, "HP_NODELETE" },
+ { DT_HP_GROUP, "HP_GROUP" },
+ { DT_HP_PROTECT_LINKAGE_TABLE, "HP_PROTECT_LINKAGE_TABLE" }
+ };
+ int first = 1;
+ size_t cnt;
+ bfd_vma val = entry->d_un.d_val;
- if (val & DF_1_NOW)
- {
- printf (" NOW");
- val ^= DF_1_NOW;
- }
- if (val & DF_1_GLOBAL)
- {
- printf (" GLOBAL");
- val ^= DF_1_GLOBAL;
- }
- if (val & DF_1_GROUP)
- {
- printf (" GROUP");
- val ^= DF_1_GROUP;
- }
- if (val & DF_1_NODELETE)
- {
- printf (" NODELETE");
- val ^= DF_1_NODELETE;
- }
- if (val & DF_1_LOADFLTR)
- {
- printf (" LOADFLTR");
- val ^= DF_1_LOADFLTR;
- }
- if (val & DF_1_INITFIRST)
- {
- printf (" INITFIRST");
- val ^= DF_1_INITFIRST;
- }
- if (val & DF_1_NOOPEN)
- {
- printf (" NOOPEN");
- val ^= DF_1_NOOPEN;
- }
- if (val & DF_1_ORIGIN)
- {
- printf (" ORIGIN");
- val ^= DF_1_ORIGIN;
- }
- if (val & DF_1_DIRECT)
- {
- printf (" DIRECT");
- val ^= DF_1_DIRECT;
- }
- if (val & DF_1_TRANS)
- {
- printf (" TRANS");
- val ^= DF_1_TRANS;
- }
- if (val & DF_1_INTERPOSE)
- {
- printf (" INTERPOSE");
- val ^= DF_1_INTERPOSE;
- }
- if (val & DF_1_NODEFLIB)
- {
- printf (" NODEFLIB");
- val ^= DF_1_NODEFLIB;
- }
- if (val & DF_1_NODUMP)
- {
- printf (" NODUMP");
- val ^= DF_1_NODUMP;
- }
- if (val & DF_1_CONLFAT)
- {
- printf (" CONLFAT");
- val ^= DF_1_CONLFAT;
- }
- if (val != 0)
- printf (" %lx", val);
- puts ("");
- }
+ for (cnt = 0; cnt < ARRAY_SIZE (flags); ++cnt)
+ if (val & flags[cnt].bit)
+ {
+ if (! first)
+ putchar (' ');
+ fputs (flags[cnt].str, stdout);
+ first = 0;
+ val ^= flags[cnt].bit;
}
- break;
- case DT_PLTREL:
- dynamic_info[entry->d_tag] = entry->d_un.d_val;
- if (do_dynamic)
- puts (get_dynamic_type (entry->d_un.d_val));
- break;
+ if (val != 0 || first)
+ {
+ if (! first)
+ putchar (' ');
+ print_vma (val, HEX);
+ }
+ }
+ break;
- case DT_NULL :
- case DT_NEEDED :
- case DT_PLTGOT :
- case DT_HASH :
- case DT_STRTAB :
- case DT_SYMTAB :
- case DT_RELA :
- case DT_INIT :
- case DT_FINI :
- case DT_SONAME :
- case DT_RPATH :
- case DT_SYMBOLIC:
- case DT_REL :
- case DT_DEBUG :
- case DT_TEXTREL :
- case DT_JMPREL :
- case DT_RUNPATH :
- dynamic_info[entry->d_tag] = entry->d_un.d_val;
+ default:
+ print_vma (entry->d_un.d_ptr, PREFIX_HEX);
+ break;
+ }
+ putchar ('\n');
+}
- if (do_dynamic)
- {
- char *name;
+static void
+dynamic_section_ia64_val (Elf_Internal_Dyn * entry)
+{
+ switch (entry->d_tag)
+ {
+ case DT_IA_64_PLT_RESERVE:
+ /* First 3 slots reserved. */
+ print_vma (entry->d_un.d_ptr, PREFIX_HEX);
+ printf (" -- ");
+ print_vma (entry->d_un.d_ptr + (3 * 8), PREFIX_HEX);
+ break;
- if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
- name = GET_DYNAMIC_NAME (entry->d_un.d_val);
- else
- name = NULL;
+ default:
+ print_vma (entry->d_un.d_ptr, PREFIX_HEX);
+ break;
+ }
+ putchar ('\n');
+}
- if (name)
- {
- switch (entry->d_tag)
- {
- case DT_NEEDED:
- printf (_("Shared library: [%s]"), name);
+static int
+get_32bit_dynamic_section (FILE * file)
+{
+ Elf32_External_Dyn * edyn;
+ Elf32_External_Dyn * ext;
+ Elf_Internal_Dyn * entry;
- if (streq (name, program_interpreter))
- printf (_(" program interpreter"));
- break;
+ edyn = (Elf32_External_Dyn *) get_data (NULL, file, dynamic_addr, 1,
+ dynamic_size, _("dynamic section"));
+ if (!edyn)
+ return 0;
- case DT_SONAME:
- printf (_("Library soname: [%s]"), name);
- break;
+/* SGI's ELF has more than one section in the DYNAMIC segment, and we
+ might not have the luxury of section headers. Look for the DT_NULL
+ terminator to determine the number of entries. */
+ for (ext = edyn, dynamic_nent = 0;
+ (char *) ext < (char *) edyn + dynamic_size;
+ ext++)
+ {
+ dynamic_nent++;
+ if (BYTE_GET (ext->d_tag) == DT_NULL)
+ break;
+ }
- case DT_RPATH:
- printf (_("Library rpath: [%s]"), name);
- break;
+ dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
+ sizeof (* entry));
+ if (dynamic_section == NULL)
+ {
+ error (_("Out of memory\n"));
+ free (edyn);
+ return 0;
+ }
- case DT_RUNPATH:
- printf (_("Library runpath: [%s]"), name);
- break;
+ for (ext = edyn, entry = dynamic_section;
+ entry < dynamic_section + dynamic_nent;
+ ext++, entry++)
+ {
+ entry->d_tag = BYTE_GET (ext->d_tag);
+ entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
+ }
- default:
- print_vma (entry->d_un.d_val, PREFIX_HEX);
- break;
- }
- }
- else
- print_vma (entry->d_un.d_val, PREFIX_HEX);
+ free (edyn);
- putchar ('\n');
- }
- break;
+ return 1;
+}
- case DT_PLTRELSZ:
- case DT_RELASZ :
- case DT_STRSZ :
- case DT_RELSZ :
- case DT_RELAENT :
- case DT_SYMENT :
- case DT_RELENT :
- dynamic_info[entry->d_tag] = entry->d_un.d_val;
- case DT_PLTPADSZ:
- case DT_MOVEENT :
- case DT_MOVESZ :
- case DT_INIT_ARRAYSZ:
- case DT_FINI_ARRAYSZ:
- case DT_GNU_CONFLICTSZ:
- case DT_GNU_LIBLISTSZ:
- if (do_dynamic)
- {
- print_vma (entry->d_un.d_val, UNSIGNED);
- printf (" (bytes)\n");
- }
- break;
+static int
+get_64bit_dynamic_section (FILE * file)
+{
+ Elf64_External_Dyn * edyn;
+ Elf64_External_Dyn * ext;
+ Elf_Internal_Dyn * entry;
- case DT_VERDEFNUM:
- case DT_VERNEEDNUM:
- case DT_RELACOUNT:
- case DT_RELCOUNT:
- if (do_dynamic)
- {
- print_vma (entry->d_un.d_val, UNSIGNED);
- putchar ('\n');
- }
- break;
+ edyn = (Elf64_External_Dyn *) get_data (NULL, file, dynamic_addr, 1,
+ dynamic_size, _("dynamic section"));
+ if (!edyn)
+ return 0;
- case DT_SYMINSZ:
- case DT_SYMINENT:
- case DT_SYMINFO:
- case DT_USED:
- case DT_INIT_ARRAY:
- case DT_FINI_ARRAY:
- if (do_dynamic)
- {
- if (entry->d_tag == DT_USED
- && VALID_DYNAMIC_NAME (entry->d_un.d_val))
- {
- char *name = GET_DYNAMIC_NAME (entry->d_un.d_val);
+/* SGI's ELF has more than one section in the DYNAMIC segment, and we
+ might not have the luxury of section headers. Look for the DT_NULL
+ terminator to determine the number of entries. */
+ for (ext = edyn, dynamic_nent = 0;
+ (char *) ext < (char *) edyn + dynamic_size;
+ ext++)
+ {
+ dynamic_nent++;
+ if (BYTE_GET (ext->d_tag) == DT_NULL)
+ break;
+ }
- if (*name)
- {
- printf (_("Not needed object: [%s]\n"), name);
- break;
- }
- }
+ dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
+ sizeof (* entry));
+ if (dynamic_section == NULL)
+ {
+ error (_("Out of memory\n"));
+ free (edyn);
+ return 0;
+ }
- print_vma (entry->d_un.d_val, PREFIX_HEX);
- putchar ('\n');
- }
- break;
+ for (ext = edyn, entry = dynamic_section;
+ entry < dynamic_section + dynamic_nent;
+ ext++, entry++)
+ {
+ entry->d_tag = BYTE_GET (ext->d_tag);
+ entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
+ }
- case DT_BIND_NOW:
- /* The value of this entry is ignored. */
- if (do_dynamic)
- putchar ('\n');
- break;
+ free (edyn);
- case DT_GNU_PRELINKED:
- if (do_dynamic)
- {
- struct tm *tmp;
- time_t time = entry->d_un.d_val;
+ return 1;
+}
- tmp = gmtime (&time);
- printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
- tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
- tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
+static void
+print_dynamic_flags (bfd_vma flags)
+{
+ int first = 1;
- }
- break;
+ while (flags)
+ {
+ bfd_vma flag;
- case DT_GNU_HASH:
- dynamic_info_DT_GNU_HASH = entry->d_un.d_val;
- if (do_dynamic)
- {
- print_vma (entry->d_un.d_val, PREFIX_HEX);
- putchar ('\n');
- }
- break;
+ flag = flags & - flags;
+ flags &= ~ flag;
- default:
- if ((entry->d_tag >= DT_VERSYM) && (entry->d_tag <= DT_VERNEEDNUM))
- version_info[DT_VERSIONTAGIDX (entry->d_tag)] =
- entry->d_un.d_val;
+ if (first)
+ first = 0;
+ else
+ putc (' ', stdout);
- if (do_dynamic)
- {
- switch (elf_header.e_machine)
- {
- case EM_MIPS:
- case EM_MIPS_RS3_LE:
- dynamic_section_mips_val (entry);
- break;
- case EM_PARISC:
- dynamic_section_parisc_val (entry);
- break;
- case EM_IA_64:
- dynamic_section_ia64_val (entry);
- break;
- default:
- print_vma (entry->d_un.d_val, PREFIX_HEX);
- putchar ('\n');
- }
- }
- break;
+ switch (flag)
+ {
+ case DF_ORIGIN: fputs ("ORIGIN", stdout); break;
+ case DF_SYMBOLIC: fputs ("SYMBOLIC", stdout); break;
+ case DF_TEXTREL: fputs ("TEXTREL", stdout); break;
+ case DF_BIND_NOW: fputs ("BIND_NOW", stdout); break;
+ case DF_STATIC_TLS: fputs ("STATIC_TLS", stdout); break;
+ default: fputs (_("unknown"), stdout); break;
}
}
-
- return 1;
+ puts ("");
}
-static char *
-get_ver_flags (unsigned int flags)
+/* Parse and display the contents of the dynamic section. */
+
+static int
+process_dynamic_section (FILE * file)
{
- static char buff[32];
+ Elf_Internal_Dyn * entry;
- buff[0] = 0;
+ if (dynamic_size == 0)
+ {
+ if (do_dynamic)
+ printf (_("\nThere is no dynamic section in this file.\n"));
- if (flags == 0)
- return _("none");
+ return 1;
+ }
- if (flags & VER_FLG_BASE)
- strcat (buff, "BASE ");
+ if (is_32bit_elf)
+ {
+ if (! get_32bit_dynamic_section (file))
+ return 0;
+ }
+ else if (! get_64bit_dynamic_section (file))
+ return 0;
- if (flags & VER_FLG_WEAK)
+ /* Find the appropriate symbol table. */
+ if (dynamic_symbols == NULL)
{
- if (flags & VER_FLG_BASE)
- strcat (buff, "| ");
+ for (entry = dynamic_section;
+ entry < dynamic_section + dynamic_nent;
+ ++entry)
+ {
+ Elf_Internal_Shdr section;
- strcat (buff, "WEAK ");
- }
+ if (entry->d_tag != DT_SYMTAB)
+ continue;
- if (flags & ~(VER_FLG_BASE | VER_FLG_WEAK))
- strcat (buff, "| <unknown>");
+ dynamic_info[DT_SYMTAB] = entry->d_un.d_val;
- return buff;
-}
+ /* Since we do not know how big the symbol table is,
+ we default to reading in the entire file (!) and
+ processing that. This is overkill, I know, but it
+ should work. */
+ section.sh_offset = offset_from_vma (file, entry->d_un.d_val, 0);
-/* Display the contents of the version sections. */
-static int
-process_version_sections (FILE *file)
-{
- Elf_Internal_Shdr *section;
- unsigned i;
- int found = 0;
+ if (archive_file_offset != 0)
+ section.sh_size = archive_file_size - section.sh_offset;
+ else
+ {
+ if (fseek (file, 0, SEEK_END))
+ error (_("Unable to seek to end of file!\n"));
- if (! do_version)
- return 1;
+ section.sh_size = ftell (file) - section.sh_offset;
+ }
- for (i = 0, section = section_headers;
- i < elf_header.e_shnum;
- i++, section++)
+ if (is_32bit_elf)
+ section.sh_entsize = sizeof (Elf32_External_Sym);
+ else
+ section.sh_entsize = sizeof (Elf64_External_Sym);
+
+ num_dynamic_syms = section.sh_size / section.sh_entsize;
+ if (num_dynamic_syms < 1)
+ {
+ error (_("Unable to determine the number of symbols to load\n"));
+ continue;
+ }
+
+ dynamic_symbols = GET_ELF_SYMBOLS (file, §ion);
+ }
+ }
+
+ /* Similarly find a string table. */
+ if (dynamic_strings == NULL)
{
- switch (section->sh_type)
+ for (entry = dynamic_section;
+ entry < dynamic_section + dynamic_nent;
+ ++entry)
{
- case SHT_GNU_verdef:
- {
- Elf_External_Verdef *edefs;
- unsigned int idx;
- unsigned int cnt;
- char *endbuf;
+ unsigned long offset;
+ long str_tab_len;
- found = 1;
+ if (entry->d_tag != DT_STRTAB)
+ continue;
- printf
- (_("\nVersion definition section '%s' contains %u entries:\n"),
- SECTION_NAME (section), section->sh_info);
+ dynamic_info[DT_STRTAB] = entry->d_un.d_val;
- printf (_(" Addr: 0x"));
- printf_vma (section->sh_addr);
- printf (_(" Offset: %#08lx Link: %u (%s)\n"),
- (unsigned long) section->sh_offset, section->sh_link,
- section->sh_link < elf_header.e_shnum
- ? SECTION_NAME (section_headers + section->sh_link)
- : "<corrupt>");
+ /* Since we do not know how big the string table is,
+ we default to reading in the entire file (!) and
+ processing that. This is overkill, I know, but it
+ should work. */
- edefs = get_data (NULL, file, section->sh_offset, 1,
- section->sh_size,
- _("version definition section"));
- endbuf = (char *) edefs + section->sh_size;
- if (!edefs)
- break;
-
- for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
- {
- char *vstart;
- Elf_External_Verdef *edef;
- Elf_Internal_Verdef ent;
- Elf_External_Verdaux *eaux;
- Elf_Internal_Verdaux aux;
- int j;
- int isum;
-
- vstart = ((char *) edefs) + idx;
- if (vstart + sizeof (*edef) > endbuf)
- break;
-
- edef = (Elf_External_Verdef *) vstart;
+ offset = offset_from_vma (file, entry->d_un.d_val, 0);
- ent.vd_version = BYTE_GET (edef->vd_version);
- ent.vd_flags = BYTE_GET (edef->vd_flags);
- ent.vd_ndx = BYTE_GET (edef->vd_ndx);
- ent.vd_cnt = BYTE_GET (edef->vd_cnt);
- ent.vd_hash = BYTE_GET (edef->vd_hash);
- ent.vd_aux = BYTE_GET (edef->vd_aux);
- ent.vd_next = BYTE_GET (edef->vd_next);
+ if (archive_file_offset != 0)
+ str_tab_len = archive_file_size - offset;
+ else
+ {
+ if (fseek (file, 0, SEEK_END))
+ error (_("Unable to seek to end of file\n"));
+ str_tab_len = ftell (file) - offset;
+ }
- printf (_(" %#06x: Rev: %d Flags: %s"),
- idx, ent.vd_version, get_ver_flags (ent.vd_flags));
+ if (str_tab_len < 1)
+ {
+ error
+ (_("Unable to determine the length of the dynamic string table\n"));
+ continue;
+ }
- printf (_(" Index: %d Cnt: %d "),
- ent.vd_ndx, ent.vd_cnt);
+ dynamic_strings = (char *) get_data (NULL, file, offset, 1,
+ str_tab_len,
+ _("dynamic string table"));
+ dynamic_strings_length = str_tab_len;
+ break;
+ }
+ }
- vstart += ent.vd_aux;
+ /* And find the syminfo section if available. */
+ if (dynamic_syminfo == NULL)
+ {
+ unsigned long syminsz = 0;
- eaux = (Elf_External_Verdaux *) vstart;
+ for (entry = dynamic_section;
+ entry < dynamic_section + dynamic_nent;
+ ++entry)
+ {
+ if (entry->d_tag == DT_SYMINENT)
+ {
+ /* Note: these braces are necessary to avoid a syntax
+ error from the SunOS4 C compiler. */
+ assert (sizeof (Elf_External_Syminfo) == entry->d_un.d_val);
+ }
+ else if (entry->d_tag == DT_SYMINSZ)
+ syminsz = entry->d_un.d_val;
+ else if (entry->d_tag == DT_SYMINFO)
+ dynamic_syminfo_offset = offset_from_vma (file, entry->d_un.d_val,
+ syminsz);
+ }
- aux.vda_name = BYTE_GET (eaux->vda_name);
- aux.vda_next = BYTE_GET (eaux->vda_next);
+ if (dynamic_syminfo_offset != 0 && syminsz != 0)
+ {
+ Elf_External_Syminfo * extsyminfo;
+ Elf_External_Syminfo * extsym;
+ Elf_Internal_Syminfo * syminfo;
- if (VALID_DYNAMIC_NAME (aux.vda_name))
- printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux.vda_name));
- else
- printf (_("Name index: %ld\n"), aux.vda_name);
+ /* There is a syminfo section. Read the data. */
+ extsyminfo = (Elf_External_Syminfo *)
+ get_data (NULL, file, dynamic_syminfo_offset, 1, syminsz,
+ _("symbol information"));
+ if (!extsyminfo)
+ return 0;
- isum = idx + ent.vd_aux;
+ dynamic_syminfo = (Elf_Internal_Syminfo *) malloc (syminsz);
+ if (dynamic_syminfo == NULL)
+ {
+ error (_("Out of memory\n"));
+ return 0;
+ }
- for (j = 1; j < ent.vd_cnt; j++)
- {
- isum += aux.vda_next;
- vstart += aux.vda_next;
+ dynamic_syminfo_nent = syminsz / sizeof (Elf_External_Syminfo);
+ for (syminfo = dynamic_syminfo, extsym = extsyminfo;
+ syminfo < dynamic_syminfo + dynamic_syminfo_nent;
+ ++syminfo, ++extsym)
+ {
+ syminfo->si_boundto = BYTE_GET (extsym->si_boundto);
+ syminfo->si_flags = BYTE_GET (extsym->si_flags);
+ }
- eaux = (Elf_External_Verdaux *) vstart;
- if (vstart + sizeof (*eaux) > endbuf)
- break;
+ free (extsyminfo);
+ }
+ }
- aux.vda_name = BYTE_GET (eaux->vda_name);
- aux.vda_next = BYTE_GET (eaux->vda_next);
+ if (do_dynamic && dynamic_addr)
+ printf (_("\nDynamic section at offset 0x%lx contains %u entries:\n"),
+ dynamic_addr, dynamic_nent);
+ if (do_dynamic)
+ printf (_(" Tag Type Name/Value\n"));
- if (VALID_DYNAMIC_NAME (aux.vda_name))
- printf (_(" %#06x: Parent %d: %s\n"),
- isum, j, GET_DYNAMIC_NAME (aux.vda_name));
- else
- printf (_(" %#06x: Parent %d, name index: %ld\n"),
- isum, j, aux.vda_name);
- }
- if (j < ent.vd_cnt)
- printf (_(" Version def aux past end of section\n"));
+ for (entry = dynamic_section;
+ entry < dynamic_section + dynamic_nent;
+ entry++)
+ {
+ if (do_dynamic)
+ {
+ const char * dtype;
- idx += ent.vd_next;
- }
- if (cnt < section->sh_info)
- printf (_(" Version definition past end of section\n"));
+ putchar (' ');
+ print_vma (entry->d_tag, FULL_HEX);
+ dtype = get_dynamic_type (entry->d_tag);
+ printf (" (%s)%*s", dtype,
+ ((is_32bit_elf ? 27 : 19)
+ - (int) strlen (dtype)),
+ " ");
+ }
- free (edefs);
- }
+ switch (entry->d_tag)
+ {
+ case DT_FLAGS:
+ if (do_dynamic)
+ print_dynamic_flags (entry->d_un.d_val);
break;
- case SHT_GNU_verneed:
- {
- Elf_External_Verneed *eneed;
- unsigned int idx;
- unsigned int cnt;
- char *endbuf;
-
- found = 1;
-
- printf (_("\nVersion needs section '%s' contains %u entries:\n"),
- SECTION_NAME (section), section->sh_info);
-
- printf (_(" Addr: 0x"));
- printf_vma (section->sh_addr);
- printf (_(" Offset: %#08lx Link: %u (%s)\n"),
- (unsigned long) section->sh_offset, section->sh_link,
- section->sh_link < elf_header.e_shnum
- ? SECTION_NAME (section_headers + section->sh_link)
- : "<corrupt>");
-
- eneed = get_data (NULL, file, section->sh_offset, 1,
- section->sh_size,
- _("version need section"));
- endbuf = (char *) eneed + section->sh_size;
- if (!eneed)
- break;
+ case DT_AUXILIARY:
+ case DT_FILTER:
+ case DT_CONFIG:
+ case DT_DEPAUDIT:
+ case DT_AUDIT:
+ if (do_dynamic)
+ {
+ switch (entry->d_tag)
+ {
+ case DT_AUXILIARY:
+ printf (_("Auxiliary library"));
+ break;
- for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
- {
- Elf_External_Verneed *entry;
- Elf_Internal_Verneed ent;
- int j;
- int isum;
- char *vstart;
+ case DT_FILTER:
+ printf (_("Filter library"));
+ break;
- vstart = ((char *) eneed) + idx;
- if (vstart + sizeof (*entry) > endbuf)
+ case DT_CONFIG:
+ printf (_("Configuration file"));
break;
- entry = (Elf_External_Verneed *) vstart;
+ case DT_DEPAUDIT:
+ printf (_("Dependency audit library"));
+ break;
- ent.vn_version = BYTE_GET (entry->vn_version);
- ent.vn_cnt = BYTE_GET (entry->vn_cnt);
- ent.vn_file = BYTE_GET (entry->vn_file);
- ent.vn_aux = BYTE_GET (entry->vn_aux);
- ent.vn_next = BYTE_GET (entry->vn_next);
+ case DT_AUDIT:
+ printf (_("Audit library"));
+ break;
+ }
- printf (_(" %#06x: Version: %d"), idx, ent.vn_version);
+ if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
+ printf (": [%s]\n", GET_DYNAMIC_NAME (entry->d_un.d_val));
+ else
+ {
+ printf (": ");
+ print_vma (entry->d_un.d_val, PREFIX_HEX);
+ putchar ('\n');
+ }
+ }
+ break;
- if (VALID_DYNAMIC_NAME (ent.vn_file))
- printf (_(" File: %s"), GET_DYNAMIC_NAME (ent.vn_file));
- else
- printf (_(" File: %lx"), ent.vn_file);
+ case DT_FEATURE:
+ if (do_dynamic)
+ {
+ printf (_("Flags:"));
- printf (_(" Cnt: %d\n"), ent.vn_cnt);
+ if (entry->d_un.d_val == 0)
+ printf (_(" None\n"));
+ else
+ {
+ unsigned long int val = entry->d_un.d_val;
- vstart += ent.vn_aux;
+ if (val & DTF_1_PARINIT)
+ {
+ printf (" PARINIT");
+ val ^= DTF_1_PARINIT;
+ }
+ if (val & DTF_1_CONFEXP)
+ {
+ printf (" CONFEXP");
+ val ^= DTF_1_CONFEXP;
+ }
+ if (val != 0)
+ printf (" %lx", val);
+ puts ("");
+ }
+ }
+ break;
- for (j = 0, isum = idx + ent.vn_aux; j < ent.vn_cnt; ++j)
- {
- Elf_External_Vernaux *eaux;
- Elf_Internal_Vernaux aux;
+ case DT_POSFLAG_1:
+ if (do_dynamic)
+ {
+ printf (_("Flags:"));
- if (vstart + sizeof (*eaux) > endbuf)
- break;
- eaux = (Elf_External_Vernaux *) vstart;
+ if (entry->d_un.d_val == 0)
+ printf (_(" None\n"));
+ else
+ {
+ unsigned long int val = entry->d_un.d_val;
- aux.vna_hash = BYTE_GET (eaux->vna_hash);
- aux.vna_flags = BYTE_GET (eaux->vna_flags);
- aux.vna_other = BYTE_GET (eaux->vna_other);
- aux.vna_name = BYTE_GET (eaux->vna_name);
- aux.vna_next = BYTE_GET (eaux->vna_next);
-
- if (VALID_DYNAMIC_NAME (aux.vna_name))
- printf (_(" %#06x: Name: %s"),
- isum, GET_DYNAMIC_NAME (aux.vna_name));
- else
- printf (_(" %#06x: Name index: %lx"),
- isum, aux.vna_name);
-
- printf (_(" Flags: %s Version: %d\n"),
- get_ver_flags (aux.vna_flags), aux.vna_other);
-
- isum += aux.vna_next;
- vstart += aux.vna_next;
- }
- if (j < ent.vn_cnt)
- printf (_(" Version need aux past end of section\n"));
-
- idx += ent.vn_next;
- }
- if (cnt < section->sh_info)
- printf (_(" Version need past end of section\n"));
-
- free (eneed);
- }
+ if (val & DF_P1_LAZYLOAD)
+ {
+ printf (" LAZYLOAD");
+ val ^= DF_P1_LAZYLOAD;
+ }
+ if (val & DF_P1_GROUPPERM)
+ {
+ printf (" GROUPPERM");
+ val ^= DF_P1_GROUPPERM;
+ }
+ if (val != 0)
+ printf (" %lx", val);
+ puts ("");
+ }
+ }
break;
- case SHT_GNU_versym:
- {
- Elf_Internal_Shdr *link_section;
- int total;
- int cnt;
- unsigned char *edata;
- unsigned short *data;
- char *strtab;
- Elf_Internal_Sym *symbols;
- Elf_Internal_Shdr *string_sec;
- long off;
-
- if (section->sh_link >= elf_header.e_shnum)
- break;
-
- link_section = section_headers + section->sh_link;
- total = section->sh_size / sizeof (Elf_External_Versym);
-
- if (link_section->sh_link >= elf_header.e_shnum)
- break;
-
- found = 1;
-
- symbols = GET_ELF_SYMBOLS (file, link_section);
-
- string_sec = section_headers + link_section->sh_link;
-
- strtab = get_data (NULL, file, string_sec->sh_offset, 1,
- string_sec->sh_size, _("version string table"));
- if (!strtab)
- break;
+ case DT_FLAGS_1:
+ if (do_dynamic)
+ {
+ printf (_("Flags:"));
+ if (entry->d_un.d_val == 0)
+ printf (_(" None\n"));
+ else
+ {
+ unsigned long int val = entry->d_un.d_val;
- printf (_("\nVersion symbols section '%s' contains %d entries:\n"),
- SECTION_NAME (section), total);
+ if (val & DF_1_NOW)
+ {
+ printf (" NOW");
+ val ^= DF_1_NOW;
+ }
+ if (val & DF_1_GLOBAL)
+ {
+ printf (" GLOBAL");
+ val ^= DF_1_GLOBAL;
+ }
+ if (val & DF_1_GROUP)
+ {
+ printf (" GROUP");
+ val ^= DF_1_GROUP;
+ }
+ if (val & DF_1_NODELETE)
+ {
+ printf (" NODELETE");
+ val ^= DF_1_NODELETE;
+ }
+ if (val & DF_1_LOADFLTR)
+ {
+ printf (" LOADFLTR");
+ val ^= DF_1_LOADFLTR;
+ }
+ if (val & DF_1_INITFIRST)
+ {
+ printf (" INITFIRST");
+ val ^= DF_1_INITFIRST;
+ }
+ if (val & DF_1_NOOPEN)
+ {
+ printf (" NOOPEN");
+ val ^= DF_1_NOOPEN;
+ }
+ if (val & DF_1_ORIGIN)
+ {
+ printf (" ORIGIN");
+ val ^= DF_1_ORIGIN;
+ }
+ if (val & DF_1_DIRECT)
+ {
+ printf (" DIRECT");
+ val ^= DF_1_DIRECT;
+ }
+ if (val & DF_1_TRANS)
+ {
+ printf (" TRANS");
+ val ^= DF_1_TRANS;
+ }
+ if (val & DF_1_INTERPOSE)
+ {
+ printf (" INTERPOSE");
+ val ^= DF_1_INTERPOSE;
+ }
+ if (val & DF_1_NODEFLIB)
+ {
+ printf (" NODEFLIB");
+ val ^= DF_1_NODEFLIB;
+ }
+ if (val & DF_1_NODUMP)
+ {
+ printf (" NODUMP");
+ val ^= DF_1_NODUMP;
+ }
+ if (val & DF_1_CONLFAT)
+ {
+ printf (" CONLFAT");
+ val ^= DF_1_CONLFAT;
+ }
+ if (val != 0)
+ printf (" %lx", val);
+ puts ("");
+ }
+ }
+ break;
- printf (_(" Addr: "));
- printf_vma (section->sh_addr);
- printf (_(" Offset: %#08lx Link: %u (%s)\n"),
- (unsigned long) section->sh_offset, section->sh_link,
- SECTION_NAME (link_section));
+ case DT_PLTREL:
+ dynamic_info[entry->d_tag] = entry->d_un.d_val;
+ if (do_dynamic)
+ puts (get_dynamic_type (entry->d_un.d_val));
+ break;
- off = offset_from_vma (file,
- version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
- total * sizeof (short));
- edata = get_data (NULL, file, off, total, sizeof (short),
- _("version symbol data"));
- if (!edata)
- {
- free (strtab);
- break;
- }
+ case DT_NULL :
+ case DT_NEEDED :
+ case DT_PLTGOT :
+ case DT_HASH :
+ case DT_STRTAB :
+ case DT_SYMTAB :
+ case DT_RELA :
+ case DT_INIT :
+ case DT_FINI :
+ case DT_SONAME :
+ case DT_RPATH :
+ case DT_SYMBOLIC:
+ case DT_REL :
+ case DT_DEBUG :
+ case DT_TEXTREL :
+ case DT_JMPREL :
+ case DT_RUNPATH :
+ dynamic_info[entry->d_tag] = entry->d_un.d_val;
- data = cmalloc (total, sizeof (short));
+ if (do_dynamic)
+ {
+ char * name;
- for (cnt = total; cnt --;)
- data[cnt] = byte_get (edata + cnt * sizeof (short),
- sizeof (short));
+ if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
+ name = GET_DYNAMIC_NAME (entry->d_un.d_val);
+ else
+ name = NULL;
- free (edata);
+ if (name)
+ {
+ switch (entry->d_tag)
+ {
+ case DT_NEEDED:
+ printf (_("Shared library: [%s]"), name);
- for (cnt = 0; cnt < total; cnt += 4)
- {
- int j, nn;
- int check_def, check_need;
- char *name;
+ if (streq (name, program_interpreter))
+ printf (_(" program interpreter"));
+ break;
- printf (" %03x:", cnt);
+ case DT_SONAME:
+ printf (_("Library soname: [%s]"), name);
+ break;
- for (j = 0; (j < 4) && (cnt + j) < total; ++j)
- switch (data[cnt + j])
- {
- case 0:
- fputs (_(" 0 (*local*) "), stdout);
+ case DT_RPATH:
+ printf (_("Library rpath: [%s]"), name);
break;
- case 1:
- fputs (_(" 1 (*global*) "), stdout);
+ case DT_RUNPATH:
+ printf (_("Library runpath: [%s]"), name);
break;
default:
- nn = printf ("%4x%c", data[cnt + j] & 0x7fff,
- data[cnt + j] & 0x8000 ? 'h' : ' ');
-
- check_def = 1;
- check_need = 1;
- if (symbols[cnt + j].st_shndx >= elf_header.e_shnum
- || section_headers[symbols[cnt + j].st_shndx].sh_type
- != SHT_NOBITS)
- {
- if (symbols[cnt + j].st_shndx == SHN_UNDEF)
- check_def = 0;
- else
- check_need = 0;
- }
+ print_vma (entry->d_un.d_val, PREFIX_HEX);
+ break;
+ }
+ }
+ else
+ print_vma (entry->d_un.d_val, PREFIX_HEX);
- if (check_need
- && version_info[DT_VERSIONTAGIDX (DT_VERNEED)])
- {
- Elf_Internal_Verneed ivn;
- unsigned long offset;
+ putchar ('\n');
+ }
+ break;
- offset = offset_from_vma
- (file, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
- sizeof (Elf_External_Verneed));
-
- do
- {
- Elf_Internal_Vernaux ivna;
- Elf_External_Verneed evn;
- Elf_External_Vernaux evna;
- unsigned long a_off;
-
- get_data (&evn, file, offset, sizeof (evn), 1,
- _("version need"));
-
- ivn.vn_aux = BYTE_GET (evn.vn_aux);
- ivn.vn_next = BYTE_GET (evn.vn_next);
-
- a_off = offset + ivn.vn_aux;
+ case DT_PLTRELSZ:
+ case DT_RELASZ :
+ case DT_STRSZ :
+ case DT_RELSZ :
+ case DT_RELAENT :
+ case DT_SYMENT :
+ case DT_RELENT :
+ dynamic_info[entry->d_tag] = entry->d_un.d_val;
+ case DT_PLTPADSZ:
+ case DT_MOVEENT :
+ case DT_MOVESZ :
+ case DT_INIT_ARRAYSZ:
+ case DT_FINI_ARRAYSZ:
+ case DT_GNU_CONFLICTSZ:
+ case DT_GNU_LIBLISTSZ:
+ if (do_dynamic)
+ {
+ print_vma (entry->d_un.d_val, UNSIGNED);
+ printf (_(" (bytes)\n"));
+ }
+ break;
- do
- {
- get_data (&evna, file, a_off, sizeof (evna),
- 1, _("version need aux (2)"));
+ case DT_VERDEFNUM:
+ case DT_VERNEEDNUM:
+ case DT_RELACOUNT:
+ case DT_RELCOUNT:
+ if (do_dynamic)
+ {
+ print_vma (entry->d_un.d_val, UNSIGNED);
+ putchar ('\n');
+ }
+ break;
- ivna.vna_next = BYTE_GET (evna.vna_next);
- ivna.vna_other = BYTE_GET (evna.vna_other);
+ case DT_SYMINSZ:
+ case DT_SYMINENT:
+ case DT_SYMINFO:
+ case DT_USED:
+ case DT_INIT_ARRAY:
+ case DT_FINI_ARRAY:
+ if (do_dynamic)
+ {
+ if (entry->d_tag == DT_USED
+ && VALID_DYNAMIC_NAME (entry->d_un.d_val))
+ {
+ char * name = GET_DYNAMIC_NAME (entry->d_un.d_val);
- a_off += ivna.vna_next;
- }
- while (ivna.vna_other != data[cnt + j]
- && ivna.vna_next != 0);
+ if (*name)
+ {
+ printf (_("Not needed object: [%s]\n"), name);
+ break;
+ }
+ }
- if (ivna.vna_other == data[cnt + j])
- {
- ivna.vna_name = BYTE_GET (evna.vna_name);
+ print_vma (entry->d_un.d_val, PREFIX_HEX);
+ putchar ('\n');
+ }
+ break;
- if (ivna.vna_name >= string_sec->sh_size)
- name = _("*invalid*");
- else
- name = strtab + ivna.vna_name;
- nn += printf ("(%s%-*s",
- name,
- 12 - (int) strlen (name),
- ")");
- check_def = 0;
- break;
- }
+ case DT_BIND_NOW:
+ /* The value of this entry is ignored. */
+ if (do_dynamic)
+ putchar ('\n');
+ break;
- offset += ivn.vn_next;
- }
- while (ivn.vn_next);
- }
+ case DT_GNU_PRELINKED:
+ if (do_dynamic)
+ {
+ struct tm * tmp;
+ time_t atime = entry->d_un.d_val;
- if (check_def && data[cnt + j] != 0x8001
- && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
- {
- Elf_Internal_Verdef ivd;
- Elf_External_Verdef evd;
- unsigned long offset;
+ tmp = gmtime (&atime);
+ printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
+ tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
+ tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
- offset = offset_from_vma
- (file, version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
- sizeof evd);
+ }
+ break;
- do
- {
- get_data (&evd, file, offset, sizeof (evd), 1,
- _("version def"));
+ case DT_GNU_HASH:
+ dynamic_info_DT_GNU_HASH = entry->d_un.d_val;
+ if (do_dynamic)
+ {
+ print_vma (entry->d_un.d_val, PREFIX_HEX);
+ putchar ('\n');
+ }
+ break;
- ivd.vd_next = BYTE_GET (evd.vd_next);
- ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
+ default:
+ if ((entry->d_tag >= DT_VERSYM) && (entry->d_tag <= DT_VERNEEDNUM))
+ version_info[DT_VERSIONTAGIDX (entry->d_tag)] =
+ entry->d_un.d_val;
- offset += ivd.vd_next;
- }
- while (ivd.vd_ndx != (data[cnt + j] & 0x7fff)
- && ivd.vd_next != 0);
+ if (do_dynamic)
+ {
+ switch (elf_header.e_machine)
+ {
+ case EM_MIPS:
+ case EM_MIPS_RS3_LE:
+ dynamic_section_mips_val (entry);
+ break;
+ case EM_PARISC:
+ dynamic_section_parisc_val (entry);
+ break;
+ case EM_IA_64:
+ dynamic_section_ia64_val (entry);
+ break;
+ default:
+ print_vma (entry->d_un.d_val, PREFIX_HEX);
+ putchar ('\n');
+ }
+ }
+ break;
+ }
+ }
- if (ivd.vd_ndx == (data[cnt + j] & 0x7fff))
- {
- Elf_External_Verdaux evda;
- Elf_Internal_Verdaux ivda;
+ return 1;
+}
- ivd.vd_aux = BYTE_GET (evd.vd_aux);
+static char *
+get_ver_flags (unsigned int flags)
+{
+ static char buff[32];
- get_data (&evda, file,
- offset - ivd.vd_next + ivd.vd_aux,
- sizeof (evda), 1,
- _("version def aux"));
+ buff[0] = 0;
- ivda.vda_name = BYTE_GET (evda.vda_name);
+ if (flags == 0)
+ return _("none");
- if (ivda.vda_name >= string_sec->sh_size)
- name = _("*invalid*");
- else
- name = strtab + ivda.vda_name;
- nn += printf ("(%s%-*s",
- name,
- 12 - (int) strlen (name),
- ")");
- }
- }
+ if (flags & VER_FLG_BASE)
+ strcat (buff, "BASE ");
- if (nn < 18)
- printf ("%*c", 18 - nn, ' ');
- }
+ if (flags & VER_FLG_WEAK)
+ {
+ if (flags & VER_FLG_BASE)
+ strcat (buff, "| ");
- putchar ('\n');
- }
+ strcat (buff, "WEAK ");
+ }
- free (data);
- free (strtab);
- free (symbols);
- }
- break;
+ if (flags & VER_FLG_INFO)
+ {
+ if (flags & (VER_FLG_BASE|VER_FLG_WEAK))
+ strcat (buff, "| ");
- default:
- break;
- }
+ strcat (buff, "INFO ");
}
- if (! found)
- printf (_("\nNo version information found in this file.\n"));
+ if (flags & ~(VER_FLG_BASE | VER_FLG_WEAK | VER_FLG_INFO))
+ strcat (buff, _("| <unknown>"));
- return 1;
+ return buff;
}
-static const char *
-get_symbol_binding (unsigned int binding)
+/* Display the contents of the version sections. */
+
+static int
+process_version_sections (FILE * file)
{
- static char buff[32];
+ Elf_Internal_Shdr * section;
+ unsigned i;
+ int found = 0;
- switch (binding)
+ if (! do_version)
+ return 1;
+
+ for (i = 0, section = section_headers;
+ i < elf_header.e_shnum;
+ i++, section++)
{
- case STB_LOCAL: return "LOCAL";
- case STB_GLOBAL: return "GLOBAL";
- case STB_WEAK: return "WEAK";
- default:
- if (binding >= STB_LOPROC && binding <= STB_HIPROC)
- snprintf (buff, sizeof (buff), _("<processor specific>: %d"),
- binding);
- else if (binding >= STB_LOOS && binding <= STB_HIOS)
- snprintf (buff, sizeof (buff), _("<OS specific>: %d"), binding);
- else
- snprintf (buff, sizeof (buff), _("<unknown>: %d"), binding);
- return buff;
- }
-}
+ switch (section->sh_type)
+ {
+ case SHT_GNU_verdef:
+ {
+ Elf_External_Verdef * edefs;
+ unsigned int idx;
+ unsigned int cnt;
+ char * endbuf;
-static const char *
-get_symbol_type (unsigned int type)
-{
- static char buff[32];
+ found = 1;
- switch (type)
- {
- case STT_NOTYPE: return "NOTYPE";
- case STT_OBJECT: return "OBJECT";
- case STT_FUNC: return "FUNC";
- case STT_SECTION: return "SECTION";
- case STT_FILE: return "FILE";
- case STT_COMMON: return "COMMON";
- case STT_TLS: return "TLS";
- case STT_RELC: return "RELC";
- case STT_SRELC: return "SRELC";
- default:
- if (type >= STT_LOPROC && type <= STT_HIPROC)
- {
- if (elf_header.e_machine == EM_ARM && type == STT_ARM_TFUNC)
- return "THUMB_FUNC";
+ printf
+ (_("\nVersion definition section '%s' contains %u entries:\n"),
+ SECTION_NAME (section), section->sh_info);
- if (elf_header.e_machine == EM_SPARCV9 && type == STT_REGISTER)
- return "REGISTER";
+ printf (_(" Addr: 0x"));
+ printf_vma (section->sh_addr);
+ printf (_(" Offset: %#08lx Link: %u (%s)\n"),
+ (unsigned long) section->sh_offset, section->sh_link,
+ section->sh_link < elf_header.e_shnum
+ ? SECTION_NAME (section_headers + section->sh_link)
+ : _("<corrupt>"));
- if (elf_header.e_machine == EM_PARISC && type == STT_PARISC_MILLI)
- return "PARISC_MILLI";
+ edefs = (Elf_External_Verdef *)
+ get_data (NULL, file, section->sh_offset, 1,section->sh_size,
+ _("version definition section"));
+ endbuf = (char *) edefs + section->sh_size;
+ if (!edefs)
+ break;
- snprintf (buff, sizeof (buff), _("<processor specific>: %d"), type);
- }
- else if (type >= STT_LOOS && type <= STT_HIOS)
- {
- if (elf_header.e_machine == EM_PARISC)
- {
- if (type == STT_HP_OPAQUE)
- return "HP_OPAQUE";
- if (type == STT_HP_STUB)
- return "HP_STUB";
- }
+ for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
+ {
+ char * vstart;
+ Elf_External_Verdef * edef;
+ Elf_Internal_Verdef ent;
+ Elf_External_Verdaux * eaux;
+ Elf_Internal_Verdaux aux;
+ int j;
+ int isum;
- snprintf (buff, sizeof (buff), _("<OS specific>: %d"), type);
- }
- else
- snprintf (buff, sizeof (buff), _("<unknown>: %d"), type);
- return buff;
- }
-}
+ vstart = ((char *) edefs) + idx;
+ if (vstart + sizeof (*edef) > endbuf)
+ break;
-static const char *
-get_symbol_visibility (unsigned int visibility)
-{
- switch (visibility)
- {
- case STV_DEFAULT: return "DEFAULT";
- case STV_INTERNAL: return "INTERNAL";
- case STV_HIDDEN: return "HIDDEN";
- case STV_PROTECTED: return "PROTECTED";
- default: abort ();
- }
-}
+ edef = (Elf_External_Verdef *) vstart;
-static const char *
-get_mips_symbol_other (unsigned int other)
-{
- switch (other)
- {
- case STO_OPTIONAL: return "OPTIONAL";
- case STO_MIPS16: return "MIPS16";
- default: return NULL;
- }
-}
+ ent.vd_version = BYTE_GET (edef->vd_version);
+ ent.vd_flags = BYTE_GET (edef->vd_flags);
+ ent.vd_ndx = BYTE_GET (edef->vd_ndx);
+ ent.vd_cnt = BYTE_GET (edef->vd_cnt);
+ ent.vd_hash = BYTE_GET (edef->vd_hash);
+ ent.vd_aux = BYTE_GET (edef->vd_aux);
+ ent.vd_next = BYTE_GET (edef->vd_next);
-static const char *
-get_symbol_other (unsigned int other)
-{
- const char * result = NULL;
- static char buff [32];
+ printf (_(" %#06x: Rev: %d Flags: %s"),
+ idx, ent.vd_version, get_ver_flags (ent.vd_flags));
- if (other == 0)
- return "";
+ printf (_(" Index: %d Cnt: %d "),
+ ent.vd_ndx, ent.vd_cnt);
- switch (elf_header.e_machine)
- {
- case EM_MIPS:
- result = get_mips_symbol_other (other);
- default:
- break;
- }
+ vstart += ent.vd_aux;
- if (result)
- return result;
+ eaux = (Elf_External_Verdaux *) vstart;
- snprintf (buff, sizeof buff, _("<other>: %x"), other);
- return buff;
-}
+ aux.vda_name = BYTE_GET (eaux->vda_name);
+ aux.vda_next = BYTE_GET (eaux->vda_next);
-static const char *
-get_symbol_index_type (unsigned int type)
-{
- static char buff[32];
+ if (VALID_DYNAMIC_NAME (aux.vda_name))
+ printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux.vda_name));
+ else
+ printf (_("Name index: %ld\n"), aux.vda_name);
- switch (type)
- {
- case SHN_UNDEF: return "UND";
- case SHN_ABS: return "ABS";
- case SHN_COMMON: return "COM";
- default:
- if (type == SHN_IA_64_ANSI_COMMON
- && elf_header.e_machine == EM_IA_64
- && elf_header.e_ident[EI_OSABI] == ELFOSABI_HPUX)
- return "ANSI_COM";
- else if (elf_header.e_machine == EM_X86_64
- && type == SHN_X86_64_LCOMMON)
- return "LARGE_COM";
- else if (type == SHN_MIPS_SCOMMON
- && elf_header.e_machine == EM_MIPS)
- return "SCOM";
- else if (type == SHN_MIPS_SUNDEFINED
- && elf_header.e_machine == EM_MIPS)
- return "SUND";
- else if (type >= SHN_LOPROC && type <= SHN_HIPROC)
- sprintf (buff, "PRC[0x%04x]", type & 0xffff);
- else if (type >= SHN_LOOS && type <= SHN_HIOS)
- sprintf (buff, "OS [0x%04x]", type & 0xffff);
- else if (type >= SHN_LORESERVE)
- sprintf (buff, "RSV[0x%04x]", type & 0xffff);
- else
- sprintf (buff, "%3d", type);
- break;
- }
+ isum = idx + ent.vd_aux;
- return buff;
-}
+ for (j = 1; j < ent.vd_cnt; j++)
+ {
+ isum += aux.vda_next;
+ vstart += aux.vda_next;
-static bfd_vma *
-get_dynamic_data (FILE *file, unsigned int number, unsigned int ent_size)
-{
- unsigned char *e_data;
- bfd_vma *i_data;
+ eaux = (Elf_External_Verdaux *) vstart;
+ if (vstart + sizeof (*eaux) > endbuf)
+ break;
- e_data = cmalloc (number, ent_size);
+ aux.vda_name = BYTE_GET (eaux->vda_name);
+ aux.vda_next = BYTE_GET (eaux->vda_next);
- if (e_data == NULL)
- {
- error (_("Out of memory\n"));
- return NULL;
- }
+ if (VALID_DYNAMIC_NAME (aux.vda_name))
+ printf (_(" %#06x: Parent %d: %s\n"),
+ isum, j, GET_DYNAMIC_NAME (aux.vda_name));
+ else
+ printf (_(" %#06x: Parent %d, name index: %ld\n"),
+ isum, j, aux.vda_name);
+ }
+ if (j < ent.vd_cnt)
+ printf (_(" Version def aux past end of section\n"));
- if (fread (e_data, ent_size, number, file) != number)
- {
- error (_("Unable to read in dynamic data\n"));
- return NULL;
- }
+ idx += ent.vd_next;
+ }
+ if (cnt < section->sh_info)
+ printf (_(" Version definition past end of section\n"));
- i_data = cmalloc (number, sizeof (*i_data));
+ free (edefs);
+ }
+ break;
- if (i_data == NULL)
- {
- error (_("Out of memory\n"));
- free (e_data);
- return NULL;
- }
+ case SHT_GNU_verneed:
+ {
+ Elf_External_Verneed * eneed;
+ unsigned int idx;
+ unsigned int cnt;
+ char * endbuf;
- while (number--)
- i_data[number] = byte_get (e_data + number * ent_size, ent_size);
+ found = 1;
- free (e_data);
+ printf (_("\nVersion needs section '%s' contains %u entries:\n"),
+ SECTION_NAME (section), section->sh_info);
- return i_data;
-}
+ printf (_(" Addr: 0x"));
+ printf_vma (section->sh_addr);
+ printf (_(" Offset: %#08lx Link: %u (%s)\n"),
+ (unsigned long) section->sh_offset, section->sh_link,
+ section->sh_link < elf_header.e_shnum
+ ? SECTION_NAME (section_headers + section->sh_link)
+ : _("<corrupt>"));
-static void
-print_dynamic_symbol (bfd_vma si, unsigned long hn)
-{
- Elf_Internal_Sym *psym;
- int n;
+ eneed = (Elf_External_Verneed *) get_data (NULL, file,
+ section->sh_offset, 1,
+ section->sh_size,
+ _("version need section"));
+ endbuf = (char *) eneed + section->sh_size;
+ if (!eneed)
+ break;
- psym = dynamic_symbols + si;
+ for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
+ {
+ Elf_External_Verneed * entry;
+ Elf_Internal_Verneed ent;
+ int j;
+ int isum;
+ char * vstart;
- n = print_vma (si, DEC_5);
- if (n < 5)
- fputs (" " + n, stdout);
- printf (" %3lu: ", hn);
- print_vma (psym->st_value, LONG_HEX);
- putchar (' ');
- print_vma (psym->st_size, DEC_5);
+ vstart = ((char *) eneed) + idx;
+ if (vstart + sizeof (*entry) > endbuf)
+ break;
- printf (" %6s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
- printf (" %6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
- printf (" %3s", get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
- /* Check to see if any other bits in the st_other field are set.
- Note - displaying this information disrupts the layout of the
- table being generated, but for the moment this case is very
- rare. */
- if (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other))
- printf (" [%s] ", get_symbol_other (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other)));
- printf (" %3.3s ", get_symbol_index_type (psym->st_shndx));
- if (VALID_DYNAMIC_NAME (psym->st_name))
- print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
- else
- printf (" <corrupt: %14ld>", psym->st_name);
- putchar ('\n');
-}
+ entry = (Elf_External_Verneed *) vstart;
-/* Dump the symbol table. */
-static int
-process_symbol_table (FILE *file)
-{
- Elf_Internal_Shdr *section;
- bfd_vma nbuckets = 0;
- bfd_vma nchains = 0;
- bfd_vma *buckets = NULL;
- bfd_vma *chains = NULL;
- bfd_vma ngnubuckets = 0;
- bfd_vma *gnubuckets = NULL;
- bfd_vma *gnuchains = NULL;
- bfd_vma gnusymidx = 0;
-
- if (! do_syms && !do_histogram)
- return 1;
+ ent.vn_version = BYTE_GET (entry->vn_version);
+ ent.vn_cnt = BYTE_GET (entry->vn_cnt);
+ ent.vn_file = BYTE_GET (entry->vn_file);
+ ent.vn_aux = BYTE_GET (entry->vn_aux);
+ ent.vn_next = BYTE_GET (entry->vn_next);
- if (dynamic_info[DT_HASH]
- && (do_histogram
- || (do_using_dynamic && dynamic_strings != NULL)))
- {
- unsigned char nb[8];
- unsigned char nc[8];
- int hash_ent_size = 4;
+ printf (_(" %#06x: Version: %d"), idx, ent.vn_version);
- if ((elf_header.e_machine == EM_ALPHA
- || elf_header.e_machine == EM_S390
- || elf_header.e_machine == EM_S390_OLD)
- && elf_header.e_ident[EI_CLASS] == ELFCLASS64)
- hash_ent_size = 8;
+ if (VALID_DYNAMIC_NAME (ent.vn_file))
+ printf (_(" File: %s"), GET_DYNAMIC_NAME (ent.vn_file));
+ else
+ printf (_(" File: %lx"), ent.vn_file);
- if (fseek (file,
- (archive_file_offset
- + offset_from_vma (file, dynamic_info[DT_HASH],
- sizeof nb + sizeof nc)),
- SEEK_SET))
- {
- error (_("Unable to seek to start of dynamic information\n"));
- return 0;
- }
+ printf (_(" Cnt: %d\n"), ent.vn_cnt);
- if (fread (nb, hash_ent_size, 1, file) != 1)
- {
- error (_("Failed to read in number of buckets\n"));
- return 0;
- }
+ vstart += ent.vn_aux;
- if (fread (nc, hash_ent_size, 1, file) != 1)
- {
- error (_("Failed to read in number of chains\n"));
- return 0;
- }
+ for (j = 0, isum = idx + ent.vn_aux; j < ent.vn_cnt; ++j)
+ {
+ Elf_External_Vernaux * eaux;
+ Elf_Internal_Vernaux aux;
- nbuckets = byte_get (nb, hash_ent_size);
- nchains = byte_get (nc, hash_ent_size);
+ if (vstart + sizeof (*eaux) > endbuf)
+ break;
+ eaux = (Elf_External_Vernaux *) vstart;
- buckets = get_dynamic_data (file, nbuckets, hash_ent_size);
- chains = get_dynamic_data (file, nchains, hash_ent_size);
+ aux.vna_hash = BYTE_GET (eaux->vna_hash);
+ aux.vna_flags = BYTE_GET (eaux->vna_flags);
+ aux.vna_other = BYTE_GET (eaux->vna_other);
+ aux.vna_name = BYTE_GET (eaux->vna_name);
+ aux.vna_next = BYTE_GET (eaux->vna_next);
- if (buckets == NULL || chains == NULL)
- return 0;
- }
+ if (VALID_DYNAMIC_NAME (aux.vna_name))
+ printf (_(" %#06x: Name: %s"),
+ isum, GET_DYNAMIC_NAME (aux.vna_name));
+ else
+ printf (_(" %#06x: Name index: %lx"),
+ isum, aux.vna_name);
- if (dynamic_info_DT_GNU_HASH
- && (do_histogram
- || (do_using_dynamic && dynamic_strings != NULL)))
- {
- unsigned char nb[16];
- bfd_vma i, maxchain = 0xffffffff, bitmaskwords;
- bfd_vma buckets_vma;
+ printf (_(" Flags: %s Version: %d\n"),
+ get_ver_flags (aux.vna_flags), aux.vna_other);
- if (fseek (file,
- (archive_file_offset
- + offset_from_vma (file, dynamic_info_DT_GNU_HASH,
- sizeof nb)),
- SEEK_SET))
- {
- error (_("Unable to seek to start of dynamic information\n"));
- return 0;
- }
+ isum += aux.vna_next;
+ vstart += aux.vna_next;
+ }
+ if (j < ent.vn_cnt)
+ printf (_(" Version need aux past end of section\n"));
- if (fread (nb, 16, 1, file) != 1)
- {
- error (_("Failed to read in number of buckets\n"));
- return 0;
- }
+ idx += ent.vn_next;
+ }
+ if (cnt < section->sh_info)
+ printf (_(" Version need past end of section\n"));
- ngnubuckets = byte_get (nb, 4);
- gnusymidx = byte_get (nb + 4, 4);
- bitmaskwords = byte_get (nb + 8, 4);
- buckets_vma = dynamic_info_DT_GNU_HASH + 16;
- if (is_32bit_elf)
- buckets_vma += bitmaskwords * 4;
- else
- buckets_vma += bitmaskwords * 8;
+ free (eneed);
+ }
+ break;
- if (fseek (file,
- (archive_file_offset
- + offset_from_vma (file, buckets_vma, 4)),
- SEEK_SET))
- {
- error (_("Unable to seek to start of dynamic information\n"));
- return 0;
- }
+ case SHT_GNU_versym:
+ {
+ Elf_Internal_Shdr * link_section;
+ int total;
+ int cnt;
+ unsigned char * edata;
+ unsigned short * data;
+ char * strtab;
+ Elf_Internal_Sym * symbols;
+ Elf_Internal_Shdr * string_sec;
+ long off;
- gnubuckets = get_dynamic_data (file, ngnubuckets, 4);
+ if (section->sh_link >= elf_header.e_shnum)
+ break;
- if (gnubuckets == NULL)
- return 0;
+ link_section = section_headers + section->sh_link;
+ total = section->sh_size / sizeof (Elf_External_Versym);
- for (i = 0; i < ngnubuckets; i++)
- if (gnubuckets[i] != 0)
- {
- if (gnubuckets[i] < gnusymidx)
- return 0;
+ if (link_section->sh_link >= elf_header.e_shnum)
+ break;
- if (maxchain == 0xffffffff || gnubuckets[i] > maxchain)
- maxchain = gnubuckets[i];
- }
+ found = 1;
- if (maxchain == 0xffffffff)
- return 0;
+ symbols = GET_ELF_SYMBOLS (file, link_section);
- maxchain -= gnusymidx;
+ string_sec = section_headers + link_section->sh_link;
- if (fseek (file,
- (archive_file_offset
- + offset_from_vma (file, buckets_vma
- + 4 * (ngnubuckets + maxchain), 4)),
- SEEK_SET))
- {
- error (_("Unable to seek to start of dynamic information\n"));
- return 0;
- }
+ strtab = (char *) get_data (NULL, file, string_sec->sh_offset, 1,
+ string_sec->sh_size,
+ _("version string table"));
+ if (!strtab)
+ break;
- do
- {
- if (fread (nb, 4, 1, file) != 1)
- {
- error (_("Failed to determine last chain length\n"));
- return 0;
- }
+ printf (_("\nVersion symbols section '%s' contains %d entries:\n"),
+ SECTION_NAME (section), total);
- if (maxchain + 1 == 0)
- return 0;
+ printf (_(" Addr: "));
+ printf_vma (section->sh_addr);
+ printf (_(" Offset: %#08lx Link: %u (%s)\n"),
+ (unsigned long) section->sh_offset, section->sh_link,
+ SECTION_NAME (link_section));
- ++maxchain;
- }
- while ((byte_get (nb, 4) & 1) == 0);
+ off = offset_from_vma (file,
+ version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
+ total * sizeof (short));
+ edata = (unsigned char *) get_data (NULL, file, off, total,
+ sizeof (short),
+ _("version symbol data"));
+ if (!edata)
+ {
+ free (strtab);
+ break;
+ }
- if (fseek (file,
- (archive_file_offset
- + offset_from_vma (file, buckets_vma + 4 * ngnubuckets, 4)),
- SEEK_SET))
- {
- error (_("Unable to seek to start of dynamic information\n"));
- return 0;
- }
+ data = (short unsigned int *) cmalloc (total, sizeof (short));
- gnuchains = get_dynamic_data (file, maxchain, 4);
+ for (cnt = total; cnt --;)
+ data[cnt] = byte_get (edata + cnt * sizeof (short),
+ sizeof (short));
- if (gnuchains == NULL)
- return 0;
- }
+ free (edata);
- if ((dynamic_info[DT_HASH] || dynamic_info_DT_GNU_HASH)
- && do_syms
- && do_using_dynamic
- && dynamic_strings != NULL)
- {
- unsigned long hn;
+ for (cnt = 0; cnt < total; cnt += 4)
+ {
+ int j, nn;
+ int check_def, check_need;
+ char * name;
- if (dynamic_info[DT_HASH])
- {
- bfd_vma si;
+ printf (" %03x:", cnt);
- printf (_("\nSymbol table for image:\n"));
- if (is_32bit_elf)
- printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
- else
- printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
+ for (j = 0; (j < 4) && (cnt + j) < total; ++j)
+ switch (data[cnt + j])
+ {
+ case 0:
+ fputs (_(" 0 (*local*) "), stdout);
+ break;
- for (hn = 0; hn < nbuckets; hn++)
- {
- if (! buckets[hn])
- continue;
+ case 1:
+ fputs (_(" 1 (*global*) "), stdout);
+ break;
- for (si = buckets[hn]; si < nchains && si > 0; si = chains[si])
- print_dynamic_symbol (si, hn);
- }
- }
+ default:
+ nn = printf ("%4x%c", data[cnt + j] & VERSYM_VERSION,
+ data[cnt + j] & VERSYM_HIDDEN ? 'h' : ' ');
- if (dynamic_info_DT_GNU_HASH)
- {
- printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
- if (is_32bit_elf)
- printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
- else
- printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
+ check_def = 1;
+ check_need = 1;
+ if (symbols[cnt + j].st_shndx >= elf_header.e_shnum
+ || section_headers[symbols[cnt + j].st_shndx].sh_type
+ != SHT_NOBITS)
+ {
+ if (symbols[cnt + j].st_shndx == SHN_UNDEF)
+ check_def = 0;
+ else
+ check_need = 0;
+ }
- for (hn = 0; hn < ngnubuckets; ++hn)
- if (gnubuckets[hn] != 0)
- {
- bfd_vma si = gnubuckets[hn];
- bfd_vma off = si - gnusymidx;
-
- do
- {
- print_dynamic_symbol (si, hn);
- si++;
- }
- while ((gnuchains[off++] & 1) == 0);
- }
- }
- }
- else if (do_syms && !do_using_dynamic)
- {
- unsigned int i;
-
- for (i = 0, section = section_headers;
- i < elf_header.e_shnum;
- i++, section++)
- {
- unsigned int si;
- char *strtab = NULL;
- unsigned long int strtab_size = 0;
- Elf_Internal_Sym *symtab;
- Elf_Internal_Sym *psym;
-
-
- if ( section->sh_type != SHT_SYMTAB
- && section->sh_type != SHT_DYNSYM)
- continue;
-
- printf (_("\nSymbol table '%s' contains %lu entries:\n"),
- SECTION_NAME (section),
- (unsigned long) (section->sh_size / section->sh_entsize));
- if (is_32bit_elf)
- printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
- else
- printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
-
- symtab = GET_ELF_SYMBOLS (file, section);
- if (symtab == NULL)
- continue;
-
- if (section->sh_link == elf_header.e_shstrndx)
- {
- strtab = string_table;
- strtab_size = string_table_length;
- }
- else if (section->sh_link < elf_header.e_shnum)
- {
- Elf_Internal_Shdr *string_sec;
-
- string_sec = section_headers + section->sh_link;
-
- strtab = get_data (NULL, file, string_sec->sh_offset,
- 1, string_sec->sh_size, _("string table"));
- strtab_size = strtab != NULL ? string_sec->sh_size : 0;
- }
-
- for (si = 0, psym = symtab;
- si < section->sh_size / section->sh_entsize;
- si++, psym++)
- {
- printf ("%6d: ", si);
- print_vma (psym->st_value, LONG_HEX);
- putchar (' ');
- print_vma (psym->st_size, DEC_5);
- printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
- printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
- printf (" %-3s", get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
- /* Check to see if any other bits in the st_other field are set.
- Note - displaying this information disrupts the layout of the
- table being generated, but for the moment this case is very rare. */
- if (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other))
- printf (" [%s] ", get_symbol_other (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other)));
- printf (" %4s ", get_symbol_index_type (psym->st_shndx));
- print_symbol (25, psym->st_name < strtab_size
- ? strtab + psym->st_name : "<corrupt>");
-
- if (section->sh_type == SHT_DYNSYM &&
- version_info[DT_VERSIONTAGIDX (DT_VERSYM)] != 0)
- {
- unsigned char data[2];
- unsigned short vers_data;
- unsigned long offset;
- int is_nobits;
- int check_def;
-
- offset = offset_from_vma
- (file, version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
- sizeof data + si * sizeof (vers_data));
-
- get_data (&data, file, offset + si * sizeof (vers_data),
- sizeof (data), 1, _("version data"));
-
- vers_data = byte_get (data, 2);
-
- is_nobits = (psym->st_shndx < elf_header.e_shnum
- && section_headers[psym->st_shndx].sh_type
- == SHT_NOBITS);
-
- check_def = (psym->st_shndx != SHN_UNDEF);
-
- if ((vers_data & 0x8000) || vers_data > 1)
- {
- if (version_info[DT_VERSIONTAGIDX (DT_VERNEED)]
- && (is_nobits || ! check_def))
+ if (check_need
+ && version_info[DT_VERSIONTAGIDX (DT_VERNEED)])
{
- Elf_External_Verneed evn;
Elf_Internal_Verneed ivn;
- Elf_Internal_Vernaux ivna;
+ unsigned long offset;
- /* We must test both. */
offset = offset_from_vma
(file, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
- sizeof evn);
+ sizeof (Elf_External_Verneed));
do
{
- unsigned long vna_off;
+ Elf_Internal_Vernaux ivna;
+ Elf_External_Verneed evn;
+ Elf_External_Vernaux evna;
+ unsigned long a_off;
get_data (&evn, file, offset, sizeof (evn), 1,
_("version need"));
ivn.vn_aux = BYTE_GET (evn.vn_aux);
ivn.vn_next = BYTE_GET (evn.vn_next);
- vna_off = offset + ivn.vn_aux;
+ a_off = offset + ivn.vn_aux;
do
{
- Elf_External_Vernaux evna;
-
- get_data (&evna, file, vna_off,
- sizeof (evna), 1,
- _("version need aux (3)"));
+ get_data (&evna, file, a_off, sizeof (evna),
+ 1, _("version need aux (2)"));
- ivna.vna_other = BYTE_GET (evna.vna_other);
ivna.vna_next = BYTE_GET (evna.vna_next);
- ivna.vna_name = BYTE_GET (evna.vna_name);
+ ivna.vna_other = BYTE_GET (evna.vna_other);
- vna_off += ivna.vna_next;
+ a_off += ivna.vna_next;
}
- while (ivna.vna_other != vers_data
+ while (ivna.vna_other != data[cnt + j]
&& ivna.vna_next != 0);
- if (ivna.vna_other == vers_data)
- break;
+ if (ivna.vna_other == data[cnt + j])
+ {
+ ivna.vna_name = BYTE_GET (evna.vna_name);
- offset += ivn.vn_next;
- }
- while (ivn.vn_next != 0);
+ if (ivna.vna_name >= string_sec->sh_size)
+ name = _("*invalid*");
+ else
+ name = strtab + ivna.vna_name;
+ nn += printf ("(%s%-*s",
+ name,
+ 12 - (int) strlen (name),
+ ")");
+ check_def = 0;
+ break;
+ }
- if (ivna.vna_other == vers_data)
- {
- printf ("@%s (%d)",
- ivna.vna_name < strtab_size
- ? strtab + ivna.vna_name : "<corrupt>",
- ivna.vna_other);
- check_def = 0;
+ offset += ivn.vn_next;
}
- else if (! is_nobits)
- error (_("bad dynamic symbol\n"));
- else
- check_def = 1;
+ while (ivn.vn_next);
}
- if (check_def)
+ if (check_def && data[cnt + j] != 0x8001
+ && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
{
- if (vers_data != 0x8001
- && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
- {
- Elf_Internal_Verdef ivd;
- Elf_Internal_Verdaux ivda;
- Elf_External_Verdaux evda;
- unsigned long offset;
+ Elf_Internal_Verdef ivd;
+ Elf_External_Verdef evd;
+ unsigned long offset;
- offset = offset_from_vma
- (file,
- version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
- sizeof (Elf_External_Verdef));
+ offset = offset_from_vma
+ (file, version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
+ sizeof evd);
- do
- {
- Elf_External_Verdef evd;
+ do
+ {
+ get_data (&evd, file, offset, sizeof (evd), 1,
+ _("version def"));
- get_data (&evd, file, offset, sizeof (evd),
- 1, _("version def"));
+ ivd.vd_next = BYTE_GET (evd.vd_next);
+ ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
- ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
- ivd.vd_aux = BYTE_GET (evd.vd_aux);
- ivd.vd_next = BYTE_GET (evd.vd_next);
+ offset += ivd.vd_next;
+ }
+ while (ivd.vd_ndx != (data[cnt + j] & VERSYM_VERSION)
+ && ivd.vd_next != 0);
- offset += ivd.vd_next;
- }
- while (ivd.vd_ndx != (vers_data & 0x7fff)
- && ivd.vd_next != 0);
+ if (ivd.vd_ndx == (data[cnt + j] & VERSYM_VERSION))
+ {
+ Elf_External_Verdaux evda;
+ Elf_Internal_Verdaux ivda;
- offset -= ivd.vd_next;
- offset += ivd.vd_aux;
+ ivd.vd_aux = BYTE_GET (evd.vd_aux);
- get_data (&evda, file, offset, sizeof (evda),
- 1, _("version def aux"));
+ get_data (&evda, file,
+ offset - ivd.vd_next + ivd.vd_aux,
+ sizeof (evda), 1,
+ _("version def aux"));
ivda.vda_name = BYTE_GET (evda.vda_name);
- if (psym->st_name != ivda.vda_name)
- printf ((vers_data & 0x8000)
- ? "@%s" : "@@%s",
- ivda.vda_name < strtab_size
- ? strtab + ivda.vda_name : "<corrupt>");
+ if (ivda.vda_name >= string_sec->sh_size)
+ name = _("*invalid*");
+ else
+ name = strtab + ivda.vda_name;
+ nn += printf ("(%s%-*s",
+ name,
+ 12 - (int) strlen (name),
+ ")");
}
}
+
+ if (nn < 18)
+ printf ("%*c", 18 - nn, ' ');
}
- }
- putchar ('\n');
- }
+ putchar ('\n');
+ }
- free (symtab);
- if (strtab != string_table)
+ free (data);
free (strtab);
+ free (symbols);
+ }
+ break;
+
+ default:
+ break;
}
}
- else if (do_syms)
- printf
- (_("\nDynamic symbol information is not available for displaying symbols.\n"));
- if (do_histogram && buckets != NULL)
- {
- unsigned long *lengths;
- unsigned long *counts;
- unsigned long hn;
- bfd_vma si;
- unsigned long maxlength = 0;
- unsigned long nzero_counts = 0;
- unsigned long nsyms = 0;
+ if (! found)
+ printf (_("\nNo version information found in this file.\n"));
- printf (_("\nHistogram for bucket list length (total of %lu buckets):\n"),
- (unsigned long) nbuckets);
- printf (_(" Length Number %% of total Coverage\n"));
+ return 1;
+}
- lengths = calloc (nbuckets, sizeof (*lengths));
- if (lengths == NULL)
- {
- error (_("Out of memory\n"));
- return 0;
- }
- for (hn = 0; hn < nbuckets; ++hn)
- {
- for (si = buckets[hn]; si > 0 && si < nchains; si = chains[si])
- {
- ++nsyms;
- if (maxlength < ++lengths[hn])
- ++maxlength;
- }
- }
+static const char *
+get_symbol_binding (unsigned int binding)
+{
+ static char buff[32];
- counts = calloc (maxlength + 1, sizeof (*counts));
- if (counts == NULL)
+ switch (binding)
+ {
+ case STB_LOCAL: return "LOCAL";
+ case STB_GLOBAL: return "GLOBAL";
+ case STB_WEAK: return "WEAK";
+ default:
+ if (binding >= STB_LOPROC && binding <= STB_HIPROC)
+ snprintf (buff, sizeof (buff), _("<processor specific>: %d"),
+ binding);
+ else if (binding >= STB_LOOS && binding <= STB_HIOS)
{
- error (_("Out of memory\n"));
- return 0;
+ if (binding == STB_GNU_UNIQUE
+ && (elf_header.e_ident[EI_OSABI] == ELFOSABI_LINUX
+ /* GNU/Linux is still using the default value 0. */
+ || elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
+ return "UNIQUE";
+ snprintf (buff, sizeof (buff), _("<OS specific>: %d"), binding);
}
+ else
+ snprintf (buff, sizeof (buff), _("<unknown>: %d"), binding);
+ return buff;
+ }
+}
- for (hn = 0; hn < nbuckets; ++hn)
- ++counts[lengths[hn]];
+static const char *
+get_symbol_type (unsigned int type)
+{
+ static char buff[32];
- if (nbuckets > 0)
+ switch (type)
+ {
+ case STT_NOTYPE: return "NOTYPE";
+ case STT_OBJECT: return "OBJECT";
+ case STT_FUNC: return "FUNC";
+ case STT_SECTION: return "SECTION";
+ case STT_FILE: return "FILE";
+ case STT_COMMON: return "COMMON";
+ case STT_TLS: return "TLS";
+ case STT_RELC: return "RELC";
+ case STT_SRELC: return "SRELC";
+ default:
+ if (type >= STT_LOPROC && type <= STT_HIPROC)
{
- unsigned long i;
- printf (" 0 %-10lu (%5.1f%%)\n",
- counts[0], (counts[0] * 100.0) / nbuckets);
- for (i = 1; i <= maxlength; ++i)
+ if (elf_header.e_machine == EM_ARM && type == STT_ARM_TFUNC)
+ return "THUMB_FUNC";
+
+ if (elf_header.e_machine == EM_SPARCV9 && type == STT_REGISTER)
+ return "REGISTER";
+
+ if (elf_header.e_machine == EM_PARISC && type == STT_PARISC_MILLI)
+ return "PARISC_MILLI";
+
+ snprintf (buff, sizeof (buff), _("<processor specific>: %d"), type);
+ }
+ else if (type >= STT_LOOS && type <= STT_HIOS)
+ {
+ if (elf_header.e_machine == EM_PARISC)
{
- nzero_counts += counts[i] * i;
- printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
- i, counts[i], (counts[i] * 100.0) / nbuckets,
- (nzero_counts * 100.0) / nsyms);
+ if (type == STT_HP_OPAQUE)
+ return "HP_OPAQUE";
+ if (type == STT_HP_STUB)
+ return "HP_STUB";
}
+
+ if (type == STT_GNU_IFUNC
+ && (elf_header.e_ident[EI_OSABI] == ELFOSABI_LINUX
+ /* GNU/Linux is still using the default value 0. */
+ || elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
+ return "IFUNC";
+
+ snprintf (buff, sizeof (buff), _("<OS specific>: %d"), type);
}
+ else
+ snprintf (buff, sizeof (buff), _("<unknown>: %d"), type);
+ return buff;
+ }
+}
- free (counts);
- free (lengths);
+static const char *
+get_symbol_visibility (unsigned int visibility)
+{
+ switch (visibility)
+ {
+ case STV_DEFAULT: return "DEFAULT";
+ case STV_INTERNAL: return "INTERNAL";
+ case STV_HIDDEN: return "HIDDEN";
+ case STV_PROTECTED: return "PROTECTED";
+ default: abort ();
+ }
+}
+
+static const char *
+get_mips_symbol_other (unsigned int other)
+{
+ switch (other)
+ {
+ case STO_OPTIONAL: return "OPTIONAL";
+ case STO_MIPS16: return "MIPS16";
+ case STO_MIPS_PLT: return "MIPS PLT";
+ case STO_MIPS_PIC: return "MIPS PIC";
+ default: return NULL;
+ }
+}
+
+static const char *
+get_symbol_other (unsigned int other)
+{
+ const char * result = NULL;
+ static char buff [32];
+
+ if (other == 0)
+ return "";
+
+ switch (elf_header.e_machine)
+ {
+ case EM_MIPS:
+ result = get_mips_symbol_other (other);
+ default:
+ break;
+ }
+
+ if (result)
+ return result;
+
+ snprintf (buff, sizeof buff, _("<other>: %x"), other);
+ return buff;
+}
+
+static const char *
+get_symbol_index_type (unsigned int type)
+{
+ static char buff[32];
+
+ switch (type)
+ {
+ case SHN_UNDEF: return "UND";
+ case SHN_ABS: return "ABS";
+ case SHN_COMMON: return "COM";
+ default:
+ if (type == SHN_IA_64_ANSI_COMMON
+ && elf_header.e_machine == EM_IA_64
+ && elf_header.e_ident[EI_OSABI] == ELFOSABI_HPUX)
+ return "ANSI_COM";
+ else if ((elf_header.e_machine == EM_X86_64
+ || elf_header.e_machine == EM_L1OM)
+ && type == SHN_X86_64_LCOMMON)
+ return "LARGE_COM";
+ else if (type == SHN_MIPS_SCOMMON
+ && elf_header.e_machine == EM_MIPS)
+ return "SCOM";
+ else if (type == SHN_MIPS_SUNDEFINED
+ && elf_header.e_machine == EM_MIPS)
+ return "SUND";
+ else if (type >= SHN_LOPROC && type <= SHN_HIPROC)
+ sprintf (buff, "PRC[0x%04x]", type & 0xffff);
+ else if (type >= SHN_LOOS && type <= SHN_HIOS)
+ sprintf (buff, "OS [0x%04x]", type & 0xffff);
+ else if (type >= SHN_LORESERVE)
+ sprintf (buff, "RSV[0x%04x]", type & 0xffff);
+ else
+ sprintf (buff, "%3d", type);
+ break;
+ }
+
+ return buff;
+}
+
+static bfd_vma *
+get_dynamic_data (FILE * file, unsigned int number, unsigned int ent_size)
+{
+ unsigned char * e_data;
+ bfd_vma * i_data;
+
+ e_data = (unsigned char *) cmalloc (number, ent_size);
+
+ if (e_data == NULL)
+ {
+ error (_("Out of memory\n"));
+ return NULL;
+ }
+
+ if (fread (e_data, ent_size, number, file) != number)
+ {
+ error (_("Unable to read in dynamic data\n"));
+ return NULL;
+ }
+
+ i_data = (bfd_vma *) cmalloc (number, sizeof (*i_data));
+
+ if (i_data == NULL)
+ {
+ error (_("Out of memory\n"));
+ free (e_data);
+ return NULL;
+ }
+
+ while (number--)
+ i_data[number] = byte_get (e_data + number * ent_size, ent_size);
+
+ free (e_data);
+
+ return i_data;
+}
+
+static void
+print_dynamic_symbol (bfd_vma si, unsigned long hn)
+{
+ Elf_Internal_Sym * psym;
+ int n;
+
+ psym = dynamic_symbols + si;
+
+ n = print_vma (si, DEC_5);
+ if (n < 5)
+ fputs (" " + n, stdout);
+ printf (" %3lu: ", hn);
+ print_vma (psym->st_value, LONG_HEX);
+ putchar (' ');
+ print_vma (psym->st_size, DEC_5);
+
+ printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
+ printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
+ printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
+ /* Check to see if any other bits in the st_other field are set.
+ Note - displaying this information disrupts the layout of the
+ table being generated, but for the moment this case is very
+ rare. */
+ if (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other))
+ printf (" [%s] ", get_symbol_other (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other)));
+ printf (" %3.3s ", get_symbol_index_type (psym->st_shndx));
+ if (VALID_DYNAMIC_NAME (psym->st_name))
+ print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
+ else
+ printf (_(" <corrupt: %14ld>"), psym->st_name);
+ putchar ('\n');
+}
+
+/* Dump the symbol table. */
+static int
+process_symbol_table (FILE * file)
+{
+ Elf_Internal_Shdr * section;
+ bfd_vma nbuckets = 0;
+ bfd_vma nchains = 0;
+ bfd_vma * buckets = NULL;
+ bfd_vma * chains = NULL;
+ bfd_vma ngnubuckets = 0;
+ bfd_vma * gnubuckets = NULL;
+ bfd_vma * gnuchains = NULL;
+ bfd_vma gnusymidx = 0;
+
+ if (!do_syms && !do_dyn_syms && !do_histogram)
+ return 1;
+
+ if (dynamic_info[DT_HASH]
+ && (do_histogram
+ || (do_using_dynamic
+ && !do_dyn_syms
+ && dynamic_strings != NULL)))
+ {
+ unsigned char nb[8];
+ unsigned char nc[8];
+ int hash_ent_size = 4;
+
+ if ((elf_header.e_machine == EM_ALPHA
+ || elf_header.e_machine == EM_S390
+ || elf_header.e_machine == EM_S390_OLD)
+ && elf_header.e_ident[EI_CLASS] == ELFCLASS64)
+ hash_ent_size = 8;
+
+ if (fseek (file,
+ (archive_file_offset
+ + offset_from_vma (file, dynamic_info[DT_HASH],
+ sizeof nb + sizeof nc)),
+ SEEK_SET))
+ {
+ error (_("Unable to seek to start of dynamic information\n"));
+ goto no_hash;
+ }
+
+ if (fread (nb, hash_ent_size, 1, file) != 1)
+ {
+ error (_("Failed to read in number of buckets\n"));
+ goto no_hash;
+ }
+
+ if (fread (nc, hash_ent_size, 1, file) != 1)
+ {
+ error (_("Failed to read in number of chains\n"));
+ goto no_hash;
+ }
+
+ nbuckets = byte_get (nb, hash_ent_size);
+ nchains = byte_get (nc, hash_ent_size);
+
+ buckets = get_dynamic_data (file, nbuckets, hash_ent_size);
+ chains = get_dynamic_data (file, nchains, hash_ent_size);
+
+ no_hash:
+ if (buckets == NULL || chains == NULL)
+ {
+ if (do_using_dynamic)
+ return 0;
+ free (buckets);
+ free (chains);
+ buckets = NULL;
+ chains = NULL;
+ nbuckets = 0;
+ nchains = 0;
+ }
+ }
+
+ if (dynamic_info_DT_GNU_HASH
+ && (do_histogram
+ || (do_using_dynamic
+ && !do_dyn_syms
+ && dynamic_strings != NULL)))
+ {
+ unsigned char nb[16];
+ bfd_vma i, maxchain = 0xffffffff, bitmaskwords;
+ bfd_vma buckets_vma;
+
+ if (fseek (file,
+ (archive_file_offset
+ + offset_from_vma (file, dynamic_info_DT_GNU_HASH,
+ sizeof nb)),
+ SEEK_SET))
+ {
+ error (_("Unable to seek to start of dynamic information\n"));
+ goto no_gnu_hash;
+ }
+
+ if (fread (nb, 16, 1, file) != 1)
+ {
+ error (_("Failed to read in number of buckets\n"));
+ goto no_gnu_hash;
+ }
+
+ ngnubuckets = byte_get (nb, 4);
+ gnusymidx = byte_get (nb + 4, 4);
+ bitmaskwords = byte_get (nb + 8, 4);
+ buckets_vma = dynamic_info_DT_GNU_HASH + 16;
+ if (is_32bit_elf)
+ buckets_vma += bitmaskwords * 4;
+ else
+ buckets_vma += bitmaskwords * 8;
+
+ if (fseek (file,
+ (archive_file_offset
+ + offset_from_vma (file, buckets_vma, 4)),
+ SEEK_SET))
+ {
+ error (_("Unable to seek to start of dynamic information\n"));
+ goto no_gnu_hash;
+ }
+
+ gnubuckets = get_dynamic_data (file, ngnubuckets, 4);
+
+ if (gnubuckets == NULL)
+ goto no_gnu_hash;
+
+ for (i = 0; i < ngnubuckets; i++)
+ if (gnubuckets[i] != 0)
+ {
+ if (gnubuckets[i] < gnusymidx)
+ return 0;
+
+ if (maxchain == 0xffffffff || gnubuckets[i] > maxchain)
+ maxchain = gnubuckets[i];
+ }
+
+ if (maxchain == 0xffffffff)
+ goto no_gnu_hash;
+
+ maxchain -= gnusymidx;
+
+ if (fseek (file,
+ (archive_file_offset
+ + offset_from_vma (file, buckets_vma
+ + 4 * (ngnubuckets + maxchain), 4)),
+ SEEK_SET))
+ {
+ error (_("Unable to seek to start of dynamic information\n"));
+ goto no_gnu_hash;
+ }
+
+ do
+ {
+ if (fread (nb, 4, 1, file) != 1)
+ {
+ error (_("Failed to determine last chain length\n"));
+ goto no_gnu_hash;
+ }
+
+ if (maxchain + 1 == 0)
+ goto no_gnu_hash;
+
+ ++maxchain;
+ }
+ while ((byte_get (nb, 4) & 1) == 0);
+
+ if (fseek (file,
+ (archive_file_offset
+ + offset_from_vma (file, buckets_vma + 4 * ngnubuckets, 4)),
+ SEEK_SET))
+ {
+ error (_("Unable to seek to start of dynamic information\n"));
+ goto no_gnu_hash;
+ }
+
+ gnuchains = get_dynamic_data (file, maxchain, 4);
+
+ no_gnu_hash:
+ if (gnuchains == NULL)
+ {
+ free (gnubuckets);
+ gnubuckets = NULL;
+ ngnubuckets = 0;
+ if (do_using_dynamic)
+ return 0;
+ }
+ }
+
+ if ((dynamic_info[DT_HASH] || dynamic_info_DT_GNU_HASH)
+ && do_syms
+ && do_using_dynamic
+ && dynamic_strings != NULL)
+ {
+ unsigned long hn;
+
+ if (dynamic_info[DT_HASH])
+ {
+ bfd_vma si;
+
+ printf (_("\nSymbol table for image:\n"));
+ if (is_32bit_elf)
+ printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
+ else
+ printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
+
+ for (hn = 0; hn < nbuckets; hn++)
+ {
+ if (! buckets[hn])
+ continue;
+
+ for (si = buckets[hn]; si < nchains && si > 0; si = chains[si])
+ print_dynamic_symbol (si, hn);
+ }
+ }
+
+ if (dynamic_info_DT_GNU_HASH)
+ {
+ printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
+ if (is_32bit_elf)
+ printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
+ else
+ printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
+
+ for (hn = 0; hn < ngnubuckets; ++hn)
+ if (gnubuckets[hn] != 0)
+ {
+ bfd_vma si = gnubuckets[hn];
+ bfd_vma off = si - gnusymidx;
+
+ do
+ {
+ print_dynamic_symbol (si, hn);
+ si++;
+ }
+ while ((gnuchains[off++] & 1) == 0);
+ }
+ }
+ }
+ else if (do_dyn_syms || (do_syms && !do_using_dynamic))
+ {
+ unsigned int i;
+
+ for (i = 0, section = section_headers;
+ i < elf_header.e_shnum;
+ i++, section++)
+ {
+ unsigned int si;
+ char * strtab = NULL;
+ unsigned long int strtab_size = 0;
+ Elf_Internal_Sym * symtab;
+ Elf_Internal_Sym * psym;
+
+ if ((section->sh_type != SHT_SYMTAB
+ && section->sh_type != SHT_DYNSYM)
+ || (!do_syms
+ && section->sh_type == SHT_SYMTAB))
+ continue;
+
+ printf (_("\nSymbol table '%s' contains %lu entries:\n"),
+ SECTION_NAME (section),
+ (unsigned long) (section->sh_size / section->sh_entsize));
+ if (is_32bit_elf)
+ printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
+ else
+ printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
+
+ symtab = GET_ELF_SYMBOLS (file, section);
+ if (symtab == NULL)
+ continue;
+
+ if (section->sh_link == elf_header.e_shstrndx)
+ {
+ strtab = string_table;
+ strtab_size = string_table_length;
+ }
+ else if (section->sh_link < elf_header.e_shnum)
+ {
+ Elf_Internal_Shdr * string_sec;
+
+ string_sec = section_headers + section->sh_link;
+
+ strtab = (char *) get_data (NULL, file, string_sec->sh_offset,
+ 1, string_sec->sh_size,
+ _("string table"));
+ strtab_size = strtab != NULL ? string_sec->sh_size : 0;
+ }
+
+ for (si = 0, psym = symtab;
+ si < section->sh_size / section->sh_entsize;
+ si++, psym++)
+ {
+ printf ("%6d: ", si);
+ print_vma (psym->st_value, LONG_HEX);
+ putchar (' ');
+ print_vma (psym->st_size, DEC_5);
+ printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
+ printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
+ printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
+ /* Check to see if any other bits in the st_other field are set.
+ Note - displaying this information disrupts the layout of the
+ table being generated, but for the moment this case is very rare. */
+ if (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other))
+ printf (" [%s] ", get_symbol_other (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other)));
+ printf (" %4s ", get_symbol_index_type (psym->st_shndx));
+ print_symbol (25, psym->st_name < strtab_size
+ ? strtab + psym->st_name : _("<corrupt>"));
+
+ if (section->sh_type == SHT_DYNSYM &&
+ version_info[DT_VERSIONTAGIDX (DT_VERSYM)] != 0)
+ {
+ unsigned char data[2];
+ unsigned short vers_data;
+ unsigned long offset;
+ int is_nobits;
+ int check_def;
+
+ offset = offset_from_vma
+ (file, version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
+ sizeof data + si * sizeof (vers_data));
+
+ get_data (&data, file, offset + si * sizeof (vers_data),
+ sizeof (data), 1, _("version data"));
+
+ vers_data = byte_get (data, 2);
+
+ is_nobits = (psym->st_shndx < elf_header.e_shnum
+ && section_headers[psym->st_shndx].sh_type
+ == SHT_NOBITS);
+
+ check_def = (psym->st_shndx != SHN_UNDEF);
+
+ if ((vers_data & VERSYM_HIDDEN) || vers_data > 1)
+ {
+ if (version_info[DT_VERSIONTAGIDX (DT_VERNEED)]
+ && (is_nobits || ! check_def))
+ {
+ Elf_External_Verneed evn;
+ Elf_Internal_Verneed ivn;
+ Elf_Internal_Vernaux ivna;
+
+ /* We must test both. */
+ offset = offset_from_vma
+ (file, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
+ sizeof evn);
+
+ do
+ {
+ unsigned long vna_off;
+
+ get_data (&evn, file, offset, sizeof (evn), 1,
+ _("version need"));
+
+ ivn.vn_aux = BYTE_GET (evn.vn_aux);
+ ivn.vn_next = BYTE_GET (evn.vn_next);
+
+ vna_off = offset + ivn.vn_aux;
+
+ do
+ {
+ Elf_External_Vernaux evna;
+
+ get_data (&evna, file, vna_off,
+ sizeof (evna), 1,
+ _("version need aux (3)"));
+
+ ivna.vna_other = BYTE_GET (evna.vna_other);
+ ivna.vna_next = BYTE_GET (evna.vna_next);
+ ivna.vna_name = BYTE_GET (evna.vna_name);
+
+ vna_off += ivna.vna_next;
+ }
+ while (ivna.vna_other != vers_data
+ && ivna.vna_next != 0);
+
+ if (ivna.vna_other == vers_data)
+ break;
+
+ offset += ivn.vn_next;
+ }
+ while (ivn.vn_next != 0);
+
+ if (ivna.vna_other == vers_data)
+ {
+ printf ("@%s (%d)",
+ ivna.vna_name < strtab_size
+ ? strtab + ivna.vna_name : _("<corrupt>"),
+ ivna.vna_other);
+ check_def = 0;
+ }
+ else if (! is_nobits)
+ error (_("bad dynamic symbol\n"));
+ else
+ check_def = 1;
+ }
+
+ if (check_def)
+ {
+ if (vers_data != 0x8001
+ && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
+ {
+ Elf_Internal_Verdef ivd;
+ Elf_Internal_Verdaux ivda;
+ Elf_External_Verdaux evda;
+ unsigned long off;
+
+ off = offset_from_vma
+ (file,
+ version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
+ sizeof (Elf_External_Verdef));
+
+ do
+ {
+ Elf_External_Verdef evd;
+
+ get_data (&evd, file, off, sizeof (evd),
+ 1, _("version def"));
+
+ ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
+ ivd.vd_aux = BYTE_GET (evd.vd_aux);
+ ivd.vd_next = BYTE_GET (evd.vd_next);
+
+ off += ivd.vd_next;
+ }
+ while (ivd.vd_ndx != (vers_data & VERSYM_VERSION)
+ && ivd.vd_next != 0);
+
+ off -= ivd.vd_next;
+ off += ivd.vd_aux;
+
+ get_data (&evda, file, off, sizeof (evda),
+ 1, _("version def aux"));
+
+ ivda.vda_name = BYTE_GET (evda.vda_name);
+
+ if (psym->st_name != ivda.vda_name)
+ printf ((vers_data & VERSYM_HIDDEN)
+ ? "@%s" : "@@%s",
+ ivda.vda_name < strtab_size
+ ? strtab + ivda.vda_name : _("<corrupt>"));
+ }
+ }
+ }
+ }
+
+ putchar ('\n');
+ }
+
+ free (symtab);
+ if (strtab != string_table)
+ free (strtab);
+ }
+ }
+ else if (do_syms)
+ printf
+ (_("\nDynamic symbol information is not available for displaying symbols.\n"));
+
+ if (do_histogram && buckets != NULL)
+ {
+ unsigned long * lengths;
+ unsigned long * counts;
+ unsigned long hn;
+ bfd_vma si;
+ unsigned long maxlength = 0;
+ unsigned long nzero_counts = 0;
+ unsigned long nsyms = 0;
+
+ printf (_("\nHistogram for bucket list length (total of %lu buckets):\n"),
+ (unsigned long) nbuckets);
+ printf (_(" Length Number %% of total Coverage\n"));
+
+ lengths = (unsigned long *) calloc (nbuckets, sizeof (*lengths));
+ if (lengths == NULL)
+ {
+ error (_("Out of memory\n"));
+ return 0;
+ }
+ for (hn = 0; hn < nbuckets; ++hn)
+ {
+ for (si = buckets[hn]; si > 0 && si < nchains; si = chains[si])
+ {
+ ++nsyms;
+ if (maxlength < ++lengths[hn])
+ ++maxlength;
+ }
+ }
+
+ counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
+ if (counts == NULL)
+ {
+ error (_("Out of memory\n"));
+ return 0;
+ }
+
+ for (hn = 0; hn < nbuckets; ++hn)
+ ++counts[lengths[hn]];
+
+ if (nbuckets > 0)
+ {
+ unsigned long i;
+ printf (" 0 %-10lu (%5.1f%%)\n",
+ counts[0], (counts[0] * 100.0) / nbuckets);
+ for (i = 1; i <= maxlength; ++i)
+ {
+ nzero_counts += counts[i] * i;
+ printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
+ i, counts[i], (counts[i] * 100.0) / nbuckets,
+ (nzero_counts * 100.0) / nsyms);
+ }
+ }
+
+ free (counts);
+ free (lengths);
+ }
+
+ if (buckets != NULL)
+ {
+ free (buckets);
+ free (chains);
+ }
+
+ if (do_histogram && gnubuckets != NULL)
+ {
+ unsigned long * lengths;
+ unsigned long * counts;
+ unsigned long hn;
+ unsigned long maxlength = 0;
+ unsigned long nzero_counts = 0;
+ unsigned long nsyms = 0;
+
+ lengths = (unsigned long *) calloc (ngnubuckets, sizeof (*lengths));
+ if (lengths == NULL)
+ {
+ error (_("Out of memory\n"));
+ return 0;
+ }
+
+ printf (_("\nHistogram for `.gnu.hash' bucket list length (total of %lu buckets):\n"),
+ (unsigned long) ngnubuckets);
+ printf (_(" Length Number %% of total Coverage\n"));
+
+ for (hn = 0; hn < ngnubuckets; ++hn)
+ if (gnubuckets[hn] != 0)
+ {
+ bfd_vma off, length = 1;
+
+ for (off = gnubuckets[hn] - gnusymidx;
+ (gnuchains[off] & 1) == 0; ++off)
+ ++length;
+ lengths[hn] = length;
+ if (length > maxlength)
+ maxlength = length;
+ nsyms += length;
+ }
+
+ counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
+ if (counts == NULL)
+ {
+ error (_("Out of memory\n"));
+ return 0;
+ }
+
+ for (hn = 0; hn < ngnubuckets; ++hn)
+ ++counts[lengths[hn]];
+
+ if (ngnubuckets > 0)
+ {
+ unsigned long j;
+ printf (" 0 %-10lu (%5.1f%%)\n",
+ counts[0], (counts[0] * 100.0) / ngnubuckets);
+ for (j = 1; j <= maxlength; ++j)
+ {
+ nzero_counts += counts[j] * j;
+ printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
+ j, counts[j], (counts[j] * 100.0) / ngnubuckets,
+ (nzero_counts * 100.0) / nsyms);
+ }
+ }
+
+ free (counts);
+ free (lengths);
+ free (gnubuckets);
+ free (gnuchains);
+ }
+
+ return 1;
+}
+
+static int
+process_syminfo (FILE * file ATTRIBUTE_UNUSED)
+{
+ unsigned int i;
+
+ if (dynamic_syminfo == NULL
+ || !do_dynamic)
+ /* No syminfo, this is ok. */
+ return 1;
+
+ /* There better should be a dynamic symbol section. */
+ if (dynamic_symbols == NULL || dynamic_strings == NULL)
+ return 0;
+
+ if (dynamic_addr)
+ printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
+ dynamic_syminfo_offset, dynamic_syminfo_nent);
+
+ printf (_(" Num: Name BoundTo Flags\n"));
+ for (i = 0; i < dynamic_syminfo_nent; ++i)
+ {
+ unsigned short int flags = dynamic_syminfo[i].si_flags;
+
+ printf ("%4d: ", i);
+ if (VALID_DYNAMIC_NAME (dynamic_symbols[i].st_name))
+ print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols[i].st_name));
+ else
+ printf (_("<corrupt: %19ld>"), dynamic_symbols[i].st_name);
+ putchar (' ');
+
+ switch (dynamic_syminfo[i].si_boundto)
+ {
+ case SYMINFO_BT_SELF:
+ fputs ("SELF ", stdout);
+ break;
+ case SYMINFO_BT_PARENT:
+ fputs ("PARENT ", stdout);
+ break;
+ default:
+ if (dynamic_syminfo[i].si_boundto > 0
+ && dynamic_syminfo[i].si_boundto < dynamic_nent
+ && VALID_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val))
+ {
+ print_symbol (10, GET_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val));
+ putchar (' ' );
+ }
+ else
+ printf ("%-10d ", dynamic_syminfo[i].si_boundto);
+ break;
+ }
+
+ if (flags & SYMINFO_FLG_DIRECT)
+ printf (" DIRECT");
+ if (flags & SYMINFO_FLG_PASSTHRU)
+ printf (" PASSTHRU");
+ if (flags & SYMINFO_FLG_COPY)
+ printf (" COPY");
+ if (flags & SYMINFO_FLG_LAZYLOAD)
+ printf (" LAZYLOAD");
+
+ puts ("");
+ }
+
+ return 1;
+}
+
+/* Check to see if the given reloc needs to be handled in a target specific
+ manner. If so then process the reloc and return TRUE otherwise return
+ FALSE. */
+
+static bfd_boolean
+target_specific_reloc_handling (Elf_Internal_Rela * reloc,
+ unsigned char * start,
+ Elf_Internal_Sym * symtab)
+{
+ unsigned int reloc_type = get_reloc_type (reloc->r_info);
+
+ switch (elf_header.e_machine)
+ {
+ case EM_MN10300:
+ case EM_CYGNUS_MN10300:
+ {
+ static Elf_Internal_Sym * saved_sym = NULL;
+
+ switch (reloc_type)
+ {
+ case 34: /* R_MN10300_ALIGN */
+ return TRUE;
+ case 33: /* R_MN10300_SYM_DIFF */
+ saved_sym = symtab + get_reloc_symindex (reloc->r_info);
+ return TRUE;
+ case 1: /* R_MN10300_32 */
+ case 2: /* R_MN10300_16 */
+ if (saved_sym != NULL)
+ {
+ bfd_vma value;
+
+ value = reloc->r_addend
+ + (symtab[get_reloc_symindex (reloc->r_info)].st_value
+ - saved_sym->st_value);
+
+ byte_put (start + reloc->r_offset, value, reloc_type == 1 ? 4 : 2);
+
+ saved_sym = NULL;
+ return TRUE;
+ }
+ break;
+ default:
+ if (saved_sym != NULL)
+ error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc"));
+ break;
+ }
+ break;
+ }
+ }
+
+ return FALSE;
+}
+
+/* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
+ DWARF debug sections. This is a target specific test. Note - we do not
+ go through the whole including-target-headers-multiple-times route, (as
+ we have already done with <elf/h8.h>) because this would become very
+ messy and even then this function would have to contain target specific
+ information (the names of the relocs instead of their numeric values).
+ FIXME: This is not the correct way to solve this problem. The proper way
+ is to have target specific reloc sizing and typing functions created by
+ the reloc-macros.h header, in the same way that it already creates the
+ reloc naming functions. */
+
+static bfd_boolean
+is_32bit_abs_reloc (unsigned int reloc_type)
+{
+ switch (elf_header.e_machine)
+ {
+ case EM_386:
+ case EM_486:
+ return reloc_type == 1; /* R_386_32. */
+ case EM_68K:
+ return reloc_type == 1; /* R_68K_32. */
+ case EM_860:
+ return reloc_type == 1; /* R_860_32. */
+ case EM_ALPHA:
+ return reloc_type == 1; /* XXX Is this right ? */
+ case EM_ARC:
+ return reloc_type == 1; /* R_ARC_32. */
+ case EM_ARM:
+ return reloc_type == 2; /* R_ARM_ABS32 */
+ case EM_AVR_OLD:
+ case EM_AVR:
+ return reloc_type == 1;
+ case EM_BLACKFIN:
+ return reloc_type == 0x12; /* R_byte4_data. */
+ case EM_CRIS:
+ return reloc_type == 3; /* R_CRIS_32. */
+ case EM_CR16:
+ case EM_CR16_OLD:
+ return reloc_type == 3; /* R_CR16_NUM32. */
+ case EM_CRX:
+ return reloc_type == 15; /* R_CRX_NUM32. */
+ case EM_CYGNUS_FRV:
+ return reloc_type == 1;
+ case EM_CYGNUS_D10V:
+ case EM_D10V:
+ return reloc_type == 6; /* R_D10V_32. */
+ case EM_CYGNUS_D30V:
+ case EM_D30V:
+ return reloc_type == 12; /* R_D30V_32_NORMAL. */
+ case EM_DLX:
+ return reloc_type == 3; /* R_DLX_RELOC_32. */
+ case EM_CYGNUS_FR30:
+ case EM_FR30:
+ return reloc_type == 3; /* R_FR30_32. */
+ case EM_H8S:
+ case EM_H8_300:
+ case EM_H8_300H:
+ return reloc_type == 1; /* R_H8_DIR32. */
+ case EM_IA_64:
+ return reloc_type == 0x65; /* R_IA64_SECREL32LSB. */
+ case EM_IP2K_OLD:
+ case EM_IP2K:
+ return reloc_type == 2; /* R_IP2K_32. */
+ case EM_IQ2000:
+ return reloc_type == 2; /* R_IQ2000_32. */
+ case EM_LATTICEMICO32:
+ return reloc_type == 3; /* R_LM32_32. */
+ case EM_M32C_OLD:
+ case EM_M32C:
+ return reloc_type == 3; /* R_M32C_32. */
+ case EM_M32R:
+ return reloc_type == 34; /* R_M32R_32_RELA. */
+ case EM_MCORE:
+ return reloc_type == 1; /* R_MCORE_ADDR32. */
+ case EM_CYGNUS_MEP:
+ return reloc_type == 4; /* R_MEP_32. */
+ case EM_MIPS:
+ return reloc_type == 2; /* R_MIPS_32. */
+ case EM_MMIX:
+ return reloc_type == 4; /* R_MMIX_32. */
+ case EM_CYGNUS_MN10200:
+ case EM_MN10200:
+ return reloc_type == 1; /* R_MN10200_32. */
+ case EM_CYGNUS_MN10300:
+ case EM_MN10300:
+ return reloc_type == 1; /* R_MN10300_32. */
+ case EM_MSP430_OLD:
+ case EM_MSP430:
+ return reloc_type == 1; /* R_MSP43_32. */
+ case EM_MT:
+ return reloc_type == 2; /* R_MT_32. */
+ case EM_ALTERA_NIOS2:
+ case EM_NIOS32:
+ return reloc_type == 1; /* R_NIOS_32. */
+ case EM_OPENRISC:
+ case EM_OR32:
+ return reloc_type == 1; /* R_OR32_32. */
+ case EM_PARISC:
+ return (reloc_type == 1 /* R_PARISC_DIR32. */
+ || reloc_type == 41); /* R_PARISC_SECREL32. */
+ case EM_PJ:
+ case EM_PJ_OLD:
+ return reloc_type == 1; /* R_PJ_DATA_DIR32. */
+ case EM_PPC64:
+ return reloc_type == 1; /* R_PPC64_ADDR32. */
+ case EM_PPC:
+ return reloc_type == 1; /* R_PPC_ADDR32. */
+ case EM_RX:
+ return reloc_type == 1; /* R_RX_DIR32. */
+ case EM_S370:
+ return reloc_type == 1; /* R_I370_ADDR31. */
+ case EM_S390_OLD:
+ case EM_S390:
+ return reloc_type == 4; /* R_S390_32. */
+ case EM_SCORE:
+ return reloc_type == 8; /* R_SCORE_ABS32. */
+ case EM_SH:
+ return reloc_type == 1; /* R_SH_DIR32. */
+ case EM_SPARC32PLUS:
+ case EM_SPARCV9:
+ case EM_SPARC:
+ return reloc_type == 3 /* R_SPARC_32. */
+ || reloc_type == 23; /* R_SPARC_UA32. */
+ case EM_SPU:
+ return reloc_type == 6; /* R_SPU_ADDR32 */
+ case EM_TI_C6000:
+ return reloc_type == 1; /* R_C6000_ABS32. */
+ case EM_CYGNUS_V850:
+ case EM_V850:
+ return reloc_type == 6; /* R_V850_ABS32. */
+ case EM_VAX:
+ return reloc_type == 1; /* R_VAX_32. */
+ case EM_X86_64:
+ case EM_L1OM:
+ return reloc_type == 10; /* R_X86_64_32. */
+ case EM_XC16X:
+ case EM_C166:
+ return reloc_type == 3; /* R_XC16C_ABS_32. */
+ case EM_XSTORMY16:
+ return reloc_type == 1; /* R_XSTROMY16_32. */
+ case EM_XTENSA_OLD:
+ case EM_XTENSA:
+ return reloc_type == 1; /* R_XTENSA_32. */
+ default:
+ error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
+ elf_header.e_machine);
+ abort ();
+ }
+}
+
+/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
+ a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
+
+static bfd_boolean
+is_32bit_pcrel_reloc (unsigned int reloc_type)
+{
+ switch (elf_header.e_machine)
+ {
+ case EM_386:
+ case EM_486:
+ return reloc_type == 2; /* R_386_PC32. */
+ case EM_68K:
+ return reloc_type == 4; /* R_68K_PC32. */
+ case EM_ALPHA:
+ return reloc_type == 10; /* R_ALPHA_SREL32. */
+ case EM_ARM:
+ return reloc_type == 3; /* R_ARM_REL32 */
+ case EM_PARISC:
+ return reloc_type == 9; /* R_PARISC_PCREL32. */
+ case EM_PPC:
+ return reloc_type == 26; /* R_PPC_REL32. */
+ case EM_PPC64:
+ return reloc_type == 26; /* R_PPC64_REL32. */
+ case EM_S390_OLD:
+ case EM_S390:
+ return reloc_type == 5; /* R_390_PC32. */
+ case EM_SH:
+ return reloc_type == 2; /* R_SH_REL32. */
+ case EM_SPARC32PLUS:
+ case EM_SPARCV9:
+ case EM_SPARC:
+ return reloc_type == 6; /* R_SPARC_DISP32. */
+ case EM_SPU:
+ return reloc_type == 13; /* R_SPU_REL32. */
+ case EM_X86_64:
+ case EM_L1OM:
+ return reloc_type == 2; /* R_X86_64_PC32. */
+ case EM_XTENSA_OLD:
+ case EM_XTENSA:
+ return reloc_type == 14; /* R_XTENSA_32_PCREL. */
+ default:
+ /* Do not abort or issue an error message here. Not all targets use
+ pc-relative 32-bit relocs in their DWARF debug information and we
+ have already tested for target coverage in is_32bit_abs_reloc. A
+ more helpful warning message will be generated by apply_relocations
+ anyway, so just return. */
+ return FALSE;
+ }
+}
+
+/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
+ a 64-bit absolute RELA relocation used in DWARF debug sections. */
+
+static bfd_boolean
+is_64bit_abs_reloc (unsigned int reloc_type)
+{
+ switch (elf_header.e_machine)
+ {
+ case EM_ALPHA:
+ return reloc_type == 2; /* R_ALPHA_REFQUAD. */
+ case EM_IA_64:
+ return reloc_type == 0x27; /* R_IA64_DIR64LSB. */
+ case EM_PARISC:
+ return reloc_type == 80; /* R_PARISC_DIR64. */
+ case EM_PPC64:
+ return reloc_type == 38; /* R_PPC64_ADDR64. */
+ case EM_SPARC32PLUS:
+ case EM_SPARCV9:
+ case EM_SPARC:
+ return reloc_type == 54; /* R_SPARC_UA64. */
+ case EM_X86_64:
+ case EM_L1OM:
+ return reloc_type == 1; /* R_X86_64_64. */
+ case EM_S390_OLD:
+ case EM_S390:
+ return reloc_type == 22; /* R_S390_64 */
+ case EM_MIPS:
+ return reloc_type == 18; /* R_MIPS_64 */
+ default:
+ return FALSE;
+ }
+}
+
+/* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
+ a 64-bit pc-relative RELA relocation used in DWARF debug sections. */
+
+static bfd_boolean
+is_64bit_pcrel_reloc (unsigned int reloc_type)
+{
+ switch (elf_header.e_machine)
+ {
+ case EM_ALPHA:
+ return reloc_type == 11; /* R_ALPHA_SREL64 */
+ case EM_IA_64:
+ return reloc_type == 0x4f; /* R_IA64_PCREL64LSB */
+ case EM_PARISC:
+ return reloc_type == 72; /* R_PARISC_PCREL64 */
+ case EM_PPC64:
+ return reloc_type == 44; /* R_PPC64_REL64 */
+ case EM_SPARC32PLUS:
+ case EM_SPARCV9:
+ case EM_SPARC:
+ return reloc_type == 46; /* R_SPARC_DISP64 */
+ case EM_X86_64:
+ case EM_L1OM:
+ return reloc_type == 24; /* R_X86_64_PC64 */
+ case EM_S390_OLD:
+ case EM_S390:
+ return reloc_type == 23; /* R_S390_PC64 */
+ default:
+ return FALSE;
+ }
+}
+
+/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
+ a 24-bit absolute RELA relocation used in DWARF debug sections. */
+
+static bfd_boolean
+is_24bit_abs_reloc (unsigned int reloc_type)
+{
+ switch (elf_header.e_machine)
+ {
+ case EM_CYGNUS_MN10200:
+ case EM_MN10200:
+ return reloc_type == 4; /* R_MN10200_24. */
+ default:
+ return FALSE;
+ }
+}
+
+/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
+ a 16-bit absolute RELA relocation used in DWARF debug sections. */
+
+static bfd_boolean
+is_16bit_abs_reloc (unsigned int reloc_type)
+{
+ switch (elf_header.e_machine)
+ {
+ case EM_AVR_OLD:
+ case EM_AVR:
+ return reloc_type == 4; /* R_AVR_16. */
+ case EM_CYGNUS_D10V:
+ case EM_D10V:
+ return reloc_type == 3; /* R_D10V_16. */
+ case EM_H8S:
+ case EM_H8_300:
+ case EM_H8_300H:
+ return reloc_type == R_H8_DIR16;
+ case EM_IP2K_OLD:
+ case EM_IP2K:
+ return reloc_type == 1; /* R_IP2K_16. */
+ case EM_M32C_OLD:
+ case EM_M32C:
+ return reloc_type == 1; /* R_M32C_16 */
+ case EM_MSP430_OLD:
+ case EM_MSP430:
+ return reloc_type == 5; /* R_MSP430_16_BYTE. */
+ case EM_ALTERA_NIOS2:
+ case EM_NIOS32:
+ return reloc_type == 9; /* R_NIOS_16. */
+ case EM_TI_C6000:
+ return reloc_type == 2; /* R_C6000_ABS16. */
+ case EM_XC16X:
+ case EM_C166:
+ return reloc_type == 2; /* R_XC16C_ABS_16. */
+ default:
+ return FALSE;
}
+}
- if (buckets != NULL)
+/* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
+ relocation entries (possibly formerly used for SHT_GROUP sections). */
+
+static bfd_boolean
+is_none_reloc (unsigned int reloc_type)
+{
+ switch (elf_header.e_machine)
{
- free (buckets);
- free (chains);
+ case EM_68K: /* R_68K_NONE. */
+ case EM_386: /* R_386_NONE. */
+ case EM_SPARC32PLUS:
+ case EM_SPARCV9:
+ case EM_SPARC: /* R_SPARC_NONE. */
+ case EM_MIPS: /* R_MIPS_NONE. */
+ case EM_PARISC: /* R_PARISC_NONE. */
+ case EM_ALPHA: /* R_ALPHA_NONE. */
+ case EM_PPC: /* R_PPC_NONE. */
+ case EM_PPC64: /* R_PPC64_NONE. */
+ case EM_ARM: /* R_ARM_NONE. */
+ case EM_IA_64: /* R_IA64_NONE. */
+ case EM_SH: /* R_SH_NONE. */
+ case EM_S390_OLD:
+ case EM_S390: /* R_390_NONE. */
+ case EM_CRIS: /* R_CRIS_NONE. */
+ case EM_X86_64: /* R_X86_64_NONE. */
+ case EM_L1OM: /* R_X86_64_NONE. */
+ case EM_MN10300: /* R_MN10300_NONE. */
+ case EM_M32R: /* R_M32R_NONE. */
+ case EM_TI_C6000:/* R_C6000_NONE. */
+ case EM_XC16X:
+ case EM_C166: /* R_XC16X_NONE. */
+ return reloc_type == 0;
+ case EM_XTENSA_OLD:
+ case EM_XTENSA:
+ return (reloc_type == 0 /* R_XTENSA_NONE. */
+ || reloc_type == 17 /* R_XTENSA_DIFF8. */
+ || reloc_type == 18 /* R_XTENSA_DIFF16. */
+ || reloc_type == 19 /* R_XTENSA_DIFF32. */);
}
+ return FALSE;
+}
- if (do_histogram && dynamic_info_DT_GNU_HASH)
- {
- unsigned long *lengths;
- unsigned long *counts;
- unsigned long hn;
- unsigned long maxlength = 0;
- unsigned long nzero_counts = 0;
- unsigned long nsyms = 0;
+/* Apply relocations to a section.
+ Note: So far support has been added only for those relocations
+ which can be found in debug sections.
+ FIXME: Add support for more relocations ? */
- lengths = calloc (ngnubuckets, sizeof (*lengths));
- if (lengths == NULL)
- {
- error (_("Out of memory\n"));
- return 0;
- }
+static void
+apply_relocations (void * file,
+ Elf_Internal_Shdr * section,
+ unsigned char * start)
+{
+ Elf_Internal_Shdr * relsec;
+ unsigned char * end = start + section->sh_size;
- printf (_("\nHistogram for `.gnu.hash' bucket list length (total of %lu buckets):\n"),
- (unsigned long) ngnubuckets);
- printf (_(" Length Number %% of total Coverage\n"));
+ if (elf_header.e_type != ET_REL)
+ return;
- for (hn = 0; hn < ngnubuckets; ++hn)
- if (gnubuckets[hn] != 0)
- {
- bfd_vma off, length = 1;
+ /* Find the reloc section associated with the section. */
+ for (relsec = section_headers;
+ relsec < section_headers + elf_header.e_shnum;
+ ++relsec)
+ {
+ bfd_boolean is_rela;
+ unsigned long num_relocs;
+ Elf_Internal_Rela * relocs;
+ Elf_Internal_Rela * rp;
+ Elf_Internal_Shdr * symsec;
+ Elf_Internal_Sym * symtab;
+ Elf_Internal_Sym * sym;
- for (off = gnubuckets[hn] - gnusymidx;
- (gnuchains[off] & 1) == 0; ++off)
- ++length;
- lengths[hn] = length;
- if (length > maxlength)
- maxlength = length;
- nsyms += length;
- }
+ if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
+ || relsec->sh_info >= elf_header.e_shnum
+ || section_headers + relsec->sh_info != section
+ || relsec->sh_size == 0
+ || relsec->sh_link >= elf_header.e_shnum)
+ continue;
- counts = calloc (maxlength + 1, sizeof (*counts));
- if (counts == NULL)
+ is_rela = relsec->sh_type == SHT_RELA;
+
+ if (is_rela)
{
- error (_("Out of memory\n"));
- return 0;
+ if (!slurp_rela_relocs ((FILE *) file, relsec->sh_offset,
+ relsec->sh_size, & relocs, & num_relocs))
+ return;
+ }
+ else
+ {
+ if (!slurp_rel_relocs ((FILE *) file, relsec->sh_offset,
+ relsec->sh_size, & relocs, & num_relocs))
+ return;
}
- for (hn = 0; hn < ngnubuckets; ++hn)
- ++counts[lengths[hn]];
+ /* SH uses RELA but uses in place value instead of the addend field. */
+ if (elf_header.e_machine == EM_SH)
+ is_rela = FALSE;
- if (ngnubuckets > 0)
+ symsec = section_headers + relsec->sh_link;
+ symtab = GET_ELF_SYMBOLS ((FILE *) file, symsec);
+
+ for (rp = relocs; rp < relocs + num_relocs; ++rp)
{
- unsigned long j;
- printf (" 0 %-10lu (%5.1f%%)\n",
- counts[0], (counts[0] * 100.0) / ngnubuckets);
- for (j = 1; j <= maxlength; ++j)
- {
- nzero_counts += counts[j] * j;
- printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
- j, counts[j], (counts[j] * 100.0) / ngnubuckets,
- (nzero_counts * 100.0) / nsyms);
- }
- }
+ bfd_vma addend;
+ unsigned int reloc_type;
+ unsigned int reloc_size;
+ unsigned char * rloc;
- free (counts);
- free (lengths);
- free (gnubuckets);
- free (gnuchains);
- }
+ reloc_type = get_reloc_type (rp->r_info);
- return 1;
-}
+ if (target_specific_reloc_handling (rp, start, symtab))
+ continue;
+ else if (is_none_reloc (reloc_type))
+ continue;
+ else if (is_32bit_abs_reloc (reloc_type)
+ || is_32bit_pcrel_reloc (reloc_type))
+ reloc_size = 4;
+ else if (is_64bit_abs_reloc (reloc_type)
+ || is_64bit_pcrel_reloc (reloc_type))
+ reloc_size = 8;
+ else if (is_24bit_abs_reloc (reloc_type))
+ reloc_size = 3;
+ else if (is_16bit_abs_reloc (reloc_type))
+ reloc_size = 2;
+ else
+ {
+ warn (_("unable to apply unsupported reloc type %d to section %s\n"),
+ reloc_type, SECTION_NAME (section));
+ continue;
+ }
-static int
-process_syminfo (FILE *file ATTRIBUTE_UNUSED)
-{
- unsigned int i;
+ rloc = start + rp->r_offset;
+ if ((rloc + reloc_size) > end)
+ {
+ warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
+ (unsigned long) rp->r_offset,
+ SECTION_NAME (section));
+ continue;
+ }
- if (dynamic_syminfo == NULL
- || !do_dynamic)
- /* No syminfo, this is ok. */
- return 1;
+ sym = symtab + get_reloc_symindex (rp->r_info);
- /* There better should be a dynamic symbol section. */
- if (dynamic_symbols == NULL || dynamic_strings == NULL)
- return 0;
+ /* If the reloc has a symbol associated with it,
+ make sure that it is of an appropriate type.
- if (dynamic_addr)
- printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
- dynamic_syminfo_offset, dynamic_syminfo_nent);
+ Relocations against symbols without type can happen.
+ Gcc -feliminate-dwarf2-dups may generate symbols
+ without type for debug info.
- printf (_(" Num: Name BoundTo Flags\n"));
- for (i = 0; i < dynamic_syminfo_nent; ++i)
- {
- unsigned short int flags = dynamic_syminfo[i].si_flags;
+ Icc generates relocations against function symbols
+ instead of local labels.
- printf ("%4d: ", i);
- if (VALID_DYNAMIC_NAME (dynamic_symbols[i].st_name))
- print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols[i].st_name));
- else
- printf ("<corrupt: %19ld>", dynamic_symbols[i].st_name);
- putchar (' ');
+ Relocations against object symbols can happen, eg when
+ referencing a global array. For an example of this see
+ the _clz.o binary in libgcc.a. */
+ if (sym != symtab
+ && ELF_ST_TYPE (sym->st_info) > STT_SECTION)
+ {
+ warn (_("skipping unexpected symbol type %s in %ld'th relocation in section %s\n"),
+ get_symbol_type (ELF_ST_TYPE (sym->st_info)),
+ (long int)(rp - relocs),
+ SECTION_NAME (relsec));
+ continue;
+ }
- switch (dynamic_syminfo[i].si_boundto)
- {
- case SYMINFO_BT_SELF:
- fputs ("SELF ", stdout);
- break;
- case SYMINFO_BT_PARENT:
- fputs ("PARENT ", stdout);
- break;
- default:
- if (dynamic_syminfo[i].si_boundto > 0
- && dynamic_syminfo[i].si_boundto < dynamic_nent
- && VALID_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val))
+ addend = 0;
+ if (is_rela)
+ addend += rp->r_addend;
+ /* R_XTENSA_32 and R_PJ_DATA_DIR32 are partial_inplace. */
+ if (!is_rela
+ || (elf_header.e_machine == EM_XTENSA
+ && reloc_type == 1)
+ || ((elf_header.e_machine == EM_PJ
+ || elf_header.e_machine == EM_PJ_OLD)
+ && reloc_type == 1))
+ addend += byte_get (rloc, reloc_size);
+
+ if (is_32bit_pcrel_reloc (reloc_type)
+ || is_64bit_pcrel_reloc (reloc_type))
{
- print_symbol (10, GET_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val));
- putchar (' ' );
+ /* On HPPA, all pc-relative relocations are biased by 8. */
+ if (elf_header.e_machine == EM_PARISC)
+ addend -= 8;
+ byte_put (rloc, (addend + sym->st_value) - rp->r_offset,
+ reloc_size);
}
else
- printf ("%-10d ", dynamic_syminfo[i].si_boundto);
- break;
+ byte_put (rloc, addend + sym->st_value, reloc_size);
}
- if (flags & SYMINFO_FLG_DIRECT)
- printf (" DIRECT");
- if (flags & SYMINFO_FLG_PASSTHRU)
- printf (" PASSTHRU");
- if (flags & SYMINFO_FLG_COPY)
- printf (" COPY");
- if (flags & SYMINFO_FLG_LAZYLOAD)
- printf (" LAZYLOAD");
-
- puts ("");
+ free (symtab);
+ free (relocs);
+ break;
}
-
- return 1;
}
#ifdef SUPPORT_DISASSEMBLY
static int
-disassemble_section (Elf_Internal_Shdr *section, FILE *file)
+disassemble_section (Elf_Internal_Shdr * section, FILE * file)
{
printf (_("\nAssembly dump of section %s\n"),
SECTION_NAME (section));
}
#endif
-static int
-dump_section_as_strings (Elf_Internal_Shdr *section, FILE *file)
-{
- Elf_Internal_Shdr *relsec;
- bfd_size_type num_bytes;
- bfd_vma addr;
- char *data;
- char *end;
- char *start;
- char *name = SECTION_NAME (section);
- bfd_boolean some_strings_shown;
-
- num_bytes = section->sh_size;
-
- if (num_bytes == 0 || section->sh_type == SHT_NOBITS)
- {
- printf (_("\nSection '%s' has no data to dump.\n"), name);
- return 0;
- }
-
- addr = section->sh_addr;
-
- start = get_data (NULL, file, section->sh_offset, 1, num_bytes,
- _("section data"));
- if (!start)
- return 0;
-
- printf (_("\nString dump of section '%s':\n"), name);
-
- /* If the section being dumped has relocations against it the user might
- be expecting these relocations to have been applied. Check for this
- case and issue a warning message in order to avoid confusion.
- FIXME: Maybe we ought to have an option that dumps a section with
- relocs applied ? */
- for (relsec = section_headers;
- relsec < section_headers + elf_header.e_shnum;
- ++relsec)
- {
- if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
- || relsec->sh_info >= elf_header.e_shnum
- || section_headers + relsec->sh_info != section
- || relsec->sh_size == 0
- || relsec->sh_link >= elf_header.e_shnum)
- continue;
-
- printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
- break;
- }
-
- data = start;
- end = start + num_bytes;
- some_strings_shown = FALSE;
-
- while (data < end)
- {
- while (!ISPRINT (* data))
- if (++ data >= end)
- break;
-
- if (data < end)
- {
-#ifndef __MSVCRT__
- printf (" [%6tx] %s\n", data - start, data);
-#else
- printf (" [%6Ix] %s\n", (size_t) (data - start), data);
-#endif
- data += strlen (data);
- some_strings_shown = TRUE;
- }
- }
-
- if (! some_strings_shown)
- printf (_(" No strings found in this section."));
-
- free (start);
-
- putchar ('\n');
- return 1;
-}
-
+/* Reads in the contents of SECTION from FILE, returning a pointer
+ to a malloc'ed buffer or NULL if something went wrong. */
-static int
-dump_section_as_bytes (Elf_Internal_Shdr *section, FILE *file)
-{
- Elf_Internal_Shdr *relsec;
- bfd_size_type bytes;
- bfd_vma addr;
- unsigned char *data;
- unsigned char *start;
+static char *
+get_section_contents (Elf_Internal_Shdr * section, FILE * file)
+{
+ bfd_size_type num_bytes;
- bytes = section->sh_size;
+ num_bytes = section->sh_size;
- if (bytes == 0 || section->sh_type == SHT_NOBITS)
+ if (num_bytes == 0 || section->sh_type == SHT_NOBITS)
{
printf (_("\nSection '%s' has no data to dump.\n"),
SECTION_NAME (section));
- return 0;
+ return NULL;
}
- else
- printf (_("\nHex dump of section '%s':\n"), SECTION_NAME (section));
- addr = section->sh_addr;
+ return (char *) get_data (NULL, file, section->sh_offset, 1, num_bytes,
+ _("section contents"));
+}
- start = get_data (NULL, file, section->sh_offset, 1, bytes,
- _("section data"));
- if (!start)
- return 0;
+
+static void
+dump_section_as_strings (Elf_Internal_Shdr * section, FILE * file)
+{
+ Elf_Internal_Shdr * relsec;
+ bfd_size_type num_bytes;
+ char * data;
+ char * end;
+ char * start;
+ char * name = SECTION_NAME (section);
+ bfd_boolean some_strings_shown;
+
+ start = get_section_contents (section, file);
+ if (start == NULL)
+ return;
+
+ printf (_("\nString dump of section '%s':\n"), name);
/* If the section being dumped has relocations against it the user might
be expecting these relocations to have been applied. Check for this
|| relsec->sh_link >= elf_header.e_shnum)
continue;
- printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
+ printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
break;
}
+ num_bytes = section->sh_size;
data = start;
+ end = start + num_bytes;
+ some_strings_shown = FALSE;
- while (bytes)
+ while (data < end)
{
- int j;
- int k;
- int lbytes;
-
- lbytes = (bytes > 16 ? 16 : bytes);
-
- printf (" 0x%8.8lx ", (unsigned long) addr);
-
- for (j = 0; j < 16; j++)
- {
- if (j < lbytes)
- printf ("%2.2x", data[j]);
- else
- printf (" ");
-
- if ((j & 3) == 3)
- printf (" ");
- }
+ while (!ISPRINT (* data))
+ if (++ data >= end)
+ break;
- for (j = 0; j < lbytes; j++)
+ if (data < end)
{
- k = data[j];
- if (k >= ' ' && k < 0x7f)
- printf ("%c", k);
- else
- printf (".");
+#ifndef __MSVCRT__
+ /* PR 11128: Use two separate invocations in order to work
+ around bugs in the Solaris 8 implementation of printf. */
+ printf (" [%6tx] ", data - start);
+ printf ("%s\n", data);
+#else
+ printf (" [%6Ix] %s\n", (size_t) (data - start), data);
+#endif
+ data += strlen (data);
+ some_strings_shown = TRUE;
}
-
- putchar ('\n');
-
- data += lbytes;
- addr += lbytes;
- bytes -= lbytes;
}
+ if (! some_strings_shown)
+ printf (_(" No strings found in this section."));
+
free (start);
putchar ('\n');
- return 1;
-}
-
-/* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
- DWARF debug sections. This is a target specific test. Note - we do not
- go through the whole including-target-headers-multiple-times route, (as
- we have already done with <elf/h8.h>) because this would become very
- messy and even then this function would have to contain target specific
- information (the names of the relocs instead of their numeric values).
- FIXME: This is not the correct way to solve this problem. The proper way
- is to have target specific reloc sizing and typing functions created by
- the reloc-macros.h header, in the same way that it already creates the
- reloc naming functions. */
-
-static bfd_boolean
-is_32bit_abs_reloc (unsigned int reloc_type)
-{
- switch (elf_header.e_machine)
- {
- case EM_386:
- case EM_486:
- return reloc_type == 1; /* R_386_32. */
- case EM_68K:
- return reloc_type == 1; /* R_68K_32. */
- case EM_860:
- return reloc_type == 1; /* R_860_32. */
- case EM_ALPHA:
- return reloc_type == 1; /* XXX Is this right ? */
- case EM_ARC:
- return reloc_type == 1; /* R_ARC_32. */
- case EM_ARM:
- return reloc_type == 2; /* R_ARM_ABS32 */
- case EM_AVR_OLD:
- case EM_AVR:
- return reloc_type == 1;
- case EM_BLACKFIN:
- return reloc_type == 0x12; /* R_byte4_data. */
- case EM_CRIS:
- return reloc_type == 3; /* R_CRIS_32. */
- case EM_CR16:
- case EM_CR16_OLD:
- return reloc_type == 3; /* R_CR16_NUM32. */
- case EM_CRX:
- return reloc_type == 15; /* R_CRX_NUM32. */
- case EM_CYGNUS_FRV:
- return reloc_type == 1;
- case EM_CYGNUS_D10V:
- case EM_D10V:
- return reloc_type == 6; /* R_D10V_32. */
- case EM_CYGNUS_D30V:
- case EM_D30V:
- return reloc_type == 12; /* R_D30V_32_NORMAL. */
- case EM_DLX:
- return reloc_type == 3; /* R_DLX_RELOC_32. */
- case EM_CYGNUS_FR30:
- case EM_FR30:
- return reloc_type == 3; /* R_FR30_32. */
- case EM_H8S:
- case EM_H8_300:
- case EM_H8_300H:
- return reloc_type == 1; /* R_H8_DIR32. */
- case EM_IA_64:
- return reloc_type == 0x65; /* R_IA64_SECREL32LSB. */
- case EM_IP2K_OLD:
- case EM_IP2K:
- return reloc_type == 2; /* R_IP2K_32. */
- case EM_IQ2000:
- return reloc_type == 2; /* R_IQ2000_32. */
- case EM_M32C_OLD:
- case EM_M32C:
- return reloc_type == 3; /* R_M32C_32. */
- case EM_M32R:
- return reloc_type == 34; /* R_M32R_32_RELA. */
- case EM_MCORE:
- return reloc_type == 1; /* R_MCORE_ADDR32. */
- case EM_CYGNUS_MEP:
- return reloc_type == 4; /* R_MEP_32. */
- case EM_MIPS:
- return reloc_type == 2; /* R_MIPS_32. */
- case EM_MMIX:
- return reloc_type == 4; /* R_MMIX_32. */
- case EM_CYGNUS_MN10200:
- case EM_MN10200:
- return reloc_type == 1; /* R_MN10200_32. */
- case EM_CYGNUS_MN10300:
- case EM_MN10300:
- return reloc_type == 1; /* R_MN10300_32. */
- case EM_MSP430_OLD:
- case EM_MSP430:
- return reloc_type == 1; /* R_MSP43_32. */
- case EM_MT:
- return reloc_type == 2; /* R_MT_32. */
- case EM_ALTERA_NIOS2:
- case EM_NIOS32:
- return reloc_type == 1; /* R_NIOS_32. */
- case EM_OPENRISC:
- case EM_OR32:
- return reloc_type == 1; /* R_OR32_32. */
- case EM_PARISC:
- return reloc_type == 1; /* R_PARISC_DIR32. */
- case EM_PJ:
- case EM_PJ_OLD:
- return reloc_type == 1; /* R_PJ_DATA_DIR32. */
- case EM_PPC64:
- return reloc_type == 1; /* R_PPC64_ADDR32. */
- case EM_PPC:
- return reloc_type == 1; /* R_PPC_ADDR32. */
- case EM_S370:
- return reloc_type == 1; /* R_I370_ADDR31. */
- case EM_S390_OLD:
- case EM_S390:
- return reloc_type == 4; /* R_S390_32. */
- case EM_SCORE:
- return reloc_type == 8; /* R_SCORE_ABS32. */
- case EM_SH:
- return reloc_type == 1; /* R_SH_DIR32. */
- case EM_SPARC32PLUS:
- case EM_SPARCV9:
- case EM_SPARC:
- return reloc_type == 3 /* R_SPARC_32. */
- || reloc_type == 23; /* R_SPARC_UA32. */
- case EM_SPU:
- return reloc_type == 6; /* R_SPU_ADDR32 */
- case EM_CYGNUS_V850:
- case EM_V850:
- return reloc_type == 6; /* R_V850_ABS32. */
- case EM_VAX:
- return reloc_type == 1; /* R_VAX_32. */
- case EM_X86_64:
- return reloc_type == 10; /* R_X86_64_32. */
- case EM_XSTORMY16:
- return reloc_type == 1; /* R_XSTROMY16_32. */
- case EM_XTENSA_OLD:
- case EM_XTENSA:
- return reloc_type == 1; /* R_XTENSA_32. */
-
- default:
- error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
- elf_header.e_machine);
- abort ();
- }
-}
-
-/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
- a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
-
-static bfd_boolean
-is_32bit_pcrel_reloc (unsigned int reloc_type)
-{
- switch (elf_header.e_machine)
- {
- case EM_386:
- case EM_486:
- return reloc_type == 2; /* R_386_PC32. */
- case EM_68K:
- return reloc_type == 4; /* R_68K_PC32. */
- case EM_ALPHA:
- return reloc_type == 10; /* R_ALPHA_SREL32. */
- case EM_ARM:
- return reloc_type == 3; /* R_ARM_REL32 */
- case EM_PARISC:
- return reloc_type == 0; /* R_PARISC_NONE. *//* FIXME: This reloc is generated, but it may be a bug. */
- case EM_PPC:
- return reloc_type == 26; /* R_PPC_REL32. */
- case EM_PPC64:
- return reloc_type == 26; /* R_PPC64_REL32. */
- case EM_S390_OLD:
- case EM_S390:
- return reloc_type == 5; /* R_390_PC32. */
- case EM_SH:
- return reloc_type == 2; /* R_SH_REL32. */
- case EM_SPARC32PLUS:
- case EM_SPARCV9:
- case EM_SPARC:
- return reloc_type == 6; /* R_SPARC_DISP32. */
- case EM_SPU:
- return reloc_type == 13; /* R_SPU_REL32. */
- case EM_X86_64:
- return reloc_type == 2; /* R_X86_64_PC32. */
- case EM_XTENSA_OLD:
- case EM_XTENSA:
- return reloc_type == 14; /* R_XTENSA_32_PCREL. */
- default:
- /* Do not abort or issue an error message here. Not all targets use
- pc-relative 32-bit relocs in their DWARF debug information and we
- have already tested for target coverage in is_32bit_abs_reloc. A
- more helpful warning message will be generated by
- debug_apply_relocations anyway, so just return. */
- return FALSE;
- }
}
-/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
- a 64-bit absolute RELA relocation used in DWARF debug sections. */
-
-static bfd_boolean
-is_64bit_abs_reloc (unsigned int reloc_type)
+static void
+dump_section_as_bytes (Elf_Internal_Shdr * section,
+ FILE * file,
+ bfd_boolean relocate)
{
- switch (elf_header.e_machine)
+ Elf_Internal_Shdr * relsec;
+ bfd_size_type bytes;
+ bfd_vma addr;
+ unsigned char * data;
+ unsigned char * start;
+
+ start = (unsigned char *) get_section_contents (section, file);
+ if (start == NULL)
+ return;
+
+ printf (_("\nHex dump of section '%s':\n"), SECTION_NAME (section));
+
+ if (relocate)
{
- case EM_ALPHA:
- return reloc_type == 2; /* R_ALPHA_REFQUAD. */
- case EM_IA_64:
- return reloc_type == 0x27; /* R_IA64_DIR64LSB. */
- case EM_PARISC:
- return reloc_type == 80; /* R_PARISC_DIR64. */
- case EM_PPC64:
- return reloc_type == 38; /* R_PPC64_ADDR64. */
- case EM_SPARC32PLUS:
- case EM_SPARCV9:
- case EM_SPARC:
- return reloc_type == 54; /* R_SPARC_UA64. */
- case EM_X86_64:
- return reloc_type == 1; /* R_X86_64_64. */
- case EM_S390_OLD:
- case EM_S390:
- return reloc_type == 22; /* R_S390_64 */
- default:
- return FALSE;
+ apply_relocations (file, section, start);
}
-}
+ else
+ {
+ /* If the section being dumped has relocations against it the user might
+ be expecting these relocations to have been applied. Check for this
+ case and issue a warning message in order to avoid confusion.
+ FIXME: Maybe we ought to have an option that dumps a section with
+ relocs applied ? */
+ for (relsec = section_headers;
+ relsec < section_headers + elf_header.e_shnum;
+ ++relsec)
+ {
+ if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
+ || relsec->sh_info >= elf_header.e_shnum
+ || section_headers + relsec->sh_info != section
+ || relsec->sh_size == 0
+ || relsec->sh_link >= elf_header.e_shnum)
+ continue;
-/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
- a 16-bit absolute RELA relocation used in DWARF debug sections. */
+ printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
+ break;
+ }
+ }
-static bfd_boolean
-is_16bit_abs_reloc (unsigned int reloc_type)
-{
- switch (elf_header.e_machine)
+ addr = section->sh_addr;
+ bytes = section->sh_size;
+ data = start;
+
+ while (bytes)
{
- case EM_AVR_OLD:
- case EM_AVR:
- return reloc_type == 4; /* R_AVR_16. */
- case EM_CYGNUS_D10V:
- case EM_D10V:
- return reloc_type == 3; /* R_D10V_16. */
- case EM_H8S:
- case EM_H8_300:
- case EM_H8_300H:
- return reloc_type == R_H8_DIR16;
- case EM_IP2K_OLD:
- case EM_IP2K:
- return reloc_type == 1; /* R_IP2K_16. */
- case EM_M32C_OLD:
- case EM_M32C:
- return reloc_type == 1; /* R_M32C_16 */
- case EM_MSP430_OLD:
- case EM_MSP430:
- return reloc_type == 5; /* R_MSP430_16_BYTE. */
- case EM_ALTERA_NIOS2:
- case EM_NIOS32:
- return reloc_type == 9; /* R_NIOS_16. */
- default:
- return FALSE;
+ int j;
+ int k;
+ int lbytes;
+
+ lbytes = (bytes > 16 ? 16 : bytes);
+
+ printf (" 0x%8.8lx ", (unsigned long) addr);
+
+ for (j = 0; j < 16; j++)
+ {
+ if (j < lbytes)
+ printf ("%2.2x", data[j]);
+ else
+ printf (" ");
+
+ if ((j & 3) == 3)
+ printf (" ");
+ }
+
+ for (j = 0; j < lbytes; j++)
+ {
+ k = data[j];
+ if (k >= ' ' && k < 0x7f)
+ printf ("%c", k);
+ else
+ printf (".");
+ }
+
+ putchar ('\n');
+
+ data += lbytes;
+ addr += lbytes;
+ bytes -= lbytes;
}
+
+ free (start);
+
+ putchar ('\n');
}
/* Uncompresses a section that was compressed using zlib, in place.
- * This is a copy of bfd_uncompress_section_contents, in bfd/compress.c */
+ This is a copy of bfd_uncompress_section_contents, in bfd/compress.c */
static int
-uncompress_section_contents (unsigned char **buffer, dwarf_size_type *size)
+uncompress_section_contents (unsigned char ** buffer, dwarf_size_type * size)
{
#ifndef HAVE_ZLIB_H
/* These are just to quiet gcc. */
return FALSE;
#else
dwarf_size_type compressed_size = *size;
- unsigned char* compressed_buffer = *buffer;
+ unsigned char * compressed_buffer = *buffer;
dwarf_size_type uncompressed_size;
- unsigned char* uncompressed_buffer;
+ unsigned char * uncompressed_buffer;
z_stream strm;
int rc;
dwarf_size_type header_size = 12;
/* Read the zlib header. In this case, it should be "ZLIB" followed
by the uncompressed section size, 8 bytes in big-endian order. */
if (compressed_size < header_size
- || ! streq ((char*) compressed_buffer, "ZLIB"))
+ || ! streq ((char *) compressed_buffer, "ZLIB"))
return 0;
+
uncompressed_size = compressed_buffer[4]; uncompressed_size <<= 8;
uncompressed_size += compressed_buffer[5]; uncompressed_size <<= 8;
uncompressed_size += compressed_buffer[6]; uncompressed_size <<= 8;
strm.zfree = NULL;
strm.opaque = NULL;
strm.avail_in = compressed_size - header_size;
- strm.next_in = (Bytef*) compressed_buffer + header_size;
+ strm.next_in = (Bytef *) compressed_buffer + header_size;
strm.avail_out = uncompressed_size;
- uncompressed_buffer = xmalloc (uncompressed_size);
+ uncompressed_buffer = (unsigned char *) xmalloc (uncompressed_size);
- rc = inflateInit (&strm);
+ rc = inflateInit (& strm);
while (strm.avail_in > 0)
{
if (rc != Z_OK)
goto fail;
- strm.next_out = ((Bytef*) uncompressed_buffer
+ strm.next_out = ((Bytef *) uncompressed_buffer
+ (uncompressed_size - strm.avail_out));
rc = inflate (&strm, Z_FINISH);
if (rc != Z_STREAM_END)
goto fail;
- rc = inflateReset (&strm);
+ rc = inflateReset (& strm);
}
- rc = inflateEnd (&strm);
+ rc = inflateEnd (& strm);
if (rc != Z_OK
|| strm.avail_out != 0)
goto fail;
#endif /* HAVE_ZLIB_H */
}
-/* Apply relocations to a debug section. */
-
-static void
-debug_apply_relocations (void *file,
- Elf_Internal_Shdr *section,
- unsigned char *start)
+static int
+load_specific_debug_section (enum dwarf_section_display_enum debug,
+ Elf_Internal_Shdr * sec, void * file)
{
- Elf_Internal_Shdr *relsec;
- unsigned char *end = start + section->sh_size;
-
- if (elf_header.e_type != ET_REL)
- return;
-
- /* Find the reloc section associated with the debug section. */
- for (relsec = section_headers;
- relsec < section_headers + elf_header.e_shnum;
- ++relsec)
- {
- bfd_boolean is_rela;
- unsigned long num_relocs;
- Elf_Internal_Rela *relocs, *rp;
- Elf_Internal_Shdr *symsec;
- Elf_Internal_Sym *symtab;
- Elf_Internal_Sym *sym;
-
- if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
- || relsec->sh_info >= elf_header.e_shnum
- || section_headers + relsec->sh_info != section
- || relsec->sh_size == 0
- || relsec->sh_link >= elf_header.e_shnum)
- continue;
-
- is_rela = relsec->sh_type == SHT_RELA;
-
- if (is_rela)
- {
- if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
- & relocs, & num_relocs))
- return;
- }
- else
- {
- if (!slurp_rel_relocs (file, relsec->sh_offset, relsec->sh_size,
- & relocs, & num_relocs))
- return;
- }
-
- /* SH uses RELA but uses in place value instead of the addend field. */
- if (elf_header.e_machine == EM_SH)
- is_rela = FALSE;
-
- symsec = section_headers + relsec->sh_link;
- symtab = GET_ELF_SYMBOLS (file, symsec);
-
- for (rp = relocs; rp < relocs + num_relocs; ++rp)
- {
- bfd_vma addend;
- unsigned int reloc_type;
- unsigned int reloc_size;
- unsigned char * loc;
-
- /* In MIPS little-endian objects, r_info isn't really a
- 64-bit little-endian value: it has a 32-bit little-endian
- symbol index followed by four individual byte fields.
- Reorder INFO accordingly. */
- if (!is_32bit_elf
- && elf_header.e_machine == EM_MIPS
- && elf_header.e_ident[EI_DATA] != ELFDATA2MSB)
- rp->r_info = (((rp->r_info & 0xffffffff) << 32)
- | ((rp->r_info >> 56) & 0xff)
- | ((rp->r_info >> 40) & 0xff00)
- | ((rp->r_info >> 24) & 0xff0000)
- | ((rp->r_info >> 8) & 0xff000000));
-
- reloc_type = get_reloc_type (rp->r_info);
+ struct dwarf_section * section = &debug_displays [debug].section;
+ char buf [64];
+ int section_is_compressed;
- if (is_32bit_abs_reloc (reloc_type)
- || is_32bit_pcrel_reloc (reloc_type))
- reloc_size = 4;
- else if (is_64bit_abs_reloc (reloc_type))
- reloc_size = 8;
- else if (is_16bit_abs_reloc (reloc_type))
- reloc_size = 2;
- else
- {
- warn (_("unable to apply unsupported reloc type %d to section %s\n"),
- reloc_type, SECTION_NAME (section));
- continue;
- }
+ /* If it is already loaded, do nothing. */
+ if (section->start != NULL)
+ return 1;
- loc = start + rp->r_offset;
- if ((loc + reloc_size) > end)
- {
- warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
- (unsigned long) rp->r_offset,
- SECTION_NAME (section));
- continue;
- }
+ section_is_compressed = section->name == section->compressed_name;
- sym = symtab + get_reloc_symindex (rp->r_info);
+ snprintf (buf, sizeof (buf), _("%s section data"), section->name);
+ section->address = sec->sh_addr;
+ section->size = sec->sh_size;
+ section->start = (unsigned char *) get_data (NULL, (FILE *) file,
+ sec->sh_offset, 1,
+ sec->sh_size, buf);
+ if (section->start == NULL)
+ return 0;
- /* If the reloc has a symbol associated with it,
- make sure that it is of an appropriate type. */
- if (sym != symtab
- && ELF_ST_TYPE (sym->st_info) != STT_SECTION
- /* Relocations against symbols without type can happen.
- Gcc -feliminate-dwarf2-dups may generate symbols
- without type for debug info. */
- && ELF_ST_TYPE (sym->st_info) != STT_NOTYPE
- /* Relocations against object symbols can happen,
- eg when referencing a global array. For an
- example of this see the _clz.o binary in libgcc.a. */
- && ELF_ST_TYPE (sym->st_info) != STT_OBJECT)
- {
- warn (_("skipping unexpected symbol type %s in %ld'th relocation in section %s\n"),
- get_symbol_type (ELF_ST_TYPE (sym->st_info)),
- (long int)(rp - relocs),
- SECTION_NAME (relsec));
- continue;
- }
+ if (section_is_compressed)
+ if (! uncompress_section_contents (§ion->start, §ion->size))
+ return 0;
- addend = is_rela ? rp->r_addend : byte_get (loc, reloc_size);
-
- if (is_32bit_pcrel_reloc (reloc_type))
- byte_put (loc, (addend + sym->st_value) - rp->r_offset,
- reloc_size);
- else
- byte_put (loc, addend + sym->st_value, reloc_size);
- }
+ if (debug_displays [debug].relocate)
+ apply_relocations ((FILE *) file, sec, section->start);
- free (symtab);
- free (relocs);
- break;
- }
+ return 1;
}
int
-load_debug_section (enum dwarf_section_display_enum debug, void *file)
+load_debug_section (enum dwarf_section_display_enum debug, void * file)
{
- struct dwarf_section *section = &debug_displays [debug].section;
- Elf_Internal_Shdr *sec;
- char buf [64];
- int section_is_compressed;
-
- /* If it is already loaded, do nothing. */
- if (section->start != NULL)
- return 1;
+ struct dwarf_section * section = &debug_displays [debug].section;
+ Elf_Internal_Shdr * sec;
/* Locate the debug section. */
sec = find_section (section->uncompressed_name);
}
if (sec == NULL)
return 0;
- section_is_compressed = section->name == section->compressed_name;
-
- snprintf (buf, sizeof (buf), _("%s section data"), section->name);
- section->address = sec->sh_addr;
- section->size = sec->sh_size;
- section->start = get_data (NULL, file, sec->sh_offset, 1,
- sec->sh_size, buf);
- if (section->start == NULL)
- return 0;
-
- if (section_is_compressed)
- if (! uncompress_section_contents (§ion->start, §ion->size))
- return 0;
-
- if (debug_displays [debug].relocate)
- debug_apply_relocations (file, sec, section->start);
- return 1;
+ return load_specific_debug_section (debug, sec, (FILE *) file);
}
void
free_debug_section (enum dwarf_section_display_enum debug)
{
- struct dwarf_section *section = &debug_displays [debug].section;
+ struct dwarf_section * section = &debug_displays [debug].section;
if (section->start == NULL)
return;
}
static int
-display_debug_section (Elf_Internal_Shdr *section, FILE *file)
+display_debug_section (Elf_Internal_Shdr * section, FILE * file)
{
- char *name = SECTION_NAME (section);
+ char * name = SECTION_NAME (section);
bfd_size_type length;
int result = 1;
- enum dwarf_section_display_enum i;
+ int i;
length = section->sh_size;
if (length == 0)
printf (_("\nSection '%s' has no debugging data.\n"), name);
return 0;
}
+ if (section->sh_type == SHT_NOBITS)
+ {
+ /* There is no point in dumping the contents of a debugging section
+ which has the NOBITS type - the bits in the file will be random.
+ This can happen when a file containing a .eh_frame section is
+ stripped with the --only-keep-debug command line option. */
+ printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"), name);
+ return 0;
+ }
if (const_strneq (name, ".gnu.linkonce.wi."))
name = ".debug_info";
if (streq (debug_displays[i].section.uncompressed_name, name)
|| streq (debug_displays[i].section.compressed_name, name))
{
- struct dwarf_section *sec = &debug_displays [i].section;
-
- if (load_debug_section (i, file))
+ struct dwarf_section * sec = &debug_displays [i].section;
+ int secondary = (section != find_section (name));
+
+ if (secondary)
+ free_debug_section ((enum dwarf_section_display_enum) i);
+
+ if (streq (sec->uncompressed_name, name))
+ sec->name = sec->uncompressed_name;
+ else
+ sec->name = sec->compressed_name;
+ if (load_specific_debug_section ((enum dwarf_section_display_enum) i,
+ section, file))
{
result &= debug_displays[i].display (sec, file);
- if (i != info && i != abbrev)
- free_debug_section (i);
+ if (secondary || (i != info && i != abbrev))
+ free_debug_section ((enum dwarf_section_display_enum) i);
}
break;
static void
initialise_dumps_byname (void)
{
- struct dump_list_entry *cur;
+ struct dump_list_entry * cur;
for (cur = dump_sects_byname; cur; cur = cur->next)
{
}
static void
-process_section_contents (FILE *file)
+process_section_contents (FILE * file)
{
- Elf_Internal_Shdr *section;
+ Elf_Internal_Shdr * section;
unsigned int i;
if (! do_dump)
disassemble_section (section, file);
#endif
if (dump_sects[i] & HEX_DUMP)
- dump_section_as_bytes (section, file);
+ dump_section_as_bytes (section, file, FALSE);
- if (dump_sects[i] & DEBUG_DUMP)
- display_debug_section (section, file);
+ if (dump_sects[i] & RELOC_DUMP)
+ dump_section_as_bytes (section, file, TRUE);
if (dump_sects[i] & STRING_DUMP)
dump_section_as_strings (section, file);
+
+ if (dump_sects[i] & DEBUG_DUMP)
+ display_debug_section (section, file);
}
/* Check to see if the user requested a
typedef struct
{
int tag;
- const char *name;
+ const char * name;
/* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
int type;
- const char **table;
+ const char ** table;
} arm_attr_public_tag;
-static const char *arm_attr_tag_CPU_arch[] =
+static const char * arm_attr_tag_CPU_arch[] =
{"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
- "v6K", "v7"};
-static const char *arm_attr_tag_ARM_ISA_use[] = {"No", "Yes"};
-static const char *arm_attr_tag_THUMB_ISA_use[] =
+ "v6K", "v7", "v6-M", "v6S-M", "v7E-M"};
+static const char * arm_attr_tag_ARM_ISA_use[] = {"No", "Yes"};
+static const char * arm_attr_tag_THUMB_ISA_use[] =
{"No", "Thumb-1", "Thumb-2"};
-static const char *arm_attr_tag_VFP_arch[] =
- {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16"};
-static const char *arm_attr_tag_WMMX_arch[] = {"No", "WMMXv1"};
-static const char *arm_attr_tag_NEON_arch[] = {"No", "NEONv1"};
-static const char *arm_attr_tag_ABI_PCS_config[] =
+static const char * arm_attr_tag_FP_arch[] =
+ {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16"};
+static const char * arm_attr_tag_WMMX_arch[] = {"No", "WMMXv1", "WMMXv2"};
+static const char * arm_attr_tag_Advanced_SIMD_arch[] =
+ {"No", "NEONv1", "NEONv1 with Fused-MAC"};
+static const char * arm_attr_tag_PCS_config[] =
{"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
"PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
-static const char *arm_attr_tag_ABI_PCS_R9_use[] =
+static const char * arm_attr_tag_ABI_PCS_R9_use[] =
{"V6", "SB", "TLS", "Unused"};
-static const char *arm_attr_tag_ABI_PCS_RW_data[] =
+static const char * arm_attr_tag_ABI_PCS_RW_data[] =
{"Absolute", "PC-relative", "SB-relative", "None"};
-static const char *arm_attr_tag_ABI_PCS_RO_DATA[] =
+static const char * arm_attr_tag_ABI_PCS_RO_data[] =
{"Absolute", "PC-relative", "None"};
-static const char *arm_attr_tag_ABI_PCS_GOT_use[] =
+static const char * arm_attr_tag_ABI_PCS_GOT_use[] =
{"None", "direct", "GOT-indirect"};
-static const char *arm_attr_tag_ABI_PCS_wchar_t[] =
+static const char * arm_attr_tag_ABI_PCS_wchar_t[] =
{"None", "??? 1", "2", "??? 3", "4"};
-static const char *arm_attr_tag_ABI_FP_rounding[] = {"Unused", "Needed"};
-static const char *arm_attr_tag_ABI_FP_denormal[] = {"Unused", "Needed"};
-static const char *arm_attr_tag_ABI_FP_exceptions[] = {"Unused", "Needed"};
-static const char *arm_attr_tag_ABI_FP_user_exceptions[] = {"Unused", "Needed"};
-static const char *arm_attr_tag_ABI_FP_number_model[] =
+static const char * arm_attr_tag_ABI_FP_rounding[] = {"Unused", "Needed"};
+static const char * arm_attr_tag_ABI_FP_denormal[] =
+ {"Unused", "Needed", "Sign only"};
+static const char * arm_attr_tag_ABI_FP_exceptions[] = {"Unused", "Needed"};
+static const char * arm_attr_tag_ABI_FP_user_exceptions[] = {"Unused", "Needed"};
+static const char * arm_attr_tag_ABI_FP_number_model[] =
{"Unused", "Finite", "RTABI", "IEEE 754"};
-static const char *arm_attr_tag_ABI_align8_needed[] = {"No", "Yes", "4-byte"};
-static const char *arm_attr_tag_ABI_align8_preserved[] =
- {"No", "Yes, except leaf SP", "Yes"};
-static const char *arm_attr_tag_ABI_enum_size[] =
+static const char * arm_attr_tag_ABI_enum_size[] =
{"Unused", "small", "int", "forced to int"};
-static const char *arm_attr_tag_ABI_HardFP_use[] =
- {"As Tag_VFP_arch", "SP only", "DP only", "SP and DP"};
-static const char *arm_attr_tag_ABI_VFP_args[] =
+static const char * arm_attr_tag_ABI_HardFP_use[] =
+ {"As Tag_FP_arch", "SP only", "DP only", "SP and DP"};
+static const char * arm_attr_tag_ABI_VFP_args[] =
{"AAPCS", "VFP registers", "custom"};
-static const char *arm_attr_tag_ABI_WMMX_args[] =
+static const char * arm_attr_tag_ABI_WMMX_args[] =
{"AAPCS", "WMMX registers", "custom"};
-static const char *arm_attr_tag_ABI_optimization_goals[] =
+static const char * arm_attr_tag_ABI_optimization_goals[] =
{"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
"Aggressive Size", "Prefer Debug", "Aggressive Debug"};
-static const char *arm_attr_tag_ABI_FP_optimization_goals[] =
+static const char * arm_attr_tag_ABI_FP_optimization_goals[] =
{"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
"Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
+static const char * arm_attr_tag_CPU_unaligned_access[] = {"None", "v6"};
+static const char * arm_attr_tag_FP_HP_extension[] =
+ {"Not Allowed", "Allowed"};
+static const char * arm_attr_tag_ABI_FP_16bit_format[] =
+ {"None", "IEEE 754", "Alternative Format"};
+static const char * arm_attr_tag_MPextension_use[] =
+ {"Not Allowed", "Allowed"};
+static const char * arm_attr_tag_DIV_use[] =
+ {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
+ "Allowed in v7-A with integer division extension"};
+static const char * arm_attr_tag_T2EE_use[] = {"Not Allowed", "Allowed"};
+static const char * arm_attr_tag_Virtualization_use[] =
+ {"Not Allowed", "TrustZone", "Virtualization Extensions",
+ "TrustZone and Virtualization Extensions"};
+static const char * arm_attr_tag_MPextension_use_legacy[] =
+ {"Not Allowed", "Allowed"};
#define LOOKUP(id, name) \
{id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
{7, "CPU_arch_profile", 0, NULL},
LOOKUP(8, ARM_ISA_use),
LOOKUP(9, THUMB_ISA_use),
- LOOKUP(10, VFP_arch),
+ LOOKUP(10, FP_arch),
LOOKUP(11, WMMX_arch),
- LOOKUP(12, NEON_arch),
- LOOKUP(13, ABI_PCS_config),
+ LOOKUP(12, Advanced_SIMD_arch),
+ LOOKUP(13, PCS_config),
LOOKUP(14, ABI_PCS_R9_use),
LOOKUP(15, ABI_PCS_RW_data),
- LOOKUP(16, ABI_PCS_RO_DATA),
+ LOOKUP(16, ABI_PCS_RO_data),
LOOKUP(17, ABI_PCS_GOT_use),
LOOKUP(18, ABI_PCS_wchar_t),
LOOKUP(19, ABI_FP_rounding),
LOOKUP(21, ABI_FP_exceptions),
LOOKUP(22, ABI_FP_user_exceptions),
LOOKUP(23, ABI_FP_number_model),
- LOOKUP(24, ABI_align8_needed),
- LOOKUP(25, ABI_align8_preserved),
+ {24, "ABI_align_needed", 0, NULL},
+ {25, "ABI_align_preserved", 0, NULL},
LOOKUP(26, ABI_enum_size),
LOOKUP(27, ABI_HardFP_use),
LOOKUP(28, ABI_VFP_args),
LOOKUP(29, ABI_WMMX_args),
LOOKUP(30, ABI_optimization_goals),
LOOKUP(31, ABI_FP_optimization_goals),
- {32, "compatibility", 0, NULL}
+ {32, "compatibility", 0, NULL},
+ LOOKUP(34, CPU_unaligned_access),
+ LOOKUP(36, FP_HP_extension),
+ LOOKUP(38, ABI_FP_16bit_format),
+ LOOKUP(42, MPextension_use),
+ LOOKUP(44, DIV_use),
+ {64, "nodefaults", 0, NULL},
+ {65, "also_compatible_with", 0, NULL},
+ LOOKUP(66, T2EE_use),
+ {67, "conformance", 1, NULL},
+ LOOKUP(68, Virtualization_use),
+ LOOKUP(70, MPextension_use_legacy)
};
#undef LOOKUP
-/* Read an unsigned LEB128 encoded value from p. Set *PLEN to the number of
- bytes read. */
-static unsigned int
-read_uleb128 (unsigned char *p, unsigned int *plen)
-{
- unsigned char c;
- unsigned int val;
- int shift;
- int len;
-
- val = 0;
- shift = 0;
- len = 0;
- do
- {
- c = *(p++);
- len++;
- val |= ((unsigned int)c & 0x7f) << shift;
- shift += 7;
- }
- while (c & 0x80);
-
- *plen = len;
- return val;
-}
-
static unsigned char *
-display_arm_attribute (unsigned char *p)
+display_arm_attribute (unsigned char * p)
{
int tag;
unsigned int len;
int val;
- arm_attr_public_tag *attr;
+ arm_attr_public_tag * attr;
unsigned i;
int type;
tag = read_uleb128 (p, &len);
p += len;
attr = NULL;
- for (i = 0; i < ARRAY_SIZE(arm_attr_public_tags); i++)
+ for (i = 0; i < ARRAY_SIZE (arm_attr_public_tags); i++)
{
if (arm_attr_public_tags[i].tag == tag)
{
p += len;
switch (val)
{
- case 0: printf ("None\n"); break;
- case 'A': printf ("Application\n"); break;
- case 'R': printf ("Realtime\n"); break;
- case 'M': printf ("Microcontroller\n"); break;
- default: printf ("??? (%d)\n", val); break;
+ case 0: printf (_("None\n")); break;
+ case 'A': printf (_("Application\n")); break;
+ case 'R': printf (_("Realtime\n")); break;
+ case 'M': printf (_("Microcontroller\n")); break;
+ case 'S': printf (_("Application or Realtime\n")); break;
+ default: printf ("??? (%d)\n", val); break;
+ }
+ break;
+
+ case 24: /* Tag_align_needed. */
+ val = read_uleb128 (p, &len);
+ p += len;
+ switch (val)
+ {
+ case 0: printf (_("None\n")); break;
+ case 1: printf (_("8-byte\n")); break;
+ case 2: printf (_("4-byte\n")); break;
+ case 3: printf ("??? 3\n"); break;
+ default:
+ if (val <= 12)
+ printf (_("8-byte and up to %d-byte extended\n"),
+ 1 << val);
+ else
+ printf ("??? (%d)\n", val);
+ break;
+ }
+ break;
+
+ case 25: /* Tag_align_preserved. */
+ val = read_uleb128 (p, &len);
+ p += len;
+ switch (val)
+ {
+ case 0: printf (_("None\n")); break;
+ case 1: printf (_("8-byte, except leaf SP\n")); break;
+ case 2: printf (_("8-byte\n")); break;
+ case 3: printf ("??? 3\n"); break;
+ default:
+ if (val <= 12)
+ printf (_("8-byte and up to %d-byte extended\n"),
+ 1 << val);
+ else
+ printf ("??? (%d)\n", val);
+ break;
}
break;
case 32: /* Tag_compatibility. */
val = read_uleb128 (p, &len);
p += len;
- printf ("flag = %d, vendor = %s\n", val, p);
- p += strlen((char *)p) + 1;
+ printf (_("flag = %d, vendor = %s\n"), val, p);
+ p += strlen ((char *) p) + 1;
+ break;
+
+ case 64: /* Tag_nodefaults. */
+ p++;
+ printf (_("True\n"));
+ break;
+
+ case 65: /* Tag_also_compatible_with. */
+ val = read_uleb128 (p, &len);
+ p += len;
+ if (val == 6 /* Tag_CPU_arch. */)
+ {
+ val = read_uleb128 (p, &len);
+ p += len;
+ if ((unsigned int)val >= ARRAY_SIZE (arm_attr_tag_CPU_arch))
+ printf ("??? (%d)\n", val);
+ else
+ printf ("%s\n", arm_attr_tag_CPU_arch[val]);
+ }
+ else
+ printf ("???\n");
+ while (*(p++) != '\0' /* NUL terminator. */);
break;
default:
- abort();
+ abort ();
}
return p;
if (type == 1)
{
printf ("\"%s\"\n", p);
- p += strlen((char *)p) + 1;
+ p += strlen ((char *) p) + 1;
}
else
{
{
val = read_uleb128 (p, &len);
p += len;
- printf ("flag = %d, vendor = %s\n", val, p);
+ printf (_("flag = %d, vendor = %s\n"), val, p);
p += strlen ((char *) p) + 1;
return p;
}
}
static unsigned char *
-display_power_gnu_attribute (unsigned char *p, int tag)
+display_power_gnu_attribute (unsigned char * p, int tag)
{
int type;
unsigned int len;
switch (val)
{
case 0:
- printf ("Hard or soft float\n");
+ printf (_("Hard or soft float\n"));
break;
case 1:
- printf ("Hard float\n");
+ printf (_("Hard float\n"));
break;
case 2:
- printf ("Soft float\n");
+ printf (_("Soft float\n"));
+ break;
+ case 3:
+ printf (_("Single-precision hard float\n"));
break;
default:
printf ("??? (%d)\n", val);
switch (val)
{
case 0:
- printf ("Any\n");
+ printf (_("Any\n"));
break;
case 1:
- printf ("Generic\n");
+ printf (_("Generic\n"));
break;
case 2:
printf ("AltiVec\n");
return p;
}
+ if (tag == Tag_GNU_Power_ABI_Struct_Return)
+ {
+ val = read_uleb128 (p, &len);
+ p += len;
+ printf (" Tag_GNU_Power_ABI_Struct_Return: ");
+ switch (val)
+ {
+ case 0:
+ printf (_("Any\n"));
+ break;
+ case 1:
+ printf ("r3/r4\n");
+ break;
+ case 2:
+ printf (_("Memory\n"));
+ break;
+ default:
+ printf ("??? (%d)\n", val);
+ break;
+ }
+ return p;
+ }
+
if (tag & 1)
type = 1; /* String. */
else
}
static unsigned char *
-display_mips_gnu_attribute (unsigned char *p, int tag)
+display_mips_gnu_attribute (unsigned char * p, int tag)
{
int type;
unsigned int len;
switch (val)
{
case 0:
- printf ("Hard or soft float\n");
+ printf (_("Hard or soft float\n"));
break;
case 1:
- printf ("Hard float (-mdouble-float)\n");
+ printf (_("Hard float (double precision)\n"));
break;
case 2:
- printf ("Hard float (-msingle-float)\n");
+ printf (_("Hard float (single precision)\n"));
break;
case 3:
- printf ("Soft float\n");
+ printf (_("Soft float\n"));
break;
case 4:
- printf ("64-bit float (-mips32r2 -mfp64)\n");
+ printf (_("64-bit float (-mips32r2 -mfp64)\n"));
break;
default:
printf ("??? (%d)\n", val);
unsigned char * (* display_pub_attribute) (unsigned char *),
unsigned char * (* display_proc_gnu_attribute) (unsigned char *, int))
{
- Elf_Internal_Shdr *sect;
- unsigned char *contents;
- unsigned char *p;
- unsigned char *end;
+ Elf_Internal_Shdr * sect;
+ unsigned char * contents;
+ unsigned char * p;
+ unsigned char * end;
bfd_vma section_len;
bfd_vma len;
unsigned i;
if (sect->sh_type != proc_type && sect->sh_type != SHT_GNU_ATTRIBUTES)
continue;
- contents = get_data (NULL, file, sect->sh_offset, 1, sect->sh_size,
- _("attributes"));
+ contents = (unsigned char *) get_data (NULL, file, sect->sh_offset, 1,
+ sect->sh_size, _("attributes"));
if (contents == NULL)
continue;
}
len -= section_len;
- printf ("Attribute Section: %s\n", p);
+ printf (_("Attribute Section: %s\n"), p);
if (public_name && streq ((char *) p, public_name))
public_section = TRUE;
switch (tag)
{
case 1:
- printf ("File Attributes\n");
+ printf (_("File Attributes\n"));
break;
case 2:
- printf ("Section Attributes:");
+ printf (_("Section Attributes:"));
goto do_numlist;
case 3:
- printf ("Symbol Attributes:");
+ printf (_("Symbol Attributes:"));
do_numlist:
for (;;)
{
- unsigned int i;
+ unsigned int j;
- val = read_uleb128 (p, &i);
- p += i;
+ val = read_uleb128 (p, &j);
+ p += j;
if (val == 0)
break;
printf (" %d", val);
printf ("\n");
break;
default:
- printf ("Unknown tag: %d\n", tag);
+ printf (_("Unknown tag: %d\n"), tag);
public_section = FALSE;
break;
}
else
{
/* ??? Do something sensible, like dump hex. */
- printf (" Unknown section contexts\n");
+ printf (_(" Unknown section contexts\n"));
p = end;
}
}
}
static int
-process_arm_specific (FILE *file)
+process_arm_specific (FILE * file)
{
return process_attributes (file, "aeabi", SHT_ARM_ATTRIBUTES,
display_arm_attribute, NULL);
}
static int
-process_power_specific (FILE *file)
+process_power_specific (FILE * file)
{
return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
display_power_gnu_attribute);
and return the VMA of the next entry. */
static bfd_vma
-print_mips_got_entry (unsigned char *data, bfd_vma pltgot, bfd_vma addr)
+print_mips_got_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr)
{
printf (" ");
print_vma (addr, LONG_HEX);
printf ("%10s", "");
printf (" ");
if (data == NULL)
- printf ("%*s", is_32bit_elf ? 8 : 16, "<unknown>");
+ printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
+ else
+ {
+ bfd_vma entry;
+
+ entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
+ print_vma (entry, LONG_HEX);
+ }
+ return addr + (is_32bit_elf ? 4 : 8);
+}
+
+/* DATA points to the contents of a MIPS PLT GOT that starts at VMA
+ PLTGOT. Print the Address and Initial fields of an entry at VMA
+ ADDR and return the VMA of the next entry. */
+
+static bfd_vma
+print_mips_pltgot_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr)
+{
+ printf (" ");
+ print_vma (addr, LONG_HEX);
+ printf (" ");
+ if (data == NULL)
+ printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
else
{
bfd_vma entry;
}
static int
-process_mips_specific (FILE *file)
+process_mips_specific (FILE * file)
{
- Elf_Internal_Dyn *entry;
+ Elf_Internal_Dyn * entry;
size_t liblist_offset = 0;
size_t liblistno = 0;
size_t conflictsno = 0;
size_t options_offset = 0;
size_t conflicts_offset = 0;
+ size_t pltrelsz = 0;
+ size_t pltrel = 0;
bfd_vma pltgot = 0;
+ bfd_vma mips_pltgot = 0;
+ bfd_vma jmprel = 0;
bfd_vma local_gotno = 0;
bfd_vma gotsym = 0;
bfd_vma symtabno = 0;
conflictsno = entry->d_un.d_val;
break;
case DT_PLTGOT:
- pltgot = entry->d_un.d_val;
+ pltgot = entry->d_un.d_ptr;
+ break;
case DT_MIPS_LOCAL_GOTNO:
local_gotno = entry->d_un.d_val;
break;
case DT_MIPS_SYMTABNO:
symtabno = entry->d_un.d_val;
break;
+ case DT_MIPS_PLTGOT:
+ mips_pltgot = entry->d_un.d_ptr;
+ break;
+ case DT_PLTREL:
+ pltrel = entry->d_un.d_val;
+ break;
+ case DT_PLTRELSZ:
+ pltrelsz = entry->d_un.d_val;
+ break;
+ case DT_JMPREL:
+ jmprel = entry->d_un.d_ptr;
+ break;
default:
break;
}
if (liblist_offset != 0 && liblistno != 0 && do_dynamic)
{
- Elf32_External_Lib *elib;
+ Elf32_External_Lib * elib;
size_t cnt;
- elib = get_data (NULL, file, liblist_offset,
- liblistno, sizeof (Elf32_External_Lib),
- _("liblist"));
+ elib = (Elf32_External_Lib *) get_data (NULL, file, liblist_offset,
+ liblistno,
+ sizeof (Elf32_External_Lib),
+ _("liblist"));
if (elib)
{
- printf ("\nSection '.liblist' contains %lu entries:\n",
+ printf (_("\nSection '.liblist' contains %lu entries:\n"),
(unsigned long) liblistno);
- fputs (" Library Time Stamp Checksum Version Flags\n",
+ fputs (_(" Library Time Stamp Checksum Version Flags\n"),
stdout);
for (cnt = 0; cnt < liblistno; ++cnt)
{
Elf32_Lib liblist;
- time_t time;
+ time_t atime;
char timebuf[20];
- struct tm *tmp;
+ struct tm * tmp;
liblist.l_name = BYTE_GET (elib[cnt].l_name);
- time = BYTE_GET (elib[cnt].l_time_stamp);
+ atime = BYTE_GET (elib[cnt].l_time_stamp);
liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
liblist.l_version = BYTE_GET (elib[cnt].l_version);
liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
- tmp = gmtime (&time);
+ tmp = gmtime (&atime);
snprintf (timebuf, sizeof (timebuf),
"%04u-%02u-%02uT%02u:%02u:%02u",
tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
if (VALID_DYNAMIC_NAME (liblist.l_name))
print_symbol (20, GET_DYNAMIC_NAME (liblist.l_name));
else
- printf ("<corrupt: %9ld>", liblist.l_name);
+ printf (_("<corrupt: %9ld>"), liblist.l_name);
printf (" %s %#10lx %-7ld", timebuf, liblist.l_checksum,
liblist.l_version);
if (liblist.l_flags == 0)
- puts (" NONE");
+ puts (_(" NONE"));
else
{
static const struct
{
- const char *name;
+ const char * name;
int bit;
}
l_flags_vals[] =
if (options_offset != 0)
{
- Elf_External_Options *eopt;
- Elf_Internal_Shdr *sect = section_headers;
- Elf_Internal_Options *iopt;
- Elf_Internal_Options *option;
+ Elf_External_Options * eopt;
+ Elf_Internal_Shdr * sect = section_headers;
+ Elf_Internal_Options * iopt;
+ Elf_Internal_Options * option;
size_t offset;
int cnt;
while (sect->sh_type != SHT_MIPS_OPTIONS)
++sect;
- eopt = get_data (NULL, file, options_offset, 1, sect->sh_size,
- _("options"));
+ eopt = (Elf_External_Options *) get_data (NULL, file, options_offset, 1,
+ sect->sh_size, _("options"));
if (eopt)
{
- iopt = cmalloc ((sect->sh_size / sizeof (eopt)), sizeof (*iopt));
+ iopt = (Elf_Internal_Options *)
+ cmalloc ((sect->sh_size / sizeof (eopt)), sizeof (* iopt));
if (iopt == NULL)
{
error (_("Out of memory\n"));
while (offset < sect->sh_size)
{
- Elf_External_Options *eoption;
+ Elf_External_Options * eoption;
eoption = (Elf_External_Options *) ((char *) eopt + offset);
if (elf_header.e_machine == EM_MIPS)
{
/* 32bit form. */
- Elf32_External_RegInfo *ereg;
+ Elf32_External_RegInfo * ereg;
Elf32_RegInfo reginfo;
ereg = (Elf32_External_RegInfo *) (option + 1);
else
{
/* 64 bit form. */
- Elf64_External_RegInfo *ereg;
+ Elf64_External_RegInfo * ereg;
Elf64_Internal_RegInfo reginfo;
ereg = (Elf64_External_RegInfo *) (option + 1);
break;
}
- len = sizeof (*eopt);
+ len = sizeof (* eopt);
while (len < option->size)
if (((char *) option)[len] >= ' '
&& ((char *) option)[len] < 0x7f)
if (conflicts_offset != 0 && conflictsno != 0)
{
- Elf32_Conflict *iconf;
+ Elf32_Conflict * iconf;
size_t cnt;
if (dynamic_symbols == NULL)
return 0;
}
- iconf = cmalloc (conflictsno, sizeof (*iconf));
+ iconf = (Elf32_Conflict *) cmalloc (conflictsno, sizeof (* iconf));
if (iconf == NULL)
{
error (_("Out of memory\n"));
if (is_32bit_elf)
{
- Elf32_External_Conflict *econf32;
+ Elf32_External_Conflict * econf32;
- econf32 = get_data (NULL, file, conflicts_offset,
- conflictsno, sizeof (*econf32), _("conflict"));
+ econf32 = (Elf32_External_Conflict *)
+ get_data (NULL, file, conflicts_offset, conflictsno,
+ sizeof (* econf32), _("conflict"));
if (!econf32)
return 0;
}
else
{
- Elf64_External_Conflict *econf64;
+ Elf64_External_Conflict * econf64;
- econf64 = get_data (NULL, file, conflicts_offset,
- conflictsno, sizeof (*econf64), _("conflict"));
+ econf64 = (Elf64_External_Conflict *)
+ get_data (NULL, file, conflicts_offset, conflictsno,
+ sizeof (* econf64), _("conflict"));
if (!econf64)
return 0;
for (cnt = 0; cnt < conflictsno; ++cnt)
{
- Elf_Internal_Sym *psym = & dynamic_symbols[iconf[cnt]];
+ Elf_Internal_Sym * psym = & dynamic_symbols[iconf[cnt]];
printf ("%5lu: %8lu ", (unsigned long) cnt, iconf[cnt]);
print_vma (psym->st_value, FULL_HEX);
if (VALID_DYNAMIC_NAME (psym->st_name))
print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
else
- printf ("<corrupt: %14ld>", psym->st_name);
+ printf (_("<corrupt: %14ld>"), psym->st_name);
putchar ('\n');
}
if (pltgot != 0 && local_gotno != 0)
{
- bfd_vma entry, local_end, global_end;
+ bfd_vma ent, local_end, global_end;
size_t i, offset;
- unsigned char *data;
+ unsigned char * data;
int addr_size;
- entry = pltgot;
+ ent = pltgot;
addr_size = (is_32bit_elf ? 4 : 8);
local_end = pltgot + local_gotno * addr_size;
global_end = local_end + (symtabno - gotsym) * addr_size;
offset = offset_from_vma (file, pltgot, global_end - pltgot);
- data = get_data (NULL, file, offset, global_end - pltgot, 1, _("GOT"));
+ data = (unsigned char *) get_data (NULL, file, offset,
+ global_end - pltgot, 1, _("GOT"));
printf (_("\nPrimary GOT:\n"));
printf (_(" Canonical gp value: "));
print_vma (pltgot + 0x7ff0, LONG_HEX);
printf (_(" Reserved entries:\n"));
printf (_(" %*s %10s %*s Purpose\n"),
- addr_size * 2, "Address", "Access",
- addr_size * 2, "Initial");
- entry = print_mips_got_entry (data, pltgot, entry);
- printf (" Lazy resolver\n");
+ addr_size * 2, _("Address"), _("Access"),
+ addr_size * 2, _("Initial"));
+ ent = print_mips_got_entry (data, pltgot, ent);
+ printf (_(" Lazy resolver\n"));
if (data
- && (byte_get (data + entry - pltgot, addr_size)
+ && (byte_get (data + ent - pltgot, addr_size)
>> (addr_size * 8 - 1)) != 0)
{
- entry = print_mips_got_entry (data, pltgot, entry);
- printf (" Module pointer (GNU extension)\n");
+ ent = print_mips_got_entry (data, pltgot, ent);
+ printf (_(" Module pointer (GNU extension)\n"));
}
printf ("\n");
- if (entry < local_end)
+ if (ent < local_end)
{
printf (_(" Local entries:\n"));
printf (_(" %*s %10s %*s\n"),
- addr_size * 2, "Address", "Access",
- addr_size * 2, "Initial");
- while (entry < local_end)
+ addr_size * 2, _("Address"), _("Access"),
+ addr_size * 2, _("Initial"));
+ while (ent < local_end)
{
- entry = print_mips_got_entry (data, pltgot, entry);
+ ent = print_mips_got_entry (data, pltgot, ent);
printf ("\n");
}
printf ("\n");
printf (_(" Global entries:\n"));
printf (_(" %*s %10s %*s %*s %-7s %3s %s\n"),
- addr_size * 2, "Address", "Access",
- addr_size * 2, "Initial",
- addr_size * 2, "Sym.Val.", "Type", "Ndx", "Name");
+ addr_size * 2, _("Address"), _("Access"),
+ addr_size * 2, _("Initial"),
+ addr_size * 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
sym_width = (is_32bit_elf ? 80 : 160) - 28 - addr_size * 6 - 1;
for (i = gotsym; i < symtabno; i++)
{
- Elf_Internal_Sym *psym;
+ Elf_Internal_Sym * psym;
psym = dynamic_symbols + i;
- entry = print_mips_got_entry (data, pltgot, entry);
+ ent = print_mips_got_entry (data, pltgot, ent);
printf (" ");
print_vma (psym->st_value, LONG_HEX);
printf (" %-7s %3s ",
if (VALID_DYNAMIC_NAME (psym->st_name))
print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
else
- printf ("<corrupt: %14ld>", psym->st_name);
+ printf (_("<corrupt: %14ld>"), psym->st_name);
printf ("\n");
}
printf ("\n");
free (data);
}
+ if (mips_pltgot != 0 && jmprel != 0 && pltrel != 0 && pltrelsz != 0)
+ {
+ bfd_vma ent, end;
+ size_t offset, rel_offset;
+ unsigned long count, i;
+ unsigned char * data;
+ int addr_size, sym_width;
+ Elf_Internal_Rela * rels;
+
+ rel_offset = offset_from_vma (file, jmprel, pltrelsz);
+ if (pltrel == DT_RELA)
+ {
+ if (!slurp_rela_relocs (file, rel_offset, pltrelsz, &rels, &count))
+ return 0;
+ }
+ else
+ {
+ if (!slurp_rel_relocs (file, rel_offset, pltrelsz, &rels, &count))
+ return 0;
+ }
+
+ ent = mips_pltgot;
+ addr_size = (is_32bit_elf ? 4 : 8);
+ end = mips_pltgot + (2 + count) * addr_size;
+
+ offset = offset_from_vma (file, mips_pltgot, end - mips_pltgot);
+ data = (unsigned char *) get_data (NULL, file, offset, end - mips_pltgot,
+ 1, _("PLT GOT"));
+ printf (_("\nPLT GOT:\n\n"));
+ printf (_(" Reserved entries:\n"));
+ printf (_(" %*s %*s Purpose\n"),
+ addr_size * 2, _("Address"), addr_size * 2, _("Initial"));
+ ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
+ printf (_(" PLT lazy resolver\n"));
+ ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
+ printf (_(" Module pointer\n"));
+ printf ("\n");
+
+ printf (_(" Entries:\n"));
+ printf (_(" %*s %*s %*s %-7s %3s %s\n"),
+ addr_size * 2, _("Address"),
+ addr_size * 2, _("Initial"),
+ addr_size * 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
+ sym_width = (is_32bit_elf ? 80 : 160) - 17 - addr_size * 6 - 1;
+ for (i = 0; i < count; i++)
+ {
+ Elf_Internal_Sym * psym;
+
+ psym = dynamic_symbols + get_reloc_symindex (rels[i].r_info);
+ ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
+ printf (" ");
+ print_vma (psym->st_value, LONG_HEX);
+ printf (" %-7s %3s ",
+ get_symbol_type (ELF_ST_TYPE (psym->st_info)),
+ get_symbol_index_type (psym->st_shndx));
+ if (VALID_DYNAMIC_NAME (psym->st_name))
+ print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
+ else
+ printf (_("<corrupt: %14ld>"), psym->st_name);
+ printf ("\n");
+ }
+ printf ("\n");
+
+ if (data)
+ free (data);
+ free (rels);
+ }
+
return 1;
}
static int
-process_gnu_liblist (FILE *file)
+process_gnu_liblist (FILE * file)
{
- Elf_Internal_Shdr *section, *string_sec;
- Elf32_External_Lib *elib;
- char *strtab;
+ Elf_Internal_Shdr * section;
+ Elf_Internal_Shdr * string_sec;
+ Elf32_External_Lib * elib;
+ char * strtab;
size_t strtab_size;
size_t cnt;
unsigned i;
if (section->sh_link >= elf_header.e_shnum)
break;
- elib = get_data (NULL, file, section->sh_offset, 1, section->sh_size,
- _("liblist"));
+ elib = (Elf32_External_Lib *)
+ get_data (NULL, file, section->sh_offset, 1, section->sh_size,
+ _("liblist"));
if (elib == NULL)
break;
string_sec = section_headers + section->sh_link;
- strtab = get_data (NULL, file, string_sec->sh_offset, 1,
- string_sec->sh_size, _("liblist string table"));
+ strtab = (char *) get_data (NULL, file, string_sec->sh_offset, 1,
+ string_sec->sh_size,
+ _("liblist string table"));
strtab_size = string_sec->sh_size;
if (strtab == NULL
printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
SECTION_NAME (section),
- (long) (section->sh_size / sizeof (Elf32_External_Lib)));
+ (unsigned long) (section->sh_size / sizeof (Elf32_External_Lib)));
- puts (" Library Time Stamp Checksum Version Flags");
+ puts (_(" Library Time Stamp Checksum Version Flags"));
for (cnt = 0; cnt < section->sh_size / sizeof (Elf32_External_Lib);
++cnt)
{
Elf32_Lib liblist;
- time_t time;
+ time_t atime;
char timebuf[20];
- struct tm *tmp;
+ struct tm * tmp;
liblist.l_name = BYTE_GET (elib[cnt].l_name);
- time = BYTE_GET (elib[cnt].l_time_stamp);
+ atime = BYTE_GET (elib[cnt].l_time_stamp);
liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
liblist.l_version = BYTE_GET (elib[cnt].l_version);
liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
- tmp = gmtime (&time);
+ tmp = gmtime (&atime);
snprintf (timebuf, sizeof (timebuf),
"%04u-%02u-%02uT%02u:%02u:%02u",
tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
printf ("%3lu: ", (unsigned long) cnt);
if (do_wide)
printf ("%-20s", liblist.l_name < strtab_size
- ? strtab + liblist.l_name : "<corrupt>");
+ ? strtab + liblist.l_name : _("<corrupt>"));
else
printf ("%-20.20s", liblist.l_name < strtab_size
- ? strtab + liblist.l_name : "<corrupt>");
+ ? strtab + liblist.l_name : _("<corrupt>"));
printf (" %s %#010lx %-7ld %-7ld\n", timebuf, liblist.l_checksum,
liblist.l_version, liblist.l_flags);
}
return _("NT_PRXFPREG (user_xfpregs structure)");
case NT_PPC_VMX:
return _("NT_PPC_VMX (ppc Altivec registers)");
+ case NT_PPC_VSX:
+ return _("NT_PPC_VSX (ppc VSX registers)");
+ case NT_X86_XSTATE:
+ return _("NT_X86_XSTATE (x86 XSAVE extended state)");
+ case NT_S390_HIGH_GPRS:
+ return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
+ case NT_S390_TIMER:
+ return _("NT_S390_TIMER (s390 timer register)");
+ case NT_S390_TODCMP:
+ return _("NT_S390_TODCMP (s390 TOD comparator register)");
+ case NT_S390_TODPREG:
+ return _("NT_S390_TODPREG (s390 TOD programmable register)");
+ case NT_S390_CTRS:
+ return _("NT_S390_CTRS (s390 control registers)");
+ case NT_S390_PREFIX:
+ return _("NT_S390_PREFIX (s390 prefix register)");
case NT_PSTATUS:
return _("NT_PSTATUS (pstatus structure)");
case NT_FPREGS:
case EM_SPARCV9:
switch (e_type)
{
- case NT_NETBSDCORE_FIRSTMACH+0:
+ case NT_NETBSDCORE_FIRSTMACH + 0:
return _("PT_GETREGS (reg structure)");
- case NT_NETBSDCORE_FIRSTMACH+2:
+ case NT_NETBSDCORE_FIRSTMACH + 2:
return _("PT_GETFPREGS (fpreg structure)");
default:
break;
default:
switch (e_type)
{
- case NT_NETBSDCORE_FIRSTMACH+1:
+ case NT_NETBSDCORE_FIRSTMACH + 1:
return _("PT_GETREGS (reg structure)");
- case NT_NETBSDCORE_FIRSTMACH+3:
+ case NT_NETBSDCORE_FIRSTMACH + 3:
return _("PT_GETFPREGS (fpreg structure)");
default:
break;
If the value of namesz is zero, there is no name present. */
static int
-process_note (Elf_Internal_Note *pnote)
+process_note (Elf_Internal_Note * pnote)
{
- const char *name = pnote->namesz ? pnote->namedata : "(NONE)";
- const char *nt;
+ const char * name = pnote->namesz ? pnote->namedata : "(NONE)";
+ const char * nt;
if (pnote->namesz == 0)
/* If there is no note name, then use the default set of
static int
-process_corefile_note_segment (FILE *file, bfd_vma offset, bfd_vma length)
+process_corefile_note_segment (FILE * file, bfd_vma offset, bfd_vma length)
{
- Elf_External_Note *pnotes;
- Elf_External_Note *external;
+ Elf_External_Note * pnotes;
+ Elf_External_Note * external;
int res = 1;
if (length <= 0)
return 0;
- pnotes = get_data (NULL, file, offset, 1, length, _("notes"));
+ pnotes = (Elf_External_Note *) get_data (NULL, file, offset, 1, length,
+ _("notes"));
if (!pnotes)
return 0;
(unsigned long) offset, (unsigned long) length);
printf (_(" Owner\t\tData size\tDescription\n"));
- while (external < (Elf_External_Note *)((char *) pnotes + length))
+ while (external < (Elf_External_Note *) ((char *) pnotes + length))
{
- Elf_External_Note *next;
+ Elf_External_Note * next;
Elf_Internal_Note inote;
- char *temp = NULL;
+ char * temp = NULL;
inote.type = BYTE_GET (external->type);
inote.namesz = BYTE_GET (external->namesz);
inote.descdata = inote.namedata + align_power (inote.namesz, 2);
inote.descpos = offset + (inote.descdata - (char *) pnotes);
- next = (Elf_External_Note *)(inote.descdata + align_power (inote.descsz, 2));
+ next = (Elf_External_Note *) (inote.descdata + align_power (inote.descsz, 2));
if (((char *) next) > (((char *) pnotes) + length))
{
warn (_("corrupt note found at offset %lx into core notes\n"),
- (long)((char *)external - (char *)pnotes));
+ (unsigned long) ((char *) external - (char *) pnotes));
warn (_(" type: %lx, namesize: %08lx, descsize: %08lx\n"),
inote.type, inote.namesz, inote.descsz);
break;
namesz. */
if (inote.namedata[inote.namesz] != '\0')
{
- temp = malloc (inote.namesz + 1);
+ temp = (char *) malloc (inote.namesz + 1);
if (temp == NULL)
{
}
static int
-process_corefile_note_segments (FILE *file)
+process_corefile_note_segments (FILE * file)
{
- Elf_Internal_Phdr *segment;
+ Elf_Internal_Phdr * segment;
unsigned int i;
int res = 1;
}
static int
-process_note_sections (FILE *file)
+process_note_sections (FILE * file)
{
- Elf_Internal_Shdr *section;
+ Elf_Internal_Shdr * section;
unsigned long i;
int res = 1;
}
static int
-process_notes (FILE *file)
+process_notes (FILE * file)
{
/* If we have not been asked to display the notes then do nothing. */
if (! do_notes)
}
static int
-process_arch_specific (FILE *file)
+process_arch_specific (FILE * file)
{
if (! do_arch)
return 1;
}
static int
-get_file_header (FILE *file)
+get_file_header (FILE * file)
{
/* Read in the identity array. */
if (fread (elf_header.e_ident, EI_NIDENT, 1, file) != 1)
positioned at the start of the ELF object. */
static int
-process_object (char *file_name, FILE *file)
+process_object (char * file_name, FILE * file)
{
unsigned int i;
do_unwind = do_version = do_dump = do_arch = 0;
if (! do_using_dynamic)
- do_syms = do_reloc = 0;
+ do_syms = do_dyn_syms = do_reloc = 0;
}
if (! process_section_groups (file))
if (section_groups)
{
- struct group_list *g, *next;
+ struct group_list * g;
+ struct group_list * next;
for (i = 0; i < group_count; i++)
{
return 0;
}
-/* Process an ELF archive.
- On entry the file is positioned just after the ARMAG string. */
+/* Return the path name for a proxy entry in a thin archive, adjusted relative
+ to the path name of the thin archive itself if necessary. Always returns
+ a pointer to malloc'ed memory. */
+
+static char *
+adjust_relative_path (char * file_name, char * name, int name_len)
+{
+ char * member_file_name;
+ const char * base_name = lbasename (file_name);
+
+ /* This is a proxy entry for a thin archive member.
+ If the extended name table contains an absolute path
+ name, or if the archive is in the current directory,
+ use the path name as given. Otherwise, we need to
+ find the member relative to the directory where the
+ archive is located. */
+ if (IS_ABSOLUTE_PATH (name) || base_name == file_name)
+ {
+ member_file_name = (char *) malloc (name_len + 1);
+ if (member_file_name == NULL)
+ {
+ error (_("Out of memory\n"));
+ return NULL;
+ }
+ memcpy (member_file_name, name, name_len);
+ member_file_name[name_len] = '\0';
+ }
+ else
+ {
+ /* Concatenate the path components of the archive file name
+ to the relative path name from the extended name table. */
+ size_t prefix_len = base_name - file_name;
+ member_file_name = (char *) malloc (prefix_len + name_len + 1);
+ if (member_file_name == NULL)
+ {
+ error (_("Out of memory\n"));
+ return NULL;
+ }
+ memcpy (member_file_name, file_name, prefix_len);
+ memcpy (member_file_name + prefix_len, name, name_len);
+ member_file_name[prefix_len + name_len] = '\0';
+ }
+ return member_file_name;
+}
+
+/* Structure to hold information about an archive file. */
+
+struct archive_info
+{
+ char * file_name; /* Archive file name. */
+ FILE * file; /* Open file descriptor. */
+ unsigned long index_num; /* Number of symbols in table. */
+ unsigned long * index_array; /* The array of member offsets. */
+ char * sym_table; /* The symbol table. */
+ unsigned long sym_size; /* Size of the symbol table. */
+ char * longnames; /* The long file names table. */
+ unsigned long longnames_size; /* Size of the long file names table. */
+ unsigned long nested_member_origin; /* Origin in the nested archive of the current member. */
+ unsigned long next_arhdr_offset; /* Offset of the next archive header. */
+ bfd_boolean is_thin_archive; /* TRUE if this is a thin archive. */
+ struct ar_hdr arhdr; /* Current archive header. */
+};
+
+/* Read the symbol table and long-name table from an archive. */
static int
-process_archive (char *file_name, FILE *file)
+setup_archive (struct archive_info * arch, char * file_name, FILE * file,
+ bfd_boolean is_thin_archive, bfd_boolean read_symbols)
{
- struct ar_hdr arhdr;
size_t got;
unsigned long size;
- unsigned long index_num = 0;
- unsigned long *index_array = NULL;
- char *sym_table = NULL;
- unsigned long sym_size = 0;
- char *longnames = NULL;
- unsigned long longnames_size = 0;
- size_t file_name_size;
- int ret;
-
- show_name = 1;
- got = fread (&arhdr, 1, sizeof arhdr, file);
- if (got != sizeof arhdr)
+ arch->file_name = strdup (file_name);
+ arch->file = file;
+ arch->index_num = 0;
+ arch->index_array = NULL;
+ arch->sym_table = NULL;
+ arch->sym_size = 0;
+ arch->longnames = NULL;
+ arch->longnames_size = 0;
+ arch->nested_member_origin = 0;
+ arch->is_thin_archive = is_thin_archive;
+ arch->next_arhdr_offset = SARMAG;
+
+ /* Read the first archive member header. */
+ if (fseek (file, SARMAG, SEEK_SET) != 0)
+ {
+ error (_("%s: failed to seek to first archive header\n"), file_name);
+ return 1;
+ }
+ got = fread (&arch->arhdr, 1, sizeof arch->arhdr, file);
+ if (got != sizeof arch->arhdr)
{
if (got == 0)
return 0;
}
/* See if this is the archive symbol table. */
- if (const_strneq (arhdr.ar_name, "/ ")
- || const_strneq (arhdr.ar_name, "/SYM64/ "))
+ if (const_strneq (arch->arhdr.ar_name, "/ ")
+ || const_strneq (arch->arhdr.ar_name, "/SYM64/ "))
{
- size = strtoul (arhdr.ar_size, NULL, 10);
+ size = strtoul (arch->arhdr.ar_size, NULL, 10);
size = size + (size & 1);
- if (do_archive_index)
+ arch->next_arhdr_offset += sizeof arch->arhdr + size;
+
+ if (read_symbols)
{
unsigned long i;
/* A buffer used to hold numbers read in from an archive index.
error (_("%s: failed to read archive index\n"), file_name);
return 1;
}
- index_num = byte_get_big_endian (integer_buffer, sizeof integer_buffer);
+ arch->index_num = byte_get_big_endian (integer_buffer, sizeof integer_buffer);
size -= SIZEOF_AR_INDEX_NUMBERS;
/* Read in the archive index. */
- if (size < index_num * SIZEOF_AR_INDEX_NUMBERS)
+ if (size < arch->index_num * SIZEOF_AR_INDEX_NUMBERS)
{
error (_("%s: the archive index is supposed to have %ld entries, but the size in the header is too small\n"),
- file_name, index_num);
+ file_name, arch->index_num);
return 1;
}
- index_buffer = malloc (index_num * SIZEOF_AR_INDEX_NUMBERS);
+ index_buffer = (unsigned char *)
+ malloc (arch->index_num * SIZEOF_AR_INDEX_NUMBERS);
if (index_buffer == NULL)
{
error (_("Out of memory whilst trying to read archive symbol index\n"));
return 1;
}
- got = fread (index_buffer, SIZEOF_AR_INDEX_NUMBERS, index_num, file);
- if (got != index_num)
+ got = fread (index_buffer, SIZEOF_AR_INDEX_NUMBERS, arch->index_num, file);
+ if (got != arch->index_num)
{
free (index_buffer);
error (_("%s: failed to read archive index\n"), file_name);
- ret = 1;
- goto out;
+ return 1;
}
- size -= index_num * SIZEOF_AR_INDEX_NUMBERS;
+ size -= arch->index_num * SIZEOF_AR_INDEX_NUMBERS;
/* Convert the index numbers into the host's numeric format. */
- index_array = malloc (index_num * sizeof (* index_array));
- if (index_array == NULL)
+ arch->index_array = (long unsigned int *)
+ malloc (arch->index_num * sizeof (* arch->index_array));
+ if (arch->index_array == NULL)
{
free (index_buffer);
error (_("Out of memory whilst trying to convert the archive symbol index\n"));
return 1;
}
- for (i = 0; i < index_num; i++)
- index_array[i] = byte_get_big_endian ((unsigned char *)(index_buffer + (i * SIZEOF_AR_INDEX_NUMBERS)),
- SIZEOF_AR_INDEX_NUMBERS);
+ for (i = 0; i < arch->index_num; i++)
+ arch->index_array[i] = byte_get_big_endian ((unsigned char *) (index_buffer + (i * SIZEOF_AR_INDEX_NUMBERS)),
+ SIZEOF_AR_INDEX_NUMBERS);
free (index_buffer);
/* The remaining space in the header is taken up by the symbol table. */
if (size < 1)
{
error (_("%s: the archive has an index but no symbols\n"), file_name);
- ret = 1;
- goto out;
+ return 1;
}
- sym_table = malloc (size);
- sym_size = size;
- if (sym_table == NULL)
+ arch->sym_table = (char *) malloc (size);
+ arch->sym_size = size;
+ if (arch->sym_table == NULL)
{
error (_("Out of memory whilst trying to read archive index symbol table\n"));
- ret = 1;
- goto out;
+ return 1;
}
- got = fread (sym_table, 1, size, file);
+ got = fread (arch->sym_table, 1, size, file);
if (got != size)
{
error (_("%s: failed to read archive index symbol table\n"), file_name);
- ret = 1;
- goto out;
- }
+ return 1;
+ }
}
else
{
}
}
- got = fread (& arhdr, 1, sizeof arhdr, file);
- if (got != sizeof arhdr)
+ /* Read the next archive header. */
+ got = fread (&arch->arhdr, 1, sizeof arch->arhdr, file);
+ if (got != sizeof arch->arhdr)
{
if (got == 0)
- {
- ret = 0;
- goto out;
- }
-
+ return 0;
error (_("%s: failed to read archive header following archive index\n"), file_name);
- ret = 1;
- goto out;
+ return 1;
}
}
- else if (do_archive_index)
+ else if (read_symbols)
printf (_("%s has no archive index\n"), file_name);
- if (const_strneq (arhdr.ar_name, "// "))
+ if (const_strneq (arch->arhdr.ar_name, "// "))
{
- /* This is the archive string table holding long member
- names. */
+ /* This is the archive string table holding long member names. */
+ arch->longnames_size = strtoul (arch->arhdr.ar_size, NULL, 10);
+ arch->next_arhdr_offset += sizeof arch->arhdr + arch->longnames_size;
- longnames_size = strtoul (arhdr.ar_size, NULL, 10);
- longnames = malloc (longnames_size);
- if (longnames == NULL)
+ arch->longnames = (char *) malloc (arch->longnames_size);
+ if (arch->longnames == NULL)
{
error (_("Out of memory reading long symbol names in archive\n"));
- ret = 1;
- goto out;
+ return 1;
}
- if (fread (longnames, longnames_size, 1, file) != 1)
+ if (fread (arch->longnames, arch->longnames_size, 1, file) != 1)
{
- free (longnames);
+ free (arch->longnames);
+ arch->longnames = NULL;
error (_("%s: failed to read long symbol name string table\n"), file_name);
- ret = 1;
- goto out;
+ return 1;
}
- if ((longnames_size & 1) != 0)
+ if ((arch->longnames_size & 1) != 0)
getc (file);
+ }
- got = fread (& arhdr, 1, sizeof arhdr, file);
- if (got != sizeof arhdr)
- {
- if (got == 0)
- ret = 0;
- else
- {
- error (_("%s: failed to read archive header following long symbol names\n"), file_name);
- ret = 1;
- }
- goto out;
- }
+ return 0;
+}
+
+/* Release the memory used for the archive information. */
+
+static void
+release_archive (struct archive_info * arch)
+{
+ if (arch->file_name != NULL)
+ free (arch->file_name);
+ if (arch->index_array != NULL)
+ free (arch->index_array);
+ if (arch->sym_table != NULL)
+ free (arch->sym_table);
+ if (arch->longnames != NULL)
+ free (arch->longnames);
+}
+
+/* Open and setup a nested archive, if not already open. */
+
+static int
+setup_nested_archive (struct archive_info * nested_arch, char * member_file_name)
+{
+ FILE * member_file;
+
+ /* Have we already setup this archive? */
+ if (nested_arch->file_name != NULL
+ && streq (nested_arch->file_name, member_file_name))
+ return 0;
+
+ /* Close previous file and discard cached information. */
+ if (nested_arch->file != NULL)
+ fclose (nested_arch->file);
+ release_archive (nested_arch);
+
+ member_file = fopen (member_file_name, "rb");
+ if (member_file == NULL)
+ return 1;
+ return setup_archive (nested_arch, member_file_name, member_file, FALSE, FALSE);
+}
+
+static char *
+get_archive_member_name_at (struct archive_info * arch,
+ unsigned long offset,
+ struct archive_info * nested_arch);
+
+/* Get the name of an archive member from the current archive header.
+ For simple names, this will modify the ar_name field of the current
+ archive header. For long names, it will return a pointer to the
+ longnames table. For nested archives, it will open the nested archive
+ and get the name recursively. NESTED_ARCH is a single-entry cache so
+ we don't keep rereading the same information from a nested archive. */
+
+static char *
+get_archive_member_name (struct archive_info * arch,
+ struct archive_info * nested_arch)
+{
+ unsigned long j, k;
+
+ if (arch->arhdr.ar_name[0] == '/')
+ {
+ /* We have a long name. */
+ char * endp;
+ char * member_file_name;
+ char * member_name;
+
+ arch->nested_member_origin = 0;
+ k = j = strtoul (arch->arhdr.ar_name + 1, &endp, 10);
+ if (arch->is_thin_archive && endp != NULL && * endp == ':')
+ arch->nested_member_origin = strtoul (endp + 1, NULL, 10);
+
+ while ((j < arch->longnames_size)
+ && (arch->longnames[j] != '\n')
+ && (arch->longnames[j] != '\0'))
+ j++;
+ if (arch->longnames[j-1] == '/')
+ j--;
+ arch->longnames[j] = '\0';
+
+ if (!arch->is_thin_archive || arch->nested_member_origin == 0)
+ return arch->longnames + k;
+
+ /* This is a proxy for a member of a nested archive.
+ Find the name of the member in that archive. */
+ member_file_name = adjust_relative_path (arch->file_name, arch->longnames + k, j - k);
+ if (member_file_name != NULL
+ && setup_nested_archive (nested_arch, member_file_name) == 0
+ && (member_name = get_archive_member_name_at (nested_arch, arch->nested_member_origin, NULL)) != NULL)
+ {
+ free (member_file_name);
+ return member_name;
+ }
+ free (member_file_name);
+
+ /* Last resort: just return the name of the nested archive. */
+ return arch->longnames + k;
+ }
+
+ /* We have a normal (short) name. */
+ j = 0;
+ while ((arch->arhdr.ar_name[j] != '/') && (j < 16))
+ j++;
+ arch->arhdr.ar_name[j] = '\0';
+ return arch->arhdr.ar_name;
+}
+
+/* Get the name of an archive member at a given OFFSET within an archive ARCH. */
+
+static char *
+get_archive_member_name_at (struct archive_info * arch,
+ unsigned long offset,
+ struct archive_info * nested_arch)
+{
+ size_t got;
+
+ if (fseek (arch->file, offset, SEEK_SET) != 0)
+ {
+ error (_("%s: failed to seek to next file name\n"), arch->file_name);
+ return NULL;
+ }
+ got = fread (&arch->arhdr, 1, sizeof arch->arhdr, arch->file);
+ if (got != sizeof arch->arhdr)
+ {
+ error (_("%s: failed to read archive header\n"), arch->file_name);
+ return NULL;
+ }
+ if (memcmp (arch->arhdr.ar_fmag, ARFMAG, 2) != 0)
+ {
+ error (_("%s: did not find a valid archive header\n"), arch->file_name);
+ return NULL;
+ }
+
+ return get_archive_member_name (arch, nested_arch);
+}
+
+/* Construct a string showing the name of the archive member, qualified
+ with the name of the containing archive file. For thin archives, we
+ use square brackets to denote the indirection. For nested archives,
+ we show the qualified name of the external member inside the square
+ brackets (e.g., "thin.a[normal.a(foo.o)]"). */
+
+static char *
+make_qualified_name (struct archive_info * arch,
+ struct archive_info * nested_arch,
+ char * member_name)
+{
+ size_t len;
+ char * name;
+
+ len = strlen (arch->file_name) + strlen (member_name) + 3;
+ if (arch->is_thin_archive && arch->nested_member_origin != 0)
+ len += strlen (nested_arch->file_name) + 2;
+
+ name = (char *) malloc (len);
+ if (name == NULL)
+ {
+ error (_("Out of memory\n"));
+ return NULL;
+ }
+
+ if (arch->is_thin_archive && arch->nested_member_origin != 0)
+ snprintf (name, len, "%s[%s(%s)]", arch->file_name, nested_arch->file_name, member_name);
+ else if (arch->is_thin_archive)
+ snprintf (name, len, "%s[%s]", arch->file_name, member_name);
+ else
+ snprintf (name, len, "%s(%s)", arch->file_name, member_name);
+
+ return name;
+}
+
+/* Process an ELF archive.
+ On entry the file is positioned just after the ARMAG string. */
+
+static int
+process_archive (char * file_name, FILE * file, bfd_boolean is_thin_archive)
+{
+ struct archive_info arch;
+ struct archive_info nested_arch;
+ size_t got;
+ int ret;
+
+ show_name = 1;
+
+ /* The ARCH structure is used to hold information about this archive. */
+ arch.file_name = NULL;
+ arch.file = NULL;
+ arch.index_array = NULL;
+ arch.sym_table = NULL;
+ arch.longnames = NULL;
+
+ /* The NESTED_ARCH structure is used as a single-item cache of information
+ about a nested archive (when members of a thin archive reside within
+ another regular archive file). */
+ nested_arch.file_name = NULL;
+ nested_arch.file = NULL;
+ nested_arch.index_array = NULL;
+ nested_arch.sym_table = NULL;
+ nested_arch.longnames = NULL;
+
+ if (setup_archive (&arch, file_name, file, is_thin_archive, do_archive_index) != 0)
+ {
+ ret = 1;
+ goto out;
}
if (do_archive_index)
{
- if (sym_table == NULL)
+ if (arch.sym_table == NULL)
error (_("%s: unable to dump the index as none was found\n"), file_name);
else
{
- unsigned int i, j, k, l;
- char elf_name[16];
+ unsigned int i, l;
unsigned long current_pos;
printf (_("Index of archive %s: (%ld entries, 0x%lx bytes in the symbol table)\n"),
- file_name, index_num, sym_size);
+ file_name, arch.index_num, arch.sym_size);
current_pos = ftell (file);
- for (i = l = 0; i < index_num; i++)
+ for (i = l = 0; i < arch.index_num; i++)
{
- if ((i == 0) || ((i > 0) && (index_array[i] != index_array[i - 1])))
- {
- if (fseek (file, index_array[i], SEEK_SET) != 0)
- {
- error (_("%s: failed to seek to next file name\n"), file_name);
- ret = 1;
- goto out;
- }
- got = fread (elf_name, 1, 16, file);
- if (got != 16)
- {
- error (_("%s: failed to read file name\n"), file_name);
- ret = 1;
- goto out;
- }
+ if ((i == 0) || ((i > 0) && (arch.index_array[i] != arch.index_array[i - 1])))
+ {
+ char * member_name;
- if (elf_name[0] == '/')
- {
- /* We have a long name. */
- k = j = strtoul (elf_name + 1, NULL, 10);
- while ((j < longnames_size) && (longnames[j] != '/'))
- j++;
- longnames[j] = '\0';
- printf (_("Binary %s contains:\n"), longnames + k);
- longnames[j] = '/';
- }
- else
- {
- j = 0;
- while ((elf_name[j] != '/') && (j < 16))
- j++;
- elf_name[j] = '\0';
- printf(_("Binary %s contains:\n"), elf_name);
+ member_name = get_archive_member_name_at (&arch, arch.index_array[i], &nested_arch);
+
+ if (member_name != NULL)
+ {
+ char * qualified_name = make_qualified_name (&arch, &nested_arch, member_name);
+
+ if (qualified_name != NULL)
+ {
+ printf (_("Binary %s contains:\n"), qualified_name);
+ free (qualified_name);
+ }
}
}
- if (l >= sym_size)
+
+ if (l >= arch.sym_size)
{
error (_("%s: end of the symbol table reached before the end of the index\n"),
file_name);
- break;
+ break;
}
- printf ("\t%s\n", sym_table + l);
- l += strlen (sym_table + l) + 1;
+ printf ("\t%s\n", arch.sym_table + l);
+ l += strlen (arch.sym_table + l) + 1;
}
- if (l < sym_size)
+ if (l & 01)
+ ++l;
+ if (l < arch.sym_size)
error (_("%s: symbols remain in the index symbol table, but without corresponding entries in the index table\n"),
file_name);
- free (index_array);
- index_array = NULL;
- free (sym_table);
- sym_table = NULL;
if (fseek (file, current_pos, SEEK_SET) != 0)
{
error (_("%s: failed to seek back to start of object files in the archive\n"), file_name);
- return 1;
+ ret = 1;
+ goto out;
}
}
if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
&& !do_segments && !do_header && !do_dump && !do_version
&& !do_histogram && !do_debugging && !do_arch && !do_notes
- && !do_section_groups)
- return 0; /* Archive index only. */
+ && !do_section_groups && !do_dyn_syms)
+ {
+ ret = 0; /* Archive index only. */
+ goto out;
+ }
}
- file_name_size = strlen (file_name);
ret = 0;
while (1)
{
- char *name;
- char *nameend;
- char *namealc;
-
- if (arhdr.ar_name[0] == '/')
- {
- unsigned long off;
-
- off = strtoul (arhdr.ar_name + 1, NULL, 10);
- if (off >= longnames_size)
- {
- error (_("%s: invalid archive string table offset %lu\n"), file_name, off);
- ret = 1;
- break;
- }
-
- name = longnames + off;
- nameend = memchr (name, '/', longnames_size - off);
- }
- else
- {
- name = arhdr.ar_name;
- nameend = memchr (name, '/', 16);
- }
-
- if (nameend == NULL)
+ char * name;
+ size_t namelen;
+ char * qualified_name;
+
+ /* Read the next archive header. */
+ if (fseek (file, arch.next_arhdr_offset, SEEK_SET) != 0)
+ {
+ error (_("%s: failed to seek to next archive header\n"), file_name);
+ return 1;
+ }
+ got = fread (&arch.arhdr, 1, sizeof arch.arhdr, file);
+ if (got != sizeof arch.arhdr)
+ {
+ if (got == 0)
+ break;
+ error (_("%s: failed to read archive header\n"), file_name);
+ ret = 1;
+ break;
+ }
+ if (memcmp (arch.arhdr.ar_fmag, ARFMAG, 2) != 0)
+ {
+ error (_("%s: did not find a valid archive header\n"), arch.file_name);
+ ret = 1;
+ break;
+ }
+
+ arch.next_arhdr_offset += sizeof arch.arhdr;
+
+ archive_file_size = strtoul (arch.arhdr.ar_size, NULL, 10);
+ if (archive_file_size & 01)
+ ++archive_file_size;
+
+ name = get_archive_member_name (&arch, &nested_arch);
+ if (name == NULL)
{
error (_("%s: bad archive file name\n"), file_name);
ret = 1;
break;
}
+ namelen = strlen (name);
- namealc = malloc (file_name_size + (nameend - name) + 3);
- if (namealc == NULL)
+ qualified_name = make_qualified_name (&arch, &nested_arch, name);
+ if (qualified_name == NULL)
{
- error (_("Out of memory\n"));
+ error (_("%s: bad archive file name\n"), file_name);
ret = 1;
break;
}
- memcpy (namealc, file_name, file_name_size);
- namealc[file_name_size] = '(';
- memcpy (namealc + file_name_size + 1, name, nameend - name);
- namealc[file_name_size + 1 + (nameend - name)] = ')';
- namealc[file_name_size + 2 + (nameend - name)] = '\0';
-
- archive_file_offset = ftell (file);
- archive_file_size = strtoul (arhdr.ar_size, NULL, 10);
-
- ret |= process_object (namealc, file);
-
- free (namealc);
-
- if (fseek (file,
- (archive_file_offset
- + archive_file_size
- + (archive_file_size & 1)),
- SEEK_SET) != 0)
- {
- error (_("%s: failed to seek to next archive header\n"), file_name);
- ret = 1;
- break;
- }
+ if (is_thin_archive && arch.nested_member_origin == 0)
+ {
+ /* This is a proxy for an external member of a thin archive. */
+ FILE * member_file;
+ char * member_file_name = adjust_relative_path (file_name, name, namelen);
+ if (member_file_name == NULL)
+ {
+ ret = 1;
+ break;
+ }
+
+ member_file = fopen (member_file_name, "rb");
+ if (member_file == NULL)
+ {
+ error (_("Input file '%s' is not readable.\n"), member_file_name);
+ free (member_file_name);
+ ret = 1;
+ break;
+ }
+
+ archive_file_offset = arch.nested_member_origin;
+
+ ret |= process_object (qualified_name, member_file);
+
+ fclose (member_file);
+ free (member_file_name);
+ }
+ else if (is_thin_archive)
+ {
+ /* This is a proxy for a member of a nested archive. */
+ archive_file_offset = arch.nested_member_origin + sizeof arch.arhdr;
+
+ /* The nested archive file will have been opened and setup by
+ get_archive_member_name. */
+ if (fseek (nested_arch.file, archive_file_offset, SEEK_SET) != 0)
+ {
+ error (_("%s: failed to seek to archive member.\n"), nested_arch.file_name);
+ ret = 1;
+ break;
+ }
+
+ ret |= process_object (qualified_name, nested_arch.file);
+ }
+ else
+ {
+ archive_file_offset = arch.next_arhdr_offset;
+ arch.next_arhdr_offset += archive_file_size;
- got = fread (&arhdr, 1, sizeof arhdr, file);
- if (got != sizeof arhdr)
- {
- if (got == 0)
- break;
+ ret |= process_object (qualified_name, file);
+ }
- error (_("%s: failed to read archive header\n"), file_name);
- ret = 1;
- break;
- }
+ free (qualified_name);
}
out:
- if (index_array != NULL)
- free (index_array);
- if (sym_table != NULL)
- free (sym_table);
- if (longnames != NULL)
- free (longnames);
+ if (nested_arch.file != NULL)
+ fclose (nested_arch.file);
+ release_archive (&nested_arch);
+ release_archive (&arch);
return ret;
}
static int
-process_file (char *file_name)
+process_file (char * file_name)
{
- FILE *file;
+ FILE * file;
struct stat statbuf;
char armag[SARMAG];
int ret;
}
if (memcmp (armag, ARMAG, SARMAG) == 0)
- ret = process_archive (file_name, file);
+ ret = process_archive (file_name, file, FALSE);
+ else if (memcmp (armag, ARMAGT, SARMAG) == 0)
+ ret = process_archive (file_name, file, TRUE);
else
{
if (do_archive_index)
symbols. */
void
-print_address (unsigned int addr, FILE *outfile)
+print_address (unsigned int addr, FILE * outfile)
{
fprintf (outfile,"0x%8.8x", addr);
}
#endif
int
-main (int argc, char **argv)
+main (int argc, char ** argv)
{
int err;
if (num_dump_sects > 0)
{
/* Make a copy of the dump_sects array. */
- cmdline_dump_sects = malloc (num_dump_sects * sizeof (* dump_sects));
+ cmdline_dump_sects = (dump_type *)
+ malloc (num_dump_sects * sizeof (* dump_sects));
if (cmdline_dump_sects == NULL)
error (_("Out of memory allocating dump request table.\n"));
else