/* readelf.c -- display contents of an ELF format file
Copyright 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007,
- 2008, 2009, 2010
+ 2008, 2009, 2010, 2011
Free Software Foundation, Inc.
Originally developed by Eric Youngdale <eric@andante.jic.com>
#include "bfd.h"
#include "bucomm.h"
+#include "elfcomm.h"
#include "dwarf.h"
#include "elf/common.h"
#include "elf/mmix.h"
#include "elf/mn10200.h"
#include "elf/mn10300.h"
+#include "elf/moxie.h"
#include "elf/mt.h"
#include "elf/msp430.h"
#include "elf/or32.h"
#include "elf/sh.h"
#include "elf/sparc.h"
#include "elf/spu.h"
+#include "elf/tic6x.h"
#include "elf/v850.h"
#include "elf/vax.h"
#include "elf/x86-64.h"
#include "elf/xstormy16.h"
#include "elf/xtensa.h"
-#include "aout/ar.h"
-
#include "getopt.h"
#include "libiberty.h"
#include "safe-ctype.h"
}
print_mode;
-static void (* byte_put) (unsigned char *, bfd_vma, int);
-
#define UNKNOWN -1
-#define SECTION_NAME(X) \
- ((X) == NULL ? "<none>" \
- : string_table == NULL ? "<no-name>" \
- : ((X)->sh_name >= string_table_length ? "<corrupt>" \
+#define SECTION_NAME(X) \
+ ((X) == NULL ? _("<none>") \
+ : string_table == NULL ? _("<no-name>") \
+ : ((X)->sh_name >= string_table_length ? _("<corrupt>") \
: string_table + (X)->sh_name))
#define DT_VERSIONTAGIDX(tag) (DT_VERNEEDNUM - (tag)) /* Reverse order! */
-#define BYTE_GET(field) byte_get (field, sizeof (field))
-
#define GET_ELF_SYMBOLS(file, section) \
(is_32bit_elf ? get_32bit_elf_symbols (file, section) \
: get_64bit_elf_symbols (file, section))
already been called and verified that the string exists. */
#define GET_DYNAMIC_NAME(offset) (dynamic_strings + offset)
-/* This is just a bit of syntatic sugar. */
-#define streq(a,b) (strcmp ((a), (b)) == 0)
-#define strneq(a,b,n) (strncmp ((a), (b), (n)) == 0)
-#define const_strneq(a,b) (strncmp ((a), (b), sizeof (b) - 1) == 0)
-
#define REMOVE_ARCH_BITS(ADDR) do { \
if (elf_header.e_machine == EM_ARM) \
(ADDR) &= ~1; \
return mvar;
}
-static void
-byte_put_little_endian (unsigned char * field, bfd_vma value, int size)
-{
- switch (size)
- {
- case 8:
- field[7] = (((value >> 24) >> 24) >> 8) & 0xff;
- field[6] = ((value >> 24) >> 24) & 0xff;
- field[5] = ((value >> 24) >> 16) & 0xff;
- field[4] = ((value >> 24) >> 8) & 0xff;
- /* Fall through. */
- case 4:
- field[3] = (value >> 24) & 0xff;
- /* Fall through. */
- case 3:
- field[2] = (value >> 16) & 0xff;
- /* Fall through. */
- case 2:
- field[1] = (value >> 8) & 0xff;
- /* Fall through. */
- case 1:
- field[0] = value & 0xff;
- break;
-
- default:
- error (_("Unhandled data length: %d\n"), size);
- abort ();
- }
-}
-
/* Print a VMA value. */
static int
Returns the number of emitted characters. */
static unsigned int
-print_symbol (int width, const char * symbol)
+print_symbol (int width, const char *symbol)
{
- const char * c;
+ const char *c;
bfd_boolean extra_padding = FALSE;
unsigned int num_printed = 0;
if (do_wide)
{
- /* Set the width to a very large value. This simplifies the code below. */
+ /* Set the width to a very large value. This simplifies the
+ code below. */
width = INT_MAX;
}
else if (width < 0)
/* Look for non-printing symbols inside the symbol's name.
This test is triggered in particular by the names generated
by the assembler for local labels. */
- while (ISPRINT (* c))
+ while (ISPRINT (*c))
c++;
len = c - symbol;
num_printed += len;
}
- if (* c == 0 || width == 0)
+ if (*c == 0 || width == 0)
break;
/* Now display the non-printing character, if
there is room left in which to dipslay it. */
- if (*c < 32)
+ if ((unsigned char) *c < 32)
{
if (width < 2)
break;
if (width < 6)
break;
- printf ("<0x%.2x>", *c);
+ printf ("<0x%.2x>", (unsigned char) *c);
width -= 6;
num_printed += 6;
return num_printed;
}
-static void
-byte_put_big_endian (unsigned char * field, bfd_vma value, int size)
-{
- switch (size)
- {
- case 8:
- field[7] = value & 0xff;
- field[6] = (value >> 8) & 0xff;
- field[5] = (value >> 16) & 0xff;
- field[4] = (value >> 24) & 0xff;
- value >>= 16;
- value >>= 16;
- /* Fall through. */
- case 4:
- field[3] = value & 0xff;
- value >>= 8;
- /* Fall through. */
- case 3:
- field[2] = value & 0xff;
- value >>= 8;
- /* Fall through. */
- case 2:
- field[1] = value & 0xff;
- value >>= 8;
- /* Fall through. */
- case 1:
- field[0] = value & 0xff;
- break;
-
- default:
- error (_("Unhandled data length: %d\n"), size);
- abort ();
- }
-}
-
/* Return a pointer to section NAME, or NULL if no such section exists. */
static Elf_Internal_Shdr *
return read_leb128 (data, length_return, 0);
}
+/* 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
+is_ia64_vms (void)
+{
+ return elf_header.e_machine == EM_IA_64
+ && elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS;
+}
+
/* Guess the relocation size commonly used by the specific machines. */
static int
case EM_CYGNUS_MN10200:
case EM_MN10300:
case EM_CYGNUS_MN10300:
+ case EM_MOXIE:
case EM_MSP430:
case EM_MSP430_OLD:
case EM_MT:
case EM_SPARC32PLUS:
case EM_SPARCV9:
case EM_SPU:
+ case EM_TI_C6000:
case EM_V850:
case EM_CYGNUS_V850:
case EM_VAX:
{
relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
relas[i].r_info = BYTE_GET (erelas[i].r_info);
- relas[i].r_addend = BYTE_GET (erelas[i].r_addend);
+ relas[i].r_addend = BYTE_GET_SIGNED (erelas[i].r_addend);
}
free (erelas);
{
relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
relas[i].r_info = BYTE_GET (erelas[i].r_info);
- relas[i].r_addend = BYTE_GET (erelas[i].r_addend);
+ relas[i].r_addend = BYTE_GET_SIGNED (erelas[i].r_addend);
/* The #ifdef BFD64 below is to prevent a compile time
warning. We know that if we do not have a 64 bit data
rtype = elf_mmix_reloc_type (type);
break;
+ case EM_MOXIE:
+ rtype = elf_moxie_reloc_type (type);
+ break;
+
case EM_MSP430:
case EM_MSP430_OLD:
rtype = elf_msp430_reloc_type (type);
case EM_CR16_OLD:
rtype = elf_cr16_reloc_type (type);
break;
-
+
case EM_MICROBLAZE:
case EM_MICROBLAZE_OLD:
rtype = elf_microblaze_reloc_type (type);
case EM_C166:
rtype = elf_xc16x_reloc_type (type);
break;
+
+ case EM_TI_C6000:
+ rtype = elf_tic6x_reloc_type (type);
+ break;
}
if (rtype == NULL)
else if (symtab_index)
{
if (symtab == NULL || symtab_index >= nsyms)
- printf (" bad symbol index: %08lx", (unsigned long) symtab_index);
+ printf (_(" bad symbol index: %08lx"), (unsigned long) symtab_index);
else
{
Elf_Internal_Sym * psym;
&& elf_header.e_ident[EI_OSABI] == ELFOSABI_HPUX
&& psym->st_shndx == SHN_IA_64_ANSI_COMMON)
sec_name = "ANSI_COM";
- else if (elf_header.e_machine == EM_IA_64
- && (elf_header.e_ident[EI_OSABI]
- == ELFOSABI_OPENVMS)
+ else if (is_ia64_vms ()
&& psym->st_shndx == SHN_IA_64_VMS_SYMVEC)
sec_name = "VMS_SYMVEC";
else
if (is_rela)
{
- long off = (long) (bfd_signed_vma) rels[i].r_addend;
+ bfd_signed_vma off = rels[i].r_addend;
if (off < 0)
- printf (" - %lx", - off);
+ printf (" - %" BFD_VMA_FMT "x", - off);
else
- printf (" + %lx", off);
+ printf (" + %" BFD_VMA_FMT "x", off);
}
}
}
}
}
+static const char *
+get_tic6x_dynamic_type (unsigned long type)
+{
+ switch (type)
+ {
+ case DT_C6000_GSYM_OFFSET: return "C6000_GSYM_OFFSET";
+ case DT_C6000_GSTR_OFFSET: return "C6000_GSTR_OFFSET";
+ case DT_C6000_DSBT_BASE: return "C6000_DSBT_BASE";
+ case DT_C6000_DSBT_SIZE: return "C6000_DSBT_SIZE";
+ case DT_C6000_PREEMPTMAP: return "C6000_PREEMPTMAP";
+ case DT_C6000_DSBT_INDEX: return "C6000_DSBT_INDEX";
+ default:
+ return NULL;
+ }
+}
static const char *
get_dynamic_type (unsigned long type)
case EM_SCORE:
result = get_score_dynamic_type (type);
break;
+ case EM_TI_C6000:
+ result = get_tic6x_dynamic_type (type);
+ break;
default:
result = NULL;
break;
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";
}
if (unknown)
- strcat (buf,", <unknown>");
+ strcat (buf,_(", <unknown>"));
}
static char *
decode_ARM_machine_flags (e_flags, buf);
break;
+ case EM_BLACKFIN:
+ if (e_flags & EF_BFIN_PIC)
+ strcat (buf, ", PIC");
+
+ if (e_flags & EF_BFIN_FDPIC)
+ strcat (buf, ", FDPIC");
+
+ if (e_flags & EF_BFIN_CODE_IN_L1)
+ strcat (buf, ", code in L1");
+
+ if (e_flags & EF_BFIN_DATA_IN_L1)
+ strcat (buf, ", data in L1");
+
+ break;
+
case EM_CYGNUS_FRV:
switch (e_flags & EF_FRV_CPU_MASK)
{
case EF_M68K_CF_ISA_B:
isa = "B";
break;
+ case EF_M68K_CF_ISA_C:
+ isa = "C";
+ break;
+ case EF_M68K_CF_ISA_C_NODIV:
+ isa = "C";
+ additional = ", nodiv";
+ break;
}
strcat (buf, ", cf, isa ");
strcat (buf, isa);
case EF_M68K_CF_EMAC:
mac = "emac";
break;
+ case EF_M68K_CF_EMAC_B:
+ mac = "emac_b";
+ break;
}
if (mac)
{
strcat (buf, ", emb");
if (e_flags & EF_PPC_RELOCATABLE)
- strcat (buf, ", relocatable");
+ strcat (buf, _(", relocatable"));
if (e_flags & EF_PPC_RELOCATABLE_LIB)
- strcat (buf, ", relocatable-lib");
+ strcat (buf, _(", relocatable-lib"));
break;
case EM_V850:
case EM_CYGNUS_V850:
switch (e_flags & EF_V850_ARCH)
{
- case E_V850E1_ARCH:
- strcat (buf, ", v850e1");
+ case E_V850E2V3_ARCH:
+ strcat (buf, ", v850e2v3");
+ break;
+ case E_V850E2_ARCH:
+ strcat (buf, ", v850e2");
+ break;
+ case E_V850E1_ARCH:
+ strcat (buf, ", v850e1");
break;
case E_V850E_ARCH:
strcat (buf, ", v850e");
strcat (buf, ", v850");
break;
default:
- strcat (buf, ", unknown v850 architecture variant");
+ strcat (buf, _(", unknown v850 architecture variant"));
break;
}
break;
case E_MIPS_MACH_9000: strcat (buf, ", 9000"); break;
case E_MIPS_MACH_LS2E: strcat (buf, ", loongson-2e"); break;
case E_MIPS_MACH_LS2F: strcat (buf, ", loongson-2f"); break;
+ case E_MIPS_MACH_LS3A: strcat (buf, ", loongson-3a"); break;
case E_MIPS_MACH_OCTEON: strcat (buf, ", octeon"); break;
case E_MIPS_MACH_OCTEON2: strcat (buf, ", octeon2"); break;
case E_MIPS_MACH_XLR: strcat (buf, ", xlr"); break;
MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
extension. */
break;
- default: strcat (buf, ", unknown CPU"); break;
+ default: strcat (buf, _(", unknown CPU")); break;
}
switch ((e_flags & EF_MIPS_ABI))
This means it is likely to be an o32 file, but not for
sure. */
break;
- default: strcat (buf, ", unknown ABI"); break;
+ default: strcat (buf, _(", unknown ABI")); break;
}
if (e_flags & EF_MIPS_ARCH_ASE_MDMX)
case E_MIPS_ARCH_32R2: strcat (buf, ", mips32r2"); break;
case E_MIPS_ARCH_64: strcat (buf, ", mips64"); break;
case E_MIPS_ARCH_64R2: strcat (buf, ", mips64r2"); break;
- default: strcat (buf, ", unknown ISA"); break;
+ default: strcat (buf, _(", unknown ISA")); break;
}
+ if (e_flags & EF_SH_PIC)
+ strcat (buf, ", pic");
+
+ if (e_flags & EF_SH_FDPIC)
+ strcat (buf, ", fdpic");
break;
case EM_SH:
case EF_SH2A_SH3_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh3-nommu"); break;
case EF_SH2A_SH4: strcat (buf, ", sh2a-or-sh4"); break;
case EF_SH2A_SH3E: strcat (buf, ", sh2a-or-sh3e"); break;
- default: strcat (buf, ", unknown ISA"); break;
+ default: strcat (buf, _(", unknown ISA")); break;
}
break;
strcat (buf, ", constant gp");
if ((e_flags & EF_IA_64_ABSOLUTE))
strcat (buf, ", absolute");
+ if (elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
+ {
+ if ((e_flags & EF_IA_64_VMS_LINKAGES))
+ strcat (buf, ", vms_linkages");
+ switch ((e_flags & EF_IA_64_VMS_COMCOD))
+ {
+ case EF_IA_64_VMS_COMCOD_SUCCESS:
+ break;
+ case EF_IA_64_VMS_COMCOD_WARNING:
+ strcat (buf, ", warning");
+ break;
+ case EF_IA_64_VMS_COMCOD_ERROR:
+ strcat (buf, ", error");
+ break;
+ case EF_IA_64_VMS_COMCOD_ABORT:
+ strcat (buf, ", abort");
+ break;
+ default:
+ abort ();
+ }
+ }
break;
case EM_VAX:
if (e_flags & E_FLAG_RX_64BIT_DOUBLES)
strcat (buf, ", 64-bit doubles");
if (e_flags & E_FLAG_RX_DSP)
- strcat (buf, ", dsp");
+ strcat (buf, ", dsp");
case EM_S390:
if (e_flags & EF_S390_HIGH_GPRS)
strcat (buf, ", highgprs");
+
+ case EM_TI_C6000:
+ if ((e_flags & EF_C6000_REL))
+ strcat (buf, ", relocatable module");
}
}
case ELFOSABI_NSK: return "HP - Non-Stop Kernel";
case ELFOSABI_AROS: return "AROS";
case ELFOSABI_FENIXOS: return "FenixOS";
- case ELFOSABI_STANDALONE: return _("Standalone App");
- case ELFOSABI_ARM: return "ARM";
default:
+ if (osabi >= 64)
+ switch (elf_header.e_machine)
+ {
+ case EM_ARM:
+ switch (osabi)
+ {
+ case ELFOSABI_ARM: return "ARM";
+ default:
+ break;
+ }
+ break;
+
+ case EM_MSP430:
+ case EM_MSP430_OLD:
+ switch (osabi)
+ {
+ case ELFOSABI_STANDALONE: return _("Standalone App");
+ default:
+ break;
+ }
+ break;
+
+ case EM_TI_C6000:
+ switch (osabi)
+ {
+ case ELFOSABI_C6000_ELFABI: return _("Bare-metal C6000");
+ case ELFOSABI_C6000_LINUX: return "Linux C6000";
+ default:
+ break;
+ }
+ break;
+
+ default:
+ break;
+ }
snprintf (buff, sizeof (buff), _("<unknown: %x>"), osabi);
return buff;
}
return NULL;
}
+static const char *
+get_tic6x_segment_type (unsigned long type)
+{
+ switch (type)
+ {
+ case PT_C6000_PHATTR: return "C6000_PHATTR";
+ default:
+ break;
+ }
+
+ return NULL;
+}
+
static const char *
get_segment_type (unsigned long p_type)
{
case EM_IA_64:
result = get_ia64_segment_type (p_type);
break;
+ case EM_TI_C6000:
+ result = get_tic6x_segment_type (p_type);
+ break;
default:
result = NULL;
break;
return NULL;
}
+static const char *
+get_tic6x_section_type_name (unsigned int sh_type)
+{
+ switch (sh_type)
+ {
+ case SHT_C6000_UNWIND:
+ return "C6000_UNWIND";
+ case SHT_C6000_PREEMPTMAP:
+ return "C6000_PREEMPTMAP";
+ case SHT_C6000_ATTRIBUTES:
+ return "C6000_ATTRIBUTES";
+ case SHT_TI_ICODE:
+ return "TI_ICODE";
+ case SHT_TI_XREF:
+ return "TI_XREF";
+ case SHT_TI_HANDLER:
+ return "TI_HANDLER";
+ case SHT_TI_INITINFO:
+ return "TI_INITINFO";
+ case SHT_TI_PHATTRS:
+ return "TI_PHATTRS";
+ default:
+ break;
+ }
+ return NULL;
+}
+
static const char *
get_section_type_name (unsigned int sh_type)
{
case EM_ARM:
result = get_arm_section_type_name (sh_type);
break;
+ case EM_TI_C6000:
+ result = get_tic6x_section_type_name (sh_type);
+ break;
default:
result = NULL;
break;
Dump the contents of section <number|name> as relocated bytes\n\
-w[lLiaprmfFsoRt] or\n\
--debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
- =frames-interp,=str,=loc,=Ranges,=pubtypes]\n\
+ =frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
+ =gdb_index,=trace_info,=trace_abbrev,=trace_aranges]\n\
Display the contents of DWARF2 debug sections\n"));
#ifdef SUPPORT_DISASSEMBLY
fprintf (stream, _("\
(elf_header.e_ident[EI_VERSION] == EV_CURRENT
? "(current)"
: (elf_header.e_ident[EI_VERSION] != EV_NONE
- ? "<unknown: %lx>"
+ ? _("<unknown: %lx>")
: "")));
printf (_(" OS/ABI: %s\n"),
get_osabi_name (elf_header.e_ident[EI_OSABI]));
if (section_headers != NULL
&& elf_header.e_phnum == PN_XNUM
&& section_headers[0].sh_info != 0)
- printf (_(" (%ld)"), (long) section_headers[0].sh_info);
+ printf (" (%ld)", (long) section_headers[0].sh_info);
putc ('\n', stdout);
printf (_(" Size of section headers: %ld (bytes)\n"),
(long) elf_header.e_shentsize);
printf (" (%u)", section_headers[0].sh_link);
else if (elf_header.e_shstrndx != SHN_UNDEF
&& elf_header.e_shstrndx >= elf_header.e_shnum)
- printf (" <corrupt: out of range>");
+ printf (_(" <corrupt: out of range>"));
putc ('\n', stdout);
}
if (elf_header.e_phnum == 0)
{
- if (do_segments)
+ /* 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"));
+ else if (do_segments)
printf (_("\nThere are no program headers in this file.\n"));
return 0;
}
sec = find_section (".dynamic");
if (sec == NULL || sec->sh_size == 0)
{
- error (_("no .dynamic section in the dynamic segment\n"));
+ /* A corresponding .dynamic section is expected, but on
+ IA-64/OpenVMS it is OK for it to be missing. */
+ if (!is_ia64_vms ())
+ error (_("no .dynamic section in the dynamic segment\n"));
break;
}
for (j = 1; j < elf_header.e_shnum; j++, section++)
{
- if (ELF_IS_SECTION_IN_SEGMENT_MEMORY (section, segment))
+ if (!ELF_TBSS_SPECIAL (section, segment)
+ && ELF_SECTION_IN_SEGMENT_STRICT (section, segment))
printf ("%s ", SECTION_NAME (section));
}
get_32bit_elf_symbols (FILE * file, Elf_Internal_Shdr * section)
{
unsigned long number;
- Elf32_External_Sym * esyms;
+ Elf32_External_Sym * esyms = NULL;
Elf_External_Sym_Shndx * shndx;
- Elf_Internal_Sym * isyms;
+ Elf_Internal_Sym * isyms = NULL;
Elf_Internal_Sym * psym;
unsigned int j;
+ /* Run some sanity checks first. */
+ if (section->sh_entsize == 0)
+ {
+ error (_("sh_entsize is zero\n"));
+ return NULL;
+ }
+
+ number = section->sh_size / section->sh_entsize;
+
+ if (number * sizeof (Elf32_External_Sym) > section->sh_size + 1)
+ {
+ error (_("Invalid sh_entsize\n"));
+ return NULL;
+ }
+
esyms = (Elf32_External_Sym *) get_data (NULL, file, section->sh_offset, 1,
section->sh_size, _("symbols"));
- if (!esyms)
+ if (esyms == NULL)
return NULL;
shndx = NULL;
symtab_shndx_hdr->sh_offset,
1, symtab_shndx_hdr->sh_size,
_("symtab shndx"));
- if (!shndx)
- {
- free (esyms);
- return NULL;
- }
+ if (shndx == NULL)
+ goto exit_point;
}
- number = section->sh_size / section->sh_entsize;
isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
if (isyms == NULL)
{
error (_("Out of memory\n"));
- if (shndx)
- free (shndx);
- free (esyms);
- return NULL;
+ goto exit_point;
}
- for (j = 0, psym = isyms;
- j < number;
- j++, psym++)
+ for (j = 0, psym = isyms; j < number; j++, psym++)
{
psym->st_name = BYTE_GET (esyms[j].st_name);
psym->st_value = BYTE_GET (esyms[j].st_value);
psym->st_other = BYTE_GET (esyms[j].st_other);
}
+ exit_point:
if (shndx)
free (shndx);
- free (esyms);
+ if (esyms)
+ free (esyms);
return isyms;
}
Elf_Internal_Sym * psym;
unsigned int j;
+ /* Run some sanity checks first. */
+ if (section->sh_entsize == 0)
+ {
+ error (_("sh_entsize is zero\n"));
+ return NULL;
+ }
+
+ number = section->sh_size / section->sh_entsize;
+
+ if (number * sizeof (Elf64_External_Sym) > section->sh_size + 1)
+ {
+ error (_("Invalid sh_entsize\n"));
+ return NULL;
+ }
+
esyms = (Elf64_External_Sym *) get_data (NULL, file, section->sh_offset, 1,
section->sh_size, _("symbols"));
if (!esyms)
}
}
- number = section->sh_size / section->sh_entsize;
isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
if (isyms == NULL)
/* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
/* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
/* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
- /* SPARC specific. */
+ /* Generic. */
/* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
+ /* SPARC specific. */
/* 19 */ { STRING_COMMA_LEN ("ORDERED") }
};
case SHF_OS_NONCONFORMING: sindex = 7; break;
case SHF_GROUP: sindex = 8; break;
case SHF_TLS: sindex = 9; break;
+ case SHF_EXCLUDE: sindex = 18; break;
default:
sindex = -1;
case EM_386:
case EM_486:
case EM_X86_64:
+ case EM_L1OM:
case EM_OLD_SPARCV9:
case EM_SPARC32PLUS:
case EM_SPARCV9:
case EM_SPARC:
- if (flag == SHF_EXCLUDE)
- sindex = 18;
- else if (flag == SHF_ORDERED)
+ if (flag == SHF_ORDERED)
sindex = 19;
break;
default:
case SHF_OS_NONCONFORMING: *p = 'O'; break;
case SHF_GROUP: *p = 'G'; break;
case SHF_TLS: *p = 'T'; break;
+ case SHF_EXCLUDE: *p = 'E'; break;
default:
if ((elf_header.e_machine == EM_X86_64
*p++ = ',';
*p++ = ' ';
}
- sprintf (p, "UNKNOWN (%*.*lx)", field_size, field_size,
+ sprintf (p, _("UNKNOWN (%*.*lx)"), field_size, field_size,
(unsigned long) unknown_flags);
p += 10 + field_size;
}
if (elf_header.e_shnum == 0)
{
- if (do_sections)
+ /* 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"));
+ else if (do_sections)
printf (_("\nThere are no sections in this file.\n"));
return 1;
request_dump_bynumber (i, DEBUG_DUMP);
else if (do_debug_frames && streq (name, ".eh_frame"))
request_dump_bynumber (i, DEBUG_DUMP);
+ else if (do_gdb_index && streq (name, ".gdb_index"))
+ request_dump_bynumber (i, DEBUG_DUMP);
+ /* Trace sections for Itanium VMS. */
+ else if ((do_debugging || do_trace_info || do_trace_abbrevs
+ || do_trace_aranges)
+ && const_strneq (name, ".trace_"))
+ {
+ name += sizeof (".trace_") - 1;
+
+ if (do_debugging
+ || (do_trace_info && streq (name, "info"))
+ || (do_trace_abbrevs && streq (name, "abbrev"))
+ || (do_trace_aranges && streq (name, "aranges"))
+ )
+ request_dump_bynumber (i, DEBUG_DUMP);
+ }
+
}
if (! do_sections)
case EM_386:
case EM_486:
case EM_X86_64:
+ case EM_L1OM:
case EM_OLD_SPARCV9:
case EM_SPARC32PLUS:
case EM_SPARCV9:
}
if (!do_section_details)
- printf (_("Key to Flags:\n\
+ {
+ if (elf_header.e_machine == EM_X86_64
+ || elf_header.e_machine == EM_L1OM)
+ 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), x (unknown)\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"));
+ }
return 1;
}
if (elf_header.e_shnum == 0)
{
if (do_section_groups)
- printf (_("\nThere are no sections in this file.\n"));
+ printf (_("\nThere are no sections to group in this file.\n"));
return 1;
}
symtab = GET_ELF_SYMBOLS (file, symtab_sec);
}
+ if (symtab == NULL)
+ {
+ error (_("Corrupt header in group section `%s'\n"), name);
+ continue;
+ }
+
sym = symtab + section->sh_info;
if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
strtab_size = strtab != NULL ? strtab_sec->sh_size : 0;
}
group_name = sym->st_name < strtab_size
- ? strtab + sym->st_name : "<corrupt>";
+ ? strtab + sym->st_name : _("<corrupt>");
}
start = (unsigned char *) get_data (NULL, file, section->sh_offset,
if (do_section_groups)
{
- printf ("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n",
+ printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
get_group_flags (entry), i, name, group_name, size);
printf (_(" [Index] Name\n"));
return 1;
}
+/* Data used to display dynamic fixups. */
+
+struct ia64_vms_dynfixup
+{
+ bfd_vma needed_ident; /* Library ident number. */
+ bfd_vma needed; /* Index in the dstrtab of the library name. */
+ bfd_vma fixup_needed; /* Index of the library. */
+ bfd_vma fixup_rela_cnt; /* Number of fixups. */
+ bfd_vma fixup_rela_off; /* Fixups offset in the dynamic segment. */
+};
+
+/* Data used to display dynamic relocations. */
+
+struct ia64_vms_dynimgrela
+{
+ bfd_vma img_rela_cnt; /* Number of relocations. */
+ bfd_vma img_rela_off; /* Reloc offset in the dynamic segment. */
+};
+
+/* 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)
+{
+ Elf64_External_VMS_IMAGE_FIXUP *imfs;
+ long i;
+ 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;
+
+ if (fixup->needed < strtab_sz)
+ lib_name = strtab + fixup->needed;
+ else
+ {
+ warn ("corrupt library name index of 0x%lx found in dynamic entry",
+ (unsigned long) fixup->needed);
+ lib_name = "???";
+ }
+ printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
+ (int) fixup->fixup_needed, lib_name, (long) fixup->needed_ident);
+ printf
+ (_("Seg Offset Type SymVec DataType\n"));
+
+ for (i = 0; i < (long) fixup->fixup_rela_cnt; i++)
+ {
+ unsigned int type;
+ const char *rtype;
+
+ printf ("%3u ", (unsigned) BYTE_GET (imfs [i].fixup_seg));
+ printf_vma ((bfd_vma) BYTE_GET (imfs [i].fixup_offset));
+ type = BYTE_GET (imfs [i].type);
+ rtype = elf_ia64_reloc_type (type);
+ if (rtype == NULL)
+ printf (" 0x%08x ", type);
+ else
+ printf (" %-32s ", rtype);
+ printf ("%6u ", (unsigned) BYTE_GET (imfs [i].symvec_index));
+ printf ("0x%08x\n", (unsigned) BYTE_GET (imfs [i].data_type));
+ }
+
+ free (imfs);
+}
+
+/* Display IA-64 OpenVMS dynamic relocations (used to relocate an image). */
+
+static void
+dump_ia64_vms_dynamic_relocs (FILE *file, struct ia64_vms_dynimgrela *imgrela)
+{
+ Elf64_External_VMS_IMAGE_RELA *imrs;
+ long i;
+
+ imrs = get_data (NULL, file, dynamic_addr + imgrela->img_rela_off,
+ 1, imgrela->img_rela_cnt * sizeof (*imrs),
+ _("dynamic section image relas"));
+ if (!imrs)
+ return;
+
+ printf (_("\nImage relocs\n"));
+ printf
+ (_("Seg Offset Type Addend Seg Sym Off\n"));
+
+ for (i = 0; i < (long) imgrela->img_rela_cnt; i++)
+ {
+ unsigned int type;
+ const char *rtype;
+
+ printf ("%3u ", (unsigned) BYTE_GET (imrs [i].rela_seg));
+ printf ("%08" BFD_VMA_FMT "x ",
+ (bfd_vma) BYTE_GET (imrs [i].rela_offset));
+ type = BYTE_GET (imrs [i].type);
+ rtype = elf_ia64_reloc_type (type);
+ if (rtype == NULL)
+ printf ("0x%08x ", type);
+ else
+ printf ("%-31s ", rtype);
+ print_vma (BYTE_GET (imrs [i].addend), FULL_HEX);
+ printf ("%3u ", (unsigned) BYTE_GET (imrs [i].sym_seg));
+ printf ("%08" BFD_VMA_FMT "x\n",
+ (bfd_vma) BYTE_GET (imrs [i].sym_offset));
+ }
+
+ free (imrs);
+}
+
+/* Display IA-64 OpenVMS dynamic relocations and fixups. */
+
+static int
+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;
+
+ memset (&fixup, 0, sizeof (fixup));
+ memset (&imgrela, 0, sizeof (imgrela));
+
+ /* Note: the order of the entries is specified by the OpenVMS specs. */
+ for (entry = dynamic_section;
+ entry < dynamic_section + dynamic_nent;
+ entry++)
+ {
+ switch (entry->d_tag)
+ {
+ case DT_IA_64_VMS_STRTAB_OFFSET:
+ strtab_off = entry->d_un.d_val;
+ break;
+ case DT_STRSZ:
+ strtab_sz = entry->d_un.d_val;
+ if (strtab == NULL)
+ strtab = get_data (NULL, file, dynamic_addr + strtab_off,
+ 1, strtab_sz, _("dynamic string section"));
+ break;
+
+ case DT_IA_64_VMS_NEEDED_IDENT:
+ fixup.needed_ident = entry->d_un.d_val;
+ break;
+ case DT_NEEDED:
+ fixup.needed = entry->d_un.d_val;
+ break;
+ case DT_IA_64_VMS_FIXUP_NEEDED:
+ fixup.fixup_needed = entry->d_un.d_val;
+ break;
+ case DT_IA_64_VMS_FIXUP_RELA_CNT:
+ fixup.fixup_rela_cnt = entry->d_un.d_val;
+ 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);
+ 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);
+ break;
+
+ default:
+ break;
+ }
+ }
+
+ if (strtab != NULL)
+ free (strtab);
+
+ return res;
+}
+
static struct
{
const char * name;
}
}
+ if (is_ia64_vms ())
+ has_dynamic_reloc |= process_ia64_vms_dynamic_relocs (file);
+
if (! has_dynamic_reloc)
printf (_("\nThere are no dynamic relocations in this file.\n"));
}
if (best)
{
*symname = (best->st_name >= strtab_size
- ? "<corrupt>" : strtab + best->st_name);
+ ? _("<corrupt>") : strtab + best->st_name);
*offset = dist;
return;
}
if (UNW_VER (stamp) != 1)
{
- printf ("\tUnknown version.\n");
+ printf (_("\tUnknown version.\n"));
continue;
}
{
case 0:
aux->table[i].start.section = sym->st_shndx;
- aux->table[i].start.offset += rp->r_addend + sym->st_value;
+ aux->table[i].start.offset = rp->r_addend + sym->st_value;
break;
case 1:
aux->table[i].end.section = sym->st_shndx;
- aux->table[i].end.offset += rp->r_addend + sym->st_value;
+ aux->table[i].end.offset = rp->r_addend + sym->st_value;
break;
case 2:
aux->table[i].info.section = sym->st_shndx;
- aux->table[i].info.offset += rp->r_addend + sym->st_value;
+ aux->table[i].info.offset = rp->r_addend + sym->st_value;
break;
default:
break;
} \
else \
{ \
- printf ("[Truncated opcode]\n"); \
+ printf (_("[Truncated opcode]\n")); \
return; \
} \
- printf (_("0x%02x "), OP)
+ printf ("0x%02x ", OP)
if (remaining == 0)
{
}
else
{
-
per_index = (word >> 24) & 0x7f;
if (per_index != 0 && per_index != 1 && per_index != 2)
{
op = word >> 24;
word <<= 8;
- printf (_(" 0x%02x "), op);
+ printf (" 0x%02x ", op);
if ((op & 0xc0) == 0x00)
{
int offset = ((op & 0x3f) << 2) + 4;
- printf (_(" vsp = vsp + %d"), offset);
+ printf (" vsp = vsp + %d", offset);
}
else if ((op & 0xc0) == 0x40)
{
int offset = ((op & 0x3f) << 2) + 4;
- printf (_(" vsp = vsp - %d"), offset);
+ printf (" vsp = vsp - %d", offset);
}
else if ((op & 0xf0) == 0x80)
{
unsigned int mask = ((op & 0x0f) << 8) | op2;
int first = 1;
int i;
+
printf ("pop {");
for (i = 0; i < 12; i++)
if (mask & (1 << i))
if (op == 0x9d || op == 0x9f)
printf (_(" [Reserved]"));
else
- printf (_(" vsp = r%d"), op & 0x0f);
+ printf (" vsp = r%d", op & 0x0f);
}
else if ((op & 0xf0) == 0xa0)
{
}
else if (op == 0xb2)
{
- unsigned char buf[5];
+ unsigned char buf[9];
unsigned int i, len;
unsigned long offset;
- for (i = 0; i < 9; i++)
+ for (i = 0; i < sizeof (buf); i++)
{
GET_OP (buf[i]);
if ((buf[i] & 0x80) == 0)
offset = read_uleb128 (buf, &len);
assert (len == i + 1);
offset = offset * 4 + 0x204;
- printf (_("vsp = vsp + %ld"), offset);
+ printf ("vsp = vsp + %ld", offset);
}
else
{
}
else
{
- bfd_vma table, table_offset;
+ bfd_vma table, table_offset = 0;
Elf_Internal_Shdr *table_sec;
fputs ("@", stdout);
{
case DT_MIPS_FLAGS:
if (entry->d_un.d_val == 0)
- printf ("NONE\n");
+ printf (_("NONE\n"));
else
{
static const char * opts[] =
};
unsigned int cnt;
int first = 1;
+
for (cnt = 0; cnt < ARRAY_SIZE (opts); ++cnt)
if (entry->d_un.d_val & (1 << cnt))
{
case DT_MIPS_IVERSION:
if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
- printf ("Interface Version: %s\n", GET_DYNAMIC_NAME (entry->d_un.d_val));
+ printf (_("Interface Version: %s\n"), GET_DYNAMIC_NAME (entry->d_un.d_val));
else
- printf ("<corrupt: %ld>\n", (long) entry->d_un.d_ptr);
+ printf (_("<corrupt: %ld>\n"), (long) entry->d_un.d_ptr);
break;
case DT_MIPS_TIME_STAMP:
snprintf (timebuf, sizeof (timebuf), "%04u-%02u-%02uT%02u:%02u:%02u",
tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
- printf ("Time Stamp: %s\n", timebuf);
+ printf (_("Time Stamp: %s\n"), timebuf);
}
break;
}
}
-
static void
dynamic_section_parisc_val (Elf_Internal_Dyn * entry)
{
putchar ('\n');
}
+#ifdef BFD64
+
+/* VMS vs Unix time offset and factor. */
+
+#define VMS_EPOCH_OFFSET 35067168000000000LL
+#define VMS_GRANULARITY_FACTOR 10000000
+
+/* Display a VMS time in a human readable format. */
+
+static void
+print_vms_time (bfd_int64_t vmstime)
+{
+ struct tm *tm;
+ time_t unxtime;
+
+ unxtime = (vmstime - VMS_EPOCH_OFFSET) / VMS_GRANULARITY_FACTOR;
+ tm = gmtime (&unxtime);
+ printf ("%04u-%02u-%02uT%02u:%02u:%02u",
+ tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday,
+ tm->tm_hour, tm->tm_min, tm->tm_sec);
+}
+#endif /* BFD64 */
+
static void
dynamic_section_ia64_val (Elf_Internal_Dyn * entry)
{
print_vma (entry->d_un.d_ptr + (3 * 8), PREFIX_HEX);
break;
+ case DT_IA_64_VMS_LINKTIME:
+#ifdef BFD64
+ print_vms_time (entry->d_un.d_val);
+#endif
+ break;
+
+ case DT_IA_64_VMS_LNKFLAGS:
+ print_vma (entry->d_un.d_ptr, PREFIX_HEX);
+ if (entry->d_un.d_val & VMS_LF_CALL_DEBUG)
+ printf (" CALL_DEBUG");
+ if (entry->d_un.d_val & VMS_LF_NOP0BUFS)
+ printf (" NOP0BUFS");
+ if (entry->d_un.d_val & VMS_LF_P0IMAGE)
+ printf (" P0IMAGE");
+ if (entry->d_un.d_val & VMS_LF_MKTHREADS)
+ printf (" MKTHREADS");
+ if (entry->d_un.d_val & VMS_LF_UPCALLS)
+ printf (" UPCALLS");
+ if (entry->d_un.d_val & VMS_LF_IMGSTA)
+ printf (" IMGSTA");
+ if (entry->d_un.d_val & VMS_LF_INITIALIZE)
+ printf (" INITIALIZE");
+ if (entry->d_un.d_val & VMS_LF_MAIN)
+ printf (" MAIN");
+ if (entry->d_un.d_val & VMS_LF_EXE_INIT)
+ printf (" EXE_INIT");
+ if (entry->d_un.d_val & VMS_LF_TBK_IN_IMG)
+ printf (" TBK_IN_IMG");
+ if (entry->d_un.d_val & VMS_LF_DBG_IN_IMG)
+ printf (" DBG_IN_IMG");
+ if (entry->d_un.d_val & VMS_LF_TBK_IN_DSF)
+ printf (" TBK_IN_DSF");
+ if (entry->d_un.d_val & VMS_LF_DBG_IN_DSF)
+ printf (" DBG_IN_DSF");
+ if (entry->d_un.d_val & VMS_LF_SIGNATURES)
+ printf (" SIGNATURES");
+ if (entry->d_un.d_val & VMS_LF_REL_SEG_OFF)
+ printf (" REL_SEG_OFF");
+ break;
+
default:
print_vma (entry->d_un.d_ptr, PREFIX_HEX);
break;
case DF_TEXTREL: fputs ("TEXTREL", stdout); break;
case DF_BIND_NOW: fputs ("BIND_NOW", stdout); break;
case DF_STATIC_TLS: fputs ("STATIC_TLS", stdout); break;
- default: fputs ("unknown", stdout); break;
+ default: fputs (_("unknown"), stdout); break;
}
}
puts ("");
if (do_dynamic)
{
print_vma (entry->d_un.d_val, UNSIGNED);
- printf (" (bytes)\n");
+ printf (_(" (bytes)\n"));
}
break;
}
if (flags & ~(VER_FLG_BASE | VER_FLG_WEAK | VER_FLG_INFO))
- strcat (buff, "| <unknown>");
+ strcat (buff, _("| <unknown>"));
return buff;
}
(unsigned long) section->sh_offset, section->sh_link,
section->sh_link < elf_header.e_shnum
? SECTION_NAME (section_headers + section->sh_link)
- : "<corrupt>");
+ : _("<corrupt>"));
edefs = (Elf_External_Verdef *)
get_data (NULL, file, section->sh_offset, 1,section->sh_size,
int j;
int isum;
+ /* Check for negative or very large indicies. */
+ if ((unsigned char *) edefs + idx < (unsigned char *) edefs)
+ break;
+
vstart = ((char *) edefs) + idx;
if (vstart + sizeof (*edef) > endbuf)
break;
printf (_(" Index: %d Cnt: %d "),
ent.vd_ndx, ent.vd_cnt);
+ /* Check for overflow. */
+ if ((unsigned char *)(vstart + ent.vd_aux) < (unsigned char *) vstart
+ || (unsigned char *)(vstart + ent.vd_aux) > (unsigned char *) endbuf)
+ break;
+
vstart += ent.vd_aux;
eaux = (Elf_External_Verdaux *) vstart;
for (j = 1; j < ent.vd_cnt; j++)
{
- isum += aux.vda_next;
+ /* Check for overflow. */
+ if ((unsigned char *)(vstart + aux.vda_next) < (unsigned char *) vstart
+ || (unsigned char *)(vstart + aux.vda_next) > (unsigned char *) endbuf)
+ break;
+
+ isum += aux.vda_next;
vstart += aux.vda_next;
eaux = (Elf_External_Verdaux *) vstart;
printf (_(" %#06x: Parent %d, name index: %ld\n"),
isum, j, aux.vda_name);
}
+
if (j < ent.vd_cnt)
printf (_(" Version def aux past end of section\n"));
idx += ent.vd_next;
}
+
if (cnt < section->sh_info)
printf (_(" Version definition past end of section\n"));
(unsigned long) section->sh_offset, section->sh_link,
section->sh_link < elf_header.e_shnum
? SECTION_NAME (section_headers + section->sh_link)
- : "<corrupt>");
+ : _("<corrupt>"));
eneed = (Elf_External_Verneed *) get_data (NULL, file,
section->sh_offset, 1,
int isum;
char * vstart;
+ if ((unsigned char *) eneed + idx < (unsigned char *) eneed)
+ break;
+
vstart = ((char *) eneed) + idx;
if (vstart + sizeof (*entry) > endbuf)
break;
printf (_(" Cnt: %d\n"), ent.vn_cnt);
+ /* Check for overflow. */
+ if ((unsigned char *)(vstart + ent.vn_aux) < (unsigned char *) vstart
+ || (unsigned char *)(vstart + ent.vn_aux) > (unsigned char *) endbuf)
+ break;
+
vstart += ent.vn_aux;
for (j = 0, isum = idx + ent.vn_aux; j < ent.vn_cnt; ++j)
printf (_(" Flags: %s Version: %d\n"),
get_ver_flags (aux.vna_flags), aux.vna_other);
+ /* Check for overflow. */
+ if ((unsigned char *)(vstart + aux.vna_next) < (unsigned char *) vstart
+ || (unsigned char *)(vstart + aux.vna_next) > (unsigned char *) endbuf)
+ break;
+
isum += aux.vna_next;
vstart += aux.vna_next;
}
found = 1;
symbols = GET_ELF_SYMBOLS (file, link_section);
+ if (symbols == NULL)
+ break;
string_sec = section_headers + link_section->sh_link;
nn = printf ("%4x%c", data[cnt + j] & VERSYM_VERSION,
data[cnt + j] & VERSYM_HIDDEN ? 'h' : ' ');
+ /* If this index value is greater than the size of the symbols
+ array, break to avoid an out-of-bounds read, */
+ if ((unsigned long)(cnt + j) >=
+ ((unsigned long)link_section->sh_size /
+ (unsigned long)link_section->sh_entsize))
+ {
+ warn (_("invalid index into symbol array\n"));
+ break;
+ }
+
check_def = 1;
check_need = 1;
if (symbols[cnt + j].st_shndx >= elf_header.e_shnum
}
}
+static const char *
+get_ia64_symbol_other (unsigned int other)
+{
+ if (is_ia64_vms ())
+ {
+ static char res[32];
+
+ res[0] = 0;
+
+ /* Function types is for images and .STB files only. */
+ switch (elf_header.e_type)
+ {
+ case ET_DYN:
+ case ET_EXEC:
+ switch (VMS_ST_FUNC_TYPE (other))
+ {
+ case VMS_SFT_CODE_ADDR:
+ strcat (res, " CA");
+ break;
+ case VMS_SFT_SYMV_IDX:
+ strcat (res, " VEC");
+ break;
+ case VMS_SFT_FD:
+ strcat (res, " FD");
+ break;
+ case VMS_SFT_RESERVE:
+ strcat (res, " RSV");
+ break;
+ default:
+ abort ();
+ }
+ break;
+ default:
+ break;
+ }
+ switch (VMS_ST_LINKAGE (other))
+ {
+ case VMS_STL_IGNORE:
+ strcat (res, " IGN");
+ break;
+ case VMS_STL_RESERVE:
+ strcat (res, " RSV");
+ break;
+ case VMS_STL_STD:
+ strcat (res, " STD");
+ break;
+ case VMS_STL_LNK:
+ strcat (res, " LNK");
+ break;
+ default:
+ abort ();
+ }
+
+ if (res[0] != 0)
+ return res + 1;
+ else
+ return res;
+ }
+ return NULL;
+}
+
static const char *
get_symbol_other (unsigned int other)
{
{
case EM_MIPS:
result = get_mips_symbol_other (other);
+ break;
+ case EM_IA_64:
+ result = get_ia64_symbol_other (other);
+ break;
default:
break;
}
if (VALID_DYNAMIC_NAME (psym->st_name))
print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
else
- printf (" <corrupt: %14ld>", psym->st_name);
+ printf (_(" <corrupt: %14ld>"), psym->st_name);
putchar ('\n');
}
&& section->sh_type == SHT_SYMTAB))
continue;
+ if (section->sh_entsize == 0)
+ {
+ printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
+ SECTION_NAME (section));
+ continue;
+ }
+
printf (_("\nSymbol table '%s' contains %lu entries:\n"),
SECTION_NAME (section),
(unsigned long) (section->sh_size / section->sh_entsize));
+
if (is_32bit_elf)
printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
else
printf (" [%s] ", get_symbol_other (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other)));
printf (" %4s ", get_symbol_index_type (psym->st_shndx));
print_symbol (25, psym->st_name < strtab_size
- ? strtab + psym->st_name : "<corrupt>");
+ ? strtab + psym->st_name : _("<corrupt>"));
if (section->sh_type == SHT_DYNSYM &&
version_info[DT_VERSIONTAGIDX (DT_VERSYM)] != 0)
{
printf ("@%s (%d)",
ivna.vna_name < strtab_size
- ? strtab + ivna.vna_name : "<corrupt>",
+ ? strtab + ivna.vna_name : _("<corrupt>"),
ivna.vna_other);
check_def = 0;
}
printf ((vers_data & VERSYM_HIDDEN)
? "@%s" : "@@%s",
ivda.vda_name < strtab_size
- ? strtab + ivda.vda_name : "<corrupt>");
+ ? strtab + ivda.vda_name : _("<corrupt>"));
}
}
}
if (VALID_DYNAMIC_NAME (dynamic_symbols[i].st_name))
print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols[i].st_name));
else
- printf ("<corrupt: %19ld>", dynamic_symbols[i].st_name);
+ printf (_("<corrupt: %19ld>"), dynamic_symbols[i].st_name);
putchar (' ');
switch (dynamic_syminfo[i].si_boundto)
return reloc_type == 1; /* R_68K_32. */
case EM_860:
return reloc_type == 1; /* R_860_32. */
+ case EM_960:
+ return reloc_type == 2; /* R_960_32. */
case EM_ALPHA:
- return reloc_type == 1; /* XXX Is this right ? */
+ return reloc_type == 1; /* R_ALPHA_REFLONG. */
case EM_ARC:
return reloc_type == 1; /* R_ARC_32. */
case EM_ARM:
return reloc_type == 1; /* R_MCORE_ADDR32. */
case EM_CYGNUS_MEP:
return reloc_type == 4; /* R_MEP_32. */
+ case EM_MICROBLAZE:
+ return reloc_type == 1; /* R_MICROBLAZE_32. */
case EM_MIPS:
return reloc_type == 2; /* R_MIPS_32. */
case EM_MMIX:
case EM_CYGNUS_MN10300:
case EM_MN10300:
return reloc_type == 1; /* R_MN10300_32. */
+ case EM_MOXIE:
+ return reloc_type == 1; /* R_MOXIE_32. */
case EM_MSP430_OLD:
case EM_MSP430:
return reloc_type == 1; /* R_MSP43_32. */
|| reloc_type == 23; /* R_SPARC_UA32. */
case EM_SPU:
return reloc_type == 6; /* R_SPU_ADDR32 */
+ case EM_TI_C6000:
+ return reloc_type == 1; /* R_C6000_ABS32. */
case EM_CYGNUS_V850:
case EM_V850:
return reloc_type == 6; /* R_V850_ABS32. */
return reloc_type == 10; /* R_ALPHA_SREL32. */
case EM_ARM:
return reloc_type == 3; /* R_ARM_REL32 */
+ case EM_MICROBLAZE:
+ return reloc_type == 2; /* R_MICROBLAZE_32_PCREL. */
case EM_PARISC:
return reloc_type == 9; /* R_PARISC_PCREL32. */
case EM_PPC:
case EM_ALTERA_NIOS2:
case EM_NIOS32:
return reloc_type == 9; /* R_NIOS_16. */
+ case EM_TI_C6000:
+ return reloc_type == 2; /* R_C6000_ABS16. */
case EM_XC16X:
case EM_C166:
return reloc_type == 2; /* R_XC16C_ABS_16. */
case EM_X86_64: /* R_X86_64_NONE. */
case EM_L1OM: /* R_X86_64_NONE. */
case EM_MN10300: /* R_MN10300_NONE. */
+ case EM_MOXIE: /* R_MOXIE_NONE. */
case EM_M32R: /* R_M32R_NONE. */
+ case EM_TI_C6000:/* R_C6000_NONE. */
case EM_XC16X:
case EM_C166: /* R_XC16X_NONE. */
return reloc_type == 0;
addend = 0;
if (is_rela)
addend += rp->r_addend;
- /* R_XTENSA_32 and R_PJ_DATA_DIR32 are partial_inplace. */
+ /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
+ partial_inplace. */
if (!is_rela
|| (elf_header.e_machine == EM_XTENSA
&& reloc_type == 1)
|| ((elf_header.e_machine == EM_PJ
|| elf_header.e_machine == EM_PJ_OLD)
- && reloc_type == 1))
+ && reloc_type == 1)
+ || ((elf_header.e_machine == EM_D30V
+ || elf_header.e_machine == EM_CYGNUS_D30V)
+ && reloc_type == 12))
addend += byte_get (rloc, reloc_size);
if (is_32bit_pcrel_reloc (reloc_type)
_("section contents"));
}
-
+
static void
dump_section_as_strings (Elf_Internal_Shdr * section, FILE * file)
{
Elf_Internal_Shdr * relsec;
bfd_size_type num_bytes;
- bfd_vma addr;
char * data;
char * end;
char * start;
}
num_bytes = section->sh_size;
- addr = section->sh_addr;
data = start;
end = start + num_bytes;
some_strings_shown = FALSE;
putchar ('\n');
}
-/* Uncompresses a section that was compressed using zlib, in place.
- This is a copy of bfd_uncompress_section_contents, in bfd/compress.c */
+/* Uncompresses a section that was compressed using zlib, in place. */
static int
-uncompress_section_contents (unsigned char ** buffer, dwarf_size_type * size)
+uncompress_section_contents (unsigned char **buffer ATTRIBUTE_UNUSED,
+ dwarf_size_type *size ATTRIBUTE_UNUSED)
{
#ifndef HAVE_ZLIB_H
- /* These are just to quiet gcc. */
- buffer = 0;
- size = 0;
return FALSE;
#else
dwarf_size_type compressed_size = *size;
fail:
free (uncompressed_buffer);
+ /* Indicate decompression failure. */
+ *buffer = NULL;
return 0;
#endif /* HAVE_ZLIB_H */
}
{
struct dwarf_section * section = &debug_displays [debug].section;
char buf [64];
- int section_is_compressed;
/* If it is already loaded, do nothing. */
if (section->start != NULL)
return 1;
- section_is_compressed = section->name == section->compressed_name;
-
snprintf (buf, sizeof (buf), _("%s section data"), section->name);
section->address = sec->sh_addr;
section->size = sec->sh_size;
section->start = (unsigned char *) get_data (NULL, (FILE *) file,
sec->sh_offset, 1,
sec->sh_size, buf);
+ if (uncompress_section_contents (§ion->start, §ion->size))
+ sec->sh_size = section->size;
+
if (section->start == NULL)
return 0;
- if (section_is_compressed)
- if (! uncompress_section_contents (§ion->start, §ion->size))
- return 0;
-
if (debug_displays [debug].relocate)
apply_relocations ((FILE *) file, sec, section->start);
static const char * arm_attr_tag_ARM_ISA_use[] = {"No", "Yes"};
static const char * arm_attr_tag_THUMB_ISA_use[] =
{"No", "Thumb-1", "Thumb-2"};
-static const char * arm_attr_tag_VFP_arch[] =
+static const char * arm_attr_tag_FP_arch[] =
{"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16"};
static const char * arm_attr_tag_WMMX_arch[] = {"No", "WMMXv1", "WMMXv2"};
-static const char * arm_attr_tag_Advanced_SIMD_arch[] =
+static const char * arm_attr_tag_Advanced_SIMD_arch[] =
{"No", "NEONv1", "NEONv1 with Fused-MAC"};
static const char * arm_attr_tag_PCS_config[] =
{"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
static const char * arm_attr_tag_ABI_FP_user_exceptions[] = {"Unused", "Needed"};
static const char * arm_attr_tag_ABI_FP_number_model[] =
{"Unused", "Finite", "RTABI", "IEEE 754"};
-static const char * arm_attr_tag_ABI_align8_needed[] = {"No", "Yes", "4-byte"};
-static const char * arm_attr_tag_ABI_align8_preserved[] =
- {"No", "Yes, except leaf SP", "Yes"};
static const char * arm_attr_tag_ABI_enum_size[] =
{"Unused", "small", "int", "forced to int"};
static const char * arm_attr_tag_ABI_HardFP_use[] =
- {"As Tag_VFP_arch", "SP only", "DP only", "SP and DP"};
+ {"As Tag_FP_arch", "SP only", "DP only", "SP and DP"};
static const char * arm_attr_tag_ABI_VFP_args[] =
{"AAPCS", "VFP registers", "custom"};
static const char * arm_attr_tag_ABI_WMMX_args[] =
{"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
"Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
static const char * arm_attr_tag_CPU_unaligned_access[] = {"None", "v6"};
-static const char * arm_attr_tag_VFP_HP_extension[] =
+static const char * arm_attr_tag_FP_HP_extension[] =
{"Not Allowed", "Allowed"};
static const char * arm_attr_tag_ABI_FP_16bit_format[] =
{"None", "IEEE 754", "Alternative Format"};
-static const char * arm_attr_tag_MPextension_use[] =
+static const char * arm_attr_tag_MPextension_use[] =
{"Not Allowed", "Allowed"};
static const char * arm_attr_tag_DIV_use[] =
- {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
+ {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
"Allowed in v7-A with integer division extension"};
static const char * arm_attr_tag_T2EE_use[] = {"Not Allowed", "Allowed"};
static const char * arm_attr_tag_Virtualization_use[] =
- {"Not Allowed", "TrustZone", "Virtualization Extensions",
+ {"Not Allowed", "TrustZone", "Virtualization Extensions",
"TrustZone and Virtualization Extensions"};
-static const char * arm_attr_tag_MPextension_use_legacy[] =
+static const char * arm_attr_tag_MPextension_use_legacy[] =
{"Not Allowed", "Allowed"};
#define LOOKUP(id, name) \
{7, "CPU_arch_profile", 0, NULL},
LOOKUP(8, ARM_ISA_use),
LOOKUP(9, THUMB_ISA_use),
- LOOKUP(10, VFP_arch),
+ LOOKUP(10, FP_arch),
LOOKUP(11, WMMX_arch),
LOOKUP(12, Advanced_SIMD_arch),
LOOKUP(13, PCS_config),
LOOKUP(21, ABI_FP_exceptions),
LOOKUP(22, ABI_FP_user_exceptions),
LOOKUP(23, ABI_FP_number_model),
- LOOKUP(24, ABI_align8_needed),
- LOOKUP(25, ABI_align8_preserved),
+ {24, "ABI_align_needed", 0, NULL},
+ {25, "ABI_align_preserved", 0, NULL},
LOOKUP(26, ABI_enum_size),
LOOKUP(27, ABI_HardFP_use),
LOOKUP(28, ABI_VFP_args),
LOOKUP(31, ABI_FP_optimization_goals),
{32, "compatibility", 0, NULL},
LOOKUP(34, CPU_unaligned_access),
- LOOKUP(36, VFP_HP_extension),
+ LOOKUP(36, FP_HP_extension),
LOOKUP(38, ABI_FP_16bit_format),
LOOKUP(42, MPextension_use),
LOOKUP(44, DIV_use),
p += len;
switch (val)
{
- case 0: printf ("None\n"); break;
- case 'A': printf ("Application\n"); break;
- case 'R': printf ("Realtime\n"); break;
- case 'M': printf ("Microcontroller\n"); break;
+ case 0: printf (_("None\n")); break;
+ case 'A': printf (_("Application\n")); break;
+ case 'R': printf (_("Realtime\n")); break;
+ case 'M': printf (_("Microcontroller\n")); break;
+ case 'S': printf (_("Application or Realtime\n")); break;
default: printf ("??? (%d)\n", val); break;
}
break;
+ case 24: /* Tag_align_needed. */
+ val = read_uleb128 (p, &len);
+ p += len;
+ switch (val)
+ {
+ case 0: printf (_("None\n")); break;
+ case 1: printf (_("8-byte\n")); break;
+ case 2: printf (_("4-byte\n")); break;
+ case 3: printf ("??? 3\n"); break;
+ default:
+ if (val <= 12)
+ printf (_("8-byte and up to %d-byte extended\n"),
+ 1 << val);
+ else
+ printf ("??? (%d)\n", val);
+ break;
+ }
+ break;
+
+ case 25: /* Tag_align_preserved. */
+ val = read_uleb128 (p, &len);
+ p += len;
+ switch (val)
+ {
+ case 0: printf (_("None\n")); break;
+ case 1: printf (_("8-byte, except leaf SP\n")); break;
+ case 2: printf (_("8-byte\n")); break;
+ case 3: printf ("??? 3\n"); break;
+ default:
+ if (val <= 12)
+ printf (_("8-byte and up to %d-byte extended\n"),
+ 1 << val);
+ else
+ printf ("??? (%d)\n", val);
+ break;
+ }
+ break;
+
case 32: /* Tag_compatibility. */
val = read_uleb128 (p, &len);
p += len;
- printf ("flag = %d, vendor = %s\n", val, p);
+ printf (_("flag = %d, vendor = %s\n"), val, p);
p += strlen ((char *) p) + 1;
break;
case 64: /* Tag_nodefaults. */
p++;
- printf ("True\n");
+ printf (_("True\n"));
break;
case 65: /* Tag_also_compatible_with. */
{
val = read_uleb128 (p, &len);
p += len;
- printf ("flag = %d, vendor = %s\n", val, p);
+ printf (_("flag = %d, vendor = %s\n"), val, p);
p += strlen ((char *) p) + 1;
return p;
}
switch (val)
{
case 0:
- printf ("Hard or soft float\n");
+ printf (_("Hard or soft float\n"));
break;
case 1:
- printf ("Hard float\n");
+ printf (_("Hard float\n"));
break;
case 2:
- printf ("Soft float\n");
+ printf (_("Soft float\n"));
break;
case 3:
- printf ("Single-precision hard float\n");
+ printf (_("Single-precision hard float\n"));
break;
default:
printf ("??? (%d)\n", val);
switch (val)
{
case 0:
- printf ("Any\n");
+ printf (_("Any\n"));
break;
case 1:
- printf ("Generic\n");
+ printf (_("Generic\n"));
break;
case 2:
printf ("AltiVec\n");
switch (val)
{
case 0:
- printf ("Any\n");
+ printf (_("Any\n"));
break;
case 1:
printf ("r3/r4\n");
break;
case 2:
- printf ("Memory\n");
+ printf (_("Memory\n"));
break;
default:
printf ("??? (%d)\n", val);
switch (val)
{
case 0:
- printf ("Hard or soft float\n");
+ printf (_("Hard or soft float\n"));
break;
case 1:
- printf ("Hard float (-mdouble-float)\n");
+ printf (_("Hard float (double precision)\n"));
break;
case 2:
- printf ("Hard float (-msingle-float)\n");
+ printf (_("Hard float (single precision)\n"));
break;
case 3:
- printf ("Soft float\n");
+ printf (_("Soft float\n"));
break;
case 4:
- printf ("64-bit float (-mips32r2 -mfp64)\n");
+ printf (_("Hard float (MIPS32r2 64-bit FPU)\n"));
break;
default:
printf ("??? (%d)\n", val);
return p;
}
+static unsigned char *
+display_tic6x_attribute (unsigned char * p)
+{
+ int tag;
+ unsigned int len;
+ int val;
+
+ tag = read_uleb128 (p, &len);
+ p += len;
+
+ switch (tag)
+ {
+ case Tag_ISA:
+ val = read_uleb128 (p, &len);
+ p += len;
+ printf (" Tag_ISA: ");
+
+ switch (val)
+ {
+ case C6XABI_Tag_ISA_none:
+ printf (_("None\n"));
+ break;
+ case C6XABI_Tag_ISA_C62X:
+ printf ("C62x\n");
+ break;
+ case C6XABI_Tag_ISA_C67X:
+ printf ("C67x\n");
+ break;
+ case C6XABI_Tag_ISA_C67XP:
+ printf ("C67x+\n");
+ break;
+ case C6XABI_Tag_ISA_C64X:
+ printf ("C64x\n");
+ break;
+ case C6XABI_Tag_ISA_C64XP:
+ printf ("C64x+\n");
+ break;
+ case C6XABI_Tag_ISA_C674X:
+ printf ("C674x\n");
+ break;
+ default:
+ printf ("??? (%d)\n", val);
+ break;
+ }
+ return p;
+
+ case Tag_ABI_wchar_t:
+ val = read_uleb128 (p, &len);
+ p += len;
+ printf (" Tag_ABI_wchar_t: ");
+ switch (val)
+ {
+ case 0:
+ printf (_("Not used\n"));
+ break;
+ case 1:
+ printf (_("2 bytes\n"));
+ break;
+ case 2:
+ printf (_("4 bytes\n"));
+ break;
+ default:
+ printf ("??? (%d)\n", val);
+ break;
+ }
+ return p;
+
+ case Tag_ABI_stack_align_needed:
+ val = read_uleb128 (p, &len);
+ p += len;
+ printf (" Tag_ABI_stack_align_needed: ");
+ switch (val)
+ {
+ case 0:
+ printf (_("8-byte\n"));
+ break;
+ case 1:
+ printf (_("16-byte\n"));
+ break;
+ default:
+ printf ("??? (%d)\n", val);
+ break;
+ }
+ return p;
+
+ case Tag_ABI_stack_align_preserved:
+ val = read_uleb128 (p, &len);
+ p += len;
+ printf (" Tag_ABI_stack_align_preserved: ");
+ switch (val)
+ {
+ case 0:
+ printf (_("8-byte\n"));
+ break;
+ case 1:
+ printf (_("16-byte\n"));
+ break;
+ default:
+ printf ("??? (%d)\n", val);
+ break;
+ }
+ return p;
+
+ case Tag_ABI_DSBT:
+ val = read_uleb128 (p, &len);
+ p += len;
+ printf (" Tag_ABI_DSBT: ");
+ switch (val)
+ {
+ case 0:
+ printf (_("DSBT addressing not used\n"));
+ break;
+ case 1:
+ printf (_("DSBT addressing used\n"));
+ break;
+ default:
+ printf ("??? (%d)\n", val);
+ break;
+ }
+ return p;
+
+ case Tag_ABI_PID:
+ val = read_uleb128 (p, &len);
+ p += len;
+ printf (" Tag_ABI_PID: ");
+ switch (val)
+ {
+ case 0:
+ printf (_("Data addressing position-dependent\n"));
+ break;
+ case 1:
+ printf (_("Data addressing position-independent, GOT near DP\n"));
+ break;
+ case 2:
+ printf (_("Data addressing position-independent, GOT far from DP\n"));
+ break;
+ default:
+ printf ("??? (%d)\n", val);
+ break;
+ }
+ return p;
+
+ case Tag_ABI_PIC:
+ val = read_uleb128 (p, &len);
+ p += len;
+ printf (" Tag_ABI_PIC: ");
+ switch (val)
+ {
+ case 0:
+ printf (_("Code addressing position-dependent\n"));
+ break;
+ case 1:
+ printf (_("Code addressing position-independent\n"));
+ break;
+ default:
+ printf ("??? (%d)\n", val);
+ break;
+ }
+ return p;
+
+ case Tag_ABI_array_object_alignment:
+ val = read_uleb128 (p, &len);
+ p += len;
+ printf (" Tag_ABI_array_object_alignment: ");
+ switch (val)
+ {
+ case 0:
+ printf (_("8-byte\n"));
+ break;
+ case 1:
+ printf (_("4-byte\n"));
+ break;
+ case 2:
+ printf (_("16-byte\n"));
+ break;
+ default:
+ printf ("??? (%d)\n", val);
+ break;
+ }
+ return p;
+
+ case Tag_ABI_array_object_align_expected:
+ val = read_uleb128 (p, &len);
+ p += len;
+ printf (" Tag_ABI_array_object_align_expected: ");
+ switch (val)
+ {
+ case 0:
+ printf (_("8-byte\n"));
+ break;
+ case 1:
+ printf (_("4-byte\n"));
+ break;
+ case 2:
+ printf (_("16-byte\n"));
+ break;
+ default:
+ printf ("??? (%d)\n", val);
+ break;
+ }
+ return p;
+
+ case Tag_ABI_compatibility:
+ val = read_uleb128 (p, &len);
+ p += len;
+ printf (" Tag_ABI_compatibility: ");
+ printf (_("flag = %d, vendor = %s\n"), val, p);
+ p += strlen ((char *) p) + 1;
+ return p;
+
+ case Tag_ABI_conformance:
+ printf (" Tag_ABI_conformance: ");
+ printf ("\"%s\"\n", p);
+ p += strlen ((char *) p) + 1;
+ return p;
+ }
+
+ printf (" Tag_unknown_%d: ", tag);
+
+ if (tag & 1)
+ {
+ printf ("\"%s\"\n", p);
+ p += strlen ((char *) p) + 1;
+ }
+ else
+ {
+ val = read_uleb128 (p, &len);
+ p += len;
+ printf ("%d (0x%x)\n", val, val);
+ }
+
+ return p;
+}
+
static int
process_attributes (FILE * file,
const char * public_name,
}
len -= section_len;
- printf ("Attribute Section: %s\n", p);
+ printf (_("Attribute Section: %s\n"), p);
if (public_name && streq ((char *) p, public_name))
public_section = TRUE;
switch (tag)
{
case 1:
- printf ("File Attributes\n");
+ printf (_("File Attributes\n"));
break;
case 2:
- printf ("Section Attributes:");
+ printf (_("Section Attributes:"));
goto do_numlist;
case 3:
- printf ("Symbol Attributes:");
+ printf (_("Symbol Attributes:"));
do_numlist:
for (;;)
{
printf ("\n");
break;
default:
- printf ("Unknown tag: %d\n", tag);
+ printf (_("Unknown tag: %d\n"), tag);
public_section = FALSE;
break;
}
else
{
/* ??? Do something sensible, like dump hex. */
- printf (" Unknown section contexts\n");
+ printf (_(" Unknown section contexts\n"));
p = end;
}
}
display_power_gnu_attribute);
}
+static int
+process_tic6x_specific (FILE * file)
+{
+ return process_attributes (file, "c6xabi", SHT_C6000_ATTRIBUTES,
+ display_tic6x_attribute, NULL);
+}
+
/* 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. */
printf ("%10s", "");
printf (" ");
if (data == NULL)
- printf ("%*s", is_32bit_elf ? 8 : 16, "<unknown>");
+ printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
else
{
bfd_vma entry;
print_vma (addr, LONG_HEX);
printf (" ");
if (data == NULL)
- printf ("%*s", is_32bit_elf ? 8 : 16, "<unknown>");
+ printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
else
{
bfd_vma entry;
_("liblist"));
if (elib)
{
- printf ("\nSection '.liblist' contains %lu entries:\n",
+ printf (_("\nSection '.liblist' contains %lu entries:\n"),
(unsigned long) liblistno);
- fputs (" Library Time Stamp Checksum Version Flags\n",
+ fputs (_(" Library Time Stamp Checksum Version Flags\n"),
stdout);
for (cnt = 0; cnt < liblistno; ++cnt)
if (VALID_DYNAMIC_NAME (liblist.l_name))
print_symbol (20, GET_DYNAMIC_NAME (liblist.l_name));
else
- printf ("<corrupt: %9ld>", liblist.l_name);
+ printf (_("<corrupt: %9ld>"), liblist.l_name);
printf (" %s %#10lx %-7ld", timebuf, liblist.l_checksum,
liblist.l_version);
if (liblist.l_flags == 0)
- puts (" NONE");
+ puts (_(" NONE"));
else
{
static const struct
if (VALID_DYNAMIC_NAME (psym->st_name))
print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
else
- printf ("<corrupt: %14ld>", psym->st_name);
+ printf (_("<corrupt: %14ld>"), psym->st_name);
putchar ('\n');
}
printf (_(" Reserved entries:\n"));
printf (_(" %*s %10s %*s Purpose\n"),
- addr_size * 2, "Address", "Access",
- addr_size * 2, "Initial");
+ addr_size * 2, _("Address"), _("Access"),
+ addr_size * 2, _("Initial"));
ent = print_mips_got_entry (data, pltgot, ent);
- printf (" Lazy resolver\n");
+ printf (_(" Lazy resolver\n"));
if (data
&& (byte_get (data + ent - pltgot, addr_size)
>> (addr_size * 8 - 1)) != 0)
{
ent = print_mips_got_entry (data, pltgot, ent);
- printf (" Module pointer (GNU extension)\n");
+ printf (_(" Module pointer (GNU extension)\n"));
}
printf ("\n");
if (ent < local_end)
{
printf (_(" Local entries:\n"));
- printf (_(" %*s %10s %*s\n"),
- addr_size * 2, "Address", "Access",
- addr_size * 2, "Initial");
+ printf (" %*s %10s %*s\n",
+ addr_size * 2, _("Address"), _("Access"),
+ addr_size * 2, _("Initial"));
while (ent < local_end)
{
ent = print_mips_got_entry (data, pltgot, ent);
int sym_width;
printf (_(" Global entries:\n"));
- printf (_(" %*s %10s %*s %*s %-7s %3s %s\n"),
- addr_size * 2, "Address", "Access",
- addr_size * 2, "Initial",
- addr_size * 2, "Sym.Val.", "Type", "Ndx", "Name");
+ printf (" %*s %10s %*s %*s %-7s %3s %s\n",
+ addr_size * 2, _("Address"), _("Access"),
+ addr_size * 2, _("Initial"),
+ addr_size * 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
sym_width = (is_32bit_elf ? 80 : 160) - 28 - addr_size * 6 - 1;
for (i = gotsym; i < symtabno; i++)
{
if (VALID_DYNAMIC_NAME (psym->st_name))
print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
else
- printf ("<corrupt: %14ld>", psym->st_name);
+ printf (_("<corrupt: %14ld>"), psym->st_name);
printf ("\n");
}
printf ("\n");
printf (_("\nPLT GOT:\n\n"));
printf (_(" Reserved entries:\n"));
printf (_(" %*s %*s Purpose\n"),
- addr_size * 2, "Address", addr_size * 2, "Initial");
+ addr_size * 2, _("Address"), addr_size * 2, _("Initial"));
ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
- printf (" PLT lazy resolver\n");
+ printf (_(" PLT lazy resolver\n"));
ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
- printf (" Module pointer\n");
+ printf (_(" Module pointer\n"));
printf ("\n");
printf (_(" Entries:\n"));
- printf (_(" %*s %*s %*s %-7s %3s %s\n"),
- addr_size * 2, "Address",
- addr_size * 2, "Initial",
- addr_size * 2, "Sym.Val.", "Type", "Ndx", "Name");
+ printf (" %*s %*s %*s %-7s %3s %s\n",
+ addr_size * 2, _("Address"),
+ addr_size * 2, _("Initial"),
+ addr_size * 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
sym_width = (is_32bit_elf ? 80 : 160) - 17 - addr_size * 6 - 1;
for (i = 0; i < count; i++)
{
if (VALID_DYNAMIC_NAME (psym->st_name))
print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
else
- printf ("<corrupt: %14ld>", psym->st_name);
+ printf (_("<corrupt: %14ld>"), psym->st_name);
printf ("\n");
}
printf ("\n");
SECTION_NAME (section),
(unsigned long) (section->sh_size / sizeof (Elf32_External_Lib)));
- puts (" Library Time Stamp Checksum Version Flags");
+ puts (_(" Library Time Stamp Checksum Version Flags"));
for (cnt = 0; cnt < section->sh_size / sizeof (Elf32_External_Lib);
++cnt)
printf ("%3lu: ", (unsigned long) cnt);
if (do_wide)
printf ("%-20s", liblist.l_name < strtab_size
- ? strtab + liblist.l_name : "<corrupt>");
+ ? strtab + liblist.l_name : _("<corrupt>"));
else
printf ("%-20.20s", liblist.l_name < strtab_size
- ? strtab + liblist.l_name : "<corrupt>");
+ ? strtab + liblist.l_name : _("<corrupt>"));
printf (" %s %#010lx %-7ld %-7ld\n", timebuf, liblist.l_checksum,
liblist.l_version, liblist.l_flags);
}
case EM_SPARCV9:
switch (e_type)
{
- case NT_NETBSDCORE_FIRSTMACH+0:
+ case NT_NETBSDCORE_FIRSTMACH + 0:
return _("PT_GETREGS (reg structure)");
- case NT_NETBSDCORE_FIRSTMACH+2:
+ case NT_NETBSDCORE_FIRSTMACH + 2:
return _("PT_GETFPREGS (fpreg structure)");
default:
break;
default:
switch (e_type)
{
- case NT_NETBSDCORE_FIRSTMACH+1:
+ case NT_NETBSDCORE_FIRSTMACH + 1:
return _("PT_GETREGS (reg structure)");
- case NT_NETBSDCORE_FIRSTMACH+3:
+ case NT_NETBSDCORE_FIRSTMACH + 3:
return _("PT_GETFPREGS (fpreg structure)");
default:
break;
pnotes = (Elf_External_Note *) get_data (NULL, file, offset, 1, length,
_("notes"));
- if (!pnotes)
+ if (pnotes == NULL)
return 0;
external = pnotes;
next = (Elf_External_Note *) (inote.descdata + align_power (inote.descsz, 2));
- if (((char *) next) > (((char *) pnotes) + length))
+ if ( ((char *) next > ((char *) pnotes) + length)
+ || ((char *) next < (char *) pnotes))
{
warn (_("corrupt note found at offset %lx into core notes\n"),
(unsigned long) ((char *) external - (char *) pnotes));
external = next;
+ /* Prevent out-of-bounds indexing. */
+ if (inote.namedata + inote.namesz >= (char *) pnotes + length
+ || inote.namedata + inote.namesz < inote.namedata)
+ {
+ warn (_("corrupt note found at offset %lx into core notes\n"),
+ (unsigned long) ((char *) external - (char *) pnotes));
+ warn (_(" type: %lx, namesize: %08lx, descsize: %08lx\n"),
+ inote.type, inote.namesz, inote.descsz);
+ break;
+ }
+
/* Verify that name is null terminated. It appears that at least
one version of Linux (RedHat 6.0) generates corefiles that don't
comply with the ELF spec by failing to include the null byte in
case EM_PPC:
return process_power_specific (file);
break;
+ case EM_TI_C6000:
+ return process_tic6x_specific (file);
+ break;
default:
break;
}
dynamic_syminfo = NULL;
}
+ if (dynamic_section)
+ {
+ free (dynamic_section);
+ dynamic_section = NULL;
+ }
+
if (section_headers_groups)
{
free (section_headers_groups);
return 0;
}
-/* Return the path name for a proxy entry in a thin archive, adjusted relative
- to the path name of the thin archive itself if necessary. Always returns
- a pointer to malloc'ed memory. */
-
-static char *
-adjust_relative_path (char * file_name, char * name, int name_len)
-{
- char * member_file_name;
- const char * base_name = lbasename (file_name);
-
- /* This is a proxy entry for a thin archive member.
- If the extended name table contains an absolute path
- name, or if the archive is in the current directory,
- use the path name as given. Otherwise, we need to
- find the member relative to the directory where the
- archive is located. */
- if (IS_ABSOLUTE_PATH (name) || base_name == file_name)
- {
- member_file_name = (char *) malloc (name_len + 1);
- if (member_file_name == NULL)
- {
- error (_("Out of memory\n"));
- return NULL;
- }
- memcpy (member_file_name, name, name_len);
- member_file_name[name_len] = '\0';
- }
- else
- {
- /* Concatenate the path components of the archive file name
- to the relative path name from the extended name table. */
- size_t prefix_len = base_name - file_name;
- member_file_name = (char *) malloc (prefix_len + name_len + 1);
- if (member_file_name == NULL)
- {
- error (_("Out of memory\n"));
- return NULL;
- }
- memcpy (member_file_name, file_name, prefix_len);
- memcpy (member_file_name + prefix_len, name, name_len);
- member_file_name[prefix_len + name_len] = '\0';
- }
- return member_file_name;
-}
-
-/* Structure to hold information about an archive file. */
-
-struct archive_info
-{
- char * file_name; /* Archive file name. */
- FILE * file; /* Open file descriptor. */
- unsigned long index_num; /* Number of symbols in table. */
- unsigned long * index_array; /* The array of member offsets. */
- char * sym_table; /* The symbol table. */
- unsigned long sym_size; /* Size of the symbol table. */
- char * longnames; /* The long file names table. */
- unsigned long longnames_size; /* Size of the long file names table. */
- unsigned long nested_member_origin; /* Origin in the nested archive of the current member. */
- unsigned long next_arhdr_offset; /* Offset of the next archive header. */
- bfd_boolean is_thin_archive; /* TRUE if this is a thin archive. */
- struct ar_hdr arhdr; /* Current archive header. */
-};
-
-/* Read the symbol table and long-name table from an archive. */
-
-static int
-setup_archive (struct archive_info * arch, char * file_name, FILE * file,
- bfd_boolean is_thin_archive, bfd_boolean read_symbols)
-{
- size_t got;
- unsigned long size;
-
- arch->file_name = strdup (file_name);
- arch->file = file;
- arch->index_num = 0;
- arch->index_array = NULL;
- arch->sym_table = NULL;
- arch->sym_size = 0;
- arch->longnames = NULL;
- arch->longnames_size = 0;
- arch->nested_member_origin = 0;
- arch->is_thin_archive = is_thin_archive;
- arch->next_arhdr_offset = SARMAG;
-
- /* Read the first archive member header. */
- if (fseek (file, SARMAG, SEEK_SET) != 0)
- {
- error (_("%s: failed to seek to first archive header\n"), file_name);
- return 1;
- }
- got = fread (&arch->arhdr, 1, sizeof arch->arhdr, file);
- if (got != sizeof arch->arhdr)
- {
- if (got == 0)
- return 0;
-
- error (_("%s: failed to read archive header\n"), file_name);
- return 1;
- }
-
- /* See if this is the archive symbol table. */
- if (const_strneq (arch->arhdr.ar_name, "/ ")
- || const_strneq (arch->arhdr.ar_name, "/SYM64/ "))
- {
- size = strtoul (arch->arhdr.ar_size, NULL, 10);
- size = size + (size & 1);
-
- arch->next_arhdr_offset += sizeof arch->arhdr + size;
-
- if (read_symbols)
- {
- unsigned long i;
- /* A buffer used to hold numbers read in from an archive index.
- These are always 4 bytes long and stored in big-endian format. */
-#define SIZEOF_AR_INDEX_NUMBERS 4
- unsigned char integer_buffer[SIZEOF_AR_INDEX_NUMBERS];
- unsigned char * index_buffer;
-
- /* Check the size of the archive index. */
- if (size < SIZEOF_AR_INDEX_NUMBERS)
- {
- error (_("%s: the archive index is empty\n"), file_name);
- return 1;
- }
-
- /* Read the numer of entries in the archive index. */
- got = fread (integer_buffer, 1, sizeof integer_buffer, file);
- if (got != sizeof (integer_buffer))
- {
- error (_("%s: failed to read archive index\n"), file_name);
- return 1;
- }
- arch->index_num = byte_get_big_endian (integer_buffer, sizeof integer_buffer);
- size -= SIZEOF_AR_INDEX_NUMBERS;
-
- /* Read in the archive index. */
- if (size < arch->index_num * SIZEOF_AR_INDEX_NUMBERS)
- {
- error (_("%s: the archive index is supposed to have %ld entries, but the size in the header is too small\n"),
- file_name, arch->index_num);
- return 1;
- }
- index_buffer = (unsigned char *)
- malloc (arch->index_num * SIZEOF_AR_INDEX_NUMBERS);
- if (index_buffer == NULL)
- {
- error (_("Out of memory whilst trying to read archive symbol index\n"));
- return 1;
- }
- got = fread (index_buffer, SIZEOF_AR_INDEX_NUMBERS, arch->index_num, file);
- if (got != arch->index_num)
- {
- free (index_buffer);
- error (_("%s: failed to read archive index\n"), file_name);
- return 1;
- }
- size -= arch->index_num * SIZEOF_AR_INDEX_NUMBERS;
-
- /* Convert the index numbers into the host's numeric format. */
- arch->index_array = (long unsigned int *)
- malloc (arch->index_num * sizeof (* arch->index_array));
- if (arch->index_array == NULL)
- {
- free (index_buffer);
- error (_("Out of memory whilst trying to convert the archive symbol index\n"));
- return 1;
- }
-
- for (i = 0; i < arch->index_num; i++)
- arch->index_array[i] = byte_get_big_endian ((unsigned char *) (index_buffer + (i * SIZEOF_AR_INDEX_NUMBERS)),
- SIZEOF_AR_INDEX_NUMBERS);
- free (index_buffer);
-
- /* The remaining space in the header is taken up by the symbol table. */
- if (size < 1)
- {
- error (_("%s: the archive has an index but no symbols\n"), file_name);
- return 1;
- }
- arch->sym_table = (char *) malloc (size);
- arch->sym_size = size;
- if (arch->sym_table == NULL)
- {
- error (_("Out of memory whilst trying to read archive index symbol table\n"));
- return 1;
- }
- got = fread (arch->sym_table, 1, size, file);
- if (got != size)
- {
- error (_("%s: failed to read archive index symbol table\n"), file_name);
- return 1;
- }
- }
- else
- {
- if (fseek (file, size, SEEK_CUR) != 0)
- {
- error (_("%s: failed to skip archive symbol table\n"), file_name);
- return 1;
- }
- }
-
- /* Read the next archive header. */
- got = fread (&arch->arhdr, 1, sizeof arch->arhdr, file);
- if (got != sizeof arch->arhdr)
- {
- if (got == 0)
- return 0;
- error (_("%s: failed to read archive header following archive index\n"), file_name);
- return 1;
- }
- }
- else if (read_symbols)
- printf (_("%s has no archive index\n"), file_name);
-
- if (const_strneq (arch->arhdr.ar_name, "// "))
- {
- /* This is the archive string table holding long member names. */
- arch->longnames_size = strtoul (arch->arhdr.ar_size, NULL, 10);
- arch->next_arhdr_offset += sizeof arch->arhdr + arch->longnames_size;
-
- arch->longnames = (char *) malloc (arch->longnames_size);
- if (arch->longnames == NULL)
- {
- error (_("Out of memory reading long symbol names in archive\n"));
- return 1;
- }
-
- if (fread (arch->longnames, arch->longnames_size, 1, file) != 1)
- {
- free (arch->longnames);
- arch->longnames = NULL;
- error (_("%s: failed to read long symbol name string table\n"), file_name);
- return 1;
- }
-
- if ((arch->longnames_size & 1) != 0)
- getc (file);
- }
-
- return 0;
-}
-
-/* Release the memory used for the archive information. */
-
-static void
-release_archive (struct archive_info * arch)
-{
- if (arch->file_name != NULL)
- free (arch->file_name);
- if (arch->index_array != NULL)
- free (arch->index_array);
- if (arch->sym_table != NULL)
- free (arch->sym_table);
- if (arch->longnames != NULL)
- free (arch->longnames);
-}
-
-/* Open and setup a nested archive, if not already open. */
-
-static int
-setup_nested_archive (struct archive_info * nested_arch, char * member_file_name)
-{
- FILE * member_file;
-
- /* Have we already setup this archive? */
- if (nested_arch->file_name != NULL
- && streq (nested_arch->file_name, member_file_name))
- return 0;
-
- /* Close previous file and discard cached information. */
- if (nested_arch->file != NULL)
- fclose (nested_arch->file);
- release_archive (nested_arch);
-
- member_file = fopen (member_file_name, "rb");
- if (member_file == NULL)
- return 1;
- return setup_archive (nested_arch, member_file_name, member_file, FALSE, FALSE);
-}
-
-static char *
-get_archive_member_name_at (struct archive_info * arch,
- unsigned long offset,
- struct archive_info * nested_arch);
-
-/* Get the name of an archive member from the current archive header.
- For simple names, this will modify the ar_name field of the current
- archive header. For long names, it will return a pointer to the
- longnames table. For nested archives, it will open the nested archive
- and get the name recursively. NESTED_ARCH is a single-entry cache so
- we don't keep rereading the same information from a nested archive. */
-
-static char *
-get_archive_member_name (struct archive_info * arch,
- struct archive_info * nested_arch)
-{
- unsigned long j, k;
-
- if (arch->arhdr.ar_name[0] == '/')
- {
- /* We have a long name. */
- char * endp;
- char * member_file_name;
- char * member_name;
-
- arch->nested_member_origin = 0;
- k = j = strtoul (arch->arhdr.ar_name + 1, &endp, 10);
- if (arch->is_thin_archive && endp != NULL && * endp == ':')
- arch->nested_member_origin = strtoul (endp + 1, NULL, 10);
-
- while ((j < arch->longnames_size)
- && (arch->longnames[j] != '\n')
- && (arch->longnames[j] != '\0'))
- j++;
- if (arch->longnames[j-1] == '/')
- j--;
- arch->longnames[j] = '\0';
-
- if (!arch->is_thin_archive || arch->nested_member_origin == 0)
- return arch->longnames + k;
-
- /* This is a proxy for a member of a nested archive.
- Find the name of the member in that archive. */
- member_file_name = adjust_relative_path (arch->file_name, arch->longnames + k, j - k);
- if (member_file_name != NULL
- && setup_nested_archive (nested_arch, member_file_name) == 0
- && (member_name = get_archive_member_name_at (nested_arch, arch->nested_member_origin, NULL)) != NULL)
- {
- free (member_file_name);
- return member_name;
- }
- free (member_file_name);
-
- /* Last resort: just return the name of the nested archive. */
- return arch->longnames + k;
- }
-
- /* We have a normal (short) name. */
- j = 0;
- while ((arch->arhdr.ar_name[j] != '/') && (j < 16))
- j++;
- arch->arhdr.ar_name[j] = '\0';
- return arch->arhdr.ar_name;
-}
-
-/* Get the name of an archive member at a given OFFSET within an archive ARCH. */
-
-static char *
-get_archive_member_name_at (struct archive_info * arch,
- unsigned long offset,
- struct archive_info * nested_arch)
-{
- size_t got;
-
- if (fseek (arch->file, offset, SEEK_SET) != 0)
- {
- error (_("%s: failed to seek to next file name\n"), arch->file_name);
- return NULL;
- }
- got = fread (&arch->arhdr, 1, sizeof arch->arhdr, arch->file);
- if (got != sizeof arch->arhdr)
- {
- error (_("%s: failed to read archive header\n"), arch->file_name);
- return NULL;
- }
- if (memcmp (arch->arhdr.ar_fmag, ARFMAG, 2) != 0)
- {
- error (_("%s: did not find a valid archive header\n"), arch->file_name);
- return NULL;
- }
-
- return get_archive_member_name (arch, nested_arch);
-}
-
-/* Construct a string showing the name of the archive member, qualified
- with the name of the containing archive file. For thin archives, we
- use square brackets to denote the indirection. For nested archives,
- we show the qualified name of the external member inside the square
- brackets (e.g., "thin.a[normal.a(foo.o)]"). */
-
-static char *
-make_qualified_name (struct archive_info * arch,
- struct archive_info * nested_arch,
- char * member_name)
-{
- size_t len;
- char * name;
-
- len = strlen (arch->file_name) + strlen (member_name) + 3;
- if (arch->is_thin_archive && arch->nested_member_origin != 0)
- len += strlen (nested_arch->file_name) + 2;
-
- name = (char *) malloc (len);
- if (name == NULL)
- {
- error (_("Out of memory\n"));
- return NULL;
- }
-
- if (arch->is_thin_archive && arch->nested_member_origin != 0)
- snprintf (name, len, "%s[%s(%s)]", arch->file_name, nested_arch->file_name, member_name);
- else if (arch->is_thin_archive)
- snprintf (name, len, "%s[%s]", arch->file_name, member_name);
- else
- snprintf (name, len, "%s(%s)", arch->file_name, member_name);
-
- return name;
-}
-
/* Process an ELF archive.
On entry the file is positioned just after the ARMAG string. */
struct archive_info arch;
struct archive_info nested_arch;
size_t got;
- size_t file_name_size;
int ret;
show_name = 1;
}
}
- file_name_size = strlen (file_name);
ret = 0;
while (1)
ret |= process_object (qualified_name, file);
}
+ if (dump_sects != NULL)
+ {
+ free (dump_sects);
+ dump_sects = NULL;
+ num_dump_sects = 0;
+ }
+
free (qualified_name);
}