/* readelf.c -- display contents of an ELF format file
- Copyright (C) 1998-2015 Free Software Foundation, Inc.
+ Copyright (C) 1998-2017 Free Software Foundation, Inc.
Originally developed by Eric Youngdale <eric@andante.jic.com>
Modifications by Nick Clifton <nickc@redhat.com>
#include "elf/metag.h"
#include "elf/microblaze.h"
#include "elf/mips.h"
+#include "elf/riscv.h"
#include "elf/mmix.h"
#include "elf/mn10200.h"
#include "elf/mn10300.h"
#include "elf/pj.h"
#include "elf/ppc.h"
#include "elf/ppc64.h"
+#include "elf/pru.h"
#include "elf/rl78.h"
#include "elf/rx.h"
#include "elf/s390.h"
#define offsetof(TYPE, MEMBER) ((size_t) &(((TYPE *) 0)->MEMBER))
#endif
+typedef struct elf_section_list
+{
+ Elf_Internal_Shdr * hdr;
+ struct elf_section_list * next;
+} elf_section_list;
+
char * program_name = "readelf";
static unsigned long archive_file_offset;
static unsigned long archive_file_size;
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;
-static int do_section_details;
-static int do_segments;
-static int do_unwind;
-static int do_using_dynamic;
-static int do_header;
-static int do_dump;
-static int do_version;
-static int do_histogram;
-static int do_debugging;
-static int do_arch;
-static int do_notes;
-static int do_archive_index;
-static int is_32bit_elf;
+static elf_section_list * symtab_shndx_list;
+static bfd_boolean show_name = FALSE;
+static bfd_boolean do_dynamic = FALSE;
+static bfd_boolean do_syms = FALSE;
+static bfd_boolean do_dyn_syms = FALSE;
+static bfd_boolean do_reloc = FALSE;
+static bfd_boolean do_sections = FALSE;
+static bfd_boolean do_section_groups = FALSE;
+static bfd_boolean do_section_details = FALSE;
+static bfd_boolean do_segments = FALSE;
+static bfd_boolean do_unwind = FALSE;
+static bfd_boolean do_using_dynamic = FALSE;
+static bfd_boolean do_header = FALSE;
+static bfd_boolean do_dump = FALSE;
+static bfd_boolean do_version = FALSE;
+static bfd_boolean do_histogram = FALSE;
+static bfd_boolean do_debugging = FALSE;
+static bfd_boolean do_arch = FALSE;
+static bfd_boolean do_notes = FALSE;
+static bfd_boolean do_archive_index = FALSE;
+static bfd_boolean is_32bit_elf = FALSE;
+static bfd_boolean decompress_dumps = FALSE;
struct group_list
{
symbol_public
};
-static const char *get_symbol_version_string
- (FILE *file, int is_dynsym, const char *strtab,
- unsigned long int strtab_size, unsigned int si,
- Elf_Internal_Sym *psym, enum versioned_symbol_info *sym_info,
- unsigned short *vna_other);
+static const char * get_symbol_version_string
+ (FILE *, bfd_boolean, const char *, unsigned long, unsigned,
+ Elf_Internal_Sym *, enum versioned_symbol_info *, unsigned short *);
#define UNKNOWN -1
|| (bfd_size_type) ((size_t) nmemb) != nmemb))
{
if (reason)
- error (_("Size truncation prevents reading 0x%llx elements of size 0x%llx for %s\n"),
- (unsigned long long) nmemb, (unsigned long long) size, reason);
+ error (_("Size truncation prevents reading 0x%" BFD_VMA_FMT "x"
+ " elements of size 0x%" BFD_VMA_FMT "x for %s\n"),
+ nmemb, size, reason);
return NULL;
}
if (amt < nmemb)
{
if (reason)
- error (_("Size overflow prevents reading 0x%llx elements of size 0x%llx for %s\n"),
- (unsigned long long) nmemb, (unsigned long long) size, reason);
+ error (_("Size overflow prevents reading 0x%" BFD_VMA_FMT "x"
+ " elements of size 0x%" BFD_VMA_FMT "x for %s\n"),
+ nmemb, size, reason);
return NULL;
}
|| offset + archive_file_offset + amt > current_file_size)
{
if (reason)
- error (_("Reading 0x%llx bytes extends past end of file for %s\n"),
- (unsigned long long) amt, reason);
+ error (_("Reading 0x%" BFD_VMA_FMT "x"
+ " bytes extends past end of file for %s\n"),
+ amt, reason);
return NULL;
}
{
if (reason)
error (_("Unable to seek to 0x%lx for %s\n"),
- (unsigned long) archive_file_offset + offset, reason);
+ archive_file_offset + offset, reason);
return NULL;
}
if (mvar == NULL)
{
if (reason)
- error (_("Out of memory allocating 0x%llx bytes for %s\n"),
- (unsigned long long) amt, reason);
+ error (_("Out of memory allocating 0x%" BFD_VMA_FMT "x"
+ " bytes for %s\n"),
+ amt, reason);
return NULL;
}
if (fread (mvar, (size_t) size, (size_t) nmemb, file) != nmemb)
{
if (reason)
- error (_("Unable to read in 0x%llx bytes of %s\n"),
- (unsigned long long) amt, reason);
+ error (_("Unable to read in 0x%" BFD_VMA_FMT "x bytes of %s\n"),
+ amt, reason);
if (mvar != var)
free (mvar);
return NULL;
return mvar;
}
-/* Print a VMA value. */
+/* Print a VMA value in the MODE specified.
+ Returns the number of characters displayed. */
-static int
+static unsigned int
print_vma (bfd_vma vma, print_mode mode)
{
- int nc = 0;
+ unsigned int nc = 0;
switch (mode)
{
case FULL_HEX:
nc = printf ("0x");
- /* Drop through. */
-
+ /* Fall through. */
case LONG_HEX:
#ifdef BFD64
if (is_32bit_elf)
case DEC_5:
if (vma <= 99999)
return printf ("%5" BFD_VMA_FMT "d", vma);
- /* Drop through. */
-
+ /* Fall through. */
case PREFIX_HEX:
nc = printf ("0x");
- /* Drop through. */
-
+ /* Fall through. */
case HEX:
return nc + printf ("%" BFD_VMA_FMT "x", vma);
case UNSIGNED:
return printf ("%" BFD_VMA_FMT "u", vma);
+
+ default:
+ /* FIXME: Report unrecognised mode ? */
+ return 0;
}
- return 0;
}
/* Display a symbol on stdout. Handles the display of control characters and
Returns the number of emitted characters. */
static unsigned int
-print_symbol (int width, const char *symbol)
+print_symbol (signed int width, const char *symbol)
{
bfd_boolean extra_padding = FALSE;
- int num_printed = 0;
+ signed int num_printed = 0;
#ifdef HAVE_MBSTATE_T
mbstate_t state;
#endif
- int width_remaining;
+ unsigned int width_remaining;
if (width < 0)
{
return num_printed;
}
-/* Returns a pointer to a static buffer containing a printable version of
+/* Returns a pointer to a static buffer containing a printable version of
the given section's name. Like print_symbol, except that it does not try
to print multibyte characters, it just interprets them as hex values. */
if (set != NULL)
{
while ((i = *set++) > 0)
- if (streq (SECTION_NAME (section_headers + i), name))
- return section_headers + i;
+ {
+ /* See PR 21156 for a reproducer. */
+ if (i >= elf_header.e_shnum)
+ continue; /* FIXME: Should we issue an error message ? */
+
+ if (streq (SECTION_NAME (section_headers + i), name))
+ return section_headers + i;
+ }
}
return find_section (name);
}
-/* Read an unsigned LEB128 encoded value from p. Set *PLEN to the number of
- bytes read. */
+/* Read an unsigned LEB128 encoded value from DATA.
+ Set *LENGTH_RETURN to the number of bytes read. */
static inline unsigned long
-read_uleb128 (unsigned char *data,
- unsigned int *length_return,
+read_uleb128 (unsigned char * data,
+ unsigned int * length_return,
const unsigned char * const end)
{
return read_leb128 (data, length_return, FALSE, end);
}
-/* Return true if the current file is for IA-64 machine and OpenVMS ABI.
+/* Return TRUE if the current file is for IA-64 machine and OpenVMS ABI.
This OS has so many departures from the ELF standard that we test it at
many places. */
-static inline int
+static inline bfd_boolean
is_ia64_vms (void)
{
return elf_header.e_machine == EM_IA_64
/* Guess the relocation size commonly used by the specific machines. */
-static int
+static bfd_boolean
guess_is_rela (unsigned int e_machine)
{
switch (e_machine)
{
/* Targets that use REL relocations. */
case EM_386:
- case EM_486:
+ case EM_IAMCU:
case EM_960:
case EM_ARM:
case EM_D10V:
case EM_ADAPTEVA_EPIPHANY:
case EM_ALPHA:
case EM_ALTERA_NIOS2:
+ case EM_ARC:
+ case EM_ARC_COMPACT:
+ case EM_ARC_COMPACT2:
case EM_AVR:
case EM_AVR_OLD:
case EM_BLACKFIN:
case EM_OR1K:
case EM_PPC64:
case EM_PPC:
+ case EM_TI_PRU:
+ case EM_RISCV:
case EM_RL78:
case EM_RX:
case EM_S390:
}
}
-static int
+/* Load RELA type relocations from FILE at REL_OFFSET extending for REL_SIZE bytes.
+ Returns TRUE upon success, FALSE otherwise. If successful then a
+ pointer to a malloc'ed buffer containing the relocs is placed in *RELASP,
+ and the number of relocs loaded is placed in *NRELASP. It is the caller's
+ responsibility to free the allocated buffer. */
+
+static bfd_boolean
slurp_rela_relocs (FILE * file,
unsigned long rel_offset,
unsigned long rel_size,
erelas = (Elf32_External_Rela *) get_data (NULL, file, rel_offset, 1,
rel_size, _("32-bit relocation data"));
if (!erelas)
- return 0;
+ return FALSE;
nrelas = rel_size / sizeof (Elf32_External_Rela);
{
free (erelas);
error (_("out of memory parsing relocs\n"));
- return 0;
+ return FALSE;
}
for (i = 0; i < nrelas; i++)
erelas = (Elf64_External_Rela *) get_data (NULL, file, rel_offset, 1,
rel_size, _("64-bit relocation data"));
if (!erelas)
- return 0;
+ return FALSE;
nrelas = rel_size / sizeof (Elf64_External_Rela);
{
free (erelas);
error (_("out of memory parsing relocs\n"));
- return 0;
+ return FALSE;
}
for (i = 0; i < nrelas; i++)
free (erelas);
}
+
*relasp = relas;
*nrelasp = nrelas;
- return 1;
+ return TRUE;
}
-static int
+/* Load REL type relocations from FILE at REL_OFFSET extending for REL_SIZE bytes.
+ Returns TRUE upon success, FALSE otherwise. If successful then a
+ pointer to a malloc'ed buffer containing the relocs is placed in *RELSP,
+ and the number of relocs loaded is placed in *NRELSP. It is the caller's
+ responsibility to free the allocated buffer. */
+
+static bfd_boolean
slurp_rel_relocs (FILE * file,
unsigned long rel_offset,
unsigned long rel_size,
erels = (Elf32_External_Rel *) get_data (NULL, file, rel_offset, 1,
rel_size, _("32-bit relocation data"));
if (!erels)
- return 0;
+ return FALSE;
nrels = rel_size / sizeof (Elf32_External_Rel);
{
free (erels);
error (_("out of memory parsing relocs\n"));
- return 0;
+ return FALSE;
}
for (i = 0; i < nrels; i++)
erels = (Elf64_External_Rel *) get_data (NULL, file, rel_offset, 1,
rel_size, _("64-bit relocation data"));
if (!erels)
- return 0;
+ return FALSE;
nrels = rel_size / sizeof (Elf64_External_Rel);
{
free (erels);
error (_("out of memory parsing relocs\n"));
- return 0;
+ return FALSE;
}
for (i = 0; i < nrels; i++)
free (erels);
}
+
*relsp = rels;
*nrelsp = nrels;
- return 1;
+ return TRUE;
}
/* Returns the reloc type extracted from the reloc info field. */
/* Display the contents of the relocation data found at the specified
offset. */
-static void
+static bfd_boolean
dump_relocations (FILE * file,
unsigned long rel_offset,
unsigned long rel_size,
char * strtab,
unsigned long strtablen,
int is_rela,
- int is_dynsym)
+ bfd_boolean is_dynsym)
{
- unsigned int i;
+ unsigned long i;
Elf_Internal_Rela * rels;
+ bfd_boolean res = TRUE;
if (is_rela == UNKNOWN)
is_rela = guess_is_rela (elf_header.e_machine);
if (is_rela)
{
if (!slurp_rela_relocs (file, rel_offset, rel_size, &rels, &rel_size))
- return;
+ return FALSE;
}
else
{
if (!slurp_rel_relocs (file, rel_offset, rel_size, &rels, &rel_size))
- return;
+ return FALSE;
}
if (is_32bit_elf)
break;
case EM_386:
- case EM_486:
+ case EM_IAMCU:
rtype = elf_i386_reloc_type (type);
break;
rtype = elf_msp430x_reloc_type (type);
break;
}
+ /* Fall through. */
case EM_MSP430_OLD:
rtype = elf_msp430_reloc_type (type);
break;
rtype = elf_mips_reloc_type (type);
break;
+ case EM_RISCV:
+ rtype = elf_riscv_reloc_type (type);
+ break;
+
case EM_ALPHA:
rtype = elf_alpha_reloc_type (type);
break;
break;
case EM_ARC:
+ case EM_ARC_COMPACT:
+ case EM_ARC_COMPACT2:
rtype = elf_arc_reloc_type (type);
break;
case EM_ALTERA_NIOS2:
rtype = elf_nios2_reloc_type (type);
break;
+
+ case EM_TI_PRU:
+ rtype = elf_pru_reloc_type (type);
+ break;
}
if (rtype == NULL)
case LITUSE_ALPHA_JSRDIRECT: rtype = "JSRDIRECT"; break;
default: rtype = NULL;
}
+
if (rtype)
printf (" (%s)", rtype);
else
putchar (' ');
printf (_("<unknown addend: %lx>"),
(unsigned long) rels[i].r_addend);
+ res = FALSE;
}
}
else if (symtab_index)
{
if (symtab == NULL || symtab_index >= nsyms)
- printf (_(" bad symbol index: %08lx"), (unsigned long) symtab_index);
+ {
+ error (_(" bad symbol index: %08lx in reloc"), (unsigned long) symtab_index);
+ res = FALSE;
+ }
else
{
Elf_Internal_Sym * psym;
else if (strtab == NULL)
printf (_("<string table index: %3ld>"), psym->st_name);
else if (psym->st_name >= strtablen)
- printf (_("<corrupt string table index: %3ld>"), psym->st_name);
+ {
+ error (_("<corrupt string table index: %3ld>"), psym->st_name);
+ res = FALSE;
+ }
else
{
print_symbol (22, strtab + psym->st_name);
if (is_rela)
{
- bfd_signed_vma off = rels[i].r_addend;
+ bfd_vma off = rels[i].r_addend;
- /* PR 17531: file: 2e63226f. */
- if (off == ((bfd_signed_vma) 1) << ((sizeof (bfd_signed_vma) * 8) - 1))
- printf (" + %" BFD_VMA_FMT "x", off);
- else if (off < 0)
+ if ((bfd_signed_vma) off < 0)
printf (" - %" BFD_VMA_FMT "x", - off);
else
printf (" + %" BFD_VMA_FMT "x", off);
}
else if (is_rela)
{
- bfd_signed_vma off = rels[i].r_addend;
+ bfd_vma off = rels[i].r_addend;
printf ("%*c", is_32bit_elf ? 12 : 20, ' ');
- /* PR 17531: file: 2e63226f. */
- if (off == ((bfd_signed_vma) 1) << ((sizeof (bfd_signed_vma) * 8) - 1))
- printf ("%" BFD_VMA_FMT "x", off);
- else if (off < 0)
+ if ((bfd_signed_vma) off < 0)
printf ("-%" BFD_VMA_FMT "x", - off);
else
printf ("%" BFD_VMA_FMT "x", off);
}
free (rels);
+
+ return res;
}
static const char *
case DT_MIPS_GOTSYM: return "MIPS_GOTSYM";
case DT_MIPS_HIPAGENO: return "MIPS_HIPAGENO";
case DT_MIPS_RLD_MAP: return "MIPS_RLD_MAP";
+ case DT_MIPS_RLD_MAP_REL: return "MIPS_RLD_MAP_REL";
case DT_MIPS_DELTA_CLASS: return "MIPS_DELTA_CLASS";
case DT_MIPS_DELTA_CLASS_NO: return "MIPS_DELTA_CLASS_NO";
case DT_MIPS_DELTA_INSTANCE: return "MIPS_DELTA_INSTANCE";
}
}
+static const char *
+get_solaris_section_type (unsigned long type)
+{
+ switch (type)
+ {
+ case 0x6fffffee: return "SUNW_ancillary";
+ case 0x6fffffef: return "SUNW_capchain";
+ case 0x6ffffff0: return "SUNW_capinfo";
+ case 0x6ffffff1: return "SUNW_symsort";
+ case 0x6ffffff2: return "SUNW_tlssort";
+ case 0x6ffffff3: return "SUNW_LDYNSYM";
+ case 0x6ffffff4: return "SUNW_dof";
+ case 0x6ffffff5: return "SUNW_cap";
+ case 0x6ffffff6: return "SUNW_SIGNATURE";
+ case 0x6ffffff7: return "SUNW_ANNOTATE";
+ case 0x6ffffff8: return "SUNW_DEBUGSTR";
+ case 0x6ffffff9: return "SUNW_DEBUG";
+ case 0x6ffffffa: return "SUNW_move";
+ case 0x6ffffffb: return "SUNW_COMDAT";
+ case 0x6ffffffc: return "SUNW_syminfo";
+ case 0x6ffffffd: return "SUNW_verdef";
+ case 0x6ffffffe: return "SUNW_verneed";
+ case 0x6fffffff: return "SUNW_versym";
+ case 0x70000000: return "SPARC_GOTDATA";
+ default: return NULL;
+ }
+}
+
static const char *
get_alpha_dynamic_type (unsigned long type)
{
switch (type)
{
case DT_ALPHA_PLTRO: return "ALPHA_PLTRO";
- default:
- return NULL;
+ default: return NULL;
}
}
case DT_SCORE_GOTSYM: return "SCORE_GOTSYM";
case DT_SCORE_UNREFEXTNO: return "SCORE_UNREFEXTNO";
case DT_SCORE_HIPAGENO: return "SCORE_HIPAGENO";
- default:
- return NULL;
+ default: return NULL;
}
}
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;
+ default: return NULL;
}
}
switch (type)
{
case DT_NIOS2_GP: return "NIOS2_GP";
- default:
- return NULL;
+ default: return NULL;
+ }
+}
+
+static const char *
+get_solaris_dynamic_type (unsigned long type)
+{
+ switch (type)
+ {
+ case 0x6000000d: return "SUNW_AUXILIARY";
+ case 0x6000000e: return "SUNW_RTLDINF";
+ case 0x6000000f: return "SUNW_FILTER";
+ case 0x60000010: return "SUNW_CAP";
+ case 0x60000011: return "SUNW_SYMTAB";
+ case 0x60000012: return "SUNW_SYMSZ";
+ case 0x60000013: return "SUNW_SORTENT";
+ case 0x60000014: return "SUNW_SYMSORT";
+ case 0x60000015: return "SUNW_SYMSORTSZ";
+ case 0x60000016: return "SUNW_TLSSORT";
+ case 0x60000017: return "SUNW_TLSSORTSZ";
+ case 0x60000018: return "SUNW_CAPINFO";
+ case 0x60000019: return "SUNW_STRPAD";
+ case 0x6000001a: return "SUNW_CAPCHAIN";
+ case 0x6000001b: return "SUNW_LDMACH";
+ case 0x6000001d: return "SUNW_CAPCHAINENT";
+ case 0x6000001f: return "SUNW_CAPCHAINSZ";
+ case 0x60000021: return "SUNW_PARENT";
+ case 0x60000023: return "SUNW_ASLR";
+ case 0x60000025: return "SUNW_RELAX";
+ case 0x60000029: return "SUNW_NXHEAP";
+ case 0x6000002b: return "SUNW_NXSTACK";
+
+ case 0x70000001: return "SPARC_REGISTER";
+ case 0x7ffffffd: return "AUXILIARY";
+ case 0x7ffffffe: return "USED";
+ case 0x7fffffff: return "FILTER";
+
+ default: return NULL;
}
}
case DT_PREINIT_ARRAY: return "PREINIT_ARRAY";
case DT_PREINIT_ARRAYSZ: return "PREINIT_ARRAYSZ";
+ case DT_SYMTAB_SHNDX: return "SYMTAB_SHNDX";
case DT_CHECKSUM: return "CHECKSUM";
case DT_PLTPADSZ: return "PLTPADSZ";
result = get_nios2_dynamic_type (type);
break;
default:
- result = NULL;
+ if (elf_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
+ result = get_solaris_dynamic_type (type);
+ else
+ result = NULL;
break;
}
result = get_ia64_dynamic_type (type);
break;
default:
- result = NULL;
+ if (elf_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
+ result = get_solaris_dynamic_type (type);
+ else
+ result = NULL;
break;
}
switch (e_type)
{
- case ET_NONE: return _("NONE (None)");
- case ET_REL: return _("REL (Relocatable file)");
- case ET_EXEC: return _("EXEC (Executable file)");
- case ET_DYN: return _("DYN (Shared object file)");
- case ET_CORE: return _("CORE (Core file)");
+ case ET_NONE: return _("NONE (None)");
+ case ET_REL: return _("REL (Relocatable file)");
+ case ET_EXEC: return _("EXEC (Executable file)");
+ case ET_DYN: return _("DYN (Shared object file)");
+ case ET_CORE: return _("CORE (Core file)");
default:
if ((e_type >= ET_LOPROC) && (e_type <= ET_HIPROC))
switch (e_machine)
{
+ /* Please keep this switch table sorted by increasing EM_ value. */
+ /* 0 */
case EM_NONE: return _("None");
- case EM_AARCH64: return "AArch64";
case EM_M32: return "WE32100";
case EM_SPARC: return "Sparc";
- case EM_SPU: return "SPU";
case EM_386: return "Intel 80386";
case EM_68K: return "MC68000";
case EM_88K: return "MC88000";
- case EM_486: return "Intel 80486";
+ case EM_IAMCU: return "Intel MCU";
case EM_860: return "Intel 80860";
case EM_MIPS: return "MIPS R3000";
case EM_S370: return "IBM System/370";
+ /* 10 */
case EM_MIPS_RS3_LE: return "MIPS R4000 big-endian";
case EM_OLD_SPARCV9: return "Sparc v9 (old)";
case EM_PARISC: return "HPPA";
- case EM_PPC_OLD: return "Power PC (old)";
+ case EM_VPP550: return "Fujitsu VPP500";
case EM_SPARC32PLUS: return "Sparc v8+" ;
case EM_960: return "Intel 90860";
case EM_PPC: return "PowerPC";
+ /* 20 */
case EM_PPC64: return "PowerPC64";
+ case EM_S390_OLD:
+ case EM_S390: return "IBM S/390";
+ case EM_SPU: return "SPU";
+ /* 30 */
+ case EM_V800: return "Renesas V850 (using RH850 ABI)";
case EM_FR20: return "Fujitsu FR20";
- case EM_FT32: return "FTDI FT32";
case EM_RH32: return "TRW RH32";
case EM_MCORE: return "MCORE";
+ /* 40 */
case EM_ARM: return "ARM";
case EM_OLD_ALPHA: return "Digital Alpha (old)";
case EM_SH: return "Renesas / SuperH SH";
case EM_H8_300H: return "Renesas H8/300H";
case EM_H8S: return "Renesas H8S";
case EM_H8_500: return "Renesas H8/500";
+ /* 50 */
case EM_IA_64: return "Intel IA-64";
case EM_MIPS_X: return "Stanford MIPS-X";
case EM_COLDFIRE: return "Motorola Coldfire";
- case EM_ALPHA: return "Alpha";
- case EM_CYGNUS_D10V:
- case EM_D10V: return "d10v";
- case EM_CYGNUS_D30V:
- case EM_D30V: return "d30v";
- case EM_CYGNUS_M32R:
- case EM_M32R: return "Renesas M32R (formerly Mitsubishi M32r)";
- case EM_CYGNUS_V850:
- case EM_V800: return "Renesas V850 (using RH850 ABI)";
- case EM_V850: return "Renesas V850";
- case EM_CYGNUS_MN10300:
- case EM_MN10300: return "mn10300";
- case EM_CYGNUS_MN10200:
- case EM_MN10200: return "mn10200";
- case EM_MOXIE: return "Moxie";
- case EM_CYGNUS_FR30:
- case EM_FR30: return "Fujitsu FR30";
- case EM_CYGNUS_FRV: return "Fujitsu FR-V";
- case EM_PJ_OLD:
- case EM_PJ: return "picoJava";
+ case EM_68HC12: return "Motorola MC68HC12 Microcontroller";
case EM_MMA: return "Fujitsu Multimedia Accelerator";
case EM_PCP: return "Siemens PCP";
case EM_NCPU: return "Sony nCPU embedded RISC processor";
case EM_NDR1: return "Denso NDR1 microprocesspr";
case EM_STARCORE: return "Motorola Star*Core processor";
case EM_ME16: return "Toyota ME16 processor";
+ /* 60 */
case EM_ST100: return "STMicroelectronics ST100 processor";
case EM_TINYJ: return "Advanced Logic Corp. TinyJ embedded processor";
+ case EM_X86_64: return "Advanced Micro Devices X86-64";
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_ST9PLUS: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
case EM_ST7: return "STMicroelectronics ST7 8-bit microcontroller";
case EM_68HC16: return "Motorola MC68HC16 Microcontroller";
- case EM_68HC12: return "Motorola MC68HC12 Microcontroller";
+ /* 70 */
case EM_68HC11: return "Motorola MC68HC11 Microcontroller";
case EM_68HC08: return "Motorola MC68HC08 Microcontroller";
case EM_68HC05: return "Motorola MC68HC05 Microcontroller";
case EM_SVX: return "Silicon Graphics SVx";
case EM_ST19: return "STMicroelectronics ST19 8-bit microcontroller";
case EM_VAX: return "Digital VAX";
- case EM_VISIUM: return "CDS VISIUMcore processor";
- case EM_AVR_OLD:
- case EM_AVR: return "Atmel AVR 8-bit microcontroller";
case EM_CRIS: return "Axis Communications 32-bit embedded processor";
case EM_JAVELIN: return "Infineon Technologies 32-bit embedded cpu";
case EM_FIREPATH: return "Element 14 64-bit DSP processor";
case EM_ZSP: return "LSI Logic's 16-bit DSP processor";
+ /* 80 */
case EM_MMIX: return "Donald Knuth's educational 64-bit processor";
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_K1OM: return "Intel K1OM";
- 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_AVR_OLD:
+ case EM_AVR: return "Atmel AVR 8-bit microcontroller";
+ case EM_CYGNUS_FR30:
+ case EM_FR30: return "Fujitsu FR30";
+ case EM_CYGNUS_D10V:
+ case EM_D10V: return "d10v";
+ case EM_CYGNUS_D30V:
+ case EM_D30V: return "d30v";
+ case EM_CYGNUS_V850:
+ case EM_V850: return "Renesas V850";
+ case EM_CYGNUS_M32R:
+ case EM_M32R: return "Renesas M32R (formerly Mitsubishi M32r)";
+ case EM_CYGNUS_MN10300:
+ case EM_MN10300: return "mn10300";
+ /* 90 */
+ case EM_CYGNUS_MN10200:
+ case EM_MN10200: return "mn10200";
+ case EM_PJ: return "picoJava";
case EM_OR1K: return "OpenRISC 1000";
- case EM_ARC_A5: return "ARC International ARCompact processor";
- case EM_CRX: return "National Semiconductor CRX microprocessor";
- case EM_ADAPTEVA_EPIPHANY: return "Adapteva EPIPHANY";
- case EM_DLX: return "OpenDLX";
- case EM_IP2K_OLD:
- case EM_IP2K: return "Ubicom IP2xxx 8-bit microcontrollers";
- case EM_IQ2000: return "Vitesse IQ2000";
+ case EM_ARC_COMPACT: return "ARCompact";
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_SNP1K: return "Trebia SNP 1000 processor";
+ /* 100 */
+ case EM_ST200: return "STMicroelectronics ST200 microcontroller";
+ case EM_IP2K_OLD:
+ case EM_IP2K: return "Ubicom IP2xxx 8-bit microcontrollers";
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";
+ /* 110 */
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_CRX: return "National Semiconductor CRX microprocessor";
+ case EM_XGATE: return "Motorola XGATE embedded processor";
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";
+ /* 120 */
+ case EM_M32C: return "Renesas M32c";
+ /* 130 */
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_SCORE: return "SUNPLUS S+Core";
case EM_DSP24: return "New Japan Radio (NJR) 24-bit DSP Processor";
case EM_VIDEOCORE3: return "Broadcom VideoCore III processor";
+ case EM_LATTICEMICO32: return "Lattice Mico32";
case EM_SE_C17: return "Seiko Epson C17 family";
+ /* 140 */
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_TI_PRU: return "TI PRU I/O processor";
+ /* 160 */
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_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";
+ /* 170 */
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_MICROBLAZE:
- case EM_MICROBLAZE_OLD: return "Xilinx MicroBlaze";
- case EM_RL78: return "Renesas RL78";
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_CR16:
+ case EM_MICROBLAZE:
+ case EM_MICROBLAZE_OLD: return "Xilinx MicroBlaze";
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";
+ /* 180 */
+ case EM_L1OM: return "Intel L1OM";
+ case EM_K1OM: return "Intel K1OM";
+ case EM_INTEL182: return "Intel (reserved)";
+ case EM_AARCH64: return "AArch64";
+ case EM_ARM184: return "ARM (reserved)";
+ case EM_AVR32: return "Atmel Corporation 32-bit microprocessor";
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_TILEGX: return "Tilera TILE-Gx multicore architecture family";
+ /* 190 */
case EM_CUDA: return "NVIDIA CUDA architecture";
- case EM_XGATE: return "Motorola XGATE embedded processor";
+ case EM_TILEGX: return "Tilera TILE-Gx multicore architecture family";
+ case EM_CLOUDSHIELD: return "CloudShield architecture family";
+ case EM_COREA_1ST: return "KIPO-KAIST Core-A 1st generation processor family";
+ case EM_COREA_2ND: return "KIPO-KAIST Core-A 2nd generation processor family";
+ case EM_ARC_COMPACT2: return "ARCv2";
+ case EM_OPEN8: return "Open8 8-bit RISC soft processor core";
+ case EM_RL78: return "Renesas RL78";
+ case EM_VIDEOCORE5: return "Broadcom VideoCore V processor";
+ case EM_78K0R: return "Renesas 78K0R";
+ /* 200 */
+ case EM_56800EX: return "Freescale 56800EX Digital Signal Controller (DSC)";
+ case EM_BA1: return "Beyond BA1 CPU architecture";
+ case EM_BA2: return "Beyond BA2 CPU architecture";
+ case EM_XCORE: return "XMOS xCORE processor family";
+ case EM_MCHP_PIC: return "Microchip 8-bit PIC(r) family";
+ /* 210 */
+ case EM_KM32: return "KM211 KM32 32-bit processor";
+ case EM_KMX32: return "KM211 KMX32 32-bit processor";
+ case EM_KMX16: return "KM211 KMX16 16-bit processor";
+ case EM_KMX8: return "KM211 KMX8 8-bit processor";
+ case EM_KVARC: return "KM211 KVARC processor";
+ case EM_CDP: return "Paneve CDP architecture family";
+ case EM_COGE: return "Cognitive Smart Memory Processor";
+ case EM_COOL: return "Bluechip Systems CoolEngine";
+ case EM_NORC: return "Nanoradio Optimized RISC";
+ case EM_CSR_KALIMBA: return "CSR Kalimba architecture family";
+ /* 220 */
+ case EM_Z80: return "Zilog Z80";
+ case EM_VISIUM: return "CDS VISIUMcore processor";
+ case EM_FT32: return "FTDI Chip FT32";
+ case EM_MOXIE: return "Moxie";
+ case EM_AMDGPU: return "AMD GPU";
+ case EM_RISCV: return "RISC-V";
+ case EM_LANAI: return "Lanai 32-bit processor";
+ case EM_BPF: return "Linux BPF";
+
+ /* Large numbers... */
+ case EM_MT: return "Morpho Techologies MT processor";
+ case EM_ALPHA: return "Alpha";
+ case EM_WEBASSEMBLY: return "Web Assembly";
+ case EM_DLX: return "OpenDLX";
+ case EM_XSTORMY16: return "Sanyo XStormy16 CPU core";
+ case EM_IQ2000: return "Vitesse IQ2000";
+ case EM_M32C_OLD:
+ case EM_NIOS32: return "Altera Nios";
+ case EM_CYGNUS_MEP: return "Toshiba MeP Media Engine";
+ case EM_ADAPTEVA_EPIPHANY: return "Adapteva EPIPHANY";
+ case EM_CYGNUS_FRV: return "Fujitsu FR-V";
+
default:
snprintf (buff, sizeof (buff), _("<unknown>: 0x%x"), e_machine);
return buff;
}
}
+static void
+decode_ARC_machine_flags (unsigned e_flags, unsigned e_machine, char buf[])
+{
+ /* ARC has two machine types EM_ARC_COMPACT and EM_ARC_COMPACT2. Some
+ other compilers don't a specific architecture type in the e_flags, and
+ instead use EM_ARC_COMPACT for old ARC600, ARC601, and ARC700
+ architectures, and switch to EM_ARC_COMPACT2 for newer ARCEM and ARCHS
+ architectures.
+
+ Th GNU tools follows this use of EM_ARC_COMPACT and EM_ARC_COMPACT2,
+ but also sets a specific architecture type in the e_flags field.
+
+ However, when decoding the flags we don't worry if we see an
+ unexpected pairing, for example EM_ARC_COMPACT machine type, with
+ ARCEM architecture type. */
+
+ switch (e_flags & EF_ARC_MACH_MSK)
+ {
+ /* We only expect these to occur for EM_ARC_COMPACT2. */
+ case EF_ARC_CPU_ARCV2EM:
+ strcat (buf, ", ARC EM");
+ break;
+ case EF_ARC_CPU_ARCV2HS:
+ strcat (buf, ", ARC HS");
+ break;
+
+ /* We only expect these to occur for EM_ARC_COMPACT. */
+ case E_ARC_MACH_ARC600:
+ strcat (buf, ", ARC600");
+ break;
+ case E_ARC_MACH_ARC601:
+ strcat (buf, ", ARC601");
+ break;
+ case E_ARC_MACH_ARC700:
+ strcat (buf, ", ARC700");
+ break;
+
+ /* The only times we should end up here are (a) A corrupt ELF, (b) A
+ new ELF with new architecture being read by an old version of
+ readelf, or (c) An ELF built with non-GNU compiler that does not
+ set the architecture in the e_flags. */
+ default:
+ if (e_machine == EM_ARC_COMPACT)
+ strcat (buf, ", Unknown ARCompact");
+ else
+ strcat (buf, ", Unknown ARC");
+ break;
+ }
+
+ switch (e_flags & EF_ARC_OSABI_MSK)
+ {
+ case E_ARC_OSABI_ORIG:
+ strcat (buf, ", (ABI:legacy)");
+ break;
+ case E_ARC_OSABI_V2:
+ strcat (buf, ", (ABI:v2)");
+ break;
+ /* Only upstream 3.9+ kernels will support ARCv2 ISA. */
+ case E_ARC_OSABI_V3:
+ strcat (buf, ", v3 no-legacy-syscalls ABI");
+ break;
+ default:
+ strcat (buf, ", unrecognised ARC OSABI flag");
+ break;
+ }
+}
+
static void
decode_ARM_machine_flags (unsigned e_flags, char buf[])
{
unsigned eabi;
- int unknown = 0;
+ bfd_boolean unknown = FALSE;
eabi = EF_ARM_EABI_VERSION (e_flags);
e_flags &= ~ EF_ARM_EABIMASK;
default:
strcat (buf, ", <unrecognized EABI>");
if (e_flags)
- unknown = 1;
+ unknown = TRUE;
break;
case EF_ARM_EABI_VER1:
break;
default:
- unknown = 1;
+ unknown = TRUE;
break;
}
}
break;
default:
- unknown = 1;
+ unknown = TRUE;
break;
}
}
break;
default:
- unknown = 1;
+ unknown = TRUE;
break;
}
- break;
}
break;
break;
default:
- unknown = 1;
+ unknown = TRUE;
break;
}
}
break;
default:
- unknown = 1;
+ unknown = TRUE;
break;
}
}
unsigned arch;
unsigned config;
unsigned version;
- int has_fpu = 0;
- int r = 0;
+ bfd_boolean has_fpu = FALSE;
+ unsigned int r = 0;
static const char *ABI_STRINGS[] =
{
if (config & E_NDS32_HAS_FPU_INST)
{
- has_fpu = 1;
+ has_fpu = TRUE;
r += snprintf (buf + r, size -r, ", FPU_SP");
}
if (config & E_NDS32_HAS_FPU_DP_INST)
{
- has_fpu = 1;
+ has_fpu = TRUE;
r += snprintf (buf + r, size -r, ", FPU_DP");
}
if (config & E_NDS32_HAS_FPU_MAC_INST)
{
- has_fpu = 1;
+ has_fpu = TRUE;
r += snprintf (buf + r, size -r, ", FPU_MAC");
}
default:
break;
+ case EM_ARC_COMPACT2:
+ case EM_ARC_COMPACT:
+ decode_ARC_machine_flags (e_flags, e_machine, buf);
+ break;
+
case EM_ARM:
decode_ARM_machine_flags (e_flags, buf);
break;
decode_NDS32_machine_flags (e_flags, buf, sizeof buf);
break;
+ case EM_RISCV:
+ if (e_flags & EF_RISCV_RVC)
+ strcat (buf, ", RVC");
+
+ switch (e_flags & EF_RISCV_FLOAT_ABI)
+ {
+ case EF_RISCV_FLOAT_ABI_SOFT:
+ strcat (buf, ", soft-float ABI");
+ break;
+
+ case EF_RISCV_FLOAT_ABI_SINGLE:
+ strcat (buf, ", single-float ABI");
+ break;
+
+ case EF_RISCV_FLOAT_ABI_DOUBLE:
+ strcat (buf, ", double-float ABI");
+ break;
+
+ case EF_RISCV_FLOAT_ABI_QUAD:
+ strcat (buf, ", quad-float ABI");
+ break;
+ }
+ break;
+
case EM_SH:
switch ((e_flags & EF_SH_MACH_MASK))
{
if (e_flags & E_FLAG_RX_SINSNS_SET)
strcat (buf, e_flags & E_FLAG_RX_SINSNS_YES
? ", uses String instructions" : ", bans String instructions");
+ if (e_flags & E_FLAG_RX_V2)
+ strcat (buf, ", V2");
break;
case EM_S390:
case ELFOSABI_NSK: return "HP - Non-Stop Kernel";
case ELFOSABI_AROS: return "AROS";
case ELFOSABI_FENIXOS: return "FenixOS";
+ case ELFOSABI_CLOUDABI: return "Nuxi CloudABI";
+ case ELFOSABI_OPENVOS: return "Stratus Technologies OpenVOS";
default:
if (osabi >= 64)
switch (elf_header.e_machine)
{
switch (type)
{
- case PT_AARCH64_ARCHEXT:
- return "AARCH64_ARCHEXT";
- default:
- break;
+ case PT_AARCH64_ARCHEXT: return "AARCH64_ARCHEXT";
+ default: return NULL;
}
-
- return NULL;
}
static const char *
{
switch (type)
{
- case PT_ARM_EXIDX:
- return "EXIDX";
- default:
- break;
+ case PT_ARM_EXIDX: return "EXIDX";
+ default: return NULL;
}
-
- return NULL;
}
static const char *
{
switch (type)
{
- case PT_MIPS_REGINFO:
- return "REGINFO";
- case PT_MIPS_RTPROC:
- return "RTPROC";
- case PT_MIPS_OPTIONS:
- return "OPTIONS";
- case PT_MIPS_ABIFLAGS:
- return "ABIFLAGS";
- default:
- break;
+ case PT_MIPS_REGINFO: return "REGINFO";
+ case PT_MIPS_RTPROC: return "RTPROC";
+ case PT_MIPS_OPTIONS: return "OPTIONS";
+ case PT_MIPS_ABIFLAGS: return "ABIFLAGS";
+ default: return NULL;
}
-
- return NULL;
}
static const char *
case PT_PARISC_ARCHEXT: return "PARISC_ARCHEXT";
case PT_PARISC_UNWIND: return "PARISC_UNWIND";
case PT_PARISC_WEAKORDER: return "PARISC_WEAKORDER";
- default:
- break;
+ default: return NULL;
}
-
- return NULL;
}
static const char *
case PT_IA_64_HP_OPT_ANOT: return "HP_OPT_ANNOT";
case PT_IA_64_HP_HSL_ANOT: return "HP_HSL_ANNOT";
case PT_IA_64_HP_STACK: return "HP_STACK";
- default:
- break;
+ default: return NULL;
}
-
- return NULL;
}
static const char *
{
switch (type)
{
- case PT_C6000_PHATTR: return "C6000_PHATTR";
- default:
- break;
+ case PT_C6000_PHATTR: return "C6000_PHATTR";
+ default: return NULL;
}
+}
- return NULL;
+static const char *
+get_solaris_segment_type (unsigned long type)
+{
+ switch (type)
+ {
+ case 0x6464e550: return "PT_SUNW_UNWIND";
+ case 0x6474e550: return "PT_SUNW_EH_FRAME";
+ case 0x6ffffff7: return "PT_LOSUNW";
+ case 0x6ffffffa: return "PT_SUNWBSS";
+ case 0x6ffffffb: return "PT_SUNWSTACK";
+ case 0x6ffffffc: return "PT_SUNWDTRACE";
+ case 0x6ffffffd: return "PT_SUNWCAP";
+ case 0x6fffffff: return "PT_HISUNW";
+ default: return NULL;
+ }
}
static const char *
case PT_SHLIB: return "SHLIB";
case PT_PHDR: return "PHDR";
case PT_TLS: return "TLS";
-
- case PT_GNU_EH_FRAME:
- return "GNU_EH_FRAME";
+ case PT_GNU_EH_FRAME: return "GNU_EH_FRAME";
case PT_GNU_STACK: return "GNU_STACK";
case PT_GNU_RELRO: return "GNU_RELRO";
if (result != NULL)
return result;
- sprintf (buff, "LOPROC+%lx", p_type - PT_LOPROC);
+ sprintf (buff, "LOPROC+%#lx", p_type - PT_LOPROC);
}
else if ((p_type >= PT_LOOS) && (p_type <= PT_HIOS))
{
result = get_ia64_segment_type (p_type);
break;
default:
- result = NULL;
+ if (elf_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
+ result = get_solaris_segment_type (p_type);
+ else
+ result = NULL;
break;
}
if (result != NULL)
return result;
- sprintf (buff, "LOOS+%lx", p_type - PT_LOOS);
+ sprintf (buff, "LOOS+%#lx", p_type - PT_LOOS);
}
else
snprintf (buff, sizeof (buff), _("<unknown>: %lx"), p_type);
case SHT_PARISC_SYMEXTN: return "PARISC_SYMEXTN";
case SHT_PARISC_STUBS: return "PARISC_STUBS";
case SHT_PARISC_DLKM: return "PARISC_DLKM";
- default:
- break;
+ default: return NULL;
}
- return NULL;
}
static const char *
switch (sh_type)
{
case SHT_X86_64_UNWIND: return "X86_64_UNWIND";
- default:
- break;
+ default: return NULL;
}
- return NULL;
}
static const char *
{
switch (sh_type)
{
- case SHT_AARCH64_ATTRIBUTES:
- return "AARCH64_ATTRIBUTES";
- default:
- break;
+ case SHT_AARCH64_ATTRIBUTES: return "AARCH64_ATTRIBUTES";
+ default: return NULL;
}
- return NULL;
}
static const char *
case SHT_ARM_ATTRIBUTES: return "ARM_ATTRIBUTES";
case SHT_ARM_DEBUGOVERLAY: return "ARM_DEBUGOVERLAY";
case SHT_ARM_OVERLAYSECTION: return "ARM_OVERLAYSECTION";
- default:
- break;
+ default: return NULL;
}
- return NULL;
}
static const char *
{
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;
+ 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: return NULL;
}
- return NULL;
}
static const char *
{
switch (sh_type)
{
- case SHT_MSP430_SEC_FLAGS: return "MSP430_SEC_FLAGS";
- case SHT_MSP430_SYM_ALIASES: return "MSP430_SYM_ALIASES";
- case SHT_MSP430_ATTRIBUTES: return "MSP430_ATTRIBUTES";
- default: return NULL;
+ case SHT_MSP430_SEC_FLAGS: return "MSP430_SEC_FLAGS";
+ case SHT_MSP430_SYM_ALIASES: return "MSP430_SYM_ALIASES";
+ case SHT_MSP430_ATTRIBUTES: return "MSP430_ATTRIBUTES";
+ default: return NULL;
}
}
{
switch (sh_type)
{
- case SHT_V850_SCOMMON: return "V850 Small Common";
- case SHT_V850_TCOMMON: return "V850 Tiny Common";
- case SHT_V850_ZCOMMON: return "V850 Zero Common";
- case SHT_RENESAS_IOP: return "RENESAS IOP";
- case SHT_RENESAS_INFO: return "RENESAS INFO";
- default: return NULL;
+ case SHT_V850_SCOMMON: return "V850 Small Common";
+ case SHT_V850_TCOMMON: return "V850 Tiny Common";
+ case SHT_V850_ZCOMMON: return "V850 Zero Common";
+ case SHT_RENESAS_IOP: return "RENESAS IOP";
+ case SHT_RENESAS_INFO: return "RENESAS INFO";
+ default: return NULL;
}
}
get_section_type_name (unsigned int sh_type)
{
static char buff[32];
+ const char * result;
switch (sh_type)
{
default:
if ((sh_type >= SHT_LOPROC) && (sh_type <= SHT_HIPROC))
{
- const char * result;
-
switch (elf_header.e_machine)
{
case EM_MIPS:
if (result != NULL)
return result;
- sprintf (buff, "LOPROC+%x", sh_type - SHT_LOPROC);
+ sprintf (buff, "LOPROC+%#x", sh_type - SHT_LOPROC);
}
else if ((sh_type >= SHT_LOOS) && (sh_type <= SHT_HIOS))
{
- const char * result;
-
switch (elf_header.e_machine)
{
case EM_IA_64:
result = get_ia64_section_type_name (sh_type);
break;
default:
- result = NULL;
+ if (elf_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
+ result = get_solaris_section_type (sh_type);
+ else
+ {
+ switch (sh_type)
+ {
+ case SHT_GNU_INCREMENTAL_INPUTS: result = "GNU_INCREMENTAL_INPUTS"; break;
+ case SHT_GNU_ATTRIBUTES: result = "GNU_ATTRIBUTES"; break;
+ case SHT_GNU_HASH: result = "GNU_HASH"; break;
+ case SHT_GNU_LIBLIST: result = "GNU_LIBLIST"; break;
+ default:
+ result = NULL;
+ break;
+ }
+ }
break;
}
if (result != NULL)
return result;
- sprintf (buff, "LOOS+%x", sh_type - SHT_LOOS);
+ sprintf (buff, "LOOS+%#x", sh_type - SHT_LOOS);
}
else if ((sh_type >= SHT_LOUSER) && (sh_type <= SHT_HIUSER))
{
case EM_V800:
case EM_V850:
case EM_CYGNUS_V850:
- return get_v850_section_type_name (sh_type);
+ result = get_v850_section_type_name (sh_type);
+ break;
default:
+ result = NULL;
break;
}
- sprintf (buff, "LOUSER+%x", sh_type - SHT_LOUSER);
+ if (result != NULL)
+ return result;
+
+ sprintf (buff, "LOUSER+%#x", sh_type - SHT_LOUSER);
}
else
/* This message is probably going to be displayed in a 15
{"hex-dump", required_argument, 0, 'x'},
{"relocated-dump", required_argument, 0, 'R'},
{"string-dump", required_argument, 0, 'p'},
+ {"decompress", no_argument, 0, 'z'},
#ifdef SUPPORT_DISASSEMBLY
{"instruction-dump", required_argument, 0, 'i'},
#endif
Dump the contents of section <number|name> as strings\n\
-R --relocated-dump=<number|name>\n\
Dump the contents of section <number|name> as relocated bytes\n\
+ -z --decompress Decompress section before dumping it\n\
-w[lLiaprmfFsoRt] or\n\
--debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
=frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
error (_("Out of memory allocating dump request table.\n"));
else
{
- /* Copy current flag settings. */
- memcpy (new_dump_sects, dump_sects, num_dump_sects * sizeof (* dump_sects));
+ if (dump_sects)
+ {
+ /* Copy current flag settings. */
+ memcpy (new_dump_sects, dump_sects, num_dump_sects * sizeof (* dump_sects));
- free (dump_sects);
+ free (dump_sects);
+ }
dump_sects = new_dump_sects;
num_dump_sects = section + 1;
usage (stderr);
while ((c = getopt_long
- (argc, argv, "ADHINR:SVWacdeghi:lnp:rstuvw::x:", options, NULL)) != EOF)
+ (argc, argv, "ADHINR:SVWacdeghi:lnp:rstuvw::x:z", options, NULL)) != EOF)
{
switch (c)
{
break;
case 'a':
- do_syms++;
- do_reloc++;
- do_unwind++;
- do_dynamic++;
- do_header++;
- do_sections++;
- do_section_groups++;
- do_segments++;
- do_version++;
- do_histogram++;
- do_arch++;
- do_notes++;
+ do_syms = TRUE;
+ do_reloc = TRUE;
+ do_unwind = TRUE;
+ do_dynamic = TRUE;
+ do_header = TRUE;
+ do_sections = TRUE;
+ do_section_groups = TRUE;
+ do_segments = TRUE;
+ do_version = TRUE;
+ do_histogram = TRUE;
+ do_arch = TRUE;
+ do_notes = TRUE;
break;
case 'g':
- do_section_groups++;
+ do_section_groups = TRUE;
break;
case 't':
case 'N':
- do_sections++;
- do_section_details++;
+ do_sections = TRUE;
+ do_section_details = TRUE;
break;
case 'e':
- do_header++;
- do_sections++;
- do_segments++;
+ do_header = TRUE;
+ do_sections = TRUE;
+ do_segments = TRUE;
break;
case 'A':
- do_arch++;
+ do_arch = TRUE;
break;
case 'D':
- do_using_dynamic++;
+ do_using_dynamic = TRUE;
break;
case 'r':
- do_reloc++;
+ do_reloc = TRUE;
break;
case 'u':
- do_unwind++;
+ do_unwind = TRUE;
break;
case 'h':
- do_header++;
+ do_header = TRUE;
break;
case 'l':
- do_segments++;
+ do_segments = TRUE;
break;
case 's':
- do_syms++;
+ do_syms = TRUE;
break;
case 'S':
- do_sections++;
+ do_sections = TRUE;
break;
case 'd':
- do_dynamic++;
+ do_dynamic = TRUE;
break;
case 'I':
- do_histogram++;
+ do_histogram = TRUE;
break;
case 'n':
- do_notes++;
+ do_notes = TRUE;
break;
case 'c':
- do_archive_index++;
+ do_archive_index = TRUE;
break;
case 'x':
request_dump (HEX_DUMP);
case 'R':
request_dump (RELOC_DUMP);
break;
+ case 'z':
+ decompress_dumps = TRUE;
+ break;
case 'w':
- do_dump++;
+ do_dump = TRUE;
if (optarg == 0)
{
- do_debugging = 1;
+ do_debugging = TRUE;
dwarf_select_sections_all ();
}
else
{
- do_debugging = 0;
+ do_debugging = FALSE;
dwarf_select_sections_by_letters (optarg);
}
break;
case OPTION_DEBUG_DUMP:
- do_dump++;
+ do_dump = TRUE;
if (optarg == 0)
- do_debugging = 1;
+ do_debugging = TRUE;
else
{
- do_debugging = 0;
+ do_debugging = FALSE;
dwarf_select_sections_by_names (optarg);
}
break;
}
break;
case OPTION_DWARF_CHECK:
- dwarf_check = 1;
+ dwarf_check = TRUE;
break;
case OPTION_DYN_SYMS:
- do_dyn_syms++;
+ do_dyn_syms = TRUE;
break;
#ifdef SUPPORT_DISASSEMBLY
case 'i':
print_version (program_name);
break;
case 'V':
- do_version++;
+ do_version = TRUE;
break;
case 'W':
- do_wide++;
+ do_wide = TRUE;
break;
default:
/* xgettext:c-format */
error (_("Invalid option '-%c'\n"), c);
- /* Drop through. */
+ /* Fall through. */
case '?':
usage (stderr);
}
/* Decode the data held in 'elf_header'. */
-static int
+static bfd_boolean
process_file_header (void)
{
if ( elf_header.e_ident[EI_MAG0] != ELFMAG0
{
error
(_("Not an ELF file - it has the wrong magic bytes at the start\n"));
- return 0;
+ return FALSE;
}
init_dwarf_regnames (elf_header.e_machine);
if (do_header)
{
- int i;
+ unsigned i;
printf (_("ELF Header:\n"));
printf (_(" Magic: "));
section_headers = NULL;
}
- return 1;
+ return TRUE;
}
static bfd_boolean
return TRUE;
}
-/* Returns 1 if the program headers were read into `program_headers'. */
+/* Returns TRUE if the program headers were read into `program_headers'. */
-static int
+static bfd_boolean
get_program_headers (FILE * file)
{
Elf_Internal_Phdr * phdrs;
/* Check cache of prior read. */
if (program_headers != NULL)
- return 1;
+ return TRUE;
phdrs = (Elf_Internal_Phdr *) cmalloc (elf_header.e_phnum,
sizeof (Elf_Internal_Phdr));
{
error (_("Out of memory reading %u program headers\n"),
elf_header.e_phnum);
- return 0;
+ return FALSE;
}
if (is_32bit_elf
: get_64bit_program_headers (file, phdrs))
{
program_headers = phdrs;
- return 1;
+ return TRUE;
}
free (phdrs);
- return 0;
+ return FALSE;
}
-/* Returns 1 if the program headers were loaded. */
+/* Returns TRUE if the program headers were loaded. */
-static int
+static bfd_boolean
process_program_headers (FILE * file)
{
Elf_Internal_Phdr * segment;
unsigned int i;
+ Elf_Internal_Phdr * previous_load = NULL;
if (elf_header.e_phnum == 0)
{
/* PR binutils/12467. */
if (elf_header.e_phoff != 0)
- warn (_("possibly corrupt ELF header - it has a non-zero program"
- " header offset, but no program headers\n"));
+ {
+ warn (_("possibly corrupt ELF header - it has a non-zero program"
+ " header offset, but no program headers\n"));
+ return FALSE;
+ }
else if (do_segments)
printf (_("\nThere are no program headers in this file.\n"));
- return 0;
+ return TRUE;
}
if (do_segments && !do_header)
}
if (! get_program_headers (file))
- return 0;
+ return TRUE;
if (do_segments)
{
(segment->p_flags & PF_R ? 'R' : ' '),
(segment->p_flags & PF_W ? 'W' : ' '),
(segment->p_flags & PF_X ? 'E' : ' '));
- print_vma (segment->p_align, HEX);
+ print_vma (segment->p_align, PREFIX_HEX);
}
- }
- if (do_segments)
- putc ('\n', stdout);
+ putc ('\n', stdout);
+ }
switch (segment->p_type)
{
+ case PT_LOAD:
+#if 0 /* Do not warn about out of order PT_LOAD segments. Although officially
+ required by the ELF standard, several programs, including the Linux
+ kernel, make use of non-ordered segments. */
+ if (previous_load
+ && previous_load->p_vaddr > segment->p_vaddr)
+ error (_("LOAD segments must be sorted in order of increasing VirtAddr\n"));
+#endif
+ if (segment->p_memsz < segment->p_filesz)
+ error (_("the segment's file size is larger than its memory size\n"));
+ previous_load = segment;
+ break;
+
+ case PT_PHDR:
+ /* PR 20815 - Verify that the program header is loaded into memory. */
+ if (i > 0 && previous_load != NULL)
+ error (_("the PHDR segment must occur before any LOAD segment\n"));
+ if (elf_header.e_machine != EM_PARISC)
+ {
+ unsigned int j;
+
+ for (j = 1; j < elf_header.e_phnum; j++)
+ if (program_headers[j].p_vaddr <= segment->p_vaddr
+ && (program_headers[j].p_vaddr + program_headers[j].p_memsz)
+ >= (segment->p_vaddr + segment->p_filesz))
+ break;
+ if (j == elf_header.e_phnum)
+ error (_("the PHDR segment is not covered by a LOAD segment\n"));
+ }
+ break;
+
case PT_DYNAMIC:
if (dynamic_addr)
error (_("more than one dynamic segment\n"));
}
}
- return 1;
+ return TRUE;
}
internal->sh_info = BYTE_GET (shdrs[i].sh_info);
internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
internal->sh_entsize = BYTE_GET (shdrs[i].sh_entsize);
+ if (!probe && internal->sh_link > num)
+ warn (_("Section %u has an out of range sh_link value of %u\n"), i, internal->sh_link);
+ if (!probe && internal->sh_flags & SHF_INFO_LINK && internal->sh_info > num)
+ warn (_("Section %u has an out of range sh_info value of %u\n"), i, internal->sh_info);
}
free (shdrs);
internal->sh_info = BYTE_GET (shdrs[i].sh_info);
internal->sh_offset = BYTE_GET (shdrs[i].sh_offset);
internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
+ if (!probe && internal->sh_link > num)
+ warn (_("Section %u has an out of range sh_link value of %u\n"), i, internal->sh_link);
+ if (!probe && internal->sh_flags & SHF_INFO_LINK && internal->sh_info > num)
+ warn (_("Section %u has an out of range sh_info value of %u\n"), i, internal->sh_info);
}
free (shdrs);
if (esyms == NULL)
goto exit_point;
- shndx = NULL;
- if (symtab_shndx_hdr != NULL
- && (symtab_shndx_hdr->sh_link
- == (unsigned long) (section - section_headers)))
- {
- shndx = (Elf_External_Sym_Shndx *) get_data (NULL, file,
- symtab_shndx_hdr->sh_offset,
- 1, symtab_shndx_hdr->sh_size,
- _("symbol table section indicies"));
- if (shndx == NULL)
- goto exit_point;
- /* PR17531: file: heap-buffer-overflow */
- else if (symtab_shndx_hdr->sh_size / sizeof (Elf_External_Sym_Shndx) < number)
+ {
+ elf_section_list * entry;
+
+ shndx = NULL;
+ for (entry = symtab_shndx_list; entry != NULL; entry = entry->next)
+ if (entry->hdr->sh_link == (unsigned long) (section - section_headers))
{
- error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
- printable_section_name (symtab_shndx_hdr),
- (unsigned long) symtab_shndx_hdr->sh_size,
- (unsigned long) section->sh_size);
- goto exit_point;
+ shndx = (Elf_External_Sym_Shndx *) get_data (NULL, file,
+ entry->hdr->sh_offset,
+ 1, entry->hdr->sh_size,
+ _("symbol table section indicies"));
+ if (shndx == NULL)
+ goto exit_point;
+ /* PR17531: file: heap-buffer-overflow */
+ else if (entry->hdr->sh_size / sizeof (Elf_External_Sym_Shndx) < number)
+ {
+ error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
+ printable_section_name (entry->hdr),
+ (unsigned long) entry->hdr->sh_size,
+ (unsigned long) section->sh_size);
+ goto exit_point;
+ }
}
- }
+ }
isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
if (!esyms)
goto exit_point;
- if (symtab_shndx_hdr != NULL
- && (symtab_shndx_hdr->sh_link
- == (unsigned long) (section - section_headers)))
- {
- shndx = (Elf_External_Sym_Shndx *) get_data (NULL, file,
- symtab_shndx_hdr->sh_offset,
- 1, symtab_shndx_hdr->sh_size,
- _("symbol table section indicies"));
- if (shndx == NULL)
- goto exit_point;
- else if (symtab_shndx_hdr->sh_size / sizeof (Elf_External_Sym_Shndx) < number)
+ {
+ elf_section_list * entry;
+
+ shndx = NULL;
+ for (entry = symtab_shndx_list; entry != NULL; entry = entry->next)
+ if (entry->hdr->sh_link == (unsigned long) (section - section_headers))
{
- error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
- printable_section_name (symtab_shndx_hdr),
- (unsigned long) symtab_shndx_hdr->sh_size,
- (unsigned long) section->sh_size);
- goto exit_point;
+ shndx = (Elf_External_Sym_Shndx *) get_data (NULL, file,
+ entry->hdr->sh_offset,
+ 1, entry->hdr->sh_size,
+ _("symbol table section indicies"));
+ if (shndx == NULL)
+ goto exit_point;
+ /* PR17531: file: heap-buffer-overflow */
+ else if (entry->hdr->sh_size / sizeof (Elf_External_Sym_Shndx) < number)
+ {
+ error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
+ printable_section_name (entry->hdr),
+ (unsigned long) entry->hdr->sh_size,
+ (unsigned long) section->sh_size);
+ goto exit_point;
+ }
}
- }
+ }
isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
{
static char buff[1024];
char * p = buff;
- int field_size = is_32bit_elf ? 8 : 16;
- int sindex;
- int size = sizeof (buff) - (field_size + 4 + 1);
+ unsigned int field_size = is_32bit_elf ? 8 : 16;
+ signed int sindex;
+ unsigned 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;
- int len;
+ unsigned int len;
}
flags [] =
{
/* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
/* SPARC specific. */
/* 19 */ { STRING_COMMA_LEN ("ORDERED") },
- /* 20 */ { STRING_COMMA_LEN ("COMPRESSED") }
+ /* 20 */ { STRING_COMMA_LEN ("COMPRESSED") },
+ /* ARM specific. */
+ /* 21 */ { STRING_COMMA_LEN ("ENTRYSECT") },
+ /* 22 */ { STRING_COMMA_LEN ("ARM_PURECODE") },
+ /* 23 */ { STRING_COMMA_LEN ("COMDEF") }
};
if (do_section_details)
break;
case EM_386:
- case EM_486:
+ case EM_IAMCU:
case EM_X86_64:
case EM_L1OM:
case EM_K1OM:
if (flag == SHF_ORDERED)
sindex = 19;
break;
+
+ case EM_ARM:
+ switch (flag)
+ {
+ case SHF_ENTRYSECT: sindex = 21; break;
+ case SHF_ARM_PURECODE: sindex = 22; break;
+ case SHF_COMDEF: sindex = 23; break;
+ default: break;
+ }
+ break;
+
default:
break;
}
|| elf_header.e_machine == EM_K1OM)
&& flag == SHF_X86_64_LARGE)
*p = 'l';
+ else if (elf_header.e_machine == EM_ARM
+ && flag == SHF_ARM_PURECODE)
+ *p = 'y';
else if (flag & SHF_MASKOS)
{
*p = 'o';
}
static unsigned int
-get_compression_header (Elf_Internal_Chdr *chdr, unsigned char *buf)
+get_compression_header (Elf_Internal_Chdr *chdr, unsigned char *buf, bfd_size_type size)
{
if (is_32bit_elf)
{
Elf32_External_Chdr *echdr = (Elf32_External_Chdr *) buf;
+
+ if (size < sizeof (* echdr))
+ {
+ error (_("Compressed section is too small even for a compression header\n"));
+ return 0;
+ }
+
chdr->ch_type = BYTE_GET (echdr->ch_type);
chdr->ch_size = BYTE_GET (echdr->ch_size);
chdr->ch_addralign = BYTE_GET (echdr->ch_addralign);
else
{
Elf64_External_Chdr *echdr = (Elf64_External_Chdr *) buf;
+
+ if (size < sizeof (* echdr))
+ {
+ error (_("Compressed section is too small even for a compression header\n"));
+ return 0;
+ }
+
chdr->ch_type = BYTE_GET (echdr->ch_type);
chdr->ch_size = BYTE_GET (echdr->ch_size);
chdr->ch_addralign = BYTE_GET (echdr->ch_addralign);
}
}
-static int
+static bfd_boolean
process_section_headers (FILE * file)
{
Elf_Internal_Shdr * section;
{
/* PR binutils/12467. */
if (elf_header.e_shoff != 0)
- warn (_("possibly corrupt ELF file header - it has a non-zero"
- " section header offset, but no section headers\n"));
+ {
+ warn (_("possibly corrupt ELF file header - it has a non-zero"
+ " section header offset, but no section headers\n"));
+ return FALSE;
+ }
else if (do_sections)
printf (_("\nThere are no sections in this file.\n"));
- return 1;
+ return TRUE;
}
if (do_sections && !do_header)
if (is_32bit_elf)
{
if (! get_32bit_section_headers (file, FALSE))
- return 0;
+ return FALSE;
+ }
+ else
+ {
+ if (! get_64bit_section_headers (file, FALSE))
+ return FALSE;
}
- else if (! get_64bit_section_headers (file, FALSE))
- return 0;
/* Read in the string table, so that we have names to display. */
if (elf_header.e_shstrndx != SHN_UNDEF
dynamic_symbols = NULL;
dynamic_strings = NULL;
dynamic_syminfo = NULL;
- symtab_shndx_hdr = NULL;
+ symtab_shndx_list = NULL;
eh_addr_size = is_32bit_elf ? 4 : 8;
switch (elf_header.e_machine)
}
else if (section->sh_type == SHT_SYMTAB_SHNDX)
{
- if (symtab_shndx_hdr != NULL)
- {
- error (_("File contains multiple symtab shndx tables\n"));
- continue;
- }
- symtab_shndx_hdr = section;
+ elf_section_list * entry = xmalloc (sizeof * entry);
+ entry->hdr = section;
+ entry->next = symtab_shndx_list;
+ symtab_shndx_list = entry;
}
else if (section->sh_type == SHT_SYMTAB)
CHECK_ENTSIZE (section, i, Sym);
|| (do_debug_pubtypes && const_strneq (name, "gnu_pubtypes"))
|| (do_debug_aranges && const_strneq (name, "aranges"))
|| (do_debug_ranges && const_strneq (name, "ranges"))
+ || (do_debug_ranges && const_strneq (name, "rnglists"))
|| (do_debug_frames && const_strneq (name, "frame"))
|| (do_debug_macinfo && const_strneq (name, "macinfo"))
|| (do_debug_macinfo && const_strneq (name, "macro"))
|| (do_debug_str && const_strneq (name, "str"))
|| (do_debug_loc && const_strneq (name, "loc"))
+ || (do_debug_loc && const_strneq (name, "loclists"))
|| (do_debug_addr && const_strneq (name, "addr"))
|| (do_debug_cu_index && const_strneq (name, "cu_index"))
|| (do_debug_cu_index && const_strneq (name, "tu_index"))
}
if (! do_sections)
- return 1;
+ return TRUE;
if (elf_header.e_shnum > 1)
printf (_("\nSection Headers:\n"));
i < elf_header.e_shnum;
i++, section++)
{
+ /* Run some sanity checks on the section header. */
+
+ /* Check the sh_link field. */
+ switch (section->sh_type)
+ {
+ case SHT_SYMTAB_SHNDX:
+ case SHT_GROUP:
+ case SHT_HASH:
+ case SHT_GNU_HASH:
+ case SHT_GNU_versym:
+ case SHT_REL:
+ case SHT_RELA:
+ if (section->sh_link < 1
+ || section->sh_link >= elf_header.e_shnum
+ || (section_headers[section->sh_link].sh_type != SHT_SYMTAB
+ && section_headers[section->sh_link].sh_type != SHT_DYNSYM))
+ warn (_("[%2u]: Link field (%u) should index a symtab section.\n"),
+ i, section->sh_link);
+ break;
+
+ case SHT_DYNAMIC:
+ case SHT_SYMTAB:
+ case SHT_DYNSYM:
+ case SHT_GNU_verneed:
+ case SHT_GNU_verdef:
+ case SHT_GNU_LIBLIST:
+ if (section->sh_link < 1
+ || section->sh_link >= elf_header.e_shnum
+ || section_headers[section->sh_link].sh_type != SHT_STRTAB)
+ warn (_("[%2u]: Link field (%u) should index a string section.\n"),
+ i, section->sh_link);
+ break;
+
+ case SHT_INIT_ARRAY:
+ case SHT_FINI_ARRAY:
+ case SHT_PREINIT_ARRAY:
+ if (section->sh_type < SHT_LOOS && section->sh_link != 0)
+ warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
+ i, section->sh_link);
+ break;
+
+ default:
+ /* FIXME: Add support for target specific section types. */
+#if 0 /* Currently we do not check other section types as there are too
+ many special cases. Stab sections for example have a type
+ of SHT_PROGBITS but an sh_link field that links to the .stabstr
+ section. */
+ if (section->sh_type < SHT_LOOS && section->sh_link != 0)
+ warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
+ i, section->sh_link);
+#endif
+ break;
+ }
+
+ /* Check the sh_info field. */
+ switch (section->sh_type)
+ {
+ case SHT_REL:
+ case SHT_RELA:
+ if (section->sh_info < 1
+ || section->sh_info >= elf_header.e_shnum
+ || (section_headers[section->sh_info].sh_type != SHT_PROGBITS
+ && section_headers[section->sh_info].sh_type != SHT_NOBITS
+ && section_headers[section->sh_info].sh_type != SHT_NOTE
+ && section_headers[section->sh_info].sh_type != SHT_INIT_ARRAY
+ /* FIXME: Are other section types valid ? */
+ && section_headers[section->sh_info].sh_type < SHT_LOOS))
+ {
+ if (section->sh_info == 0
+ && (streq (SECTION_NAME (section), ".rel.dyn")
+ || streq (SECTION_NAME (section), ".rela.dyn")))
+ /* The .rel.dyn and .rela.dyn sections have an sh_info field
+ of zero. The relocations in these sections may apply
+ to many different sections. */
+ ;
+ else
+ warn (_("[%2u]: Info field (%u) should index a relocatable section.\n"),
+ i, section->sh_info);
+ }
+ break;
+
+ case SHT_DYNAMIC:
+ case SHT_HASH:
+ case SHT_SYMTAB_SHNDX:
+ case SHT_INIT_ARRAY:
+ case SHT_FINI_ARRAY:
+ case SHT_PREINIT_ARRAY:
+ if (section->sh_info != 0)
+ warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
+ i, section->sh_info);
+ break;
+
+ case SHT_GROUP:
+ case SHT_SYMTAB:
+ case SHT_DYNSYM:
+ /* A symbol index - we assume that it is valid. */
+ break;
+
+ default:
+ /* FIXME: Add support for target specific section types. */
+ if (section->sh_type == SHT_NOBITS)
+ /* NOBITS section headers with non-zero sh_info fields can be
+ created when a binary is stripped of everything but its debug
+ information. The stripped sections have their headers
+ preserved but their types set to SHT_NOBITS. So do not check
+ this type of section. */
+ ;
+ else if (section->sh_flags & SHF_INFO_LINK)
+ {
+ if (section->sh_info < 1 || section->sh_info >= elf_header.e_shnum)
+ warn (_("[%2u]: Expected link to another section in info field"), i);
+ }
+ else if (section->sh_type < SHT_LOOS && section->sh_info != 0)
+ warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
+ i, section->sh_info);
+ break;
+ }
+
printf (" [%2u] ", i);
if (do_section_details)
printf ("%s\n ", printable_section_name (section));
switch (elf_header.e_machine)
{
case EM_386:
- case EM_486:
+ case EM_IAMCU:
case EM_X86_64:
case EM_L1OM:
case EM_K1OM:
/* Minimum section size is 12 bytes for 32-bit compression
header + 12 bytes for compressed data header. */
unsigned char buf[24];
+
assert (sizeof (buf) >= sizeof (Elf64_External_Chdr));
if (get_data (&buf, (FILE *) file, section->sh_offset, 1,
sizeof (buf), _("compression header")))
{
Elf_Internal_Chdr chdr;
- get_compression_header (&chdr, buf);
+
+ (void) get_compression_header (&chdr, buf, sizeof (buf));
+
if (chdr.ch_type == ELFCOMPRESS_ZLIB)
printf (" ZLIB, ");
else
if (!do_section_details)
{
+ /* The ordering of the letters shown here matches the ordering of the
+ corresponding SHF_xxx values, and hence the order in which these
+ letters will be displayed to the user. */
+ printf (_("Key to Flags:\n\
+ W (write), A (alloc), X (execute), M (merge), S (strings), I (info),\n\
+ L (link order), O (extra OS processing required), G (group), T (TLS),\n\
+ C (compressed), x (unknown), o (OS specific), E (exclude),\n "));
if (elf_header.e_machine == EM_X86_64
|| elf_header.e_machine == EM_L1OM
|| elf_header.e_machine == EM_K1OM)
- printf (_("Key to Flags:\n\
- W (write), A (alloc), X (execute), M (merge), S (strings), l (large)\n\
- I (info), L (link order), G (group), T (TLS), E (exclude), x (unknown)\n\
- O (extra OS processing required) o (OS specific), p (processor specific)\n"));
- else
- printf (_("Key to Flags:\n\
- W (write), A (alloc), X (execute), M (merge), S (strings)\n\
- I (info), L (link order), G (group), T (TLS), E (exclude), x (unknown)\n\
- O (extra OS processing required) o (OS specific), p (processor specific)\n"));
+ printf (_("l (large), "));
+ else if (elf_header.e_machine == EM_ARM)
+ printf (_("y (purecode), "));
+ printf ("p (processor specific)\n");
}
- return 1;
+ return TRUE;
}
static const char *
get_group_flags (unsigned int flags)
{
- static char buff[32];
- switch (flags)
- {
- case 0:
- return "";
+ static char buff[128];
+
+ if (flags == 0)
+ return "";
+ else if (flags == GRP_COMDAT)
+ return "COMDAT ";
- case GRP_COMDAT:
- return "COMDAT ";
+ snprintf (buff, 14, _("[0x%x: "), flags);
- default:
- snprintf (buff, sizeof (buff), _("[<unknown>: 0x%x] "), flags);
- break;
+ flags &= ~ GRP_COMDAT;
+ if (flags & GRP_MASKOS)
+ {
+ strcat (buff, "<OS specific>");
+ flags &= ~ GRP_MASKOS;
}
+
+ if (flags & GRP_MASKPROC)
+ {
+ strcat (buff, "<PROC specific>");
+ flags &= ~ GRP_MASKPROC;
+ }
+
+ if (flags)
+ strcat (buff, "<unknown>");
+
+ strcat (buff, "]");
return buff;
}
-static int
+static bfd_boolean
process_section_groups (FILE * file)
{
Elf_Internal_Shdr * section;
/* Don't process section groups unless needed. */
if (!do_unwind && !do_section_groups)
- return 1;
+ return TRUE;
if (elf_header.e_shnum == 0)
{
if (do_section_groups)
printf (_("\nThere are no sections to group in this file.\n"));
- return 1;
+ return TRUE;
}
if (section_headers == NULL)
{
error (_("Section headers are not available!\n"));
/* PR 13622: This can happen with a corrupt ELF header. */
- return 0;
+ return FALSE;
}
section_headers_groups = (struct group **) calloc (elf_header.e_shnum,
{
error (_("Out of memory reading %u section group headers\n"),
elf_header.e_shnum);
- return 0;
+ return FALSE;
}
/* Scan the sections for the group section. */
if (do_section_groups)
printf (_("\nThere are no section groups in this file.\n"));
- return 1;
+ return TRUE;
}
section_groups = (struct group *) calloc (group_count, sizeof (struct group));
{
error (_("Out of memory reading %lu groups\n"),
(unsigned long) group_count);
- return 0;
+ return FALSE;
}
symtab_sec = NULL;
else
{
/* Intel C/C++ compiler may put section 0 in a
- section group. We just warn it the first time
+ section group. We just warn it the first time
and ignore it afterwards. */
- static int warned = 0;
+ static bfd_boolean warned = FALSE;
if (!warned)
{
error (_("section 0 in group section [%5u]\n"),
section_headers_groups [entry]->group_index);
- warned++;
+ warned = TRUE;
}
}
}
free (symtab);
if (strtab)
free (strtab);
- return 1;
+ return TRUE;
}
/* Data used to display dynamic fixups. */
/* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
library). */
-static void
-dump_ia64_vms_dynamic_fixups (FILE *file, struct ia64_vms_dynfixup *fixup,
- const char *strtab, unsigned int strtab_sz)
+static bfd_boolean
+dump_ia64_vms_dynamic_fixups (FILE * file,
+ struct ia64_vms_dynfixup * fixup,
+ const char * strtab,
+ unsigned int strtab_sz)
{
- Elf64_External_VMS_IMAGE_FIXUP *imfs;
+ Elf64_External_VMS_IMAGE_FIXUP * imfs;
long i;
- const char *lib_name;
+ const char * lib_name;
imfs = get_data (NULL, file, dynamic_addr + fixup->fixup_rela_off,
1, fixup->fixup_rela_cnt * sizeof (*imfs),
_("dynamic section image fixups"));
if (!imfs)
- return;
+ return FALSE;
if (fixup->needed < strtab_sz)
lib_name = strtab + fixup->needed;
else
{
- warn ("corrupt library name index of 0x%lx found in dynamic entry",
+ warn (_("corrupt library name index of 0x%lx found in dynamic entry"),
(unsigned long) fixup->needed);
lib_name = "???";
}
}
free (imfs);
+ return TRUE;
}
/* Display IA-64 OpenVMS dynamic relocations (used to relocate an image). */
-static void
+static bfd_boolean
dump_ia64_vms_dynamic_relocs (FILE *file, struct ia64_vms_dynimgrela *imgrela)
{
Elf64_External_VMS_IMAGE_RELA *imrs;
1, imgrela->img_rela_cnt * sizeof (*imrs),
_("dynamic section image relocations"));
if (!imrs)
- return;
+ return FALSE;
printf (_("\nImage relocs\n"));
printf
}
free (imrs);
+ return TRUE;
}
/* Display IA-64 OpenVMS dynamic relocations and fixups. */
-static int
+static bfd_boolean
process_ia64_vms_dynamic_relocs (FILE *file)
{
struct ia64_vms_dynfixup fixup;
struct ia64_vms_dynimgrela imgrela;
Elf_Internal_Dyn *entry;
- int res = 0;
bfd_vma strtab_off = 0;
bfd_vma strtab_sz = 0;
char *strtab = NULL;
+ bfd_boolean res = TRUE;
memset (&fixup, 0, sizeof (fixup));
memset (&imgrela, 0, sizeof (imgrela));
break;
case DT_IA_64_VMS_FIXUP_RELA_OFF:
fixup.fixup_rela_off = entry->d_un.d_val;
- res++;
- dump_ia64_vms_dynamic_fixups (file, &fixup, strtab, strtab_sz);
+ if (! dump_ia64_vms_dynamic_fixups (file, &fixup, strtab, strtab_sz))
+ res = FALSE;
break;
-
case DT_IA_64_VMS_IMG_RELA_CNT:
imgrela.img_rela_cnt = entry->d_un.d_val;
break;
case DT_IA_64_VMS_IMG_RELA_OFF:
imgrela.img_rela_off = entry->d_un.d_val;
- res++;
- dump_ia64_vms_dynamic_relocs (file, &imgrela);
+ if (! dump_ia64_vms_dynamic_relocs (file, &imgrela))
+ res = FALSE;
break;
default:
int reloc;
int size;
int rela;
-} dynamic_relocations [] =
+}
+ dynamic_relocations [] =
{
- { "REL", DT_REL, DT_RELSZ, FALSE },
- { "RELA", DT_RELA, DT_RELASZ, TRUE },
- { "PLT", DT_JMPREL, DT_PLTRELSZ, UNKNOWN }
+ { "REL", DT_REL, DT_RELSZ, FALSE },
+ { "RELA", DT_RELA, DT_RELASZ, TRUE },
+ { "PLT", DT_JMPREL, DT_PLTRELSZ, UNKNOWN }
};
/* Process the reloc section. */
-static int
+static bfd_boolean
process_relocs (FILE * file)
{
unsigned long rel_size;
unsigned long rel_offset;
-
if (!do_reloc)
- return 1;
+ return TRUE;
if (do_using_dynamic)
{
- int is_rela;
+ int is_rela;
const char * name;
- int has_dynamic_reloc;
+ bfd_boolean has_dynamic_reloc;
unsigned int i;
- has_dynamic_reloc = 0;
+ has_dynamic_reloc = FALSE;
for (i = 0; i < ARRAY_SIZE (dynamic_relocations); i++)
{
rel_size = dynamic_info [dynamic_relocations [i].size];
rel_offset = dynamic_info [dynamic_relocations [i].reloc];
- has_dynamic_reloc |= rel_size;
+ if (rel_size)
+ has_dynamic_reloc = TRUE;
if (is_rela == UNKNOWN)
{
rel_size,
dynamic_symbols, num_dynamic_syms,
dynamic_strings, dynamic_strings_length,
- is_rela, 1);
+ is_rela, TRUE /* is_dynamic */);
}
}
if (is_ia64_vms ())
- has_dynamic_reloc |= process_ia64_vms_dynamic_relocs (file);
+ if (process_ia64_vms_dynamic_relocs (file))
+ has_dynamic_reloc = TRUE;
if (! has_dynamic_reloc)
printf (_("\nThere are no dynamic relocations in this file.\n"));
{
Elf_Internal_Shdr * section;
unsigned long i;
- int found = 0;
+ bfd_boolean found = FALSE;
for (i = 0, section = section_headers;
i < elf_header.e_shnum;
}
else
dump_relocations (file, rel_offset, rel_size,
- NULL, 0, NULL, 0, is_rela, 0);
+ NULL, 0, NULL, 0, is_rela,
+ FALSE /* is_dynamic */);
- found = 1;
+ found = TRUE;
}
}
printf (_("\nThere are no relocations in this file.\n"));
}
- return 1;
+ return TRUE;
}
/* An absolute address consists of a section and an offset. If the
*offset = addr.offset;
}
-static int
+static /* signed */ int
symcmp (const void *p, const void *q)
{
Elf_Internal_Sym *sp = (Elf_Internal_Sym *) p;
struct ia64_unw_aux_info
{
- struct ia64_unw_table_entry *table; /* Unwind table. */
- unsigned long table_len; /* Length of unwind table. */
- 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. */
- unsigned long nsyms; /* Number of symbols. */
- Elf_Internal_Sym * funtab; /* Sorted table of STT_FUNC symbols. */
- unsigned long nfuns; /* Number of entries in funtab. */
- char * strtab; /* The string table. */
- unsigned long strtab_size; /* Size of string table. */
+ struct ia64_unw_table_entry * table; /* Unwind table. */
+ unsigned long table_len; /* Length of unwind table. */
+ 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. */
+ unsigned long nsyms; /* Number of symbols. */
+ Elf_Internal_Sym * funtab; /* Sorted table of STT_FUNC symbols. */
+ unsigned long nfuns; /* Number of entries in funtab. */
+ char * strtab; /* The string table. */
+ unsigned long strtab_size; /* Size of string table. */
};
-static void
+static bfd_boolean
dump_ia64_unwind (struct ia64_unw_aux_info * aux)
{
struct ia64_unw_table_entry * tp;
unsigned long j, nfuns;
int in_body;
+ bfd_boolean res = TRUE;
aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
for (nfuns = 0, j = 0; j < aux->nsyms; j++)
{
warn (_("Invalid offset %lx in table entry %ld\n"),
(long) tp->info.offset, (long) (tp - aux->table));
+ res = FALSE;
continue;
}
if (end > aux->info + aux->info_size)
end = aux->info + aux->info_size;
for (dp = head + 8; dp < end;)
- dp = unw_decode (dp, in_body, & in_body);
+ dp = unw_decode (dp, in_body, & in_body, end);
}
free (aux->funtab);
+
+ return res;
}
static bfd_boolean
return TRUE;
}
-static void
+static bfd_boolean
ia64_process_unwind (FILE * file)
{
Elf_Internal_Shdr * sec;
Elf_Internal_Shdr * strsec;
unsigned long i, unwcount = 0, unwstart = 0;
struct ia64_unw_aux_info aux;
+ bfd_boolean res = TRUE;
memset (& aux, 0, sizeof (aux));
{
error (_("Multiple auxillary string tables encountered\n"));
free (aux.strtab);
+ res = FALSE;
}
aux.strtab = (char *) get_data (NULL, file, strsec->sh_offset,
1, strsec->sh_size,
free (aux.symtab);
if (aux.strtab)
free ((char *) aux.strtab);
+
+ return res;
}
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 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 * 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. */
- unsigned long nsyms; /* Number of symbols. */
- Elf_Internal_Sym * funtab; /* Sorted table of STT_FUNC symbols. */
- unsigned long nfuns; /* Number of entries in funtab. */
- char * strtab; /* The string table. */
- unsigned long strtab_size; /* Size of string 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. */
+ unsigned long nsyms; /* Number of symbols. */
+ Elf_Internal_Sym * funtab; /* Sorted table of STT_FUNC symbols. */
+ unsigned long nfuns; /* Number of entries in funtab. */
+ char * strtab; /* The string table. */
+ unsigned long strtab_size; /* Size of string table. */
};
-static void
+static bfd_boolean
dump_hppa_unwind (struct hppa_unw_aux_info * aux)
{
struct hppa_unw_table_entry * tp;
unsigned long j, nfuns;
+ bfd_boolean res = TRUE;
aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
for (nfuns = 0, j = 0; j < aux->nsyms; j++)
printf ("\n");
free (aux->funtab);
+
+ return res;
}
-static int
+static bfd_boolean
slurp_hppa_unwind_table (FILE * file,
struct hppa_unw_aux_info * aux,
Elf_Internal_Shdr * sec)
/* First, find the starting address of the segment that includes
this section. */
-
if (elf_header.e_phnum)
{
if (! get_program_headers (file))
- return 0;
+ return FALSE;
for (seg = program_headers;
seg < program_headers + elf_header.e_phnum;
table = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1, size,
_("unwind table"));
if (!table)
- return 0;
+ return FALSE;
unw_ent_size = 16;
nentries = size / unw_ent_size;
if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
& rela, & nrelas))
- return 0;
+ return FALSE;
for (rp = rela; rp < rela + nrelas; ++rp)
{
aux->table_len = nentries;
- return 1;
+ return TRUE;
}
-static void
+static bfd_boolean
hppa_process_unwind (FILE * file)
{
struct hppa_unw_aux_info aux;
Elf_Internal_Shdr * strsec;
Elf_Internal_Shdr * sec;
unsigned long i;
+ bfd_boolean res = TRUE;
if (string_table == NULL)
- return;
+ return FALSE;
memset (& aux, 0, sizeof (aux));
{
error (_("Multiple auxillary string tables encountered\n"));
free (aux.strtab);
+ res = FALSE;
}
aux.strtab = (char *) get_data (NULL, file, strsec->sh_offset,
1, strsec->sh_size,
(unsigned long) sec->sh_offset,
(unsigned long) (sec->sh_size / (2 * eh_addr_size + 8)));
- slurp_hppa_unwind_table (file, &aux, sec);
+ if (! slurp_hppa_unwind_table (file, &aux, sec))
+ res = FALSE;
+
if (aux.table_len > 0)
- dump_hppa_unwind (&aux);
+ {
+ if (! dump_hppa_unwind (&aux))
+ res = FALSE;
+ }
if (aux.table)
free ((char *) aux.table);
free (aux.symtab);
if (aux.strtab)
free ((char *) aux.strtab);
+
+ return res;
}
struct arm_section
return FALSE;
/* If the offset is invalid then fail. */
- if (word_offset > sec->sh_size - 4)
+ if (word_offset > (sec->sh_size - 4)
+ /* PR 18879 */
+ || (sec->sh_size < 5 && word_offset >= sec->sh_size)
+ || ((bfd_signed_vma) word_offset) < 0)
return FALSE;
/* Get the word at the required offset. */
data_offset += 4; \
if (! get_unwind_section_word (aux, data_arm_sec, data_sec, \
data_offset, & word, & addr, NULL)) \
- return; \
+ return FALSE; \
remaining = 4; \
more_words--; \
} \
else \
{ \
printf (_("[Truncated opcode]\n")); \
- return; \
+ return FALSE; \
} \
printf ("0x%02x ", OP)
-static void
+static bfd_boolean
decode_arm_unwind_bytecode (struct arm_unw_aux_info * aux,
unsigned int word,
unsigned int remaining,
struct arm_section * data_arm_sec)
{
struct absaddr addr;
+ bfd_boolean res = TRUE;
/* Decode the unwinding instructions. */
while (1)
else
{
unsigned int mask = ((op & 0x0f) << 8) | op2;
- int first = 1;
+ bfd_boolean first = TRUE;
int i;
printf ("pop {");
if (mask & (1 << i))
{
if (first)
- first = 0;
+ first = FALSE;
else
printf (", ");
printf ("r%d", 4 + i);
else if ((op & 0xf0) == 0xa0)
{
int end = 4 + (op & 0x07);
- int first = 1;
+ bfd_boolean first = TRUE;
int i;
printf (" pop {");
for (i = 4; i <= end; i++)
{
if (first)
- first = 0;
+ first = FALSE;
else
printf (", ");
printf ("r%d", i);
else
{
unsigned int mask = op2 & 0x0f;
- int first = 1;
+ bfd_boolean first = TRUE;
int i;
printf ("pop {");
if (mask & (1 << i))
{
if (first)
- first = 0;
+ first = FALSE;
else
printf (", ");
printf ("r%d", i);
break;
}
if (i == sizeof (buf))
- printf (_("corrupt change to vsp"));
+ {
+ error (_("corrupt change to vsp"));
+ res = FALSE;
+ }
else
{
offset = read_uleb128 (buf, &len, buf + i + 1);
else
{
unsigned int mask = op2 & 0x0f;
- int first = 1;
+ bfd_boolean first = TRUE;
int i;
printf ("pop {");
if (mask & (1 << i))
{
if (first)
- first = 0;
+ first = FALSE;
else
printf (", ");
printf ("wCGR%d", i);
}
}
else
- printf (_(" [unsupported opcode]"));
+ {
+ printf (_(" [unsupported opcode]"));
+ res = FALSE;
+ }
+
printf ("\n");
}
+
+ return res;
}
-static void
+static bfd_boolean
decode_tic6x_unwind_bytecode (struct arm_unw_aux_info * aux,
unsigned int word,
unsigned int remaining,
const char *name;
struct
{
- unsigned int offset;
- unsigned int reg;
+ unsigned int offset;
+ unsigned int reg;
} regpos[16];
/* Scan entire instruction first so that GET_OP output is not
/* PR 17531: file: id:000001,src:001906+004739,op:splice,rep:2. */
if (i == sizeof (buf))
{
- printf ("<corrupt sp adjust>\n");
warn (_("Corrupt stack pointer adjustment detected\n"));
- return;
+ return FALSE;
}
offset = read_uleb128 (buf, &len, buf + i + 1);
}
putchar ('\n');
}
+
+ return TRUE;
}
static bfd_vma
return offset + where;
}
-static void
+static bfd_boolean
decode_arm_unwind (struct arm_unw_aux_info * aux,
unsigned int word,
unsigned int remaining,
unsigned int more_words = 0;
struct absaddr addr;
bfd_vma sym_name = (bfd_vma) -1;
+ bfd_boolean res = FALSE;
if (remaining == 0)
{
the personality routine. */
if (! get_unwind_section_word (aux, data_arm_sec, data_sec, data_offset,
& word, & addr, & sym_name))
- return;
+ return FALSE;
remaining = 4;
}
if (!remaining)
{
printf (_(" [Truncated data]\n"));
- return;
+ return FALSE;
}
more_words = word >> 24;
word <<= 8;
per_index = -1;
}
else
- return;
+ return TRUE;
}
else
{
if (elf_header.e_machine == EM_ARM
&& (word & 0x70000000))
- warn (_("Corrupt ARM compact model table entry: %x \n"), word);
+ {
+ warn (_("Corrupt ARM compact model table entry: %x \n"), word);
+ res = FALSE;
+ }
per_index = (word >> 24) & 0x7f;
printf (_(" Compact model index: %d\n"), per_index);
case EM_ARM:
if (per_index < 3)
{
- decode_arm_unwind_bytecode (aux, word, remaining, more_words,
- data_offset, data_sec, data_arm_sec);
+ if (! decode_arm_unwind_bytecode (aux, word, remaining, more_words,
+ data_offset, data_sec, data_arm_sec))
+ res = FALSE;
}
else
{
warn (_("Unknown ARM compact model index encountered\n"));
printf (_(" [reserved]\n"));
+ res = FALSE;
}
break;
case EM_TI_C6000:
if (per_index < 3)
{
- decode_tic6x_unwind_bytecode (aux, word, remaining, more_words,
- data_offset, data_sec, data_arm_sec);
+ if (! decode_tic6x_unwind_bytecode (aux, word, remaining, more_words,
+ data_offset, data_sec, data_arm_sec))
+ res = FALSE;
}
else if (per_index < 5)
{
default:
error (_("Unsupported architecture type %d encountered when decoding unwind table\n"),
elf_header.e_machine);
+ res = FALSE;
}
/* Decode the descriptors. Not implemented. */
+
+ return res;
}
-static void
+static bfd_boolean
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;
unsigned long j, nfuns;
+ bfd_boolean res = TRUE;
memset (&exidx_arm_sec, 0, sizeof (exidx_arm_sec));
memset (&extab_arm_sec, 0, sizeof (extab_arm_sec));
free (aux->funtab);
arm_free_section (& exidx_arm_sec);
arm_free_section (& extab_arm_sec);
- return;
+ return FALSE;
}
/* ARM EHABI, Section 5:
An index table entry consists of 2 words.
The first word contains a prel31 offset to the start of a function, with bit 31 clear. */
if (exidx_fn & 0x80000000)
- warn (_("corrupt index table entry: %x\n"), exidx_fn);
+ {
+ warn (_("corrupt index table entry: %x\n"), exidx_fn);
+ res = FALSE;
+ }
fn = arm_expand_prel31 (exidx_fn, exidx_sec->sh_addr + 8 * i);
{
table_sec = section_headers + entry_addr.section;
table_offset = entry_addr.offset;
- }
+ /* PR 18879 */
+ if (table_offset > table_sec->sh_size
+ || ((bfd_signed_vma) table_offset) < 0)
+ {
+ warn (_("Unwind entry contains corrupt offset (0x%lx) into section %s\n"),
+ (unsigned long) table_offset,
+ printable_section_name (table_sec));
+ res = FALSE;
+ continue;
+ }
+ }
else
{
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);
+ res = FALSE;
continue;
}
- decode_arm_unwind (aux, 0, 0, table_offset, table_sec,
- &extab_arm_sec);
+
+ if (! decode_arm_unwind (aux, 0, 0, table_offset, table_sec,
+ &extab_arm_sec))
+ res = FALSE;
}
}
free (aux->funtab);
arm_free_section (&exidx_arm_sec);
arm_free_section (&extab_arm_sec);
+
+ return res;
}
/* Used for both ARM and C6X unwinding tables. */
-static void
+static bfd_boolean
arm_process_unwind (FILE *file)
{
struct arm_unw_aux_info aux;
Elf_Internal_Shdr *sec;
unsigned long i;
unsigned int sec_type;
+ bfd_boolean res = TRUE;
switch (elf_header.e_machine)
{
default:
error (_("Unsupported architecture type %d encountered when processing unwind table\n"),
elf_header.e_machine);
- return;
+ return FALSE;
}
if (string_table == NULL)
- return;
+ return FALSE;
memset (& aux, 0, sizeof (aux));
aux.file = file;
{
error (_("Multiple string tables found in file.\n"));
free (aux.strtab);
+ res = FALSE;
}
aux.strtab = get_data (NULL, file, strsec->sh_offset,
1, strsec->sh_size, _("string table"));
(unsigned long) sec->sh_offset,
(unsigned long) (sec->sh_size / (2 * eh_addr_size)));
- dump_arm_unwind (&aux, sec);
+ if (! dump_arm_unwind (&aux, sec))
+ res = FALSE;
}
}
free (aux.symtab);
if (aux.strtab)
free ((char *) aux.strtab);
+
+ return res;
}
-static void
+static bfd_boolean
process_unwind (FILE * file)
{
struct unwind_handler
{
- int machtype;
- void (* handler)(FILE *);
+ unsigned int machtype;
+ bfd_boolean (* handler)(FILE *);
} handlers[] =
{
{ EM_ARM, arm_process_unwind },
{ EM_IA_64, ia64_process_unwind },
{ EM_PARISC, hppa_process_unwind },
{ EM_TI_C6000, arm_process_unwind },
- { 0, 0 }
+ { 0, NULL }
};
int i;
if (!do_unwind)
- return;
+ return TRUE;
for (i = 0; handlers[i].handler != NULL; i++)
if (elf_header.e_machine == handlers[i].machtype)
- {
- handlers[i].handler (file);
- return;
- }
+ return handlers[i].handler (file);
printf (_("\nThe decoding of unwind sections for machine type %s is not currently supported.\n"),
get_machine_name (elf_header.e_machine));
+ return TRUE;
}
static void
"RLD_ORDER_SAFE"
};
unsigned int cnt;
- int first = 1;
+ bfd_boolean first = TRUE;
for (cnt = 0; cnt < ARRAY_SIZE (opts); ++cnt)
if (entry->d_un.d_val & (1 << cnt))
{
printf ("%s%s", first ? "" : " ", opts[cnt]);
- first = 0;
+ first = FALSE;
}
}
break;
case DT_MIPS_TIME_STAMP:
{
- char timebuf[20];
+ char timebuf[128];
struct tm * tmp;
time_t atime = entry->d_un.d_val;
case DT_MIPS_DELTA_SYM_NO:
case DT_MIPS_DELTA_CLASSSYM_NO:
case DT_MIPS_COMPACT_SIZE:
- print_vma (entry->d_un.d_ptr, DEC);
+ print_vma (entry->d_un.d_val, DEC);
break;
default:
{ DT_HP_GROUP, "HP_GROUP" },
{ DT_HP_PROTECT_LINKAGE_TABLE, "HP_PROTECT_LINKAGE_TABLE" }
};
- int first = 1;
+ bfd_boolean first = TRUE;
size_t cnt;
bfd_vma val = entry->d_un.d_val;
if (! first)
putchar (' ');
fputs (flags[cnt].str, stdout);
- first = 0;
+ first = FALSE;
val ^= flags[cnt].bit;
}
putchar ('\n');
}
-static int
+static bfd_boolean
get_32bit_dynamic_section (FILE * file)
{
Elf32_External_Dyn * edyn;
edyn = (Elf32_External_Dyn *) get_data (NULL, file, dynamic_addr, 1,
dynamic_size, _("dynamic section"));
if (!edyn)
- return 0;
+ return FALSE;
/* 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 - sizeof (* entry);
+ (char *) (ext + 1) <= (char *) edyn + dynamic_size;
ext++)
{
dynamic_nent++;
error (_("Out of memory allocating space for %lu dynamic entries\n"),
(unsigned long) dynamic_nent);
free (edyn);
- return 0;
+ return FALSE;
}
for (ext = edyn, entry = dynamic_section;
free (edyn);
- return 1;
+ return TRUE;
}
-static int
+static bfd_boolean
get_64bit_dynamic_section (FILE * file)
{
Elf64_External_Dyn * edyn;
edyn = (Elf64_External_Dyn *) get_data (NULL, file, dynamic_addr, 1,
dynamic_size, _("dynamic section"));
if (!edyn)
- return 0;
+ return FALSE;
/* 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;
- /* PR 17533 file: 033-67080-0.004 - do not read off the end of the buffer. */
- (char *) ext < ((char *) edyn) + dynamic_size - sizeof (* ext);
+ /* PR 17533 file: 033-67080-0.004 - do not read past end of buffer. */
+ (char *) (ext + 1) <= (char *) edyn + dynamic_size;
ext++)
{
dynamic_nent++;
error (_("Out of memory allocating space for %lu dynamic entries\n"),
(unsigned long) dynamic_nent);
free (edyn);
- return 0;
+ return FALSE;
}
/* Convert from external to internal formats. */
free (edyn);
- return 1;
+ return TRUE;
}
static void
print_dynamic_flags (bfd_vma flags)
{
- int first = 1;
+ bfd_boolean first = TRUE;
while (flags)
{
flags &= ~ flag;
if (first)
- first = 0;
+ first = FALSE;
else
putc (' ', stdout);
/* Parse and display the contents of the dynamic section. */
-static int
+static bfd_boolean
process_dynamic_section (FILE * file)
{
Elf_Internal_Dyn * entry;
if (do_dynamic)
printf (_("\nThere is no dynamic section in this file.\n"));
- return 1;
+ return TRUE;
}
if (is_32bit_elf)
{
if (! get_32bit_dynamic_section (file))
- return 0;
+ return FALSE;
+ }
+ else
+ {
+ if (! get_64bit_dynamic_section (file))
+ return FALSE;
}
- else if (! get_64bit_dynamic_section (file))
- return 0;
/* Find the appropriate symbol table. */
if (dynamic_symbols == NULL)
get_data (NULL, file, dynamic_syminfo_offset, 1, syminsz,
_("symbol information"));
if (!extsyminfo)
- return 0;
+ return FALSE;
dynamic_syminfo = (Elf_Internal_Syminfo *) malloc (syminsz);
if (dynamic_syminfo == NULL)
{
error (_("Out of memory allocating %lu byte for dynamic symbol info\n"),
(unsigned long) syminsz);
- return 0;
+ return FALSE;
}
dynamic_syminfo_nent = syminsz / sizeof (Elf_External_Syminfo);
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)),
- " ");
+ ((is_32bit_elf ? 27 : 19) - (int) strlen (dtype)), " ");
}
switch (entry->d_tag)
printf (" SINGLETON");
val ^= DF_1_SINGLETON;
}
+ if (val & DF_1_STUB)
+ {
+ printf (" STUB");
+ val ^= DF_1_STUB;
+ }
+ if (val & DF_1_PIE)
+ {
+ printf (" PIE");
+ val ^= DF_1_PIE;
+ }
if (val != 0)
printf (" %lx", val);
puts ("");
case DT_SYMENT :
case DT_RELENT :
dynamic_info[entry->d_tag] = entry->d_un.d_val;
+ /* Fall through. */
case DT_PLTPADSZ:
case DT_MOVEENT :
case DT_MOVESZ :
}
}
- return 1;
+ return TRUE;
}
static char *
return _("none");
if (flags & VER_FLG_BASE)
- strcat (buff, "BASE ");
+ strcat (buff, "BASE");
if (flags & VER_FLG_WEAK)
{
if (flags & VER_FLG_BASE)
- strcat (buff, "| ");
+ strcat (buff, " | ");
- strcat (buff, "WEAK ");
+ strcat (buff, "WEAK");
}
if (flags & VER_FLG_INFO)
{
if (flags & (VER_FLG_BASE|VER_FLG_WEAK))
- strcat (buff, "| ");
+ strcat (buff, " | ");
- strcat (buff, "INFO ");
+ strcat (buff, "INFO");
}
if (flags & ~(VER_FLG_BASE | VER_FLG_WEAK | VER_FLG_INFO))
- strcat (buff, _("| <unknown>"));
+ {
+ if (flags & (VER_FLG_BASE | VER_FLG_WEAK | VER_FLG_INFO))
+ strcat (buff, " | ");
+
+ strcat (buff, _("<unknown>"));
+ }
return buff;
}
/* Display the contents of the version sections. */
-static int
+static bfd_boolean
process_version_sections (FILE * file)
{
Elf_Internal_Shdr * section;
unsigned i;
- int found = 0;
+ bfd_boolean found = FALSE;
if (! do_version)
- return 1;
+ return TRUE;
for (i = 0, section = section_headers;
i < elf_header.e_shnum;
Elf_External_Verdef * edefs;
unsigned int idx;
unsigned int cnt;
+ unsigned int end;
char * endbuf;
- found = 1;
+ found = TRUE;
printf (_("\nVersion definition section '%s' contains %u entries:\n"),
printable_section_name (section),
printf (_(" Addr: 0x"));
printf_vma (section->sh_addr);
- printf (_(" Offset: %#08lx Link: %u (%s)"),
+ printf (_(" Offset: %#08lx Link: %u (%s)\n"),
(unsigned long) section->sh_offset, section->sh_link,
printable_section_name_from_index (section->sh_link));
break;
endbuf = (char *) edefs + section->sh_size;
- for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
+ /* PR 17531: file: id:000001,src:000172+005151,op:splice,rep:2. */
+ end = (section->sh_info < section->sh_size
+ ? section->sh_info : section->sh_size);
+ for (idx = cnt = 0; cnt < end; ++cnt)
{
char * vstart;
Elf_External_Verdef * edef;
Elf_Internal_Verdef ent;
Elf_External_Verdaux * eaux;
Elf_Internal_Verdaux aux;
+ unsigned int isum;
int j;
- int isum;
- /* Check for very large indicies. */
+ /* Check for very large indices. */
if (idx > (size_t) (endbuf - (char *) edefs))
break;
ent.vd_ndx, ent.vd_cnt);
/* Check for overflow. */
- if (ent.vd_aux > (size_t) (endbuf - vstart))
+ if (ent.vd_aux + sizeof (* eaux) > (size_t) (endbuf - vstart))
break;
vstart += ent.vd_aux;
if (j < ent.vd_cnt)
printf (_(" Version def aux past end of section\n"));
- /* PR 17531: file: id:000001,src:000172+005151,op:splice,rep:2. */
- if (idx + ent.vd_next <= idx)
+ /* PR 17531:
+ file: id:000001,src:000172+005151,op:splice,rep:2. */
+ if (idx + ent.vd_next < idx)
break;
idx += ent.vd_next;
unsigned int cnt;
char * endbuf;
- found = 1;
+ found = TRUE;
printf (_("\nVersion needs section '%s' contains %u entries:\n"),
printable_section_name (section), section->sh_info);
{
Elf_External_Verneed * entry;
Elf_Internal_Verneed ent;
+ unsigned int isum;
int j;
- int isum;
char * vstart;
if (idx > (size_t) (endbuf - (char *) eneed))
if (link_section->sh_link >= elf_header.e_shnum)
break;
- found = 1;
+ found = TRUE;
symbols = GET_ELF_SYMBOLS (file, link_section, & num_syms);
if (symbols == NULL)
for (cnt = 0; cnt < total; cnt += 4)
{
int j, nn;
- int check_def, check_need;
- char * name;
+ char *name;
+ char *invalid = _("*invalid*");
printf (" %03x:", cnt);
break;
}
- 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;
- }
-
- if (check_need
- && version_info[DT_VERSIONTAGIDX (DT_VERNEED)])
+ name = NULL;
+ if (version_info[DT_VERSIONTAGIDX (DT_VERNEED)])
{
Elf_Internal_Verneed ivn;
unsigned long offset;
ivna.vna_name = BYTE_GET (evna.vna_name);
if (ivna.vna_name >= string_sec->sh_size)
- name = _("*invalid*");
+ name = invalid;
else
name = strtab + ivna.vna_name;
- nn += printf ("(%s%-*s",
- name,
- 12 - (int) strlen (name),
- ")");
- check_def = 0;
break;
}
while (ivn.vn_next);
}
- if (check_def && data[cnt + j] != 0x8001
+ if (data[cnt + j] != 0x8001
&& version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
{
Elf_Internal_Verdef ivd;
ivda.vda_name = BYTE_GET (evda.vda_name);
if (ivda.vda_name >= string_sec->sh_size)
- name = _("*invalid*");
+ name = invalid;
+ else if (name != NULL && name != invalid)
+ name = _("*both*");
else
name = strtab + ivda.vda_name;
- nn += printf ("(%s%-*s",
- name,
- 12 - (int) strlen (name),
- ")");
}
}
+ if (name != NULL)
+ nn += printf ("(%s%-*s",
+ name,
+ 12 - (int) strlen (name),
+ ")");
if (nn < 18)
printf ("%*c", 18 - nn, ' ');
if (! found)
printf (_("\nNo version information found in this file.\n"));
- return 1;
+ return TRUE;
}
static const char *
}
}
+static const char *
+get_solaris_symbol_visibility (unsigned int visibility)
+{
+ switch (visibility)
+ {
+ case 4: return "EXPORTED";
+ case 5: return "SINGLETON";
+ case 6: return "ELIMINATE";
+ default: return get_symbol_visibility (visibility);
+ }
+}
+
static const char *
get_mips_symbol_other (unsigned int other)
{
switch (other)
{
- case STO_OPTIONAL:
- return "OPTIONAL";
- case STO_MIPS_PLT:
- return "MIPS PLT";
- case STO_MIPS_PIC:
- return "MIPS PIC";
- case STO_MICROMIPS:
- return "MICROMIPS";
- case STO_MICROMIPS | STO_MIPS_PIC:
- return "MICROMIPS, MIPS PIC";
- case STO_MIPS16:
- return "MIPS16";
- default:
- return NULL;
+ case STO_OPTIONAL: return "OPTIONAL";
+ case STO_MIPS_PLT: return "MIPS PLT";
+ case STO_MIPS_PIC: return "MIPS PIC";
+ case STO_MICROMIPS: return "MICROMIPS";
+ case STO_MICROMIPS | STO_MIPS_PIC: return "MICROMIPS, MIPS PIC";
+ case STO_MIPS16: return "MIPS16";
+ default: return NULL;
}
}
result = get_ppc64_symbol_other (other);
break;
default:
+ result = NULL;
break;
}
if (sizeof (size_t) < sizeof (bfd_size_type)
&& (bfd_size_type) ((size_t) number) != number)
{
- error (_("Size truncation prevents reading %llu elements of size %u\n"),
- (unsigned long long) number, ent_size);
+ error (_("Size truncation prevents reading %" BFD_VMA_FMT "u"
+ " elements of size %u\n"),
+ number, ent_size);
return NULL;
}
attempting to allocate memory when the read is bound to fail. */
if (ent_size * number > current_file_size)
{
- error (_("Invalid number of dynamic entries: %llu\n"),
- (unsigned long long) number);
+ error (_("Invalid number of dynamic entries: %" BFD_VMA_FMT "u\n"),
+ number);
return NULL;
}
e_data = (unsigned char *) cmalloc ((size_t) number, ent_size);
if (e_data == NULL)
{
- error (_("Out of memory reading %llu dynamic entries\n"),
- (unsigned long long) number);
+ error (_("Out of memory reading %" BFD_VMA_FMT "u dynamic entries\n"),
+ number);
return NULL;
}
if (fread (e_data, ent_size, (size_t) number, file) != number)
{
- error (_("Unable to read in %llu bytes of dynamic data\n"),
- (unsigned long long) (number * ent_size));
+ error (_("Unable to read in %" BFD_VMA_FMT "u bytes of dynamic data\n"),
+ number * ent_size);
free (e_data);
return NULL;
}
i_data = (bfd_vma *) cmalloc ((size_t) number, sizeof (*i_data));
if (i_data == NULL)
{
- error (_("Out of memory allocating space for %llu dynamic entries\n"),
- (unsigned long long) number);
+ error (_("Out of memory allocating space for %" BFD_VMA_FMT "u"
+ " dynamic entries\n"),
+ number);
free (e_data);
return NULL;
}
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)));
+
+ if (elf_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
+ printf (" %-7s", get_solaris_symbol_visibility (psym->st_other));
+ else
+ {
+ unsigned int vis = ELF_ST_VISIBILITY (psym->st_other);
+
+ printf (" %-7s", get_symbol_visibility (vis));
+ /* 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 ^ vis)
+ printf (" [%s] ", get_symbol_other (psym->st_other ^ vis));
+ }
+
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));
}
static const char *
-get_symbol_version_string (FILE *file, int is_dynsym,
- const char *strtab,
- unsigned long int strtab_size,
- unsigned int si, Elf_Internal_Sym *psym,
- enum versioned_symbol_info *sym_info,
- unsigned short *vna_other)
+get_symbol_version_string (FILE * file,
+ bfd_boolean is_dynsym,
+ const char * strtab,
+ unsigned long int strtab_size,
+ unsigned int si,
+ Elf_Internal_Sym * psym,
+ enum versioned_symbol_info * sym_info,
+ unsigned short * vna_other)
{
- const char *version_string = NULL;
+ unsigned char data[2];
+ unsigned short vers_data;
+ unsigned long offset;
- if (is_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;
+ if (!is_dynsym
+ || version_info[DT_VERSIONTAGIDX (DT_VERSYM)] == 0)
+ return NULL;
+
+ offset = offset_from_vma (file, version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
+ sizeof data + si * sizeof (vers_data));
- offset = offset_from_vma
- (file, version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
- sizeof data + si * sizeof (vers_data));
+ if (get_data (&data, file, offset + si * sizeof (vers_data),
+ sizeof (data), 1, _("version data")) == NULL)
+ return NULL;
+
+ vers_data = byte_get (data, 2);
- if (get_data (&data, file, offset + si * sizeof (vers_data),
- sizeof (data), 1, _("version data")) == NULL)
- return NULL;
+ if ((vers_data & VERSYM_HIDDEN) == 0 && vers_data <= 1)
+ return NULL;
- vers_data = byte_get (data, 2);
+ /* Usually we'd only see verdef for defined symbols, and verneed for
+ undefined symbols. However, symbols defined by the linker in
+ .dynbss for variables copied from a shared library in order to
+ avoid text relocations are defined yet have verneed. We could
+ use a heuristic to detect the special case, for example, check
+ for verneed first on symbols defined in SHT_NOBITS sections, but
+ it is simpler and more reliable to just look for both verdef and
+ verneed. .dynbss might not be mapped to a SHT_NOBITS section. */
- is_nobits = (section_headers != NULL
- && psym->st_shndx < elf_header.e_shnum
- && section_headers[psym->st_shndx].sh_type
- == SHT_NOBITS);
+ if (psym->st_shndx != SHN_UNDEF
+ && vers_data != 0x8001
+ && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
+ {
+ Elf_Internal_Verdef ivd;
+ Elf_Internal_Verdaux ivda;
+ Elf_External_Verdaux evda;
+ unsigned long off;
- check_def = (psym->st_shndx != SHN_UNDEF);
+ off = offset_from_vma (file,
+ version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
+ sizeof (Elf_External_Verdef));
- if ((vers_data & VERSYM_HIDDEN) || vers_data > 1)
+ do
{
- if (version_info[DT_VERSIONTAGIDX (DT_VERNEED)]
- && (is_nobits || ! check_def))
+ Elf_External_Verdef evd;
+
+ if (get_data (&evd, file, off, sizeof (evd), 1,
+ _("version def")) == NULL)
+ {
+ ivd.vd_ndx = 0;
+ ivd.vd_aux = 0;
+ ivd.vd_next = 0;
+ }
+ else
{
- Elf_External_Verneed evn;
- Elf_Internal_Verneed ivn;
- Elf_Internal_Vernaux ivna;
+ ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
+ ivd.vd_aux = BYTE_GET (evd.vd_aux);
+ ivd.vd_next = BYTE_GET (evd.vd_next);
+ }
- /* We must test both. */
- offset = offset_from_vma
- (file, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
- sizeof evn);
+ off += ivd.vd_next;
+ }
+ while (ivd.vd_ndx != (vers_data & VERSYM_VERSION) && ivd.vd_next != 0);
- do
- {
- unsigned long vna_off;
+ if (ivd.vd_ndx == (vers_data & VERSYM_VERSION))
+ {
+ off -= ivd.vd_next;
+ off += ivd.vd_aux;
- if (get_data (&evn, file, offset, sizeof (evn), 1,
- _("version need")) == NULL)
- {
- ivna.vna_next = 0;
- ivna.vna_other = 0;
- ivna.vna_name = 0;
- break;
- }
+ if (get_data (&evda, file, off, sizeof (evda), 1,
+ _("version def aux")) != NULL)
+ {
+ ivda.vda_name = BYTE_GET (evda.vda_name);
- ivn.vn_aux = BYTE_GET (evn.vn_aux);
- ivn.vn_next = BYTE_GET (evn.vn_next);
+ if (psym->st_name != ivda.vda_name)
+ {
+ *sym_info = ((vers_data & VERSYM_HIDDEN) != 0
+ ? symbol_hidden : symbol_public);
+ return (ivda.vda_name < strtab_size
+ ? strtab + ivda.vda_name : _("<corrupt>"));
+ }
+ }
+ }
+ }
- vna_off = offset + ivn.vn_aux;
+ if (version_info[DT_VERSIONTAGIDX (DT_VERNEED)])
+ {
+ Elf_External_Verneed evn;
+ Elf_Internal_Verneed ivn;
+ Elf_Internal_Vernaux ivna;
- do
- {
- Elf_External_Vernaux evna;
+ offset = offset_from_vma (file,
+ version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
+ sizeof evn);
+ do
+ {
+ unsigned long vna_off;
- if (get_data (&evna, file, vna_off,
- sizeof (evna), 1,
- _("version need aux (3)")) == NULL)
- {
- ivna.vna_next = 0;
- ivna.vna_other = 0;
- ivna.vna_name = 0;
- }
- else
- {
- ivna.vna_other = BYTE_GET (evna.vna_other);
- ivna.vna_next = BYTE_GET (evna.vna_next);
- ivna.vna_name = BYTE_GET (evna.vna_name);
- }
+ if (get_data (&evn, file, offset, sizeof (evn), 1,
+ _("version need")) == NULL)
+ {
+ ivna.vna_next = 0;
+ ivna.vna_other = 0;
+ ivna.vna_name = 0;
+ break;
+ }
- vna_off += ivna.vna_next;
- }
- while (ivna.vna_other != vers_data
- && ivna.vna_next != 0);
+ ivn.vn_aux = BYTE_GET (evn.vn_aux);
+ ivn.vn_next = BYTE_GET (evn.vn_next);
- if (ivna.vna_other == vers_data)
- break;
+ vna_off = offset + ivn.vn_aux;
- offset += ivn.vn_next;
- }
- while (ivn.vn_next != 0);
+ do
+ {
+ Elf_External_Vernaux evna;
- if (ivna.vna_other == vers_data)
+ if (get_data (&evna, file, vna_off, sizeof (evna), 1,
+ _("version need aux (3)")) == NULL)
{
- *sym_info = symbol_undefined;
- *vna_other = ivna.vna_other;
- version_string = (ivna.vna_name < strtab_size
- ? strtab + ivna.vna_name
- : _("<corrupt>"));
- check_def = 0;
+ ivna.vna_next = 0;
+ ivna.vna_other = 0;
+ ivna.vna_name = 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;
-
- if (get_data (&evd, file, off, sizeof (evd),
- 1, _("version def")) == NULL)
- {
- ivd.vd_ndx = 0;
- ivd.vd_aux = 0;
- ivd.vd_next = 0;
- }
- else
- {
- 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);
+ ivna.vna_other = BYTE_GET (evna.vna_other);
+ ivna.vna_next = BYTE_GET (evna.vna_next);
+ ivna.vna_name = BYTE_GET (evna.vna_name);
+ }
- off -= ivd.vd_next;
- off += ivd.vd_aux;
+ vna_off += ivna.vna_next;
+ }
+ while (ivna.vna_other != vers_data && ivna.vna_next != 0);
- if (get_data (&evda, file, off, sizeof (evda),
- 1, _("version def aux")) == NULL)
- return version_string;
+ if (ivna.vna_other == vers_data)
+ break;
- ivda.vda_name = BYTE_GET (evda.vda_name);
+ offset += ivn.vn_next;
+ }
+ while (ivn.vn_next != 0);
- if (psym->st_name != ivda.vda_name)
- {
- *sym_info = ((vers_data & VERSYM_HIDDEN) != 0
- ? symbol_hidden : symbol_public);
- version_string = (ivda.vda_name < strtab_size
- ? strtab + ivda.vda_name
- : _("<corrupt>"));
- }
- }
- }
+ if (ivna.vna_other == vers_data)
+ {
+ *sym_info = symbol_undefined;
+ *vna_other = ivna.vna_other;
+ return (ivna.vna_name < strtab_size
+ ? strtab + ivna.vna_name : _("<corrupt>"));
}
}
- return version_string;
+ return NULL;
}
/* Dump the symbol table. */
-static int
+static bfd_boolean
process_symbol_table (FILE * file)
{
Elf_Internal_Shdr * section;
bfd_size_type ngnuchains = 0;
if (!do_syms && !do_dyn_syms && !do_histogram)
- return 1;
+ return TRUE;
if (dynamic_info[DT_HASH]
&& (do_histogram
if (buckets == NULL || chains == NULL)
{
if (do_using_dynamic)
- return 0;
+ return FALSE;
free (buckets);
free (chains);
buckets = NULL;
if (gnubuckets[i] != 0)
{
if (gnubuckets[i] < gnusymidx)
- return 0;
+ return FALSE;
if (maxchain == 0xffffffff || gnubuckets[i] > maxchain)
maxchain = gnubuckets[i];
gnubuckets = NULL;
ngnubuckets = 0;
if (do_using_dynamic)
- return 0;
+ return FALSE;
}
}
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)));
+ if (elf_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
+ printf (" %-7s", get_solaris_symbol_visibility (psym->st_other));
+ else
+ {
+ unsigned int vis = ELF_ST_VISIBILITY (psym->st_other);
+
+ printf (" %-7s", get_symbol_visibility (vis));
+ /* 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 ^ vis)
+ printf (" [%s] ", get_symbol_other (psym->st_other ^ vis));
+ }
printf (" %4s ", get_symbol_index_type (psym->st_shndx));
print_symbol (25, psym->st_name < strtab_size
? strtab + psym->st_name : _("<corrupt>"));
}
putchar ('\n');
+
+ if (ELF_ST_BIND (psym->st_info) == STB_LOCAL
+ && si >= section->sh_info
+ /* Irix 5 and 6 MIPS binaries are known to ignore this requirement. */
+ && elf_header.e_machine != EM_MIPS
+ /* Solaris binaries have been found to violate this requirement as
+ well. Not sure if this is a bug or an ABI requirement. */
+ && elf_header.e_ident[EI_OSABI] != ELFOSABI_SOLARIS)
+ warn (_("local symbol %u found at index >= %s's sh_info value of %u\n"),
+ si, printable_section_name (section), section->sh_info);
}
free (symtab);
if (lengths == NULL)
{
error (_("Out of memory allocating space for histogram buckets\n"));
- return 0;
+ return FALSE;
}
printf (_(" Length Number %% of total Coverage\n"));
{
free (lengths);
error (_("Out of memory allocating space for histogram counts\n"));
- return 0;
+ return FALSE;
}
for (hn = 0; hn < nbuckets; ++hn)
if (lengths == NULL)
{
error (_("Out of memory allocating space for gnu histogram buckets\n"));
- return 0;
+ return FALSE;
}
printf (_(" Length Number %% of total Coverage\n"));
{
free (lengths);
error (_("Out of memory allocating space for gnu histogram counts\n"));
- return 0;
+ return FALSE;
}
for (hn = 0; hn < ngnubuckets; ++hn)
free (gnuchains);
}
- return 1;
+ return TRUE;
}
-static int
+static bfd_boolean
process_syminfo (FILE * file ATTRIBUTE_UNUSED)
{
unsigned int i;
if (dynamic_syminfo == NULL
|| !do_dynamic)
/* No syminfo, this is ok. */
- return 1;
+ return TRUE;
/* There better should be a dynamic symbol section. */
if (dynamic_symbols == NULL || dynamic_strings == NULL)
- return 0;
+ return FALSE;
if (dynamic_addr)
printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
puts ("");
}
- return 1;
+ return TRUE;
}
+#define IN_RANGE(START,END,ADDR,OFF) \
+ (((ADDR) >= (START)) && ((ADDR) + (OFF) < (END)))
+
/* 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. */
+ FALSE.
+
+ If called with reloc == NULL, then this is a signal that reloc processing
+ for the current section has finished, and any saved state should be
+ discarded. */
static bfd_boolean
target_specific_reloc_handling (Elf_Internal_Rela * reloc,
unsigned char * start,
- Elf_Internal_Sym * symtab)
+ unsigned char * end,
+ Elf_Internal_Sym * symtab,
+ unsigned long num_syms)
{
- unsigned int reloc_type = get_reloc_type (reloc->r_info);
+ unsigned int reloc_type = 0;
+ unsigned long sym_index = 0;
+
+ if (reloc)
+ {
+ reloc_type = get_reloc_type (reloc->r_info);
+ sym_index = get_reloc_symindex (reloc->r_info);
+ }
switch (elf_header.e_machine)
{
{
static Elf_Internal_Sym * saved_sym = NULL;
+ if (reloc == NULL)
+ {
+ saved_sym = NULL;
+ return TRUE;
+ }
+
switch (reloc_type)
{
case 10: /* R_MSP430_SYM_DIFF */
if (uses_msp430x_relocs ())
break;
+ /* Fall through. */
case 21: /* R_MSP430X_SYM_DIFF */
- saved_sym = symtab + get_reloc_symindex (reloc->r_info);
+ /* PR 21139. */
+ if (sym_index >= num_syms)
+ error (_("MSP430 SYM_DIFF reloc contains invalid symbol index %lu\n"),
+ sym_index);
+ else
+ saved_sym = symtab + sym_index;
return TRUE;
case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
handle_sym_diff:
if (saved_sym != NULL)
{
+ int reloc_size = reloc_type == 1 ? 4 : 2;
bfd_vma value;
- value = reloc->r_addend
- + (symtab[get_reloc_symindex (reloc->r_info)].st_value
- - saved_sym->st_value);
+ if (sym_index >= num_syms)
+ error (_("MSP430 reloc contains invalid symbol index %lu\n"),
+ sym_index);
+ else
+ {
+ value = reloc->r_addend + (symtab[sym_index].st_value
+ - saved_sym->st_value);
- byte_put (start + reloc->r_offset, value, reloc_type == 1 ? 4 : 2);
+ if (IN_RANGE (start, end, start + reloc->r_offset, reloc_size))
+ byte_put (start + reloc->r_offset, value, reloc_size);
+ else
+ /* PR 21137 */
+ error (_("MSP430 sym diff reloc contains invalid offset: 0x%lx\n"),
+ (long) reloc->r_offset);
+ }
saved_sym = NULL;
return TRUE;
{
static Elf_Internal_Sym * saved_sym = NULL;
+ if (reloc == NULL)
+ {
+ saved_sym = NULL;
+ return TRUE;
+ }
+
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);
+ if (sym_index >= num_syms)
+ error (_("MN10300_SYM_DIFF reloc contains invalid symbol index %lu\n"),
+ sym_index);
+ else
+ saved_sym = symtab + sym_index;
return TRUE;
+
case 1: /* R_MN10300_32 */
case 2: /* R_MN10300_16 */
if (saved_sym != NULL)
{
+ int reloc_size = reloc_type == 1 ? 4 : 2;
bfd_vma value;
- value = reloc->r_addend
- + (symtab[get_reloc_symindex (reloc->r_info)].st_value
- - saved_sym->st_value);
+ if (sym_index >= num_syms)
+ error (_("MN10300 reloc contains invalid symbol index %lu\n"),
+ sym_index);
+ else
+ {
+ value = reloc->r_addend + (symtab[sym_index].st_value
+ - saved_sym->st_value);
- byte_put (start + reloc->r_offset, value, reloc_type == 1 ? 4 : 2);
+ if (IN_RANGE (start, end, start + reloc->r_offset, reloc_size))
+ byte_put (start + reloc->r_offset, value, reloc_size);
+ else
+ error (_("MN10300 sym diff reloc contains invalid offset: 0x%lx\n"),
+ (long) reloc->r_offset);
+ }
saved_sym = NULL;
return TRUE;
static bfd_vma saved_sym2 = 0;
static bfd_vma value;
+ if (reloc == NULL)
+ {
+ saved_sym1 = saved_sym2 = 0;
+ return TRUE;
+ }
+
switch (reloc_type)
{
case 0x80: /* R_RL78_SYM. */
saved_sym1 = saved_sym2;
- saved_sym2 = symtab[get_reloc_symindex (reloc->r_info)].st_value;
- saved_sym2 += reloc->r_addend;
+ if (sym_index >= num_syms)
+ error (_("RL78_SYM reloc contains invalid symbol index %lu\n"),
+ sym_index);
+ else
+ {
+ saved_sym2 = symtab[sym_index].st_value;
+ saved_sym2 += reloc->r_addend;
+ }
return TRUE;
case 0x83: /* R_RL78_OPsub. */
break;
case 0x41: /* R_RL78_ABS32. */
- byte_put (start + reloc->r_offset, value, 4);
+ if (IN_RANGE (start, end, start + reloc->r_offset, 4))
+ byte_put (start + reloc->r_offset, value, 4);
+ else
+ error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
+ (long) reloc->r_offset);
value = 0;
return TRUE;
case 0x43: /* R_RL78_ABS16. */
- byte_put (start + reloc->r_offset, value, 2);
+ if (IN_RANGE (start, end, start + reloc->r_offset, 2))
+ byte_put (start + reloc->r_offset, value, 2);
+ else
+ error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
+ (long) reloc->r_offset);
value = 0;
return TRUE;
static bfd_boolean
is_32bit_abs_reloc (unsigned int reloc_type)
{
+ /* Please keep this table alpha-sorted for ease of visual lookup. */
switch (elf_header.e_machine)
{
case EM_386:
- case EM_486:
+ case EM_IAMCU:
return reloc_type == 1; /* R_386_32. */
case EM_68K:
return reloc_type == 1; /* R_68K_32. */
case EM_960:
return reloc_type == 2; /* R_960_32. */
case EM_AARCH64:
- return reloc_type == 258; /* R_AARCH64_ABS32 */
+ return (reloc_type == 258
+ || reloc_type == 1); /* R_AARCH64_ABS32 || R_AARCH64_P32_ABS32 */
+ case EM_ADAPTEVA_EPIPHANY:
+ return reloc_type == 3;
case EM_ALPHA:
return reloc_type == 1; /* R_ALPHA_REFLONG. */
case EM_ARC:
return reloc_type == 1; /* R_ARC_32. */
+ case EM_ARC_COMPACT:
+ case EM_ARC_COMPACT2:
+ return reloc_type == 4; /* 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_ADAPTEVA_EPIPHANY:
- return reloc_type == 3;
case EM_BLACKFIN:
return reloc_type == 0x12; /* R_byte4_data. */
case EM_CRIS:
case EM_H8_300H:
return reloc_type == 1; /* R_H8_DIR32. */
case EM_IA_64:
- return reloc_type == 0x65; /* R_IA64_SECREL32LSB. */
+ return reloc_type == 0x65 /* R_IA64_SECREL32LSB. */
+ || reloc_type == 0x25; /* R_IA64_DIR32LSB. */
case EM_IP2K_OLD:
case EM_IP2K:
return reloc_type == 2; /* R_IP2K_32. */
return reloc_type == 3; /* R_M32C_32. */
case EM_M32R:
return reloc_type == 34; /* R_M32R_32_RELA. */
+ case EM_68HC11:
+ case EM_68HC12:
+ return reloc_type == 6; /* R_M68HC11_32. */
case EM_MCORE:
return reloc_type == 1; /* R_MCORE_ADDR32. */
case EM_CYGNUS_MEP:
return reloc_type == 1; /* R_PPC64_ADDR32. */
case EM_PPC:
return reloc_type == 1; /* R_PPC_ADDR32. */
+ case EM_TI_PRU:
+ return reloc_type == 11; /* R_PRU_BFD_RELOC_32. */
+ case EM_RISCV:
+ return reloc_type == 1; /* R_RISCV_32. */
case EM_RL78:
return reloc_type == 1; /* R_RL78_DIR32. */
case EM_RX:
is_32bit_pcrel_reloc (unsigned int reloc_type)
{
switch (elf_header.e_machine)
+ /* Please keep this table alpha-sorted for ease of visual lookup. */
{
case EM_386:
- case EM_486:
+ case EM_IAMCU:
return reloc_type == 2; /* R_386_PC32. */
case EM_68K:
return reloc_type == 4; /* R_68K_PC32. */
return reloc_type == 6;
case EM_ALPHA:
return reloc_type == 10; /* R_ALPHA_SREL32. */
+ case EM_ARC_COMPACT:
+ case EM_ARC_COMPACT2:
+ return reloc_type == 49; /* R_ARC_32_PCREL. */
case EM_ARM:
return reloc_type == 3; /* R_ARM_REL32 */
+ case EM_AVR_OLD:
+ case EM_AVR:
+ return reloc_type == 36; /* R_AVR_32_PCREL. */
case EM_MICROBLAZE:
return reloc_type == 2; /* R_MICROBLAZE_32_PCREL. */
case EM_OR1K:
return reloc_type == 80; /* R_PARISC_DIR64. */
case EM_PPC64:
return reloc_type == 38; /* R_PPC64_ADDR64. */
+ case EM_RISCV:
+ return reloc_type == 2; /* R_RISCV_64. */
case EM_SPARC32PLUS:
case EM_SPARCV9:
case EM_SPARC:
case EM_CYGNUS_MN10200:
case EM_MN10200:
return reloc_type == 4; /* R_MN10200_24. */
+ case EM_FT32:
+ return reloc_type == 5; /* R_FT32_20. */
default:
return FALSE;
}
static bfd_boolean
is_16bit_abs_reloc (unsigned int reloc_type)
{
+ /* Please keep this table alpha-sorted for ease of visual lookup. */
switch (elf_header.e_machine)
{
+ case EM_ARC:
+ case EM_ARC_COMPACT:
+ case EM_ARC_COMPACT2:
+ return reloc_type == 2; /* R_ARC_16. */
+ case EM_ADAPTEVA_EPIPHANY:
+ return reloc_type == 5;
case EM_AVR_OLD:
case EM_AVR:
return reloc_type == 4; /* R_AVR_16. */
- case EM_ADAPTEVA_EPIPHANY:
- return reloc_type == 5;
case EM_CYGNUS_D10V:
case EM_D10V:
return reloc_type == 3; /* R_D10V_16. */
case EM_M32C_OLD:
case EM_M32C:
return reloc_type == 1; /* R_M32C_16 */
+ case EM_CYGNUS_MN10200:
+ case EM_MN10200:
+ return reloc_type == 2; /* R_MN10200_16. */
+ case EM_CYGNUS_MN10300:
+ case EM_MN10300:
+ return reloc_type == 2; /* R_MN10300_16. */
case EM_MSP430:
if (uses_msp430x_relocs ())
return reloc_type == 2; /* R_MSP430_ABS16. */
+ /* Fall through. */
case EM_MSP430_OLD:
return reloc_type == 5; /* R_MSP430_16_BYTE. */
case EM_NDS32:
return reloc_type == 9; /* R_NIOS_16. */
case EM_OR1K:
return reloc_type == 2; /* R_OR1K_16. */
+ case EM_TI_PRU:
+ return reloc_type == 8; /* R_PRU_BFD_RELOC_16. */
case EM_TI_C6000:
return reloc_type == 2; /* R_C6000_ABS16. */
+ case EM_VISIUM:
+ return reloc_type == 2; /* R_VISIUM_16. */
case EM_XC16X:
case EM_C166:
return reloc_type == 2; /* R_XC16C_ABS_16. */
- case EM_CYGNUS_MN10200:
- case EM_MN10200:
- return reloc_type == 2; /* R_MN10200_16. */
- case EM_CYGNUS_MN10300:
- case EM_MN10300:
- return reloc_type == 2; /* R_MN10300_16. */
- case EM_VISIUM:
- return reloc_type == 2; /* R_VISIUM_16. */
case EM_XGATE:
return reloc_type == 3; /* R_XGATE_16. */
default:
{
switch (elf_header.e_machine)
{
- 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_68K: /* R_68K_NONE. */
case EM_ADAPTEVA_EPIPHANY:
- case EM_PPC: /* R_PPC_NONE. */
- case EM_PPC64: /* R_PPC64_NONE. */
+ case EM_ALPHA: /* R_ALPHA_NONE. */
+ case EM_ALTERA_NIOS2: /* R_NIOS2_NONE. */
+ case EM_ARC: /* R_ARC_NONE. */
+ case EM_ARC_COMPACT2: /* R_ARC_NONE. */
+ case EM_ARC_COMPACT: /* R_ARC_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_C166: /* R_XC16X_NONE. */
case EM_CRIS: /* R_CRIS_NONE. */
- case EM_X86_64: /* R_X86_64_NONE. */
- case EM_L1OM: /* R_X86_64_NONE. */
+ case EM_FT32: /* R_FT32_NONE. */
+ case EM_IA_64: /* R_IA64_NONE. */
case EM_K1OM: /* R_X86_64_NONE. */
+ case EM_L1OM: /* R_X86_64_NONE. */
+ case EM_M32R: /* R_M32R_NONE. */
+ case EM_MIPS: /* R_MIPS_NONE. */
case EM_MN10300: /* R_MN10300_NONE. */
- case EM_FT32: /* R_FT32_NONE. */
case EM_MOXIE: /* R_MOXIE_NONE. */
- case EM_M32R: /* R_M32R_NONE. */
- case EM_TI_C6000:/* R_C6000_NONE. */
+ case EM_NIOS32: /* R_NIOS_NONE. */
+ case EM_OR1K: /* R_OR1K_NONE. */
+ case EM_PARISC: /* R_PARISC_NONE. */
+ case EM_PPC64: /* R_PPC64_NONE. */
+ case EM_PPC: /* R_PPC_NONE. */
+ case EM_RISCV: /* R_RISCV_NONE. */
+ case EM_S390: /* R_390_NONE. */
+ case EM_S390_OLD:
+ case EM_SH: /* R_SH_NONE. */
+ case EM_SPARC32PLUS:
+ case EM_SPARC: /* R_SPARC_NONE. */
+ case EM_SPARCV9:
case EM_TILEGX: /* R_TILEGX_NONE. */
case EM_TILEPRO: /* R_TILEPRO_NONE. */
+ case EM_TI_C6000:/* R_C6000_NONE. */
+ case EM_X86_64: /* R_X86_64_NONE. */
case EM_XC16X:
- case EM_C166: /* R_XC16X_NONE. */
- case EM_ALTERA_NIOS2: /* R_NIOS2_NONE. */
- case EM_NIOS32: /* R_NIOS_NONE. */
- case EM_OR1K: /* R_OR1K_NONE. */
return reloc_type == 0;
+
case EM_AARCH64:
return reloc_type == 0 || reloc_type == 256;
- case EM_NDS32:
- return (reloc_type == 0 /* R_XTENSA_NONE. */
- || reloc_type == 204 /* R_NDS32_DIFF8. */
+ case EM_AVR_OLD:
+ case EM_AVR:
+ return (reloc_type == 0 /* R_AVR_NONE. */
+ || reloc_type == 30 /* R_AVR_DIFF8. */
+ || reloc_type == 31 /* R_AVR_DIFF16. */
+ || reloc_type == 32 /* R_AVR_DIFF32. */);
+ case EM_METAG:
+ return reloc_type == 3; /* R_METAG_NONE. */
+ case EM_NDS32:
+ return (reloc_type == 0 /* R_XTENSA_NONE. */
+ || reloc_type == 204 /* R_NDS32_DIFF8. */
|| reloc_type == 205 /* R_NDS32_DIFF16. */
|| reloc_type == 206 /* R_NDS32_DIFF32. */
|| reloc_type == 207 /* R_NDS32_ULEB128. */);
+ case EM_TI_PRU:
+ return (reloc_type == 0 /* R_PRU_NONE. */
+ || reloc_type == 65 /* R_PRU_DIFF8. */
+ || reloc_type == 66 /* R_PRU_DIFF16. */
+ || reloc_type == 67 /* R_PRU_DIFF32. */);
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. */);
- case EM_METAG:
- return reloc_type == 3; /* R_METAG_NONE. */
}
return FALSE;
}
+/* Returns TRUE if there is a relocation against
+ section NAME at OFFSET bytes. */
+
+bfd_boolean
+reloc_at (struct dwarf_section * dsec, dwarf_vma offset)
+{
+ Elf_Internal_Rela * relocs;
+ Elf_Internal_Rela * rp;
+
+ if (dsec == NULL || dsec->reloc_info == NULL)
+ return FALSE;
+
+ relocs = (Elf_Internal_Rela *) dsec->reloc_info;
+
+ for (rp = relocs; rp < relocs + dsec->num_relocs; ++rp)
+ if (rp->r_offset == offset)
+ return TRUE;
+
+ return FALSE;
+}
+
/* Apply relocations to a section.
+ Returns TRUE upon success, FALSE otherwise.
+ If RELOCS_RETURN is non-NULL then it is set to point to the loaded relocs.
+ It is then the caller's responsibility to free them. NUM_RELOCS_RETURN
+ will be set to the number of relocs loaded.
+
Note: So far support has been added only for those relocations
- which can be found in debug sections.
- FIXME: Add support for more relocations ? */
+ which can be found in debug sections. FIXME: Add support for
+ more relocations ? */
-static void
-apply_relocations (void * file,
- const Elf_Internal_Shdr * section,
- unsigned char * start, bfd_size_type size)
+static bfd_boolean
+apply_relocations (void * file,
+ const Elf_Internal_Shdr * section,
+ unsigned char * start,
+ bfd_size_type size,
+ void ** relocs_return,
+ unsigned long * num_relocs_return)
{
Elf_Internal_Shdr * relsec;
unsigned char * end = start + size;
+ bfd_boolean res = TRUE;
+
+ if (relocs_return != NULL)
+ {
+ * (Elf_Internal_Rela **) relocs_return = NULL;
+ * num_relocs_return = 0;
+ }
if (elf_header.e_type != ET_REL)
- return;
+ /* No relocs to apply. */
+ return TRUE;
/* Find the reloc section associated with the section. */
for (relsec = section_headers;
{
if (!slurp_rela_relocs ((FILE *) file, relsec->sh_offset,
relsec->sh_size, & relocs, & num_relocs))
- return;
+ return FALSE;
}
else
{
if (!slurp_rel_relocs ((FILE *) file, relsec->sh_offset,
relsec->sh_size, & relocs, & num_relocs))
- return;
+ return FALSE;
}
/* SH uses RELA but uses in place value instead of the addend field. */
is_rela = FALSE;
symsec = section_headers + relsec->sh_link;
+ if (symsec->sh_type != SHT_SYMTAB
+ && symsec->sh_type != SHT_DYNSYM)
+ return FALSE;
symtab = GET_ELF_SYMBOLS ((FILE *) file, symsec, & num_syms);
for (rp = relocs; rp < relocs + num_relocs; ++rp)
reloc_type = get_reloc_type (rp->r_info);
- if (target_specific_reloc_handling (rp, start, symtab))
+ if (target_specific_reloc_handling (rp, start, end, symtab, num_syms))
continue;
else if (is_none_reloc (reloc_type))
continue;
warn (_("unable to apply unsupported reloc type %d to section %s\n"),
reloc_type, printable_section_name (section));
prev_reloc = reloc_type;
+ res = FALSE;
continue;
}
warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
(unsigned long) rp->r_offset,
printable_section_name (section));
+ res = FALSE;
continue;
}
{
warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
sym_index, printable_section_name (section));
+ res = FALSE;
continue;
}
sym = symtab + sym_index;
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_COMMON
&& 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),
printable_section_name (relsec));
+ res = FALSE;
continue;
}
}
free (symtab);
- free (relocs);
+ /* Let the target specific reloc processing code know that
+ we have finished with these relocs. */
+ target_specific_reloc_handling (NULL, NULL, NULL, NULL, 0);
+
+ if (relocs_return)
+ {
+ * (Elf_Internal_Rela **) relocs_return = relocs;
+ * num_relocs_return = num_relocs;
+ }
+ else
+ free (relocs);
+
break;
}
+
+ return res;
}
#ifdef SUPPORT_DISASSEMBLY
-static int
+static bfd_boolean
disassemble_section (Elf_Internal_Shdr * section, FILE * file)
{
printf (_("\nAssembly dump of section %s\n"), printable_section_name (section));
/* FIXME: XXX -- to be done --- XXX */
- return 1;
+ return TRUE;
}
#endif
_("section contents"));
}
+/* Uncompresses a section that was compressed using zlib, in place. */
-static void
-dump_section_as_strings (Elf_Internal_Shdr * section, FILE * file)
+static bfd_boolean
+uncompress_section_contents (unsigned char **buffer,
+ dwarf_size_type uncompressed_size,
+ dwarf_size_type *size)
{
- Elf_Internal_Shdr * relsec;
- bfd_size_type num_bytes;
- char * data;
- char * end;
- char * start;
- bfd_boolean some_strings_shown;
+ dwarf_size_type compressed_size = *size;
+ unsigned char * compressed_buffer = *buffer;
+ unsigned char * uncompressed_buffer;
+ z_stream strm;
+ int rc;
+
+ /* It is possible the section consists of several compressed
+ buffers concatenated together, so we uncompress in a loop. */
+ /* PR 18313: The state field in the z_stream structure is supposed
+ to be invisible to the user (ie us), but some compilers will
+ still complain about it being used without initialisation. So
+ we first zero the entire z_stream structure and then set the fields
+ that we need. */
+ memset (& strm, 0, sizeof strm);
+ strm.avail_in = compressed_size;
+ strm.next_in = (Bytef *) compressed_buffer;
+ strm.avail_out = uncompressed_size;
+ uncompressed_buffer = (unsigned char *) xmalloc (uncompressed_size);
+
+ rc = inflateInit (& strm);
+ while (strm.avail_in > 0)
+ {
+ if (rc != Z_OK)
+ goto fail;
+ 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 = inflateEnd (& strm);
+ if (rc != Z_OK
+ || strm.avail_out != 0)
+ goto fail;
+
+ *buffer = uncompressed_buffer;
+ *size = uncompressed_size;
+ return TRUE;
+
+ fail:
+ free (uncompressed_buffer);
+ /* Indicate decompression failure. */
+ *buffer = NULL;
+ return FALSE;
+}
- start = get_section_contents (section, file);
+static bfd_boolean
+dump_section_as_strings (Elf_Internal_Shdr * section, FILE * file)
+{
+ Elf_Internal_Shdr * relsec;
+ bfd_size_type num_bytes;
+ unsigned char * data;
+ unsigned char * end;
+ unsigned char * real_start;
+ unsigned char * start;
+ bfd_boolean some_strings_shown;
+
+ real_start = start = (unsigned char *) get_section_contents (section,
+ file);
if (start == NULL)
- return;
+ return FALSE;
+ num_bytes = section->sh_size;
printf (_("\nString dump of section '%s':\n"), printable_section_name (section));
+ if (decompress_dumps)
+ {
+ dwarf_size_type new_size = num_bytes;
+ dwarf_size_type uncompressed_size = 0;
+
+ if ((section->sh_flags & SHF_COMPRESSED) != 0)
+ {
+ Elf_Internal_Chdr chdr;
+ unsigned int compression_header_size
+ = get_compression_header (& chdr, (unsigned char *) start,
+ num_bytes);
+
+ if (chdr.ch_type != ELFCOMPRESS_ZLIB)
+ {
+ warn (_("section '%s' has unsupported compress type: %d\n"),
+ printable_section_name (section), chdr.ch_type);
+ return FALSE;
+ }
+ else if (chdr.ch_addralign != section->sh_addralign)
+ {
+ warn (_("compressed section '%s' is corrupted\n"),
+ printable_section_name (section));
+ return FALSE;
+ }
+ uncompressed_size = chdr.ch_size;
+ start += compression_header_size;
+ new_size -= compression_header_size;
+ }
+ else if (new_size > 12 && streq ((char *) start, "ZLIB"))
+ {
+ /* Read the zlib header. In this case, it should be "ZLIB"
+ followed by the uncompressed section size, 8 bytes in
+ big-endian order. */
+ uncompressed_size = start[4]; uncompressed_size <<= 8;
+ uncompressed_size += start[5]; uncompressed_size <<= 8;
+ uncompressed_size += start[6]; uncompressed_size <<= 8;
+ uncompressed_size += start[7]; uncompressed_size <<= 8;
+ uncompressed_size += start[8]; uncompressed_size <<= 8;
+ uncompressed_size += start[9]; uncompressed_size <<= 8;
+ uncompressed_size += start[10]; uncompressed_size <<= 8;
+ uncompressed_size += start[11];
+ start += 12;
+ new_size -= 12;
+ }
+
+ if (uncompressed_size)
+ {
+ if (uncompress_section_contents (& start,
+ uncompressed_size, & new_size))
+ num_bytes = new_size;
+ else
+ {
+ error (_("Unable to decompress section %s\n"),
+ printable_section_name (section));
+ return FALSE;
+ }
+ }
+ else
+ start = real_start;
+ }
+
/* 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.
break;
}
- num_bytes = section->sh_size;
data = start;
end = start + num_bytes;
some_strings_shown = FALSE;
#endif
if (maxlen > 0)
{
- print_symbol ((int) maxlen, data);
+ print_symbol ((int) maxlen, (const char *) data);
putchar ('\n');
- data += strnlen (data, maxlen);
+ data += strnlen ((const char *) data, maxlen);
}
else
{
if (! some_strings_shown)
printf (_(" No strings found in this section."));
- free (start);
+ free (real_start);
putchar ('\n');
+ return TRUE;
}
-static void
+static bfd_boolean
dump_section_as_bytes (Elf_Internal_Shdr * section,
FILE * file,
bfd_boolean relocate)
{
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);
+ bfd_size_type bytes;
+ bfd_size_type section_size;
+ bfd_vma addr;
+ unsigned char * data;
+ unsigned char * real_start;
+ unsigned char * start;
+
+ real_start = start = (unsigned char *) get_section_contents (section, file);
if (start == NULL)
- return;
+ return FALSE;
+
+ section_size = section->sh_size;
printf (_("\nHex dump of section '%s':\n"), printable_section_name (section));
+ if (decompress_dumps)
+ {
+ dwarf_size_type new_size = section_size;
+ dwarf_size_type uncompressed_size = 0;
+
+ if ((section->sh_flags & SHF_COMPRESSED) != 0)
+ {
+ Elf_Internal_Chdr chdr;
+ unsigned int compression_header_size
+ = get_compression_header (& chdr, start, section_size);
+
+ if (chdr.ch_type != ELFCOMPRESS_ZLIB)
+ {
+ warn (_("section '%s' has unsupported compress type: %d\n"),
+ printable_section_name (section), chdr.ch_type);
+ return FALSE;
+ }
+ else if (chdr.ch_addralign != section->sh_addralign)
+ {
+ warn (_("compressed section '%s' is corrupted\n"),
+ printable_section_name (section));
+ return FALSE;
+ }
+ uncompressed_size = chdr.ch_size;
+ start += compression_header_size;
+ new_size -= compression_header_size;
+ }
+ else if (new_size > 12 && streq ((char *) start, "ZLIB"))
+ {
+ /* Read the zlib header. In this case, it should be "ZLIB"
+ followed by the uncompressed section size, 8 bytes in
+ big-endian order. */
+ uncompressed_size = start[4]; uncompressed_size <<= 8;
+ uncompressed_size += start[5]; uncompressed_size <<= 8;
+ uncompressed_size += start[6]; uncompressed_size <<= 8;
+ uncompressed_size += start[7]; uncompressed_size <<= 8;
+ uncompressed_size += start[8]; uncompressed_size <<= 8;
+ uncompressed_size += start[9]; uncompressed_size <<= 8;
+ uncompressed_size += start[10]; uncompressed_size <<= 8;
+ uncompressed_size += start[11];
+ start += 12;
+ new_size -= 12;
+ }
+
+ if (uncompressed_size)
+ {
+ if (uncompress_section_contents (& start, uncompressed_size,
+ & new_size))
+ {
+ section_size = new_size;
+ }
+ else
+ {
+ error (_("Unable to decompress section %s\n"),
+ printable_section_name (section));
+ /* FIXME: Print the section anyway ? */
+ return FALSE;
+ }
+ }
+ else
+ start = real_start;
+ }
+
if (relocate)
{
- apply_relocations (file, section, start, section->sh_size);
+ if (! apply_relocations (file, section, start, section_size, NULL, NULL))
+ return FALSE;
}
else
{
}
addr = section->sh_addr;
- bytes = section->sh_size;
+ bytes = section_size;
data = start;
while (bytes)
bytes -= lbytes;
}
- free (start);
+ free (real_start);
putchar ('\n');
+ return TRUE;
}
-/* Uncompresses a section that was compressed using zlib, in place. */
-
-static int
-uncompress_section_contents (unsigned char **buffer,
- dwarf_size_type *size)
-{
- dwarf_size_type compressed_size = *size;
- unsigned char * compressed_buffer = *buffer;
- dwarf_size_type uncompressed_size;
- 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"))
- 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;
- uncompressed_size += compressed_buffer[7]; uncompressed_size <<= 8;
- uncompressed_size += compressed_buffer[8]; uncompressed_size <<= 8;
- uncompressed_size += compressed_buffer[9]; uncompressed_size <<= 8;
- uncompressed_size += compressed_buffer[10]; uncompressed_size <<= 8;
- uncompressed_size += compressed_buffer[11];
-
- /* It is possible the section consists of several compressed
- buffers concatenated together, so we uncompress in a loop. */
- /* PR 18313: The state field in the z_stream structure is supposed
- to be invisible to the user (ie us), but some compilers will
- still complain about it being used without initialisation. So
- we first zero the entire z_stream structure and then set the fields
- that we need. */
- memset (& strm, 0, sizeof strm);
- strm.avail_in = compressed_size - header_size;
- strm.next_in = (Bytef *) compressed_buffer + header_size;
- strm.avail_out = uncompressed_size;
- uncompressed_buffer = (unsigned char *) xmalloc (uncompressed_size);
-
- rc = inflateInit (& strm);
- while (strm.avail_in > 0)
- {
- if (rc != Z_OK)
- goto fail;
- 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 = inflateEnd (& strm);
- if (rc != Z_OK
- || strm.avail_out != 0)
- goto fail;
-
- *buffer = uncompressed_buffer;
- *size = uncompressed_size;
- return 1;
-
- fail:
- free (uncompressed_buffer);
- /* Indicate decompression failure. */
- *buffer = NULL;
- return 0;
-}
-
-static int
+static bfd_boolean
load_specific_debug_section (enum dwarf_section_display_enum debug,
const Elf_Internal_Shdr * sec, void * file)
{
/* If it is already loaded, do nothing. */
if (section->start != NULL)
- return 1;
+ return TRUE;
snprintf (buf, sizeof (buf), _("%s section data"), section->name);
section->address = sec->sh_addr;
{
unsigned char *start = section->start;
dwarf_size_type size = sec->sh_size;
+ dwarf_size_type uncompressed_size = 0;
if ((sec->sh_flags & SHF_COMPRESSED) != 0)
{
Elf_Internal_Chdr chdr;
- unsigned int compression_header_size
- = get_compression_header (&chdr, start);
- if (chdr.ch_type != ELFCOMPRESS_ZLIB
- || chdr.ch_addralign != sec->sh_addralign)
- return 0;
+ unsigned int compression_header_size;
+
+ if (size < (is_32bit_elf
+ ? sizeof (Elf32_External_Chdr)
+ : sizeof (Elf64_External_Chdr)))
+ {
+ warn (_("compressed section %s is too small to contain a compression header"),
+ section->name);
+ return FALSE;
+ }
+
+ compression_header_size = get_compression_header (&chdr, start, size);
+
+ if (chdr.ch_type != ELFCOMPRESS_ZLIB)
+ {
+ warn (_("section '%s' has unsupported compress type: %d\n"),
+ section->name, chdr.ch_type);
+ return FALSE;
+ }
+ else if (chdr.ch_addralign != sec->sh_addralign)
+ {
+ warn (_("compressed section '%s' is corrupted\n"),
+ section->name);
+ return FALSE;
+ }
+ uncompressed_size = chdr.ch_size;
start += compression_header_size;
size -= compression_header_size;
}
+ else if (size > 12 && streq ((char *) start, "ZLIB"))
+ {
+ /* Read the zlib header. In this case, it should be "ZLIB"
+ followed by the uncompressed section size, 8 bytes in
+ big-endian order. */
+ uncompressed_size = start[4]; uncompressed_size <<= 8;
+ uncompressed_size += start[5]; uncompressed_size <<= 8;
+ uncompressed_size += start[6]; uncompressed_size <<= 8;
+ uncompressed_size += start[7]; uncompressed_size <<= 8;
+ uncompressed_size += start[8]; uncompressed_size <<= 8;
+ uncompressed_size += start[9]; uncompressed_size <<= 8;
+ uncompressed_size += start[10]; uncompressed_size <<= 8;
+ uncompressed_size += start[11];
+ start += 12;
+ size -= 12;
+ }
- if (uncompress_section_contents (&start, &size))
+ if (uncompressed_size)
{
- /* Free the compressed buffer, update the section buffer
- and the section size if uncompress is successful. */
- free (section->start);
- section->start = start;
+ if (uncompress_section_contents (&start, uncompressed_size,
+ &size))
+ {
+ /* Free the compressed buffer, update the section buffer
+ and the section size if uncompress is successful. */
+ free (section->start);
+ section->start = start;
+ }
+ else
+ {
+ error (_("Unable to decompress section %s\n"),
+ printable_section_name (sec));
+ return FALSE;
+ }
}
+
section->size = size;
}
if (section->start == NULL)
- return 0;
+ return FALSE;
if (debug_displays [debug].relocate)
- apply_relocations ((FILE *) file, sec, section->start, section->size);
+ {
+ if (! apply_relocations ((FILE *) file, sec, section->start, section->size,
+ & section->reloc_info, & section->num_relocs))
+ return FALSE;
+ }
+ else
+ {
+ section->reloc_info = NULL;
+ section->num_relocs = 0;
+ }
- return 1;
+ return TRUE;
}
/* If this is not NULL, load_debug_section will only look for sections
within the list of sections given here. */
-unsigned int *section_subset = NULL;
+static unsigned int * section_subset = NULL;
-int
+bfd_boolean
load_debug_section (enum dwarf_section_display_enum debug, void * file)
{
struct dwarf_section * section = &debug_displays [debug].section;
section->name = section->compressed_name;
}
if (sec == NULL)
- return 0;
+ return FALSE;
/* If we're loading from a subset of sections, and we've loaded
a section matching this name before, it's likely that it's a
section->size = 0;
}
-static int
+static bfd_boolean
display_debug_section (int shndx, Elf_Internal_Shdr * section, FILE * file)
{
char * name = SECTION_NAME (section);
const char * print_name = printable_section_name (section);
bfd_size_type length;
- int result = 1;
+ bfd_boolean result = TRUE;
int i;
length = section->sh_size;
if (length == 0)
{
printf (_("\nSection '%s' has no debugging data.\n"), print_name);
- return 0;
+ return TRUE;
}
if (section->sh_type == SHT_NOBITS)
{
stripped with the --only-keep-debug command line option. */
printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"),
print_name);
- return 0;
+ return FALSE;
}
if (const_strneq (name, ".gnu.linkonce.wi."))
if (i == max)
{
printf (_("Unrecognized debug section: %s\n"), print_name);
- result = 0;
+ result = FALSE;
}
return result;
for (cur = dump_sects_byname; cur; cur = cur->next)
{
unsigned int i;
- int any;
+ bfd_boolean any = FALSE;
- for (i = 0, any = 0; i < elf_header.e_shnum; i++)
+ for (i = 0; i < elf_header.e_shnum; i++)
if (streq (SECTION_NAME (section_headers + i), cur->name))
{
request_dump_bynumber (i, cur->type);
- any = 1;
+ any = TRUE;
}
if (!any)
}
}
-static void
+static bfd_boolean
process_section_contents (FILE * file)
{
Elf_Internal_Shdr * section;
unsigned int i;
+ bfd_boolean res = TRUE;
if (! do_dump)
- return;
+ return TRUE;
initialise_dumps_byname ();
disassemble_section (section, file);
#endif
if (dump_sects[i] & HEX_DUMP)
- dump_section_as_bytes (section, file, FALSE);
+ {
+ if (! dump_section_as_bytes (section, file, FALSE))
+ res = FALSE;
+ }
if (dump_sects[i] & RELOC_DUMP)
- dump_section_as_bytes (section, file, TRUE);
+ {
+ if (! dump_section_as_bytes (section, file, TRUE))
+ res = FALSE;
+ }
if (dump_sects[i] & STRING_DUMP)
- dump_section_as_strings (section, file);
+ {
+ if (! dump_section_as_strings (section, file))
+ res = FALSE;
+ }
if (dump_sects[i] & DEBUG_DUMP)
- display_debug_section (i, section, file);
+ {
+ if (! display_debug_section (i, section, file))
+ res = FALSE;
+ }
}
/* Check to see if the user requested a
dump of a section that does not exist. */
- while (i++ < num_dump_sects)
- if (dump_sects[i])
- warn (_("Section %d was not dumped because it does not exist!\n"), i);
+ while (i < num_dump_sects)
+ {
+ if (dump_sects[i])
+ {
+ warn (_("Section %d was not dumped because it does not exist!\n"), i);
+ res = FALSE;
+ }
+ i++;
+ }
+
+ return res;
}
static void
{
if (mask)
{
- int first = 1;
+ bfd_boolean first = TRUE;
+
if (mask & OEX_FPU_INEX)
- fputs ("INEX", stdout), first = 0;
+ fputs ("INEX", stdout), first = FALSE;
if (mask & OEX_FPU_UFLO)
- printf ("%sUFLO", first ? "" : "|"), first = 0;
+ printf ("%sUFLO", first ? "" : "|"), first = FALSE;
if (mask & OEX_FPU_OFLO)
- printf ("%sOFLO", first ? "" : "|"), first = 0;
+ printf ("%sOFLO", first ? "" : "|"), first = FALSE;
if (mask & OEX_FPU_DIV0)
- printf ("%sDIV0", first ? "" : "|"), first = 0;
+ printf ("%sDIV0", first ? "" : "|"), first = FALSE;
if (mask & OEX_FPU_INVAL)
printf ("%sINVAL", first ? "" : "|");
}
Reads at or beyond END will not be made. */
static unsigned char *
-display_tag_value (int tag,
+display_tag_value (signed int tag,
unsigned char * p,
const unsigned char * const end)
{
static const char * arm_attr_tag_CPU_arch[] =
{"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
- "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8"};
+ "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8", "", "v8-M.baseline",
+ "v8-M.mainline"};
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"};
+ {"No", "Thumb-1", "Thumb-2", "Yes"};
static const char * arm_attr_tag_FP_arch[] =
{"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
"FP for ARMv8", "FPv5/FP-D16 for ARMv8"};
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", "NEON for ARMv8"};
+ {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8",
+ "NEON for ARMv8.1"};
static const char * arm_attr_tag_PCS_config[] =
{"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
"PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
{"Not Allowed", "Allowed"};
static const char * arm_attr_tag_ABI_FP_16bit_format[] =
{"None", "IEEE 754", "Alternative Format"};
+static const char * arm_attr_tag_DSP_extension[] =
+ {"Follow architecture", "Allowed"};
static const char * arm_attr_tag_MPextension_use[] =
{"Not Allowed", "Allowed"};
static const char * arm_attr_tag_DIV_use[] =
LOOKUP(38, ABI_FP_16bit_format),
LOOKUP(42, MPextension_use),
LOOKUP(44, DIV_use),
+ LOOKUP(46, DSP_extension),
{64, "nodefaults", 0, NULL},
{65, "also_compatible_with", 0, NULL},
LOOKUP(66, T2EE_use),
static unsigned char *
display_gnu_attribute (unsigned char * p,
- unsigned char * (* display_proc_gnu_attribute) (unsigned char *, int, const unsigned char * const),
+ unsigned char * (* display_proc_gnu_attribute) (unsigned char *, unsigned int, const unsigned char * const),
const unsigned char * const end)
{
int tag;
unsigned int len;
- int val;
+ unsigned int val;
tag = read_uleb128 (p, &len, end);
p += len;
static unsigned char *
display_power_gnu_attribute (unsigned char * p,
- int tag,
+ unsigned int tag,
const unsigned char * const end)
{
unsigned int len;
- int val;
+ unsigned int val;
if (tag == Tag_GNU_Power_ABI_FP)
{
val = read_uleb128 (p, &len, end);
p += len;
printf (" Tag_GNU_Power_ABI_FP: ");
+ if (len == 0)
+ {
+ printf (_("<corrupt>\n"));
+ return p;
+ }
- switch (val)
+ if (val > 15)
+ printf ("(%#x), ", val);
+
+ switch (val & 3)
{
case 0:
- printf (_("Hard or soft float\n"));
+ printf (_("unspecified hard/soft float, "));
break;
case 1:
- printf (_("Hard float\n"));
+ printf (_("hard float, "));
break;
case 2:
- printf (_("Soft float\n"));
+ printf (_("soft float, "));
break;
case 3:
- printf (_("Single-precision hard float\n"));
+ printf (_("single-precision hard float, "));
break;
- default:
- printf ("??? (%d)\n", val);
+ }
+
+ switch (val & 0xC)
+ {
+ case 0:
+ printf (_("unspecified long double\n"));
+ break;
+ case 4:
+ printf (_("128-bit IBM long double\n"));
+ break;
+ case 8:
+ printf (_("64-bit long double\n"));
+ break;
+ case 12:
+ printf (_("128-bit IEEE long double\n"));
break;
}
return p;
- }
+ }
if (tag == Tag_GNU_Power_ABI_Vector)
{
val = read_uleb128 (p, &len, end);
p += len;
printf (" Tag_GNU_Power_ABI_Vector: ");
- switch (val)
+ if (len == 0)
+ {
+ printf (_("<corrupt>\n"));
+ return p;
+ }
+
+ if (val > 3)
+ printf ("(%#x), ", val);
+
+ switch (val & 3)
{
case 0:
- printf (_("Any\n"));
+ printf (_("unspecified\n"));
break;
case 1:
- printf (_("Generic\n"));
+ printf (_("generic\n"));
break;
case 2:
printf ("AltiVec\n");
case 3:
printf ("SPE\n");
break;
- default:
- printf ("??? (%d)\n", val);
- break;
}
return p;
- }
+ }
if (tag == Tag_GNU_Power_ABI_Struct_Return)
{
- if (p == end)
+ val = read_uleb128 (p, &len, end);
+ p += len;
+ printf (" Tag_GNU_Power_ABI_Struct_Return: ");
+ if (len == 0)
{
- warn (_("corrupt Tag_GNU_Power_ABI_Struct_Return\n"));
+ printf (_("<corrupt>\n"));
return p;
}
- val = read_uleb128 (p, &len, end);
- 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;
- }
+ if (val > 2)
+ printf ("(%#x), ", val);
+
+ switch (val & 3)
+ {
+ case 0:
+ printf (_("unspecified\n"));
+ break;
+ case 1:
+ printf ("r3/r4\n");
+ break;
+ case 2:
+ printf (_("memory\n"));
+ break;
+ case 3:
+ printf ("???\n");
+ break;
+ }
return p;
}
static unsigned char *
display_s390_gnu_attribute (unsigned char * p,
- int tag,
+ unsigned int tag,
const unsigned char * const end)
{
unsigned int len;
}
static void
-display_sparc_hwcaps (int mask)
+display_sparc_hwcaps (unsigned int mask)
{
if (mask)
{
- int first = 1;
+ bfd_boolean first = TRUE;
if (mask & ELF_SPARC_HWCAP_MUL32)
- fputs ("mul32", stdout), first = 0;
+ fputs ("mul32", stdout), first = FALSE;
if (mask & ELF_SPARC_HWCAP_DIV32)
- printf ("%sdiv32", first ? "" : "|"), first = 0;
+ printf ("%sdiv32", first ? "" : "|"), first = FALSE;
if (mask & ELF_SPARC_HWCAP_FSMULD)
- printf ("%sfsmuld", first ? "" : "|"), first = 0;
+ printf ("%sfsmuld", first ? "" : "|"), first = FALSE;
if (mask & ELF_SPARC_HWCAP_V8PLUS)
- printf ("%sv8plus", first ? "" : "|"), first = 0;
+ printf ("%sv8plus", first ? "" : "|"), first = FALSE;
if (mask & ELF_SPARC_HWCAP_POPC)
- printf ("%spopc", first ? "" : "|"), first = 0;
+ printf ("%spopc", first ? "" : "|"), first = FALSE;
if (mask & ELF_SPARC_HWCAP_VIS)
- printf ("%svis", first ? "" : "|"), first = 0;
+ printf ("%svis", first ? "" : "|"), first = FALSE;
if (mask & ELF_SPARC_HWCAP_VIS2)
- printf ("%svis2", first ? "" : "|"), first = 0;
+ printf ("%svis2", first ? "" : "|"), first = FALSE;
if (mask & ELF_SPARC_HWCAP_ASI_BLK_INIT)
- printf ("%sASIBlkInit", first ? "" : "|"), first = 0;
+ printf ("%sASIBlkInit", first ? "" : "|"), first = FALSE;
if (mask & ELF_SPARC_HWCAP_FMAF)
- printf ("%sfmaf", first ? "" : "|"), first = 0;
+ printf ("%sfmaf", first ? "" : "|"), first = FALSE;
if (mask & ELF_SPARC_HWCAP_VIS3)
- printf ("%svis3", first ? "" : "|"), first = 0;
+ printf ("%svis3", first ? "" : "|"), first = FALSE;
if (mask & ELF_SPARC_HWCAP_HPC)
- printf ("%shpc", first ? "" : "|"), first = 0;
+ printf ("%shpc", first ? "" : "|"), first = FALSE;
if (mask & ELF_SPARC_HWCAP_RANDOM)
- printf ("%srandom", first ? "" : "|"), first = 0;
+ printf ("%srandom", first ? "" : "|"), first = FALSE;
if (mask & ELF_SPARC_HWCAP_TRANS)
- printf ("%strans", first ? "" : "|"), first = 0;
+ printf ("%strans", first ? "" : "|"), first = FALSE;
if (mask & ELF_SPARC_HWCAP_FJFMAU)
- printf ("%sfjfmau", first ? "" : "|"), first = 0;
+ printf ("%sfjfmau", first ? "" : "|"), first = FALSE;
if (mask & ELF_SPARC_HWCAP_IMA)
- printf ("%sima", first ? "" : "|"), first = 0;
+ printf ("%sima", first ? "" : "|"), first = FALSE;
if (mask & ELF_SPARC_HWCAP_ASI_CACHE_SPARING)
- printf ("%scspare", first ? "" : "|"), first = 0;
+ printf ("%scspare", first ? "" : "|"), first = FALSE;
}
else
fputc ('0', stdout);
}
static void
-display_sparc_hwcaps2 (int mask)
+display_sparc_hwcaps2 (unsigned int mask)
{
if (mask)
{
- int first = 1;
+ bfd_boolean first = TRUE;
if (mask & ELF_SPARC_HWCAP2_FJATHPLUS)
- fputs ("fjathplus", stdout), first = 0;
+ fputs ("fjathplus", stdout), first = FALSE;
if (mask & ELF_SPARC_HWCAP2_VIS3B)
- printf ("%svis3b", first ? "" : "|"), first = 0;
+ printf ("%svis3b", first ? "" : "|"), first = FALSE;
if (mask & ELF_SPARC_HWCAP2_ADP)
- printf ("%sadp", first ? "" : "|"), first = 0;
+ printf ("%sadp", first ? "" : "|"), first = FALSE;
if (mask & ELF_SPARC_HWCAP2_SPARC5)
- printf ("%ssparc5", first ? "" : "|"), first = 0;
+ printf ("%ssparc5", first ? "" : "|"), first = FALSE;
if (mask & ELF_SPARC_HWCAP2_MWAIT)
- printf ("%smwait", first ? "" : "|"), first = 0;
+ printf ("%smwait", first ? "" : "|"), first = FALSE;
if (mask & ELF_SPARC_HWCAP2_XMPMUL)
- printf ("%sxmpmul", first ? "" : "|"), first = 0;
+ printf ("%sxmpmul", first ? "" : "|"), first = FALSE;
if (mask & ELF_SPARC_HWCAP2_XMONT)
- printf ("%sxmont2", first ? "" : "|"), first = 0;
+ printf ("%sxmont2", first ? "" : "|"), first = FALSE;
if (mask & ELF_SPARC_HWCAP2_NSEC)
- printf ("%snsec", first ? "" : "|"), first = 0;
+ printf ("%snsec", first ? "" : "|"), first = FALSE;
if (mask & ELF_SPARC_HWCAP2_FJATHHPC)
- printf ("%sfjathhpc", first ? "" : "|"), first = 0;
+ printf ("%sfjathhpc", first ? "" : "|"), first = FALSE;
if (mask & ELF_SPARC_HWCAP2_FJDES)
- printf ("%sfjdes", first ? "" : "|"), first = 0;
+ printf ("%sfjdes", first ? "" : "|"), first = FALSE;
if (mask & ELF_SPARC_HWCAP2_FJAES)
- printf ("%sfjaes", first ? "" : "|"), first = 0;
+ printf ("%sfjaes", first ? "" : "|"), first = FALSE;
}
else
fputc ('0', stdout);
static unsigned char *
display_sparc_gnu_attribute (unsigned char * p,
- int tag,
+ unsigned int tag,
const unsigned char * const end)
{
unsigned int len;
}
static void
-print_mips_fp_abi_value (int val)
+print_mips_fp_abi_value (unsigned int val)
{
switch (val)
{
case Val_GNU_MIPS_ABI_FP_64A:
printf (_("Hard float compat (32-bit CPU, 64-bit FPU)\n"));
break;
+ case Val_GNU_MIPS_ABI_FP_NAN2008:
+ printf (_("NaN 2008 compatibility\n"));
+ break;
default:
printf ("??? (%d)\n", val);
break;
static unsigned char *
display_mips_gnu_attribute (unsigned char * p,
- int tag,
+ unsigned int tag,
const unsigned char * const end)
{
if (tag == Tag_GNU_MIPS_ABI_FP)
{
unsigned int len;
- int val;
+ unsigned int val;
val = read_uleb128 (p, &len, end);
p += len;
if (tag == Tag_GNU_MIPS_ABI_MSA)
{
unsigned int len;
- int val;
+ unsigned int val;
val = read_uleb128 (p, &len, end);
p += len;
display_tic6x_attribute (unsigned char * p,
const unsigned char * const end)
{
- int tag;
+ unsigned int tag;
unsigned int len;
int val;
}
static void
-display_raw_attribute (unsigned char * p, unsigned char * end)
+display_raw_attribute (unsigned char * p, unsigned char const * const end)
{
unsigned long addr = 0;
size_t bytes = end - p;
const unsigned char * const end)
{
unsigned int len;
- int val;
- int tag;
+ unsigned int val;
+ unsigned int tag;
tag = read_uleb128 (p, & len, end);
p += len;
return p;
}
-static int
+static bfd_boolean
process_attributes (FILE * file,
const char * public_name,
unsigned int proc_type,
unsigned char * (* display_pub_attribute) (unsigned char *, const unsigned char * const),
- unsigned char * (* display_proc_gnu_attribute) (unsigned char *, int, const unsigned char * const))
+ unsigned char * (* display_proc_gnu_attribute) (unsigned char *, unsigned int, const unsigned char * const))
{
Elf_Internal_Shdr * sect;
unsigned i;
+ bfd_boolean res = TRUE;
/* Find the section header so that we get the size. */
for (i = 0, sect = section_headers;
contents = (unsigned char *) get_data (NULL, file, sect->sh_offset, 1,
sect->sh_size, _("attributes"));
if (contents == NULL)
- continue;
+ {
+ res = FALSE;
+ continue;
+ }
p = contents;
- if (*p == 'A')
+ /* The first character is the version of the attributes.
+ Currently only version 1, (aka 'A') is recognised here. */
+ if (*p != 'A')
+ {
+ printf (_("Unknown attributes version '%c'(%d) - expecting 'A'\n"), *p, *p);
+ res = FALSE;
+ }
+ else
{
bfd_vma section_len;
if (section_len <= 4)
{
error (_("Tag section ends prematurely\n"));
+ res = FALSE;
break;
}
attr_len = byte_get (p, 4);
error (_("Bad attribute length (%u > %u)\n"),
(unsigned) attr_len, (unsigned) section_len);
attr_len = section_len;
+ res = FALSE;
}
/* PR 17531: file: 001-101425-0.004 */
else if (attr_len < 5)
{
error (_("Attribute length of %u is too small\n"), (unsigned) attr_len);
+ res = FALSE;
break;
}
if (namelen == 0 || namelen >= attr_len)
{
error (_("Corrupt attribute section name\n"));
+ res = FALSE;
break;
}
if (attr_len < 6)
{
error (_("Unused bytes at end of section\n"));
+ res = FALSE;
section_len = 0;
break;
}
{
error (_("Bad subsection length (%u > %u)\n"),
(unsigned) size, (unsigned) attr_len);
+ res = FALSE;
size = attr_len;
}
/* PR binutils/17531: Safe handling of corrupt files. */
{
error (_("Bad subsection length (%u < 6)\n"),
(unsigned) size);
+ res = FALSE;
section_len = 0;
break;
}
goto do_numlist;
case 3:
printf (_("Symbol Attributes:"));
+ /* Fall through. */
do_numlist:
for (;;)
{
{
while (p < end)
p = display_pub_attribute (p, end);
- assert (p <= end);
+ assert (p == end);
}
else if (gnu_section && display_proc_gnu_attribute != NULL)
{
p = display_gnu_attribute (p,
display_proc_gnu_attribute,
end);
- assert (p <= end);
+ assert (p == end);
}
else if (p < end)
{
}
}
}
- else
- printf (_("Unknown format '%c' (%d)\n"), *p, *p);
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_s390_specific (FILE * file)
-{
- return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
- display_s390_gnu_attribute);
-}
-
-static int
-process_sparc_specific (FILE * file)
-{
- return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
- display_sparc_gnu_attribute);
-}
-
-static int
-process_tic6x_specific (FILE * file)
-{
- return process_attributes (file, "c6xabi", SHT_C6000_ATTRIBUTES,
- display_tic6x_attribute, NULL);
-}
-static int
-process_msp430x_specific (FILE * file)
-{
- return process_attributes (file, "mspabi", SHT_MSP430_ATTRIBUTES,
- display_msp430x_attribute, NULL);
+ return res;
}
/* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
fputs ("\n\tDSP ASE", stdout);
if (mask & AFL_ASE_DSPR2)
fputs ("\n\tDSP R2 ASE", stdout);
+ if (mask & AFL_ASE_DSPR3)
+ fputs ("\n\tDSP R3 ASE", stdout);
if (mask & AFL_ASE_EVA)
fputs ("\n\tEnhanced VA Scheme", stdout);
if (mask & AFL_ASE_MCU)
}
}
-static int
+static signed int
get_mips_reg_size (int reg_size)
{
return (reg_size == AFL_REG_NONE) ? 0
: -1;
}
-static int
+static bfd_boolean
process_mips_specific (FILE * file)
{
Elf_Internal_Dyn * entry;
bfd_vma local_gotno = 0;
bfd_vma gotsym = 0;
bfd_vma symtabno = 0;
+ bfd_boolean res = TRUE;
- process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
- display_mips_gnu_attribute);
+ if (! process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
+ display_mips_gnu_attribute))
+ res = FALSE;
sect = find_section (".MIPS.abiflags");
Elf_Internal_ABIFlags_v0 abiflags_in;
if (sizeof (Elf_External_ABIFlags_v0) != sect->sh_size)
- fputs ("\nCorrupt ABI Flags section.\n", stdout);
+ {
+ error (_("Corrupt MIPS ABI Flags section.\n"));
+ res = FALSE;
+ }
else
{
abiflags_ext = get_data (NULL, file, sect->sh_offset, 1,
/* We have a lot of special sections. Thanks SGI! */
if (dynamic_section == NULL)
/* No information available. */
- return 0;
+ return res;
for (entry = dynamic_section;
/* PR 17531 file: 012-50589-0.004. */
{
Elf32_Lib liblist;
time_t atime;
- char timebuf[20];
+ char timebuf[128];
struct tm * tmp;
liblist.l_name = BYTE_GET (elib[cnt].l_name);
free (elib);
}
+ else
+ res = FALSE;
}
if (options_offset != 0)
if (sect == NULL)
{
error (_("No MIPS_OPTIONS header found\n"));
- return 0;
+ return FALSE;
}
eopt = (Elf_External_Options *) get_data (NULL, file, options_offset, 1,
cmalloc ((sect->sh_size / sizeof (eopt)), sizeof (* iopt));
if (iopt == NULL)
{
- error (_("Out of memory allocatinf space for MIPS options\n"));
- return 0;
+ error (_("Out of memory allocating space for MIPS options\n"));
+ return FALSE;
}
offset = cnt = 0;
|| offset + option->size > sect->sh_size)
{
error (_("Invalid size (%u) for MIPS option\n"), option->size);
- return 0;
+ return FALSE;
}
offset += option->size;
-
+
++option;
++cnt;
}
len = sizeof (* eopt);
while (len < option->size)
{
- char datum = * ((char *) eopt + offset + len);
+ unsigned char datum = * ((unsigned char *) eopt + offset + len);
if (ISPRINT (datum))
printf ("%c", datum);
free (eopt);
}
+ else
+ res = FALSE;
}
if (conflicts_offset != 0 && conflictsno != 0)
if (dynamic_symbols == NULL)
{
error (_("conflict list found without a dynamic symbol table\n"));
- return 0;
+ return FALSE;
}
iconf = (Elf32_Conflict *) cmalloc (conflictsno, sizeof (* iconf));
if (iconf == NULL)
{
error (_("Out of memory allocating space for dynamic conflicts\n"));
- return 0;
+ return FALSE;
}
if (is_32bit_elf)
get_data (NULL, file, conflicts_offset, conflictsno,
sizeof (* econf32), _("conflict"));
if (!econf32)
- return 0;
+ return FALSE;
for (cnt = 0; cnt < conflictsno; ++cnt)
iconf[cnt] = BYTE_GET (econf32[cnt]);
get_data (NULL, file, conflicts_offset, conflictsno,
sizeof (* econf64), _("conflict"));
if (!econf64)
- return 0;
+ return FALSE;
for (cnt = 0; cnt < conflictsno; ++cnt)
iconf[cnt] = BYTE_GET (econf64[cnt]);
{
error (_("The GOT symbol offset (%lu) is greater than the symbol table size (%lu)\n"),
(unsigned long) gotsym, (unsigned long) symtabno);
- return 0;
+ return FALSE;
}
global_end = local_end + (symtabno - gotsym) * addr_size;
if (global_end < local_end)
{
error (_("Too many GOT symbols: %lu\n"), (unsigned long) symtabno);
- return 0;
+ return FALSE;
}
offset = offset_from_vma (file, pltgot, global_end - pltgot);
global_end - pltgot, 1,
_("Global Offset Table data"));
if (data == NULL)
- return 0;
+ return FALSE;
data_end = data + (global_end - pltgot);
printf (_("\nPrimary GOT:\n"));
if (pltrel == DT_RELA)
{
if (!slurp_rela_relocs (file, rel_offset, pltrelsz, &rels, &count))
- return 0;
+ return FALSE;
}
else
{
if (!slurp_rel_relocs (file, rel_offset, pltrelsz, &rels, &count))
- return 0;
+ return FALSE;
}
ent = mips_pltgot;
data = (unsigned char *) get_data (NULL, file, offset, end - mips_pltgot,
1, _("Procedure Linkage Table data"));
if (data == NULL)
- return 0;
+ return FALSE;
printf ("\nPLT GOT:\n\n");
printf (_(" Reserved entries:\n"));
free (rels);
}
- return 1;
+ return res;
}
-static int
+static bfd_boolean
process_nds32_specific (FILE * file)
{
Elf_Internal_Shdr *sect = NULL;
flag = get_data (NULL, file, sect->sh_offset, 1,
sect->sh_size, _("NDS32 elf flags section"));
+ if (! flag)
+ return FALSE;
+
switch ((*flag) & 0x3)
{
case 0:
return TRUE;
}
-static int
+static bfd_boolean
process_gnu_liblist (FILE * file)
{
Elf_Internal_Shdr * section;
size_t strtab_size;
size_t cnt;
unsigned i;
+ bfd_boolean res = TRUE;
if (! do_arch)
- return 0;
+ return TRUE;
for (i = 0, section = section_headers;
i < elf_header.e_shnum;
_("liblist section data"));
if (elib == NULL)
- break;
- string_sec = section_headers + section->sh_link;
+ {
+ res = FALSE;
+ break;
+ }
+ string_sec = section_headers + section->sh_link;
strtab = (char *) get_data (NULL, file, string_sec->sh_offset, 1,
string_sec->sh_size,
_("liblist string table"));
{
free (elib);
free (strtab);
+ res = FALSE;
break;
}
strtab_size = string_sec->sh_size;
{
Elf32_Lib liblist;
time_t atime;
- char timebuf[20];
+ char timebuf[128];
struct tm * tmp;
liblist.l_name = BYTE_GET (elib[cnt].l_name);
}
}
- return 1;
+ return res;
}
static const char *
return _("NT_VERSION (version)");
case NT_ARCH:
return _("NT_ARCH (architecture)");
+ case NT_GNU_BUILD_ATTRIBUTE_OPEN:
+ return _("NT_GNU_BUILD_ATTRIBUTE_OPEN");
+ case NT_GNU_BUILD_ATTRIBUTE_FUNC:
+ return _("NT_GNU_BUILD_ATTRIBUTE_FUNC");
default:
break;
}
return buff;
}
-static int
+static bfd_boolean
print_core_note (Elf_Internal_Note *pnote)
{
unsigned int addr_size = is_32bit_elf ? 4 : 8;
unsigned char *descdata, *filenames, *descend;
if (pnote->type != NT_FILE)
- return 1;
+ return TRUE;
#ifndef BFD64
if (!is_32bit_elf)
{
printf (_(" Cannot decode 64-bit note in 32-bit build\n"));
/* Still "successful". */
- return 1;
+ return TRUE;
}
#endif
if (pnote->descsz < 2 * addr_size)
{
- printf (_(" Malformed note - too short for header\n"));
- return 0;
+ error (_(" Malformed note - too short for header\n"));
+ return FALSE;
}
descdata = (unsigned char *) pnote->descdata;
if (descdata[pnote->descsz - 1] != '\0')
{
- printf (_(" Malformed note - does not end with \\0\n"));
- return 0;
+ error (_(" Malformed note - does not end with \\0\n"));
+ return FALSE;
}
count = byte_get (descdata, addr_size);
if (pnote->descsz < 2 * addr_size + count * 3 * addr_size)
{
- printf (_(" Malformed note - too short for supplied file count\n"));
- return 0;
+ error (_(" Malformed note - too short for supplied file count\n"));
+ return FALSE;
}
printf (_(" Page size: "));
(int) (4 + 2 * addr_size), _("End"),
(int) (4 + 2 * addr_size), _("Page Offset"));
filenames = descdata + count * 3 * addr_size;
- while (--count > 0)
+ while (count-- > 0)
{
bfd_vma start, end, file_ofs;
if (filenames == descend)
{
- printf (_(" Malformed note - filenames end too early\n"));
- return 0;
+ error (_(" Malformed note - filenames end too early\n"));
+ return FALSE;
}
start = byte_get (descdata, addr_size);
filenames += 1 + strlen ((char *) filenames);
}
- return 1;
+ return TRUE;
}
static const char *
get_gnu_elf_note_type (unsigned e_type)
{
- static char buff[64];
-
+ /* NB/ Keep this switch statement in sync with print_gnu_note (). */
switch (e_type)
{
case NT_GNU_ABI_TAG:
return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
case NT_GNU_GOLD_VERSION:
return _("NT_GNU_GOLD_VERSION (gold version)");
+ case NT_GNU_PROPERTY_TYPE_0:
+ return _("NT_GNU_PROPERTY_TYPE_0");
+ case NT_GNU_BUILD_ATTRIBUTE_OPEN:
+ return _("NT_GNU_BUILD_ATTRIBUTE_OPEN");
+ case NT_GNU_BUILD_ATTRIBUTE_FUNC:
+ return _("NT_GNU_BUILD_ATTRIBUTE_FUNC");
default:
- break;
+ {
+ static char buff[64];
+
+ snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
+ return buff;
+ }
}
+}
- snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
- return buff;
+static void
+decode_x86_isa (unsigned int bitmask)
+{
+ while (bitmask)
+ {
+ unsigned int bit = bitmask & (- bitmask);
+
+ bitmask &= ~ bit;
+ switch (bit)
+ {
+ case GNU_PROPERTY_X86_ISA_1_486: printf ("i486"); break;
+ case GNU_PROPERTY_X86_ISA_1_586: printf ("586"); break;
+ case GNU_PROPERTY_X86_ISA_1_686: printf ("686"); break;
+ case GNU_PROPERTY_X86_ISA_1_SSE: printf ("SSE"); break;
+ case GNU_PROPERTY_X86_ISA_1_SSE2: printf ("SSE2"); break;
+ case GNU_PROPERTY_X86_ISA_1_SSE3: printf ("SSE3"); break;
+ case GNU_PROPERTY_X86_ISA_1_SSSE3: printf ("SSSE3"); break;
+ case GNU_PROPERTY_X86_ISA_1_SSE4_1: printf ("SSE4_1"); break;
+ case GNU_PROPERTY_X86_ISA_1_SSE4_2: printf ("SSE4_2"); break;
+ case GNU_PROPERTY_X86_ISA_1_AVX: printf ("AVX"); break;
+ case GNU_PROPERTY_X86_ISA_1_AVX2: printf ("AVX2"); break;
+ case GNU_PROPERTY_X86_ISA_1_AVX512F: printf ("AVX512F"); break;
+ case GNU_PROPERTY_X86_ISA_1_AVX512CD: printf ("AVX512CD"); break;
+ case GNU_PROPERTY_X86_ISA_1_AVX512ER: printf ("AVX512ER"); break;
+ case GNU_PROPERTY_X86_ISA_1_AVX512PF: printf ("AVX512PF"); break;
+ case GNU_PROPERTY_X86_ISA_1_AVX512VL: printf ("AVX512VL"); break;
+ case GNU_PROPERTY_X86_ISA_1_AVX512DQ: printf ("AVX512DQ"); break;
+ case GNU_PROPERTY_X86_ISA_1_AVX512BW: printf ("AVX512BW"); break;
+ default: printf (_("<unknown: %x>"), bit); break;
+ }
+ if (bitmask)
+ printf (", ");
+ }
+}
+
+static void
+print_gnu_property_note (Elf_Internal_Note * pnote)
+{
+ unsigned char * ptr = (unsigned char *) pnote->descdata;
+ unsigned char * ptr_end = ptr + pnote->descsz;
+ unsigned int size = is_32bit_elf ? 4 : 8;
+
+ printf (_(" Properties: "));
+
+ if (pnote->descsz < 8 || (pnote->descsz % size) != 0)
+ {
+ printf (_("<corrupt GNU_PROPERTY_TYPE, size = %#lx>\n"), pnote->descsz);
+ return;
+ }
+
+ while (1)
+ {
+ unsigned int j;
+ unsigned int type = byte_get (ptr, 4);
+ unsigned int datasz = byte_get (ptr + 4, 4);
+
+ ptr += 8;
+
+ if ((ptr + datasz) > ptr_end)
+ {
+ printf (_("<corrupt type (%#x) datasz: %#x>\n"),
+ type, datasz);
+ break;
+ }
+
+ if (type >= GNU_PROPERTY_LOPROC && type <= GNU_PROPERTY_HIPROC)
+ {
+ if (elf_header.e_machine == EM_X86_64
+ || elf_header.e_machine == EM_IAMCU
+ || elf_header.e_machine == EM_386)
+ {
+ switch (type)
+ {
+ case GNU_PROPERTY_X86_ISA_1_USED:
+ printf ("x86 ISA used: ");
+ if (datasz != 4)
+ printf (_("<corrupt length: %#x> "), datasz);
+ else
+ decode_x86_isa (byte_get (ptr, 4));
+ goto next;
+
+ case GNU_PROPERTY_X86_ISA_1_NEEDED:
+ printf ("x86 ISA needed: ");
+ if (datasz != 4)
+ printf (_("<corrupt length: %#x> "), datasz);
+ else
+ decode_x86_isa (byte_get (ptr, 4));
+ goto next;
+
+ default:
+ break;
+ }
+ }
+ }
+ else
+ {
+ switch (type)
+ {
+ case GNU_PROPERTY_STACK_SIZE:
+ printf (_("stack size: "));
+ if (datasz != size)
+ printf (_("<corrupt length: %#x> "), datasz);
+ else
+ printf ("%#lx", (unsigned long) byte_get (ptr, size));
+ goto next;
+
+ case GNU_PROPERTY_NO_COPY_ON_PROTECTED:
+ printf ("no copy on protected ");
+ if (datasz)
+ printf (_("<corrupt length: %#x> "), datasz);
+ goto next;
+
+ default:
+ break;
+ }
+ }
+
+ if (type < GNU_PROPERTY_LOPROC)
+ printf (_("<unknown type %#x data: "), type);
+ else if (type < GNU_PROPERTY_LOUSER)
+ printf (_("<procesor-specific type %#x data: "), type);
+ else
+ printf (_("<application-specific type %#x data: "), type);
+ for (j = 0; j < datasz; ++j)
+ printf ("%02x ", ptr[j] & 0xff);
+ printf (">");
+
+next:
+ ptr += ((datasz + (size - 1)) & ~ (size - 1));
+ if (ptr == ptr_end)
+ break;
+ else
+ {
+ if (do_wide)
+ printf (", ");
+ else
+ printf ("\n\t");
+ }
+
+ if (ptr > (ptr_end - 8))
+ {
+ printf (_("<corrupt descsz: %#lx>\n"), pnote->descsz);
+ break;
+ }
+ }
+
+ printf ("\n");
}
-static int
+static bfd_boolean
print_gnu_note (Elf_Internal_Note *pnote)
{
+ /* NB/ Keep this switch statement in sync with get_gnu_elf_note_type (). */
switch (pnote->type)
{
case NT_GNU_BUILD_ID:
case GNU_ABI_TAG_NETBSD:
osname = "NetBSD";
break;
+ case GNU_ABI_TAG_SYLLABLE:
+ osname = "Syllable";
+ break;
+ case GNU_ABI_TAG_NACL:
+ osname = "NaCl";
+ break;
default:
osname = "Unknown";
break;
printf ("\n");
}
break;
+
+ case NT_GNU_HWCAP:
+ {
+ unsigned long num_entries, mask;
+
+ /* Hardware capabilities information. Word 0 is the number of entries.
+ Word 1 is a bitmask of enabled entries. The rest of the descriptor
+ is a series of entries, where each entry is a single byte followed
+ by a nul terminated string. The byte gives the bit number to test
+ if enabled in the bitmask. */
+ printf (_(" Hardware Capabilities: "));
+ if (pnote->descsz < 8)
+ {
+ error (_("<corrupt GNU_HWCAP>\n"));
+ return FALSE;
+ }
+ num_entries = byte_get ((unsigned char *) pnote->descdata, 4);
+ mask = byte_get ((unsigned char *) pnote->descdata + 4, 4);
+ printf (_("num entries: %ld, enabled mask: %lx\n"), num_entries, mask);
+ /* FIXME: Add code to display the entries... */
+ }
+ break;
+
+ case NT_GNU_PROPERTY_TYPE_0:
+ print_gnu_property_note (pnote);
+ break;
+
+ default:
+ /* Handle unrecognised types. An error message should have already been
+ created by get_gnu_elf_note_type(), so all that we need to do is to
+ display the data. */
+ {
+ unsigned long i;
+
+ printf (_(" Description data: "));
+ for (i = 0; i < pnote->descsz; ++i)
+ printf ("%02x ", pnote->descdata[i] & 0xff);
+ printf ("\n");
+ }
+ break;
}
- return 1;
+ return TRUE;
}
static const char *
}
}
-static int
+static bfd_boolean
print_v850_note (Elf_Internal_Note * pnote)
{
unsigned int val;
if (pnote->descsz != 4)
- return 0;
+ return FALSE;
+
val = byte_get ((unsigned char *) pnote->descdata, pnote->descsz);
if (val == 0)
{
printf (_("not set\n"));
- return 1;
+ return TRUE;
}
switch (pnote->type)
case V850_NOTE_ALIGNMENT:
switch (val)
{
- case EF_RH850_DATA_ALIGN4: printf (_("4-byte\n")); return 1;
- case EF_RH850_DATA_ALIGN8: printf (_("8-byte\n")); return 1;
+ case EF_RH850_DATA_ALIGN4: printf (_("4-byte\n")); return TRUE;
+ case EF_RH850_DATA_ALIGN8: printf (_("8-byte\n")); return TRUE;
}
break;
-
+
case V850_NOTE_DATA_SIZE:
switch (val)
{
- case EF_RH850_DOUBLE32: printf (_("4-bytes\n")); return 1;
- case EF_RH850_DOUBLE64: printf (_("8-bytes\n")); return 1;
+ case EF_RH850_DOUBLE32: printf (_("4-bytes\n")); return TRUE;
+ case EF_RH850_DOUBLE64: printf (_("8-bytes\n")); return TRUE;
}
break;
-
+
case V850_NOTE_FPU_INFO:
switch (val)
{
- case EF_RH850_FPU20: printf (_("FPU-2.0\n")); return 1;
- case EF_RH850_FPU30: printf (_("FPU-3.0\n")); return 1;
+ case EF_RH850_FPU20: printf (_("FPU-2.0\n")); return TRUE;
+ case EF_RH850_FPU30: printf (_("FPU-3.0\n")); return TRUE;
}
break;
-
+
case V850_NOTE_MMU_INFO:
case V850_NOTE_CACHE_INFO:
case V850_NOTE_SIMD_INFO:
if (val == EF_RH850_SIMD)
{
printf (_("yes\n"));
- return 1;
+ return TRUE;
}
break;
}
printf (_("unknown value: %x\n"), val);
- return 0;
+ return FALSE;
+}
+
+static bfd_boolean
+process_netbsd_elf_note (Elf_Internal_Note * pnote)
+{
+ unsigned int version;
+
+ switch (pnote->type)
+ {
+ case NT_NETBSD_IDENT:
+ version = byte_get ((unsigned char *) pnote->descdata, sizeof (version));
+ if ((version / 10000) % 100)
+ printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u%s%c)\n", pnote->descsz,
+ version, version / 100000000, (version / 1000000) % 100,
+ (version / 10000) % 100 > 26 ? "Z" : "",
+ 'A' + (version / 10000) % 26);
+ else
+ printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u.%u)\n", pnote->descsz,
+ version, version / 100000000, (version / 1000000) % 100,
+ (version / 100) % 100);
+ return TRUE;
+
+ case NT_NETBSD_MARCH:
+ printf (" NetBSD\t0x%08lx\tMARCH <%s>\n", pnote->descsz,
+ pnote->descdata);
+ return TRUE;
+
+ default:
+ printf (" NetBSD\t0x%08lx\tUnknown note type: (0x%08lx)\n", pnote->descsz,
+ pnote->type);
+ return FALSE;
+ }
+}
+
+static const char *
+get_freebsd_elfcore_note_type (unsigned e_type)
+{
+ switch (e_type)
+ {
+ case NT_FREEBSD_THRMISC:
+ return _("NT_THRMISC (thrmisc structure)");
+ case NT_FREEBSD_PROCSTAT_PROC:
+ return _("NT_PROCSTAT_PROC (proc data)");
+ case NT_FREEBSD_PROCSTAT_FILES:
+ return _("NT_PROCSTAT_FILES (files data)");
+ case NT_FREEBSD_PROCSTAT_VMMAP:
+ return _("NT_PROCSTAT_VMMAP (vmmap data)");
+ case NT_FREEBSD_PROCSTAT_GROUPS:
+ return _("NT_PROCSTAT_GROUPS (groups data)");
+ case NT_FREEBSD_PROCSTAT_UMASK:
+ return _("NT_PROCSTAT_UMASK (umask data)");
+ case NT_FREEBSD_PROCSTAT_RLIMIT:
+ return _("NT_PROCSTAT_RLIMIT (rlimit data)");
+ case NT_FREEBSD_PROCSTAT_OSREL:
+ return _("NT_PROCSTAT_OSREL (osreldate data)");
+ case NT_FREEBSD_PROCSTAT_PSSTRINGS:
+ return _("NT_PROCSTAT_PSSTRINGS (ps_strings data)");
+ case NT_FREEBSD_PROCSTAT_AUXV:
+ return _("NT_PROCSTAT_AUXV (auxv data)");
+ }
+ return get_note_type (e_type);
}
static const char *
return buff;
}
-static int
+static bfd_boolean
print_stapsdt_note (Elf_Internal_Note *pnote)
{
int addr_size = is_32bit_elf ? 4 : 8;
}
}
-static int
+static bfd_boolean
print_ia64_vms_note (Elf_Internal_Note * pnote)
{
switch (pnote->type)
printf (_(" Linker id: %s\n"), pnote->descdata);
break;
default:
- break;
+ return FALSE;
}
- return 1;
+ return TRUE;
+}
+
+/* Print the name of the symbol associated with a build attribute
+ that is attached to address OFFSET. */
+
+static bfd_boolean
+print_symbol_for_build_attribute (FILE * file,
+ unsigned long offset,
+ bfd_boolean is_open_attr)
+{
+ static FILE * saved_file = NULL;
+ static char * strtab;
+ static unsigned long strtablen;
+ static Elf_Internal_Sym * symtab;
+ static unsigned long nsyms;
+ Elf_Internal_Sym * saved_sym = NULL;
+ Elf_Internal_Sym * sym;
+
+ if (saved_file == NULL || file != saved_file)
+ {
+ Elf_Internal_Shdr * symsec;
+
+ /* Load the symbol and string sections. */
+ for (symsec = section_headers;
+ symsec < section_headers + elf_header.e_shnum;
+ symsec ++)
+ {
+ if (symsec->sh_type == SHT_SYMTAB)
+ {
+ symtab = GET_ELF_SYMBOLS (file, symsec, & nsyms);
+
+ if (symsec->sh_link < elf_header.e_shnum)
+ {
+ Elf_Internal_Shdr * strtab_sec = section_headers + symsec->sh_link;
+
+ strtab = (char *) get_data (NULL, file, strtab_sec->sh_offset,
+ 1, strtab_sec->sh_size,
+ _("string table"));
+ strtablen = strtab != NULL ? strtab_sec->sh_size : 0;
+ }
+ }
+ }
+ saved_file = file;
+ }
+
+ if (symtab == NULL || strtab == NULL)
+ {
+ printf ("\n");
+ return FALSE;
+ }
+
+ /* Find a symbol whose value matches offset. */
+ for (sym = symtab; sym < symtab + nsyms; sym ++)
+ if (sym->st_value == offset)
+ {
+ if (sym->st_name >= strtablen)
+ /* Huh ? This should not happen. */
+ continue;
+
+ if (strtab[sym->st_name] == 0)
+ continue;
+
+ if (is_open_attr)
+ {
+ /* For OPEN attributes we prefer GLOBAL over LOCAL symbols
+ and FILE or OBJECT symbols over NOTYPE symbols. We skip
+ FUNC symbols entirely. */
+ switch (ELF_ST_TYPE (sym->st_info))
+ {
+ case STT_FILE:
+ saved_sym = sym;
+ /* We can stop searching now. */
+ sym = symtab + nsyms;
+ continue;
+
+ case STT_OBJECT:
+ saved_sym = sym;
+ continue;
+
+ case STT_FUNC:
+ /* Ignore function symbols. */
+ continue;
+
+ default:
+ break;
+ }
+
+ switch (ELF_ST_BIND (sym->st_info))
+ {
+ case STB_GLOBAL:
+ if (saved_sym == NULL
+ || ELF_ST_TYPE (saved_sym->st_info) != STT_OBJECT)
+ saved_sym = sym;
+ break;
+
+ case STB_LOCAL:
+ if (saved_sym == NULL)
+ saved_sym = sym;
+ break;
+
+ default:
+ break;
+ }
+ }
+ else
+ {
+ if (ELF_ST_TYPE (sym->st_info) != STT_FUNC)
+ continue;
+
+ saved_sym = sym;
+ break;
+ }
+ }
+
+ printf (" (%s: %s)\n",
+ is_open_attr ? _("file") : _("func"),
+ saved_sym ? strtab + saved_sym->st_name : _("<no symbol found>)"));
+ return TRUE;
+}
+
+static bfd_boolean
+print_gnu_build_attribute_description (Elf_Internal_Note * pnote,
+ FILE * file)
+{
+ static unsigned long global_offset = 0;
+ unsigned long offset;
+ unsigned int desc_size = is_32bit_elf ? 4 : 8;
+ bfd_boolean is_open_attr = pnote->type == NT_GNU_BUILD_ATTRIBUTE_OPEN;
+
+ if (pnote->descsz == 0)
+ {
+ if (is_open_attr)
+ {
+ printf (_(" Applies from offset %#lx\n"), global_offset);
+ return TRUE;
+ }
+ else
+ {
+ printf (_(" Applies to func at %#lx"), global_offset);
+ return print_symbol_for_build_attribute (file, global_offset, is_open_attr);
+ }
+ }
+
+ if (pnote->descsz != desc_size)
+ {
+ error (_(" <invalid description size: %lx>\n"), pnote->descsz);
+ printf (_(" <invalid descsz>"));
+ return FALSE;
+ }
+
+ offset = byte_get ((unsigned char *) pnote->descdata, desc_size);
+
+ if (is_open_attr)
+ {
+ printf (_(" Applies from offset %#lx"), offset);
+ global_offset = offset;
+ }
+ else
+ {
+ printf (_(" Applies to func at %#lx"), offset);
+ }
+
+ return print_symbol_for_build_attribute (file, offset, is_open_attr);
+}
+
+static bfd_boolean
+print_gnu_build_attribute_name (Elf_Internal_Note * pnote)
+{
+ char name_type;
+ char name_attribute;
+ char * expected_types;
+ const char * name = pnote->namedata;
+ const char * text;
+ int left;
+
+ if (name == NULL || pnote->namesz < 2)
+ {
+ error (_("corrupt name field in GNU build attribute note: size = %ld\n"), pnote->namesz);
+ print_symbol (-20, _(" <corrupt name field>"));
+ return FALSE;
+ }
+
+ switch ((name_type = * name))
+ {
+ case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC:
+ case GNU_BUILD_ATTRIBUTE_TYPE_STRING:
+ case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE:
+ case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE:
+ printf ("%c", * name);
+ break;
+ default:
+ error (_("unrecognised attribute type in name field: %d\n"), name_type);
+ print_symbol (-20, _("<unknown name type>"));
+ return FALSE;
+ }
+
+ left = 19;
+ ++ name;
+ text = NULL;
+
+ switch ((name_attribute = * name))
+ {
+ case GNU_BUILD_ATTRIBUTE_VERSION:
+ text = _("<version>");
+ expected_types = "$";
+ ++ name;
+ break;
+ case GNU_BUILD_ATTRIBUTE_STACK_PROT:
+ text = _("<stack prot>");
+ expected_types = "!+";
+ ++ name;
+ break;
+ case GNU_BUILD_ATTRIBUTE_RELRO:
+ text = _("<relro>");
+ expected_types = "!+";
+ ++ name;
+ break;
+ case GNU_BUILD_ATTRIBUTE_STACK_SIZE:
+ text = _("<stack size>");
+ expected_types = "*";
+ ++ name;
+ break;
+ case GNU_BUILD_ATTRIBUTE_TOOL:
+ text = _("<tool>");
+ expected_types = "$";
+ ++ name;
+ break;
+ case GNU_BUILD_ATTRIBUTE_ABI:
+ text = _("<ABI>");
+ expected_types = "$*";
+ ++ name;
+ break;
+ case GNU_BUILD_ATTRIBUTE_PIC:
+ text = _("<PIC>");
+ expected_types = "*";
+ ++ name;
+ break;
+
+ default:
+ if (ISPRINT (* name))
+ {
+ int len = strnlen (name, pnote->namesz - (name - pnote->namedata)) + 1;
+
+ if (len > left && ! do_wide)
+ len = left;
+ printf ("%.*s ", len, name);
+ left -= len;
+ name += len + 1;
+ }
+ else
+ {
+ error (_("unexpected character in name field\n"));
+ print_symbol (- left, _("<unknown attribute>"));
+ return 0;
+ }
+ expected_types = "*$!+";
+ break;
+ }
+
+ if (text)
+ {
+ printf ("%s", text);
+ left -= strlen (text);
+ }
+
+ if (strchr (expected_types, name_type) == NULL)
+ warn (_("attribute does not have the expected type\n"));
+
+ if ((unsigned long)(name - pnote->namedata) > pnote->namesz)
+ {
+ error (_("corrupt name field: namesz: %lu but parsing gets to %ld\n"),
+ (unsigned long) pnote->namesz,
+ (long) (name - pnote->namedata));
+ return FALSE;
+ }
+
+ if (left < 1 && ! do_wide)
+ return TRUE;
+
+ switch (name_type)
+ {
+ case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC:
+ {
+ unsigned int bytes = pnote->namesz - (name - pnote->namedata);
+ unsigned long val = 0;
+ unsigned int shift = 0;
+
+ while (bytes --)
+ {
+ unsigned long byte = (* name ++) & 0xff;
+
+ val |= byte << shift;
+ shift += 8;
+ }
+
+ if (name_attribute == GNU_BUILD_ATTRIBUTE_PIC)
+ {
+ char * pic_type = NULL;
+
+ switch (val)
+ {
+ case 0: pic_type = "static"; break;
+ case 1: pic_type = "pic"; break;
+ case 2: pic_type = "PIC"; break;
+ case 3: pic_type = "pie"; break;
+ case 4: pic_type = "PIE"; break;
+ }
+
+ if (pic_type != NULL)
+ {
+ if (do_wide)
+ left -= printf ("%s", pic_type);
+ else
+ left -= printf ("%-.*s", left, pic_type);
+ break;
+ }
+ }
+
+ if (do_wide)
+ left -= printf ("0x%lx", val);
+ else
+ left -= printf ("0x%-.*lx", left, val);
+ }
+ break;
+ case GNU_BUILD_ATTRIBUTE_TYPE_STRING:
+ left -= print_symbol (- left, name);
+ break;
+ case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE:
+ left -= print_symbol (- left, "true");
+ break;
+ case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE:
+ left -= print_symbol (- left, "false");
+ break;
+ }
+
+ if (do_wide && left > 0)
+ printf ("%-*s", left, " ");
+
+ return TRUE;
}
/* Note that by the ELF standard, the name field is already null byte
I.E. the value of namesz for the name "FSF" is 4.
If the value of namesz is zero, there is no name present. */
-static int
-process_note (Elf_Internal_Note * pnote)
+
+static bfd_boolean
+process_note (Elf_Internal_Note * pnote,
+ FILE * file)
{
const char * name = pnote->namesz ? pnote->namedata : "(NONE)";
const char * nt;
/* GNU-specific object file notes. */
nt = get_gnu_elf_note_type (pnote->type);
+ else if (const_strneq (pnote->namedata, "FreeBSD"))
+ /* FreeBSD-specific core file notes. */
+ nt = get_freebsd_elfcore_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 (const_strneq (pnote->namedata, "NetBSD"))
+ /* NetBSD-specific core file notes. */
+ return process_netbsd_elf_note (pnote);
+
else if (strneq (pnote->namedata, "SPU/", 4))
{
/* SPU-specific core file notes. */
note type strings. */
nt = get_note_type (pnote->type);
- printf (" %-20s 0x%08lx\t%s\n", name, pnote->descsz, nt);
+ printf (" ");
+
+ if (pnote->type == NT_GNU_BUILD_ATTRIBUTE_OPEN
+ || pnote->type == NT_GNU_BUILD_ATTRIBUTE_FUNC)
+ print_gnu_build_attribute_name (pnote);
+ else
+ print_symbol (-20, name);
+
+ if (do_wide)
+ printf (" 0x%08lx\t%s\t", pnote->descsz, nt);
+ else
+ printf (" 0x%08lx\t%s\n", pnote->descsz, nt);
if (const_strneq (pnote->namedata, "IPF/VMS"))
return print_ia64_vms_note (pnote);
return print_stapsdt_note (pnote);
else if (const_strneq (pnote->namedata, "CORE"))
return print_core_note (pnote);
- else
- return 1;
-}
+ else if (pnote->type == NT_GNU_BUILD_ATTRIBUTE_OPEN
+ || pnote->type == NT_GNU_BUILD_ATTRIBUTE_FUNC)
+ return print_gnu_build_attribute_description (pnote, file);
+ if (pnote->descsz)
+ {
+ unsigned long i;
-static int
-process_corefile_note_segment (FILE * file, bfd_vma offset, bfd_vma length)
+ printf (_(" description data: "));
+ for (i = 0; i < pnote->descsz; i++)
+ printf ("%02x ", pnote->descdata[i]);
+ }
+
+ if (do_wide)
+ printf ("\n");
+
+ return TRUE;
+}
+
+static bfd_boolean
+process_notes_at (FILE * file,
+ Elf_Internal_Shdr * section,
+ bfd_vma offset,
+ bfd_vma length)
{
Elf_External_Note * pnotes;
Elf_External_Note * external;
char * end;
- int res = 1;
+ bfd_boolean res = TRUE;
if (length <= 0)
- return 0;
+ return FALSE;
- pnotes = (Elf_External_Note *) get_data (NULL, file, offset, 1, length,
- _("notes"));
+ if (section)
+ {
+ pnotes = (Elf_External_Note *) get_section_contents (section, file);
+ if (pnotes)
+ {
+ if (! apply_relocations (file, section, (unsigned char *) pnotes, length, NULL, NULL))
+ return FALSE;
+ }
+ }
+ else
+ pnotes = (Elf_External_Note *) get_data (NULL, file, offset, 1, length,
+ _("notes"));
if (pnotes == NULL)
- return 0;
+ return FALSE;
external = pnotes;
- printf (_("\nDisplaying notes found at file offset 0x%08lx with length 0x%08lx:\n"),
- (unsigned long) offset, (unsigned long) length);
+ if (section)
+ printf (_("\nDisplaying notes found in: %s\n"), printable_section_name (section));
+ else
+ printf (_("\nDisplaying notes found at file offset 0x%08lx with length 0x%08lx:\n"),
+ (unsigned long) offset, (unsigned long) length);
+
printf (_(" %-20s %10s\tDescription\n"), _("Owner"), _("Data size"));
end = (char *) pnotes + length;
/* PR 17531: file: 3443835e. */
if (inote.descdata < (char *) pnotes || inote.descdata > end)
{
- warn (_("Corrupt note: name size is too big: %lx\n"), inote.namesz);
+ warn (_("Corrupt note: name size is too big: (got: %lx, expected no more than: %lx)\n"),
+ inote.namesz, (long)(end - inote.namedata));
inote.descdata = inote.namedata;
inote.namesz = 0;
}
-
+
inote.descpos = offset + (inote.descdata - (char *) pnotes);
next = inote.descdata + align_power (inote.descsz, 2);
}
if (temp == NULL)
{
error (_("Out of memory allocating space for inote name\n"));
- res = 0;
+ res = FALSE;
break;
}
- strncpy (temp, inote.namedata, inote.namesz);
+ memcpy (temp, inote.namedata, inote.namesz);
temp[inote.namesz] = 0;
/* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
inote.namedata = temp;
}
- res &= process_note (& inote);
+ if (! process_note (& inote, file))
+ res = FALSE;
if (temp != NULL)
{
return res;
}
-static int
+static bfd_boolean
process_corefile_note_segments (FILE * file)
{
Elf_Internal_Phdr * segment;
unsigned int i;
- int res = 1;
+ bfd_boolean res = TRUE;
if (! get_program_headers (file))
- return 0;
+ return TRUE;
for (i = 0, segment = program_headers;
i < elf_header.e_phnum;
i++, segment++)
{
if (segment->p_type == PT_NOTE)
- res &= process_corefile_note_segment (file,
- (bfd_vma) segment->p_offset,
- (bfd_vma) segment->p_filesz);
+ if (! process_notes_at (file, NULL,
+ (bfd_vma) segment->p_offset,
+ (bfd_vma) segment->p_filesz))
+ res = FALSE;
}
return res;
}
-static int
+static bfd_boolean
process_v850_notes (FILE * file, bfd_vma offset, bfd_vma length)
{
Elf_External_Note * pnotes;
Elf_External_Note * external;
char * end;
- int res = 1;
+ bfd_boolean res = TRUE;
if (length <= 0)
- return 0;
+ return FALSE;
pnotes = (Elf_External_Note *) get_data (NULL, file, offset, 1, length,
_("v850 notes"));
if (pnotes == NULL)
- return 0;
+ return FALSE;
external = pnotes;
end = (char*) pnotes + length;
if (! print_v850_note (& inote))
{
- res = 0;
+ res = FALSE;
printf ("<corrupt sizes: namesz: %lx, descsz: %lx>\n",
inote.namesz, inote.descsz);
}
return res;
}
-static int
+static bfd_boolean
process_note_sections (FILE * file)
{
Elf_Internal_Shdr * section;
unsigned long i;
- int n = 0;
- int res = 1;
+ unsigned int n = 0;
+ bfd_boolean res = TRUE;
for (i = 0, section = section_headers;
i < elf_header.e_shnum && section != NULL;
{
if (section->sh_type == SHT_NOTE)
{
- res &= process_corefile_note_segment (file,
- (bfd_vma) section->sh_offset,
- (bfd_vma) section->sh_size);
+ if (! process_notes_at (file, section,
+ (bfd_vma) section->sh_offset,
+ (bfd_vma) section->sh_size))
+ res = FALSE;
n++;
}
|| elf_header.e_machine == EM_CYGNUS_V850)
&& section->sh_type == SHT_RENESAS_INFO)
{
- res &= process_v850_notes (file,
- (bfd_vma) section->sh_offset,
- (bfd_vma) section->sh_size);
+ if (! process_v850_notes (file,
+ (bfd_vma) section->sh_offset,
+ (bfd_vma) section->sh_size))
+ res = FALSE;
n++;
}
}
return res;
}
-static int
+static bfd_boolean
process_notes (FILE * file)
{
/* If we have not been asked to display the notes then do nothing. */
if (! do_notes)
- return 1;
+ return TRUE;
if (elf_header.e_type != ET_CORE)
return process_note_sections (file);
return process_corefile_note_segments (file);
printf (_("No note segments present in the core file.\n"));
- return 1;
+ return TRUE;
+}
+
+static unsigned char *
+display_public_gnu_attributes (unsigned char * start,
+ const unsigned char * const end)
+{
+ printf (_(" Unknown GNU attribute: %s\n"), start);
+
+ start += strnlen ((char *) start, end - start);
+ display_raw_attribute (start, end);
+
+ return (unsigned char *) end;
}
-static int
+static unsigned char *
+display_generic_attribute (unsigned char * start,
+ unsigned int tag,
+ const unsigned char * const end)
+{
+ if (tag == 0)
+ return (unsigned char *) end;
+
+ return display_tag_value (tag, start, end);
+}
+
+static bfd_boolean
process_arch_specific (FILE * file)
{
if (! do_arch)
- return 1;
+ return TRUE;
switch (elf_header.e_machine)
{
case EM_ARM:
- return process_arm_specific (file);
+ return process_attributes (file, "aeabi", SHT_ARM_ATTRIBUTES,
+ display_arm_attribute,
+ display_generic_attribute);
+
case EM_MIPS:
case EM_MIPS_RS3_LE:
return process_mips_specific (file);
- break;
+
+ case EM_MSP430:
+ return process_attributes (file, "mspabi", SHT_MSP430_ATTRIBUTES,
+ display_msp430x_attribute,
+ display_generic_attribute);
+
case EM_NDS32:
return process_nds32_specific (file);
- break;
+
case EM_PPC:
- return process_power_specific (file);
- break;
+ case EM_PPC64:
+ return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
+ display_power_gnu_attribute);
+
case EM_S390:
case EM_S390_OLD:
- return process_s390_specific (file);
- break;
+ return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
+ display_s390_gnu_attribute);
+
case EM_SPARC:
case EM_SPARC32PLUS:
case EM_SPARCV9:
- return process_sparc_specific (file);
- break;
+ return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
+ display_sparc_gnu_attribute);
+
case EM_TI_C6000:
- return process_tic6x_specific (file);
- break;
- case EM_MSP430:
- return process_msp430x_specific (file);
+ return process_attributes (file, "c6xabi", SHT_C6000_ATTRIBUTES,
+ display_tic6x_attribute,
+ display_generic_attribute);
+
default:
- break;
+ return process_attributes (file, "gnu", SHT_GNU_ATTRIBUTES,
+ display_public_gnu_attributes,
+ display_generic_attribute);
}
- return 1;
}
-static int
+static bfd_boolean
get_file_header (FILE * file)
{
/* Read in the identity array. */
if (fread (elf_header.e_ident, EI_NIDENT, 1, file) != 1)
- return 0;
+ return FALSE;
/* Determine how to read the rest of the header. */
switch (elf_header.e_ident[EI_DATA])
{
- default: /* fall through */
- case ELFDATANONE: /* fall through */
+ default:
+ case ELFDATANONE:
case ELFDATA2LSB:
byte_get = byte_get_little_endian;
byte_put = byte_put_little_endian;
Elf32_External_Ehdr ehdr32;
if (fread (ehdr32.e_type, sizeof (ehdr32) - EI_NIDENT, 1, file) != 1)
- return 0;
+ return FALSE;
elf_header.e_type = BYTE_GET (ehdr32.e_type);
elf_header.e_machine = BYTE_GET (ehdr32.e_machine);
{
error (_("This instance of readelf has been built without support for a\n\
64 bit data type and so it cannot read 64 bit ELF files.\n"));
- return 0;
+ return FALSE;
}
if (fread (ehdr64.e_type, sizeof (ehdr64) - EI_NIDENT, 1, file) != 1)
- return 0;
+ return FALSE;
elf_header.e_type = BYTE_GET (ehdr64.e_type);
elf_header.e_machine = BYTE_GET (ehdr64.e_machine);
get_64bit_section_headers (file, TRUE);
}
- return 1;
+ return TRUE;
}
/* Process one ELF object file according to the command line options.
This file may actually be stored in an archive. The file is
- positioned at the start of the ELF object. */
+ positioned at the start of the ELF object. Returns TRUE if no
+ problems were encountered, FALSE otherwise. */
-static int
+static bfd_boolean
process_object (char * file_name, FILE * file)
{
unsigned int i;
+ bfd_boolean res = TRUE;
if (! get_file_header (file))
{
error (_("%s: Failed to read file header\n"), file_name);
- return 1;
+ return FALSE;
}
/* Initialise per file variables. */
}
if (! process_file_header ())
- return 1;
+ return FALSE;
if (! process_section_headers (file))
{
- /* Without loaded section headers we cannot process lots of
- things. */
- do_unwind = do_version = do_dump = do_arch = 0;
+ /* Without loaded section headers we cannot process lots of things. */
+ do_unwind = do_version = do_dump = do_arch = FALSE;
if (! do_using_dynamic)
- do_syms = do_dyn_syms = do_reloc = 0;
+ do_syms = do_dyn_syms = do_reloc = FALSE;
}
if (! process_section_groups (file))
- {
- /* Without loaded section groups we cannot process unwind. */
- do_unwind = 0;
- }
+ /* Without loaded section groups we cannot process unwind. */
+ do_unwind = FALSE;
if (process_program_headers (file))
process_dynamic_section (file);
+ else
+ res = FALSE;
- process_relocs (file);
+ if (! process_relocs (file))
+ res = FALSE;
- process_unwind (file);
+ if (! process_unwind (file))
+ res = FALSE;
- process_symbol_table (file);
+ if (! process_symbol_table (file))
+ res = FALSE;
- process_syminfo (file);
+ if (! process_syminfo (file))
+ res = FALSE;
- process_version_sections (file);
+ if (! process_version_sections (file))
+ res = FALSE;
- process_section_contents (file);
+ if (! process_section_contents (file))
+ res = FALSE;
- process_notes (file);
+ if (! process_notes (file))
+ res = FALSE;
- process_gnu_liblist (file);
+ if (! process_gnu_liblist (file))
+ res = FALSE;
- process_arch_specific (file);
+ if (! process_arch_specific (file))
+ res = FALSE;
if (program_headers)
{
free_debug_memory ();
- return 0;
+ return res;
}
/* Process an ELF archive.
- On entry the file is positioned just after the ARMAG string. */
+ On entry the file is positioned just after the ARMAG string.
+ Returns TRUE upon success, FALSE otherwise. */
-static int
+static bfd_boolean
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;
+ bfd_boolean ret = TRUE;
- show_name = 1;
+ show_name = TRUE;
/* The ARCH structure is used to hold information about this archive. */
arch.file_name = NULL;
if (setup_archive (&arch, file_name, file, is_thin_archive, do_archive_index) != 0)
{
- ret = 1;
+ ret = FALSE;
goto out;
}
{
error (_("%s: end of the symbol table reached before the end of the index\n"),
file_name);
+ ret = FALSE;
break;
}
/* PR 17531: file: 0b6630b2. */
l += l & 1;
if (l < arch.sym_size)
- error (_("%s: %ld bytes remain in the symbol table, but without corresponding entries in the index table\n"),
- file_name, arch.sym_size - l);
+ {
+ error (_("%s: %ld bytes remain in the symbol table, but without corresponding entries in the index table\n"),
+ file_name, arch.sym_size - l);
+ ret = FALSE;
+ }
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);
- ret = 1;
+ ret = FALSE;
goto out;
}
}
&& !do_histogram && !do_debugging && !do_arch && !do_notes
&& !do_section_groups && !do_dyn_syms)
{
- ret = 0; /* Archive index only. */
+ ret = TRUE; /* Archive index only. */
goto out;
}
}
- ret = 0;
-
while (1)
{
char * name;
if (fseek (file, arch.next_arhdr_offset, SEEK_SET) != 0)
{
error (_("%s: failed to seek to next archive header\n"), file_name);
- return 1;
+ return FALSE;
}
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;
+ ret = FALSE;
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;
+ ret = FALSE;
break;
}
if (name == NULL)
{
error (_("%s: bad archive file name\n"), file_name);
- ret = 1;
+ ret = FALSE;
break;
}
namelen = strlen (name);
if (qualified_name == NULL)
{
error (_("%s: bad archive file name\n"), file_name);
- ret = 1;
+ ret = FALSE;
break;
}
/* 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;
+ ret = FALSE;
break;
}
{
error (_("Input file '%s' is not readable.\n"), member_file_name);
free (member_file_name);
- ret = 1;
+ ret = FALSE;
break;
}
archive_file_offset = arch.nested_member_origin;
- ret |= process_object (qualified_name, member_file);
+ if (! process_object (qualified_name, member_file))
+ ret = FALSE;
fclose (member_file);
free (member_file_name);
{
error (_("%s: contains corrupt thin archive: %s\n"),
file_name, name);
- ret = 1;
+ ret = FALSE;
break;
}
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;
+ ret = FALSE;
break;
}
- ret |= process_object (qualified_name, nested_arch.file);
+ if (! process_object (qualified_name, nested_arch.file))
+ ret = FALSE;
}
else
{
archive_file_offset = arch.next_arhdr_offset;
arch.next_arhdr_offset += archive_file_size;
- ret |= process_object (qualified_name, file);
+ if (! process_object (qualified_name, file))
+ ret = FALSE;
}
if (dump_sects != NULL)
return ret;
}
-static int
+static bfd_boolean
process_file (char * file_name)
{
FILE * file;
struct stat statbuf;
char armag[SARMAG];
- int ret;
+ bfd_boolean ret = TRUE;
if (stat (file_name, &statbuf) < 0)
{
else
error (_("Could not locate '%s'. System error message: %s\n"),
file_name, strerror (errno));
- return 1;
+ return FALSE;
}
if (! S_ISREG (statbuf.st_mode))
{
error (_("'%s' is not an ordinary file\n"), file_name);
- return 1;
+ return FALSE;
}
file = fopen (file_name, "rb");
if (file == NULL)
{
error (_("Input file '%s' is not readable.\n"), file_name);
- return 1;
+ return FALSE;
}
if (fread (armag, SARMAG, 1, file) != 1)
{
error (_("%s: Failed to read file's magic number\n"), file_name);
fclose (file);
- return 1;
+ return FALSE;
}
current_file_size = (bfd_size_type) statbuf.st_size;
if (memcmp (armag, ARMAG, SARMAG) == 0)
- ret = process_archive (file_name, file, FALSE);
+ {
+ if (! process_archive (file_name, file, FALSE))
+ ret = FALSE;
+ }
else if (memcmp (armag, ARMAGT, SARMAG) == 0)
- ret = process_archive (file_name, file, TRUE);
+ {
+ if ( ! process_archive (file_name, file, TRUE))
+ ret = FALSE;
+ }
else
{
if (do_archive_index)
rewind (file);
archive_file_size = archive_file_offset = 0;
- ret = process_object (file_name, file);
+
+ if (! process_object (file_name, file))
+ ret = FALSE;
}
fclose (file);
-
current_file_size = 0;
+
return ret;
}
}
if (optind < (argc - 1))
- show_name = 1;
+ show_name = TRUE;
else if (optind >= argc)
{
warn (_("Nothing to do.\n"));
usage (stderr);
}
- err = 0;
+ err = FALSE;
while (optind < argc)
- err |= process_file (argv[optind++]);
+ if (! process_file (argv[optind++]))
+ err = TRUE;
if (dump_sects != NULL)
free (dump_sects);
if (cmdline_dump_sects != NULL)
free (cmdline_dump_sects);
- return err;
+ return err ? EXIT_FAILURE : EXIT_SUCCESS;
}