/* readelf.c -- display contents of an ELF format file
- Copyright (C) 1998-2017 Free Software Foundation, Inc.
+ Copyright (C) 1998-2018 Free Software Foundation, Inc.
Originally developed by Eric Youngdale <eric@andante.jic.com>
Modifications by Nick Clifton <nickc@redhat.com>
#include "elf/cr16.h"
#include "elf/cris.h"
#include "elf/crx.h"
+#include "elf/csky.h"
#include "elf/d10v.h"
#include "elf/d30v.h"
#include "elf/dlx.h"
#include "elf/m32r.h"
#include "elf/m68k.h"
#include "elf/m68hc11.h"
+#include "elf/s12z.h"
#include "elf/mcore.h"
#include "elf/mep.h"
#include "elf/metag.h"
#include "elf/microblaze.h"
#include "elf/mips.h"
-#include "elf/riscv.h"
#include "elf/mmix.h"
#include "elf/mn10200.h"
#include "elf/mn10300.h"
#include "elf/mt.h"
#include "elf/msp430.h"
#include "elf/nds32.h"
+#include "elf/nfp.h"
#include "elf/nios2.h"
#include "elf/or1k.h"
#include "elf/pj.h"
#include "elf/ppc.h"
#include "elf/ppc64.h"
#include "elf/pru.h"
+#include "elf/riscv.h"
#include "elf/rl78.h"
#include "elf/rx.h"
#include "elf/s390.h"
width = - width;
extra_padding = TRUE;
}
- assert (width != 0);
+ else if (width == 0)
+ return 0;
if (do_wide)
/* Set the remaining width to a very large value.
{
unsigned int i;
- assert (filedata->section_headers != NULL);
+ if (filedata->section_headers == NULL)
+ return NULL;
for (i = 0; i < filedata->file_header.e_shnum; i++)
if (streq (SECTION_NAME (filedata->section_headers + i), name))
{
unsigned int i;
+ if (filedata->section_headers == NULL)
+ return NULL;
+
for (i = 0; i < filedata->file_header.e_shnum; i++)
{
Elf_Internal_Shdr *sec = filedata->section_headers + i;
{
unsigned int i;
+ if (filedata->section_headers == NULL)
+ return NULL;
+
for (i = 0; i < filedata->file_header.e_shnum; i++)
{
Elf_Internal_Shdr *sec = filedata->section_headers + i;
{
unsigned int i;
+ if (filedata->section_headers == NULL)
+ return NULL;
+
if (set != NULL)
{
while ((i = *set++) > 0)
case EM_CYGNUS_M32R:
case EM_SCORE:
case EM_XGATE:
+ case EM_NFP:
return FALSE;
/* Targets that use RELA relocations. */
case EM_CR16:
case EM_CRIS:
case EM_CRX:
+ case EM_CSKY:
case EM_D30V:
case EM_CYGNUS_D30V:
case EM_FR30:
rtype = elf_m68hc11_reloc_type (type);
break;
+ case EM_S12Z:
+ rtype = elf_s12z_reloc_type (type);
+ break;
+
case EM_68K:
rtype = elf_m68k_reloc_type (type);
break;
rtype = elf_frv_reloc_type (type);
break;
+ case EM_CSKY:
+ rtype = elf_csky_reloc_type (type);
+ break;
+
case EM_FT32:
rtype = elf_ft32_reloc_type (type);
break;
case EM_TI_PRU:
rtype = elf_pru_reloc_type (type);
break;
+
+ case EM_NFP:
+ if (EF_NFP_MACH (filedata->file_header.e_flags) == E_NFP_MACH_3200)
+ rtype = elf_nfp3200_reloc_type (type);
+ else
+ rtype = elf_nfp_reloc_type (type);
+ break;
}
if (rtype == NULL)
case EM_PARISC: return "HPPA";
case EM_VPP550: return "Fujitsu VPP500";
case EM_SPARC32PLUS: return "Sparc v8+" ;
- case EM_960: return "Intel 90860";
+ case EM_960: return "Intel 80960";
case EM_PPC: return "PowerPC";
/* 20 */
case EM_PPC64: return "PowerPC64";
case EM_RISCV: return "RISC-V";
case EM_LANAI: return "Lanai 32-bit processor";
case EM_BPF: return "Linux BPF";
+ case EM_NFP: return "Netronome Flow Processor";
/* Large numbers... */
case EM_MT: return "Morpho Techologies MT processor";
case EM_CYGNUS_MEP: return "Toshiba MeP Media Engine";
case EM_ADAPTEVA_EPIPHANY: return "Adapteva EPIPHANY";
case EM_CYGNUS_FRV: return "Fujitsu FR-V";
+ case EM_S12Z: return "Freescale S12Z";
+ case EM_CSKY: return "C-SKY";
default:
snprintf (buff, sizeof (buff), _("<unknown>: 0x%x"), e_machine);
e_flags &= ~ EF_ARM_RELEXEC;
}
+ if (e_flags & EF_ARM_PIC)
+ {
+ strcat (buf, ", position independent");
+ e_flags &= ~ EF_ARM_PIC;
+ }
+
/* Now handle EABI specific flags. */
switch (eabi)
{
decode_NDS32_machine_flags (e_flags, buf, sizeof buf);
break;
+ case EM_NFP:
+ switch (EF_NFP_MACH (e_flags))
+ {
+ case E_NFP_MACH_3200:
+ strcat (buf, ", NFP-32xx");
+ break;
+ case E_NFP_MACH_6000:
+ strcat (buf, ", NFP-6xxx");
+ break;
+ }
+ break;
+
case EM_RISCV:
if (e_flags & EF_RISCV_RVC)
strcat (buf, ", RVC");
+ if (e_flags & EF_RISCV_RVE)
+ strcat (buf, ", RVE");
+
switch (e_flags & EF_RISCV_FLOAT_ABI)
{
case EF_RISCV_FLOAT_ABI_SOFT:
switch (osabi)
{
case ELFOSABI_ARM: return "ARM";
+ case ELFOSABI_ARM_FDPIC: return "ARM FDPIC";
default:
break;
}
}
}
+static const char *
+get_nfp_section_type_name (unsigned int sh_type)
+{
+ switch (sh_type)
+ {
+ case SHT_NFP_MECONFIG: return "NFP_MECONFIG";
+ case SHT_NFP_INITREG: return "NFP_INITREG";
+ case SHT_NFP_UDEBUG: return "NFP_UDEBUG";
+ default: return NULL;
+ }
+}
+
static const char *
get_v850_section_type_name (unsigned int sh_type)
{
case SHT_PREINIT_ARRAY: return "PREINIT_ARRAY";
case SHT_GNU_HASH: return "GNU_HASH";
case SHT_GROUP: return "GROUP";
- case SHT_SYMTAB_SHNDX: return "SYMTAB SECTION INDICIES";
+ case SHT_SYMTAB_SHNDX: return "SYMTAB SECTION INDICES";
case SHT_GNU_verdef: return "VERDEF";
case SHT_GNU_verneed: return "VERNEED";
case SHT_GNU_versym: return "VERSYM";
case EM_MSP430:
result = get_msp430x_section_type_name (sh_type);
break;
+ case EM_NFP:
+ result = get_nfp_section_type_name (sh_type);
+ break;
case EM_V800:
case EM_V850:
case EM_CYGNUS_V850:
get_elf_class (header->e_ident[EI_CLASS]));
printf (_(" Data: %s\n"),
get_data_encoding (header->e_ident[EI_DATA]));
- printf (_(" Version: %d %s\n"),
+ printf (_(" Version: %d%s\n"),
header->e_ident[EI_VERSION],
(header->e_ident[EI_VERSION] == EV_CURRENT
- ? "(current)"
+ ? _(" (current)")
: (header->e_ident[EI_VERSION] != EV_NONE
- ? _("<unknown: %lx>")
+ ? _(" <unknown>")
: "")));
printf (_(" OS/ABI: %s\n"),
get_osabi_name (filedata, header->e_ident[EI_OSABI]));
printf (_(" Machine: %s\n"),
get_machine_name (header->e_machine));
printf (_(" Version: 0x%lx\n"),
- (unsigned long) header->e_version);
+ header->e_version);
printf (_(" Entry point address: "));
- print_vma ((bfd_vma) header->e_entry, PREFIX_HEX);
+ print_vma (header->e_entry, PREFIX_HEX);
printf (_("\n Start of program headers: "));
- print_vma ((bfd_vma) header->e_phoff, DEC);
+ print_vma (header->e_phoff, DEC);
printf (_(" (bytes into file)\n Start of section headers: "));
- print_vma ((bfd_vma) header->e_shoff, DEC);
+ print_vma (header->e_shoff, DEC);
printf (_(" (bytes into file)\n"));
printf (_(" Flags: 0x%lx%s\n"),
- (unsigned long) header->e_flags,
+ header->e_flags,
get_machine_flags (filedata, header->e_flags, header->e_machine));
- printf (_(" Size of this header: %ld (bytes)\n"),
- (long) header->e_ehsize);
- printf (_(" Size of program headers: %ld (bytes)\n"),
- (long) header->e_phentsize);
- printf (_(" Number of program headers: %ld"),
- (long) header->e_phnum);
+ printf (_(" Size of this header: %u (bytes)\n"),
+ header->e_ehsize);
+ printf (_(" Size of program headers: %u (bytes)\n"),
+ header->e_phentsize);
+ printf (_(" Number of program headers: %u"),
+ header->e_phnum);
if (filedata->section_headers != NULL
&& header->e_phnum == PN_XNUM
&& filedata->section_headers[0].sh_info != 0)
- printf (" (%ld)", (long) filedata->section_headers[0].sh_info);
+ {
+ header->e_phnum = filedata->section_headers[0].sh_info;
+ printf (" (%u)", header->e_phnum);
+ }
putc ('\n', stdout);
- printf (_(" Size of section headers: %ld (bytes)\n"),
- (long) header->e_shentsize);
- printf (_(" Number of section headers: %ld"),
- (long) header->e_shnum);
+ printf (_(" Size of section headers: %u (bytes)\n"),
+ header->e_shentsize);
+ printf (_(" Number of section headers: %u"),
+ header->e_shnum);
if (filedata->section_headers != NULL && header->e_shnum == SHN_UNDEF)
- printf (" (%ld)", (long) filedata->section_headers[0].sh_size);
+ {
+ header->e_shnum = filedata->section_headers[0].sh_size;
+ printf (" (%u)", header->e_shnum);
+ }
putc ('\n', stdout);
- printf (_(" Section header string table index: %ld"),
- (long) header->e_shstrndx);
+ printf (_(" Section header string table index: %u"),
+ header->e_shstrndx);
if (filedata->section_headers != NULL
&& header->e_shstrndx == (SHN_XINDEX & 0xffff))
- printf (" (%u)", filedata->section_headers[0].sh_link);
- else if (header->e_shstrndx != SHN_UNDEF
- && header->e_shstrndx >= header->e_shnum)
- printf (_(" <corrupt: out of range>"));
+ {
+ header->e_shstrndx = filedata->section_headers[0].sh_link;
+ printf (" (%u)", header->e_shstrndx);
+ }
+ if (header->e_shstrndx != SHN_UNDEF
+ && header->e_shstrndx >= header->e_shnum)
+ {
+ header->e_shstrndx = SHN_UNDEF;
+ printf (_(" <corrupt: out of range>"));
+ }
putc ('\n', stdout);
}
header->e_shnum = filedata->section_headers[0].sh_size;
if (header->e_shstrndx == (SHN_XINDEX & 0xffff))
header->e_shstrndx = filedata->section_headers[0].sh_link;
- else if (header->e_shstrndx >= header->e_shnum)
+ if (header->e_shstrndx >= header->e_shnum)
header->e_shstrndx = SHN_UNDEF;
free (filedata->section_headers);
filedata->section_headers = NULL;
{
if (!probe)
error (_("Out of memory reading %u section headers\n"), num);
+ free (shdrs);
return FALSE;
}
{
if (! probe)
error (_("Out of memory reading %u section headers\n"), num);
+ free (shdrs);
return FALSE;
}
Elf_Internal_Sym * isyms = NULL;
Elf_Internal_Sym * psym;
unsigned int j;
+ elf_section_list * entry;
if (section->sh_size == 0)
{
if (esyms == NULL)
goto exit_point;
- {
- elf_section_list * entry;
-
- shndx = NULL;
- for (entry = symtab_shndx_list; entry != NULL; entry = entry->next)
- if (entry->hdr->sh_link == (unsigned long) (section - filedata->section_headers))
- {
- shndx = (Elf_External_Sym_Shndx *) get_data (NULL, filedata,
- entry->hdr->sh_offset,
- 1, entry->hdr->sh_size,
- _("symbol table section indicies"));
- if (shndx == NULL)
- goto exit_point;
- /* PR17531: file: heap-buffer-overflow */
- else if (entry->hdr->sh_size / sizeof (Elf_External_Sym_Shndx) < number)
- {
- error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
- printable_section_name (filedata, entry->hdr),
- (unsigned long) entry->hdr->sh_size,
- (unsigned long) section->sh_size);
- goto exit_point;
- }
+ shndx = NULL;
+ for (entry = symtab_shndx_list; entry != NULL; entry = entry->next)
+ {
+ if (entry->hdr->sh_link != (unsigned long) (section - filedata->section_headers))
+ continue;
+
+ if (shndx != NULL)
+ {
+ error (_("Multiple symbol table index sections associated with the same symbol section\n"));
+ free (shndx);
}
- }
+
+ shndx = (Elf_External_Sym_Shndx *) get_data (NULL, filedata,
+ entry->hdr->sh_offset,
+ 1, entry->hdr->sh_size,
+ _("symbol table section indices"));
+ if (shndx == NULL)
+ goto exit_point;
+
+ /* PR17531: file: heap-buffer-overflow */
+ if (entry->hdr->sh_size / sizeof (Elf_External_Sym_Shndx) < number)
+ {
+ error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
+ printable_section_name (filedata, entry->hdr),
+ (unsigned long) entry->hdr->sh_size,
+ (unsigned long) section->sh_size);
+ goto exit_point;
+ }
+ }
isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
}
exit_point:
- if (shndx != NULL)
- free (shndx);
- if (esyms != NULL)
- free (esyms);
+ free (shndx);
+ free (esyms);
if (num_syms_return != NULL)
* num_syms_return = isyms == NULL ? 0 : number;
Elf_Internal_Sym * isyms = NULL;
Elf_Internal_Sym * psym;
unsigned int j;
+ elf_section_list * entry;
if (section->sh_size == 0)
{
if (!esyms)
goto exit_point;
- {
- elf_section_list * entry;
-
- shndx = NULL;
- for (entry = symtab_shndx_list; entry != NULL; entry = entry->next)
- if (entry->hdr->sh_link == (unsigned long) (section - filedata->section_headers))
- {
- shndx = (Elf_External_Sym_Shndx *) get_data (NULL, filedata,
- entry->hdr->sh_offset,
- 1, entry->hdr->sh_size,
- _("symbol table section indicies"));
- if (shndx == NULL)
- goto exit_point;
- /* PR17531: file: heap-buffer-overflow */
- else if (entry->hdr->sh_size / sizeof (Elf_External_Sym_Shndx) < number)
- {
- error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
- printable_section_name (filedata, entry->hdr),
- (unsigned long) entry->hdr->sh_size,
- (unsigned long) section->sh_size);
- goto exit_point;
- }
+ shndx = NULL;
+ for (entry = symtab_shndx_list; entry != NULL; entry = entry->next)
+ {
+ if (entry->hdr->sh_link != (unsigned long) (section - filedata->section_headers))
+ continue;
+
+ if (shndx != NULL)
+ {
+ error (_("Multiple symbol table index sections associated with the same symbol section\n"));
+ free (shndx);
}
- }
+
+ shndx = (Elf_External_Sym_Shndx *) get_data (NULL, filedata,
+ entry->hdr->sh_offset,
+ 1, entry->hdr->sh_size,
+ _("symbol table section indices"));
+ if (shndx == NULL)
+ goto exit_point;
+
+ /* PR17531: file: heap-buffer-overflow */
+ if (entry->hdr->sh_size / sizeof (Elf_External_Sym_Shndx) < number)
+ {
+ error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
+ printable_section_name (filedata, entry->hdr),
+ (unsigned long) entry->hdr->sh_size,
+ (unsigned long) section->sh_size);
+ goto exit_point;
+ }
+ }
isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
}
exit_point:
- if (shndx != NULL)
- free (shndx);
- if (esyms != NULL)
- free (esyms);
+ free (shndx);
+ free (esyms);
if (num_syms_return != NULL)
* num_syms_return = isyms == NULL ? 0 : number;
|| do_debug_lines || do_debug_pubnames || do_debug_pubtypes
|| do_debug_aranges || do_debug_frames || do_debug_macinfo
|| do_debug_str || do_debug_loc || do_debug_ranges
- || do_debug_addr || do_debug_cu_index)
+ || do_debug_addr || do_debug_cu_index || do_debug_links)
&& (const_strneq (name, ".debug_")
|| const_strneq (name, ".zdebug_")))
{
&& filedata->section_headers[section->sh_info].sh_type < SHT_LOOS))
{
if (section->sh_info == 0
- && (streq (SECTION_NAME (section), ".rel.dyn")
+ && (filedata->file_header.e_type == ET_EXEC
+ || filedata->file_header.e_type == ET_DYN
+ /* These next two tests may be redundant, but
+ they have been left in for paranoia's sake. */
+ || streq (SECTION_NAME (section), ".rel.dyn")
|| streq (SECTION_NAME (section), ".rela.dyn")))
- /* The .rel.dyn and .rela.dyn sections have an sh_info field
- of zero. The relocations in these sections may apply
- to many different sections. */
- ;
+ /* Dynamic relocations apply to segments, not sections, so
+ they do not need an sh_info value. */
+ ;
else
warn (_("[%2u]: Info field (%u) should index a relocatable section.\n"),
i, section->sh_info);
}
else if (do_section_details)
{
- printf (" %-15.15s ",
- get_section_type_name (filedata, section->sh_type));
+ putchar (' ');
print_vma (section->sh_addr, LONG_HEX);
if ((long) section->sh_offset == section->sh_offset)
printf (" %16.16lx", (unsigned long) section->sh_offset);
error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
entry, i, filedata->file_header.e_shnum - 1);
if (num_group_errors == 10)
- warn (_("Further error messages about overlarge group section indicies suppressed\n"));
+ warn (_("Further error messages about overlarge group section indices suppressed\n"));
}
continue;
}
if (! slurp_hppa_unwind_table (filedata, &aux, sec))
res = FALSE;
-
- if (aux.table_len > 0)
+
+ if (res && aux.table_len > 0)
{
if (! dump_hppa_unwind (filedata, &aux))
res = FALSE;
section.sh_entsize = sizeof (Elf64_External_Sym);
section.sh_name = filedata->string_table_length;
+ if (dynamic_symbols != NULL)
+ {
+ error (_("Multiple dynamic symbol table sections found\n"));
+ free (dynamic_symbols);
+ }
dynamic_symbols = GET_ELF_SYMBOLS (filedata, §ion, & num_dynamic_syms);
if (num_dynamic_syms < 1)
{
if (archive_file_offset != 0)
str_tab_len = archive_file_size - offset;
else
- str_tab_len = filedata->file_size;
+ str_tab_len = filedata->file_size - offset;
if (str_tab_len < 1)
{
continue;
}
+ if (dynamic_strings != NULL)
+ {
+ error (_("Multiple dynamic string tables found\n"));
+ free (dynamic_strings);
+ }
+
dynamic_strings = (char *) get_data (NULL, filedata, offset, 1,
str_tab_len,
_("dynamic string table"));
dynamic_strings_length = dynamic_strings == NULL ? 0 : str_tab_len;
- break;
}
}
if (!extsyminfo)
return FALSE;
+ if (dynamic_syminfo != NULL)
+ {
+ error (_("Multiple dynamic symbol information sections found\n"));
+ free (dynamic_syminfo);
+ }
dynamic_syminfo = (Elf_Internal_Syminfo *) malloc (syminsz);
if (dynamic_syminfo == NULL)
{
printf (" PIE");
val ^= DF_1_PIE;
}
+ if (val & DF_1_KMOD)
+ {
+ printf (" KMOD");
+ val ^= DF_1_KMOD;
+ }
+ if (val & DF_1_WEAKFILTER)
+ {
+ printf (" WEAKFILTER");
+ val ^= DF_1_WEAKFILTER;
+ }
+ if (val & DF_1_NOCOMMON)
+ {
+ printf (" NOCOMMON");
+ val ^= DF_1_NOCOMMON;
+ }
if (val != 0)
printf (" %lx", val);
puts ("");
static char *
get_ver_flags (unsigned int flags)
{
- static char buff[32];
+ static char buff[128];
buff[0] = 0;
static const char *
get_ppc64_symbol_other (unsigned int other)
{
- if (PPC64_LOCAL_ENTRY_OFFSET (other) != 0)
+ if ((other & ~STO_PPC64_LOCAL_MASK) != 0)
+ return NULL;
+
+ other >>= STO_PPC64_LOCAL_BIT;
+ if (other <= 6)
{
static char buf[32];
- snprintf (buf, sizeof buf, _("<localentry>: %d"),
- PPC64_LOCAL_ENTRY_OFFSET (other));
+ if (other >= 2)
+ other = ppc64_decode_local_entry (other);
+ snprintf (buf, sizeof buf, _("<localentry>: %d"), other);
return buf;
}
return NULL;
vers_data = byte_get (data, 2);
- if ((vers_data & VERSYM_HIDDEN) == 0 && vers_data <= 1)
+ if ((vers_data & VERSYM_HIDDEN) == 0 && vers_data == 0)
return NULL;
/* Usually we'd only see verdef for defined symbols, and verneed for
ivd.vd_ndx = 0;
ivd.vd_aux = 0;
ivd.vd_next = 0;
+ ivd.vd_flags = 0;
}
else
{
ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
ivd.vd_aux = BYTE_GET (evd.vd_aux);
ivd.vd_next = BYTE_GET (evd.vd_next);
+ ivd.vd_flags = BYTE_GET (evd.vd_flags);
}
off += ivd.vd_next;
if (ivd.vd_ndx == (vers_data & VERSYM_VERSION))
{
+ if (ivd.vd_ndx == 1 && ivd.vd_flags == VER_FLG_BASE)
+ return NULL;
+
off -= ivd.vd_next;
off += ivd.vd_aux;
return reloc_type == 3; /* R_CR16_NUM32. */
case EM_CRX:
return reloc_type == 15; /* R_CRX_NUM32. */
+ case EM_CSKY:
+ return reloc_type == 1; /* R_CKCORE_ADDR32. */
case EM_CYGNUS_FRV:
return reloc_type == 1;
case EM_CYGNUS_D10V:
case EM_68HC11:
case EM_68HC12:
return reloc_type == 6; /* R_M68HC11_32. */
+ case EM_S12Z:
+ return reloc_type == 6; /* R_S12Z_EXT32. */
case EM_MCORE:
return reloc_type == 1; /* R_MCORE_ADDR32. */
case EM_CYGNUS_MEP:
case EM_OR1K:
return reloc_type == 1; /* R_OR1K_32. */
case EM_PARISC:
- return (reloc_type == 1 /* R_PARISC_DIR32. */
+ return (reloc_type == 1 /* R_PARISC_DIR32. */
+ || reloc_type == 2 /* R_PARISC_DIR21L. */
|| reloc_type == 41); /* R_PARISC_SECREL32. */
case EM_PJ:
case EM_PJ_OLD:
return reloc_type == 9; /* R_NIOS_16. */
case EM_OR1K:
return reloc_type == 2; /* R_OR1K_16. */
+ case EM_RISCV:
+ return reloc_type == 55; /* R_RISCV_SET16. */
case EM_TI_PRU:
return reloc_type == 8; /* R_PRU_BFD_RELOC_16. */
case EM_TI_C6000:
}
}
+/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
+ a 8-bit absolute RELA relocation used in DWARF debug sections. */
+
+static bfd_boolean
+is_8bit_abs_reloc (Filedata * filedata, unsigned int reloc_type)
+{
+ switch (filedata->file_header.e_machine)
+ {
+ case EM_RISCV:
+ return reloc_type == 54; /* R_RISCV_SET8. */
+ default:
+ return FALSE;
+ }
+}
+
+/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
+ a 6-bit absolute RELA relocation used in DWARF debug sections. */
+
+static bfd_boolean
+is_6bit_abs_reloc (Filedata * filedata, unsigned int reloc_type)
+{
+ switch (filedata->file_header.e_machine)
+ {
+ case EM_RISCV:
+ return reloc_type == 53; /* R_RISCV_SET6. */
+ default:
+ return FALSE;
+ }
+}
+
+/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
+ a 32-bit inplace add RELA relocation used in DWARF debug sections. */
+
+static bfd_boolean
+is_32bit_inplace_add_reloc (Filedata * filedata, unsigned int reloc_type)
+{
+ /* Please keep this table alpha-sorted for ease of visual lookup. */
+ switch (filedata->file_header.e_machine)
+ {
+ case EM_RISCV:
+ return reloc_type == 35; /* R_RISCV_ADD32. */
+ default:
+ return FALSE;
+ }
+}
+
+/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
+ a 32-bit inplace sub RELA relocation used in DWARF debug sections. */
+
+static bfd_boolean
+is_32bit_inplace_sub_reloc (Filedata * filedata, unsigned int reloc_type)
+{
+ /* Please keep this table alpha-sorted for ease of visual lookup. */
+ switch (filedata->file_header.e_machine)
+ {
+ case EM_RISCV:
+ return reloc_type == 39; /* R_RISCV_SUB32. */
+ default:
+ return FALSE;
+ }
+}
+
+/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
+ a 64-bit inplace add RELA relocation used in DWARF debug sections. */
+
+static bfd_boolean
+is_64bit_inplace_add_reloc (Filedata * filedata, unsigned int reloc_type)
+{
+ /* Please keep this table alpha-sorted for ease of visual lookup. */
+ switch (filedata->file_header.e_machine)
+ {
+ case EM_RISCV:
+ return reloc_type == 36; /* R_RISCV_ADD64. */
+ default:
+ return FALSE;
+ }
+}
+
+/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
+ a 64-bit inplace sub RELA relocation used in DWARF debug sections. */
+
+static bfd_boolean
+is_64bit_inplace_sub_reloc (Filedata * filedata, unsigned int reloc_type)
+{
+ /* Please keep this table alpha-sorted for ease of visual lookup. */
+ switch (filedata->file_header.e_machine)
+ {
+ case EM_RISCV:
+ return reloc_type == 40; /* R_RISCV_SUB64. */
+ default:
+ return FALSE;
+ }
+}
+
+/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
+ a 16-bit inplace add RELA relocation used in DWARF debug sections. */
+
+static bfd_boolean
+is_16bit_inplace_add_reloc (Filedata * filedata, unsigned int reloc_type)
+{
+ /* Please keep this table alpha-sorted for ease of visual lookup. */
+ switch (filedata->file_header.e_machine)
+ {
+ case EM_RISCV:
+ return reloc_type == 34; /* R_RISCV_ADD16. */
+ default:
+ return FALSE;
+ }
+}
+
+/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
+ a 16-bit inplace sub RELA relocation used in DWARF debug sections. */
+
+static bfd_boolean
+is_16bit_inplace_sub_reloc (Filedata * filedata, unsigned int reloc_type)
+{
+ /* Please keep this table alpha-sorted for ease of visual lookup. */
+ switch (filedata->file_header.e_machine)
+ {
+ case EM_RISCV:
+ return reloc_type == 38; /* R_RISCV_SUB16. */
+ default:
+ return FALSE;
+ }
+}
+
+/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
+ a 8-bit inplace add RELA relocation used in DWARF debug sections. */
+
+static bfd_boolean
+is_8bit_inplace_add_reloc (Filedata * filedata, unsigned int reloc_type)
+{
+ /* Please keep this table alpha-sorted for ease of visual lookup. */
+ switch (filedata->file_header.e_machine)
+ {
+ case EM_RISCV:
+ return reloc_type == 33; /* R_RISCV_ADD8. */
+ default:
+ return FALSE;
+ }
+}
+
+/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
+ a 8-bit inplace sub RELA relocation used in DWARF debug sections. */
+
+static bfd_boolean
+is_8bit_inplace_sub_reloc (Filedata * filedata, unsigned int reloc_type)
+{
+ /* Please keep this table alpha-sorted for ease of visual lookup. */
+ switch (filedata->file_header.e_machine)
+ {
+ case EM_RISCV:
+ return reloc_type == 37; /* R_RISCV_SUB8. */
+ default:
+ return FALSE;
+ }
+}
+
+/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
+ a 6-bit inplace sub RELA relocation used in DWARF debug sections. */
+
+static bfd_boolean
+is_6bit_inplace_sub_reloc (Filedata * filedata, unsigned int reloc_type)
+{
+ switch (filedata->file_header.e_machine)
+ {
+ case EM_RISCV:
+ return reloc_type == 52; /* R_RISCV_SUB6. */
+ default:
+ return FALSE;
+ }
+}
+
/* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
relocation entries (possibly formerly used for SHT_GROUP sections). */
bfd_vma addend;
unsigned int reloc_type;
unsigned int reloc_size;
+ bfd_boolean reloc_inplace = FALSE;
+ bfd_boolean reloc_subtract = FALSE;
unsigned char * rloc;
unsigned long sym_index;
reloc_size = 3;
else if (is_16bit_abs_reloc (filedata, reloc_type))
reloc_size = 2;
+ else if (is_8bit_abs_reloc (filedata, reloc_type)
+ || is_6bit_abs_reloc (filedata, reloc_type))
+ reloc_size = 1;
+ else if ((reloc_subtract = is_32bit_inplace_sub_reloc (filedata,
+ reloc_type))
+ || is_32bit_inplace_add_reloc (filedata, reloc_type))
+ {
+ reloc_size = 4;
+ reloc_inplace = TRUE;
+ }
+ else if ((reloc_subtract = is_64bit_inplace_sub_reloc (filedata,
+ reloc_type))
+ || is_64bit_inplace_add_reloc (filedata, reloc_type))
+ {
+ reloc_size = 8;
+ reloc_inplace = TRUE;
+ }
+ else if ((reloc_subtract = is_16bit_inplace_sub_reloc (filedata,
+ reloc_type))
+ || is_16bit_inplace_add_reloc (filedata, reloc_type))
+ {
+ reloc_size = 2;
+ reloc_inplace = TRUE;
+ }
+ else if ((reloc_subtract = is_8bit_inplace_sub_reloc (filedata,
+ reloc_type))
+ || is_8bit_inplace_add_reloc (filedata, reloc_type))
+ {
+ reloc_size = 1;
+ reloc_inplace = TRUE;
+ }
+ else if ((reloc_subtract = is_6bit_inplace_sub_reloc (filedata,
+ reloc_type)))
+ {
+ reloc_size = 1;
+ reloc_inplace = TRUE;
+ }
else
{
static unsigned int prev_reloc = 0;
&& reloc_type == 1)
|| ((filedata->file_header.e_machine == EM_D30V
|| filedata->file_header.e_machine == EM_CYGNUS_D30V)
- && reloc_type == 12))
- addend += byte_get (rloc, reloc_size);
+ && reloc_type == 12)
+ || reloc_inplace)
+ {
+ if (is_6bit_inplace_sub_reloc (filedata, reloc_type))
+ addend += byte_get (rloc, reloc_size) & 0x3f;
+ else
+ addend += byte_get (rloc, reloc_size);
+ }
if (is_32bit_pcrel_reloc (filedata, reloc_type)
|| is_64bit_pcrel_reloc (filedata, reloc_type))
byte_put (rloc, (addend + sym->st_value) - rp->r_offset,
reloc_size);
}
+ else if (is_6bit_abs_reloc (filedata, reloc_type)
+ || is_6bit_inplace_sub_reloc (filedata, reloc_type))
+ {
+ if (reloc_subtract)
+ addend -= sym->st_value;
+ else
+ addend += sym->st_value;
+ addend = (addend & 0x3f) | (byte_get (rloc, reloc_size) & 0xc0);
+ byte_put (rloc, addend, reloc_size);
+ }
+ else if (reloc_subtract)
+ byte_put (rloc, addend - sym->st_value, reloc_size);
else
byte_put (rloc, addend + sym->st_value, reloc_size);
}
Elf_Internal_Shdr * sec;
Filedata * filedata = (Filedata *) data;
- if (filedata->string_table == NULL)
+ /* Without section headers we cannot find any sections. */
+ if (filedata->section_headers == NULL)
+ return FALSE;
+
+ if (filedata->string_table == NULL
+ && filedata->file_header.e_shstrndx != SHN_UNDEF
+ && filedata->file_header.e_shstrndx < filedata->file_header.e_shnum)
{
Elf_Internal_Shdr * strs;
/* Read in the string table, so that we have section names to scan. */
strs = filedata->section_headers + filedata->file_header.e_shstrndx;
- if (strs->sh_size != 0)
+ if (strs != NULL && strs->sh_size != 0)
{
- filedata->string_table = (char *) get_data (NULL, filedata, strs->sh_offset,
- 1, strs->sh_size,
- _("string table"));
+ filedata->string_table
+ = (char *) get_data (NULL, filedata, strs->sh_offset,
+ 1, strs->sh_size, _("string table"));
- filedata->string_table_length = filedata->string_table != NULL ? strs->sh_size : 0;
+ filedata->string_table_length
+ = filedata->string_table != NULL ? strs->sh_size : 0;
}
}
/* See if we know how to display the contents of this section. */
for (i = 0; i < max; i++)
- if (streq (debug_displays[i].section.uncompressed_name, name)
- || (i == line && const_strneq (name, ".debug_line."))
- || streq (debug_displays[i].section.compressed_name, name))
- {
- struct dwarf_section * sec = &debug_displays [i].section;
- int secondary = (section != find_section (filedata, name));
+ {
+ enum dwarf_section_display_enum id = (enum dwarf_section_display_enum) i;
+ struct dwarf_section_display * display = debug_displays + i;
+ struct dwarf_section * sec = & display->section;
- if (secondary)
- free_debug_section ((enum dwarf_section_display_enum) i);
+ if (streq (sec->uncompressed_name, name)
+ || (id == line && const_strneq (name, ".debug_line."))
+ || streq (sec->compressed_name, name))
+ {
+ bfd_boolean secondary = (section != find_section (filedata, name));
- if (i == line && const_strneq (name, ".debug_line."))
- sec->name = name;
- else if (streq (sec->uncompressed_name, name))
- sec->name = sec->uncompressed_name;
- else
- sec->name = sec->compressed_name;
+ if (secondary)
+ free_debug_section (id);
- if (load_specific_debug_section ((enum dwarf_section_display_enum) i,
- section, filedata))
- {
- /* If this debug section is part of a CU/TU set in a .dwp file,
- restrict load_debug_section to the sections in that set. */
- section_subset = find_cu_tu_set (filedata, shndx);
+ if (i == line && const_strneq (name, ".debug_line."))
+ sec->name = name;
+ else if (streq (sec->uncompressed_name, name))
+ sec->name = sec->uncompressed_name;
+ else
+ sec->name = sec->compressed_name;
- result &= debug_displays[i].display (sec, filedata);
+ if (load_specific_debug_section (id, section, filedata))
+ {
+ /* If this debug section is part of a CU/TU set in a .dwp file,
+ restrict load_debug_section to the sections in that set. */
+ section_subset = find_cu_tu_set (filedata, shndx);
- section_subset = NULL;
+ result &= display->display (sec, filedata);
- if (secondary || (i != info && i != abbrev))
- free_debug_section ((enum dwarf_section_display_enum) i);
- }
+ section_subset = NULL;
- break;
- }
+ if (secondary || (id != info && id != abbrev))
+ free_debug_section (id);
+ }
+ break;
+ }
+ }
if (i == max)
{
printf (" Tag_ARC_ISA_mpy_option: %d\n", val);
break;
+ case Tag_ARC_ATR_version:
+ val = read_uleb128 (p, &len, end);
+ p += len;
+ printf (" Tag_ARC_ATR_version: %d\n", val);
+ break;
+
default:
return display_tag_value (tag & 1, p, end);
}
fputs ("\n\tXPA ASE", stdout);
if (mask & AFL_ASE_MIPS16E2)
fputs ("\n\tMIPS16e2 ASE", stdout);
+ if (mask & AFL_ASE_CRC)
+ fputs ("\n\tCRC ASE", stdout);
+ if (mask & AFL_ASE_GINV)
+ fputs ("\n\tGINV ASE", stdout);
+ if (mask & AFL_ASE_LOONGSON_MMI)
+ fputs ("\n\tLoongson MMI ASE", stdout);
if (mask == 0)
fprintf (stdout, "\n\t%s", _("None"));
else if ((mask & ~AFL_ASE_MASK) != 0)
case NT_PPC_TM_CVMX:
return _("NT_PPC_TM_CVMX (ppc checkpointed Altivec registers)");
case NT_PPC_TM_CVSX:
- return _("NT_PPC_TM_VSX (ppc checkpointed VSX registers)");
+ return _("NT_PPC_TM_CVSX (ppc checkpointed VSX registers)");
case NT_PPC_TM_SPR:
return _("NT_PPC_TM_SPR (ppc TM special purpose registers)");
case NT_PPC_TM_CTAR:
case NT_ARCH:
return _("NT_ARCH (architecture)");
case NT_GNU_BUILD_ATTRIBUTE_OPEN:
- return _("NT_GNU_BUILD_ATTRIBUTE_OPEN");
+ return _("OPEN");
case NT_GNU_BUILD_ATTRIBUTE_FUNC:
- return _("NT_GNU_BUILD_ATTRIBUTE_FUNC");
+ return _("func");
default:
break;
}
}
}
+static void
+decode_x86_compat_isa (unsigned int bitmask)
+{
+ while (bitmask)
+ {
+ unsigned int bit = bitmask & (- bitmask);
+
+ bitmask &= ~ bit;
+ switch (bit)
+ {
+ case GNU_PROPERTY_X86_COMPAT_ISA_1_486:
+ printf ("i486");
+ break;
+ case GNU_PROPERTY_X86_COMPAT_ISA_1_586:
+ printf ("586");
+ break;
+ case GNU_PROPERTY_X86_COMPAT_ISA_1_686:
+ printf ("686");
+ break;
+ case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE:
+ printf ("SSE");
+ break;
+ case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE2:
+ printf ("SSE2");
+ break;
+ case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE3:
+ printf ("SSE3");
+ break;
+ case GNU_PROPERTY_X86_COMPAT_ISA_1_SSSE3:
+ printf ("SSSE3");
+ break;
+ case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE4_1:
+ printf ("SSE4_1");
+ break;
+ case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE4_2:
+ printf ("SSE4_2");
+ break;
+ case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX:
+ printf ("AVX");
+ break;
+ case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX2:
+ printf ("AVX2");
+ break;
+ case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512F:
+ printf ("AVX512F");
+ break;
+ case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512CD:
+ printf ("AVX512CD");
+ break;
+ case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512ER:
+ printf ("AVX512ER");
+ break;
+ case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512PF:
+ printf ("AVX512PF");
+ break;
+ case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512VL:
+ printf ("AVX512VL");
+ break;
+ case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512DQ:
+ printf ("AVX512DQ");
+ break;
+ case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512BW:
+ printf ("AVX512BW");
+ break;
+ default: printf (_("<unknown: %x>"), bit); break;
+ }
+ if (bitmask)
+ printf (", ");
+ }
+}
+
static void
decode_x86_isa (unsigned int bitmask)
{
bitmask &= ~ bit;
switch (bit)
{
- case GNU_PROPERTY_X86_ISA_1_486: printf ("i486"); break;
- case GNU_PROPERTY_X86_ISA_1_586: printf ("586"); break;
- case GNU_PROPERTY_X86_ISA_1_686: printf ("686"); break;
- case GNU_PROPERTY_X86_ISA_1_SSE: printf ("SSE"); break;
- case GNU_PROPERTY_X86_ISA_1_SSE2: printf ("SSE2"); break;
- case GNU_PROPERTY_X86_ISA_1_SSE3: printf ("SSE3"); break;
- case GNU_PROPERTY_X86_ISA_1_SSSE3: printf ("SSSE3"); break;
- case GNU_PROPERTY_X86_ISA_1_SSE4_1: printf ("SSE4_1"); break;
- case GNU_PROPERTY_X86_ISA_1_SSE4_2: printf ("SSE4_2"); break;
- case GNU_PROPERTY_X86_ISA_1_AVX: printf ("AVX"); break;
- case GNU_PROPERTY_X86_ISA_1_AVX2: printf ("AVX2"); break;
- case GNU_PROPERTY_X86_ISA_1_AVX512F: printf ("AVX512F"); break;
- case GNU_PROPERTY_X86_ISA_1_AVX512CD: printf ("AVX512CD"); break;
- case GNU_PROPERTY_X86_ISA_1_AVX512ER: printf ("AVX512ER"); break;
- case GNU_PROPERTY_X86_ISA_1_AVX512PF: printf ("AVX512PF"); break;
- case GNU_PROPERTY_X86_ISA_1_AVX512VL: printf ("AVX512VL"); break;
- case GNU_PROPERTY_X86_ISA_1_AVX512DQ: printf ("AVX512DQ"); break;
- case GNU_PROPERTY_X86_ISA_1_AVX512BW: printf ("AVX512BW"); break;
+ case GNU_PROPERTY_X86_ISA_1_CMOV:
+ printf ("CMOV");
+ break;
+ case GNU_PROPERTY_X86_ISA_1_SSE:
+ printf ("SSE");
+ break;
+ case GNU_PROPERTY_X86_ISA_1_SSE2:
+ printf ("SSE2");
+ break;
+ case GNU_PROPERTY_X86_ISA_1_SSE3:
+ printf ("SSE3");
+ break;
+ case GNU_PROPERTY_X86_ISA_1_SSSE3:
+ printf ("SSSE3");
+ break;
+ case GNU_PROPERTY_X86_ISA_1_SSE4_1:
+ printf ("SSE4_1");
+ break;
+ case GNU_PROPERTY_X86_ISA_1_SSE4_2:
+ printf ("SSE4_2");
+ break;
+ case GNU_PROPERTY_X86_ISA_1_AVX:
+ printf ("AVX");
+ break;
+ case GNU_PROPERTY_X86_ISA_1_AVX2:
+ printf ("AVX2");
+ break;
+ case GNU_PROPERTY_X86_ISA_1_FMA:
+ printf ("FMA");
+ break;
+ case GNU_PROPERTY_X86_ISA_1_AVX512F:
+ printf ("AVX512F");
+ break;
+ case GNU_PROPERTY_X86_ISA_1_AVX512CD:
+ printf ("AVX512CD");
+ break;
+ case GNU_PROPERTY_X86_ISA_1_AVX512ER:
+ printf ("AVX512ER");
+ break;
+ case GNU_PROPERTY_X86_ISA_1_AVX512PF:
+ printf ("AVX512PF");
+ break;
+ case GNU_PROPERTY_X86_ISA_1_AVX512VL:
+ printf ("AVX512VL");
+ break;
+ case GNU_PROPERTY_X86_ISA_1_AVX512DQ:
+ printf ("AVX512DQ");
+ break;
+ case GNU_PROPERTY_X86_ISA_1_AVX512BW:
+ printf ("AVX512BW");
+ break;
+ case GNU_PROPERTY_X86_ISA_1_AVX512_4FMAPS:
+ printf ("AVX512_4FMAPS");
+ break;
+ case GNU_PROPERTY_X86_ISA_1_AVX512_4VNNIW:
+ printf ("AVX512_4VNNIW");
+ break;
+ case GNU_PROPERTY_X86_ISA_1_AVX512_BITALG:
+ printf ("AVX512_BITALG");
+ break;
+ case GNU_PROPERTY_X86_ISA_1_AVX512_IFMA:
+ printf ("AVX512_IFMA");
+ break;
+ case GNU_PROPERTY_X86_ISA_1_AVX512_VBMI:
+ printf ("AVX512_VBMI");
+ break;
+ case GNU_PROPERTY_X86_ISA_1_AVX512_VBMI2:
+ printf ("AVX512_VBMI2");
+ break;
+ case GNU_PROPERTY_X86_ISA_1_AVX512_VNNI:
+ printf ("AVX512_VNNI");
+ break;
default: printf (_("<unknown: %x>"), bit); break;
}
if (bitmask)
}
static void
-decode_x86_feature (unsigned int type, unsigned int bitmask)
+decode_x86_feature_1 (unsigned int bitmask)
{
while (bitmask)
{
switch (bit)
{
case GNU_PROPERTY_X86_FEATURE_1_IBT:
- switch (type)
- {
- case GNU_PROPERTY_X86_FEATURE_1_AND:
- printf ("IBT");
- break;
- default:
- /* This should never happen. */
- abort ();
- }
+ printf ("IBT");
break;
case GNU_PROPERTY_X86_FEATURE_1_SHSTK:
- switch (type)
- {
- case GNU_PROPERTY_X86_FEATURE_1_AND:
- printf ("SHSTK");
- break;
- default:
- /* This should never happen. */
- abort ();
- }
+ printf ("SHSTK");
break;
default:
printf (_("<unknown: %x>"), bit);
}
}
+static void
+decode_x86_feature_2 (unsigned int bitmask)
+{
+ while (bitmask)
+ {
+ unsigned int bit = bitmask & (- bitmask);
+
+ bitmask &= ~ bit;
+ switch (bit)
+ {
+ case GNU_PROPERTY_X86_FEATURE_2_X86:
+ printf ("x86");
+ break;
+ case GNU_PROPERTY_X86_FEATURE_2_X87:
+ printf ("x87");
+ break;
+ case GNU_PROPERTY_X86_FEATURE_2_MMX:
+ printf ("MMX");
+ break;
+ case GNU_PROPERTY_X86_FEATURE_2_XMM:
+ printf ("XMM");
+ break;
+ case GNU_PROPERTY_X86_FEATURE_2_YMM:
+ printf ("YMM");
+ break;
+ case GNU_PROPERTY_X86_FEATURE_2_ZMM:
+ printf ("ZMM");
+ break;
+ case GNU_PROPERTY_X86_FEATURE_2_FXSR:
+ printf ("FXSR");
+ break;
+ case GNU_PROPERTY_X86_FEATURE_2_XSAVE:
+ printf ("XSAVE");
+ break;
+ case GNU_PROPERTY_X86_FEATURE_2_XSAVEOPT:
+ printf ("XSAVEOPT");
+ break;
+ case GNU_PROPERTY_X86_FEATURE_2_XSAVEC:
+ printf ("XSAVEC");
+ break;
+ default: printf (_("<unknown: %x>"), bit); break;
+ }
+ if (bitmask)
+ printf (", ");
+ }
+}
+
static void
print_gnu_property_note (Filedata * filedata, Elf_Internal_Note * pnote)
{
|| filedata->file_header.e_machine == EM_IAMCU
|| filedata->file_header.e_machine == EM_386)
{
+ unsigned int bitmask;
+
+ if (datasz == 4)
+ {
+ bitmask = byte_get (ptr, 4);
+ if (filedata->file_header.e_type == ET_EXEC
+ || filedata->file_header.e_type == ET_DYN)
+ {
+ if ((bitmask & GNU_PROPERTY_X86_UINT32_VALID))
+ bitmask &= ~GNU_PROPERTY_X86_UINT32_VALID;
+ else
+ printf ("Invalid ");
+ }
+ }
+ else
+ bitmask = 0;
+
switch (type)
{
case GNU_PROPERTY_X86_ISA_1_USED:
- printf ("x86 ISA used: ");
if (datasz != 4)
- printf (_("<corrupt length: %#x> "), datasz);
+ printf (_("x86 ISA used: <corrupt length: %#x> "),
+ datasz);
else
- decode_x86_isa (byte_get (ptr, 4));
+ {
+ printf ("x86 ISA used: ");
+ decode_x86_isa (bitmask);
+ }
goto next;
case GNU_PROPERTY_X86_ISA_1_NEEDED:
- printf ("x86 ISA needed: ");
if (datasz != 4)
- printf (_("<corrupt length: %#x> "), datasz);
+ printf (_("x86 ISA needed: <corrupt length: %#x> "),
+ datasz);
else
- decode_x86_isa (byte_get (ptr, 4));
+ {
+ printf ("x86 ISA needed: ");
+ decode_x86_isa (bitmask);
+ }
goto next;
case GNU_PROPERTY_X86_FEATURE_1_AND:
- printf ("x86 feature: ");
if (datasz != 4)
- printf (_("<corrupt length: %#x> "), datasz);
+ printf (_("x86 feature: <corrupt length: %#x> "),
+ datasz);
+ else
+ {
+ printf ("x86 feature: ");
+ decode_x86_feature_1 (bitmask);
+ }
+ goto next;
+
+ case GNU_PROPERTY_X86_FEATURE_2_USED:
+ if (datasz != 4)
+ printf (_("x86 feature used: <corrupt length: %#x> "),
+ datasz);
+ else
+ {
+ printf ("x86 feature used: ");
+ decode_x86_feature_2 (bitmask);
+ }
+ goto next;
+
+ case GNU_PROPERTY_X86_FEATURE_2_NEEDED:
+ if (datasz != 4)
+ printf (_("x86 feature needed: <corrupt length: %#x> "), datasz);
+ else
+ {
+ printf ("x86 feature needed: ");
+ decode_x86_feature_2 (bitmask);
+ }
+ goto next;
+
+ case GNU_PROPERTY_X86_COMPAT_ISA_1_USED:
+ if (datasz != 4)
+ printf (_("x86 ISA used: <corrupt length: %#x> "),
+ datasz);
+ else
+ {
+ printf ("x86 ISA used: ");
+ decode_x86_compat_isa (bitmask);
+ }
+ goto next;
+
+ case GNU_PROPERTY_X86_COMPAT_ISA_1_NEEDED:
+ if (datasz != 4)
+ printf (_("x86 ISA needed: <corrupt length: %#x> "),
+ datasz);
else
- decode_x86_feature (type, byte_get (ptr, 4));
+ {
+ printf ("x86 ISA needed: ");
+ decode_x86_compat_isa (bitmask);
+ }
goto next;
default:
return TRUE;
}
-/* Print the name of the symbol associated with a build attribute
- that is attached to address OFFSET. */
+/* Find the symbol associated with a build attribute that is attached
+ to address OFFSET. If PNAME is non-NULL then store the name of
+ the symbol (if found) in the provided pointer, Returns NULL if a
+ symbol could not be found. */
-static bfd_boolean
-print_symbol_for_build_attribute (Filedata * filedata,
- unsigned long offset,
- bfd_boolean is_open_attr)
+static Elf_Internal_Sym *
+get_symbol_for_build_attribute (Filedata * filedata,
+ unsigned long offset,
+ bfd_boolean is_open_attr,
+ const char ** pname)
{
static Filedata * saved_filedata = NULL;
static char * strtab;
}
if (symtab == NULL || strtab == NULL)
- {
- printf ("\n");
- return FALSE;
- }
+ return NULL;
/* Find a symbol whose value matches offset. */
for (sym = symtab; sym < symtab + nsyms; sym ++)
if (strtab[sym->st_name] == 0)
continue;
+ /* The AArch64 and ARM architectures define mapping symbols
+ (eg $d, $x, $t) which we want to ignore. */
+ if (strtab[sym->st_name] == '$'
+ && strtab[sym->st_name + 1] != 0
+ && strtab[sym->st_name + 2] == 0)
+ continue;
+
if (is_open_attr)
{
/* For OPEN attributes we prefer GLOBAL over LOCAL symbols
FUNC symbols entirely. */
switch (ELF_ST_TYPE (sym->st_info))
{
- case STT_FILE:
- saved_sym = sym;
- /* We can stop searching now. */
- sym = symtab + nsyms;
- continue;
-
case STT_OBJECT:
+ case STT_FILE:
saved_sym = sym;
+ if (sym->st_size)
+ {
+ /* If the symbol has a size associated
+ with it then we can stop searching. */
+ sym = symtab + nsyms;
+ }
continue;
case STT_FUNC:
}
}
- printf (" (%s: %s)\n",
- is_open_attr ? _("file") : _("func"),
- saved_sym ? strtab + saved_sym->st_name : _("<no symbol found>)"));
- return TRUE;
+ if (saved_sym && pname)
+ * pname = strtab + saved_sym->st_name;
+
+ return saved_sym;
+}
+
+/* Returns true iff addr1 and addr2 are in the same section. */
+
+static bfd_boolean
+same_section (Filedata * filedata, unsigned long addr1, unsigned long addr2)
+{
+ Elf_Internal_Shdr * a1;
+ Elf_Internal_Shdr * a2;
+
+ a1 = find_section_by_address (filedata, addr1);
+ a2 = find_section_by_address (filedata, addr2);
+
+ return a1 == a2 && a1 != NULL;
}
static bfd_boolean
print_gnu_build_attribute_description (Elf_Internal_Note * pnote,
Filedata * filedata)
{
- static unsigned long global_offset = 0;
- unsigned long offset;
- unsigned int desc_size = is_32bit_elf ? 4 : 8;
- bfd_boolean is_open_attr = pnote->type == NT_GNU_BUILD_ATTRIBUTE_OPEN;
+ static unsigned long global_offset = 0;
+ static unsigned long global_end = 0;
+ static unsigned long func_offset = 0;
+ static unsigned long func_end = 0;
+
+ Elf_Internal_Sym * sym;
+ const char * name;
+ unsigned long start;
+ unsigned long end;
+ bfd_boolean is_open_attr = pnote->type == NT_GNU_BUILD_ATTRIBUTE_OPEN;
- if (pnote->descsz == 0)
+ switch (pnote->descsz)
{
+ case 0:
+ /* A zero-length description means that the range of
+ the previous note of the same type should be used. */
if (is_open_attr)
{
- printf (_(" Applies from offset %#lx\n"), global_offset);
- return TRUE;
+ if (global_end > global_offset)
+ printf (_(" Applies to region from %#lx to %#lx\n"),
+ global_offset, global_end);
+ else
+ printf (_(" Applies to region from %#lx\n"), global_offset);
}
else
{
- printf (_(" Applies to func at %#lx"), global_offset);
- return print_symbol_for_build_attribute (filedata, global_offset, is_open_attr);
+ if (func_end > func_offset)
+ printf (_(" Applies to region from %#lx to %#lx\n"), func_offset, func_end);
+ else
+ printf (_(" Applies to region from %#lx\n"), func_offset);
}
- }
+ return TRUE;
- if (pnote->descsz != desc_size)
- {
+ case 4:
+ start = byte_get ((unsigned char *) pnote->descdata, 4);
+ end = 0;
+ break;
+
+ case 8:
+ if (is_32bit_elf)
+ {
+ /* FIXME: We should check that version 3+ notes are being used here... */
+ start = byte_get ((unsigned char *) pnote->descdata, 4);
+ end = byte_get ((unsigned char *) pnote->descdata + 4, 4);
+ }
+ else
+ {
+ start = byte_get ((unsigned char *) pnote->descdata, 8);
+ end = 0;
+ }
+ break;
+
+ case 16:
+ start = byte_get ((unsigned char *) pnote->descdata, 8);
+ end = byte_get ((unsigned char *) pnote->descdata + 8, 8);
+ break;
+
+ default:
error (_(" <invalid description size: %lx>\n"), pnote->descsz);
printf (_(" <invalid descsz>"));
return FALSE;
}
- offset = byte_get ((unsigned char *) pnote->descdata, desc_size);
+ name = NULL;
+ sym = get_symbol_for_build_attribute (filedata, start, is_open_attr, & name);
+ /* As of version 5 of the annobin plugin, filename symbols are biased by 2
+ in order to avoid them being confused with the start address of the
+ first function in the file... */
+ if (sym == NULL && is_open_attr)
+ sym = get_symbol_for_build_attribute (filedata, start + 2, is_open_attr,
+ & name);
+
+ if (end == 0 && sym != NULL && sym->st_size > 0)
+ end = start + sym->st_size;
if (is_open_attr)
{
- printf (_(" Applies from offset %#lx"), offset);
- global_offset = offset;
+ /* FIXME: Need to properly allow for section alignment.
+ 16 is just the alignment used on x86_64. */
+ if (global_end > 0
+ && start > BFD_ALIGN (global_end, 16)
+ /* Build notes are not guaranteed to be organised in order of
+ increasing address, but we should find the all of the notes
+ for one section in the same place. */
+ && same_section (filedata, start, global_end))
+ warn (_("Gap in build notes detected from %#lx to %#lx\n"),
+ global_end + 1, start - 1);
+
+ printf (_(" Applies to region from %#lx"), start);
+ global_offset = start;
+
+ if (end)
+ {
+ printf (_(" to %#lx"), end);
+ global_end = end;
+ }
}
else
{
- printf (_(" Applies to func at %#lx"), offset);
+ printf (_(" Applies to region from %#lx"), start);
+ func_offset = start;
+
+ if (end)
+ {
+ printf (_(" to %#lx"), end);
+ func_end = end;
+ }
}
- return print_symbol_for_build_attribute (filedata, offset, is_open_attr);
+ if (sym && name)
+ printf (_(" (%s)"), name);
+
+ printf ("\n");
+ return TRUE;
}
static bfd_boolean
return FALSE;
}
- left = 20;
+ if (do_wide)
+ left = 28;
+ else
+ left = 20;
/* Version 2 of the spec adds a "GA" prefix to the name field. */
if (name[0] == 'G' && name[1] == 'A')
{
+ if (pnote->namesz < 4)
+ {
+ error (_("corrupt name field in GNU build attribute note: size = %ld\n"), pnote->namesz);
+ print_symbol (-20, _(" <corrupt name>"));
+ return FALSE;
+ }
+
printf ("GA");
name += 2;
left -= 2;
process_notes_at (Filedata * filedata,
Elf_Internal_Shdr * section,
bfd_vma offset,
- bfd_vma length)
+ bfd_vma length,
+ bfd_vma align)
{
Elf_External_Note * pnotes;
Elf_External_Note * external;
- char * end;
- bfd_boolean res = TRUE;
+ char * end;
+ bfd_boolean res = TRUE;
if (length <= 0)
return FALSE;
else
pnotes = (Elf_External_Note *) get_data (NULL, filedata, offset, 1, length,
_("notes"));
+
if (pnotes == NULL)
return FALSE;
printf (_("\nDisplaying notes found at file offset 0x%08lx with length 0x%08lx:\n"),
(unsigned long) offset, (unsigned long) length);
+ /* NB: Some note sections may have alignment value of 0 or 1. gABI
+ specifies that notes should be aligned to 4 bytes in 32-bit
+ objects and to 8 bytes in 64-bit objects. As a Linux extension,
+ we also support 4 byte alignment in 64-bit objects. If section
+ alignment is less than 4, we treate alignment as 4 bytes. */
+ if (align < 4)
+ align = 4;
+ else if (align != 4 && align != 8)
+ {
+ warn (_("Corrupt note: alignment %ld, expecting 4 or 8\n"),
+ (long) align);
+ return FALSE;
+ }
+
printf (_(" %-20s %10s\tDescription\n"), _("Owner"), _("Data size"));
end = (char *) pnotes + length;
{
Elf_Internal_Note inote;
size_t min_notesz;
- char *next;
+ char * next;
char * temp = NULL;
size_t data_remaining = end - (char *) external;
inote.namesz = BYTE_GET (external->namesz);
inote.namedata = external->name;
inote.descsz = BYTE_GET (external->descsz);
- inote.descdata = inote.namedata + align_power (inote.namesz, 2);
+ inote.descdata = ((char *) external
+ + ELF_NOTE_DESC_OFFSET (inote.namesz, align));
inote.descpos = offset + (inote.descdata - (char *) pnotes);
- next = inote.descdata + align_power (inote.descsz, 2);
+ next = ((char *) external
+ + ELF_NOTE_NEXT_OFFSET (inote.namesz, inote.descsz, align));
}
else
{
{
warn (_("note with invalid namesz and/or descsz found at offset 0x%lx\n"),
(unsigned long) ((char *) external - (char *) pnotes));
- warn (_(" type: 0x%lx, namesize: 0x%08lx, descsize: 0x%08lx\n"),
- inote.type, inote.namesz, inote.descsz);
+ warn (_(" type: 0x%lx, namesize: 0x%08lx, descsize: 0x%08lx, alignment: %u\n"),
+ inote.type, inote.namesz, inote.descsz, (int) align);
break;
}
if (segment->p_type == PT_NOTE)
if (! process_notes_at (filedata, NULL,
(bfd_vma) segment->p_offset,
- (bfd_vma) segment->p_filesz))
+ (bfd_vma) segment->p_filesz,
+ (bfd_vma) segment->p_align))
res = FALSE;
}
{
if (! process_notes_at (filedata, section,
(bfd_vma) section->sh_offset,
- (bfd_vma) section->sh_size))
+ (bfd_vma) section->sh_size,
+ (bfd_vma) section->sh_addralign))
res = FALSE;
n++;
}
if (! process_version_sections (filedata))
res = FALSE;
- separates = load_separate_debug_file (filedata, filedata->file_name);
+ if (filedata->file_header.e_shstrndx != SHN_UNDEF)
+ separates = load_separate_debug_file (filedata, filedata->file_name);
+ else
+ separates = NULL;
if (! process_section_contents (filedata))
res = FALSE;
l += strnlen (arch.sym_table + l, arch.sym_size - l) + 1;
}
- if (arch.uses_64bit_indicies)
+ if (arch.uses_64bit_indices)
l = (l + 7) & ~ 7;
else
l += l & 1;
}
else if (is_thin_archive)
{
- Filedata thin_filedata = { 0 };
+ Filedata thin_filedata;
+
+ memset (&thin_filedata, 0, sizeof (thin_filedata));
/* PR 15140: Allow for corrupt thin archives. */
if (nested_arch.file == NULL)
archive_file_offset = arch.next_arhdr_offset;
arch.next_arhdr_offset += archive_file_size;
+ filedata->file_name = qualified_name;
if (! process_object (filedata))
ret = FALSE;
}
projects / deliverable / binutils-gdb.git / blobdiff