This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2 of the License, or
+ the Free Software Foundation; either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
#include "elf/arm.h"
#include "elf/avr.h"
#include "elf/bfin.h"
+#include "elf/cr16.h"
#include "elf/cris.h"
#include "elf/crx.h"
#include "elf/d10v.h"
#include "getopt.h"
#include "libiberty.h"
+#include "safe-ctype.h"
char *program_name = "readelf";
static long archive_file_offset;
static int do_debugging;
static int do_arch;
static int do_notes;
+static int do_archive_index;
static int is_32bit_elf;
struct group_list
static struct group *section_groups;
static struct group **section_headers_groups;
-/* A linked list of the section names for which dumps were requested
- by name. */
+
+/* Flag bits indicating particular types of dump. */
+#define HEX_DUMP (1 << 0) /* The -x command line switch. */
+#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. */
+
+typedef unsigned char dump_type;
+
+/* A linked list of the section names for which dumps were requested. */
struct dump_list_entry
{
char *name;
- int type;
+ dump_type type;
struct dump_list_entry *next;
};
static struct dump_list_entry *dump_sects_byname;
-/* A dynamic array of flags indicating for which sections a hex dump
- has been requested (via the -x switch) and/or a disassembly dump
- (via the -i switch). */
-char *cmdline_dump_sects = NULL;
-unsigned num_cmdline_dump_sects = 0;
+/* A dynamic array of flags indicating for which sections a dump
+ has been requested via command line switches. */
+static dump_type * cmdline_dump_sects = NULL;
+static unsigned int num_cmdline_dump_sects = 0;
/* A dynamic array of flags indicating for which sections a dump of
some kind has been requested. It is reset on a per-object file
basis and then initialised from the cmdline_dump_sects array,
the results of interpreting the -w switch, and the
dump_sects_byname list. */
-char *dump_sects = NULL;
-unsigned int num_dump_sects = 0;
+static dump_type * dump_sects = NULL;
+static unsigned int num_dump_sects = 0;
-#define HEX_DUMP (1 << 0)
-#define DISASS_DUMP (1 << 1)
-#define DEBUG_DUMP (1 << 2)
/* How to print a vma value. */
typedef enum print_mode
#define BYTE_GET(field) byte_get (field, sizeof (field))
-#define NUM_ELEM(array) (sizeof (array) / sizeof ((array)[0]))
-
#define GET_ELF_SYMBOLS(file, section) \
(is_32bit_elf ? get_32bit_elf_symbols (file, section) \
: get_64bit_elf_symbols (file, section))
#define GET_DYNAMIC_NAME(offset) (dynamic_strings + offset)
/* This is just a bit of syntatic sugar. */
-#define streq(a,b) (strcmp ((a), (b)) == 0)
-#define strneq(a,b,n) (strncmp ((a), (b), (n)) == 0)
+#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)
\f
static void *
}
}
-#if defined BFD64 && !BFD_HOST_64BIT_LONG
+#if defined BFD64 && !BFD_HOST_64BIT_LONG && !BFD_HOST_64BIT_LONG_LONG
static int
print_dec_vma (bfd_vma vma, int is_signed)
{
case HEX:
#if BFD_HOST_64BIT_LONG
return nc + printf ("%lx", vma);
+#elif BFD_HOST_64BIT_LONG_LONG
+ return nc + printf ("%llx", vma);
#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
+ return printf ("%lld", vma);
#else
return print_dec_vma (vma, 1);
#endif
return printf ("%5ld", vma);
else
return printf ("%#lx", vma);
+#elif BFD_HOST_64BIT_LONG_LONG
+ if (vma <= 99999)
+ return printf ("%5lld", vma);
+ else
+ return printf ("%#llx", vma);
#else
if (vma <= 99999)
return printf ("%5ld", _bfd_int64_low (vma));
case UNSIGNED:
#if BFD_HOST_64BIT_LONG
return printf ("%lu", vma);
+#elif BFD_HOST_64BIT_LONG_LONG
+ return printf ("%llu", vma);
#else
return print_dec_vma (vma, 0);
#endif
case EM_AVR:
case EM_AVR_OLD:
case EM_BLACKFIN:
+ case EM_CR16:
case EM_CRIS:
case EM_CRX:
case EM_D30V:
if (is_32bit_elf)
{
-#ifdef _bfd_int64_low
- printf ("%8.8lx %8.8lx ", _bfd_int64_low (offset), _bfd_int64_low (info));
-#else
- printf ("%8.8lx %8.8lx ", offset, info);
-#endif
+ printf ("%8.8lx %8.8lx ",
+ (unsigned long) offset & 0xffffffff,
+ (unsigned long) info & 0xffffffff);
}
else
{
-#ifdef _bfd_int64_low
+#if BFD_HOST_64BIT_LONG
+ printf (do_wide
+ ? "%16.16lx %16.16lx "
+ : "%12.12lx %12.12lx ",
+ offset, info);
+#elif BFD_HOST_64BIT_LONG_LONG
+ printf (do_wide
+ ? "%16.16llx %16.16llx "
+ : "%12.12llx %12.12llx ",
+ offset, info);
+#else
printf (do_wide
? "%8.8lx%8.8lx %8.8lx%8.8lx "
: "%4.4lx%8.8lx %4.4lx%8.8lx ",
_bfd_int64_low (offset),
_bfd_int64_high (info),
_bfd_int64_low (info));
-#else
- printf (do_wide
- ? "%16.16lx %16.16lx "
- : "%12.12lx %12.12lx ",
- offset, info);
#endif
}
case EM_CYGNUS_MEP:
rtype = elf_mep_reloc_type (type);
break;
+
+ case EM_CR16:
+ rtype = elf_cr16_reloc_type (type);
+ break;
}
if (rtype == NULL)
-#ifdef _bfd_int64_low
- printf (_("unrecognized: %-7lx"), _bfd_int64_low (type));
-#else
- printf (_("unrecognized: %-7lx"), type);
-#endif
+ printf (_("unrecognized: %-7lx"), (unsigned long) type & 0xffffffff);
else
printf (do_wide ? "%-22.22s" : "%-17.17s", rtype);
printf (" Type2: ");
if (rtype2 == NULL)
-#ifdef _bfd_int64_low
- printf (_("unrecognized: %-7lx"), _bfd_int64_low (type2));
-#else
- printf (_("unrecognized: %-7lx"), type2);
-#endif
+ printf (_("unrecognized: %-7lx"),
+ (unsigned long) type2 & 0xffffffff);
else
printf ("%-17.17s", rtype2);
printf ("\n Type3: ");
if (rtype3 == NULL)
-#ifdef _bfd_int64_low
- printf (_("unrecognized: %-7lx"), _bfd_int64_low (type3));
-#else
- printf (_("unrecognized: %-7lx"), type3);
-#endif
+ printf (_("unrecognized: %-7lx"),
+ (unsigned long) type3 & 0xffffffff);
else
printf ("%-17.17s", rtype3);
case EM_ALTERA_NIOS2: return "Altera Nios II";
case EM_XC16X: return "Infineon Technologies xc16x";
case EM_CYGNUS_MEP: return "Toshiba MeP Media Engine";
+ case EM_CR16: return "National Semiconductor's CR16";
default:
snprintf (buff, sizeof (buff), _("<unknown>: 0x%x"), e_machine);
return buff;
{"arch-specific", no_argument, 0, 'A'},
{"version-info", no_argument, 0, 'V'},
{"use-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},
- {"unwind", no_argument, 0, 'u'},
+ {"string-dump", required_argument, 0, 'p'},
#ifdef SUPPORT_DISASSEMBLY
{"instruction-dump", required_argument, 0, 'i'},
#endif
-d --dynamic Display the dynamic section (if present)\n\
-V --version-info Display the version sections (if present)\n\
-A --arch-specific Display architecture specific information (if any).\n\
+ -c --archive-index Display the symbol/file index in an archive\n\
-D --use-dynamic Use the dynamic section info when displaying symbols\n\
- -x --hex-dump=<number> Dump the contents of section <number>\n\
+ -x --hex-dump=<number|name>\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[liaprmfFsoR] or\n\
--debug-dump[=line,=info,=abbrev,=pubnames,=aranges,=macro,=frames,=str,=loc,=Ranges]\n\
Display the contents of DWARF2 debug sections\n"));
#ifdef SUPPORT_DISASSEMBLY
fprintf (stream, _("\
- -i --instruction-dump=<number>\n\
- Disassemble the contents of section <number>\n"));
+ -i --instruction-dump=<number|name>\n\
+ Disassemble the contents of section <number|name>\n"));
#endif
fprintf (stream, _("\
-I --histogram Display histogram of bucket list lengths\n\
@<file> Read options from <file>\n\
-H --help Display this information\n\
-v --version Display the version number of readelf\n"));
-
+
if (REPORT_BUGS_TO[0] && stream == stdout)
fprintf (stdout, _("Report bugs to %s\n"), REPORT_BUGS_TO);
the first time. */
static void
-request_dump (unsigned int section, int type)
+request_dump_bynumber (unsigned int section, dump_type type)
{
if (section >= num_dump_sects)
{
- char *new_dump_sects;
+ dump_type *new_dump_sects;
- new_dump_sects = calloc (section + 1, 1);
+ new_dump_sects = calloc (section + 1, sizeof (* dump_sects));
if (new_dump_sects == NULL)
error (_("Out of memory allocating dump request table.\n"));
else
{
/* Copy current flag settings. */
- memcpy (new_dump_sects, dump_sects, num_dump_sects);
+ memcpy (new_dump_sects, dump_sects, num_dump_sects * sizeof (* dump_sects));
free (dump_sects);
/* Request a dump by section name. */
static void
-request_dump_byname (const char *section, int type)
+request_dump_byname (const char *section, dump_type type)
{
struct dump_list_entry *new_request;
usage (stderr);
while ((c = getopt_long
- (argc, argv, "ersuahnldSDAINtgw::x:i:vVWH", options, NULL)) != EOF)
+ (argc, argv, "ADHINSVWacdeghi:lnp:rstuvw::x:", options, NULL)) != EOF)
{
char *cp;
int section;
case 'n':
do_notes++;
break;
+ case 'c':
+ do_archive_index++;
+ break;
case 'x':
do_dump++;
section = strtoul (optarg, & cp, 0);
if (! *cp && section >= 0)
- request_dump (section, HEX_DUMP);
+ request_dump_bynumber (section, HEX_DUMP);
else
request_dump_byname (optarg, HEX_DUMP);
break;
+ case 'p':
+ do_dump++;
+ section = strtoul (optarg, & cp, 0);
+ if (! *cp && section >= 0)
+ request_dump_bynumber (section, STRING_DUMP);
+ else
+ request_dump_byname (optarg, STRING_DUMP);
+ break;
case 'w':
do_dump++;
if (optarg == 0)
do_dump++;
section = strtoul (optarg, & cp, 0);
if (! *cp && section >= 0)
- {
- request_dump (section, DISASS_DUMP);
- break;
- }
- goto oops;
+ request_dump_bynumber (section, DISASS_DUMP);
+ else
+ request_dump_byname (optarg, DISASS_DUMP);
#endif
case 'v':
print_version (program_name);
do_wide++;
break;
default:
-#ifdef SUPPORT_DISASSEMBLY
- oops:
-#endif
/* xgettext:c-format */
error (_("Invalid option '-%c'\n"), c);
/* Drop through. */
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_section_groups && !do_archive_index)
usage (stderr);
else if (argc < 3)
{
|| (do_debug_str && streq (name, "str"))
|| (do_debug_loc && streq (name, "loc"))
)
- request_dump (i, DEBUG_DUMP);
+ request_dump_bynumber (i, DEBUG_DUMP);
}
/* linkonce section to be combined with .debug_info at link time. */
else if ((do_debugging || do_debug_info)
&& const_strneq (name, ".gnu.linkonce.wi."))
- request_dump (i, DEBUG_DUMP);
+ request_dump_bynumber (i, DEBUG_DUMP);
else if (do_debug_frames && streq (name, ".eh_frame"))
- request_dump (i, DEBUG_DUMP);
+ request_dump_bynumber (i, DEBUG_DUMP);
}
if (! do_sections)
};
unsigned int cnt;
int first = 1;
- for (cnt = 0; cnt < NUM_ELEM (opts); ++cnt)
+ for (cnt = 0; cnt < ARRAY_SIZE (opts); ++cnt)
if (entry->d_un.d_val & (1 << cnt))
{
printf ("%s%s", first ? "" : " ", opts[cnt]);
size_t cnt;
bfd_vma val = entry->d_un.d_val;
- for (cnt = 0; cnt < sizeof (flags) / sizeof (flags[0]); ++cnt)
+ for (cnt = 0; cnt < ARRAY_SIZE (flags); ++cnt)
if (val & flags[cnt].bit)
{
if (! first)
Elf_External_Verdef *edefs;
unsigned int idx;
unsigned int cnt;
+ char *endbuf;
found = 1;
edefs = get_data (NULL, file, section->sh_offset, 1,
section->sh_size,
_("version definition section"));
+ endbuf = (char *) edefs + section->sh_size;
if (!edefs)
break;
int isum;
vstart = ((char *) edefs) + idx;
+ if (vstart + sizeof (*edef) > endbuf)
+ break;
edef = (Elf_External_Verdef *) vstart;
vstart += aux.vda_next;
eaux = (Elf_External_Verdaux *) vstart;
+ if (vstart + sizeof (*eaux) > endbuf)
+ break;
aux.vda_name = BYTE_GET (eaux->vda_name);
aux.vda_next = BYTE_GET (eaux->vda_next);
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"));
idx += ent.vd_next;
}
+ if (cnt < section->sh_info)
+ printf (_(" Version definition past end of section\n"));
free (edefs);
}
Elf_External_Verneed *eneed;
unsigned int idx;
unsigned int cnt;
+ char *endbuf;
found = 1;
eneed = get_data (NULL, file, section->sh_offset, 1,
section->sh_size,
_("version need section"));
+ endbuf = (char *) eneed + section->sh_size;
if (!eneed)
break;
char *vstart;
vstart = ((char *) eneed) + idx;
+ if (vstart + sizeof (*entry) > endbuf)
+ break;
entry = (Elf_External_Verneed *) vstart;
Elf_External_Vernaux *eaux;
Elf_Internal_Vernaux aux;
+ if (vstart + sizeof (*eaux) > endbuf)
+ break;
eaux = (Elf_External_Vernaux *) vstart;
aux.vna_hash = BYTE_GET (eaux->vna_hash);
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);
}
{
ivna.vna_name = BYTE_GET (evna.vna_name);
- name = strtab + ivna.vna_name;
+ 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),
ivda.vda_name = BYTE_GET (evda.vda_name);
- name = strtab + ivda.vda_name;
+ 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),
#endif
static int
-dump_section (Elf_Internal_Shdr *section, FILE *file)
+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)
+ || SECTION_HEADER_INDEX (relsec->sh_info) >= elf_header.e_shnum
+ || SECTION_HEADER (relsec->sh_info) != section
+ || relsec->sh_size == 0
+ || SECTION_HEADER_INDEX (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)
+ {
+ printf (" [%6zx] %s\n", data - start, data);
+ data += strlen (data);
+ some_strings_shown = TRUE;
+ }
+ }
+
+ if (! some_strings_shown)
+ printf (_(" No strings found in this section."));
+
+ free (start);
+
+ putchar ('\n');
+ return 1;
+}
+
+
+static int
+dump_section_as_bytes (Elf_Internal_Shdr *section, FILE *file)
{
Elf_Internal_Shdr *relsec;
bfd_size_type bytes;
printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
break;
}
-
+
data = start;
while (bytes)
for (i = 0, any = 0; i < elf_header.e_shnum; i++)
if (streq (SECTION_NAME (section_headers + i), cur->name))
{
- request_dump (i, cur->type);
+ request_dump_bynumber (i, cur->type);
any = 1;
}
disassemble_section (section, file);
#endif
if (dump_sects[i] & HEX_DUMP)
- dump_section (section, file);
+ dump_section_as_bytes (section, file);
if (dump_sects[i] & DEBUG_DUMP)
display_debug_section (section, file);
+
+ if (dump_sects[i] & STRING_DUMP)
+ dump_section_as_strings (section, file);
}
/* Check to see if the user requested a
return p;
}
+static unsigned char *
+display_gnu_attribute (unsigned char * p,
+ unsigned char * (* display_proc_gnu_attribute) (unsigned char *, int))
+{
+ int tag;
+ unsigned int len;
+ int val;
+ int type;
+
+ tag = read_uleb128 (p, &len);
+ p += len;
+
+ /* Tag_compatibility is the only generic GNU attribute defined at
+ present. */
+ if (tag == 32)
+ {
+ val = read_uleb128 (p, &len);
+ p += len;
+ printf ("flag = %d, vendor = %s\n", val, p);
+ p += strlen ((char *) p) + 1;
+ return p;
+ }
+
+ if ((tag & 2) == 0 && display_proc_gnu_attribute)
+ return display_proc_gnu_attribute (p, tag);
+
+ if (tag & 1)
+ type = 1; /* String. */
+ else
+ type = 2; /* uleb128. */
+ printf (" Tag_unknown_%d: ", tag);
+
+ if (type == 1)
+ {
+ printf ("\"%s\"\n", p);
+ p += strlen ((char *) p) + 1;
+ }
+ else
+ {
+ val = read_uleb128 (p, &len);
+ p += len;
+ printf ("%d (0x%x)\n", val, val);
+ }
+
+ return p;
+}
+
+static unsigned char *
+display_power_gnu_attribute (unsigned char *p, int tag)
+{
+ int type;
+ unsigned int len;
+ int val;
+
+ if (tag == Tag_GNU_Power_ABI_FP)
+ {
+ val = read_uleb128 (p, &len);
+ p += len;
+ printf (" Tag_GNU_Power_ABI_FP: ");
+
+ switch (val)
+ {
+ case 0:
+ printf ("Hard or soft float\n");
+ break;
+ case 1:
+ printf ("Hard float\n");
+ break;
+ case 2:
+ printf ("Soft float\n");
+ break;
+ default:
+ printf ("??? (%d)\n", val);
+ break;
+ }
+ return p;
+ }
+
+ if (tag & 1)
+ type = 1; /* String. */
+ else
+ type = 2; /* uleb128. */
+ printf (" Tag_unknown_%d: ", tag);
+
+ if (type == 1)
+ {
+ printf ("\"%s\"\n", p);
+ p += strlen ((char *) p) + 1;
+ }
+ else
+ {
+ val = read_uleb128 (p, &len);
+ p += len;
+ printf ("%d (0x%x)\n", val, val);
+ }
+
+ return p;
+}
+
+static unsigned char *
+display_mips_gnu_attribute (unsigned char *p, int tag)
+{
+ int type;
+ unsigned int len;
+ int val;
+
+ if (tag == Tag_GNU_MIPS_ABI_FP)
+ {
+ val = read_uleb128 (p, &len);
+ p += len;
+ printf (" Tag_GNU_MIPS_ABI_FP: ");
+
+ switch (val)
+ {
+ case 0:
+ printf ("Hard or soft float\n");
+ break;
+ case 1:
+ printf ("Hard float (-mdouble-float)\n");
+ break;
+ case 2:
+ printf ("Hard float (-msingle-float)\n");
+ break;
+ case 3:
+ printf ("Soft float\n");
+ break;
+ default:
+ printf ("??? (%d)\n", val);
+ break;
+ }
+ return p;
+ }
+
+ if (tag & 1)
+ type = 1; /* String. */
+ else
+ type = 2; /* uleb128. */
+ printf (" Tag_unknown_%d: ", tag);
+
+ if (type == 1)
+ {
+ printf ("\"%s\"\n", p);
+ p += strlen ((char *) p) + 1;
+ }
+ else
+ {
+ val = read_uleb128 (p, &len);
+ p += len;
+ printf ("%d (0x%x)\n", val, val);
+ }
+
+ return p;
+}
+
static int
-process_arm_specific (FILE *file)
+process_attributes (FILE * file,
+ const char * public_name,
+ unsigned int proc_type,
+ unsigned char * (* display_pub_attribute) (unsigned char *),
+ unsigned char * (* display_proc_gnu_attribute) (unsigned char *, int))
{
Elf_Internal_Shdr *sect;
unsigned char *contents;
i < elf_header.e_shnum;
i++, sect++)
{
- if (sect->sh_type != SHT_ARM_ATTRIBUTES)
+ 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"));
-
- if (!contents)
+ if (contents == NULL)
continue;
+
p = contents;
if (*p == 'A')
{
len = sect->sh_size - 1;
p++;
+
while (len > 0)
{
int namelen;
bfd_boolean public_section;
+ bfd_boolean gnu_section;
section_len = byte_get (p, 4);
p += 4;
+
if (section_len > len)
{
printf (_("ERROR: Bad section length (%d > %d)\n"),
- (int)section_len, (int)len);
+ (int) section_len, (int) len);
section_len = len;
}
+
len -= section_len;
printf ("Attribute Section: %s\n", p);
- if (strcmp ((char *)p, "aeabi") == 0)
+
+ if (public_name && streq ((char *) p, public_name))
public_section = TRUE;
else
public_section = FALSE;
- namelen = strlen ((char *)p) + 1;
+
+ if (streq ((char *) p, "gnu"))
+ gnu_section = TRUE;
+ else
+ gnu_section = FALSE;
+
+ namelen = strlen ((char *) p) + 1;
p += namelen;
section_len -= namelen + 4;
+
while (section_len > 0)
{
int tag = *(p++);
int val;
bfd_vma size;
+
size = byte_get (p, 4);
if (size > section_len)
{
printf (_("ERROR: Bad subsection length (%d > %d)\n"),
- (int)size, (int)section_len);
+ (int) size, (int) section_len);
size = section_len;
}
+
section_len -= size;
end = p + size - 1;
p += 4;
+
switch (tag)
{
case 1:
for (;;)
{
unsigned int i;
+
val = read_uleb128 (p, &i);
p += i;
if (val == 0)
public_section = FALSE;
break;
}
+
if (public_section)
{
while (p < end)
- p = display_arm_attribute(p);
+ p = display_pub_attribute (p);
+ }
+ else if (gnu_section)
+ {
+ while (p < end)
+ p = display_gnu_attribute (p,
+ display_proc_gnu_attribute);
}
else
{
}
}
else
- {
- printf (_("Unknown format '%c'\n"), *p);
- }
+ printf (_("Unknown format '%c'\n"), *p);
- free(contents);
+ free (contents);
}
return 1;
}
+static int
+process_arm_specific (FILE *file)
+{
+ return process_attributes (file, "aeabi", SHT_ARM_ATTRIBUTES,
+ display_arm_attribute, NULL);
+}
+
+static int
+process_power_specific (FILE *file)
+{
+ return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
+ display_power_gnu_attribute);
+}
+
static int
process_mips_specific (FILE *file)
{
size_t options_offset = 0;
size_t conflicts_offset = 0;
+ process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
+ display_mips_gnu_attribute);
+
/* We have a lot of special sections. Thanks SGI! */
if (dynamic_section == NULL)
/* No information available. */
int flags = liblist.l_flags;
size_t fcnt;
- for (fcnt = 0;
- fcnt < sizeof (l_flags_vals) / sizeof (l_flags_vals[0]);
- ++fcnt)
+ for (fcnt = 0; fcnt < ARRAY_SIZE (l_flags_vals); ++fcnt)
if ((flags & l_flags_vals[fcnt].bit) != 0)
{
fputs (l_flags_vals[fcnt].name, stdout);
return buff;
}
+static const char *
+get_gnu_elf_note_type (unsigned e_type)
+{
+ static char buff[64];
+
+ switch (e_type)
+ {
+ case NT_GNU_ABI_TAG:
+ return _("NT_GNU_ABI_TAG (ABI version tag)");
+ case NT_GNU_HWCAP:
+ return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
+ case NT_GNU_BUILD_ID:
+ return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
+ default:
+ break;
+ }
+
+ snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
+ return buff;
+}
+
static const char *
get_netbsd_elfcore_note_type (unsigned e_type)
{
static int
process_note (Elf_Internal_Note *pnote)
{
+ const char *name = pnote->namesz ? pnote->namedata : "(NONE)";
const char *nt;
if (pnote->namesz == 0)
note type strings. */
nt = get_note_type (pnote->type);
+ else if (const_strneq (pnote->namedata, "GNU"))
+ /* GNU-specific object file notes. */
+ nt = get_gnu_elf_note_type (pnote->type);
+
else if (const_strneq (pnote->namedata, "NetBSD-CORE"))
/* NetBSD-specific core file notes. */
nt = get_netbsd_elfcore_note_type (pnote->type);
+ else if (strneq (pnote->namedata, "SPU/", 4))
+ {
+ /* SPU-specific core file notes. */
+ nt = pnote->namedata + 4;
+ name = "SPU";
+ }
+
else
/* Don't recognize this note name; just use the default set of
note type strings. */
nt = get_note_type (pnote->type);
- printf (" %s\t\t0x%08lx\t%s\n",
- pnote->namesz ? pnote->namedata : "(NONE)",
- pnote->descsz, nt);
+ printf (" %s\t\t0x%08lx\t%s\n", name, pnote->descsz, nt);
return 1;
}
case EM_MIPS_RS3_LE:
return process_mips_specific (file);
break;
+ case EM_PPC:
+ return process_power_specific (file);
+ break;
default:
break;
}
}
/* Initialise per file variables. */
- for (i = NUM_ELEM (version_info); i--;)
+ for (i = ARRAY_SIZE (version_info); i--;)
version_info[i] = 0;
- for (i = NUM_ELEM (dynamic_info); i--;)
+ for (i = ARRAY_SIZE (dynamic_info); i--;)
dynamic_info[i] = 0;
/* Process the file. */
must make sure that the dump_sets array is zeroed out before each
object file is processed. */
if (num_dump_sects > num_cmdline_dump_sects)
- memset (dump_sects, 0, num_dump_sects);
+ memset (dump_sects, 0, num_dump_sects * sizeof (* dump_sects));
if (num_cmdline_dump_sects > 0)
{
if (num_dump_sects == 0)
/* A sneaky way of allocating the dump_sects array. */
- request_dump (num_cmdline_dump_sects, 0);
+ request_dump_bynumber (num_cmdline_dump_sects, 0);
assert (num_dump_sects >= num_cmdline_dump_sects);
- memcpy (dump_sects, cmdline_dump_sects, num_cmdline_dump_sects);
+ memcpy (dump_sects, cmdline_dump_sects,
+ num_cmdline_dump_sects * sizeof (* dump_sects));
}
if (! process_file_header ())
return 0;
}
-/* Process an ELF archive. The file is positioned just after the
- ARMAG string. */
+/* Process an ELF archive.
+ On entry the file is positioned just after the ARMAG string. */
static int
process_archive (char *file_name, FILE *file)
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;
return 1;
}
- if (const_strneq (arhdr.ar_name, "/ "))
+ /* See if this is the archive symbol table. */
+ if (const_strneq (arhdr.ar_name, "/ ")
+ || const_strneq (arhdr.ar_name, "/SYM64/ "))
{
- /* This is the archive symbol table. Skip it.
- FIXME: We should have an option to dump it. */
size = strtoul (arhdr.ar_size, NULL, 10);
- if (fseek (file, size + (size & 1), SEEK_CUR) != 0)
+ size = size + (size & 1);
+
+ if (do_archive_index)
{
- error (_("%s: failed to skip archive symbol table\n"), file_name);
- return 1;
+ unsigned long i;
+ /* A buffer used to hold numbers read in from an archive index.
+ These are always 4 bytes long and stored in big-endian format. */
+#define SIZEOF_AR_INDEX_NUMBERS 4
+ unsigned char integer_buffer[SIZEOF_AR_INDEX_NUMBERS];
+ unsigned char * index_buffer;
+
+ /* Check the size of the archive index. */
+ if (size < SIZEOF_AR_INDEX_NUMBERS)
+ {
+ error (_("%s: the archive index is empty\n"), file_name);
+ return 1;
+ }
+
+ /* Read the numer of entries in the archive index. */
+ got = fread (integer_buffer, 1, sizeof integer_buffer, file);
+ if (got != sizeof (integer_buffer))
+ {
+ error (_("%s: failed to read archive index\n"), file_name);
+ return 1;
+ }
+ 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)
+ {
+ 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);
+ return 1;
+ }
+ index_buffer = malloc (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)
+ {
+ free (index_buffer);
+ error (_("%s: failed to read archive index\n"), file_name);
+ ret = 1;
+ goto out;
+ }
+ size -= 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)
+ {
+ 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);
+ 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;
+ }
+ sym_table = malloc (size);
+ sym_size = size;
+ if (sym_table == NULL)
+ {
+ error (_("Out of memory whilst trying to read archive index symbol table\n"));
+ ret = 1;
+ goto out;
+ }
+ got = fread (sym_table, 1, size, file);
+ if (got != size)
+ {
+ error (_("%s: failed to read archive index symbol table\n"), file_name);
+ ret = 1;
+ goto out;
+ }
+ }
+ else
+ {
+ if (fseek (file, size, SEEK_CUR) != 0)
+ {
+ error (_("%s: failed to skip archive symbol table\n"), file_name);
+ return 1;
+ }
}
- got = fread (&arhdr, 1, sizeof arhdr, file);
+ got = fread (& arhdr, 1, sizeof arhdr, file);
if (got != sizeof arhdr)
{
if (got == 0)
- return 0;
+ {
+ ret = 0;
+ goto out;
+ }
- error (_("%s: failed to read archive header\n"), file_name);
- return 1;
+ error (_("%s: failed to read archive header following archive index\n"), file_name);
+ ret = 1;
+ goto out;
}
}
+ else if (do_archive_index)
+ printf (_("%s has no archive index\n"), file_name);
if (const_strneq (arhdr.ar_name, "// "))
{
names. */
longnames_size = strtoul (arhdr.ar_size, NULL, 10);
-
longnames = malloc (longnames_size);
if (longnames == NULL)
{
- error (_("Out of memory\n"));
- return 1;
+ error (_("Out of memory reading long symbol names in archive\n"));
+ ret = 1;
+ goto out;
}
if (fread (longnames, longnames_size, 1, file) != 1)
{
free (longnames);
- error (_("%s: failed to read string table\n"), file_name);
- return 1;
+ error (_("%s: failed to read long symbol name string table\n"), file_name);
+ ret = 1;
+ goto out;
}
if ((longnames_size & 1) != 0)
getc (file);
- got = fread (&arhdr, 1, sizeof arhdr, file);
+ got = fread (& arhdr, 1, sizeof arhdr, file);
if (got != sizeof arhdr)
{
- free (longnames);
-
if (got == 0)
- return 0;
+ ret = 0;
+ else
+ {
+ error (_("%s: failed to read archive header following long symbol names\n"), file_name);
+ ret = 1;
+ }
+ goto out;
+ }
+ }
- error (_("%s: failed to read archive header\n"), file_name);
- return 1;
+ if (do_archive_index)
+ {
+ if (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 long current_pos;
+
+ printf (_("Index of archive %s: (%ld entries, 0x%lx bytes in the symbol table)\n"),
+ file_name, index_num, sym_size);
+ current_pos = ftell (file);
+
+ for (i = l = 0; i < 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 (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);
+ }
+ }
+ if (l >= sym_size)
+ {
+ error (_("%s: end of the symbol table reached before the end of the index\n"),
+ file_name);
+ break;
+ }
+ printf ("\t%s\n", sym_table + l);
+ l += strlen (sym_table + l) + 1;
+ }
+
+ if (l < 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;
+ }
}
+
+ 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. */
}
file_name_size = strlen (file_name);
}
}
- if (longnames != 0)
+ out:
+ if (index_array != NULL)
+ free (index_array);
+ if (sym_table != NULL)
+ free (sym_table);
+ if (longnames != NULL)
free (longnames);
return ret;
if (fread (armag, SARMAG, 1, file) != 1)
{
- error (_("%s: Failed to read file header\n"), file_name);
+ error (_("%s: Failed to read file's magic number\n"), file_name);
fclose (file);
return 1;
}
ret = process_archive (file_name, file);
else
{
+ if (do_archive_index)
+ error (_("File %s is not an archive so its index cannot be displayed.\n"),
+ file_name);
+
rewind (file);
archive_file_size = archive_file_offset = 0;
ret = process_object (file_name, file);
if (num_dump_sects > 0)
{
/* Make a copy of the dump_sects array. */
- cmdline_dump_sects = malloc (num_dump_sects);
+ cmdline_dump_sects = malloc (num_dump_sects * sizeof (* dump_sects));
if (cmdline_dump_sects == NULL)
error (_("Out of memory allocating dump request table.\n"));
else
{
- memcpy (cmdline_dump_sects, dump_sects, num_dump_sects);
+ memcpy (cmdline_dump_sects, dump_sects,
+ num_dump_sects * sizeof (* dump_sects));
num_cmdline_dump_sects = num_dump_sects;
}
}
projects / deliverable / binutils-gdb.git / blobdiff