#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"
#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 BYTE_GET(field) byte_get (field, sizeof (field))
+#define BYTE_GET_SIGNED(field) byte_get_signed (field, sizeof (field))
#define GET_ELF_SYMBOLS(file, section) \
(is_32bit_elf ? get_32bit_elf_symbols (file, section) \
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\
+ =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]));
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);
}
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;
}
request_dump_bynumber (i, DEBUG_DUMP);
else if (do_debug_frames && streq (name, ".eh_frame"))
request_dump_bynumber (i, DEBUG_DUMP);
+ /* Trace sections for Itanium VMS. */
+ else if ((do_debugging || do_trace_info || do_trace_abbrevs
+ || do_trace_aranges)
+ && const_strneq (name, ".trace_"))
+ {
+ name += sizeof (".trace_") - 1;
+
+ if (do_debugging
+ || (do_trace_info && streq (name, "info"))
+ || (do_trace_abbrevs && streq (name, "abbrev"))
+ || (do_trace_aranges && streq (name, "aranges"))
+ )
+ request_dump_bynumber (i, DEBUG_DUMP);
+ }
+
}
if (! do_sections)
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;
}
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)
}
else
{
-
per_index = (word >> 24) & 0x7f;
if (per_index != 0 && per_index != 1 && per_index != 2)
{
unsigned int mask = ((op & 0x0f) << 8) | op2;
int first = 1;
int i;
+
printf ("pop {");
for (i = 0; i < 12; i++)
if (mask & (1 << i))
}
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)
{
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++)
{
+ /* 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;
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");
{
printf (_(" Local entries:\n"));
printf (_(" %*s %10s %*s\n"),
- addr_size * 2, "Address", "Access",
- addr_size * 2, "Initial");
+ addr_size * 2, _("Address"), _("Access"),
+ addr_size * 2, _("Initial"));
while (ent < local_end)
{
ent = print_mips_got_entry (data, pltgot, ent);
printf (_(" Global entries:\n"));
printf (_(" %*s %10s %*s %*s %-7s %3s %s\n"),
- addr_size * 2, "Address", "Access",
- addr_size * 2, "Initial",
- addr_size * 2, "Sym.Val.", "Type", "Ndx", "Name");
+ addr_size * 2, _("Address"), _("Access"),
+ addr_size * 2, _("Initial"),
+ addr_size * 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
sym_width = (is_32bit_elf ? 80 : 160) - 28 - addr_size * 6 - 1;
for (i = gotsym; i < symtabno; i++)
{
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");
+ 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;
}
/* We have a normal (short) name. */
j = 0;
- while ((arch->arhdr.ar_name[j] != '/') && (j < 16))
+ while ((arch->arhdr.ar_name[j] != '/')
+ && (j < sizeof (arch->arhdr.ar_name) - 1))
j++;
arch->arhdr.ar_name[j] = '\0';
return arch->arhdr.ar_name;
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)
projects / thirdparty / binutils-gdb.git / blobdiff