/* readelf.c -- display contents of an ELF format file
- Copyright (C) 1998-2014 Free Software Foundation, Inc.
+ Copyright (C) 1998-2016 Free Software Foundation, Inc.
Originally developed by Eric Youngdale <eric@andante.jic.com>
Modifications by Nick Clifton <nickc@redhat.com>
#include "sysdep.h"
#include <assert.h>
#include <time.h>
-#ifdef HAVE_ZLIB_H
#include <zlib.h>
-#endif
#ifdef HAVE_WCHAR_H
#include <wchar.h>
#endif
#include "elf/epiphany.h"
#include "elf/fr30.h"
#include "elf/frv.h"
+#include "elf/ft32.h"
#include "elf/h8.h"
#include "elf/hppa.h"
#include "elf/i386.h"
#include "elf/tilepro.h"
#include "elf/v850.h"
#include "elf/vax.h"
+#include "elf/visium.h"
#include "elf/x86-64.h"
#include "elf/xc16x.h"
#include "elf/xgate.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 elf_section_list * symtab_shndx_list;
static int show_name;
static int do_dynamic;
static int do_syms;
static int do_notes;
static int do_archive_index;
static int is_32bit_elf;
+static int decompress_dumps;
struct group_list
{
context. */
static void *
-get_data (void * var, FILE * file, unsigned long offset, size_t size, size_t nmemb,
- const char * reason)
+get_data (void * var, FILE * file, unsigned long offset, bfd_size_type size,
+ bfd_size_type nmemb, const char * reason)
{
void * mvar;
- size_t amt = size * nmemb;
+ bfd_size_type amt = size * nmemb;
if (size == 0 || nmemb == 0)
return NULL;
+ /* If the size_t type is smaller than the bfd_size_type, eg because
+ you are building a 32-bit tool on a 64-bit host, then make sure
+ that when the sizes are cast to (size_t) no information is lost. */
+ if (sizeof (size_t) < sizeof (bfd_size_type)
+ && ( (bfd_size_type) ((size_t) size) != size
+ || (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);
+ return NULL;
+ }
+
+ /* Check for size overflow. */
+ 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);
+ return NULL;
+ }
+
/* Be kind to memory chekers (eg valgrind, address sanitizer) by not
attempting to allocate memory when the read is bound to fail. */
if (amt > current_file_size
|| offset + archive_file_offset + amt > current_file_size)
{
if (reason)
- error (_("Reading 0x%lx bytes extends past end of file for %s\n"),
- (unsigned long) amt, reason);
+ error (_("Reading 0x%llx bytes extends past end of file for %s\n"),
+ (unsigned long long) amt, reason);
return NULL;
}
if (mvar == NULL)
{
/* Check for overflow. */
- if (nmemb < (~(size_t) 0 - 1) / size)
+ if (nmemb < (~(bfd_size_type) 0 - 1) / size)
/* + 1 so that we can '\0' terminate invalid string table sections. */
- mvar = malloc (size * nmemb + 1);
+ mvar = malloc ((size_t) amt + 1);
if (mvar == NULL)
{
if (reason)
- error (_("Out of memory allocating 0x%lx bytes for %s\n"),
- (unsigned long)(size * nmemb), reason);
+ error (_("Out of memory allocating 0x%llx bytes for %s\n"),
+ (unsigned long long) amt, reason);
return NULL;
}
((char *) mvar)[amt] = '\0';
}
- if (fread (mvar, size, nmemb, file) != nmemb)
+ if (fread (mvar, (size_t) size, (size_t) nmemb, file) != nmemb)
{
if (reason)
- error (_("Unable to read in 0x%lx bytes of %s\n"),
- (unsigned long) amt, reason);
+ error (_("Unable to read in 0x%llx bytes of %s\n"),
+ (unsigned long long) amt, reason);
if (mvar != var)
free (mvar);
return NULL;
to print multibyte characters, it just interprets them as hex values. */
static const char *
-printable_section_name (Elf_Internal_Shdr * sec)
+printable_section_name (const Elf_Internal_Shdr * sec)
{
#define MAX_PRINT_SEC_NAME_LEN 128
static char sec_name_buf [MAX_PRINT_SEC_NAME_LEN + 1];
{
if (remaining < 2)
break;
-
+
* buf ++ = '^';
* buf ++ = c + 0x40;
remaining -= 2;
{
/* 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_D30V:
case EM_CYGNUS_D30V:
case EM_FR30:
+ case EM_FT32:
case EM_CYGNUS_FR30:
case EM_CYGNUS_FRV:
case EM_H8S:
case EM_V850:
case EM_CYGNUS_V850:
case EM_VAX:
+ case EM_VISIUM:
case EM_X86_64:
case EM_L1OM:
case EM_K1OM:
break;
case EM_386:
- case EM_486:
+ case EM_IAMCU:
rtype = elf_i386_reloc_type (type);
break;
rtype = elf_frv_reloc_type (type);
break;
+ case EM_FT32:
+ rtype = elf_ft32_reloc_type (type);
+ break;
+
case EM_MCORE:
rtype = elf_mcore_reloc_type (type);
break;
break;
case EM_ARC:
+ case EM_ARC_COMPACT:
+ case EM_ARC_COMPACT2:
rtype = elf_arc_reloc_type (type);
break;
rtype = elf_vax_reloc_type (type);
break;
+ case EM_VISIUM:
+ rtype = elf_visium_reloc_type (type);
+ break;
+
case EM_ADAPTEVA_EPIPHANY:
rtype = elf_epiphany_reloc_type (type);
break;
if (is_rela)
{
- bfd_signed_vma off = rels[i].r_addend;
+ bfd_vma off = rels[i].r_addend;
- 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, ' ');
- if (off < 0)
+ if ((bfd_signed_vma) off < 0)
printf ("-%" BFD_VMA_FMT "x", - off);
else
printf ("%" BFD_VMA_FMT "x", off);
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";
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";
case EM_PPC: return "PowerPC";
case EM_PPC64: return "PowerPC64";
case EM_FR20: return "Fujitsu FR20";
+ case EM_FT32: return "FTDI FT32";
case EM_RH32: return "TRW RH32";
case EM_MCORE: return "MCORE";
case EM_ARM: return "ARM";
case EM_SPARCV9: return "Sparc v9";
case EM_TRICORE: return "Siemens Tricore";
case EM_ARC: return "ARC";
+ case EM_ARC_COMPACT: return "ARCompact";
+ case EM_ARC_COMPACT2: return "ARCv2";
case EM_H8_300: return "Renesas H8/300";
case EM_H8_300H: return "Renesas H8/300H";
case EM_H8S: return "Renesas H8S";
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_SCORE: return "SUNPLUS S+Core";
case EM_XSTORMY16: return "Sanyo XStormy16 CPU core";
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";
e_flags &= ~ EF_ARM_RELEXEC;
}
- if (e_flags & EF_ARM_HASENTRY)
- {
- strcat (buf, ", has entry point");
- e_flags &= ~ EF_ARM_HASENTRY;
- }
-
/* Now handle EABI specific flags. */
switch (eabi)
{
strcat (buf,_(", <unknown>"));
}
+static void
+decode_AVR_machine_flags (unsigned e_flags, char buf[], size_t size)
+{
+ --size; /* Leave space for null terminator. */
+
+ switch (e_flags & EF_AVR_MACH)
+ {
+ case E_AVR_MACH_AVR1:
+ strncat (buf, ", avr:1", size);
+ break;
+ case E_AVR_MACH_AVR2:
+ strncat (buf, ", avr:2", size);
+ break;
+ case E_AVR_MACH_AVR25:
+ strncat (buf, ", avr:25", size);
+ break;
+ case E_AVR_MACH_AVR3:
+ strncat (buf, ", avr:3", size);
+ break;
+ case E_AVR_MACH_AVR31:
+ strncat (buf, ", avr:31", size);
+ break;
+ case E_AVR_MACH_AVR35:
+ strncat (buf, ", avr:35", size);
+ break;
+ case E_AVR_MACH_AVR4:
+ strncat (buf, ", avr:4", size);
+ break;
+ case E_AVR_MACH_AVR5:
+ strncat (buf, ", avr:5", size);
+ break;
+ case E_AVR_MACH_AVR51:
+ strncat (buf, ", avr:51", size);
+ break;
+ case E_AVR_MACH_AVR6:
+ strncat (buf, ", avr:6", size);
+ break;
+ case E_AVR_MACH_AVRTINY:
+ strncat (buf, ", avr:100", size);
+ break;
+ case E_AVR_MACH_XMEGA1:
+ strncat (buf, ", avr:101", size);
+ break;
+ case E_AVR_MACH_XMEGA2:
+ strncat (buf, ", avr:102", size);
+ break;
+ case E_AVR_MACH_XMEGA3:
+ strncat (buf, ", avr:103", size);
+ break;
+ case E_AVR_MACH_XMEGA4:
+ strncat (buf, ", avr:104", size);
+ break;
+ case E_AVR_MACH_XMEGA5:
+ strncat (buf, ", avr:105", size);
+ break;
+ case E_AVR_MACH_XMEGA6:
+ strncat (buf, ", avr:106", size);
+ break;
+ case E_AVR_MACH_XMEGA7:
+ strncat (buf, ", avr:107", size);
+ break;
+ default:
+ strncat (buf, ", avr:<unknown>", size);
+ break;
+ }
+
+ size -= strlen (buf);
+ if (e_flags & EF_AVR_LINKRELAX_PREPARED)
+ strncat (buf, ", link-relax", size);
+}
+
static void
decode_NDS32_machine_flags (unsigned e_flags, char buf[], size_t size)
{
default:
break;
+ case EM_ARC_COMPACT2:
+ switch (e_flags & EF_ARC_MACH_MSK)
+ {
+ case EF_ARC_CPU_ARCV2EM:
+ strcat (buf, ", ARC EM");
+ break;
+ case EF_ARC_CPU_ARCV2HS:
+ strcat (buf, ", ARC HS");
+ break;
+ case EF_ARC_CPU_GENERIC:
+ strcat (buf, ", ARC generic");
+ break;
+ 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;
+ default:
+ strcat (buf, ", unrecognized cpu flag for ARCv2");
+ 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;
+ }
+ break;
+
+ case EM_ARC_COMPACT:
+ switch (e_flags & EF_ARC_MACH_MSK)
+ {
+ case E_ARC_MACH_ARC600:
+ strcat (buf, ", ARC 600");
+ break;
+ case E_ARC_MACH_ARC601:
+ strcat (buf, ", ARC 601");
+ break;
+ case E_ARC_MACH_ARC700:
+ strcat (buf, ", ARC 700");
+ break;
+ default:
+ strcat (buf, ", Generic ARCompact");
+ break;
+ }
+ switch (e_flags & EF_ARC_OSABI_MSK)
+ {
+ case E_ARC_OSABI_ORIG:
+ strcat (buf, ", legacy syscall ABI");
+ break;
+ case E_ARC_OSABI_V2:
+ /* For 3.2+ Linux kernels which use asm-generic
+ hdrs. */
+ strcat (buf, ", v2 syscall ABI");
+ break;
+ case E_ARC_OSABI_V3:
+ /* Upstream 3.9+ kernels which don't use any legacy
+ syscalls. */
+ strcat (buf, ", v3 no-legacy-syscalls ABI");
+ break;
+ }
+ break;
+
case EM_ARM:
decode_ARM_machine_flags (e_flags, buf);
break;
+ case EM_AVR:
+ decode_AVR_machine_flags (e_flags, buf, sizeof buf);
+ break;
+
case EM_BLACKFIN:
if (e_flags & EF_BFIN_PIC)
strcat (buf, ", PIC");
}
break;
+ case EM_CYGNUS_MEP:
+ switch (e_flags & EF_MEP_CPU_MASK)
+ {
+ case EF_MEP_CPU_MEP: strcat (buf, ", generic MeP"); break;
+ case EF_MEP_CPU_C2: strcat (buf, ", MeP C2"); break;
+ case EF_MEP_CPU_C3: strcat (buf, ", MeP C3"); break;
+ case EF_MEP_CPU_C4: strcat (buf, ", MeP C4"); break;
+ case EF_MEP_CPU_C5: strcat (buf, ", MeP C5"); break;
+ case EF_MEP_CPU_H1: strcat (buf, ", MeP H1"); break;
+ default: strcat (buf, _(", <unknown MeP cpu type>")); break;
+ }
+
+ switch (e_flags & EF_MEP_COP_MASK)
+ {
+ case EF_MEP_COP_NONE: break;
+ case EF_MEP_COP_AVC: strcat (buf, ", AVC coprocessor"); break;
+ case EF_MEP_COP_AVC2: strcat (buf, ", AVC2 coprocessor"); break;
+ case EF_MEP_COP_FMAX: strcat (buf, ", FMAX coprocessor"); break;
+ case EF_MEP_COP_IVC2: strcat (buf, ", IVC2 coprocessor"); break;
+ default: strcat (buf, _("<unknown MeP copro type>")); break;
+ }
+
+ if (e_flags & EF_MEP_LIBRARY)
+ strcat (buf, ", Built for Library");
+
+ if (e_flags & EF_MEP_INDEX_MASK)
+ sprintf (buf + strlen (buf), ", Configuration Index: %#x",
+ e_flags & EF_MEP_INDEX_MASK);
+
+ if (e_flags & ~ EF_MEP_ALL_FLAGS)
+ sprintf (buf + strlen (buf), _(", unknown flags bits: %#x"),
+ e_flags & ~ EF_MEP_ALL_FLAGS);
+ break;
+
case EM_PPC:
if (e_flags & EF_PPC_EMB)
strcat (buf, ", emb");
{
case EF_RH850_FPU_DOUBLE: strcat (buf, ", double precision FPU"); break;
case EF_RH850_FPU_SINGLE: strcat (buf, ", single precision FPU"); break;
- case EF_RH850_SIMD: strcat (buf, ", SIMD"); break;
- case EF_RH850_CACHE: strcat (buf, ", CACHE"); break;
- case EF_RH850_MMU: strcat (buf, ", MMU"); break;
case EF_RH850_REGMODE22: strcat (buf, ", regmode:22"); break;
case EF_RH850_REGMODE32: strcat (buf, ", regmode:23"); break;
- case EF_RH850_DATA_ALIGN8: strcat (buf, ", 8-byte alignment"); break;
case EF_RH850_GP_FIX: strcat (buf, ", r4 fixed"); break;
case EF_RH850_GP_NOFIX: strcat (buf, ", r4 free"); break;
case EF_RH850_EP_FIX: strcat (buf, ", r30 fixed"); break;
if (e_flags & EF_SH_FDPIC)
strcat (buf, ", fdpic");
break;
-
+
case EM_OR1K:
if (e_flags & EF_OR1K_NODELAY)
strcat (buf, ", no delay");
strcat (buf, ", G-Float");
break;
+ case EM_VISIUM:
+ if (e_flags & EF_VISIUM_ARCH_MCM)
+ strcat (buf, ", mcm");
+ else if (e_flags & EF_VISIUM_ARCH_MCM24)
+ strcat (buf, ", mcm24");
+ if (e_flags & EF_VISIUM_ARCH_GR6)
+ strcat (buf, ", gr6");
+ break;
+
case EM_RL78:
- if (e_flags & E_FLAG_RL78_G10)
- strcat (buf, ", G10");
+ switch (e_flags & E_FLAG_RL78_CPU_MASK)
+ {
+ case E_FLAG_RL78_ANY_CPU: break;
+ case E_FLAG_RL78_G10: strcat (buf, ", G10"); break;
+ case E_FLAG_RL78_G13: strcat (buf, ", G13"); break;
+ case E_FLAG_RL78_G14: strcat (buf, ", G14"); break;
+ }
if (e_flags & E_FLAG_RL78_64BIT_DOUBLES)
strcat (buf, ", 64-bit doubles");
break;
strcat (buf, ", pid");
if (e_flags & E_FLAG_RX_ABI)
strcat (buf, ", RX ABI");
+ 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 EM_MSP430:
case EM_MSP430_OLD:
+ case EM_VISIUM:
switch (osabi)
{
case ELFOSABI_STANDALONE: return _("Standalone App");
}
}
+static const char *
+get_v850_section_type_name (unsigned int sh_type)
+{
+ 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;
+ }
+}
+
static const char *
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:
case EM_MSP430:
result = get_msp430x_section_type_name (sh_type);
break;
+ case EM_V800:
+ case EM_V850:
+ case EM_CYGNUS_V850:
+ result = get_v850_section_type_name (sh_type);
+ break;
default:
result = NULL;
break;
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:
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))
- sprintf (buff, "LOUSER+%x", sh_type - SHT_LOUSER);
+ {
+ switch (elf_header.e_machine)
+ {
+ case EM_V800:
+ case EM_V850:
+ case EM_CYGNUS_V850:
+ result = get_v850_section_type_name (sh_type);
+ break;
+ default:
+ result = NULL;
+ break;
+ }
+
+ 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
character wide field, so put the hex value first. */
{"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\
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)
{
case 'R':
request_dump (RELOC_DUMP);
break;
+ case 'z':
+ decompress_dumps++;
+ break;
case 'w':
do_dump++;
if (optarg == 0)
&& !do_section_groups && !do_archive_index
&& !do_dyn_syms)
usage (stderr);
- else if (argc < 3)
- {
- warn (_("Nothing to do.\n"));
- usage (stderr);
- }
}
static const char *
/* 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"));
+ " header offset, but no program headers\n"));
else if (do_segments)
printf (_("\nThere are no program headers in this file.\n"));
return 0;
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));
/* Generic. */
/* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
/* SPARC specific. */
- /* 19 */ { STRING_COMMA_LEN ("ORDERED") }
+ /* 19 */ { STRING_COMMA_LEN ("ORDERED") },
+ /* 20 */ { STRING_COMMA_LEN ("COMPRESSED") },
+ /* ARM specific. */
+ /* 21 */ { STRING_COMMA_LEN ("ENTRYSECT") },
+ /* 22 */ { STRING_COMMA_LEN ("ARM_NOREAD") },
+ /* 23 */ { STRING_COMMA_LEN ("COMDEF") }
};
if (do_section_details)
case SHF_GROUP: sindex = 8; break;
case SHF_TLS: sindex = 9; break;
case SHF_EXCLUDE: sindex = 18; break;
+ case SHF_COMPRESSED: sindex = 20; break;
default:
sindex = -1;
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_NOREAD: sindex = 22; break;
+ case SHF_COMDEF: sindex = 23; break;
+ default: break;
+ }
+ break;
+
default:
break;
}
case SHF_GROUP: *p = 'G'; break;
case SHF_TLS: *p = 'T'; break;
case SHF_EXCLUDE: *p = 'E'; break;
+ case SHF_COMPRESSED: *p = 'C'; break;
default:
if ((elf_header.e_machine == EM_X86_64
|| elf_header.e_machine == EM_K1OM)
&& flag == SHF_X86_64_LARGE)
*p = 'l';
+ else if (elf_header.e_machine == EM_ARM
+ && flag == SHF_ARM_NOREAD)
+ *p = 'y';
else if (flag & SHF_MASKOS)
{
*p = 'o';
return buff;
}
+static unsigned int
+get_compression_header (Elf_Internal_Chdr *chdr, unsigned char *buf)
+{
+ if (is_32bit_elf)
+ {
+ Elf32_External_Chdr *echdr = (Elf32_External_Chdr *) buf;
+ chdr->ch_type = BYTE_GET (echdr->ch_type);
+ chdr->ch_size = BYTE_GET (echdr->ch_size);
+ chdr->ch_addralign = BYTE_GET (echdr->ch_addralign);
+ return sizeof (*echdr);
+ }
+ else
+ {
+ Elf64_External_Chdr *echdr = (Elf64_External_Chdr *) buf;
+ chdr->ch_type = BYTE_GET (echdr->ch_type);
+ chdr->ch_size = BYTE_GET (echdr->ch_size);
+ chdr->ch_addralign = BYTE_GET (echdr->ch_addralign);
+ return sizeof (*echdr);
+ }
+}
+
static int
process_section_headers (FILE * file)
{
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);
switch (elf_header.e_machine)
{
case EM_386:
- case EM_486:
+ case EM_IAMCU:
case EM_X86_64:
case EM_L1OM:
case EM_K1OM:
}
if (do_section_details)
- printf (" %s\n", get_elf_section_flags (section->sh_flags));
+ {
+ printf (" %s\n", get_elf_section_flags (section->sh_flags));
+ if ((section->sh_flags & SHF_COMPRESSED) != 0)
+ {
+ /* 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);
+ if (chdr.ch_type == ELFCOMPRESS_ZLIB)
+ printf (" ZLIB, ");
+ else
+ printf (_(" [<unknown>: 0x%x], "),
+ chdr.ch_type);
+ print_vma (chdr.ch_size, LONG_HEX);
+ printf (", %lu\n", (unsigned long) chdr.ch_addralign);
+ }
+ }
+ }
}
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 (noread), "));
+ printf ("p (processor specific)\n");
}
return 1;
if (entry >= elf_header.e_shnum)
{
- error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
- entry, i, elf_header.e_shnum - 1);
+ static unsigned num_group_errors = 0;
+
+ if (num_group_errors ++ < 10)
+ {
+ error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
+ entry, i, elf_header.e_shnum - 1);
+ if (num_group_errors == 10)
+ warn (_("Futher error messages about overlarge group section indicies suppressed\n"));
+ }
continue;
}
{
if (entry)
{
- error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
- entry, i,
- section_headers_groups [entry]->group_index);
+ static unsigned num_errs = 0;
+
+ if (num_errs ++ < 10)
+ {
+ error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
+ entry, i,
+ section_headers_groups [entry]->group_index);
+ if (num_errs == 10)
+ warn (_("Further error messages about already contained group sections suppressed\n"));
+ }
continue;
}
else
return 1;
}
-/* Process the unwind section. */
-
-#include "unwind-ia64.h"
-
/* An absolute address consists of a section and an offset. If the
section is NULL, the offset itself is the address, otherwise, the
address equals to LOAD_ADDRESS(section) + offset. */
struct absaddr
- {
- unsigned short section;
- bfd_vma offset;
- };
+{
+ unsigned short section;
+ bfd_vma offset;
+};
#define ABSADDR(a) \
((a).section \
? section_headers [(a).section].sh_addr + (a).offset \
: (a).offset)
-struct ia64_unw_table_entry
- {
- struct absaddr start;
- struct absaddr end;
- struct absaddr info;
- };
-
-struct ia64_unw_aux_info
- {
-
- struct ia64_unw_table_entry *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. */
- char * strtab; /* The string table. */
- unsigned long strtab_size; /* Size of string table. */
- };
+/* Find the nearest symbol at or below ADDR. Returns the symbol
+ name, if found, and the offset from the symbol to ADDR. */
static void
find_symbol_for_address (Elf_Internal_Sym * symtab,
- unsigned long nsyms,
- const char * strtab,
- unsigned long strtab_size,
- struct absaddr addr,
- const char ** symname,
- bfd_vma * offset)
+ unsigned long nsyms,
+ const char * strtab,
+ unsigned long strtab_size,
+ struct absaddr addr,
+ const char ** symname,
+ bfd_vma * offset)
{
bfd_vma dist = 0x100000;
Elf_Internal_Sym * sym;
+ Elf_Internal_Sym * beg;
+ Elf_Internal_Sym * end;
Elf_Internal_Sym * best = NULL;
- unsigned long i;
REMOVE_ARCH_BITS (addr.offset);
+ beg = symtab;
+ end = symtab + nsyms;
- for (i = 0, sym = symtab; i < nsyms; ++i, ++sym)
+ while (beg < end)
{
- bfd_vma value = sym->st_value;
+ bfd_vma value;
+
+ sym = beg + (end - beg) / 2;
+ value = sym->st_value;
REMOVE_ARCH_BITS (value);
- if (ELF_ST_TYPE (sym->st_info) == STT_FUNC
- && sym->st_name != 0
+ if (sym->st_name != 0
&& (addr.section == SHN_UNDEF || addr.section == sym->st_shndx)
&& addr.offset >= value
&& addr.offset - value < dist)
if (!dist)
break;
}
+
+ if (addr.offset < value)
+ end = sym;
+ else
+ beg = sym + 1;
}
if (best)
*offset = addr.offset;
}
+static int
+symcmp (const void *p, const void *q)
+{
+ Elf_Internal_Sym *sp = (Elf_Internal_Sym *) p;
+ Elf_Internal_Sym *sq = (Elf_Internal_Sym *) q;
+
+ return sp->st_value > sq->st_value ? 1 : (sp->st_value < sq->st_value ? -1 : 0);
+}
+
+/* Process the unwind section. */
+
+#include "unwind-ia64.h"
+
+struct ia64_unw_table_entry
+{
+ struct absaddr start;
+ struct absaddr end;
+ struct absaddr info;
+};
+
+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. */
+};
+
static void
dump_ia64_unwind (struct ia64_unw_aux_info * aux)
{
struct ia64_unw_table_entry * tp;
+ unsigned long j, nfuns;
int in_body;
+ aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
+ for (nfuns = 0, j = 0; j < aux->nsyms; j++)
+ if (aux->symtab[j].st_value && ELF_ST_TYPE (aux->symtab[j].st_info) == STT_FUNC)
+ aux->funtab[nfuns++] = aux->symtab[j];
+ aux->nfuns = nfuns;
+ qsort (aux->funtab, aux->nfuns, sizeof (Elf_Internal_Sym), symcmp);
+
for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
{
bfd_vma stamp;
bfd_vma offset;
const unsigned char * dp;
const unsigned char * head;
+ const unsigned char * end;
const char * procname;
- find_symbol_for_address (aux->symtab, aux->nsyms, aux->strtab,
+ find_symbol_for_address (aux->funtab, aux->nfuns, aux->strtab,
aux->strtab_size, tp->start, &procname, &offset);
fputs ("\n<", stdout);
printf ("], info at +0x%lx\n",
(unsigned long) (tp->info.offset - aux->seg_base));
+ /* PR 17531: file: 86232b32. */
+ if (aux->info == NULL)
+ continue;
+
+ /* PR 17531: file: 0997b4d1. */
+ if ((ABSADDR (tp->info) - aux->info_addr) >= aux->info_size)
+ {
+ warn (_("Invalid offset %lx in table entry %ld\n"),
+ (long) tp->info.offset, (long) (tp - aux->table));
+ continue;
+ }
+
head = aux->info + (ABSADDR (tp->info) - aux->info_addr);
stamp = byte_get ((unsigned char *) head, sizeof (stamp));
}
in_body = 0;
- for (dp = head + 8; dp < head + 8 + eh_addr_size * UNW_LENGTH (stamp);)
- dp = unw_decode (dp, in_body, & in_body);
+ end = head + 8 + eh_addr_size * UNW_LENGTH (stamp);
+ /* PR 17531: file: 16ceda89. */
+ 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, end);
}
+
+ free (aux->funtab);
}
-static int
+static bfd_boolean
slurp_ia64_unwind_table (FILE * file,
struct ia64_unw_aux_info * aux,
Elf_Internal_Shdr * sec)
Elf_Internal_Sym * sym;
const char * relname;
+ aux->table_len = 0;
+
/* 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;
+ aux->table_len = size / (3 * eh_addr_size);
aux->table = (struct ia64_unw_table_entry *)
- xcmalloc (size / (3 * eh_addr_size), sizeof (aux->table[0]));
+ xcmalloc (aux->table_len, sizeof (aux->table[0]));
tep = aux->table;
- for (tp = table; tp < table + size; ++tep)
+
+ for (tp = table; tp <= table + size - (3 * eh_addr_size); ++tep)
{
tep->start.section = SHN_UNDEF;
tep->end.section = SHN_UNDEF;
if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
& rela, & nrelas))
- return 0;
+ {
+ free (aux->table);
+ aux->table = NULL;
+ aux->table_len = 0;
+ return FALSE;
+ }
for (rp = rela; rp < rela + nrelas; ++rp)
{
relname = elf_ia64_reloc_type (get_reloc_type (rp->r_info));
sym = aux->symtab + get_reloc_symindex (rp->r_info);
+ /* PR 17531: file: 9fa67536. */
+ if (relname == NULL)
+ {
+ warn (_("Skipping unknown relocation type: %u\n"), get_reloc_type (rp->r_info));
+ continue;
+ }
+
if (! const_strneq (relname, "R_IA64_SEGREL"))
{
- warn (_("Skipping unexpected relocation type %s\n"), relname);
+ warn (_("Skipping unexpected relocation type: %s\n"), relname);
continue;
}
i = rp->r_offset / (3 * eh_addr_size);
- switch (rp->r_offset/eh_addr_size % 3)
+ /* PR 17531: file: 5bc8d9bf. */
+ if (i >= aux->table_len)
+ {
+ warn (_("Skipping reloc with overlarge offset: %lx\n"), i);
+ continue;
+ }
+
+ switch (rp->r_offset / eh_addr_size % 3)
{
case 0:
aux->table[i].start.section = sym->st_shndx;
free (rela);
}
- aux->table_len = size / (3 * eh_addr_size);
- return 1;
+ return TRUE;
}
static void
(unsigned long) unwsec->sh_offset,
(unsigned long) (unwsec->sh_size / (3 * eh_addr_size)));
- (void) slurp_ia64_unwind_table (file, & aux, unwsec);
-
- if (aux.table_len > 0)
+ if (slurp_ia64_unwind_table (file, & aux, unwsec)
+ && aux.table_len > 0)
dump_ia64_unwind (& aux);
if (aux.table)
{
struct absaddr start;
struct absaddr end;
- unsigned int Cannot_unwind:1; /* 0 */
+ 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 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 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 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 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_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 Cleanup_defined:1; /* 31 */
- unsigned int MPE_XL_interrupt_marker:1; /* 0 */
- unsigned int HP_UX_interrupt_marker:1; /* 1 */
+ 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 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. */
- 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
dump_hppa_unwind (struct hppa_unw_aux_info * aux)
{
struct hppa_unw_table_entry * tp;
+ unsigned long j, nfuns;
+
+ aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
+ for (nfuns = 0, j = 0; j < aux->nsyms; j++)
+ if (aux->symtab[j].st_value && ELF_ST_TYPE (aux->symtab[j].st_info) == STT_FUNC)
+ aux->funtab[nfuns++] = aux->symtab[j];
+ aux->nfuns = nfuns;
+ qsort (aux->funtab, aux->nfuns, sizeof (Elf_Internal_Sym), symcmp);
for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
{
bfd_vma offset;
const char * procname;
- find_symbol_for_address (aux->symtab, aux->nsyms, aux->strtab,
+ find_symbol_for_address (aux->funtab, aux->nfuns, aux->strtab,
aux->strtab_size, tp->start, &procname,
&offset);
}
printf ("\n");
+
+ free (aux->funtab);
}
static int
FILE * file; /* The file containing the unwind sections. */
Elf_Internal_Sym * symtab; /* The file's symbol table. */
unsigned long nsyms; /* Number of symbols. */
+ Elf_Internal_Sym * funtab; /* Sorted table of STT_FUNC symbols. */
+ unsigned long nfuns; /* Number of these symbols. */
char * strtab; /* The file's string table. */
unsigned long strtab_size; /* Size of string table. */
};
if (addr.section == SHN_UNDEF)
addr.offset = fn;
- find_symbol_for_address (aux->symtab, aux->nsyms, aux->strtab,
+ find_symbol_for_address (aux->funtab, aux->nfuns, aux->strtab,
aux->strtab_size, addr, &procname,
&sym_offset);
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. */
printf ("0x%02x ", OP)
static void
-decode_arm_unwind_bytecode (struct arm_unw_aux_info *aux,
- unsigned int word, unsigned int remaining,
- unsigned int more_words,
- bfd_vma data_offset, Elf_Internal_Shdr *data_sec,
- struct arm_section *data_arm_sec)
+decode_arm_unwind_bytecode (struct arm_unw_aux_info * aux,
+ unsigned int word,
+ unsigned int remaining,
+ unsigned int more_words,
+ bfd_vma data_offset,
+ Elf_Internal_Shdr * data_sec,
+ struct arm_section * data_arm_sec)
{
struct absaddr addr;
}
static void
-decode_tic6x_unwind_bytecode (struct arm_unw_aux_info *aux,
- unsigned int word, unsigned int remaining,
- unsigned int more_words,
- bfd_vma data_offset, Elf_Internal_Shdr *data_sec,
- struct arm_section *data_arm_sec)
+decode_tic6x_unwind_bytecode (struct arm_unw_aux_info * aux,
+ unsigned int word,
+ unsigned int remaining,
+ unsigned int more_words,
+ bfd_vma data_offset,
+ Elf_Internal_Shdr * data_sec,
+ struct arm_section * data_arm_sec)
{
struct absaddr addr;
warn (_("Corrupt stack pointer adjustment detected\n"));
return;
}
-
+
offset = read_uleb128 (buf, &len, buf + i + 1);
assert (len == i + 1);
offset = offset * 8 + 0x408;
{
struct arm_section exidx_arm_sec, extab_arm_sec;
unsigned int i, exidx_len;
+ unsigned long j, nfuns;
memset (&exidx_arm_sec, 0, sizeof (exidx_arm_sec));
memset (&extab_arm_sec, 0, sizeof (extab_arm_sec));
exidx_len = exidx_sec->sh_size / 8;
+ aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
+ for (nfuns = 0, j = 0; j < aux->nsyms; j++)
+ if (aux->symtab[j].st_value && ELF_ST_TYPE (aux->symtab[j].st_info) == STT_FUNC)
+ aux->funtab[nfuns++] = aux->symtab[j];
+ aux->nfuns = nfuns;
+ qsort (aux->funtab, aux->nfuns, sizeof (Elf_Internal_Sym), symcmp);
+
for (i = 0; i < exidx_len; i++)
{
unsigned int exidx_fn, exidx_entry;
|| ! get_unwind_section_word (aux, & exidx_arm_sec, exidx_sec,
8 * i + 4, & exidx_entry, & entry_addr, NULL))
{
+ free (aux->funtab);
arm_free_section (& exidx_arm_sec);
arm_free_section (& extab_arm_sec);
return;
{
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));
+ continue;
+ }
}
else
{
printf ("\n");
+ free (aux->funtab);
arm_free_section (&exidx_arm_sec);
arm_free_section (&extab_arm_sec);
}
{
char timebuf[20];
struct tm * tmp;
-
time_t atime = entry->d_un.d_val;
+
tmp = gmtime (&atime);
- snprintf (timebuf, sizeof (timebuf), "%04u-%02u-%02uT%02u:%02u:%02u",
- tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
- tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
+ /* PR 17531: file: 6accc532. */
+ if (tmp == NULL)
+ snprintf (timebuf, sizeof (timebuf), _("<corrupt>"));
+ else
+ snprintf (timebuf, sizeof (timebuf), "%04u-%02u-%02uT%02u:%02u:%02u",
+ tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
+ tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
printf (_("Time Stamp: %s"), timebuf);
}
break;
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++;
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++;
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 ("");
/* Check for overflow. */
if (ent.vn_aux > (size_t) (endbuf - vstart))
break;
-
vstart += ent.vn_aux;
for (j = 0, isum = idx + ent.vn_aux; j < ent.vn_cnt; ++j)
get_ver_flags (aux.vna_flags), aux.vna_other);
/* Check for overflow. */
- if (aux.vna_next > (size_t) (endbuf - vstart))
- break;
-
+ if (aux.vna_next > (size_t) (endbuf - vstart)
+ || (aux.vna_next == 0 && j < ent.vn_cnt - 1))
+ {
+ warn (_("Invalid vna_next field of %lx\n"),
+ aux.vna_next);
+ j = ent.vn_cnt;
+ break;
+ }
isum += aux.vna_next;
vstart += aux.vna_next;
}
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;
_("version def")) == NULL)
{
ivd.vd_next = 0;
- /* PR 17531: file: 046-1082287-0.004. */
+ /* PR 17531: file: 046-1082287-0.004. */
ivd.vd_ndx = (data[cnt + j] & VERSYM_VERSION) + 1;
break;
}
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, ' ');
}
static bfd_vma *
-get_dynamic_data (FILE * file, size_t number, unsigned int ent_size)
+get_dynamic_data (FILE * file, bfd_size_type number, unsigned int ent_size)
{
unsigned char * e_data;
bfd_vma * i_data;
+ /* If the size_t type is smaller than the bfd_size_type, eg because
+ you are building a 32-bit tool on a 64-bit host, then make sure
+ that when (number) is cast to (size_t) no information is lost. */
+ 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);
+ return NULL;
+ }
+
/* Be kind to memory chekers (eg valgrind, address sanitizer) by not
attempting to allocate memory when the read is bound to fail. */
if (ent_size * number > current_file_size)
{
- error (_("Invalid number of dynamic entries: %lu\n"),
- (unsigned long) number);
+ error (_("Invalid number of dynamic entries: %llu\n"),
+ (unsigned long long) number);
return NULL;
}
- e_data = (unsigned char *) cmalloc (number, ent_size);
+ e_data = (unsigned char *) cmalloc ((size_t) number, ent_size);
if (e_data == NULL)
{
- error (_("Out of memory reading %lu dynamic entries\n"),
- (unsigned long) number);
+ error (_("Out of memory reading %llu dynamic entries\n"),
+ (unsigned long long) number);
return NULL;
}
- if (fread (e_data, ent_size, number, file) != number)
+ if (fread (e_data, ent_size, (size_t) number, file) != number)
{
- error (_("Unable to read in %lu bytes of dynamic data\n"),
- (unsigned long) (number * ent_size));
+ error (_("Unable to read in %llu bytes of dynamic data\n"),
+ (unsigned long long) (number * ent_size));
free (e_data);
return NULL;
}
- i_data = (bfd_vma *) cmalloc (number, sizeof (*i_data));
+ i_data = (bfd_vma *) cmalloc ((size_t) number, sizeof (*i_data));
if (i_data == NULL)
{
- error (_("Out of memory allocating space for %lu dynamic entries\n"),
- (unsigned long) number);
+ error (_("Out of memory allocating space for %llu dynamic entries\n"),
+ (unsigned long long) number);
free (e_data);
return NULL;
}
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;
+ 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 ((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 = (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. */
unsigned long maxlength = 0;
unsigned long nzero_counts = 0;
unsigned long nsyms = 0;
+ unsigned long chained;
printf (_("\nHistogram for bucket list length (total of %lu buckets):\n"),
(unsigned long) nbuckets);
printf (_(" Length Number %% of total Coverage\n"));
for (hn = 0; hn < nbuckets; ++hn)
{
- for (si = buckets[hn]; si > 0 && si < nchains; si = chains[si])
+ for (si = buckets[hn], chained = 0;
+ si > 0 && si < nchains && si < nbuckets && chained <= nchains;
+ si = chains[si], ++chained)
{
++nsyms;
if (maxlength < ++lengths[hn])
++maxlength;
-
- /* PR binutils/17531: A corrupt binary could contain broken
- histogram data. Do not go into an infinite loop trying
- to process it. */
- if (chains[si] == si)
- {
- error (_("histogram chain links to itself\n"));
- break;
- }
}
+
+ /* PR binutils/17531: A corrupt binary could contain broken
+ histogram data. Do not go into an infinite loop trying
+ to process it. */
+ if (chained > nchains)
+ {
+ error (_("histogram chain is corrupt\n"));
+ break;
+ }
}
counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
}
break;
}
+
+ case EM_RL78:
+ {
+ static bfd_vma saved_sym1 = 0;
+ static bfd_vma saved_sym2 = 0;
+ static bfd_vma value;
+
+ 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;
+ return TRUE;
+
+ case 0x83: /* R_RL78_OPsub. */
+ value = saved_sym1 - saved_sym2;
+ saved_sym2 = saved_sym1 = 0;
+ return TRUE;
+ break;
+
+ case 0x41: /* R_RL78_ABS32. */
+ byte_put (start + reloc->r_offset, value, 4);
+ value = 0;
+ return TRUE;
+
+ case 0x43: /* R_RL78_ABS16. */
+ byte_put (start + reloc->r_offset, value, 2);
+ value = 0;
+ return TRUE;
+
+ default:
+ break;
+ }
+ break;
+ }
}
return FALSE;
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. */
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_CYGNUS_FR30:
case EM_FR30:
return reloc_type == 3; /* R_FR30_32. */
+ case EM_FT32:
+ return reloc_type == 1; /* R_FT32_32. */
case EM_H8S:
case EM_H8_300:
case EM_H8_300H:
return reloc_type == 1; /* R_H8_DIR32. */
case EM_IA_64:
- return reloc_type == 0x65; /* R_IA64_SECREL32LSB. */
+ 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 == 0x33; /* R_V810_WORD. */
case EM_VAX:
return reloc_type == 1; /* R_VAX_32. */
+ case EM_VISIUM:
+ return reloc_type == 3; /* R_VISIUM_32. */
case EM_X86_64:
case EM_L1OM:
case EM_K1OM:
switch (elf_header.e_machine)
{
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_MICROBLAZE:
return reloc_type == 6; /* R_TILEGX_32_PCREL. */
case EM_TILEPRO:
return reloc_type == 4; /* R_TILEPRO_32_PCREL. */
+ case EM_VISIUM:
+ return reloc_type == 6; /* R_VISIUM_32_PCREL */
case EM_X86_64:
case EM_L1OM:
case EM_K1OM:
{
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_AVR_OLD:
case EM_AVR:
return reloc_type == 4; /* R_AVR_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:
case EM_ADAPTEVA_EPIPHANY:
case EM_PPC: /* R_PPC_NONE. */
case EM_PPC64: /* R_PPC64_NONE. */
+ case EM_ARC: /* R_ARC_NONE. */
+ case EM_ARC_COMPACT: /* R_ARC_NONE. */
+ case EM_ARC_COMPACT2: /* R_ARC_NONE. */
case EM_ARM: /* R_ARM_NONE. */
case EM_IA_64: /* R_IA64_NONE. */
case EM_SH: /* R_SH_NONE. */
case EM_L1OM: /* R_X86_64_NONE. */
case EM_K1OM: /* R_X86_64_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. */
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.
Note: So far support has been added only for those relocations
which can be found in debug sections.
+ If RELOCS_RETURN is non-NULL then returns in it a pointer to the
+ loaded relocs. It is then the caller's responsibility to free them.
FIXME: Add support for more relocations ? */
static void
-apply_relocations (void * file,
- Elf_Internal_Shdr * section,
- unsigned char * start)
+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 + section->sh_size;
+ unsigned char * end = start + size;
+
+ if (relocs_return != NULL)
+ {
+ * (Elf_Internal_Rela **) relocs_return = NULL;
+ * num_relocs_return = 0;
+ }
if (elf_header.e_type != ET_REL)
return;
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"),
}
free (symtab);
- free (relocs);
+
+ if (relocs_return)
+ {
+ * (Elf_Internal_Rela **) relocs_return = relocs;
+ * num_relocs_return = num_relocs;
+ }
+ else
+ free (relocs);
+
break;
}
}
_("section contents"));
}
+/* Uncompresses a section that was compressed using zlib, in place. */
+
+static bfd_boolean
+uncompress_section_contents (unsigned char **buffer,
+ dwarf_size_type uncompressed_size,
+ dwarf_size_type *size)
+{
+ 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;
+}
static void
dump_section_as_strings (Elf_Internal_Shdr * section, FILE * file)
{
- Elf_Internal_Shdr * relsec;
- bfd_size_type num_bytes;
- char * data;
- char * end;
- char * start;
- bfd_boolean some_strings_shown;
-
- start = get_section_contents (section, 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;
+ 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);
+
+ if (chdr.ch_type != ELFCOMPRESS_ZLIB)
+ {
+ warn (_("section '%s' has unsupported compress type: %d\n"),
+ printable_section_name (section), chdr.ch_type);
+ return;
+ }
+ else if (chdr.ch_addralign != section->sh_addralign)
+ {
+ warn (_("compressed section '%s' is corrupted\n"),
+ printable_section_name (section));
+ return;
+ }
+ 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
+ && uncompress_section_contents (& start,
+ uncompressed_size, & new_size))
+ num_bytes = new_size;
+ }
+
/* 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');
}
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;
+ 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);
+
+ if (chdr.ch_type != ELFCOMPRESS_ZLIB)
+ {
+ warn (_("section '%s' has unsupported compress type: %d\n"),
+ printable_section_name (section), chdr.ch_type);
+ return;
+ }
+ else if (chdr.ch_addralign != section->sh_addralign)
+ {
+ warn (_("compressed section '%s' is corrupted\n"),
+ printable_section_name (section));
+ return;
+ }
+ 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
+ && uncompress_section_contents (& start, uncompressed_size,
+ & new_size))
+ section_size = new_size;
+ }
+
if (relocate)
{
- apply_relocations (file, section, start);
+ apply_relocations (file, section, start, section_size, NULL, NULL);
}
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');
}
-/* Uncompresses a section that was compressed using zlib, in place. */
-
-static int
-uncompress_section_contents (unsigned char **buffer ATTRIBUTE_UNUSED,
- dwarf_size_type *size ATTRIBUTE_UNUSED)
-{
-#ifndef HAVE_ZLIB_H
- return FALSE;
-#else
- 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. */
- strm.zalloc = NULL;
- strm.zfree = NULL;
- strm.opaque = NULL;
- 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;
-
- free (compressed_buffer);
- *buffer = uncompressed_buffer;
- *size = uncompressed_size;
- return 1;
-
- fail:
- free (uncompressed_buffer);
- /* Indicate decompression failure. */
- *buffer = NULL;
- return 0;
-#endif /* HAVE_ZLIB_H */
-}
-
static int
load_specific_debug_section (enum dwarf_section_display_enum debug,
- Elf_Internal_Shdr * sec, void * file)
+ const Elf_Internal_Shdr * sec, void * file)
{
struct dwarf_section * section = &debug_displays [debug].section;
char buf [64];
section->size = 0;
else
{
- section->size = sec->sh_size;
- if (uncompress_section_contents (§ion->start, §ion->size))
- sec->sh_size = section->size;
+ 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)
+ {
+ warn (_("section '%s' has unsupported compress type: %d\n"),
+ section->name, chdr.ch_type);
+ return 0;
+ }
+ else if (chdr.ch_addralign != sec->sh_addralign)
+ {
+ warn (_("compressed section '%s' is corrupted\n"),
+ section->name);
+ return 0;
+ }
+ 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 (uncompressed_size
+ && 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;
+ }
+ section->size = size;
}
if (section->start == NULL)
return 0;
if (debug_displays [debug].relocate)
- apply_relocations ((FILE *) file, sec, section->start);
+ apply_relocations ((FILE *) file, sec, section->start, section->size,
+ & section->reloc_info, & section->num_relocs);
+ else
+ {
+ section->reloc_info = NULL;
+ section->num_relocs = 0;
+ }
return 1;
}
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_ABI_enum_size[] =
{"Unused", "small", "int", "forced to int"};
static const char * arm_attr_tag_ABI_HardFP_use[] =
- {"As Tag_FP_arch", "SP only", "DP only", "SP and DP"};
+ {"As Tag_FP_arch", "SP only", "Reserved", "Deprecated"};
static const char * arm_attr_tag_ABI_VFP_args[] =
- {"AAPCS", "VFP registers", "custom"};
+ {"AAPCS", "VFP registers", "custom", "compatible"};
static const char * arm_attr_tag_ABI_WMMX_args[] =
{"AAPCS", "WMMX registers", "custom"};
static const char * arm_attr_tag_ABI_optimization_goals[] =
return display_tag_value (tag & 1, p, end);
}
+static unsigned char *
+display_s390_gnu_attribute (unsigned char * p,
+ int tag,
+ const unsigned char * const end)
+{
+ unsigned int len;
+ int val;
+
+ if (tag == Tag_GNU_S390_ABI_Vector)
+ {
+ val = read_uleb128 (p, &len, end);
+ p += len;
+ printf (" Tag_GNU_S390_ABI_Vector: ");
+
+ switch (val)
+ {
+ case 0:
+ printf (_("any\n"));
+ break;
+ case 1:
+ printf (_("software\n"));
+ break;
+ case 2:
+ printf (_("hardware\n"));
+ break;
+ default:
+ printf ("??? (%d)\n", val);
+ break;
+ }
+ return p;
+ }
+
+ return display_tag_value (tag & 1, p, end);
+}
+
static void
display_sparc_hwcaps (int mask)
{
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;
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)
{
/* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
Print the Address, Access and Initial fields of an entry at VMA ADDR
- and return the VMA of the next entry. */
+ and return the VMA of the next entry, or -1 if there was a problem.
+ Does not read from DATA_END or beyond. */
static bfd_vma
-print_mips_got_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr)
+print_mips_got_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr,
+ unsigned char * data_end)
{
printf (" ");
print_vma (addr, LONG_HEX);
else
{
bfd_vma entry;
+ unsigned char * from = data + addr - pltgot;
- entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
- print_vma (entry, LONG_HEX);
+ if (from + (is_32bit_elf ? 4 : 8) > data_end)
+ {
+ warn (_("MIPS GOT entry extends beyond the end of available data\n"));
+ printf ("%*s", is_32bit_elf ? 8 : 16, _("<corrupt>"));
+ return (bfd_vma) -1;
+ }
+ else
+ {
+ entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
+ print_vma (entry, LONG_HEX);
+ }
}
return addr + (is_32bit_elf ? 4 : 8);
}
/* Find the section header so that we get the size. */
sect = find_section_by_type (SHT_MIPS_OPTIONS);
- /* PR 17533 file: 012-277276-0.004. */
+ /* PR 17533 file: 012-277276-0.004. */
if (sect == NULL)
{
error (_("No MIPS_OPTIONS header found\n"));
offset = cnt = 0;
option = iopt;
- while (offset < sect->sh_size)
+ while (offset <= sect->sh_size - sizeof (* eopt))
{
Elf_External_Options * eoption;
option->section = BYTE_GET (eoption->section);
option->info = BYTE_GET (eoption->info);
+ /* PR 17531: file: ffa0fa3b. */
+ if (option->size < sizeof (* eopt)
+ || offset + option->size > sect->sh_size)
+ {
+ error (_("Invalid size (%u) for MIPS option\n"), option->size);
+ return 0;
+ }
offset += option->size;
++option;
printable_section_name (sect), cnt);
option = iopt;
+ offset = 0;
while (cnt-- > 0)
{
len = sizeof (* eopt);
while (len < option->size)
- if (((char *) option)[len] >= ' '
- && ((char *) option)[len] < 0x7f)
- printf ("%c", ((char *) option)[len++]);
- else
- printf ("\\%03o", ((char *) option)[len++]);
+ {
+ unsigned char datum = * ((unsigned char *) eopt + offset + len);
+ if (ISPRINT (datum))
+ printf ("%c", datum);
+ else
+ printf ("\\%03o", datum);
+ len ++;
+ }
fputs ("\n", stdout);
+
+ offset += option->size;
++option;
}
bfd_vma ent, local_end, global_end;
size_t i, offset;
unsigned char * data;
+ unsigned char * data_end;
int addr_size;
ent = pltgot;
if (symtabno < gotsym)
{
error (_("The GOT symbol offset (%lu) is greater than the symbol table size (%lu)\n"),
- (long) gotsym, (long) symtabno);
+ (unsigned long) gotsym, (unsigned long) symtabno);
return 0;
}
-
+
global_end = local_end + (symtabno - gotsym) * addr_size;
- assert (global_end >= local_end);
+ /* PR 17531: file: 54c91a34. */
+ if (global_end < local_end)
+ {
+ error (_("Too many GOT symbols: %lu\n"), (unsigned long) symtabno);
+ return 0;
+ }
+
offset = offset_from_vma (file, pltgot, global_end - pltgot);
data = (unsigned char *) get_data (NULL, file, offset,
global_end - pltgot, 1,
_("Global Offset Table data"));
if (data == NULL)
return 0;
+ data_end = data + (global_end - pltgot);
printf (_("\nPrimary GOT:\n"));
printf (_(" Canonical gp value: "));
printf (_(" %*s %10s %*s Purpose\n"),
addr_size * 2, _("Address"), _("Access"),
addr_size * 2, _("Initial"));
- ent = print_mips_got_entry (data, pltgot, ent);
+ ent = print_mips_got_entry (data, pltgot, ent, data_end);
printf (_(" Lazy resolver\n"));
+ if (ent == (bfd_vma) -1)
+ goto got_print_fail;
if (data
&& (byte_get (data + ent - pltgot, addr_size)
>> (addr_size * 8 - 1)) != 0)
{
- ent = print_mips_got_entry (data, pltgot, ent);
+ ent = print_mips_got_entry (data, pltgot, ent, data_end);
printf (_(" Module pointer (GNU extension)\n"));
+ if (ent == (bfd_vma) -1)
+ goto got_print_fail;
}
printf ("\n");
addr_size * 2, _("Initial"));
while (ent < local_end)
{
- ent = print_mips_got_entry (data, pltgot, ent);
+ ent = print_mips_got_entry (data, pltgot, ent, data_end);
printf ("\n");
+ if (ent == (bfd_vma) -1)
+ goto got_print_fail;
}
printf ("\n");
}
for (i = gotsym; i < symtabno; i++)
{
- ent = print_mips_got_entry (data, pltgot, ent);
+ ent = print_mips_got_entry (data, pltgot, ent, data_end);
printf (" ");
if (dynamic_symbols == NULL)
(unsigned long) i);
printf ("\n");
+ if (ent == (bfd_vma) -1)
+ break;
}
printf ("\n");
}
+ got_print_fail:
if (data)
free (data);
}
return _("NT_S390_SYSTEM_CALL (s390 system call restart data)");
case NT_S390_TDB:
return _("NT_S390_TDB (s390 transaction diagnostic block)");
+ case NT_S390_VXRS_LOW:
+ return _("NT_S390_VXRS_LOW (s390 vector registers 0-15 upper half)");
+ case NT_S390_VXRS_HIGH:
+ return _("NT_S390_VXRS_HIGH (s390 vector registers 16-31)");
case NT_ARM_VFP:
return _("NT_ARM_VFP (arm VFP registers)");
case NT_ARM_TLS:
(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;
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;
return 1;
}
+static const char *
+get_v850_elf_note_type (enum v850_notes n_type)
+{
+ static char buff[64];
+
+ switch (n_type)
+ {
+ case V850_NOTE_ALIGNMENT: return _("Alignment of 8-byte objects");
+ case V850_NOTE_DATA_SIZE: return _("Sizeof double and long double");
+ case V850_NOTE_FPU_INFO: return _("Type of FPU support needed");
+ case V850_NOTE_SIMD_INFO: return _("Use of SIMD instructions");
+ case V850_NOTE_CACHE_INFO: return _("Use of cache");
+ case V850_NOTE_MMU_INFO: return _("Use of MMU");
+ default:
+ snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), n_type);
+ return buff;
+ }
+}
+
+static int
+print_v850_note (Elf_Internal_Note * pnote)
+{
+ unsigned int val;
+
+ if (pnote->descsz != 4)
+ return 0;
+ val = byte_get ((unsigned char *) pnote->descdata, pnote->descsz);
+
+ if (val == 0)
+ {
+ printf (_("not set\n"));
+ return 1;
+ }
+
+ 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;
+ }
+ 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;
+ }
+ 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;
+ }
+ 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;
+ }
+ break;
+
+ default:
+ /* An 'unknown note type' message will already have been displayed. */
+ break;
+ }
+
+ printf (_("unknown value: %x\n"), val);
+ return 0;
+}
+
+static int
+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 1;
+
+ case NT_NETBSD_MARCH:
+ printf (" NetBSD\t0x%08lx\tMARCH <%s>\n", pnote->descsz,
+ pnote->descdata);
+ return 1;
+
+ default:
+ break;
+ }
+
+ printf (" NetBSD\t0x%08lx\tUnknown note type: (0x%08lx)\n", pnote->descsz,
+ pnote->type);
+ return 1;
+}
+
+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 *
get_netbsd_elfcore_note_type (unsigned e_type)
{
case NT_VMS_FPMODE:
printf (_(" Floating Point mode: "));
printf ("0x%016" BFD_VMA_FMT "x\n",
- (bfd_vma)byte_get ((unsigned char *)pnote->descdata, 8));
+ (bfd_vma) byte_get ((unsigned char *)pnote->descdata, 8));
break;
case NT_VMS_LINKTIME:
printf (_(" Link time: "));
((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata + 8, 8));
printf (_("\n Link flags : "));
printf ("0x%016" BFD_VMA_FMT "x\n",
- (bfd_vma)byte_get ((unsigned char *)pnote->descdata + 16, 8));
+ (bfd_vma) byte_get ((unsigned char *)pnote->descdata + 16, 8));
printf (_(" Header flags: 0x%08x\n"),
- (unsigned)byte_get ((unsigned char *)pnote->descdata + 24, 4));
+ (unsigned) byte_get ((unsigned char *)pnote->descdata + 24, 4));
printf (_(" Image id : %s\n"), pnote->descdata + 32);
break;
#endif
/* 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. */
{
Elf_External_Note * pnotes;
Elf_External_Note * external;
+ char * end;
int res = 1;
if (length <= 0)
(unsigned long) offset, (unsigned long) length);
printf (_(" %-20s %10s\tDescription\n"), _("Owner"), _("Data size"));
- while ((char *) external < (char *) pnotes + length)
+ end = (char *) pnotes + length;
+ while ((char *) external < end)
{
Elf_Internal_Note inote;
size_t min_notesz;
char *next;
char * temp = NULL;
- size_t data_remaining = ((char *) pnotes + length) - (char *) external;
+ size_t data_remaining = end - (char *) external;
if (!is_ia64_vms ())
{
inote.namedata = external->name;
inote.descsz = BYTE_GET (external->descsz);
inote.descdata = inote.namedata + align_power (inote.namesz, 2);
+ /* PR 17531: file: 3443835e. */
+ if (inote.descdata < (char *) pnotes || inote.descdata > end)
+ {
+ warn (_("Corrupt note: name size is too big: %lx\n"), inote.namesz);
+ inote.descdata = inote.namedata;
+ inote.namesz = 0;
+ }
+
inote.descpos = offset + (inote.descdata - (char *) pnotes);
next = inote.descdata + align_power (inote.descsz, 2);
}
return res;
}
+static int
+process_v850_notes (FILE * file, bfd_vma offset, bfd_vma length)
+{
+ Elf_External_Note * pnotes;
+ Elf_External_Note * external;
+ char * end;
+ int res = 1;
+
+ if (length <= 0)
+ return 0;
+
+ pnotes = (Elf_External_Note *) get_data (NULL, file, offset, 1, length,
+ _("v850 notes"));
+ if (pnotes == NULL)
+ return 0;
+
+ external = pnotes;
+ end = (char*) pnotes + length;
+
+ printf (_("\nDisplaying contents of Renesas V850 notes section at offset 0x%lx with length 0x%lx:\n"),
+ (unsigned long) offset, (unsigned long) length);
+
+ while ((char *) external + sizeof (Elf_External_Note) < end)
+ {
+ Elf_External_Note * next;
+ Elf_Internal_Note inote;
+
+ inote.type = BYTE_GET (external->type);
+ inote.namesz = BYTE_GET (external->namesz);
+ inote.namedata = external->name;
+ inote.descsz = BYTE_GET (external->descsz);
+ inote.descdata = inote.namedata + align_power (inote.namesz, 2);
+ inote.descpos = offset + (inote.descdata - (char *) pnotes);
+
+ if (inote.descdata < (char *) pnotes || inote.descdata >= end)
+ {
+ warn (_("Corrupt note: name size is too big: %lx\n"), inote.namesz);
+ inote.descdata = inote.namedata;
+ inote.namesz = 0;
+ }
+
+ next = (Elf_External_Note *) (inote.descdata + align_power (inote.descsz, 2));
+
+ if ( ((char *) next > end)
+ || ((char *) next < (char *) pnotes))
+ {
+ warn (_("corrupt descsz found in note at offset 0x%lx\n"),
+ (unsigned long) ((char *) external - (char *) pnotes));
+ warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
+ inote.type, inote.namesz, inote.descsz);
+ break;
+ }
+
+ external = next;
+
+ /* Prevent out-of-bounds indexing. */
+ if ( inote.namedata + inote.namesz > end
+ || inote.namedata + inote.namesz < inote.namedata)
+ {
+ warn (_("corrupt namesz found in note at offset 0x%lx\n"),
+ (unsigned long) ((char *) external - (char *) pnotes));
+ warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
+ inote.type, inote.namesz, inote.descsz);
+ break;
+ }
+
+ printf (" %s: ", get_v850_elf_note_type (inote.type));
+
+ if (! print_v850_note (& inote))
+ {
+ res = 0;
+ printf ("<corrupt sizes: namesz: %lx, descsz: %lx>\n",
+ inote.namesz, inote.descsz);
+ }
+ }
+
+ free (pnotes);
+
+ return res;
+}
+
static int
process_note_sections (FILE * file)
{
for (i = 0, section = section_headers;
i < elf_header.e_shnum && section != NULL;
i++, section++)
- if (section->sh_type == SHT_NOTE)
- {
- res &= process_corefile_note_segment (file,
- (bfd_vma) section->sh_offset,
- (bfd_vma) section->sh_size);
- n++;
- }
+ {
+ if (section->sh_type == SHT_NOTE)
+ {
+ res &= process_corefile_note_segment (file,
+ (bfd_vma) section->sh_offset,
+ (bfd_vma) section->sh_size);
+ n++;
+ }
+
+ if (( elf_header.e_machine == EM_V800
+ || elf_header.e_machine == EM_V850
+ || 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);
+ n++;
+ }
+ }
if (n == 0)
/* Try processing NOTE segments instead. */
case EM_PPC:
return process_power_specific (file);
break;
+ case EM_S390:
+ case EM_S390_OLD:
+ return process_s390_specific (file);
+ break;
case EM_SPARC:
case EM_SPARC32PLUS:
case EM_SPARCV9:
if (optind < (argc - 1))
show_name = 1;
+ else if (optind >= argc)
+ {
+ warn (_("Nothing to do.\n"));
+ usage (stderr);
+ }
err = 0;
while (optind < argc)