/* readelf.c -- display contents of an ELF format file
- Copyright (C) 1998-2017 Free Software Foundation, Inc.
+ Copyright (C) 1998-2020 Free Software Foundation, Inc.
Originally developed by Eric Youngdale <eric@andante.jic.com>
Modifications by Nick Clifton <nickc@redhat.com>
#include "bucomm.h"
#include "elfcomm.h"
#include "dwarf.h"
+#include "ctf-api.h"
#include "elf/common.h"
#include "elf/external.h"
#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/bpf.h"
#include "elf/epiphany.h"
#include "elf/fr30.h"
#include "elf/frv.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"
#include "elf/v850.h"
#include "elf/vax.h"
#include "elf/visium.h"
+#include "elf/wasm32.h"
#include "elf/x86-64.h"
#include "elf/xc16x.h"
#include "elf/xgate.h"
#include "elf/xstormy16.h"
#include "elf/xtensa.h"
+#include "elf/z80.h"
#include "getopt.h"
#include "libiberty.h"
typedef struct elf_section_list
{
- Elf_Internal_Shdr * hdr;
- struct elf_section_list * next;
+ Elf_Internal_Shdr * hdr;
+ struct elf_section_list * next;
} elf_section_list;
+/* Flag bits indicating particular types of dump. */
+#define HEX_DUMP (1 << 0) /* The -x command line switch. */
+#define DISASS_DUMP (1 << 1) /* The -i command line switch. */
+#define DEBUG_DUMP (1 << 2) /* The -w command line switch. */
+#define STRING_DUMP (1 << 3) /* The -p command line switch. */
+#define RELOC_DUMP (1 << 4) /* The -R command line switch. */
+#define CTF_DUMP (1 << 5) /* The --ctf command line switch. */
+
+typedef unsigned char dump_type;
+
+/* A linked list of the section names for which dumps were requested. */
+struct dump_list_entry
+{
+ char * name;
+ dump_type type;
+ struct dump_list_entry * next;
+};
+
+typedef struct filedata
+{
+ const char * file_name;
+ FILE * handle;
+ bfd_size_type file_size;
+ Elf_Internal_Ehdr file_header;
+ Elf_Internal_Shdr * section_headers;
+ Elf_Internal_Phdr * program_headers;
+ char * string_table;
+ unsigned long string_table_length;
+ /* A dynamic array of flags indicating for which sections a dump of
+ some kind has been requested. It is reset on a per-object file
+ basis and then initialised from the cmdline_dump_sects array,
+ the results of interpreting the -w switch, and the
+ dump_sects_byname list. */
+ dump_type * dump_sects;
+ unsigned int num_dump_sects;
+} Filedata;
+
char * program_name = "readelf";
+
static unsigned long archive_file_offset;
static unsigned long archive_file_size;
-static bfd_size_type current_file_size;
static unsigned long dynamic_addr;
static bfd_size_type dynamic_size;
static size_t dynamic_nent;
static char * dynamic_strings;
static unsigned long dynamic_strings_length;
-static char * string_table;
-static unsigned long string_table_length;
static unsigned long num_dynamic_syms;
static Elf_Internal_Sym * dynamic_symbols;
static Elf_Internal_Syminfo * dynamic_syminfo;
static char program_interpreter[PATH_MAX];
static bfd_vma dynamic_info[DT_ENCODING];
static bfd_vma dynamic_info_DT_GNU_HASH;
+static bfd_vma dynamic_info_DT_MIPS_XHASH;
static bfd_vma version_info[16];
-static Elf_Internal_Ehdr elf_header;
-static Elf_Internal_Shdr * section_headers;
-static Elf_Internal_Phdr * program_headers;
static Elf_Internal_Dyn * dynamic_section;
static elf_section_list * symtab_shndx_list;
-static int show_name;
-static int do_dynamic;
-static int do_syms;
-static int do_dyn_syms;
-static int do_reloc;
-static int do_sections;
-static int do_section_groups;
-static int do_section_details;
-static int do_segments;
-static int do_unwind;
-static int do_using_dynamic;
-static int do_header;
-static int do_dump;
-static int do_version;
-static int do_histogram;
-static int do_debugging;
-static int do_arch;
-static int do_notes;
-static int do_archive_index;
-static int is_32bit_elf;
-static int decompress_dumps;
+static bfd_boolean show_name = FALSE;
+static bfd_boolean do_dynamic = FALSE;
+static bfd_boolean do_syms = FALSE;
+static bfd_boolean do_dyn_syms = FALSE;
+static bfd_boolean do_reloc = FALSE;
+static bfd_boolean do_sections = FALSE;
+static bfd_boolean do_section_groups = FALSE;
+static bfd_boolean do_section_details = FALSE;
+static bfd_boolean do_segments = FALSE;
+static bfd_boolean do_unwind = FALSE;
+static bfd_boolean do_using_dynamic = FALSE;
+static bfd_boolean do_header = FALSE;
+static bfd_boolean do_dump = FALSE;
+static bfd_boolean do_version = FALSE;
+static bfd_boolean do_histogram = FALSE;
+static bfd_boolean do_debugging = FALSE;
+static bfd_boolean do_ctf = FALSE;
+static bfd_boolean do_arch = FALSE;
+static bfd_boolean do_notes = FALSE;
+static bfd_boolean do_archive_index = FALSE;
+static bfd_boolean is_32bit_elf = FALSE;
+static bfd_boolean decompress_dumps = FALSE;
+
+static char *dump_ctf_parent_name;
+static char *dump_ctf_symtab_name;
+static char *dump_ctf_strtab_name;
struct group_list
{
- struct group_list * next;
- unsigned int section_index;
+ struct group_list * next;
+ unsigned int section_index;
};
struct group
{
- struct group_list * root;
- unsigned int group_index;
+ struct group_list * root;
+ unsigned int group_index;
};
-static size_t group_count;
-static struct group * section_groups;
-static struct group ** section_headers_groups;
-
-
-/* Flag bits indicating particular types of dump. */
-#define HEX_DUMP (1 << 0) /* The -x command line switch. */
-#define DISASS_DUMP (1 << 1) /* The -i command line switch. */
-#define DEBUG_DUMP (1 << 2) /* The -w command line switch. */
-#define STRING_DUMP (1 << 3) /* The -p command line switch. */
-#define RELOC_DUMP (1 << 4) /* The -R command line switch. */
-
-typedef unsigned char dump_type;
-
-/* A linked list of the section names for which dumps were requested. */
-struct dump_list_entry
-{
- char * name;
- dump_type type;
- struct dump_list_entry * next;
-};
-static struct dump_list_entry * dump_sects_byname;
+static size_t group_count;
+static struct group * section_groups;
+static struct group ** section_headers_groups;
/* A dynamic array of flags indicating for which sections a dump
has been requested via command line switches. */
-static dump_type * cmdline_dump_sects = NULL;
-static unsigned int num_cmdline_dump_sects = 0;
-
-/* A dynamic array of flags indicating for which sections a dump of
- some kind has been requested. It is reset on a per-object file
- basis and then initialised from the cmdline_dump_sects array,
- the results of interpreting the -w switch, and the
- dump_sects_byname list. */
-static dump_type * dump_sects = NULL;
-static unsigned int num_dump_sects = 0;
+static Filedata cmdline;
+static struct dump_list_entry * dump_sects_byname;
/* How to print a vma value. */
typedef enum print_mode
symbol_public
};
-static const char *get_symbol_version_string
- (FILE *file, int is_dynsym, const char *strtab,
- unsigned long int strtab_size, unsigned int si,
- Elf_Internal_Sym *psym, enum versioned_symbol_info *sym_info,
- unsigned short *vna_other);
+static const char * get_symbol_version_string
+ (Filedata *, bfd_boolean, const char *, unsigned long, unsigned,
+ Elf_Internal_Sym *, enum versioned_symbol_info *, unsigned short *);
#define UNKNOWN -1
#define SECTION_NAME(X) \
((X) == NULL ? _("<none>") \
- : string_table == NULL ? _("<no-name>") \
- : ((X)->sh_name >= string_table_length ? _("<corrupt>") \
- : string_table + (X)->sh_name))
+ : filedata->string_table == NULL ? _("<no-strings>") \
+ : ((X)->sh_name >= filedata->string_table_length ? _("<corrupt>") \
+ : filedata->string_table + (X)->sh_name))
#define DT_VERSIONTAGIDX(tag) (DT_VERNEEDNUM - (tag)) /* Reverse order! */
#define REMOVE_ARCH_BITS(ADDR) \
do \
{ \
- if (elf_header.e_machine == EM_ARM) \
+ if (filedata->file_header.e_machine == EM_ARM) \
(ADDR) &= ~1; \
} \
while (0)
+
+/* Get the correct GNU hash section name. */
+#define GNU_HASH_SECTION_NAME \
+ dynamic_info_DT_MIPS_XHASH ? ".MIPS.xhash" : ".gnu.hash"
\f
-/* Retrieve NMEMB structures, each SIZE bytes long from FILE starting at OFFSET +
- the offset of the current archive member, if we are examining an archive.
- Put the retrieved data into VAR, if it is not NULL. Otherwise allocate a buffer
- using malloc and fill that. In either case return the pointer to the start of
- the retrieved data or NULL if something went wrong. If something does go wrong
- and REASON is not NULL then emit an error message using REASON as part of the
- context. */
+/* Print a BFD_VMA to an internal buffer, for use in error messages.
+ BFD_FMA_FMT can't be used in translated strings. */
+
+static const char *
+bfd_vmatoa (char *fmtch, bfd_vma value)
+{
+ /* bfd_vmatoa is used more then once in a printf call for output.
+ Cycle through an array of buffers. */
+ static int buf_pos = 0;
+ static struct bfd_vmatoa_buf
+ {
+ char place[64];
+ } buf[4];
+ char *ret;
+ char fmt[32];
+
+ ret = buf[buf_pos++].place;
+ buf_pos %= ARRAY_SIZE (buf);
+
+ sprintf (fmt, "%%%s%s", BFD_VMA_FMT, fmtch);
+ snprintf (ret, sizeof (buf[0].place), fmt, value);
+ return ret;
+}
+
+/* Retrieve NMEMB structures, each SIZE bytes long from FILEDATA starting at
+ OFFSET + the offset of the current archive member, if we are examining an
+ archive. Put the retrieved data into VAR, if it is not NULL. Otherwise
+ allocate a buffer using malloc and fill that. In either case return the
+ pointer to the start of the retrieved data or NULL if something went wrong.
+ If something does go wrong and REASON is not NULL then emit an error
+ message using REASON as part of the context. */
static void *
-get_data (void * var, FILE * file, unsigned long offset, bfd_size_type size,
- bfd_size_type nmemb, const char * reason)
+get_data (void * var,
+ Filedata * filedata,
+ unsigned long offset,
+ bfd_size_type size,
+ bfd_size_type nmemb,
+ const char * reason)
{
void * mvar;
bfd_size_type amt = size * nmemb;
/* If the size_t type is smaller than the bfd_size_type, eg because
you are building a 32-bit tool on a 64-bit host, then make sure
that when the sizes are cast to (size_t) no information is lost. */
- if (sizeof (size_t) < sizeof (bfd_size_type)
- && ( (bfd_size_type) ((size_t) size) != size
- || (bfd_size_type) ((size_t) nmemb) != nmemb))
+ if ((size_t) size != size
+ || (size_t) nmemb != nmemb
+ || (size_t) amt != amt)
{
if (reason)
- error (_("Size truncation prevents reading 0x%" BFD_VMA_FMT "x"
- " elements of size 0x%" BFD_VMA_FMT "x for %s\n"),
- nmemb, size, reason);
+ error (_("Size truncation prevents reading %s"
+ " elements of size %s for %s\n"),
+ bfd_vmatoa ("u", nmemb), bfd_vmatoa ("u", size), reason);
return NULL;
}
/* Check for size overflow. */
- if (amt < nmemb)
+ if (amt / size != nmemb || (size_t) amt + 1 == 0)
{
if (reason)
- error (_("Size overflow prevents reading 0x%" BFD_VMA_FMT "x"
- " elements of size 0x%" BFD_VMA_FMT "x for %s\n"),
- nmemb, size, reason);
+ error (_("Size overflow prevents reading %s"
+ " elements of size %s for %s\n"),
+ bfd_vmatoa ("u", nmemb), bfd_vmatoa ("u", size), reason);
return NULL;
}
- /* Be kind to memory chekers (eg valgrind, address sanitizer) by not
+ /* Be kind to memory checkers (eg valgrind, address sanitizer) by not
attempting to allocate memory when the read is bound to fail. */
- if (amt > current_file_size
- || offset + archive_file_offset + amt > current_file_size)
+ if (archive_file_offset > filedata->file_size
+ || offset > filedata->file_size - archive_file_offset
+ || amt > filedata->file_size - archive_file_offset - offset)
{
if (reason)
- error (_("Reading 0x%" BFD_VMA_FMT "x"
- " bytes extends past end of file for %s\n"),
- amt, reason);
+ error (_("Reading %s bytes extends past end of file for %s\n"),
+ bfd_vmatoa ("u", amt), reason);
return NULL;
}
- if (fseek (file, archive_file_offset + offset, SEEK_SET))
+ if (fseek (filedata->handle, archive_file_offset + offset, SEEK_SET))
{
if (reason)
error (_("Unable to seek to 0x%lx for %s\n"),
mvar = var;
if (mvar == NULL)
{
- /* Check for overflow. */
- if (nmemb < (~(bfd_size_type) 0 - 1) / size)
- /* + 1 so that we can '\0' terminate invalid string table sections. */
- mvar = malloc ((size_t) amt + 1);
+ /* + 1 so that we can '\0' terminate invalid string table sections. */
+ mvar = malloc ((size_t) amt + 1);
if (mvar == NULL)
{
if (reason)
- error (_("Out of memory allocating 0x%" BFD_VMA_FMT "x"
- " bytes for %s\n"),
- amt, reason);
+ error (_("Out of memory allocating %s bytes for %s\n"),
+ bfd_vmatoa ("u", amt), reason);
return NULL;
}
((char *) mvar)[amt] = '\0';
}
- if (fread (mvar, (size_t) size, (size_t) nmemb, file) != nmemb)
+ if (fread (mvar, (size_t) size, (size_t) nmemb, filedata->handle) != nmemb)
{
if (reason)
- error (_("Unable to read in 0x%" BFD_VMA_FMT "x bytes of %s\n"),
- amt, reason);
+ error (_("Unable to read in %s bytes of %s\n"),
+ bfd_vmatoa ("u", amt), reason);
if (mvar != var)
free (mvar);
return NULL;
return mvar;
}
-/* Print a VMA value. */
+/* Print a VMA value in the MODE specified.
+ Returns the number of characters displayed. */
-static int
+static unsigned int
print_vma (bfd_vma vma, print_mode mode)
{
- int nc = 0;
+ unsigned int nc = 0;
switch (mode)
{
case FULL_HEX:
nc = printf ("0x");
/* Fall through. */
-
case LONG_HEX:
#ifdef BFD64
if (is_32bit_elf)
if (vma <= 99999)
return printf ("%5" BFD_VMA_FMT "d", vma);
/* Fall through. */
-
case PREFIX_HEX:
nc = printf ("0x");
/* Fall through. */
-
case HEX:
return nc + printf ("%" BFD_VMA_FMT "x", vma);
case UNSIGNED:
return printf ("%" BFD_VMA_FMT "u", vma);
+
+ default:
+ /* FIXME: Report unrecognised mode ? */
+ return 0;
}
- return 0;
}
/* Display a symbol on stdout. Handles the display of control characters and
Returns the number of emitted characters. */
static unsigned int
-print_symbol (int width, const char *symbol)
+print_symbol (signed int width, const char *symbol)
{
bfd_boolean extra_padding = FALSE;
- int num_printed = 0;
+ signed int num_printed = 0;
#ifdef HAVE_MBSTATE_T
mbstate_t state;
#endif
- int width_remaining;
+ unsigned int width_remaining;
if (width < 0)
{
- /* Keep the width positive. This also helps. */
+ /* Keep the width positive. This helps the code below. */
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.
to print multibyte characters, it just interprets them as hex values. */
static const char *
-printable_section_name (const Elf_Internal_Shdr * sec)
+printable_section_name (Filedata * filedata, const Elf_Internal_Shdr * sec)
{
#define MAX_PRINT_SEC_NAME_LEN 128
static char sec_name_buf [MAX_PRINT_SEC_NAME_LEN + 1];
}
static const char *
-printable_section_name_from_index (unsigned long ndx)
+printable_section_name_from_index (Filedata * filedata, unsigned long ndx)
{
- if (ndx >= elf_header.e_shnum)
+ if (ndx >= filedata->file_header.e_shnum)
return _("<corrupt>");
- return printable_section_name (section_headers + ndx);
+ return printable_section_name (filedata, filedata->section_headers + ndx);
}
/* Return a pointer to section NAME, or NULL if no such section exists. */
static Elf_Internal_Shdr *
-find_section (const char * name)
+find_section (Filedata * filedata, const char * name)
{
unsigned int i;
- for (i = 0; i < elf_header.e_shnum; i++)
- if (streq (SECTION_NAME (section_headers + i), name))
- return section_headers + i;
+ 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))
+ return filedata->section_headers + i;
return NULL;
}
section exists. */
static Elf_Internal_Shdr *
-find_section_by_address (bfd_vma addr)
+find_section_by_address (Filedata * filedata, bfd_vma addr)
{
unsigned int i;
- for (i = 0; i < elf_header.e_shnum; i++)
+ if (filedata->section_headers == NULL)
+ return NULL;
+
+ for (i = 0; i < filedata->file_header.e_shnum; i++)
{
- Elf_Internal_Shdr *sec = section_headers + i;
+ Elf_Internal_Shdr *sec = filedata->section_headers + i;
+
if (addr >= sec->sh_addr && addr < sec->sh_addr + sec->sh_size)
return sec;
}
}
static Elf_Internal_Shdr *
-find_section_by_type (unsigned int type)
+find_section_by_type (Filedata * filedata, unsigned int type)
{
unsigned int i;
- for (i = 0; i < elf_header.e_shnum; i++)
+ if (filedata->section_headers == NULL)
+ return NULL;
+
+ for (i = 0; i < filedata->file_header.e_shnum; i++)
{
- Elf_Internal_Shdr *sec = section_headers + i;
+ Elf_Internal_Shdr *sec = filedata->section_headers + i;
+
if (sec->sh_type == type)
return sec;
}
restricted to the list of sections given in SET. */
static Elf_Internal_Shdr *
-find_section_in_set (const char * name, unsigned int * set)
+find_section_in_set (Filedata * filedata, const char * name, unsigned int * set)
{
unsigned int i;
+ if (filedata->section_headers == NULL)
+ return NULL;
+
if (set != NULL)
{
while ((i = *set++) > 0)
{
/* See PR 21156 for a reproducer. */
- if (i >= elf_header.e_shnum)
+ if (i >= filedata->file_header.e_shnum)
continue; /* FIXME: Should we issue an error message ? */
- if (streq (SECTION_NAME (section_headers + i), name))
- return section_headers + i;
+ if (streq (SECTION_NAME (filedata->section_headers + i), name))
+ return filedata->section_headers + i;
}
}
- return find_section (name);
-}
-
-/* Read an unsigned LEB128 encoded value from p. Set *PLEN to the number of
- bytes read. */
-
-static inline unsigned long
-read_uleb128 (unsigned char *data,
- unsigned int *length_return,
- const unsigned char * const end)
-{
- return read_leb128 (data, length_return, FALSE, end);
+ return find_section (filedata, name);
}
-/* Return true if the current file is for IA-64 machine and OpenVMS ABI.
+/* Return TRUE if the current file is for IA-64 machine and OpenVMS ABI.
This OS has so many departures from the ELF standard that we test it at
many places. */
-static inline int
-is_ia64_vms (void)
+static inline bfd_boolean
+is_ia64_vms (Filedata * filedata)
{
- return elf_header.e_machine == EM_IA_64
- && elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS;
+ return filedata->file_header.e_machine == EM_IA_64
+ && filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS;
}
/* Guess the relocation size commonly used by the specific machines. */
-static int
+static bfd_boolean
guess_is_rela (unsigned int e_machine)
{
switch (e_machine)
case EM_CYGNUS_M32R:
case EM_SCORE:
case EM_XGATE:
+ case EM_NFP:
+ case EM_BPF:
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:
case EM_XTENSA_OLD:
case EM_MICROBLAZE:
case EM_MICROBLAZE_OLD:
+ case EM_WEBASSEMBLY:
return TRUE;
case EM_68HC05:
}
}
-static int
-slurp_rela_relocs (FILE * file,
- unsigned long rel_offset,
- unsigned long rel_size,
- Elf_Internal_Rela ** relasp,
- unsigned long * nrelasp)
+/* Load RELA type relocations from FILEDATA at REL_OFFSET extending for REL_SIZE bytes.
+ Returns TRUE upon success, FALSE otherwise. If successful then a
+ pointer to a malloc'ed buffer containing the relocs is placed in *RELASP,
+ and the number of relocs loaded is placed in *NRELASP. It is the caller's
+ responsibility to free the allocated buffer. */
+
+static bfd_boolean
+slurp_rela_relocs (Filedata * filedata,
+ unsigned long rel_offset,
+ unsigned long rel_size,
+ Elf_Internal_Rela ** relasp,
+ unsigned long * nrelasp)
{
Elf_Internal_Rela * relas;
size_t nrelas;
{
Elf32_External_Rela * erelas;
- erelas = (Elf32_External_Rela *) get_data (NULL, file, rel_offset, 1,
+ erelas = (Elf32_External_Rela *) get_data (NULL, filedata, rel_offset, 1,
rel_size, _("32-bit relocation data"));
if (!erelas)
- return 0;
+ return FALSE;
nrelas = rel_size / sizeof (Elf32_External_Rela);
{
free (erelas);
error (_("out of memory parsing relocs\n"));
- return 0;
+ return FALSE;
}
for (i = 0; i < nrelas; i++)
{
Elf64_External_Rela * erelas;
- erelas = (Elf64_External_Rela *) get_data (NULL, file, rel_offset, 1,
+ erelas = (Elf64_External_Rela *) get_data (NULL, filedata, rel_offset, 1,
rel_size, _("64-bit relocation data"));
if (!erelas)
- return 0;
+ return FALSE;
nrelas = rel_size / sizeof (Elf64_External_Rela);
{
free (erelas);
error (_("out of memory parsing relocs\n"));
- return 0;
+ return FALSE;
}
for (i = 0; i < nrelas; i++)
warning. We know that if we do not have a 64 bit data
type that we will never execute this code anyway. */
#ifdef BFD64
- if (elf_header.e_machine == EM_MIPS
- && elf_header.e_ident[EI_DATA] != ELFDATA2MSB)
+ if (filedata->file_header.e_machine == EM_MIPS
+ && filedata->file_header.e_ident[EI_DATA] != ELFDATA2MSB)
{
/* In little-endian objects, r_info isn't really a
64-bit little-endian value: it has a 32-bit
free (erelas);
}
+
*relasp = relas;
*nrelasp = nrelas;
- return 1;
+ return TRUE;
}
-static int
-slurp_rel_relocs (FILE * file,
- unsigned long rel_offset,
- unsigned long rel_size,
- Elf_Internal_Rela ** relsp,
- unsigned long * nrelsp)
+/* Load REL type relocations from FILEDATA at REL_OFFSET extending for REL_SIZE bytes.
+ Returns TRUE upon success, FALSE otherwise. If successful then a
+ pointer to a malloc'ed buffer containing the relocs is placed in *RELSP,
+ and the number of relocs loaded is placed in *NRELSP. It is the caller's
+ responsibility to free the allocated buffer. */
+
+static bfd_boolean
+slurp_rel_relocs (Filedata * filedata,
+ unsigned long rel_offset,
+ unsigned long rel_size,
+ Elf_Internal_Rela ** relsp,
+ unsigned long * nrelsp)
{
Elf_Internal_Rela * rels;
size_t nrels;
{
Elf32_External_Rel * erels;
- erels = (Elf32_External_Rel *) get_data (NULL, file, rel_offset, 1,
+ erels = (Elf32_External_Rel *) get_data (NULL, filedata, rel_offset, 1,
rel_size, _("32-bit relocation data"));
if (!erels)
- return 0;
+ return FALSE;
nrels = rel_size / sizeof (Elf32_External_Rel);
{
free (erels);
error (_("out of memory parsing relocs\n"));
- return 0;
+ return FALSE;
}
for (i = 0; i < nrels; i++)
{
Elf64_External_Rel * erels;
- erels = (Elf64_External_Rel *) get_data (NULL, file, rel_offset, 1,
+ erels = (Elf64_External_Rel *) get_data (NULL, filedata, rel_offset, 1,
rel_size, _("64-bit relocation data"));
if (!erels)
- return 0;
+ return FALSE;
nrels = rel_size / sizeof (Elf64_External_Rel);
{
free (erels);
error (_("out of memory parsing relocs\n"));
- return 0;
+ return FALSE;
}
for (i = 0; i < nrels; i++)
warning. We know that if we do not have a 64 bit data
type that we will never execute this code anyway. */
#ifdef BFD64
- if (elf_header.e_machine == EM_MIPS
- && elf_header.e_ident[EI_DATA] != ELFDATA2MSB)
+ if (filedata->file_header.e_machine == EM_MIPS
+ && filedata->file_header.e_ident[EI_DATA] != ELFDATA2MSB)
{
/* In little-endian objects, r_info isn't really a
64-bit little-endian value: it has a 32-bit
free (erels);
}
+
*relsp = rels;
*nrelsp = nrels;
- return 1;
+ return TRUE;
}
/* Returns the reloc type extracted from the reloc info field. */
static unsigned int
-get_reloc_type (bfd_vma reloc_info)
+get_reloc_type (Filedata * filedata, bfd_vma reloc_info)
{
if (is_32bit_elf)
return ELF32_R_TYPE (reloc_info);
- switch (elf_header.e_machine)
+ switch (filedata->file_header.e_machine)
{
case EM_MIPS:
/* Note: We assume that reloc_info has already been adjusted for us. */
}
static inline bfd_boolean
-uses_msp430x_relocs (void)
+uses_msp430x_relocs (Filedata * filedata)
{
return
- elf_header.e_machine == EM_MSP430 /* Paranoia. */
+ filedata->file_header.e_machine == EM_MSP430 /* Paranoia. */
/* GCC uses osabi == ELFOSBI_STANDALONE. */
- && (((elf_header.e_flags & EF_MSP430_MACH) == E_MSP430_MACH_MSP430X)
+ && (((filedata->file_header.e_flags & EF_MSP430_MACH) == E_MSP430_MACH_MSP430X)
/* TI compiler uses ELFOSABI_NONE. */
- || (elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE));
+ || (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_NONE));
}
/* Display the contents of the relocation data found at the specified
offset. */
-static void
-dump_relocations (FILE * file,
- unsigned long rel_offset,
- unsigned long rel_size,
- Elf_Internal_Sym * symtab,
- unsigned long nsyms,
- char * strtab,
- unsigned long strtablen,
- int is_rela,
- int is_dynsym)
+static bfd_boolean
+dump_relocations (Filedata * filedata,
+ unsigned long rel_offset,
+ unsigned long rel_size,
+ Elf_Internal_Sym * symtab,
+ unsigned long nsyms,
+ char * strtab,
+ unsigned long strtablen,
+ int is_rela,
+ bfd_boolean is_dynsym)
{
- unsigned int i;
+ unsigned long i;
Elf_Internal_Rela * rels;
+ bfd_boolean res = TRUE;
if (is_rela == UNKNOWN)
- is_rela = guess_is_rela (elf_header.e_machine);
+ is_rela = guess_is_rela (filedata->file_header.e_machine);
if (is_rela)
{
- if (!slurp_rela_relocs (file, rel_offset, rel_size, &rels, &rel_size))
- return;
+ if (!slurp_rela_relocs (filedata, rel_offset, rel_size, &rels, &rel_size))
+ return FALSE;
}
else
{
- if (!slurp_rel_relocs (file, rel_offset, rel_size, &rels, &rel_size))
- return;
+ if (!slurp_rel_relocs (filedata, rel_offset, rel_size, &rels, &rel_size))
+ return FALSE;
}
if (is_32bit_elf)
offset = rels[i].r_offset;
inf = rels[i].r_info;
- type = get_reloc_type (inf);
+ type = get_reloc_type (filedata, inf);
symtab_index = get_reloc_symindex (inf);
if (is_32bit_elf)
#endif
}
- switch (elf_header.e_machine)
+ switch (filedata->file_header.e_machine)
{
default:
rtype = NULL;
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;
break;
case EM_MSP430:
- if (uses_msp430x_relocs ())
+ if (uses_msp430x_relocs (filedata))
{
rtype = elf_msp430x_reloc_type (type);
break;
rtype = elf_visium_reloc_type (type);
break;
+ case EM_BPF:
+ rtype = elf_bpf_reloc_type (type);
+ break;
+
case EM_ADAPTEVA_EPIPHANY:
rtype = elf_epiphany_reloc_type (type);
break;
rtype = elf_tilepro_reloc_type (type);
break;
+ case EM_WEBASSEMBLY:
+ rtype = elf_wasm32_reloc_type (type);
+ break;
+
case EM_XGATE:
rtype = elf_xgate_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;
+
+ case EM_Z80:
+ rtype = elf_z80_reloc_type (type);
+ break;
}
if (rtype == NULL)
printf (_("unrecognized: %-7lx"), (unsigned long) type & 0xffffffff);
else
- printf (do_wide ? "%-22.22s" : "%-17.17s", rtype);
+ printf (do_wide ? "%-22s" : "%-17.17s", rtype);
- if (elf_header.e_machine == EM_ALPHA
+ if (filedata->file_header.e_machine == EM_ALPHA
&& rtype != NULL
&& streq (rtype, "R_ALPHA_LITUSE")
&& is_rela)
case LITUSE_ALPHA_JSRDIRECT: rtype = "JSRDIRECT"; break;
default: rtype = NULL;
}
+
if (rtype)
printf (" (%s)", rtype);
else
putchar (' ');
printf (_("<unknown addend: %lx>"),
(unsigned long) rels[i].r_addend);
+ res = FALSE;
}
}
else if (symtab_index)
{
if (symtab == NULL || symtab_index >= nsyms)
- printf (_(" bad symbol index: %08lx"), (unsigned long) symtab_index);
+ {
+ error (_(" bad symbol index: %08lx in reloc"), (unsigned long) symtab_index);
+ res = FALSE;
+ }
else
{
Elf_Internal_Sym * psym;
psym = symtab + symtab_index;
version_string
- = get_symbol_version_string (file, is_dynsym,
+ = get_symbol_version_string (filedata, is_dynsym,
strtab, strtablen,
symtab_index,
psym,
if (ELF_ST_TYPE (psym->st_info) == STT_SECTION)
{
- if (psym->st_shndx < elf_header.e_shnum)
- sec_name = SECTION_NAME (section_headers + psym->st_shndx);
+ if (psym->st_shndx < filedata->file_header.e_shnum)
+ sec_name = SECTION_NAME (filedata->section_headers + psym->st_shndx);
else if (psym->st_shndx == SHN_ABS)
sec_name = "ABS";
else if (psym->st_shndx == SHN_COMMON)
sec_name = "COMMON";
- else if ((elf_header.e_machine == EM_MIPS
+ else if ((filedata->file_header.e_machine == EM_MIPS
&& psym->st_shndx == SHN_MIPS_SCOMMON)
- || (elf_header.e_machine == EM_TI_C6000
+ || (filedata->file_header.e_machine == EM_TI_C6000
&& psym->st_shndx == SHN_TIC6X_SCOMMON))
sec_name = "SCOMMON";
- else if (elf_header.e_machine == EM_MIPS
+ else if (filedata->file_header.e_machine == EM_MIPS
&& psym->st_shndx == SHN_MIPS_SUNDEFINED)
sec_name = "SUNDEF";
- else if ((elf_header.e_machine == EM_X86_64
- || elf_header.e_machine == EM_L1OM
- || elf_header.e_machine == EM_K1OM)
+ else if ((filedata->file_header.e_machine == EM_X86_64
+ || filedata->file_header.e_machine == EM_L1OM
+ || filedata->file_header.e_machine == EM_K1OM)
&& psym->st_shndx == SHN_X86_64_LCOMMON)
sec_name = "LARGE_COMMON";
- else if (elf_header.e_machine == EM_IA_64
- && elf_header.e_ident[EI_OSABI] == ELFOSABI_HPUX
+ else if (filedata->file_header.e_machine == EM_IA_64
+ && filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_HPUX
&& psym->st_shndx == SHN_IA_64_ANSI_COMMON)
sec_name = "ANSI_COM";
- else if (is_ia64_vms ()
+ else if (is_ia64_vms (filedata)
&& psym->st_shndx == SHN_IA_64_VMS_SYMVEC)
sec_name = "VMS_SYMVEC";
else
else if (strtab == NULL)
printf (_("<string table index: %3ld>"), psym->st_name);
else if (psym->st_name >= strtablen)
- printf (_("<corrupt string table index: %3ld>"), psym->st_name);
+ {
+ error (_("<corrupt string table index: %3ld>"), psym->st_name);
+ res = FALSE;
+ }
else
{
print_symbol (22, strtab + psym->st_name);
printf ("%" BFD_VMA_FMT "x", off);
}
- if (elf_header.e_machine == EM_SPARCV9
+ if (filedata->file_header.e_machine == EM_SPARCV9
&& rtype != NULL
&& streq (rtype, "R_SPARC_OLO10"))
printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (inf));
putchar ('\n');
#ifdef BFD64
- if (! is_32bit_elf && elf_header.e_machine == EM_MIPS)
+ if (! is_32bit_elf && filedata->file_header.e_machine == EM_MIPS)
{
bfd_vma type2 = ELF64_MIPS_R_TYPE2 (inf);
bfd_vma type3 = ELF64_MIPS_R_TYPE3 (inf);
}
free (rels);
+
+ return res;
+}
+
+static const char *
+get_aarch64_dynamic_type (unsigned long type)
+{
+ switch (type)
+ {
+ case DT_AARCH64_BTI_PLT: return "AARCH64_BTI_PLT";
+ case DT_AARCH64_PAC_PLT: return "AARCH64_PAC_PLT";
+ case DT_AARCH64_VARIANT_PCS: return "AARCH64_VARIANT_PCS";
+ default:
+ return NULL;
+ }
}
static const char *
case DT_MIPS_AUX_DYNAMIC: return "MIPS_AUX_DYNAMIC";
case DT_MIPS_PLTGOT: return "MIPS_PLTGOT";
case DT_MIPS_RWPLT: return "MIPS_RWPLT";
+ case DT_MIPS_XHASH: return "MIPS_XHASH";
default:
return NULL;
}
switch (type)
{
case DT_ALPHA_PLTRO: return "ALPHA_PLTRO";
- default:
- return NULL;
+ default: return NULL;
}
}
case DT_SCORE_GOTSYM: return "SCORE_GOTSYM";
case DT_SCORE_UNREFEXTNO: return "SCORE_UNREFEXTNO";
case DT_SCORE_HIPAGENO: return "SCORE_HIPAGENO";
- default:
- return NULL;
+ default: return NULL;
}
}
case DT_C6000_DSBT_SIZE: return "C6000_DSBT_SIZE";
case DT_C6000_PREEMPTMAP: return "C6000_PREEMPTMAP";
case DT_C6000_DSBT_INDEX: return "C6000_DSBT_INDEX";
- default:
- return NULL;
+ default: return NULL;
}
}
switch (type)
{
case DT_NIOS2_GP: return "NIOS2_GP";
- default:
- return NULL;
+ default: return NULL;
}
}
}
static const char *
-get_dynamic_type (unsigned long type)
+get_dynamic_type (Filedata * filedata, unsigned long type)
{
static char buff[64];
{
const char * result;
- switch (elf_header.e_machine)
+ switch (filedata->file_header.e_machine)
{
+ case EM_AARCH64:
+ result = get_aarch64_dynamic_type (type);
+ break;
case EM_MIPS:
case EM_MIPS_RS3_LE:
result = get_mips_dynamic_type (type);
result = get_nios2_dynamic_type (type);
break;
default:
- if (elf_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
+ if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
result = get_solaris_dynamic_type (type);
else
result = NULL;
snprintf (buff, sizeof (buff), _("Processor Specific: %lx"), type);
}
else if (((type >= DT_LOOS) && (type <= DT_HIOS))
- || (elf_header.e_machine == EM_PARISC
+ || (filedata->file_header.e_machine == EM_PARISC
&& (type >= OLD_DT_LOOS) && (type <= OLD_DT_HIOS)))
{
const char * result;
- switch (elf_header.e_machine)
+ switch (filedata->file_header.e_machine)
{
case EM_PARISC:
result = get_parisc_dynamic_type (type);
result = get_ia64_dynamic_type (type);
break;
default:
- if (elf_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
+ if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
result = get_solaris_dynamic_type (type);
else
result = NULL;
switch (e_type)
{
- case ET_NONE: return _("NONE (None)");
- case ET_REL: return _("REL (Relocatable file)");
- case ET_EXEC: return _("EXEC (Executable file)");
- case ET_DYN: return _("DYN (Shared object file)");
- case ET_CORE: return _("CORE (Core file)");
+ case ET_NONE: return _("NONE (None)");
+ case ET_REL: return _("REL (Relocatable file)");
+ case ET_EXEC: return _("EXEC (Executable file)");
+ case ET_DYN: return _("DYN (Shared object file)");
+ case ET_CORE: return _("CORE (Core file)");
default:
if ((e_type >= ET_LOPROC) && (e_type <= ET_HIPROC))
switch (e_machine)
{
+ /* Please keep this switch table sorted by increasing EM_ value. */
+ /* 0 */
case EM_NONE: return _("None");
- case EM_AARCH64: return "AArch64";
case EM_M32: return "WE32100";
case EM_SPARC: return "Sparc";
- case EM_SPU: return "SPU";
case EM_386: return "Intel 80386";
case EM_68K: return "MC68000";
case EM_88K: return "MC88000";
case EM_860: return "Intel 80860";
case EM_MIPS: return "MIPS R3000";
case EM_S370: return "IBM System/370";
+ /* 10 */
case EM_MIPS_RS3_LE: return "MIPS R4000 big-endian";
case EM_OLD_SPARCV9: return "Sparc v9 (old)";
case EM_PARISC: return "HPPA";
- case EM_PPC_OLD: return "Power PC (old)";
+ case EM_VPP550: return "Fujitsu VPP500";
case EM_SPARC32PLUS: return "Sparc v8+" ;
- case EM_960: return "Intel 90860";
+ case EM_960: return "Intel 80960";
case EM_PPC: return "PowerPC";
+ /* 20 */
case EM_PPC64: return "PowerPC64";
+ case EM_S390_OLD:
+ case EM_S390: return "IBM S/390";
+ case EM_SPU: return "SPU";
+ /* 30 */
+ case EM_V800: return "Renesas V850 (using RH850 ABI)";
case EM_FR20: return "Fujitsu FR20";
- case EM_FT32: return "FTDI FT32";
case EM_RH32: return "TRW RH32";
case EM_MCORE: return "MCORE";
+ /* 40 */
case EM_ARM: return "ARM";
case EM_OLD_ALPHA: return "Digital Alpha (old)";
case EM_SH: return "Renesas / SuperH SH";
case EM_SPARCV9: return "Sparc v9";
case EM_TRICORE: return "Siemens Tricore";
case EM_ARC: return "ARC";
- case EM_ARC_COMPACT: return "ARCompact";
- case EM_ARC_COMPACT2: return "ARCv2";
case EM_H8_300: return "Renesas H8/300";
case EM_H8_300H: return "Renesas H8/300H";
case EM_H8S: return "Renesas H8S";
case EM_H8_500: return "Renesas H8/500";
+ /* 50 */
case EM_IA_64: return "Intel IA-64";
case EM_MIPS_X: return "Stanford MIPS-X";
case EM_COLDFIRE: return "Motorola Coldfire";
- case EM_ALPHA: return "Alpha";
- case EM_CYGNUS_D10V:
- case EM_D10V: return "d10v";
- case EM_CYGNUS_D30V:
- case EM_D30V: return "d30v";
- case EM_CYGNUS_M32R:
- case EM_M32R: return "Renesas M32R (formerly Mitsubishi M32r)";
- case EM_CYGNUS_V850:
- case EM_V800: return "Renesas V850 (using RH850 ABI)";
- case EM_V850: return "Renesas V850";
- case EM_CYGNUS_MN10300:
- case EM_MN10300: return "mn10300";
- case EM_CYGNUS_MN10200:
- case EM_MN10200: return "mn10200";
- case EM_MOXIE: return "Moxie";
- case EM_CYGNUS_FR30:
- case EM_FR30: return "Fujitsu FR30";
- case EM_CYGNUS_FRV: return "Fujitsu FR-V";
- case EM_PJ_OLD:
- case EM_PJ: return "picoJava";
+ case EM_68HC12: return "Motorola MC68HC12 Microcontroller";
case EM_MMA: return "Fujitsu Multimedia Accelerator";
case EM_PCP: return "Siemens PCP";
case EM_NCPU: return "Sony nCPU embedded RISC processor";
case EM_NDR1: return "Denso NDR1 microprocesspr";
case EM_STARCORE: return "Motorola Star*Core processor";
case EM_ME16: return "Toyota ME16 processor";
+ /* 60 */
case EM_ST100: return "STMicroelectronics ST100 processor";
case EM_TINYJ: return "Advanced Logic Corp. TinyJ embedded processor";
+ case EM_X86_64: return "Advanced Micro Devices X86-64";
case EM_PDSP: return "Sony DSP processor";
case EM_PDP10: return "Digital Equipment Corp. PDP-10";
case EM_PDP11: return "Digital Equipment Corp. PDP-11";
case EM_ST9PLUS: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
case EM_ST7: return "STMicroelectronics ST7 8-bit microcontroller";
case EM_68HC16: return "Motorola MC68HC16 Microcontroller";
- case EM_68HC12: return "Motorola MC68HC12 Microcontroller";
+ /* 70 */
case EM_68HC11: return "Motorola MC68HC11 Microcontroller";
case EM_68HC08: return "Motorola MC68HC08 Microcontroller";
case EM_68HC05: return "Motorola MC68HC05 Microcontroller";
case EM_SVX: return "Silicon Graphics SVx";
case EM_ST19: return "STMicroelectronics ST19 8-bit microcontroller";
case EM_VAX: return "Digital VAX";
- case EM_VISIUM: return "CDS VISIUMcore processor";
- case EM_AVR_OLD:
- case EM_AVR: return "Atmel AVR 8-bit microcontroller";
case EM_CRIS: return "Axis Communications 32-bit embedded processor";
case EM_JAVELIN: return "Infineon Technologies 32-bit embedded cpu";
case EM_FIREPATH: return "Element 14 64-bit DSP processor";
case EM_ZSP: return "LSI Logic's 16-bit DSP processor";
+ /* 80 */
case EM_MMIX: return "Donald Knuth's educational 64-bit processor";
case EM_HUANY: return "Harvard Universitys's machine-independent object format";
case EM_PRISM: return "Vitesse Prism";
- case EM_X86_64: return "Advanced Micro Devices X86-64";
- case EM_L1OM: return "Intel L1OM";
- case EM_K1OM: return "Intel K1OM";
- case EM_S390_OLD:
- case EM_S390: return "IBM S/390";
- case EM_SCORE: return "SUNPLUS S+Core";
- case EM_XSTORMY16: return "Sanyo XStormy16 CPU core";
+ case EM_AVR_OLD:
+ case EM_AVR: return "Atmel AVR 8-bit microcontroller";
+ case EM_CYGNUS_FR30:
+ case EM_FR30: return "Fujitsu FR30";
+ case EM_CYGNUS_D10V:
+ case EM_D10V: return "d10v";
+ case EM_CYGNUS_D30V:
+ case EM_D30V: return "d30v";
+ case EM_CYGNUS_V850:
+ case EM_V850: return "Renesas V850";
+ case EM_CYGNUS_M32R:
+ case EM_M32R: return "Renesas M32R (formerly Mitsubishi M32r)";
+ case EM_CYGNUS_MN10300:
+ case EM_MN10300: return "mn10300";
+ /* 90 */
+ case EM_CYGNUS_MN10200:
+ case EM_MN10200: return "mn10200";
+ case EM_PJ: return "picoJava";
case EM_OR1K: return "OpenRISC 1000";
- case EM_CRX: return "National Semiconductor CRX microprocessor";
- case EM_ADAPTEVA_EPIPHANY: return "Adapteva EPIPHANY";
- case EM_DLX: return "OpenDLX";
- case EM_IP2K_OLD:
- case EM_IP2K: return "Ubicom IP2xxx 8-bit microcontrollers";
- case EM_IQ2000: return "Vitesse IQ2000";
+ case EM_ARC_COMPACT: return "ARCompact";
case EM_XTENSA_OLD:
case EM_XTENSA: return "Tensilica Xtensa Processor";
case EM_VIDEOCORE: return "Alphamosaic VideoCore processor";
case EM_TMM_GPP: return "Thompson Multimedia General Purpose Processor";
case EM_NS32K: return "National Semiconductor 32000 series";
case EM_TPC: return "Tenor Network TPC processor";
+ case EM_SNP1K: return "Trebia SNP 1000 processor";
+ /* 100 */
case EM_ST200: return "STMicroelectronics ST200 microcontroller";
+ case EM_IP2K_OLD:
+ case EM_IP2K: return "Ubicom IP2xxx 8-bit microcontrollers";
case EM_MAX: return "MAX Processor";
case EM_CR: return "National Semiconductor CompactRISC";
case EM_F2MC16: return "Fujitsu F2MC16";
case EM_MSP430: return "Texas Instruments msp430 microcontroller";
- case EM_LATTICEMICO32: return "Lattice Mico32";
- case EM_M32C_OLD:
- case EM_M32C: return "Renesas M32c";
- case EM_MT: return "Morpho Techologies MT processor";
case EM_BLACKFIN: return "Analog Devices Blackfin";
case EM_SE_C33: return "S1C33 Family of Seiko Epson processors";
case EM_SEP: return "Sharp embedded microprocessor";
case EM_ARCA: return "Arca RISC microprocessor";
+ /* 110 */
case EM_UNICORE: return "Unicore";
case EM_EXCESS: return "eXcess 16/32/64-bit configurable embedded CPU";
case EM_DXP: return "Icera Semiconductor Inc. Deep Execution Processor";
- case EM_NIOS32: return "Altera Nios";
case EM_ALTERA_NIOS2: return "Altera Nios II";
+ case EM_CRX: return "National Semiconductor CRX microprocessor";
+ case EM_XGATE: return "Motorola XGATE embedded processor";
case EM_C166:
case EM_XC16X: return "Infineon Technologies xc16x";
case EM_M16C: return "Renesas M16C series microprocessors";
case EM_DSPIC30F: return "Microchip Technology dsPIC30F Digital Signal Controller";
case EM_CE: return "Freescale Communication Engine RISC core";
+ /* 120 */
+ case EM_M32C: return "Renesas M32c";
+ /* 130 */
case EM_TSK3000: return "Altium TSK3000 core";
case EM_RS08: return "Freescale RS08 embedded processor";
case EM_ECOG2: return "Cyan Technology eCOG2 microprocessor";
+ case EM_SCORE: return "SUNPLUS S+Core";
case EM_DSP24: return "New Japan Radio (NJR) 24-bit DSP Processor";
case EM_VIDEOCORE3: return "Broadcom VideoCore III processor";
+ case EM_LATTICEMICO32: return "Lattice Mico32";
case EM_SE_C17: return "Seiko Epson C17 family";
+ /* 140 */
case EM_TI_C6000: return "Texas Instruments TMS320C6000 DSP family";
case EM_TI_C2000: return "Texas Instruments TMS320C2000 DSP family";
case EM_TI_C5500: return "Texas Instruments TMS320C55x DSP family";
+ case EM_TI_PRU: return "TI PRU I/O processor";
+ /* 160 */
case EM_MMDSP_PLUS: return "STMicroelectronics 64bit VLIW Data Signal Processor";
case EM_CYPRESS_M8C: return "Cypress M8C microprocessor";
case EM_R32C: return "Renesas R32C series microprocessors";
case EM_NDS32: return "Andes Technology compact code size embedded RISC processor family";
case EM_ECOG1X: return "Cyan Technology eCOG1X family";
case EM_MAXQ30: return "Dallas Semiconductor MAXQ30 Core microcontrollers";
+ /* 170 */
case EM_XIMO16: return "New Japan Radio (NJR) 16-bit DSP Processor";
case EM_MANIK: return "M2000 Reconfigurable RISC Microprocessor";
case EM_CRAYNV2: return "Cray Inc. NV2 vector architecture";
- case EM_CYGNUS_MEP: return "Toshiba MeP Media Engine";
- case EM_CR16:
- case EM_MICROBLAZE:
- case EM_MICROBLAZE_OLD: return "Xilinx MicroBlaze";
- case EM_RISCV: return "RISC-V";
- case EM_RL78: return "Renesas RL78";
case EM_RX: return "Renesas RX";
case EM_METAG: return "Imagination Technologies Meta processor architecture";
case EM_MCST_ELBRUS: return "MCST Elbrus general purpose hardware architecture";
case EM_ECOG16: return "Cyan Technology eCOG16 family";
+ case EM_CR16:
+ case EM_MICROBLAZE:
+ case EM_MICROBLAZE_OLD: return "Xilinx MicroBlaze";
case EM_ETPU: return "Freescale Extended Time Processing Unit";
case EM_SLE9X: return "Infineon Technologies SLE9X core";
- case EM_AVR32: return "Atmel Corporation 32-bit microprocessor family";
+ /* 180 */
+ case EM_L1OM: return "Intel L1OM";
+ case EM_K1OM: return "Intel K1OM";
+ case EM_INTEL182: return "Intel (reserved)";
+ case EM_AARCH64: return "AArch64";
+ case EM_ARM184: return "ARM (reserved)";
+ case EM_AVR32: return "Atmel Corporation 32-bit microprocessor";
case EM_STM8: return "STMicroeletronics STM8 8-bit microcontroller";
case EM_TILE64: return "Tilera TILE64 multicore architecture family";
case EM_TILEPRO: return "Tilera TILEPro multicore architecture family";
- case EM_TILEGX: return "Tilera TILE-Gx multicore architecture family";
+ /* 190 */
case EM_CUDA: return "NVIDIA CUDA architecture";
- case EM_XGATE: return "Motorola XGATE embedded processor";
+ case EM_TILEGX: return "Tilera TILE-Gx multicore architecture family";
case EM_CLOUDSHIELD: return "CloudShield architecture family";
case EM_COREA_1ST: return "KIPO-KAIST Core-A 1st generation processor family";
case EM_COREA_2ND: return "KIPO-KAIST Core-A 2nd generation processor family";
+ case EM_ARC_COMPACT2: return "ARCv2";
case EM_OPEN8: return "Open8 8-bit RISC soft processor core";
+ case EM_RL78: return "Renesas RL78";
case EM_VIDEOCORE5: return "Broadcom VideoCore V processor";
+ case EM_78K0R: return "Renesas 78K0R";
+ /* 200 */
case EM_56800EX: return "Freescale 56800EX Digital Signal Controller (DSC)";
case EM_BA1: return "Beyond BA1 CPU architecture";
case EM_BA2: return "Beyond BA2 CPU architecture";
case EM_XCORE: return "XMOS xCORE processor family";
case EM_MCHP_PIC: return "Microchip 8-bit PIC(r) family";
+ /* 210 */
case EM_KM32: return "KM211 KM32 32-bit processor";
case EM_KMX32: return "KM211 KMX32 32-bit processor";
case EM_KMX16: return "KM211 KMX16 16-bit processor";
case EM_COOL: return "Bluechip Systems CoolEngine";
case EM_NORC: return "Nanoradio Optimized RISC";
case EM_CSR_KALIMBA: return "CSR Kalimba architecture family";
+ /* 220 */
case EM_Z80: return "Zilog Z80";
- case EM_AMDGPU: return "AMD GPU architecture";
- case EM_TI_PRU: return "TI PRU I/O processor";
+ case EM_VISIUM: return "CDS VISIUMcore processor";
+ case EM_FT32: return "FTDI Chip FT32";
+ case EM_MOXIE: return "Moxie";
+ case EM_AMDGPU: return "AMD GPU";
+ case EM_RISCV: return "RISC-V";
+ case EM_LANAI: return "Lanai 32-bit processor";
+ case EM_BPF: return "Linux BPF";
+ case EM_NFP: return "Netronome Flow Processor";
+
+ /* Large numbers... */
+ case EM_MT: return "Morpho Techologies MT processor";
+ case EM_ALPHA: return "Alpha";
+ case EM_WEBASSEMBLY: return "Web Assembly";
+ case EM_DLX: return "OpenDLX";
+ case EM_XSTORMY16: return "Sanyo XStormy16 CPU core";
+ case EM_IQ2000: return "Vitesse IQ2000";
+ case EM_M32C_OLD:
+ case EM_NIOS32: return "Altera Nios";
+ case EM_CYGNUS_MEP: return "Toshiba MeP Media Engine";
+ case EM_ADAPTEVA_EPIPHANY: return "Adapteva EPIPHANY";
+ case EM_CYGNUS_FRV: return "Fujitsu FR-V";
+ case EM_S12Z: return "Freescale S12Z";
+ case EM_CSKY: return "C-SKY";
+
default:
snprintf (buff, sizeof (buff), _("<unknown>: 0x%x"), e_machine);
return buff;
case E_ARC_OSABI_V3:
strcat (buf, ", v3 no-legacy-syscalls ABI");
break;
+ case E_ARC_OSABI_V4:
+ strcat (buf, ", v4 ABI");
+ break;
default:
strcat (buf, ", unrecognised ARC OSABI flag");
break;
decode_ARM_machine_flags (unsigned e_flags, char buf[])
{
unsigned eabi;
- int unknown = 0;
+ bfd_boolean unknown = FALSE;
eabi = EF_ARM_EABI_VERSION (e_flags);
e_flags &= ~ EF_ARM_EABIMASK;
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)
{
default:
strcat (buf, ", <unrecognized EABI>");
if (e_flags)
- unknown = 1;
+ unknown = TRUE;
break;
case EF_ARM_EABI_VER1:
break;
default:
- unknown = 1;
+ unknown = TRUE;
break;
}
}
break;
default:
- unknown = 1;
+ unknown = TRUE;
break;
}
}
break;
default:
- unknown = 1;
+ unknown = TRUE;
break;
}
- break;
}
break;
break;
default:
- unknown = 1;
+ unknown = TRUE;
break;
}
}
break;
default:
- unknown = 1;
+ unknown = TRUE;
break;
}
}
unsigned arch;
unsigned config;
unsigned version;
- int has_fpu = 0;
- int r = 0;
+ bfd_boolean has_fpu = FALSE;
+ unsigned int r = 0;
static const char *ABI_STRINGS[] =
{
if (config & E_NDS32_HAS_FPU_INST)
{
- has_fpu = 1;
+ has_fpu = TRUE;
r += snprintf (buf + r, size -r, ", FPU_SP");
}
if (config & E_NDS32_HAS_FPU_DP_INST)
{
- has_fpu = 1;
+ has_fpu = TRUE;
r += snprintf (buf + r, size -r, ", FPU_DP");
}
if (config & E_NDS32_HAS_FPU_MAC_INST)
{
- has_fpu = 1;
+ has_fpu = TRUE;
r += snprintf (buf + r, size -r, ", FPU_MAC");
}
}
static char *
-get_machine_flags (unsigned e_flags, unsigned e_machine)
+get_machine_flags (Filedata * filedata, unsigned e_flags, unsigned e_machine)
{
static char buf[1024];
case E_MIPS_MACH_4650: strcat (buf, ", 4650"); break;
case E_MIPS_MACH_5400: strcat (buf, ", 5400"); break;
case E_MIPS_MACH_5500: strcat (buf, ", 5500"); break;
+ case E_MIPS_MACH_5900: strcat (buf, ", 5900"); break;
case E_MIPS_MACH_SB1: strcat (buf, ", sb1"); 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_GS464: strcat (buf, ", gs464"); break;
+ case E_MIPS_MACH_GS464E: strcat (buf, ", gs464e"); break;
+ case E_MIPS_MACH_GS264E: strcat (buf, ", gs264e"); break;
case E_MIPS_MACH_OCTEON: strcat (buf, ", octeon"); break;
case E_MIPS_MACH_OCTEON2: strcat (buf, ", octeon2"); break;
case E_MIPS_MACH_OCTEON3: strcat (buf, ", octeon3"); break;
case E_MIPS_MACH_XLR: strcat (buf, ", xlr"); break;
+ case E_MIPS_MACH_IAMR2: strcat (buf, ", interaptiv-mr2"); break;
case 0:
/* We simply ignore the field in this case to avoid confusion:
MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
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:
strcat (buf, ", constant gp");
if ((e_flags & EF_IA_64_ABSOLUTE))
strcat (buf, ", absolute");
- if (elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
+ if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
{
if ((e_flags & EF_IA_64_VMS_LINKAGES))
strcat (buf, ", vms_linkages");
? ", uses String instructions" : ", bans String instructions");
if (e_flags & E_FLAG_RX_V2)
strcat (buf, ", V2");
+ if (e_flags & E_FLAG_RX_V3)
+ strcat (buf, ", V3");
break;
case EM_S390:
if (e_flags & ~ EF_MSP430_MACH)
strcat (buf, _(": unknown extra flag bits also present"));
+ break;
+
+ case EM_Z80:
+ switch (e_flags & EF_Z80_MACH_MSK)
+ {
+ case EF_Z80_MACH_Z80: strcat (buf, ", Z80"); break;
+ case EF_Z80_MACH_Z180: strcat (buf, ", Z180"); break;
+ case EF_Z80_MACH_R800: strcat (buf, ", R800"); break;
+ case EF_Z80_MACH_EZ80_Z80: strcat (buf, ", EZ80"); break;
+ case EF_Z80_MACH_EZ80_ADL: strcat (buf, ", EZ80, ADL"); break;
+ case EF_Z80_MACH_GBZ80: strcat (buf, ", GBZ80"); break;
+ default:
+ strcat (buf, _(", unknown")); break;
+ }
+ break;
}
}
}
static const char *
-get_osabi_name (unsigned int osabi)
+get_osabi_name (Filedata * filedata, unsigned int osabi)
{
static char buff[32];
case ELFOSABI_OPENVOS: return "Stratus Technologies OpenVOS";
default:
if (osabi >= 64)
- switch (elf_header.e_machine)
+ switch (filedata->file_header.e_machine)
{
case EM_ARM:
switch (osabi)
{
case ELFOSABI_ARM: return "ARM";
+ case ELFOSABI_ARM_FDPIC: return "ARM FDPIC";
default:
break;
}
{
switch (type)
{
- case PT_AARCH64_ARCHEXT:
- return "AARCH64_ARCHEXT";
- default:
- break;
+ case PT_AARCH64_ARCHEXT: return "AARCH64_ARCHEXT";
+ default: return NULL;
}
-
- return NULL;
}
static const char *
{
switch (type)
{
- case PT_ARM_EXIDX:
- return "EXIDX";
- default:
- break;
+ case PT_ARM_EXIDX: return "EXIDX";
+ default: return NULL;
}
+}
- return NULL;
+static const char *
+get_s390_segment_type (unsigned long type)
+{
+ switch (type)
+ {
+ case PT_S390_PGSTE: return "S390_PGSTE";
+ default: return NULL;
+ }
}
static const char *
{
switch (type)
{
- case PT_MIPS_REGINFO:
- return "REGINFO";
- case PT_MIPS_RTPROC:
- return "RTPROC";
- case PT_MIPS_OPTIONS:
- return "OPTIONS";
- case PT_MIPS_ABIFLAGS:
- return "ABIFLAGS";
- default:
- break;
+ case PT_MIPS_REGINFO: return "REGINFO";
+ case PT_MIPS_RTPROC: return "RTPROC";
+ case PT_MIPS_OPTIONS: return "OPTIONS";
+ case PT_MIPS_ABIFLAGS: return "ABIFLAGS";
+ default: return NULL;
}
-
- return NULL;
}
static const char *
{
switch (type)
{
- case PT_HP_TLS: return "HP_TLS";
- case PT_HP_CORE_NONE: return "HP_CORE_NONE";
- case PT_HP_CORE_VERSION: return "HP_CORE_VERSION";
- case PT_HP_CORE_KERNEL: return "HP_CORE_KERNEL";
- case PT_HP_CORE_COMM: return "HP_CORE_COMM";
- case PT_HP_CORE_PROC: return "HP_CORE_PROC";
- case PT_HP_CORE_LOADABLE: return "HP_CORE_LOADABLE";
- case PT_HP_CORE_STACK: return "HP_CORE_STACK";
- case PT_HP_CORE_SHM: return "HP_CORE_SHM";
- case PT_HP_CORE_MMF: return "HP_CORE_MMF";
- case PT_HP_PARALLEL: return "HP_PARALLEL";
- case PT_HP_FASTBIND: return "HP_FASTBIND";
- case PT_HP_OPT_ANNOT: return "HP_OPT_ANNOT";
- case PT_HP_HSL_ANNOT: return "HP_HSL_ANNOT";
- case PT_HP_STACK: return "HP_STACK";
- case PT_HP_CORE_UTSNAME: return "HP_CORE_UTSNAME";
case PT_PARISC_ARCHEXT: return "PARISC_ARCHEXT";
case PT_PARISC_UNWIND: return "PARISC_UNWIND";
case PT_PARISC_WEAKORDER: return "PARISC_WEAKORDER";
- default:
- break;
+ default: return NULL;
}
-
- return NULL;
}
static const char *
{
case PT_IA_64_ARCHEXT: return "IA_64_ARCHEXT";
case PT_IA_64_UNWIND: return "IA_64_UNWIND";
- case PT_HP_TLS: return "HP_TLS";
- case PT_IA_64_HP_OPT_ANOT: return "HP_OPT_ANNOT";
- case PT_IA_64_HP_HSL_ANOT: return "HP_HSL_ANNOT";
- case PT_IA_64_HP_STACK: return "HP_STACK";
- default:
- break;
+ default: return NULL;
}
-
- return NULL;
}
static const char *
{
switch (type)
{
- case PT_C6000_PHATTR: return "C6000_PHATTR";
- default:
- break;
+ case PT_C6000_PHATTR: return "C6000_PHATTR";
+ default: return NULL;
}
+}
+
+static const char *
+get_hpux_segment_type (unsigned long type, unsigned e_machine)
+{
+ if (e_machine == EM_PARISC)
+ switch (type)
+ {
+ case PT_HP_TLS: return "HP_TLS";
+ case PT_HP_CORE_NONE: return "HP_CORE_NONE";
+ case PT_HP_CORE_VERSION: return "HP_CORE_VERSION";
+ case PT_HP_CORE_KERNEL: return "HP_CORE_KERNEL";
+ case PT_HP_CORE_COMM: return "HP_CORE_COMM";
+ case PT_HP_CORE_PROC: return "HP_CORE_PROC";
+ case PT_HP_CORE_LOADABLE: return "HP_CORE_LOADABLE";
+ case PT_HP_CORE_STACK: return "HP_CORE_STACK";
+ case PT_HP_CORE_SHM: return "HP_CORE_SHM";
+ case PT_HP_CORE_MMF: return "HP_CORE_MMF";
+ case PT_HP_PARALLEL: return "HP_PARALLEL";
+ case PT_HP_FASTBIND: return "HP_FASTBIND";
+ case PT_HP_OPT_ANNOT: return "HP_OPT_ANNOT";
+ case PT_HP_HSL_ANNOT: return "HP_HSL_ANNOT";
+ case PT_HP_STACK: return "HP_STACK";
+ case PT_HP_CORE_UTSNAME: return "HP_CORE_UTSNAME";
+ default: return NULL;
+ }
+
+ if (e_machine == EM_IA_64)
+ switch (type)
+ {
+ case PT_HP_TLS: return "HP_TLS";
+ case PT_IA_64_HP_OPT_ANOT: return "HP_OPT_ANNOT";
+ case PT_IA_64_HP_HSL_ANOT: return "HP_HSL_ANNOT";
+ case PT_IA_64_HP_STACK: return "HP_STACK";
+ default: return NULL;
+ }
return NULL;
}
case 0x6ffffffc: return "PT_SUNWDTRACE";
case 0x6ffffffd: return "PT_SUNWCAP";
case 0x6fffffff: return "PT_HISUNW";
- default: return NULL;
+ default: return NULL;
}
}
static const char *
-get_segment_type (unsigned long p_type)
+get_segment_type (Filedata * filedata, unsigned long p_type)
{
static char buff[32];
case PT_SHLIB: return "SHLIB";
case PT_PHDR: return "PHDR";
case PT_TLS: return "TLS";
-
- case PT_GNU_EH_FRAME:
- return "GNU_EH_FRAME";
+ case PT_GNU_EH_FRAME: return "GNU_EH_FRAME";
case PT_GNU_STACK: return "GNU_STACK";
case PT_GNU_RELRO: return "GNU_RELRO";
+ case PT_GNU_PROPERTY: return "GNU_PROPERTY";
default:
if ((p_type >= PT_LOPROC) && (p_type <= PT_HIPROC))
{
const char * result;
- switch (elf_header.e_machine)
+ switch (filedata->file_header.e_machine)
{
case EM_AARCH64:
result = get_aarch64_segment_type (p_type);
case EM_TI_C6000:
result = get_tic6x_segment_type (p_type);
break;
+ case EM_S390:
+ case EM_S390_OLD:
+ result = get_s390_segment_type (p_type);
+ break;
default:
result = NULL;
break;
}
else if ((p_type >= PT_LOOS) && (p_type <= PT_HIOS))
{
- const char * result;
+ const char * result = NULL;
- switch (elf_header.e_machine)
+ switch (filedata->file_header.e_ident[EI_OSABI])
{
- case EM_PARISC:
- result = get_parisc_segment_type (p_type);
+ case ELFOSABI_GNU:
+ case ELFOSABI_FREEBSD:
+ if (p_type >= PT_GNU_MBIND_LO && p_type <= PT_GNU_MBIND_HI)
+ {
+ sprintf (buff, "GNU_MBIND+%#lx", p_type - PT_GNU_MBIND_LO);
+ result = buff;
+ }
break;
- case EM_IA_64:
- result = get_ia64_segment_type (p_type);
+ case ELFOSABI_HPUX:
+ result = get_hpux_segment_type (p_type,
+ filedata->file_header.e_machine);
+ break;
+ case ELFOSABI_SOLARIS:
+ result = get_solaris_segment_type (p_type);
break;
default:
- if (elf_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
- result = get_solaris_segment_type (p_type);
- else
- result = NULL;
break;
}
-
if (result != NULL)
return result;
}
}
+static const char *
+get_arc_section_type_name (unsigned int sh_type)
+{
+ switch (sh_type)
+ {
+ case SHT_ARC_ATTRIBUTES: return "ARC_ATTRIBUTES";
+ default:
+ break;
+ }
+ return NULL;
+}
+
static const char *
get_mips_section_type_name (unsigned int sh_type)
{
case SHT_MIPS_XLATE_OLD: return "MIPS_XLATE_OLD";
case SHT_MIPS_PDR_EXCEPTION: return "MIPS_PDR_EXCEPTION";
case SHT_MIPS_ABIFLAGS: return "MIPS_ABIFLAGS";
+ case SHT_MIPS_XHASH: return "MIPS_XHASH";
default:
break;
}
case SHT_PARISC_SYMEXTN: return "PARISC_SYMEXTN";
case SHT_PARISC_STUBS: return "PARISC_STUBS";
case SHT_PARISC_DLKM: return "PARISC_DLKM";
- default:
- break;
+ default: return NULL;
}
- return NULL;
}
static const char *
-get_ia64_section_type_name (unsigned int sh_type)
+get_ia64_section_type_name (Filedata * filedata, unsigned int sh_type)
{
/* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
if ((sh_type & 0xFF000000) == SHT_IA_64_LOPSREG)
- return get_osabi_name ((sh_type & 0x00FF0000) >> 16);
+ return get_osabi_name (filedata, (sh_type & 0x00FF0000) >> 16);
switch (sh_type)
{
switch (sh_type)
{
case SHT_X86_64_UNWIND: return "X86_64_UNWIND";
- default:
- break;
+ default: return NULL;
}
- return NULL;
}
static const char *
{
switch (sh_type)
{
- case SHT_AARCH64_ATTRIBUTES:
- return "AARCH64_ATTRIBUTES";
- default:
- break;
+ case SHT_AARCH64_ATTRIBUTES: return "AARCH64_ATTRIBUTES";
+ default: return NULL;
}
- return NULL;
}
static const char *
case SHT_ARM_ATTRIBUTES: return "ARM_ATTRIBUTES";
case SHT_ARM_DEBUGOVERLAY: return "ARM_DEBUGOVERLAY";
case SHT_ARM_OVERLAYSECTION: return "ARM_OVERLAYSECTION";
- default:
- break;
+ default: return NULL;
}
- return NULL;
}
static const char *
{
switch (sh_type)
{
- case SHT_C6000_UNWIND:
- return "C6000_UNWIND";
- case SHT_C6000_PREEMPTMAP:
- return "C6000_PREEMPTMAP";
- case SHT_C6000_ATTRIBUTES:
- return "C6000_ATTRIBUTES";
- case SHT_TI_ICODE:
- return "TI_ICODE";
- case SHT_TI_XREF:
- return "TI_XREF";
- case SHT_TI_HANDLER:
- return "TI_HANDLER";
- case SHT_TI_INITINFO:
- return "TI_INITINFO";
- case SHT_TI_PHATTRS:
- return "TI_PHATTRS";
- default:
- break;
+ case SHT_C6000_UNWIND: return "C6000_UNWIND";
+ case SHT_C6000_PREEMPTMAP: return "C6000_PREEMPTMAP";
+ case SHT_C6000_ATTRIBUTES: return "C6000_ATTRIBUTES";
+ case SHT_TI_ICODE: return "TI_ICODE";
+ case SHT_TI_XREF: return "TI_XREF";
+ case SHT_TI_HANDLER: return "TI_HANDLER";
+ case SHT_TI_INITINFO: return "TI_INITINFO";
+ case SHT_TI_PHATTRS: return "TI_PHATTRS";
+ default: return NULL;
}
- return NULL;
}
static const char *
{
switch (sh_type)
{
- case SHT_MSP430_SEC_FLAGS: return "MSP430_SEC_FLAGS";
- case SHT_MSP430_SYM_ALIASES: return "MSP430_SYM_ALIASES";
- case SHT_MSP430_ATTRIBUTES: return "MSP430_ATTRIBUTES";
- default: return NULL;
+ case SHT_MSP430_SEC_FLAGS: return "MSP430_SEC_FLAGS";
+ case SHT_MSP430_SYM_ALIASES: return "MSP430_SYM_ALIASES";
+ case SHT_MSP430_ATTRIBUTES: return "MSP430_ATTRIBUTES";
+ default: return NULL;
+ }
+}
+
+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;
}
}
{
switch (sh_type)
{
- case SHT_V850_SCOMMON: return "V850 Small Common";
- case SHT_V850_TCOMMON: return "V850 Tiny Common";
- case SHT_V850_ZCOMMON: return "V850 Zero Common";
- case SHT_RENESAS_IOP: return "RENESAS IOP";
- case SHT_RENESAS_INFO: return "RENESAS INFO";
+ case SHT_V850_SCOMMON: return "V850 Small Common";
+ case SHT_V850_TCOMMON: return "V850 Tiny Common";
+ case SHT_V850_ZCOMMON: return "V850 Zero Common";
+ case SHT_RENESAS_IOP: return "RENESAS IOP";
+ case SHT_RENESAS_INFO: return "RENESAS INFO";
+ default: return NULL;
+ }
+}
+
+static const char *
+get_riscv_section_type_name (unsigned int sh_type)
+{
+ switch (sh_type)
+ {
+ case SHT_RISCV_ATTRIBUTES: return "RISCV_ATTRIBUTES";
default: return NULL;
}
}
static const char *
-get_section_type_name (unsigned int sh_type)
+get_section_type_name (Filedata * filedata, unsigned int sh_type)
{
static char buff[32];
const char * result;
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";
default:
if ((sh_type >= SHT_LOPROC) && (sh_type <= SHT_HIPROC))
{
- switch (elf_header.e_machine)
+ switch (filedata->file_header.e_machine)
{
+ case EM_ARC:
+ case EM_ARC_COMPACT:
+ case EM_ARC_COMPACT2:
+ result = get_arc_section_type_name (sh_type);
+ break;
case EM_MIPS:
case EM_MIPS_RS3_LE:
result = get_mips_section_type_name (sh_type);
result = get_parisc_section_type_name (sh_type);
break;
case EM_IA_64:
- result = get_ia64_section_type_name (sh_type);
+ result = get_ia64_section_type_name (filedata, sh_type);
break;
case EM_X86_64:
case EM_L1OM:
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:
result = get_v850_section_type_name (sh_type);
break;
+ case EM_RISCV:
+ result = get_riscv_section_type_name (sh_type);
+ break;
default:
result = NULL;
break;
}
else if ((sh_type >= SHT_LOOS) && (sh_type <= SHT_HIOS))
{
- switch (elf_header.e_machine)
+ switch (filedata->file_header.e_machine)
{
case EM_IA_64:
- result = get_ia64_section_type_name (sh_type);
+ result = get_ia64_section_type_name (filedata, sh_type);
break;
default:
- if (elf_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
+ if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
result = get_solaris_section_type (sh_type);
else
{
}
else if ((sh_type >= SHT_LOUSER) && (sh_type <= SHT_HIUSER))
{
- switch (elf_header.e_machine)
+ switch (filedata->file_header.e_machine)
{
case EM_V800:
case EM_V850:
#define OPTION_DWARF_DEPTH 514
#define OPTION_DWARF_START 515
#define OPTION_DWARF_CHECK 516
+#define OPTION_CTF_DUMP 517
+#define OPTION_CTF_PARENT 518
+#define OPTION_CTF_SYMBOLS 519
+#define OPTION_CTF_STRINGS 520
static struct option options[] =
{
{"dwarf-start", required_argument, 0, OPTION_DWARF_START},
{"dwarf-check", no_argument, 0, OPTION_DWARF_CHECK},
+ {"ctf", required_argument, 0, OPTION_CTF_DUMP},
+
+ {"ctf-symbols", required_argument, 0, OPTION_CTF_SYMBOLS},
+ {"ctf-strings", required_argument, 0, OPTION_CTF_STRINGS},
+ {"ctf-parent", required_argument, 0, OPTION_CTF_PARENT},
+
{"version", no_argument, 0, 'v'},
{"wide", no_argument, 0, 'W'},
{"help", no_argument, 0, 'H'},
-R --relocated-dump=<number|name>\n\
Dump the contents of section <number|name> as relocated bytes\n\
-z --decompress Decompress section before dumping it\n\
- -w[lLiaprmfFsoRt] or\n\
+ -w[lLiaprmfFsoRtUuTgAckK] or\n\
--debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
=frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
=gdb_index,=trace_info,=trace_abbrev,=trace_aranges,\n\
- =addr,=cu_index]\n\
- Display the contents of DWARF2 debug sections\n"));
+ =addr,=cu_index,=links,=follow-links]\n\
+ Display the contents of DWARF debug sections\n"));
fprintf (stream, _("\
--dwarf-depth=N Do not display DIEs at depth N or greater\n\
--dwarf-start=N Display DIEs starting with N, at the same depth\n\
or deeper\n"));
+ fprintf (stream, _("\
+ --ctf=<number|name> Display CTF info from section <number|name>\n\
+ --ctf-parent=<number|name>\n\
+ Use section <number|name> as the CTF parent\n\n\
+ --ctf-symbols=<number|name>\n\
+ Use section <number|name> as the CTF external symtab\n\n\
+ --ctf-strings=<number|name>\n\
+ Use section <number|name> as the CTF external strtab\n\n"));
+
#ifdef SUPPORT_DISASSEMBLY
fprintf (stream, _("\
-i --instruction-dump=<number|name>\n\
the first time. */
static void
-request_dump_bynumber (unsigned int section, dump_type type)
+request_dump_bynumber (Filedata * filedata, unsigned int section, dump_type type)
{
- if (section >= num_dump_sects)
+ if (section >= filedata->num_dump_sects)
{
dump_type * new_dump_sects;
new_dump_sects = (dump_type *) calloc (section + 1,
- sizeof (* dump_sects));
+ sizeof (* new_dump_sects));
if (new_dump_sects == NULL)
error (_("Out of memory allocating dump request table.\n"));
else
{
- if (dump_sects)
+ if (filedata->dump_sects)
{
/* Copy current flag settings. */
- memcpy (new_dump_sects, dump_sects, num_dump_sects * sizeof (* dump_sects));
+ memcpy (new_dump_sects, filedata->dump_sects,
+ filedata->num_dump_sects * sizeof (* new_dump_sects));
- free (dump_sects);
+ free (filedata->dump_sects);
}
- dump_sects = new_dump_sects;
- num_dump_sects = section + 1;
+ filedata->dump_sects = new_dump_sects;
+ filedata->num_dump_sects = section + 1;
}
}
- if (dump_sects)
- dump_sects[section] |= type;
-
- return;
+ if (filedata->dump_sects)
+ filedata->dump_sects[section] |= type;
}
/* Request a dump by section name. */
}
static inline void
-request_dump (dump_type type)
+request_dump (Filedata * filedata, dump_type type)
{
int section;
char * cp;
section = strtoul (optarg, & cp, 0);
if (! *cp && section >= 0)
- request_dump_bynumber (section, type);
+ request_dump_bynumber (filedata, section, type);
else
request_dump_byname (optarg, type);
}
-
static void
-parse_args (int argc, char ** argv)
+parse_args (Filedata * filedata, int argc, char ** argv)
{
int c;
break;
case 'a':
- do_syms++;
- do_reloc++;
- do_unwind++;
- do_dynamic++;
- do_header++;
- do_sections++;
- do_section_groups++;
- do_segments++;
- do_version++;
- do_histogram++;
- do_arch++;
- do_notes++;
+ do_syms = TRUE;
+ do_reloc = TRUE;
+ do_unwind = TRUE;
+ do_dynamic = TRUE;
+ do_header = TRUE;
+ do_sections = TRUE;
+ do_section_groups = TRUE;
+ do_segments = TRUE;
+ do_version = TRUE;
+ do_histogram = TRUE;
+ do_arch = TRUE;
+ do_notes = TRUE;
break;
case 'g':
- do_section_groups++;
+ do_section_groups = TRUE;
break;
case 't':
case 'N':
- do_sections++;
- do_section_details++;
+ do_sections = TRUE;
+ do_section_details = TRUE;
break;
case 'e':
- do_header++;
- do_sections++;
- do_segments++;
+ do_header = TRUE;
+ do_sections = TRUE;
+ do_segments = TRUE;
break;
case 'A':
- do_arch++;
+ do_arch = TRUE;
break;
case 'D':
- do_using_dynamic++;
+ do_using_dynamic = TRUE;
break;
case 'r':
- do_reloc++;
+ do_reloc = TRUE;
break;
case 'u':
- do_unwind++;
+ do_unwind = TRUE;
break;
case 'h':
- do_header++;
+ do_header = TRUE;
break;
case 'l':
- do_segments++;
+ do_segments = TRUE;
break;
case 's':
- do_syms++;
+ do_syms = TRUE;
break;
case 'S':
- do_sections++;
+ do_sections = TRUE;
break;
case 'd':
- do_dynamic++;
+ do_dynamic = TRUE;
break;
case 'I':
- do_histogram++;
+ do_histogram = TRUE;
break;
case 'n':
- do_notes++;
+ do_notes = TRUE;
break;
case 'c':
- do_archive_index++;
+ do_archive_index = TRUE;
break;
case 'x':
- request_dump (HEX_DUMP);
+ request_dump (filedata, HEX_DUMP);
break;
case 'p':
- request_dump (STRING_DUMP);
+ request_dump (filedata, STRING_DUMP);
break;
case 'R':
- request_dump (RELOC_DUMP);
+ request_dump (filedata, RELOC_DUMP);
break;
case 'z':
- decompress_dumps++;
+ decompress_dumps = TRUE;
break;
case 'w':
- do_dump++;
+ do_dump = TRUE;
if (optarg == 0)
{
- do_debugging = 1;
+ do_debugging = TRUE;
dwarf_select_sections_all ();
}
else
{
- do_debugging = 0;
+ do_debugging = FALSE;
dwarf_select_sections_by_letters (optarg);
}
break;
case OPTION_DEBUG_DUMP:
- do_dump++;
+ do_dump = TRUE;
if (optarg == 0)
- do_debugging = 1;
+ do_debugging = TRUE;
else
{
- do_debugging = 0;
+ do_debugging = FALSE;
dwarf_select_sections_by_names (optarg);
}
break;
}
break;
case OPTION_DWARF_CHECK:
- dwarf_check = 1;
+ dwarf_check = TRUE;
+ break;
+ case OPTION_CTF_DUMP:
+ do_ctf = TRUE;
+ request_dump (filedata, CTF_DUMP);
+ break;
+ case OPTION_CTF_SYMBOLS:
+ dump_ctf_symtab_name = strdup (optarg);
+ break;
+ case OPTION_CTF_STRINGS:
+ dump_ctf_strtab_name = strdup (optarg);
+ break;
+ case OPTION_CTF_PARENT:
+ dump_ctf_parent_name = strdup (optarg);
break;
case OPTION_DYN_SYMS:
- do_dyn_syms++;
+ do_dyn_syms = TRUE;
break;
#ifdef SUPPORT_DISASSEMBLY
case 'i':
- request_dump (DISASS_DUMP);
+ request_dump (filedata, DISASS_DUMP);
break;
#endif
case 'v':
print_version (program_name);
break;
case 'V':
- do_version++;
+ do_version = TRUE;
break;
case 'W':
- do_wide++;
+ do_wide = TRUE;
break;
default:
/* xgettext:c-format */
}
}
-/* Decode the data held in 'elf_header'. */
+/* Decode the data held in 'filedata->file_header'. */
-static int
-process_file_header (void)
+static bfd_boolean
+process_file_header (Filedata * filedata)
{
- if ( elf_header.e_ident[EI_MAG0] != ELFMAG0
- || elf_header.e_ident[EI_MAG1] != ELFMAG1
- || elf_header.e_ident[EI_MAG2] != ELFMAG2
- || elf_header.e_ident[EI_MAG3] != ELFMAG3)
+ Elf_Internal_Ehdr * header = & filedata->file_header;
+
+ if ( header->e_ident[EI_MAG0] != ELFMAG0
+ || header->e_ident[EI_MAG1] != ELFMAG1
+ || header->e_ident[EI_MAG2] != ELFMAG2
+ || header->e_ident[EI_MAG3] != ELFMAG3)
{
error
(_("Not an ELF file - it has the wrong magic bytes at the start\n"));
- return 0;
+ return FALSE;
}
- init_dwarf_regnames (elf_header.e_machine);
+ init_dwarf_regnames_by_elf_machine_code (header->e_machine);
if (do_header)
{
- int i;
+ unsigned i;
printf (_("ELF Header:\n"));
printf (_(" Magic: "));
for (i = 0; i < EI_NIDENT; i++)
- printf ("%2.2x ", elf_header.e_ident[i]);
+ printf ("%2.2x ", header->e_ident[i]);
printf ("\n");
printf (_(" Class: %s\n"),
- get_elf_class (elf_header.e_ident[EI_CLASS]));
+ get_elf_class (header->e_ident[EI_CLASS]));
printf (_(" Data: %s\n"),
- get_data_encoding (elf_header.e_ident[EI_DATA]));
- printf (_(" Version: %d %s\n"),
- elf_header.e_ident[EI_VERSION],
- (elf_header.e_ident[EI_VERSION] == EV_CURRENT
- ? "(current)"
- : (elf_header.e_ident[EI_VERSION] != EV_NONE
- ? _("<unknown: %lx>")
+ get_data_encoding (header->e_ident[EI_DATA]));
+ printf (_(" Version: %d%s\n"),
+ header->e_ident[EI_VERSION],
+ (header->e_ident[EI_VERSION] == EV_CURRENT
+ ? _(" (current)")
+ : (header->e_ident[EI_VERSION] != EV_NONE
+ ? _(" <unknown>")
: "")));
printf (_(" OS/ABI: %s\n"),
- get_osabi_name (elf_header.e_ident[EI_OSABI]));
+ get_osabi_name (filedata, header->e_ident[EI_OSABI]));
printf (_(" ABI Version: %d\n"),
- elf_header.e_ident[EI_ABIVERSION]);
+ header->e_ident[EI_ABIVERSION]);
printf (_(" Type: %s\n"),
- get_file_type (elf_header.e_type));
+ get_file_type (header->e_type));
printf (_(" Machine: %s\n"),
- get_machine_name (elf_header.e_machine));
+ get_machine_name (header->e_machine));
printf (_(" Version: 0x%lx\n"),
- (unsigned long) elf_header.e_version);
+ header->e_version);
printf (_(" Entry point address: "));
- print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
+ print_vma (header->e_entry, PREFIX_HEX);
printf (_("\n Start of program headers: "));
- print_vma ((bfd_vma) elf_header.e_phoff, DEC);
+ print_vma (header->e_phoff, DEC);
printf (_(" (bytes into file)\n Start of section headers: "));
- print_vma ((bfd_vma) elf_header.e_shoff, DEC);
+ print_vma (header->e_shoff, DEC);
printf (_(" (bytes into file)\n"));
printf (_(" Flags: 0x%lx%s\n"),
- (unsigned long) elf_header.e_flags,
- get_machine_flags (elf_header.e_flags, elf_header.e_machine));
- printf (_(" Size of this header: %ld (bytes)\n"),
- (long) elf_header.e_ehsize);
- printf (_(" Size of program headers: %ld (bytes)\n"),
- (long) elf_header.e_phentsize);
- printf (_(" Number of program headers: %ld"),
- (long) elf_header.e_phnum);
- if (section_headers != NULL
- && elf_header.e_phnum == PN_XNUM
- && section_headers[0].sh_info != 0)
- printf (" (%ld)", (long) section_headers[0].sh_info);
+ header->e_flags,
+ get_machine_flags (filedata, header->e_flags, header->e_machine));
+ 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)
+ {
+ 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) elf_header.e_shentsize);
- printf (_(" Number of section headers: %ld"),
- (long) elf_header.e_shnum);
- if (section_headers != NULL && elf_header.e_shnum == SHN_UNDEF)
- printf (" (%ld)", (long) section_headers[0].sh_size);
+ 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)
+ {
+ 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) elf_header.e_shstrndx);
- if (section_headers != NULL
- && elf_header.e_shstrndx == (SHN_XINDEX & 0xffff))
- 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 (_(" Section header string table index: %u"),
+ header->e_shstrndx);
+ if (filedata->section_headers != NULL
+ && header->e_shstrndx == (SHN_XINDEX & 0xffff))
+ {
+ 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);
}
- if (section_headers != NULL)
+ if (filedata->section_headers != NULL)
{
- if (elf_header.e_phnum == PN_XNUM
- && section_headers[0].sh_info != 0)
- elf_header.e_phnum = section_headers[0].sh_info;
- if (elf_header.e_shnum == SHN_UNDEF)
- elf_header.e_shnum = section_headers[0].sh_size;
- if (elf_header.e_shstrndx == (SHN_XINDEX & 0xffff))
- elf_header.e_shstrndx = section_headers[0].sh_link;
- else if (elf_header.e_shstrndx >= elf_header.e_shnum)
- elf_header.e_shstrndx = SHN_UNDEF;
- free (section_headers);
- section_headers = NULL;
+ if (header->e_phnum == PN_XNUM
+ && filedata->section_headers[0].sh_info != 0)
+ header->e_phnum = filedata->section_headers[0].sh_info;
+ if (header->e_shnum == SHN_UNDEF)
+ 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;
+ if (header->e_shstrndx >= header->e_shnum)
+ header->e_shstrndx = SHN_UNDEF;
+ free (filedata->section_headers);
+ filedata->section_headers = NULL;
}
- return 1;
+ return TRUE;
}
+/* Read in the program headers from FILEDATA and store them in PHEADERS.
+ Returns TRUE upon success, FALSE otherwise. Loads 32-bit headers. */
+
static bfd_boolean
-get_32bit_program_headers (FILE * file, Elf_Internal_Phdr * pheaders)
+get_32bit_program_headers (Filedata * filedata, Elf_Internal_Phdr * pheaders)
{
Elf32_External_Phdr * phdrs;
Elf32_External_Phdr * external;
Elf_Internal_Phdr * internal;
unsigned int i;
- unsigned int size = elf_header.e_phentsize;
- unsigned int num = elf_header.e_phnum;
+ unsigned int size = filedata->file_header.e_phentsize;
+ unsigned int num = filedata->file_header.e_phnum;
/* PR binutils/17531: Cope with unexpected section header sizes. */
if (size == 0 || num == 0)
if (size > sizeof * phdrs)
warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
- phdrs = (Elf32_External_Phdr *) get_data (NULL, file, elf_header.e_phoff,
+ phdrs = (Elf32_External_Phdr *) get_data (NULL, filedata, filedata->file_header.e_phoff,
size, num, _("program headers"));
if (phdrs == NULL)
return FALSE;
for (i = 0, internal = pheaders, external = phdrs;
- i < elf_header.e_phnum;
+ i < filedata->file_header.e_phnum;
i++, internal++, external++)
{
internal->p_type = BYTE_GET (external->p_type);
return TRUE;
}
+/* Read in the program headers from FILEDATA and store them in PHEADERS.
+ Returns TRUE upon success, FALSE otherwise. Loads 64-bit headers. */
+
static bfd_boolean
-get_64bit_program_headers (FILE * file, Elf_Internal_Phdr * pheaders)
+get_64bit_program_headers (Filedata * filedata, Elf_Internal_Phdr * pheaders)
{
Elf64_External_Phdr * phdrs;
Elf64_External_Phdr * external;
Elf_Internal_Phdr * internal;
unsigned int i;
- unsigned int size = elf_header.e_phentsize;
- unsigned int num = elf_header.e_phnum;
+ unsigned int size = filedata->file_header.e_phentsize;
+ unsigned int num = filedata->file_header.e_phnum;
/* PR binutils/17531: Cope with unexpected section header sizes. */
if (size == 0 || num == 0)
if (size > sizeof * phdrs)
warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
- phdrs = (Elf64_External_Phdr *) get_data (NULL, file, elf_header.e_phoff,
+ phdrs = (Elf64_External_Phdr *) get_data (NULL, filedata, filedata->file_header.e_phoff,
size, num, _("program headers"));
if (!phdrs)
return FALSE;
for (i = 0, internal = pheaders, external = phdrs;
- i < elf_header.e_phnum;
+ i < filedata->file_header.e_phnum;
i++, internal++, external++)
{
internal->p_type = BYTE_GET (external->p_type);
return TRUE;
}
-/* Returns 1 if the program headers were read into `program_headers'. */
+/* Returns TRUE if the program headers were read into `program_headers'. */
-static int
-get_program_headers (FILE * file)
+static bfd_boolean
+get_program_headers (Filedata * filedata)
{
Elf_Internal_Phdr * phdrs;
/* Check cache of prior read. */
- if (program_headers != NULL)
- return 1;
+ if (filedata->program_headers != NULL)
+ return TRUE;
- phdrs = (Elf_Internal_Phdr *) cmalloc (elf_header.e_phnum,
- sizeof (Elf_Internal_Phdr));
+ /* Be kind to memory checkers by looking for
+ e_phnum values which we know must be invalid. */
+ if (filedata->file_header.e_phnum
+ * (is_32bit_elf ? sizeof (Elf32_External_Phdr) : sizeof (Elf64_External_Phdr))
+ >= filedata->file_size)
+ {
+ error (_("Too many program headers - %#x - the file is not that big\n"),
+ filedata->file_header.e_phnum);
+ return FALSE;
+ }
+ phdrs = (Elf_Internal_Phdr *) cmalloc (filedata->file_header.e_phnum,
+ sizeof (Elf_Internal_Phdr));
if (phdrs == NULL)
{
error (_("Out of memory reading %u program headers\n"),
- elf_header.e_phnum);
- return 0;
+ filedata->file_header.e_phnum);
+ return FALSE;
}
if (is_32bit_elf
- ? get_32bit_program_headers (file, phdrs)
- : get_64bit_program_headers (file, phdrs))
+ ? get_32bit_program_headers (filedata, phdrs)
+ : get_64bit_program_headers (filedata, phdrs))
{
- program_headers = phdrs;
- return 1;
+ filedata->program_headers = phdrs;
+ return TRUE;
}
free (phdrs);
- return 0;
+ return FALSE;
}
-/* Returns 1 if the program headers were loaded. */
+/* Returns TRUE if the program headers were loaded. */
-static int
-process_program_headers (FILE * file)
+static bfd_boolean
+process_program_headers (Filedata * filedata)
{
Elf_Internal_Phdr * segment;
unsigned int i;
Elf_Internal_Phdr * previous_load = NULL;
- if (elf_header.e_phnum == 0)
+ dynamic_addr = 0;
+ dynamic_size = 0;
+
+ if (filedata->file_header.e_phnum == 0)
{
/* PR binutils/12467. */
- if (elf_header.e_phoff != 0)
- warn (_("possibly corrupt ELF header - it has a non-zero program"
- " header offset, but no program headers\n"));
+ if (filedata->file_header.e_phoff != 0)
+ {
+ warn (_("possibly corrupt ELF header - it has a non-zero program"
+ " header offset, but no program headers\n"));
+ return FALSE;
+ }
else if (do_segments)
printf (_("\nThere are no program headers in this file.\n"));
- return 0;
+ return TRUE;
}
if (do_segments && !do_header)
{
- printf (_("\nElf file type is %s\n"), get_file_type (elf_header.e_type));
- printf (_("Entry point "));
- print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
- printf (_("\nThere are %d program headers, starting at offset "),
- elf_header.e_phnum);
- print_vma ((bfd_vma) elf_header.e_phoff, DEC);
- printf ("\n");
+ printf (_("\nElf file type is %s\n"), get_file_type (filedata->file_header.e_type));
+ printf (_("Entry point 0x%s\n"), bfd_vmatoa ("x", filedata->file_header.e_entry));
+ printf (ngettext ("There is %d program header, starting at offset %s\n",
+ "There are %d program headers, starting at offset %s\n",
+ filedata->file_header.e_phnum),
+ filedata->file_header.e_phnum,
+ bfd_vmatoa ("u", filedata->file_header.e_phoff));
}
- if (! get_program_headers (file))
- return 0;
+ if (! get_program_headers (filedata))
+ return TRUE;
if (do_segments)
{
- if (elf_header.e_phnum > 1)
+ if (filedata->file_header.e_phnum > 1)
printf (_("\nProgram Headers:\n"));
else
printf (_("\nProgram Headers:\n"));
}
}
- dynamic_addr = 0;
- dynamic_size = 0;
-
- for (i = 0, segment = program_headers;
- i < elf_header.e_phnum;
+ for (i = 0, segment = filedata->program_headers;
+ i < filedata->file_header.e_phnum;
i++, segment++)
{
if (do_segments)
{
- printf (" %-14.14s ", get_segment_type (segment->p_type));
+ printf (" %-14.14s ", get_segment_type (filedata, segment->p_type));
if (is_32bit_elf)
{
/* PR 20815 - Verify that the program header is loaded into memory. */
if (i > 0 && previous_load != NULL)
error (_("the PHDR segment must occur before any LOAD segment\n"));
- if (elf_header.e_machine != EM_PARISC)
+ if (filedata->file_header.e_machine != EM_PARISC)
{
unsigned int j;
- for (j = 1; j < elf_header.e_phnum; j++)
- if (program_headers[j].p_vaddr <= segment->p_vaddr
- && (program_headers[j].p_vaddr + program_headers[j].p_memsz)
- >= (segment->p_vaddr + segment->p_filesz))
- break;
- if (j == elf_header.e_phnum)
+ for (j = 1; j < filedata->file_header.e_phnum; j++)
+ {
+ Elf_Internal_Phdr *load = filedata->program_headers + j;
+ if (load->p_type == PT_LOAD
+ && load->p_offset <= segment->p_offset
+ && (load->p_offset + load->p_filesz
+ >= segment->p_offset + segment->p_filesz)
+ && load->p_vaddr <= segment->p_vaddr
+ && (load->p_vaddr + load->p_filesz
+ >= segment->p_vaddr + segment->p_filesz))
+ break;
+ }
+ if (j == filedata->file_header.e_phnum)
error (_("the PHDR segment is not covered by a LOAD segment\n"));
}
break;
section in the DYNAMIC segment. */
dynamic_addr = segment->p_offset;
dynamic_size = segment->p_filesz;
- /* PR binutils/17512: Avoid corrupt dynamic section info in the segment. */
- if (dynamic_addr + dynamic_size >= current_file_size)
- {
- error (_("the dynamic segment offset + size exceeds the size of the file\n"));
- dynamic_addr = dynamic_size = 0;
- }
/* Try to locate the .dynamic section. If there is
a section header table, we can easily locate it. */
- if (section_headers != NULL)
+ if (filedata->section_headers != NULL)
{
Elf_Internal_Shdr * sec;
- sec = find_section (".dynamic");
+ sec = find_section (filedata, ".dynamic");
if (sec == NULL || sec->sh_size == 0)
{
/* A corresponding .dynamic section is expected, but on
IA-64/OpenVMS it is OK for it to be missing. */
- if (!is_ia64_vms ())
+ if (!is_ia64_vms (filedata))
error (_("no .dynamic section in the dynamic segment\n"));
break;
}
warn (_("the .dynamic section is not the first section"
" in the dynamic segment.\n"));
}
+
+ /* PR binutils/17512: Avoid corrupt dynamic section info in the
+ segment. Check this after matching against the section headers
+ so we don't warn on debuginfo file (which have NOBITS .dynamic
+ sections). */
+ if (dynamic_addr > filedata->file_size
+ || dynamic_size > filedata->file_size - dynamic_addr)
+ {
+ error (_("the dynamic segment offset + size exceeds the size of the file\n"));
+ dynamic_addr = dynamic_size = 0;
+ }
break;
case PT_INTERP:
- if (fseek (file, archive_file_offset + (long) segment->p_offset,
+ if (fseek (filedata->handle, archive_file_offset + (long) segment->p_offset,
SEEK_SET))
error (_("Unable to find program interpreter name\n"));
else
error (_("Internal error: failed to create format string to display program interpreter\n"));
program_interpreter[0] = 0;
- if (fscanf (file, fmt, program_interpreter) <= 0)
+ if (fscanf (filedata->handle, fmt, program_interpreter) <= 0)
error (_("Unable to read program interpreter name\n"));
if (do_segments)
}
}
- if (do_segments && section_headers != NULL && string_table != NULL)
+ if (do_segments
+ && filedata->section_headers != NULL
+ && filedata->string_table != NULL)
{
printf (_("\n Section to Segment mapping:\n"));
printf (_(" Segment Sections...\n"));
- for (i = 0; i < elf_header.e_phnum; i++)
+ for (i = 0; i < filedata->file_header.e_phnum; i++)
{
unsigned int j;
Elf_Internal_Shdr * section;
- segment = program_headers + i;
- section = section_headers + 1;
+ segment = filedata->program_headers + i;
+ section = filedata->section_headers + 1;
printf (" %2.2d ", i);
- for (j = 1; j < elf_header.e_shnum; j++, section++)
+ for (j = 1; j < filedata->file_header.e_shnum; j++, section++)
{
if (!ELF_TBSS_SPECIAL (section, segment)
&& ELF_SECTION_IN_SEGMENT_STRICT (section, segment))
- printf ("%s ", printable_section_name (section));
+ printf ("%s ", printable_section_name (filedata, section));
}
putc ('\n',stdout);
}
}
- return 1;
+ return TRUE;
}
/* Find the file offset corresponding to VMA by using the program headers. */
static long
-offset_from_vma (FILE * file, bfd_vma vma, bfd_size_type size)
+offset_from_vma (Filedata * filedata, bfd_vma vma, bfd_size_type size)
{
Elf_Internal_Phdr * seg;
- if (! get_program_headers (file))
+ if (! get_program_headers (filedata))
{
warn (_("Cannot interpret virtual addresses without program headers.\n"));
return (long) vma;
}
- for (seg = program_headers;
- seg < program_headers + elf_header.e_phnum;
+ for (seg = filedata->program_headers;
+ seg < filedata->program_headers + filedata->file_header.e_phnum;
++seg)
{
if (seg->p_type != PT_LOAD)
}
-/* Allocate memory and load the sections headers into the global pointer
- SECTION_HEADERS. If PROBE is true, this is just a probe and we do not
- generate any error messages if the load fails. */
+/* Allocate memory and load the sections headers into FILEDATA->filedata->section_headers.
+ If PROBE is true, this is just a probe and we do not generate any error
+ messages if the load fails. */
static bfd_boolean
-get_32bit_section_headers (FILE * file, bfd_boolean probe)
+get_32bit_section_headers (Filedata * filedata, bfd_boolean probe)
{
Elf32_External_Shdr * shdrs;
Elf_Internal_Shdr * internal;
- unsigned int i;
- unsigned int size = elf_header.e_shentsize;
- unsigned int num = probe ? 1 : elf_header.e_shnum;
+ unsigned int i;
+ unsigned int size = filedata->file_header.e_shentsize;
+ unsigned int num = probe ? 1 : filedata->file_header.e_shnum;
/* PR binutils/17531: Cope with unexpected section header sizes. */
if (size == 0 || num == 0)
if (!probe && size > sizeof * shdrs)
warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
- shdrs = (Elf32_External_Shdr *) get_data (NULL, file, elf_header.e_shoff,
+ shdrs = (Elf32_External_Shdr *) get_data (NULL, filedata, filedata->file_header.e_shoff,
size, num,
probe ? NULL : _("section headers"));
if (shdrs == NULL)
return FALSE;
- if (section_headers != NULL)
- free (section_headers);
- section_headers = (Elf_Internal_Shdr *) cmalloc (num,
- sizeof (Elf_Internal_Shdr));
- if (section_headers == NULL)
+ free (filedata->section_headers);
+ filedata->section_headers = (Elf_Internal_Shdr *)
+ cmalloc (num, sizeof (Elf_Internal_Shdr));
+ if (filedata->section_headers == NULL)
{
if (!probe)
error (_("Out of memory reading %u section headers\n"), num);
+ free (shdrs);
return FALSE;
}
- for (i = 0, internal = section_headers;
+ for (i = 0, internal = filedata->section_headers;
i < num;
i++, internal++)
{
return TRUE;
}
+/* Like get_32bit_section_headers, except that it fetches 64-bit headers. */
+
static bfd_boolean
-get_64bit_section_headers (FILE * file, bfd_boolean probe)
+get_64bit_section_headers (Filedata * filedata, bfd_boolean probe)
{
- Elf64_External_Shdr * shdrs;
- Elf_Internal_Shdr * internal;
- unsigned int i;
- unsigned int size = elf_header.e_shentsize;
- unsigned int num = probe ? 1 : elf_header.e_shnum;
+ Elf64_External_Shdr * shdrs;
+ Elf_Internal_Shdr * internal;
+ unsigned int i;
+ unsigned int size = filedata->file_header.e_shentsize;
+ unsigned int num = probe ? 1 : filedata->file_header.e_shnum;
/* PR binutils/17531: Cope with unexpected section header sizes. */
if (size == 0 || num == 0)
return FALSE;
+
if (size < sizeof * shdrs)
{
if (! probe)
error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
return FALSE;
}
+
if (! probe && size > sizeof * shdrs)
warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
- shdrs = (Elf64_External_Shdr *) get_data (NULL, file, elf_header.e_shoff,
+ shdrs = (Elf64_External_Shdr *) get_data (NULL, filedata,
+ filedata->file_header.e_shoff,
size, num,
probe ? NULL : _("section headers"));
if (shdrs == NULL)
return FALSE;
- if (section_headers != NULL)
- free (section_headers);
- section_headers = (Elf_Internal_Shdr *) cmalloc (num,
- sizeof (Elf_Internal_Shdr));
- if (section_headers == NULL)
+ free (filedata->section_headers);
+ filedata->section_headers = (Elf_Internal_Shdr *)
+ cmalloc (num, sizeof (Elf_Internal_Shdr));
+ if (filedata->section_headers == NULL)
{
if (! probe)
error (_("Out of memory reading %u section headers\n"), num);
+ free (shdrs);
return FALSE;
}
- for (i = 0, internal = section_headers;
+ for (i = 0, internal = filedata->section_headers;
i < num;
i++, internal++)
{
}
static Elf_Internal_Sym *
-get_32bit_elf_symbols (FILE * file,
- Elf_Internal_Shdr * section,
- unsigned long * num_syms_return)
+get_32bit_elf_symbols (Filedata * filedata,
+ Elf_Internal_Shdr * section,
+ unsigned long * num_syms_return)
{
unsigned long number = 0;
Elf32_External_Sym * esyms = NULL;
Elf_Internal_Sym * isyms = NULL;
Elf_Internal_Sym * psym;
unsigned int j;
+ elf_section_list * entry;
if (section->sh_size == 0)
{
if (section->sh_entsize == 0 || section->sh_entsize > section->sh_size)
{
error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
- printable_section_name (section), (unsigned long) section->sh_entsize);
+ printable_section_name (filedata, section),
+ (unsigned long) section->sh_entsize);
goto exit_point;
}
- if (section->sh_size > current_file_size)
+ if (section->sh_size > filedata->file_size)
{
error (_("Section %s has an invalid sh_size of 0x%lx\n"),
- printable_section_name (section), (unsigned long) section->sh_size);
+ printable_section_name (filedata, section),
+ (unsigned long) section->sh_size);
goto exit_point;
}
{
error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
(unsigned long) section->sh_size,
- printable_section_name (section),
+ printable_section_name (filedata, section),
(unsigned long) section->sh_entsize);
goto exit_point;
}
- esyms = (Elf32_External_Sym *) get_data (NULL, file, section->sh_offset, 1,
+ esyms = (Elf32_External_Sym *) get_data (NULL, filedata, section->sh_offset, 1,
section->sh_size, _("symbols"));
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 - section_headers))
- {
- shndx = (Elf_External_Sym_Shndx *) get_data (NULL, file,
- entry->hdr->sh_offset,
- 1, entry->hdr->sh_size,
- _("symbol table section indicies"));
- if (shndx == NULL)
- goto exit_point;
- /* PR17531: file: heap-buffer-overflow */
- else if (entry->hdr->sh_size / sizeof (Elf_External_Sym_Shndx) < number)
- {
- error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
- printable_section_name (entry->hdr),
- (unsigned long) entry->hdr->sh_size,
- (unsigned long) section->sh_size);
- goto exit_point;
- }
+ 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;
}
static Elf_Internal_Sym *
-get_64bit_elf_symbols (FILE * file,
- Elf_Internal_Shdr * section,
- unsigned long * num_syms_return)
+get_64bit_elf_symbols (Filedata * filedata,
+ Elf_Internal_Shdr * section,
+ unsigned long * num_syms_return)
{
unsigned long number = 0;
Elf64_External_Sym * esyms = NULL;
Elf_Internal_Sym * isyms = NULL;
Elf_Internal_Sym * psym;
unsigned int j;
+ elf_section_list * entry;
if (section->sh_size == 0)
{
if (section->sh_entsize == 0 || section->sh_entsize > section->sh_size)
{
error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
- printable_section_name (section),
+ printable_section_name (filedata, section),
(unsigned long) section->sh_entsize);
goto exit_point;
}
- if (section->sh_size > current_file_size)
+ if (section->sh_size > filedata->file_size)
{
error (_("Section %s has an invalid sh_size of 0x%lx\n"),
- printable_section_name (section),
+ printable_section_name (filedata, section),
(unsigned long) section->sh_size);
goto exit_point;
}
{
error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
(unsigned long) section->sh_size,
- printable_section_name (section),
+ printable_section_name (filedata, section),
(unsigned long) section->sh_entsize);
goto exit_point;
}
- esyms = (Elf64_External_Sym *) get_data (NULL, file, section->sh_offset, 1,
+ esyms = (Elf64_External_Sym *) get_data (NULL, filedata, section->sh_offset, 1,
section->sh_size, _("symbols"));
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 - section_headers))
- {
- shndx = (Elf_External_Sym_Shndx *) get_data (NULL, file,
- entry->hdr->sh_offset,
- 1, entry->hdr->sh_size,
- _("symbol table section indicies"));
- if (shndx == NULL)
- goto exit_point;
- /* PR17531: file: heap-buffer-overflow */
- else if (entry->hdr->sh_size / sizeof (Elf_External_Sym_Shndx) < number)
- {
- error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
- printable_section_name (entry->hdr),
- (unsigned long) entry->hdr->sh_size,
- (unsigned long) section->sh_size);
- goto exit_point;
- }
+ 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;
}
static const char *
-get_elf_section_flags (bfd_vma sh_flags)
+get_elf_section_flags (Filedata * filedata, bfd_vma sh_flags)
{
static char buff[1024];
char * p = buff;
- int field_size = is_32bit_elf ? 8 : 16;
- int sindex;
- int size = sizeof (buff) - (field_size + 4 + 1);
+ unsigned int field_size = is_32bit_elf ? 8 : 16;
+ signed int sindex;
+ unsigned int size = sizeof (buff) - (field_size + 4 + 1);
bfd_vma os_flags = 0;
bfd_vma proc_flags = 0;
bfd_vma unknown_flags = 0;
static const struct
{
const char * str;
- int len;
+ unsigned int len;
}
flags [] =
{
/* ARM specific. */
/* 21 */ { STRING_COMMA_LEN ("ENTRYSECT") },
/* 22 */ { STRING_COMMA_LEN ("ARM_PURECODE") },
- /* 23 */ { STRING_COMMA_LEN ("COMDEF") }
+ /* 23 */ { STRING_COMMA_LEN ("COMDEF") },
+ /* GNU specific. */
+ /* 24 */ { STRING_COMMA_LEN ("GNU_MBIND") },
+ /* VLE specific. */
+ /* 25 */ { STRING_COMMA_LEN ("VLE") },
};
if (do_section_details)
case SHF_TLS: sindex = 9; break;
case SHF_EXCLUDE: sindex = 18; break;
case SHF_COMPRESSED: sindex = 20; break;
+ case SHF_GNU_MBIND: sindex = 24; break;
default:
sindex = -1;
- switch (elf_header.e_machine)
+ switch (filedata->file_header.e_machine)
{
case EM_IA_64:
if (flag == SHF_IA_64_SHORT)
else if (flag == SHF_IA_64_NORECOV)
sindex = 11;
#ifdef BFD64
- else if (elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
+ else if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
switch (flag)
{
case SHF_IA_64_VMS_GLOBAL: sindex = 12; break;
default: break;
}
break;
+ case EM_PPC:
+ if (flag == SHF_PPC_VLE)
+ sindex = 25;
+ break;
default:
break;
case SHF_TLS: *p = 'T'; break;
case SHF_EXCLUDE: *p = 'E'; break;
case SHF_COMPRESSED: *p = 'C'; break;
+ case SHF_GNU_MBIND: *p = 'D'; break;
default:
- if ((elf_header.e_machine == EM_X86_64
- || elf_header.e_machine == EM_L1OM
- || elf_header.e_machine == EM_K1OM)
+ if ((filedata->file_header.e_machine == EM_X86_64
+ || filedata->file_header.e_machine == EM_L1OM
+ || filedata->file_header.e_machine == EM_K1OM)
&& flag == SHF_X86_64_LARGE)
*p = 'l';
- else if (elf_header.e_machine == EM_ARM
+ else if (filedata->file_header.e_machine == EM_ARM
&& flag == SHF_ARM_PURECODE)
*p = 'y';
+ else if (filedata->file_header.e_machine == EM_PPC
+ && flag == SHF_PPC_VLE)
+ *p = 'v';
else if (flag & SHF_MASKOS)
{
*p = 'o';
}
}
-static int
-process_section_headers (FILE * file)
+static bfd_boolean
+process_section_headers (Filedata * filedata)
{
Elf_Internal_Shdr * section;
unsigned int i;
- section_headers = NULL;
+ filedata->section_headers = NULL;
- if (elf_header.e_shnum == 0)
+ if (filedata->file_header.e_shnum == 0)
{
/* PR binutils/12467. */
- if (elf_header.e_shoff != 0)
- warn (_("possibly corrupt ELF file header - it has a non-zero"
- " section header offset, but no section headers\n"));
+ if (filedata->file_header.e_shoff != 0)
+ {
+ warn (_("possibly corrupt ELF file header - it has a non-zero"
+ " section header offset, but no section headers\n"));
+ return FALSE;
+ }
else if (do_sections)
printf (_("\nThere are no sections in this file.\n"));
- return 1;
+ return TRUE;
}
if (do_sections && !do_header)
- printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
- elf_header.e_shnum, (unsigned long) elf_header.e_shoff);
+ printf (ngettext ("There is %d section header, "
+ "starting at offset 0x%lx:\n",
+ "There are %d section headers, "
+ "starting at offset 0x%lx:\n",
+ filedata->file_header.e_shnum),
+ filedata->file_header.e_shnum,
+ (unsigned long) filedata->file_header.e_shoff);
if (is_32bit_elf)
{
- if (! get_32bit_section_headers (file, FALSE))
- return 0;
+ if (! get_32bit_section_headers (filedata, FALSE))
+ return FALSE;
+ }
+ else
+ {
+ if (! get_64bit_section_headers (filedata, FALSE))
+ return FALSE;
}
- else if (! get_64bit_section_headers (file, FALSE))
- return 0;
/* Read in the string table, so that we have names to display. */
- if (elf_header.e_shstrndx != SHN_UNDEF
- && elf_header.e_shstrndx < elf_header.e_shnum)
+ if (filedata->file_header.e_shstrndx != SHN_UNDEF
+ && filedata->file_header.e_shstrndx < filedata->file_header.e_shnum)
{
- section = section_headers + elf_header.e_shstrndx;
+ section = filedata->section_headers + filedata->file_header.e_shstrndx;
if (section->sh_size != 0)
{
- string_table = (char *) get_data (NULL, file, section->sh_offset,
- 1, section->sh_size,
- _("string table"));
+ filedata->string_table = (char *) get_data (NULL, filedata, section->sh_offset,
+ 1, section->sh_size,
+ _("string table"));
- string_table_length = string_table != NULL ? section->sh_size : 0;
+ filedata->string_table_length = filedata->string_table != NULL ? section->sh_size : 0;
}
}
symtab_shndx_list = NULL;
eh_addr_size = is_32bit_elf ? 4 : 8;
- switch (elf_header.e_machine)
+ switch (filedata->file_header.e_machine)
{
case EM_MIPS:
case EM_MIPS_RS3_LE:
earlier compilers provided no way of distinguishing ILP32 objects
from LP64 objects, so if there's any doubt, we should assume that
the official LP64 form is being used. */
- if ((elf_header.e_flags & EF_MIPS_ABI) == E_MIPS_ABI_EABI64
- && find_section (".gcc_compiled_long32") == NULL)
+ if ((filedata->file_header.e_flags & EF_MIPS_ABI) == E_MIPS_ABI_EABI64
+ && find_section (filedata, ".gcc_compiled_long32") == NULL)
eh_addr_size = 8;
break;
case EM_H8_300:
case EM_H8_300H:
- switch (elf_header.e_flags & EF_H8_MACH)
+ switch (filedata->file_header.e_flags & EF_H8_MACH)
{
case E_H8_MACH_H8300:
case E_H8_MACH_H8300HN:
case EM_M32C_OLD:
case EM_M32C:
- switch (elf_header.e_flags & EF_M32C_CPU_MASK)
+ switch (filedata->file_header.e_flags & EF_M32C_CPU_MASK)
{
case EF_M32C_CPU_M16C:
eh_addr_size = 2;
CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
sizeof (Elf64_External_##type))
- for (i = 0, section = section_headers;
- i < elf_header.e_shnum;
+ for (i = 0, section = filedata->section_headers;
+ i < filedata->file_header.e_shnum;
i++, section++)
{
char * name = SECTION_NAME (section);
}
CHECK_ENTSIZE (section, i, Sym);
- dynamic_symbols = GET_ELF_SYMBOLS (file, section, & num_dynamic_syms);
+ dynamic_symbols = GET_ELF_SYMBOLS (filedata, section, & num_dynamic_syms);
}
else if (section->sh_type == SHT_STRTAB
&& streq (name, ".dynstr"))
continue;
}
- dynamic_strings = (char *) get_data (NULL, file, section->sh_offset,
+ dynamic_strings = (char *) get_data (NULL, filedata, section->sh_offset,
1, section->sh_size,
_("dynamic strings"));
dynamic_strings_length = dynamic_strings == NULL ? 0 : section->sh_size;
else if (section->sh_type == SHT_SYMTAB_SHNDX)
{
elf_section_list * entry = xmalloc (sizeof * entry);
+
entry->hdr = section;
entry->next = symtab_shndx_list;
symtab_shndx_list = entry;
|| 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_")))
{
|| (do_debug_cu_index && const_strneq (name, "cu_index"))
|| (do_debug_cu_index && const_strneq (name, "tu_index"))
)
- request_dump_bynumber (i, DEBUG_DUMP);
+ request_dump_bynumber (filedata, i, DEBUG_DUMP);
}
/* Linkonce section to be combined with .debug_info at link time. */
else if ((do_debugging || do_debug_info)
&& const_strneq (name, ".gnu.linkonce.wi."))
- request_dump_bynumber (i, DEBUG_DUMP);
+ request_dump_bynumber (filedata, i, DEBUG_DUMP);
else if (do_debug_frames && streq (name, ".eh_frame"))
- request_dump_bynumber (i, DEBUG_DUMP);
- else if (do_gdb_index && streq (name, ".gdb_index"))
- request_dump_bynumber (i, DEBUG_DUMP);
+ request_dump_bynumber (filedata, i, DEBUG_DUMP);
+ else if (do_gdb_index && (streq (name, ".gdb_index")
+ || streq (name, ".debug_names")))
+ request_dump_bynumber (filedata, i, DEBUG_DUMP);
/* Trace sections for Itanium VMS. */
else if ((do_debugging || do_trace_info || do_trace_abbrevs
|| do_trace_aranges)
|| (do_trace_abbrevs && streq (name, "abbrev"))
|| (do_trace_aranges && streq (name, "aranges"))
)
- request_dump_bynumber (i, DEBUG_DUMP);
+ request_dump_bynumber (filedata, i, DEBUG_DUMP);
}
+ else if ((do_debugging || do_debug_links)
+ && (const_strneq (name, ".gnu_debuglink")
+ || const_strneq (name, ".gnu_debugaltlink")))
+ request_dump_bynumber (filedata, i, DEBUG_DUMP);
}
if (! do_sections)
- return 1;
+ return TRUE;
- if (elf_header.e_shnum > 1)
+ if (filedata->file_header.e_shnum > 1)
printf (_("\nSection Headers:\n"));
else
printf (_("\nSection Header:\n"));
if (do_section_details)
printf (_(" Flags\n"));
- for (i = 0, section = section_headers;
- i < elf_header.e_shnum;
+ for (i = 0, section = filedata->section_headers;
+ i < filedata->file_header.e_shnum;
i++, section++)
{
/* Run some sanity checks on the section header. */
/* Check the sh_link field. */
switch (section->sh_type)
{
+ case SHT_REL:
+ case SHT_RELA:
+ if (section->sh_link == 0
+ && (filedata->file_header.e_type == ET_EXEC
+ || filedata->file_header.e_type == ET_DYN))
+ /* A dynamic relocation section where all entries use a
+ zero symbol index need not specify a symtab section. */
+ break;
+ /* Fall through. */
case SHT_SYMTAB_SHNDX:
case SHT_GROUP:
case SHT_HASH:
case SHT_GNU_HASH:
case SHT_GNU_versym:
- case SHT_REL:
- case SHT_RELA:
- if (section->sh_link < 1
- || section->sh_link >= elf_header.e_shnum
- || (section_headers[section->sh_link].sh_type != SHT_SYMTAB
- && section_headers[section->sh_link].sh_type != SHT_DYNSYM))
+ if (section->sh_link == 0
+ || section->sh_link >= filedata->file_header.e_shnum
+ || (filedata->section_headers[section->sh_link].sh_type != SHT_SYMTAB
+ && filedata->section_headers[section->sh_link].sh_type != SHT_DYNSYM))
warn (_("[%2u]: Link field (%u) should index a symtab section.\n"),
i, section->sh_link);
break;
case SHT_GNU_verneed:
case SHT_GNU_verdef:
case SHT_GNU_LIBLIST:
- if (section->sh_link < 1
- || section->sh_link >= elf_header.e_shnum
- || section_headers[section->sh_link].sh_type != SHT_STRTAB)
+ if (section->sh_link == 0
+ || section->sh_link >= filedata->file_header.e_shnum
+ || filedata->section_headers[section->sh_link].sh_type != SHT_STRTAB)
warn (_("[%2u]: Link field (%u) should index a string section.\n"),
i, section->sh_link);
break;
{
case SHT_REL:
case SHT_RELA:
- if (section->sh_info < 1
- || section->sh_info >= elf_header.e_shnum
- || (section_headers[section->sh_info].sh_type != SHT_PROGBITS
- && section_headers[section->sh_info].sh_type != SHT_NOBITS
- && section_headers[section->sh_info].sh_type != SHT_NOTE
- && section_headers[section->sh_info].sh_type != SHT_INIT_ARRAY
+ if (section->sh_info == 0
+ && (filedata->file_header.e_type == ET_EXEC
+ || filedata->file_header.e_type == ET_DYN))
+ /* Dynamic relocations apply to segments, so they do not
+ need to specify the section they relocate. */
+ break;
+ if (section->sh_info == 0
+ || section->sh_info >= filedata->file_header.e_shnum
+ || (filedata->section_headers[section->sh_info].sh_type != SHT_PROGBITS
+ && filedata->section_headers[section->sh_info].sh_type != SHT_NOBITS
+ && filedata->section_headers[section->sh_info].sh_type != SHT_NOTE
+ && filedata->section_headers[section->sh_info].sh_type != SHT_INIT_ARRAY
+ && filedata->section_headers[section->sh_info].sh_type != SHT_FINI_ARRAY
+ && filedata->section_headers[section->sh_info].sh_type != SHT_PREINIT_ARRAY
/* FIXME: Are other section types valid ? */
- && section_headers[section->sh_info].sh_type < SHT_LOOS))
- {
- if (section->sh_info == 0
- && (streq (SECTION_NAME (section), ".rel.dyn")
- || streq (SECTION_NAME (section), ".rela.dyn")))
- /* The .rel.dyn and .rela.dyn sections have an sh_info field
- of zero. The relocations in these sections may apply
- to many different sections. */
- ;
- else
- warn (_("[%2u]: Info field (%u) should index a relocatable section.\n"),
- i, section->sh_info);
- }
+ && filedata->section_headers[section->sh_info].sh_type < SHT_LOOS))
+ warn (_("[%2u]: Info field (%u) should index a relocatable section.\n"),
+ i, section->sh_info);
break;
case SHT_DYNAMIC:
;
else if (section->sh_flags & SHF_INFO_LINK)
{
- if (section->sh_info < 1 || section->sh_info >= elf_header.e_shnum)
+ if (section->sh_info < 1 || section->sh_info >= filedata->file_header.e_shnum)
warn (_("[%2u]: Expected link to another section in info field"), i);
}
- else if (section->sh_type < SHT_LOOS && section->sh_info != 0)
+ else if (section->sh_type < SHT_LOOS
+ && (section->sh_flags & SHF_GNU_MBIND) == 0
+ && section->sh_info != 0)
warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
i, section->sh_info);
break;
}
+ /* Check the sh_size field. */
+ if (section->sh_size > filedata->file_size
+ && section->sh_type != SHT_NOBITS
+ && section->sh_type != SHT_NULL
+ && section->sh_type < SHT_LOOS)
+ warn (_("Size of section %u is larger than the entire file!\n"), i);
+
printf (" [%2u] ", i);
if (do_section_details)
- printf ("%s\n ", printable_section_name (section));
+ printf ("%s\n ", printable_section_name (filedata, section));
else
print_symbol (-17, SECTION_NAME (section));
printf (do_wide ? " %-15s " : " %-15.15s ",
- get_section_type_name (section->sh_type));
+ get_section_type_name (filedata, section->sh_type));
if (is_32bit_elf)
{
if (do_section_details)
fputs (" ", stdout);
else
- printf (" %3s ", get_elf_section_flags (section->sh_flags));
+ printf (" %3s ", get_elf_section_flags (filedata, section->sh_flags));
- if (section->sh_link >= elf_header.e_shnum)
+ if (section->sh_link >= filedata->file_header.e_shnum)
{
link_too_big = "";
/* The sh_link value is out of range. Normally this indicates
an error but it can have special values in Solaris binaries. */
- switch (elf_header.e_machine)
+ switch (filedata->file_header.e_machine)
{
case EM_386:
case EM_IAMCU:
if (do_section_details)
fputs (" ", stdout);
else
- printf (" %3s ", get_elf_section_flags (section->sh_flags));
+ printf (" %3s ", get_elf_section_flags (filedata, section->sh_flags));
printf ("%2u %3u ", section->sh_link, section->sh_info);
}
else if (do_section_details)
{
- printf (" %-15.15s ",
- get_section_type_name (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);
printf (" ");
print_vma (section->sh_entsize, LONG_HEX);
- printf (" %3s ", get_elf_section_flags (section->sh_flags));
+ printf (" %3s ", get_elf_section_flags (filedata, section->sh_flags));
printf (" %2u %3u %lu\n",
section->sh_link,
if (do_section_details)
{
- printf (" %s\n", get_elf_section_flags (section->sh_flags));
+ printf (" %s\n", get_elf_section_flags (filedata, section->sh_flags));
if ((section->sh_flags & SHF_COMPRESSED) != 0)
{
/* Minimum section size is 12 bytes for 32-bit compression
unsigned char buf[24];
assert (sizeof (buf) >= sizeof (Elf64_External_Chdr));
- if (get_data (&buf, (FILE *) file, section->sh_offset, 1,
+ if (get_data (&buf, filedata, section->sh_offset, 1,
sizeof (buf), _("compression header")))
{
Elf_Internal_Chdr chdr;
W (write), A (alloc), X (execute), M (merge), S (strings), I (info),\n\
L (link order), O (extra OS processing required), G (group), T (TLS),\n\
C (compressed), x (unknown), o (OS specific), E (exclude),\n "));
- if (elf_header.e_machine == EM_X86_64
- || elf_header.e_machine == EM_L1OM
- || elf_header.e_machine == EM_K1OM)
+ if (filedata->file_header.e_machine == EM_X86_64
+ || filedata->file_header.e_machine == EM_L1OM
+ || filedata->file_header.e_machine == EM_K1OM)
printf (_("l (large), "));
- else if (elf_header.e_machine == EM_ARM)
+ else if (filedata->file_header.e_machine == EM_ARM)
printf (_("y (purecode), "));
+ else if (filedata->file_header.e_machine == EM_PPC)
+ printf (_("v (VLE), "));
printf ("p (processor specific)\n");
}
- return 1;
+ return TRUE;
}
static const char *
return buff;
}
-static int
-process_section_groups (FILE * file)
+static bfd_boolean
+process_section_groups (Filedata * filedata)
{
Elf_Internal_Shdr * section;
unsigned int i;
/* Don't process section groups unless needed. */
if (!do_unwind && !do_section_groups)
- return 1;
+ return TRUE;
- if (elf_header.e_shnum == 0)
+ if (filedata->file_header.e_shnum == 0)
{
if (do_section_groups)
printf (_("\nThere are no sections to group in this file.\n"));
- return 1;
+ return TRUE;
}
- if (section_headers == NULL)
+ if (filedata->section_headers == NULL)
{
error (_("Section headers are not available!\n"));
/* PR 13622: This can happen with a corrupt ELF header. */
- return 0;
+ return FALSE;
}
- section_headers_groups = (struct group **) calloc (elf_header.e_shnum,
+ section_headers_groups = (struct group **) calloc (filedata->file_header.e_shnum,
sizeof (struct group *));
if (section_headers_groups == NULL)
{
error (_("Out of memory reading %u section group headers\n"),
- elf_header.e_shnum);
- return 0;
+ filedata->file_header.e_shnum);
+ return FALSE;
}
/* Scan the sections for the group section. */
group_count = 0;
- for (i = 0, section = section_headers;
- i < elf_header.e_shnum;
+ for (i = 0, section = filedata->section_headers;
+ i < filedata->file_header.e_shnum;
i++, section++)
if (section->sh_type == SHT_GROUP)
group_count++;
if (do_section_groups)
printf (_("\nThere are no section groups in this file.\n"));
- return 1;
+ return TRUE;
}
section_groups = (struct group *) calloc (group_count, sizeof (struct group));
{
error (_("Out of memory reading %lu groups\n"),
(unsigned long) group_count);
- return 0;
+ return FALSE;
}
symtab_sec = NULL;
num_syms = 0;
strtab = NULL;
strtab_size = 0;
- for (i = 0, section = section_headers, group = section_groups;
- i < elf_header.e_shnum;
+ for (i = 0, section = filedata->section_headers, group = section_groups;
+ i < filedata->file_header.e_shnum;
i++, section++)
{
if (section->sh_type == SHT_GROUP)
{
- const char * name = printable_section_name (section);
+ const char * name = printable_section_name (filedata, section);
const char * group_name;
unsigned char * start;
unsigned char * indices;
Elf_Internal_Sym * sym;
/* Get the symbol table. */
- if (section->sh_link >= elf_header.e_shnum
- || ((sec = section_headers + section->sh_link)->sh_type
+ if (section->sh_link >= filedata->file_header.e_shnum
+ || ((sec = filedata->section_headers + section->sh_link)->sh_type
!= SHT_SYMTAB))
{
error (_("Bad sh_link in group section `%s'\n"), name);
symtab_sec = sec;
if (symtab)
free (symtab);
- symtab = GET_ELF_SYMBOLS (file, symtab_sec, & num_syms);
+ symtab = GET_ELF_SYMBOLS (filedata, symtab_sec, & num_syms);
}
if (symtab == NULL)
if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
{
if (sym->st_shndx == 0
- || sym->st_shndx >= elf_header.e_shnum)
+ || sym->st_shndx >= filedata->file_header.e_shnum)
{
error (_("Bad sh_info in group section `%s'\n"), name);
continue;
}
- group_name = SECTION_NAME (section_headers + sym->st_shndx);
+ group_name = SECTION_NAME (filedata->section_headers + sym->st_shndx);
strtab_sec = NULL;
if (strtab)
free (strtab);
else
{
/* Get the string table. */
- if (symtab_sec->sh_link >= elf_header.e_shnum)
+ if (symtab_sec->sh_link >= filedata->file_header.e_shnum)
{
strtab_sec = NULL;
if (strtab)
strtab_size = 0;
}
else if (strtab_sec
- != (sec = section_headers + symtab_sec->sh_link))
+ != (sec = filedata->section_headers + symtab_sec->sh_link))
{
strtab_sec = sec;
if (strtab)
free (strtab);
- strtab = (char *) get_data (NULL, file, strtab_sec->sh_offset,
+ strtab = (char *) get_data (NULL, filedata, strtab_sec->sh_offset,
1, strtab_sec->sh_size,
_("string table"));
strtab_size = strtab != NULL ? strtab_sec->sh_size : 0;
if (section->sh_entsize > section->sh_size)
{
error (_("Section %s has sh_entsize (0x%lx) which is larger than its size (0x%lx)\n"),
- printable_section_name (section),
+ printable_section_name (filedata, section),
(unsigned long) section->sh_entsize,
(unsigned long) section->sh_size);
- break;
+ continue;
}
- start = (unsigned char *) get_data (NULL, file, section->sh_offset,
+ start = (unsigned char *) get_data (NULL, filedata, section->sh_offset,
1, section->sh_size,
_("section data"));
if (start == NULL)
entry = byte_get (indices, 4);
indices += 4;
- if (entry >= elf_header.e_shnum)
+ if (entry >= filedata->file_header.e_shnum)
{
static unsigned num_group_errors = 0;
if (num_group_errors ++ < 10)
{
error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
- entry, i, elf_header.e_shnum - 1);
+ entry, i, filedata->file_header.e_shnum - 1);
if (num_group_errors == 10)
- warn (_("Futher error messages about overlarge group section indicies suppressed\n"));
+ warn (_("Further error messages about overlarge group section indices suppressed\n"));
}
continue;
}
else
{
/* Intel C/C++ compiler may put section 0 in a
- section group. We just warn it the first time
+ section group. We just warn it the first time
and ignore it afterwards. */
- static int warned = 0;
+ static bfd_boolean warned = FALSE;
if (!warned)
{
error (_("section 0 in group section [%5u]\n"),
section_headers_groups [entry]->group_index);
- warned++;
+ warned = TRUE;
}
}
}
if (do_section_groups)
{
- sec = section_headers + entry;
- printf (" [%5u] %s\n", entry, printable_section_name (sec));
+ sec = filedata->section_headers + entry;
+ printf (" [%5u] %s\n", entry, printable_section_name (filedata, sec));
}
g = (struct group_list *) xmalloc (sizeof (struct group_list));
free (symtab);
if (strtab)
free (strtab);
- return 1;
+ return TRUE;
}
/* Data used to display dynamic fixups. */
/* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
library). */
-static void
-dump_ia64_vms_dynamic_fixups (FILE *file, struct ia64_vms_dynfixup *fixup,
- const char *strtab, unsigned int strtab_sz)
+static bfd_boolean
+dump_ia64_vms_dynamic_fixups (Filedata * filedata,
+ struct ia64_vms_dynfixup * fixup,
+ const char * strtab,
+ unsigned int strtab_sz)
{
- Elf64_External_VMS_IMAGE_FIXUP *imfs;
+ Elf64_External_VMS_IMAGE_FIXUP * imfs;
long i;
- const char *lib_name;
+ const char * lib_name;
- imfs = get_data (NULL, file, dynamic_addr + fixup->fixup_rela_off,
+ imfs = get_data (NULL, filedata, dynamic_addr + fixup->fixup_rela_off,
1, fixup->fixup_rela_cnt * sizeof (*imfs),
_("dynamic section image fixups"));
if (!imfs)
- return;
+ return FALSE;
if (fixup->needed < strtab_sz)
lib_name = strtab + fixup->needed;
else
{
- warn ("corrupt library name index of 0x%lx found in dynamic entry",
+ warn (_("corrupt library name index of 0x%lx found in dynamic entry"),
(unsigned long) fixup->needed);
lib_name = "???";
}
}
free (imfs);
+ return TRUE;
}
/* Display IA-64 OpenVMS dynamic relocations (used to relocate an image). */
-static void
-dump_ia64_vms_dynamic_relocs (FILE *file, struct ia64_vms_dynimgrela *imgrela)
+static bfd_boolean
+dump_ia64_vms_dynamic_relocs (Filedata * filedata, struct ia64_vms_dynimgrela *imgrela)
{
Elf64_External_VMS_IMAGE_RELA *imrs;
long i;
- imrs = get_data (NULL, file, dynamic_addr + imgrela->img_rela_off,
+ imrs = get_data (NULL, filedata, dynamic_addr + imgrela->img_rela_off,
1, imgrela->img_rela_cnt * sizeof (*imrs),
_("dynamic section image relocations"));
if (!imrs)
- return;
+ return FALSE;
printf (_("\nImage relocs\n"));
printf
}
free (imrs);
+ return TRUE;
}
/* Display IA-64 OpenVMS dynamic relocations and fixups. */
-static int
-process_ia64_vms_dynamic_relocs (FILE *file)
+static bfd_boolean
+process_ia64_vms_dynamic_relocs (Filedata * filedata)
{
struct ia64_vms_dynfixup fixup;
struct ia64_vms_dynimgrela imgrela;
Elf_Internal_Dyn *entry;
- int res = 0;
bfd_vma strtab_off = 0;
bfd_vma strtab_sz = 0;
char *strtab = NULL;
+ bfd_boolean res = TRUE;
memset (&fixup, 0, sizeof (fixup));
memset (&imgrela, 0, sizeof (imgrela));
case DT_STRSZ:
strtab_sz = entry->d_un.d_val;
if (strtab == NULL)
- strtab = get_data (NULL, file, dynamic_addr + strtab_off,
+ strtab = get_data (NULL, filedata, dynamic_addr + strtab_off,
1, strtab_sz, _("dynamic string section"));
break;
break;
case DT_IA_64_VMS_FIXUP_RELA_OFF:
fixup.fixup_rela_off = entry->d_un.d_val;
- res++;
- dump_ia64_vms_dynamic_fixups (file, &fixup, strtab, strtab_sz);
+ if (! dump_ia64_vms_dynamic_fixups (filedata, &fixup, strtab, strtab_sz))
+ res = FALSE;
break;
-
case DT_IA_64_VMS_IMG_RELA_CNT:
imgrela.img_rela_cnt = entry->d_un.d_val;
break;
case DT_IA_64_VMS_IMG_RELA_OFF:
imgrela.img_rela_off = entry->d_un.d_val;
- res++;
- dump_ia64_vms_dynamic_relocs (file, &imgrela);
+ if (! dump_ia64_vms_dynamic_relocs (filedata, &imgrela))
+ res = FALSE;
break;
default:
int reloc;
int size;
int rela;
-} dynamic_relocations [] =
+}
+ dynamic_relocations [] =
{
- { "REL", DT_REL, DT_RELSZ, FALSE },
- { "RELA", DT_RELA, DT_RELASZ, TRUE },
- { "PLT", DT_JMPREL, DT_PLTRELSZ, UNKNOWN }
+ { "REL", DT_REL, DT_RELSZ, FALSE },
+ { "RELA", DT_RELA, DT_RELASZ, TRUE },
+ { "PLT", DT_JMPREL, DT_PLTRELSZ, UNKNOWN }
};
/* Process the reloc section. */
-static int
-process_relocs (FILE * file)
+static bfd_boolean
+process_relocs (Filedata * filedata)
{
unsigned long rel_size;
unsigned long rel_offset;
-
if (!do_reloc)
- return 1;
+ return TRUE;
if (do_using_dynamic)
{
- int is_rela;
+ int is_rela;
const char * name;
- int has_dynamic_reloc;
+ bfd_boolean has_dynamic_reloc;
unsigned int i;
- has_dynamic_reloc = 0;
+ has_dynamic_reloc = FALSE;
for (i = 0; i < ARRAY_SIZE (dynamic_relocations); i++)
{
rel_size = dynamic_info [dynamic_relocations [i].size];
rel_offset = dynamic_info [dynamic_relocations [i].reloc];
- has_dynamic_reloc |= rel_size;
+ if (rel_size)
+ has_dynamic_reloc = TRUE;
if (is_rela == UNKNOWN)
{
(_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
name, rel_offset, rel_size);
- dump_relocations (file,
- offset_from_vma (file, rel_offset, rel_size),
+ dump_relocations (filedata,
+ offset_from_vma (filedata, rel_offset, rel_size),
rel_size,
dynamic_symbols, num_dynamic_syms,
dynamic_strings, dynamic_strings_length,
- is_rela, 1);
+ is_rela, TRUE /* is_dynamic */);
}
}
- if (is_ia64_vms ())
- has_dynamic_reloc |= process_ia64_vms_dynamic_relocs (file);
+ if (is_ia64_vms (filedata))
+ if (process_ia64_vms_dynamic_relocs (filedata))
+ has_dynamic_reloc = TRUE;
if (! has_dynamic_reloc)
printf (_("\nThere are no dynamic relocations in this file.\n"));
{
Elf_Internal_Shdr * section;
unsigned long i;
- int found = 0;
+ bfd_boolean found = FALSE;
- for (i = 0, section = section_headers;
- i < elf_header.e_shnum;
+ for (i = 0, section = filedata->section_headers;
+ i < filedata->file_header.e_shnum;
i++, section++)
{
if ( section->sh_type != SHT_RELA
{
Elf_Internal_Shdr * strsec;
int is_rela;
+ unsigned long num_rela;
printf (_("\nRelocation section "));
- if (string_table == NULL)
+ if (filedata->string_table == NULL)
printf ("%d", section->sh_name);
else
- printf ("'%s'", printable_section_name (section));
+ printf ("'%s'", printable_section_name (filedata, section));
- printf (_(" at offset 0x%lx contains %lu entries:\n"),
- rel_offset, (unsigned long) (rel_size / section->sh_entsize));
+ num_rela = rel_size / section->sh_entsize;
+ printf (ngettext (" at offset 0x%lx contains %lu entry:\n",
+ " at offset 0x%lx contains %lu entries:\n",
+ num_rela),
+ rel_offset, num_rela);
is_rela = section->sh_type == SHT_RELA;
if (section->sh_link != 0
- && section->sh_link < elf_header.e_shnum)
+ && section->sh_link < filedata->file_header.e_shnum)
{
Elf_Internal_Shdr * symsec;
Elf_Internal_Sym * symtab;
unsigned long strtablen = 0;
char * strtab = NULL;
- symsec = section_headers + section->sh_link;
+ symsec = filedata->section_headers + section->sh_link;
if (symsec->sh_type != SHT_SYMTAB
&& symsec->sh_type != SHT_DYNSYM)
continue;
- symtab = GET_ELF_SYMBOLS (file, symsec, & nsyms);
+ symtab = GET_ELF_SYMBOLS (filedata, symsec, & nsyms);
if (symtab == NULL)
continue;
if (symsec->sh_link != 0
- && symsec->sh_link < elf_header.e_shnum)
+ && symsec->sh_link < filedata->file_header.e_shnum)
{
- strsec = section_headers + symsec->sh_link;
+ strsec = filedata->section_headers + symsec->sh_link;
- strtab = (char *) get_data (NULL, file, strsec->sh_offset,
+ strtab = (char *) get_data (NULL, filedata, strsec->sh_offset,
1, strsec->sh_size,
_("string table"));
strtablen = strtab == NULL ? 0 : strsec->sh_size;
}
- dump_relocations (file, rel_offset, rel_size,
+ dump_relocations (filedata, rel_offset, rel_size,
symtab, nsyms, strtab, strtablen,
is_rela,
symsec->sh_type == SHT_DYNSYM);
free (symtab);
}
else
- dump_relocations (file, rel_offset, rel_size,
- NULL, 0, NULL, 0, is_rela, 0);
+ dump_relocations (filedata, rel_offset, rel_size,
+ NULL, 0, NULL, 0, is_rela,
+ FALSE /* is_dynamic */);
- found = 1;
+ found = TRUE;
}
}
if (! found)
- printf (_("\nThere are no relocations in this file.\n"));
- }
-
- return 1;
-}
+ {
+ /* Users sometimes forget the -D option, so try to be helpful. */
+ for (i = 0; i < ARRAY_SIZE (dynamic_relocations); i++)
+ {
+ if (dynamic_info [dynamic_relocations [i].size])
+ {
+ printf (_("\nThere are no static relocations in this file."));
+ printf (_("\nTo see the dynamic relocations add --use-dynamic to the command line.\n"));
+
+ break;
+ }
+ }
+ if (i == ARRAY_SIZE (dynamic_relocations))
+ printf (_("\nThere are no relocations in this file.\n"));
+ }
+ }
+
+ return TRUE;
+}
/* An absolute address consists of a section and an offset. If the
section is NULL, the offset itself is the address, otherwise, the
bfd_vma offset;
};
-#define ABSADDR(a) \
- ((a).section \
- ? section_headers [(a).section].sh_addr + (a).offset \
- : (a).offset)
-
/* Find the nearest symbol at or below ADDR. Returns the symbol
name, if found, and the offset from the symbol to ADDR. */
static void
-find_symbol_for_address (Elf_Internal_Sym * symtab,
- unsigned long nsyms,
- const char * strtab,
- unsigned long strtab_size,
- struct absaddr addr,
- const char ** symname,
- bfd_vma * offset)
+find_symbol_for_address (Filedata * filedata,
+ Elf_Internal_Sym * symtab,
+ unsigned long nsyms,
+ const char * strtab,
+ unsigned long strtab_size,
+ struct absaddr addr,
+ const char ** symname,
+ bfd_vma * offset)
{
bfd_vma dist = 0x100000;
Elf_Internal_Sym * sym;
*offset = addr.offset;
}
-static int
+static /* signed */ int
symcmp (const void *p, const void *q)
{
Elf_Internal_Sym *sp = (Elf_Internal_Sym *) p;
struct ia64_unw_aux_info
{
- struct ia64_unw_table_entry *table; /* Unwind table. */
- unsigned long table_len; /* Length of unwind table. */
- unsigned char * info; /* Unwind info. */
- unsigned long info_size; /* Size of unwind info. */
- bfd_vma info_addr; /* Starting address of unwind info. */
- bfd_vma seg_base; /* Starting address of segment. */
- Elf_Internal_Sym * symtab; /* The symbol table. */
- unsigned long nsyms; /* Number of symbols. */
- Elf_Internal_Sym * funtab; /* Sorted table of STT_FUNC symbols. */
- unsigned long nfuns; /* Number of entries in funtab. */
- char * strtab; /* The string table. */
- unsigned long strtab_size; /* Size of string table. */
+ struct ia64_unw_table_entry * table; /* Unwind table. */
+ unsigned long table_len; /* Length of unwind table. */
+ unsigned char * info; /* Unwind info. */
+ unsigned long info_size; /* Size of unwind info. */
+ bfd_vma info_addr; /* Starting address of unwind info. */
+ bfd_vma seg_base; /* Starting address of segment. */
+ Elf_Internal_Sym * symtab; /* The symbol table. */
+ unsigned long nsyms; /* Number of symbols. */
+ Elf_Internal_Sym * funtab; /* Sorted table of STT_FUNC symbols. */
+ unsigned long nfuns; /* Number of entries in funtab. */
+ char * strtab; /* The string table. */
+ unsigned long strtab_size; /* Size of string table. */
};
-static void
-dump_ia64_unwind (struct ia64_unw_aux_info * aux)
+static bfd_boolean
+dump_ia64_unwind (Filedata * filedata, struct ia64_unw_aux_info * aux)
{
struct ia64_unw_table_entry * tp;
unsigned long j, nfuns;
int in_body;
+ bfd_boolean res = TRUE;
aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
for (nfuns = 0, j = 0; j < aux->nsyms; j++)
const unsigned char * end;
const char * procname;
- find_symbol_for_address (aux->funtab, aux->nfuns, aux->strtab,
+ find_symbol_for_address (filedata, aux->funtab, aux->nfuns, aux->strtab,
aux->strtab_size, tp->start, &procname, &offset);
fputs ("\n<", stdout);
if (aux->info == NULL)
continue;
+ offset = tp->info.offset;
+ if (tp->info.section)
+ {
+ if (tp->info.section >= filedata->file_header.e_shnum)
+ {
+ warn (_("Invalid section %u in table entry %ld\n"),
+ tp->info.section, (long) (tp - aux->table));
+ res = FALSE;
+ continue;
+ }
+ offset += filedata->section_headers[tp->info.section].sh_addr;
+ }
+ offset -= aux->info_addr;
/* PR 17531: file: 0997b4d1. */
- if ((ABSADDR (tp->info) - aux->info_addr) >= aux->info_size)
+ if (offset >= aux->info_size
+ || aux->info_size - offset < 8)
{
warn (_("Invalid offset %lx in table entry %ld\n"),
(long) tp->info.offset, (long) (tp - aux->table));
+ res = FALSE;
continue;
}
- head = aux->info + (ABSADDR (tp->info) - aux->info_addr);
+ head = aux->info + offset;
stamp = byte_get ((unsigned char *) head, sizeof (stamp));
printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
}
free (aux->funtab);
+
+ return res;
}
static bfd_boolean
-slurp_ia64_unwind_table (FILE * file,
- struct ia64_unw_aux_info * aux,
- Elf_Internal_Shdr * sec)
+slurp_ia64_unwind_table (Filedata * filedata,
+ struct ia64_unw_aux_info * aux,
+ Elf_Internal_Shdr * sec)
{
unsigned long size, nrelas, i;
Elf_Internal_Phdr * seg;
/* First, find the starting address of the segment that includes
this section: */
- if (elf_header.e_phnum)
+ if (filedata->file_header.e_phnum)
{
- if (! get_program_headers (file))
+ if (! get_program_headers (filedata))
return FALSE;
- for (seg = program_headers;
- seg < program_headers + elf_header.e_phnum;
+ for (seg = filedata->program_headers;
+ seg < filedata->program_headers + filedata->file_header.e_phnum;
++seg)
{
if (seg->p_type != PT_LOAD)
/* Second, build the unwind table from the contents of the unwind section: */
size = sec->sh_size;
- table = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1, size,
+ table = (unsigned char *) get_data (NULL, filedata, sec->sh_offset, 1, size,
_("unwind table"));
if (!table)
return FALSE;
free (table);
/* Third, apply any relocations to the unwind table: */
- for (relsec = section_headers;
- relsec < section_headers + elf_header.e_shnum;
+ for (relsec = filedata->section_headers;
+ relsec < filedata->section_headers + filedata->file_header.e_shnum;
++relsec)
{
if (relsec->sh_type != SHT_RELA
- || relsec->sh_info >= elf_header.e_shnum
- || section_headers + relsec->sh_info != sec)
+ || relsec->sh_info >= filedata->file_header.e_shnum
+ || filedata->section_headers + relsec->sh_info != sec)
continue;
- if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
+ if (!slurp_rela_relocs (filedata, relsec->sh_offset, relsec->sh_size,
& rela, & nrelas))
{
free (aux->table);
for (rp = rela; rp < rela + nrelas; ++rp)
{
- relname = elf_ia64_reloc_type (get_reloc_type (rp->r_info));
- sym = aux->symtab + get_reloc_symindex (rp->r_info);
+ unsigned int sym_ndx;
+ unsigned int r_type = get_reloc_type (filedata, rp->r_info);
+ relname = elf_ia64_reloc_type (r_type);
/* PR 17531: file: 9fa67536. */
if (relname == NULL)
{
- warn (_("Skipping unknown relocation type: %u\n"), get_reloc_type (rp->r_info));
+ warn (_("Skipping unknown relocation type: %u\n"), r_type);
continue;
}
continue;
}
+ sym_ndx = get_reloc_symindex (rp->r_info);
+ if (sym_ndx >= aux->nsyms)
+ {
+ warn (_("Skipping reloc with invalid symbol index: %u\n"),
+ sym_ndx);
+ continue;
+ }
+ sym = aux->symtab + sym_ndx;
+
switch (rp->r_offset / eh_addr_size % 3)
{
case 0:
return TRUE;
}
-static void
-ia64_process_unwind (FILE * file)
+static bfd_boolean
+ia64_process_unwind (Filedata * filedata)
{
Elf_Internal_Shdr * sec;
Elf_Internal_Shdr * unwsec = NULL;
Elf_Internal_Shdr * strsec;
unsigned long i, unwcount = 0, unwstart = 0;
struct ia64_unw_aux_info aux;
+ bfd_boolean res = TRUE;
memset (& aux, 0, sizeof (aux));
- for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
+ for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum; ++i, ++sec)
{
if (sec->sh_type == SHT_SYMTAB
- && sec->sh_link < elf_header.e_shnum)
+ && sec->sh_link < filedata->file_header.e_shnum)
{
- aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
+ aux.symtab = GET_ELF_SYMBOLS (filedata, sec, & aux.nsyms);
- strsec = section_headers + sec->sh_link;
+ strsec = filedata->section_headers + sec->sh_link;
if (aux.strtab != NULL)
{
error (_("Multiple auxillary string tables encountered\n"));
free (aux.strtab);
+ res = FALSE;
}
- aux.strtab = (char *) get_data (NULL, file, strsec->sh_offset,
+ aux.strtab = (char *) get_data (NULL, filedata, strsec->sh_offset,
1, strsec->sh_size,
_("string table"));
aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
char * suffix;
size_t len, len2;
- for (i = unwstart, sec = section_headers + unwstart, unwsec = NULL;
- i < elf_header.e_shnum; ++i, ++sec)
+ for (i = unwstart, sec = filedata->section_headers + unwstart, unwsec = NULL;
+ i < filedata->file_header.e_shnum; ++i, ++sec)
if (sec->sh_type == SHT_IA_64_UNWIND)
{
unwsec = sec;
if (section_headers_groups == NULL
|| section_headers_groups [i] == NULL)
- i = elf_header.e_shnum;
+ i = filedata->file_header.e_shnum;
else
{
g = section_headers_groups [i]->root;
for (; g != NULL; g = g->next)
{
- sec = section_headers + g->section_index;
+ sec = filedata->section_headers + g->section_index;
if (streq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info))
break;
}
if (g == NULL)
- i = elf_header.e_shnum;
+ i = filedata->file_header.e_shnum;
}
}
else if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind_once, len))
/* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
len2 = sizeof (ELF_STRING_ia64_unwind_info_once) - 1;
suffix = SECTION_NAME (unwsec) + len;
- for (i = 0, sec = section_headers; i < elf_header.e_shnum;
+ for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum;
++i, ++sec)
if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info_once, len2)
&& streq (SECTION_NAME (sec) + len2, suffix))
suffix = "";
if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind, len))
suffix = SECTION_NAME (unwsec) + len;
- for (i = 0, sec = section_headers; i < elf_header.e_shnum;
+ for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum;
++i, ++sec)
if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info, len2)
&& streq (SECTION_NAME (sec) + len2, suffix))
break;
}
- if (i == elf_header.e_shnum)
+ if (i == filedata->file_header.e_shnum)
{
printf (_("\nCould not find unwind info section for "));
- if (string_table == NULL)
+ if (filedata->string_table == NULL)
printf ("%d", unwsec->sh_name);
else
- printf ("'%s'", printable_section_name (unwsec));
+ printf ("'%s'", printable_section_name (filedata, unwsec));
}
else
{
aux.info_addr = sec->sh_addr;
- aux.info = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1,
+ aux.info = (unsigned char *) get_data (NULL, filedata, sec->sh_offset, 1,
sec->sh_size,
_("unwind info"));
aux.info_size = aux.info == NULL ? 0 : sec->sh_size;
printf (_("\nUnwind section "));
- if (string_table == NULL)
+ if (filedata->string_table == NULL)
printf ("%d", unwsec->sh_name);
else
- printf ("'%s'", printable_section_name (unwsec));
+ printf ("'%s'", printable_section_name (filedata, unwsec));
printf (_(" at offset 0x%lx contains %lu entries:\n"),
(unsigned long) unwsec->sh_offset,
(unsigned long) (unwsec->sh_size / (3 * eh_addr_size)));
- if (slurp_ia64_unwind_table (file, & aux, unwsec)
+ if (slurp_ia64_unwind_table (filedata, & aux, unwsec)
&& aux.table_len > 0)
- dump_ia64_unwind (& aux);
+ dump_ia64_unwind (filedata, & aux);
if (aux.table)
free ((char *) aux.table);
free (aux.symtab);
if (aux.strtab)
free ((char *) aux.strtab);
+
+ return res;
}
struct hppa_unw_table_entry
- {
- struct absaddr start;
- struct absaddr end;
- unsigned int Cannot_unwind:1; /* 0 */
- unsigned int Millicode:1; /* 1 */
- unsigned int Millicode_save_sr0:1; /* 2 */
- unsigned int Region_description:2; /* 3..4 */
- unsigned int reserved1:1; /* 5 */
- unsigned int Entry_SR:1; /* 6 */
- unsigned int Entry_FR:4; /* number saved */ /* 7..10 */
- unsigned int Entry_GR:5; /* number saved */ /* 11..15 */
- unsigned int Args_stored:1; /* 16 */
- unsigned int Variable_Frame:1; /* 17 */
- unsigned int Separate_Package_Body:1; /* 18 */
- unsigned int Frame_Extension_Millicode:1; /* 19 */
- unsigned int Stack_Overflow_Check:1; /* 20 */
- unsigned int Two_Instruction_SP_Increment:1;/* 21 */
- unsigned int Ada_Region:1; /* 22 */
- unsigned int cxx_info:1; /* 23 */
- unsigned int cxx_try_catch:1; /* 24 */
- unsigned int sched_entry_seq:1; /* 25 */
- unsigned int reserved2:1; /* 26 */
- unsigned int Save_SP:1; /* 27 */
- unsigned int Save_RP:1; /* 28 */
- unsigned int Save_MRP_in_frame:1; /* 29 */
- unsigned int extn_ptr_defined:1; /* 30 */
- unsigned int Cleanup_defined:1; /* 31 */
-
- unsigned int MPE_XL_interrupt_marker:1; /* 0 */
- unsigned int HP_UX_interrupt_marker:1; /* 1 */
- unsigned int Large_frame:1; /* 2 */
- unsigned int Pseudo_SP_Set:1; /* 3 */
- unsigned int reserved4:1; /* 4 */
- unsigned int Total_frame_size:27; /* 5..31 */
- };
+{
+ struct absaddr start;
+ struct absaddr end;
+ unsigned int Cannot_unwind:1; /* 0 */
+ unsigned int Millicode:1; /* 1 */
+ unsigned int Millicode_save_sr0:1; /* 2 */
+ unsigned int Region_description:2; /* 3..4 */
+ unsigned int reserved1:1; /* 5 */
+ unsigned int Entry_SR:1; /* 6 */
+ unsigned int Entry_FR:4; /* Number saved 7..10 */
+ unsigned int Entry_GR:5; /* Number saved 11..15 */
+ unsigned int Args_stored:1; /* 16 */
+ unsigned int Variable_Frame:1; /* 17 */
+ unsigned int Separate_Package_Body:1; /* 18 */
+ unsigned int Frame_Extension_Millicode:1; /* 19 */
+ unsigned int Stack_Overflow_Check:1; /* 20 */
+ unsigned int Two_Instruction_SP_Increment:1; /* 21 */
+ unsigned int Ada_Region:1; /* 22 */
+ unsigned int cxx_info:1; /* 23 */
+ unsigned int cxx_try_catch:1; /* 24 */
+ unsigned int sched_entry_seq:1; /* 25 */
+ unsigned int reserved2:1; /* 26 */
+ unsigned int Save_SP:1; /* 27 */
+ unsigned int Save_RP:1; /* 28 */
+ unsigned int Save_MRP_in_frame:1; /* 29 */
+ unsigned int extn_ptr_defined:1; /* 30 */
+ unsigned int Cleanup_defined:1; /* 31 */
+
+ unsigned int MPE_XL_interrupt_marker:1; /* 0 */
+ unsigned int HP_UX_interrupt_marker:1; /* 1 */
+ unsigned int Large_frame:1; /* 2 */
+ unsigned int Pseudo_SP_Set:1; /* 3 */
+ unsigned int reserved4:1; /* 4 */
+ unsigned int Total_frame_size:27; /* 5..31 */
+};
struct hppa_unw_aux_info
{
- struct hppa_unw_table_entry * table; /* Unwind table. */
- unsigned long table_len; /* Length of unwind table. */
- bfd_vma seg_base; /* Starting address of segment. */
- Elf_Internal_Sym * symtab; /* The symbol table. */
- unsigned long nsyms; /* Number of symbols. */
- Elf_Internal_Sym * funtab; /* Sorted table of STT_FUNC symbols. */
- unsigned long nfuns; /* Number of entries in funtab. */
- char * strtab; /* The string table. */
- unsigned long strtab_size; /* Size of string table. */
+ struct hppa_unw_table_entry * table; /* Unwind table. */
+ unsigned long table_len; /* Length of unwind table. */
+ bfd_vma seg_base; /* Starting address of segment. */
+ Elf_Internal_Sym * symtab; /* The symbol table. */
+ unsigned long nsyms; /* Number of symbols. */
+ Elf_Internal_Sym * funtab; /* Sorted table of STT_FUNC symbols. */
+ unsigned long nfuns; /* Number of entries in funtab. */
+ char * strtab; /* The string table. */
+ unsigned long strtab_size; /* Size of string table. */
};
-static void
-dump_hppa_unwind (struct hppa_unw_aux_info * aux)
+static bfd_boolean
+dump_hppa_unwind (Filedata * filedata, struct hppa_unw_aux_info * aux)
{
struct hppa_unw_table_entry * tp;
unsigned long j, nfuns;
+ bfd_boolean res = TRUE;
aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
for (nfuns = 0, j = 0; j < aux->nsyms; j++)
bfd_vma offset;
const char * procname;
- find_symbol_for_address (aux->funtab, aux->nfuns, aux->strtab,
+ find_symbol_for_address (filedata, aux->funtab, aux->nfuns, aux->strtab,
aux->strtab_size, tp->start, &procname,
&offset);
printf ("\n");
free (aux->funtab);
+
+ return res;
}
-static int
-slurp_hppa_unwind_table (FILE * file,
- struct hppa_unw_aux_info * aux,
- Elf_Internal_Shdr * sec)
+static bfd_boolean
+slurp_hppa_unwind_table (Filedata * filedata,
+ struct hppa_unw_aux_info * aux,
+ Elf_Internal_Shdr * sec)
{
unsigned long size, unw_ent_size, nentries, nrelas, i;
Elf_Internal_Phdr * seg;
/* First, find the starting address of the segment that includes
this section. */
-
- if (elf_header.e_phnum)
+ if (filedata->file_header.e_phnum)
{
- if (! get_program_headers (file))
- return 0;
+ if (! get_program_headers (filedata))
+ return FALSE;
- for (seg = program_headers;
- seg < program_headers + elf_header.e_phnum;
+ for (seg = filedata->program_headers;
+ seg < filedata->program_headers + filedata->file_header.e_phnum;
++seg)
{
if (seg->p_type != PT_LOAD)
/* Second, build the unwind table from the contents of the unwind
section. */
size = sec->sh_size;
- table = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1, size,
+ table = (unsigned char *) get_data (NULL, filedata, sec->sh_offset, 1, size,
_("unwind table"));
if (!table)
- return 0;
+ return FALSE;
unw_ent_size = 16;
nentries = size / unw_ent_size;
free (table);
/* Third, apply any relocations to the unwind table. */
- for (relsec = section_headers;
- relsec < section_headers + elf_header.e_shnum;
+ for (relsec = filedata->section_headers;
+ relsec < filedata->section_headers + filedata->file_header.e_shnum;
++relsec)
{
if (relsec->sh_type != SHT_RELA
- || relsec->sh_info >= elf_header.e_shnum
- || section_headers + relsec->sh_info != sec)
+ || relsec->sh_info >= filedata->file_header.e_shnum
+ || filedata->section_headers + relsec->sh_info != sec)
continue;
- if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
+ if (!slurp_rela_relocs (filedata, relsec->sh_offset, relsec->sh_size,
& rela, & nrelas))
- return 0;
+ return FALSE;
for (rp = rela; rp < rela + nrelas; ++rp)
{
- relname = elf_hppa_reloc_type (get_reloc_type (rp->r_info));
- sym = aux->symtab + get_reloc_symindex (rp->r_info);
+ unsigned int sym_ndx;
+ unsigned int r_type = get_reloc_type (filedata, rp->r_info);
+ relname = elf_hppa_reloc_type (r_type);
+
+ if (relname == NULL)
+ {
+ warn (_("Skipping unknown relocation type: %u\n"), r_type);
+ continue;
+ }
/* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
if (! const_strneq (relname, "R_PARISC_SEGREL"))
{
- warn (_("Skipping unexpected relocation type %s\n"), relname);
+ warn (_("Skipping unexpected relocation type: %s\n"), relname);
continue;
}
i = rp->r_offset / unw_ent_size;
+ if (i >= aux->table_len)
+ {
+ warn (_("Skipping reloc with overlarge offset: %lx\n"), i);
+ continue;
+ }
+
+ sym_ndx = get_reloc_symindex (rp->r_info);
+ if (sym_ndx >= aux->nsyms)
+ {
+ warn (_("Skipping reloc with invalid symbol index: %u\n"),
+ sym_ndx);
+ continue;
+ }
+ sym = aux->symtab + sym_ndx;
- switch ((rp->r_offset % unw_ent_size) / eh_addr_size)
+ switch ((rp->r_offset % unw_ent_size) / 4)
{
case 0:
aux->table[i].start.section = sym->st_shndx;
aux->table_len = nentries;
- return 1;
+ return TRUE;
}
-static void
-hppa_process_unwind (FILE * file)
+static bfd_boolean
+hppa_process_unwind (Filedata * filedata)
{
struct hppa_unw_aux_info aux;
Elf_Internal_Shdr * unwsec = NULL;
Elf_Internal_Shdr * strsec;
Elf_Internal_Shdr * sec;
unsigned long i;
+ bfd_boolean res = TRUE;
- if (string_table == NULL)
- return;
+ if (filedata->string_table == NULL)
+ return FALSE;
memset (& aux, 0, sizeof (aux));
- for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
+ for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum; ++i, ++sec)
{
if (sec->sh_type == SHT_SYMTAB
- && sec->sh_link < elf_header.e_shnum)
+ && sec->sh_link < filedata->file_header.e_shnum)
{
- aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
+ aux.symtab = GET_ELF_SYMBOLS (filedata, sec, & aux.nsyms);
- strsec = section_headers + sec->sh_link;
+ strsec = filedata->section_headers + sec->sh_link;
if (aux.strtab != NULL)
{
error (_("Multiple auxillary string tables encountered\n"));
free (aux.strtab);
+ res = FALSE;
}
- aux.strtab = (char *) get_data (NULL, file, strsec->sh_offset,
+ aux.strtab = (char *) get_data (NULL, filedata, strsec->sh_offset,
1, strsec->sh_size,
_("string table"));
aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
if (!unwsec)
printf (_("\nThere are no unwind sections in this file.\n"));
- for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
+ for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum; ++i, ++sec)
{
if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
{
- printf (_("\nUnwind section '%s' at offset 0x%lx contains %lu entries:\n"),
- printable_section_name (sec),
+ unsigned long num_unwind = sec->sh_size / 16;
+
+ printf (ngettext ("\nUnwind section '%s' at offset 0x%lx "
+ "contains %lu entry:\n",
+ "\nUnwind section '%s' at offset 0x%lx "
+ "contains %lu entries:\n",
+ num_unwind),
+ printable_section_name (filedata, sec),
(unsigned long) sec->sh_offset,
- (unsigned long) (sec->sh_size / (2 * eh_addr_size + 8)));
+ num_unwind);
- slurp_hppa_unwind_table (file, &aux, sec);
- if (aux.table_len > 0)
- dump_hppa_unwind (&aux);
+ if (! slurp_hppa_unwind_table (filedata, &aux, sec))
+ res = FALSE;
+
+ if (res && aux.table_len > 0)
+ {
+ if (! dump_hppa_unwind (filedata, &aux))
+ res = FALSE;
+ }
if (aux.table)
free ((char *) aux.table);
free (aux.symtab);
if (aux.strtab)
free ((char *) aux.strtab);
+
+ return res;
}
struct arm_section
struct arm_unw_aux_info
{
- FILE * file; /* The file containing the unwind sections. */
+ Filedata * filedata; /* The file containing the unwind sections. */
Elf_Internal_Sym * symtab; /* The file's symbol table. */
unsigned long nsyms; /* Number of symbols. */
Elf_Internal_Sym * funtab; /* Sorted table of STT_FUNC symbols. */
};
static const char *
-arm_print_vma_and_name (struct arm_unw_aux_info *aux,
- bfd_vma fn, struct absaddr addr)
+arm_print_vma_and_name (Filedata * filedata,
+ struct arm_unw_aux_info * aux,
+ bfd_vma fn,
+ struct absaddr addr)
{
const char *procname;
bfd_vma sym_offset;
if (addr.section == SHN_UNDEF)
addr.offset = fn;
- find_symbol_for_address (aux->funtab, aux->nfuns, aux->strtab,
+ find_symbol_for_address (filedata, aux->funtab, aux->nfuns, aux->strtab,
aux->strtab_size, addr, &procname,
&sym_offset);
5) Return TRUE upon success, FALSE otherwise. */
static bfd_boolean
-get_unwind_section_word (struct arm_unw_aux_info * aux,
+get_unwind_section_word (Filedata * filedata,
+ struct arm_unw_aux_info * aux,
struct arm_section * arm_sec,
Elf_Internal_Shdr * sec,
bfd_vma word_offset,
arm_free_section (arm_sec);
arm_sec->sec = sec;
- arm_sec->data = get_data (NULL, aux->file, sec->sh_offset, 1,
+ arm_sec->data = get_data (NULL, aux->filedata, sec->sh_offset, 1,
sec->sh_size, _("unwind data"));
arm_sec->rela = NULL;
arm_sec->nrelas = 0;
- for (relsec = section_headers;
- relsec < section_headers + elf_header.e_shnum;
+ for (relsec = filedata->section_headers;
+ relsec < filedata->section_headers + filedata->file_header.e_shnum;
++relsec)
{
- if (relsec->sh_info >= elf_header.e_shnum
- || section_headers + relsec->sh_info != sec
+ if (relsec->sh_info >= filedata->file_header.e_shnum
+ || filedata->section_headers + relsec->sh_info != sec
/* PR 15745: Check the section type as well. */
|| (relsec->sh_type != SHT_REL
&& relsec->sh_type != SHT_RELA))
arm_sec->rel_type = relsec->sh_type;
if (relsec->sh_type == SHT_REL)
{
- if (!slurp_rel_relocs (aux->file, relsec->sh_offset,
+ if (!slurp_rel_relocs (aux->filedata, relsec->sh_offset,
relsec->sh_size,
& arm_sec->rela, & arm_sec->nrelas))
return FALSE;
}
else /* relsec->sh_type == SHT_RELA */
{
- if (!slurp_rela_relocs (aux->file, relsec->sh_offset,
+ if (!slurp_rela_relocs (aux->filedata, relsec->sh_offset,
relsec->sh_size,
& arm_sec->rela, & arm_sec->nrelas))
return FALSE;
return FALSE;
/* If the offset is invalid then fail. */
- if (word_offset > (sec->sh_size - 4)
- /* PR 18879 */
- || (sec->sh_size < 5 && word_offset >= sec->sh_size)
+ if (/* PR 21343 *//* PR 18879 */
+ sec->sh_size < 4
+ || word_offset > (sec->sh_size - 4)
|| ((bfd_signed_vma) word_offset) < 0)
return FALSE;
prelval = offset - (arm_sec->sec->sh_addr + rp->r_offset);
/* Check that we are processing the expected reloc type. */
- if (elf_header.e_machine == EM_ARM)
+ if (filedata->file_header.e_machine == EM_ARM)
{
relname = elf_arm_reloc_type (ELF32_R_TYPE (rp->r_info));
if (relname == NULL)
continue;
}
}
- else if (elf_header.e_machine == EM_TI_C6000)
+ else if (filedata->file_header.e_machine == EM_TI_C6000)
{
relname = elf_tic6x_reloc_type (ELF32_R_TYPE (rp->r_info));
if (relname == NULL)
if (remaining == 0 && more_words) \
{ \
data_offset += 4; \
- if (! get_unwind_section_word (aux, data_arm_sec, data_sec, \
+ if (! get_unwind_section_word (filedata, aux, data_arm_sec, data_sec, \
data_offset, & word, & addr, NULL)) \
- return; \
+ return FALSE; \
remaining = 4; \
more_words--; \
} \
else \
{ \
printf (_("[Truncated opcode]\n")); \
- return; \
+ return FALSE; \
} \
printf ("0x%02x ", OP)
-static void
-decode_arm_unwind_bytecode (struct arm_unw_aux_info * aux,
+static bfd_boolean
+decode_arm_unwind_bytecode (Filedata * filedata,
+ struct arm_unw_aux_info * aux,
unsigned int word,
unsigned int remaining,
unsigned int more_words,
struct arm_section * data_arm_sec)
{
struct absaddr addr;
+ bfd_boolean res = TRUE;
/* Decode the unwinding instructions. */
while (1)
else
{
unsigned int mask = ((op & 0x0f) << 8) | op2;
- int first = 1;
+ bfd_boolean first = TRUE;
int i;
printf ("pop {");
if (mask & (1 << i))
{
if (first)
- first = 0;
+ first = FALSE;
else
printf (", ");
printf ("r%d", 4 + i);
else if ((op & 0xf0) == 0xa0)
{
int end = 4 + (op & 0x07);
- int first = 1;
+ bfd_boolean first = TRUE;
int i;
printf (" pop {");
for (i = 4; i <= end; i++)
{
if (first)
- first = 0;
+ first = FALSE;
else
printf (", ");
printf ("r%d", i);
else
{
unsigned int mask = op2 & 0x0f;
- int first = 1;
+ bfd_boolean first = TRUE;
int i;
printf ("pop {");
if (mask & (1 << i))
{
if (first)
- first = 0;
+ first = FALSE;
else
printf (", ");
printf ("r%d", i);
break;
}
if (i == sizeof (buf))
- printf (_("corrupt change to vsp"));
+ {
+ error (_("corrupt change to vsp"));
+ res = FALSE;
+ }
else
{
- offset = read_uleb128 (buf, &len, buf + i + 1);
+ offset = read_leb128 (buf, buf + i + 1, FALSE, &len, NULL);
assert (len == i + 1);
offset = offset * 4 + 0x204;
printf ("vsp = vsp + %ld", offset);
else
{
unsigned int mask = op2 & 0x0f;
- int first = 1;
+ bfd_boolean first = TRUE;
int i;
printf ("pop {");
if (mask & (1 << i))
{
if (first)
- first = 0;
+ first = FALSE;
else
printf (", ");
printf ("wCGR%d", i);
}
}
else
- printf (_(" [unsupported opcode]"));
+ {
+ printf (_(" [unsupported opcode]"));
+ res = FALSE;
+ }
+
printf ("\n");
}
+
+ return res;
}
-static void
-decode_tic6x_unwind_bytecode (struct arm_unw_aux_info * aux,
+static bfd_boolean
+decode_tic6x_unwind_bytecode (Filedata * filedata,
+ struct arm_unw_aux_info * aux,
unsigned int word,
unsigned int remaining,
unsigned int more_words,
const char *name;
struct
{
- unsigned int offset;
- unsigned int reg;
+ unsigned int offset;
+ unsigned int reg;
} regpos[16];
/* Scan entire instruction first so that GET_OP output is not
}
printf (_("pop frame {"));
- reg = nregs - 1;
- for (i = i * 2; i > 0; i--)
+ if (nregs == 0)
+ {
+ printf (_("*corrupt* - no registers specified"));
+ }
+ else
{
- if (regpos[reg].offset == i - 1)
+ reg = nregs - 1;
+ for (i = i * 2; i > 0; i--)
{
- name = tic6x_unwind_regnames[regpos[reg].reg];
- if (reg > 0)
- reg--;
- }
- else
- name = _("[pad]");
+ if (regpos[reg].offset == i - 1)
+ {
+ name = tic6x_unwind_regnames[regpos[reg].reg];
+ if (reg > 0)
+ reg--;
+ }
+ else
+ name = _("[pad]");
- fputs (name, stdout);
- if (i > 1)
- printf (", ");
+ fputs (name, stdout);
+ if (i > 1)
+ printf (", ");
+ }
}
printf ("}");
/* PR 17531: file: id:000001,src:001906+004739,op:splice,rep:2. */
if (i == sizeof (buf))
{
- printf ("<corrupt sp adjust>\n");
warn (_("Corrupt stack pointer adjustment detected\n"));
- return;
+ return FALSE;
}
- offset = read_uleb128 (buf, &len, buf + i + 1);
+ offset = read_leb128 (buf, buf + i + 1, FALSE, &len, NULL);
assert (len == i + 1);
offset = offset * 8 + 0x408;
printf (_("sp = sp + %ld"), offset);
}
putchar ('\n');
}
+
+ return TRUE;
}
static bfd_vma
-arm_expand_prel31 (bfd_vma word, bfd_vma where)
+arm_expand_prel31 (Filedata * filedata, bfd_vma word, bfd_vma where)
{
bfd_vma offset;
if (offset & 0x40000000)
offset |= ~ (bfd_vma) 0x7fffffff;
- if (elf_header.e_machine == EM_TI_C6000)
+ if (filedata->file_header.e_machine == EM_TI_C6000)
offset <<= 1;
return offset + where;
}
-static void
-decode_arm_unwind (struct arm_unw_aux_info * aux,
+static bfd_boolean
+decode_arm_unwind (Filedata * filedata,
+ struct arm_unw_aux_info * aux,
unsigned int word,
unsigned int remaining,
bfd_vma data_offset,
unsigned int more_words = 0;
struct absaddr addr;
bfd_vma sym_name = (bfd_vma) -1;
+ bfd_boolean res = TRUE;
if (remaining == 0)
{
here will always be 0. So we also pass in the sym_name
parameter so that we can find the symbol associated with
the personality routine. */
- if (! get_unwind_section_word (aux, data_arm_sec, data_sec, data_offset,
+ if (! get_unwind_section_word (filedata, aux, data_arm_sec, data_sec, data_offset,
& word, & addr, & sym_name))
- return;
+ return FALSE;
remaining = 4;
}
+ else
+ {
+ addr.section = SHN_UNDEF;
+ addr.offset = 0;
+ }
if ((word & 0x80000000) == 0)
{
bfd_vma fn;
const char *procname;
- fn = arm_expand_prel31 (word, data_sec->sh_addr + data_offset);
+ fn = arm_expand_prel31 (filedata, word, data_sec->sh_addr + data_offset);
printf (_(" Personality routine: "));
if (fn == 0
&& addr.section == SHN_UNDEF && addr.offset == 0
}
}
else
- procname = arm_print_vma_and_name (aux, fn, addr);
+ procname = arm_print_vma_and_name (filedata, aux, fn, addr);
fputc ('\n', stdout);
/* The GCC personality routines use the standard compact
if (!remaining)
{
printf (_(" [Truncated data]\n"));
- return;
+ return FALSE;
}
more_words = word >> 24;
word <<= 8;
per_index = -1;
}
else
- return;
+ return TRUE;
}
else
{
-- ----- ----- ----
1 0 index Data for personalityRoutine[index] */
- if (elf_header.e_machine == EM_ARM
+ if (filedata->file_header.e_machine == EM_ARM
&& (word & 0x70000000))
- warn (_("Corrupt ARM compact model table entry: %x \n"), word);
+ {
+ warn (_("Corrupt ARM compact model table entry: %x \n"), word);
+ res = FALSE;
+ }
per_index = (word >> 24) & 0x7f;
printf (_(" Compact model index: %d\n"), per_index);
}
}
- switch (elf_header.e_machine)
+ switch (filedata->file_header.e_machine)
{
case EM_ARM:
if (per_index < 3)
{
- decode_arm_unwind_bytecode (aux, word, remaining, more_words,
- data_offset, data_sec, data_arm_sec);
+ if (! decode_arm_unwind_bytecode (filedata, aux, word, remaining, more_words,
+ data_offset, data_sec, data_arm_sec))
+ res = FALSE;
}
else
{
warn (_("Unknown ARM compact model index encountered\n"));
printf (_(" [reserved]\n"));
+ res = FALSE;
}
break;
case EM_TI_C6000:
if (per_index < 3)
{
- decode_tic6x_unwind_bytecode (aux, word, remaining, more_words,
- data_offset, data_sec, data_arm_sec);
+ if (! decode_tic6x_unwind_bytecode (filedata, aux, word, remaining, more_words,
+ data_offset, data_sec, data_arm_sec))
+ res = FALSE;
}
else if (per_index < 5)
{
default:
error (_("Unsupported architecture type %d encountered when decoding unwind table\n"),
- elf_header.e_machine);
+ filedata->file_header.e_machine);
+ res = FALSE;
}
/* Decode the descriptors. Not implemented. */
+
+ return res;
}
-static void
-dump_arm_unwind (struct arm_unw_aux_info *aux, Elf_Internal_Shdr *exidx_sec)
+static bfd_boolean
+dump_arm_unwind (Filedata * filedata,
+ struct arm_unw_aux_info * aux,
+ Elf_Internal_Shdr * exidx_sec)
{
struct arm_section exidx_arm_sec, extab_arm_sec;
unsigned int i, exidx_len;
unsigned long j, nfuns;
+ bfd_boolean res = TRUE;
memset (&exidx_arm_sec, 0, sizeof (exidx_arm_sec));
memset (&extab_arm_sec, 0, sizeof (extab_arm_sec));
fputc ('\n', stdout);
- if (! get_unwind_section_word (aux, & exidx_arm_sec, exidx_sec,
+ if (! get_unwind_section_word (filedata, aux, & exidx_arm_sec, exidx_sec,
8 * i, & exidx_fn, & fn_addr, NULL)
- || ! get_unwind_section_word (aux, & exidx_arm_sec, exidx_sec,
+ || ! get_unwind_section_word (filedata, aux, & exidx_arm_sec, exidx_sec,
8 * i + 4, & exidx_entry, & entry_addr, NULL))
{
free (aux->funtab);
arm_free_section (& exidx_arm_sec);
arm_free_section (& extab_arm_sec);
- return;
+ return FALSE;
}
/* ARM EHABI, Section 5:
An index table entry consists of 2 words.
The first word contains a prel31 offset to the start of a function, with bit 31 clear. */
if (exidx_fn & 0x80000000)
- warn (_("corrupt index table entry: %x\n"), exidx_fn);
+ {
+ warn (_("corrupt index table entry: %x\n"), exidx_fn);
+ res = FALSE;
+ }
- fn = arm_expand_prel31 (exidx_fn, exidx_sec->sh_addr + 8 * i);
+ fn = arm_expand_prel31 (filedata, exidx_fn, exidx_sec->sh_addr + 8 * i);
- arm_print_vma_and_name (aux, fn, fn_addr);
+ arm_print_vma_and_name (filedata, aux, fn, fn_addr);
fputs (": ", stdout);
if (exidx_entry == 1)
{
print_vma (exidx_entry, PREFIX_HEX);
fputc ('\n', stdout);
- decode_arm_unwind (aux, exidx_entry, 4, 0, NULL, NULL);
+ decode_arm_unwind (filedata, aux, exidx_entry, 4, 0, NULL, NULL);
}
else
{
Elf_Internal_Shdr *table_sec;
fputs ("@", stdout);
- table = arm_expand_prel31 (exidx_entry, exidx_sec->sh_addr + 8 * i + 4);
+ table = arm_expand_prel31 (filedata, exidx_entry, exidx_sec->sh_addr + 8 * i + 4);
print_vma (table, PREFIX_HEX);
printf ("\n");
/* Locate the matching .ARM.extab. */
if (entry_addr.section != SHN_UNDEF
- && entry_addr.section < elf_header.e_shnum)
+ && entry_addr.section < filedata->file_header.e_shnum)
{
- table_sec = section_headers + entry_addr.section;
+ table_sec = filedata->section_headers + entry_addr.section;
table_offset = entry_addr.offset;
/* PR 18879 */
if (table_offset > table_sec->sh_size
{
warn (_("Unwind entry contains corrupt offset (0x%lx) into section %s\n"),
(unsigned long) table_offset,
- printable_section_name (table_sec));
+ printable_section_name (filedata, table_sec));
+ res = FALSE;
continue;
}
}
else
{
- table_sec = find_section_by_address (table);
+ table_sec = find_section_by_address (filedata, table);
if (table_sec != NULL)
table_offset = table - table_sec->sh_addr;
}
+
if (table_sec == NULL)
{
warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
(unsigned long) table);
+ res = FALSE;
continue;
}
- decode_arm_unwind (aux, 0, 0, table_offset, table_sec,
- &extab_arm_sec);
+
+ if (! decode_arm_unwind (filedata, aux, 0, 0, table_offset, table_sec,
+ &extab_arm_sec))
+ res = FALSE;
}
}
free (aux->funtab);
arm_free_section (&exidx_arm_sec);
arm_free_section (&extab_arm_sec);
+
+ return res;
}
/* Used for both ARM and C6X unwinding tables. */
-static void
-arm_process_unwind (FILE *file)
+static bfd_boolean
+arm_process_unwind (Filedata * filedata)
{
struct arm_unw_aux_info aux;
Elf_Internal_Shdr *unwsec = NULL;
Elf_Internal_Shdr *sec;
unsigned long i;
unsigned int sec_type;
+ bfd_boolean res = TRUE;
- switch (elf_header.e_machine)
+ switch (filedata->file_header.e_machine)
{
case EM_ARM:
sec_type = SHT_ARM_EXIDX;
default:
error (_("Unsupported architecture type %d encountered when processing unwind table\n"),
- elf_header.e_machine);
- return;
+ filedata->file_header.e_machine);
+ return FALSE;
}
- if (string_table == NULL)
- return;
+ if (filedata->string_table == NULL)
+ return FALSE;
memset (& aux, 0, sizeof (aux));
- aux.file = file;
+ aux.filedata = filedata;
- for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
+ for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum; ++i, ++sec)
{
- if (sec->sh_type == SHT_SYMTAB && sec->sh_link < elf_header.e_shnum)
+ if (sec->sh_type == SHT_SYMTAB && sec->sh_link < filedata->file_header.e_shnum)
{
- aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
+ aux.symtab = GET_ELF_SYMBOLS (filedata, sec, & aux.nsyms);
- strsec = section_headers + sec->sh_link;
+ strsec = filedata->section_headers + sec->sh_link;
/* PR binutils/17531 file: 011-12666-0.004. */
if (aux.strtab != NULL)
{
error (_("Multiple string tables found in file.\n"));
free (aux.strtab);
+ res = FALSE;
}
- aux.strtab = get_data (NULL, file, strsec->sh_offset,
+ aux.strtab = get_data (NULL, filedata, strsec->sh_offset,
1, strsec->sh_size, _("string table"));
aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
}
if (unwsec == NULL)
printf (_("\nThere are no unwind sections in this file.\n"));
else
- for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
+ for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum; ++i, ++sec)
{
if (sec->sh_type == sec_type)
{
- printf (_("\nUnwind table index '%s' at offset 0x%lx contains %lu entries:\n"),
- printable_section_name (sec),
+ unsigned long num_unwind = sec->sh_size / (2 * eh_addr_size);
+ printf (ngettext ("\nUnwind section '%s' at offset 0x%lx "
+ "contains %lu entry:\n",
+ "\nUnwind section '%s' at offset 0x%lx "
+ "contains %lu entries:\n",
+ num_unwind),
+ printable_section_name (filedata, sec),
(unsigned long) sec->sh_offset,
- (unsigned long) (sec->sh_size / (2 * eh_addr_size)));
+ num_unwind);
- dump_arm_unwind (&aux, sec);
+ if (! dump_arm_unwind (filedata, &aux, sec))
+ res = FALSE;
}
}
free (aux.symtab);
if (aux.strtab)
free ((char *) aux.strtab);
+
+ return res;
}
-static void
-process_unwind (FILE * file)
+static bfd_boolean
+process_unwind (Filedata * filedata)
{
struct unwind_handler
{
- int machtype;
- void (* handler)(FILE *);
+ unsigned int machtype;
+ bfd_boolean (* handler)(Filedata *);
} handlers[] =
{
{ EM_ARM, arm_process_unwind },
{ EM_IA_64, ia64_process_unwind },
{ EM_PARISC, hppa_process_unwind },
{ EM_TI_C6000, arm_process_unwind },
- { 0, 0 }
+ { 0, NULL }
};
int i;
if (!do_unwind)
- return;
+ return TRUE;
for (i = 0; handlers[i].handler != NULL; i++)
- if (elf_header.e_machine == handlers[i].machtype)
- {
- handlers[i].handler (file);
- return;
- }
+ if (filedata->file_header.e_machine == handlers[i].machtype)
+ return handlers[i].handler (filedata);
printf (_("\nThe decoding of unwind sections for machine type %s is not currently supported.\n"),
- get_machine_name (elf_header.e_machine));
+ get_machine_name (filedata->file_header.e_machine));
+ return TRUE;
+}
+
+static void
+dynamic_section_aarch64_val (Elf_Internal_Dyn * entry)
+{
+ switch (entry->d_tag)
+ {
+ case DT_AARCH64_BTI_PLT:
+ case DT_AARCH64_PAC_PLT:
+ break;
+ default:
+ print_vma (entry->d_un.d_ptr, PREFIX_HEX);
+ break;
+ }
+ putchar ('\n');
}
static void
"RLD_ORDER_SAFE"
};
unsigned int cnt;
- int first = 1;
+ bfd_boolean first = TRUE;
for (cnt = 0; cnt < ARRAY_SIZE (opts); ++cnt)
if (entry->d_un.d_val & (1 << cnt))
{
printf ("%s%s", first ? "" : " ", opts[cnt]);
- first = 0;
+ first = FALSE;
}
}
break;
print_vma (entry->d_un.d_val, DEC);
break;
+ case DT_MIPS_XHASH:
+ dynamic_info_DT_MIPS_XHASH = entry->d_un.d_val;
+ dynamic_info_DT_GNU_HASH = entry->d_un.d_val;
+ /* Falls through. */
+
default:
print_vma (entry->d_un.d_ptr, PREFIX_HEX);
}
{ DT_HP_GROUP, "HP_GROUP" },
{ DT_HP_PROTECT_LINKAGE_TABLE, "HP_PROTECT_LINKAGE_TABLE" }
};
- int first = 1;
+ bfd_boolean first = TRUE;
size_t cnt;
bfd_vma val = entry->d_un.d_val;
if (! first)
putchar (' ');
fputs (flags[cnt].str, stdout);
- first = 0;
+ first = FALSE;
val ^= flags[cnt].bit;
}
putchar ('\n');
}
-static int
-get_32bit_dynamic_section (FILE * file)
+static bfd_boolean
+get_32bit_dynamic_section (Filedata * filedata)
{
Elf32_External_Dyn * edyn;
Elf32_External_Dyn * ext;
Elf_Internal_Dyn * entry;
- edyn = (Elf32_External_Dyn *) get_data (NULL, file, dynamic_addr, 1,
+ edyn = (Elf32_External_Dyn *) get_data (NULL, filedata, dynamic_addr, 1,
dynamic_size, _("dynamic section"));
if (!edyn)
- return 0;
+ return FALSE;
/* SGI's ELF has more than one section in the DYNAMIC segment, and we
might not have the luxury of section headers. Look for the DT_NULL
error (_("Out of memory allocating space for %lu dynamic entries\n"),
(unsigned long) dynamic_nent);
free (edyn);
- return 0;
+ return FALSE;
}
for (ext = edyn, entry = dynamic_section;
free (edyn);
- return 1;
+ return TRUE;
}
-static int
-get_64bit_dynamic_section (FILE * file)
+static bfd_boolean
+get_64bit_dynamic_section (Filedata * filedata)
{
Elf64_External_Dyn * edyn;
Elf64_External_Dyn * ext;
Elf_Internal_Dyn * entry;
/* Read in the data. */
- edyn = (Elf64_External_Dyn *) get_data (NULL, file, dynamic_addr, 1,
+ edyn = (Elf64_External_Dyn *) get_data (NULL, filedata, dynamic_addr, 1,
dynamic_size, _("dynamic section"));
if (!edyn)
- return 0;
+ return FALSE;
/* SGI's ELF has more than one section in the DYNAMIC segment, and we
might not have the luxury of section headers. Look for the DT_NULL
error (_("Out of memory allocating space for %lu dynamic entries\n"),
(unsigned long) dynamic_nent);
free (edyn);
- return 0;
+ return FALSE;
}
/* Convert from external to internal formats. */
free (edyn);
- return 1;
+ return TRUE;
}
static void
print_dynamic_flags (bfd_vma flags)
{
- int first = 1;
+ bfd_boolean first = TRUE;
while (flags)
{
flags &= ~ flag;
if (first)
- first = 0;
+ first = FALSE;
else
putc (' ', stdout);
/* Parse and display the contents of the dynamic section. */
-static int
-process_dynamic_section (FILE * file)
+static bfd_boolean
+process_dynamic_section (Filedata * filedata)
{
Elf_Internal_Dyn * entry;
if (do_dynamic)
printf (_("\nThere is no dynamic section in this file.\n"));
- return 1;
+ return TRUE;
}
if (is_32bit_elf)
{
- if (! get_32bit_dynamic_section (file))
- return 0;
+ if (! get_32bit_dynamic_section (filedata))
+ return FALSE;
+ }
+ else
+ {
+ if (! get_64bit_dynamic_section (filedata))
+ return FALSE;
}
- else if (! get_64bit_dynamic_section (file))
- return 0;
/* Find the appropriate symbol table. */
if (dynamic_symbols == NULL)
we default to reading in the entire file (!) and
processing that. This is overkill, I know, but it
should work. */
- section.sh_offset = offset_from_vma (file, entry->d_un.d_val, 0);
+ section.sh_offset = offset_from_vma (filedata, entry->d_un.d_val, 0);
+ if ((bfd_size_type) section.sh_offset > filedata->file_size)
+ {
+ /* See PR 21379 for a reproducer. */
+ error (_("Invalid DT_SYMTAB entry: %lx"), (long) section.sh_offset);
+ return FALSE;
+ }
if (archive_file_offset != 0)
section.sh_size = archive_file_size - section.sh_offset;
else
- {
- if (fseek (file, 0, SEEK_END))
- error (_("Unable to seek to end of file!\n"));
-
- section.sh_size = ftell (file) - section.sh_offset;
- }
+ section.sh_size = filedata->file_size - section.sh_offset;
if (is_32bit_elf)
section.sh_entsize = sizeof (Elf32_External_Sym);
else
section.sh_entsize = sizeof (Elf64_External_Sym);
- section.sh_name = string_table_length;
+ section.sh_name = filedata->string_table_length;
- dynamic_symbols = GET_ELF_SYMBOLS (file, §ion, & num_dynamic_syms);
+ 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)
{
error (_("Unable to determine the number of symbols to load\n"));
processing that. This is overkill, I know, but it
should work. */
- offset = offset_from_vma (file, entry->d_un.d_val, 0);
+ offset = offset_from_vma (filedata, entry->d_un.d_val, 0);
if (archive_file_offset != 0)
str_tab_len = archive_file_size - offset;
else
- {
- if (fseek (file, 0, SEEK_END))
- error (_("Unable to seek to end of file\n"));
- str_tab_len = ftell (file) - offset;
- }
+ str_tab_len = filedata->file_size - offset;
if (str_tab_len < 1)
{
continue;
}
- dynamic_strings = (char *) get_data (NULL, file, offset, 1,
+ 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;
}
}
else if (entry->d_tag == DT_SYMINSZ)
syminsz = entry->d_un.d_val;
else if (entry->d_tag == DT_SYMINFO)
- dynamic_syminfo_offset = offset_from_vma (file, entry->d_un.d_val,
+ dynamic_syminfo_offset = offset_from_vma (filedata, entry->d_un.d_val,
syminsz);
}
/* There is a syminfo section. Read the data. */
extsyminfo = (Elf_External_Syminfo *)
- get_data (NULL, file, dynamic_syminfo_offset, 1, syminsz,
+ get_data (NULL, filedata, dynamic_syminfo_offset, 1, syminsz,
_("symbol information"));
if (!extsyminfo)
- return 0;
+ 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)
{
error (_("Out of memory allocating %lu byte for dynamic symbol info\n"),
(unsigned long) syminsz);
- return 0;
+ return FALSE;
}
dynamic_syminfo_nent = syminsz / sizeof (Elf_External_Syminfo);
}
if (do_dynamic && dynamic_addr)
- printf (_("\nDynamic section at offset 0x%lx contains %lu entries:\n"),
+ printf (ngettext ("\nDynamic section at offset 0x%lx "
+ "contains %lu entry:\n",
+ "\nDynamic section at offset 0x%lx "
+ "contains %lu entries:\n",
+ dynamic_nent),
dynamic_addr, (unsigned long) dynamic_nent);
if (do_dynamic)
printf (_(" Tag Type Name/Value\n"));
putchar (' ');
print_vma (entry->d_tag, FULL_HEX);
- dtype = get_dynamic_type (entry->d_tag);
+ dtype = get_dynamic_type (filedata, entry->d_tag);
printf (" (%s)%*s", dtype,
- ((is_32bit_elf ? 27 : 19)
- - (int) strlen (dtype)),
- " ");
+ ((is_32bit_elf ? 27 : 19) - (int) strlen (dtype)), " ");
}
switch (entry->d_tag)
printf (" 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 ("");
case DT_PLTREL:
dynamic_info[entry->d_tag] = entry->d_un.d_val;
if (do_dynamic)
- puts (get_dynamic_type (entry->d_un.d_val));
+ puts (get_dynamic_type (filedata, entry->d_un.d_val));
break;
case DT_NULL :
if (do_dynamic)
{
- switch (elf_header.e_machine)
+ switch (filedata->file_header.e_machine)
{
+ case EM_AARCH64:
+ dynamic_section_aarch64_val (entry);
+ break;
case EM_MIPS:
case EM_MIPS_RS3_LE:
dynamic_section_mips_val (entry);
}
}
- return 1;
+ return TRUE;
}
static char *
get_ver_flags (unsigned int flags)
{
- static char buff[32];
+ static char buff[128];
buff[0] = 0;
/* Display the contents of the version sections. */
-static int
-process_version_sections (FILE * file)
+static bfd_boolean
+process_version_sections (Filedata * filedata)
{
Elf_Internal_Shdr * section;
unsigned i;
- int found = 0;
+ bfd_boolean found = FALSE;
if (! do_version)
- return 1;
+ return TRUE;
- for (i = 0, section = section_headers;
- i < elf_header.e_shnum;
+ for (i = 0, section = filedata->section_headers;
+ i < filedata->file_header.e_shnum;
i++, section++)
{
switch (section->sh_type)
case SHT_GNU_verdef:
{
Elf_External_Verdef * edefs;
- unsigned int idx;
- unsigned int cnt;
- unsigned int end;
+ unsigned long idx;
+ unsigned long cnt;
char * endbuf;
- found = 1;
+ found = TRUE;
- printf (_("\nVersion definition section '%s' contains %u entries:\n"),
- printable_section_name (section),
+ printf (ngettext ("\nVersion definition section '%s' "
+ "contains %u entry:\n",
+ "\nVersion definition section '%s' "
+ "contains %u entries:\n",
+ section->sh_info),
+ printable_section_name (filedata, section),
section->sh_info);
- printf (_(" Addr: 0x"));
+ printf (_(" Addr: 0x"));
printf_vma (section->sh_addr);
printf (_(" Offset: %#08lx Link: %u (%s)\n"),
(unsigned long) section->sh_offset, section->sh_link,
- printable_section_name_from_index (section->sh_link));
+ printable_section_name_from_index (filedata, section->sh_link));
edefs = (Elf_External_Verdef *)
- get_data (NULL, file, section->sh_offset, 1,section->sh_size,
+ get_data (NULL, filedata, section->sh_offset, 1,section->sh_size,
_("version definition section"));
if (!edefs)
break;
endbuf = (char *) edefs + section->sh_size;
- /* PR 17531: file: id:000001,src:000172+005151,op:splice,rep:2. */
- end = (section->sh_info < section->sh_size
- ? section->sh_info : section->sh_size);
- for (idx = cnt = 0; cnt < end; ++cnt)
+ for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
{
char * vstart;
Elf_External_Verdef * edef;
Elf_Internal_Verdef ent;
Elf_External_Verdaux * eaux;
Elf_Internal_Verdaux aux;
- unsigned int isum;
+ unsigned long isum;
int j;
- /* Check for very large indices. */
- if (idx > (size_t) (endbuf - (char *) edefs))
- break;
-
vstart = ((char *) edefs) + idx;
if (vstart + sizeof (*edef) > endbuf)
break;
ent.vd_aux = BYTE_GET (edef->vd_aux);
ent.vd_next = BYTE_GET (edef->vd_next);
- printf (_(" %#06x: Rev: %d Flags: %s"),
+ printf (_(" %#06lx: Rev: %d Flags: %s"),
idx, ent.vd_version, get_ver_flags (ent.vd_flags));
printf (_(" Index: %d Cnt: %d "),
ent.vd_ndx, ent.vd_cnt);
/* Check for overflow. */
- if (ent.vd_aux + sizeof (* eaux) > (size_t) (endbuf - vstart))
+ if (ent.vd_aux > (size_t) (endbuf - vstart))
break;
vstart += ent.vd_aux;
+ if (vstart + sizeof (*eaux) > endbuf)
+ break;
eaux = (Elf_External_Verdaux *) vstart;
aux.vda_name = BYTE_GET (eaux->vda_name);
for (j = 1; j < ent.vd_cnt; j++)
{
+ if (aux.vda_next < sizeof (*eaux)
+ && !(j == ent.vd_cnt - 1 && aux.vda_next == 0))
+ {
+ warn (_("Invalid vda_next field of %lx\n"),
+ aux.vda_next);
+ j = ent.vd_cnt;
+ break;
+ }
/* Check for overflow. */
if (aux.vda_next > (size_t) (endbuf - vstart))
break;
isum += aux.vda_next;
vstart += aux.vda_next;
- eaux = (Elf_External_Verdaux *) vstart;
if (vstart + sizeof (*eaux) > endbuf)
break;
+ eaux = (Elf_External_Verdaux *) vstart;
aux.vda_name = BYTE_GET (eaux->vda_name);
aux.vda_next = BYTE_GET (eaux->vda_next);
if (VALID_DYNAMIC_NAME (aux.vda_name))
- printf (_(" %#06x: Parent %d: %s\n"),
+ printf (_(" %#06lx: Parent %d: %s\n"),
isum, j, GET_DYNAMIC_NAME (aux.vda_name));
else
- printf (_(" %#06x: Parent %d, name index: %ld\n"),
+ printf (_(" %#06lx: Parent %d, name index: %ld\n"),
isum, j, aux.vda_name);
}
/* PR 17531:
file: id:000001,src:000172+005151,op:splice,rep:2. */
- if (idx + ent.vd_next < idx)
+ if (ent.vd_next < sizeof (*edef)
+ && !(cnt == section->sh_info - 1 && ent.vd_next == 0))
+ {
+ warn (_("Invalid vd_next field of %lx\n"), ent.vd_next);
+ cnt = section->sh_info;
+ break;
+ }
+ if (ent.vd_next > (size_t) (endbuf - ((char *) edefs + idx)))
break;
idx += ent.vd_next;
case SHT_GNU_verneed:
{
Elf_External_Verneed * eneed;
- unsigned int idx;
- unsigned int cnt;
+ unsigned long idx;
+ unsigned long cnt;
char * endbuf;
- found = 1;
+ found = TRUE;
- printf (_("\nVersion needs section '%s' contains %u entries:\n"),
- printable_section_name (section), section->sh_info);
+ printf (ngettext ("\nVersion needs section '%s' "
+ "contains %u entry:\n",
+ "\nVersion needs section '%s' "
+ "contains %u entries:\n",
+ section->sh_info),
+ printable_section_name (filedata, section), section->sh_info);
printf (_(" Addr: 0x"));
printf_vma (section->sh_addr);
printf (_(" Offset: %#08lx Link: %u (%s)\n"),
(unsigned long) section->sh_offset, section->sh_link,
- printable_section_name_from_index (section->sh_link));
+ printable_section_name_from_index (filedata, section->sh_link));
- eneed = (Elf_External_Verneed *) get_data (NULL, file,
+ eneed = (Elf_External_Verneed *) get_data (NULL, filedata,
section->sh_offset, 1,
section->sh_size,
_("Version Needs section"));
{
Elf_External_Verneed * entry;
Elf_Internal_Verneed ent;
- unsigned int isum;
+ unsigned long isum;
int j;
char * vstart;
- if (idx > (size_t) (endbuf - (char *) eneed))
- break;
-
vstart = ((char *) eneed) + idx;
if (vstart + sizeof (*entry) > endbuf)
break;
ent.vn_aux = BYTE_GET (entry->vn_aux);
ent.vn_next = BYTE_GET (entry->vn_next);
- printf (_(" %#06x: Version: %d"), idx, ent.vn_version);
+ printf (_(" %#06lx: Version: %d"), idx, ent.vn_version);
if (VALID_DYNAMIC_NAME (ent.vn_file))
printf (_(" File: %s"), GET_DYNAMIC_NAME (ent.vn_file));
aux.vna_next = BYTE_GET (eaux->vna_next);
if (VALID_DYNAMIC_NAME (aux.vna_name))
- printf (_(" %#06x: Name: %s"),
+ printf (_(" %#06lx: Name: %s"),
isum, GET_DYNAMIC_NAME (aux.vna_name));
else
- printf (_(" %#06x: Name index: %lx"),
+ printf (_(" %#06lx: Name index: %lx"),
isum, aux.vna_name);
printf (_(" Flags: %s Version: %d\n"),
get_ver_flags (aux.vna_flags), aux.vna_other);
- /* Check for overflow. */
- if (aux.vna_next > (size_t) (endbuf - vstart)
- || (aux.vna_next == 0 && j < ent.vn_cnt - 1))
+ if (aux.vna_next < sizeof (*eaux)
+ && !(j == ent.vn_cnt - 1 && aux.vna_next == 0))
{
warn (_("Invalid vna_next field of %lx\n"),
aux.vna_next);
j = ent.vn_cnt;
break;
}
+ /* Check for overflow. */
+ if (aux.vna_next > (size_t) (endbuf - vstart))
+ break;
isum += aux.vna_next;
vstart += aux.vna_next;
}
if (j < ent.vn_cnt)
warn (_("Missing Version Needs auxillary information\n"));
- if (ent.vn_next == 0 && cnt < section->sh_info - 1)
+ if (ent.vn_next < sizeof (*entry)
+ && !(cnt == section->sh_info - 1 && ent.vn_next == 0))
{
- warn (_("Corrupt Version Needs structure - offset to next structure is zero with entries still left to be processed\n"));
+ warn (_("Invalid vn_next field of %lx\n"), ent.vn_next);
cnt = section->sh_info;
break;
}
+ if (ent.vn_next > (size_t) (endbuf - ((char *) eneed + idx)))
+ break;
idx += ent.vn_next;
}
unsigned long num_syms;
long off;
- if (section->sh_link >= elf_header.e_shnum)
+ if (section->sh_link >= filedata->file_header.e_shnum)
break;
- link_section = section_headers + section->sh_link;
+ link_section = filedata->section_headers + section->sh_link;
total = section->sh_size / sizeof (Elf_External_Versym);
- if (link_section->sh_link >= elf_header.e_shnum)
+ if (link_section->sh_link >= filedata->file_header.e_shnum)
break;
- found = 1;
+ found = TRUE;
- symbols = GET_ELF_SYMBOLS (file, link_section, & num_syms);
+ symbols = GET_ELF_SYMBOLS (filedata, link_section, & num_syms);
if (symbols == NULL)
break;
- string_sec = section_headers + link_section->sh_link;
+ string_sec = filedata->section_headers + link_section->sh_link;
- strtab = (char *) get_data (NULL, file, string_sec->sh_offset, 1,
+ strtab = (char *) get_data (NULL, filedata, string_sec->sh_offset, 1,
string_sec->sh_size,
_("version string table"));
if (!strtab)
break;
}
- printf (_("\nVersion symbols section '%s' contains %lu entries:\n"),
- printable_section_name (section), (unsigned long) total);
+ printf (ngettext ("\nVersion symbols section '%s' "
+ "contains %lu entry:\n",
+ "\nVersion symbols section '%s' "
+ "contains %lu entries:\n",
+ total),
+ printable_section_name (filedata, section), (unsigned long) total);
- printf (_(" Addr: "));
+ printf (_(" Addr: 0x"));
printf_vma (section->sh_addr);
printf (_(" Offset: %#08lx Link: %u (%s)\n"),
(unsigned long) section->sh_offset, section->sh_link,
- printable_section_name (link_section));
+ printable_section_name (filedata, link_section));
- off = offset_from_vma (file,
+ off = offset_from_vma (filedata,
version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
total * sizeof (short));
- edata = (unsigned char *) get_data (NULL, file, off, total,
+ edata = (unsigned char *) get_data (NULL, filedata, off, total,
sizeof (short),
_("version symbol data"));
if (!edata)
unsigned long offset;
offset = offset_from_vma
- (file, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
+ (filedata, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
sizeof (Elf_External_Verneed));
do
Elf_External_Vernaux evna;
unsigned long a_off;
- if (get_data (&evn, file, offset, sizeof (evn), 1,
+ if (get_data (&evn, filedata, offset, sizeof (evn), 1,
_("version need")) == NULL)
break;
do
{
- if (get_data (&evna, file, a_off, sizeof (evna),
+ if (get_data (&evna, filedata, a_off, sizeof (evna),
1, _("version need aux (2)")) == NULL)
{
ivna.vna_next = 0;
unsigned long offset;
offset = offset_from_vma
- (file, version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
+ (filedata, version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
sizeof evd);
do
{
- if (get_data (&evd, file, offset, sizeof (evd), 1,
+ if (get_data (&evd, filedata, offset, sizeof (evd), 1,
_("version def")) == NULL)
{
ivd.vd_next = 0;
ivd.vd_aux = BYTE_GET (evd.vd_aux);
- if (get_data (&evda, file,
+ if (get_data (&evda, filedata,
offset - ivd.vd_next + ivd.vd_aux,
sizeof (evda), 1,
_("version def aux")) == NULL)
if (! found)
printf (_("\nNo version information found in this file.\n"));
- return 1;
+ return TRUE;
}
static const char *
-get_symbol_binding (unsigned int binding)
+get_symbol_binding (Filedata * filedata, unsigned int binding)
{
static char buff[32];
else if (binding >= STB_LOOS && binding <= STB_HIOS)
{
if (binding == STB_GNU_UNIQUE
- && (elf_header.e_ident[EI_OSABI] == ELFOSABI_GNU
- /* GNU is still using the default value 0. */
- || elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
+ && filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_GNU)
return "UNIQUE";
snprintf (buff, sizeof (buff), _("<OS specific>: %d"), binding);
}
}
static const char *
-get_symbol_type (unsigned int type)
+get_symbol_type (Filedata * filedata, unsigned int type)
{
static char buff[32];
default:
if (type >= STT_LOPROC && type <= STT_HIPROC)
{
- if (elf_header.e_machine == EM_ARM && type == STT_ARM_TFUNC)
+ if (filedata->file_header.e_machine == EM_ARM && type == STT_ARM_TFUNC)
return "THUMB_FUNC";
- if (elf_header.e_machine == EM_SPARCV9 && type == STT_REGISTER)
+ if (filedata->file_header.e_machine == EM_SPARCV9 && type == STT_REGISTER)
return "REGISTER";
- if (elf_header.e_machine == EM_PARISC && type == STT_PARISC_MILLI)
+ if (filedata->file_header.e_machine == EM_PARISC && type == STT_PARISC_MILLI)
return "PARISC_MILLI";
snprintf (buff, sizeof (buff), _("<processor specific>: %d"), type);
}
else if (type >= STT_LOOS && type <= STT_HIOS)
{
- if (elf_header.e_machine == EM_PARISC)
+ if (filedata->file_header.e_machine == EM_PARISC)
{
if (type == STT_HP_OPAQUE)
return "HP_OPAQUE";
}
if (type == STT_GNU_IFUNC
- && (elf_header.e_ident[EI_OSABI] == ELFOSABI_GNU
- || elf_header.e_ident[EI_OSABI] == ELFOSABI_FREEBSD
- /* GNU is still using the default value 0. */
- || elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
+ && (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_GNU
+ || filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_FREEBSD))
return "IFUNC";
snprintf (buff, sizeof (buff), _("<OS specific>: %d"), type);
}
}
+static const char *
+get_alpha_symbol_other (unsigned int other)
+{
+ switch (other)
+ {
+ case STO_ALPHA_NOPV: return "NOPV";
+ case STO_ALPHA_STD_GPLOAD: return "STD GPLOAD";
+ default:
+ error (_("Unrecognized alpah specific other value: %u"), other);
+ return _("<unknown>");
+ }
+}
+
static const char *
get_solaris_symbol_visibility (unsigned int visibility)
{
}
}
+static const char *
+get_aarch64_symbol_other (unsigned int other)
+{
+ static char buf[32];
+
+ if (other & STO_AARCH64_VARIANT_PCS)
+ {
+ other &= ~STO_AARCH64_VARIANT_PCS;
+ if (other == 0)
+ return "VARIANT_PCS";
+ snprintf (buf, sizeof buf, "VARIANT_PCS | %x", other);
+ return buf;
+ }
+ return NULL;
+}
+
static const char *
get_mips_symbol_other (unsigned int other)
{
switch (other)
{
- case STO_OPTIONAL:
- return "OPTIONAL";
- case STO_MIPS_PLT:
- return "MIPS PLT";
- case STO_MIPS_PIC:
- return "MIPS PIC";
- case STO_MICROMIPS:
- return "MICROMIPS";
- case STO_MICROMIPS | STO_MIPS_PIC:
- return "MICROMIPS, MIPS PIC";
- case STO_MIPS16:
- return "MIPS16";
- default:
- return NULL;
+ case STO_OPTIONAL: return "OPTIONAL";
+ case STO_MIPS_PLT: return "MIPS PLT";
+ case STO_MIPS_PIC: return "MIPS PIC";
+ case STO_MICROMIPS: return "MICROMIPS";
+ case STO_MICROMIPS | STO_MIPS_PIC: return "MICROMIPS, MIPS PIC";
+ case STO_MIPS16: return "MIPS16";
+ default: return NULL;
}
}
static const char *
-get_ia64_symbol_other (unsigned int other)
+get_ia64_symbol_other (Filedata * filedata, unsigned int other)
{
- if (is_ia64_vms ())
+ if (is_ia64_vms (filedata))
{
static char res[32];
res[0] = 0;
/* Function types is for images and .STB files only. */
- switch (elf_header.e_type)
+ switch (filedata->file_header.e_type)
{
case ET_DYN:
case ET_EXEC:
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;
}
static const char *
-get_symbol_other (unsigned int other)
+get_symbol_other (Filedata * filedata, unsigned int other)
{
const char * result = NULL;
static char buff [32];
if (other == 0)
return "";
- switch (elf_header.e_machine)
+ switch (filedata->file_header.e_machine)
{
+ case EM_ALPHA:
+ result = get_alpha_symbol_other (other);
+ break;
+ case EM_AARCH64:
+ result = get_aarch64_symbol_other (other);
+ break;
case EM_MIPS:
result = get_mips_symbol_other (other);
break;
case EM_IA_64:
- result = get_ia64_symbol_other (other);
+ result = get_ia64_symbol_other (filedata, other);
break;
case EM_PPC64:
result = get_ppc64_symbol_other (other);
}
static const char *
-get_symbol_index_type (unsigned int type)
+get_symbol_index_type (Filedata * filedata, unsigned int type)
{
static char buff[32];
case SHN_COMMON: return "COM";
default:
if (type == SHN_IA_64_ANSI_COMMON
- && elf_header.e_machine == EM_IA_64
- && elf_header.e_ident[EI_OSABI] == ELFOSABI_HPUX)
+ && filedata->file_header.e_machine == EM_IA_64
+ && filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_HPUX)
return "ANSI_COM";
- else if ((elf_header.e_machine == EM_X86_64
- || elf_header.e_machine == EM_L1OM
- || elf_header.e_machine == EM_K1OM)
+ else if ((filedata->file_header.e_machine == EM_X86_64
+ || filedata->file_header.e_machine == EM_L1OM
+ || filedata->file_header.e_machine == EM_K1OM)
&& type == SHN_X86_64_LCOMMON)
return "LARGE_COM";
else if ((type == SHN_MIPS_SCOMMON
- && elf_header.e_machine == EM_MIPS)
+ && filedata->file_header.e_machine == EM_MIPS)
|| (type == SHN_TIC6X_SCOMMON
- && elf_header.e_machine == EM_TI_C6000))
+ && filedata->file_header.e_machine == EM_TI_C6000))
return "SCOM";
else if (type == SHN_MIPS_SUNDEFINED
- && elf_header.e_machine == EM_MIPS)
+ && filedata->file_header.e_machine == EM_MIPS)
return "SUND";
else if (type >= SHN_LOPROC && type <= SHN_HIPROC)
sprintf (buff, "PRC[0x%04x]", type & 0xffff);
sprintf (buff, "OS [0x%04x]", type & 0xffff);
else if (type >= SHN_LORESERVE)
sprintf (buff, "RSV[0x%04x]", type & 0xffff);
- else if (type >= elf_header.e_shnum)
+ else if (type >= filedata->file_header.e_shnum)
sprintf (buff, _("bad section index[%3d]"), type);
else
sprintf (buff, "%3d", type);
}
static bfd_vma *
-get_dynamic_data (FILE * file, bfd_size_type number, unsigned int ent_size)
+get_dynamic_data (Filedata * filedata, bfd_size_type number, unsigned int ent_size)
{
unsigned char * e_data;
bfd_vma * i_data;
if (sizeof (size_t) < sizeof (bfd_size_type)
&& (bfd_size_type) ((size_t) number) != number)
{
- error (_("Size truncation prevents reading %" BFD_VMA_FMT "u"
- " elements of size %u\n"),
- number, ent_size);
+ error (_("Size truncation prevents reading %s elements of size %u\n"),
+ bfd_vmatoa ("u", number), ent_size);
return NULL;
}
/* Be kind to memory chekers (eg valgrind, address sanitizer) by not
attempting to allocate memory when the read is bound to fail. */
- if (ent_size * number > current_file_size)
+ if (ent_size * number > filedata->file_size)
{
- error (_("Invalid number of dynamic entries: %" BFD_VMA_FMT "u\n"),
- number);
+ error (_("Invalid number of dynamic entries: %s\n"),
+ bfd_vmatoa ("u", number));
return NULL;
}
e_data = (unsigned char *) cmalloc ((size_t) number, ent_size);
if (e_data == NULL)
{
- error (_("Out of memory reading %" BFD_VMA_FMT "u dynamic entries\n"),
- number);
+ error (_("Out of memory reading %s dynamic entries\n"),
+ bfd_vmatoa ("u", number));
return NULL;
}
- if (fread (e_data, ent_size, (size_t) number, file) != number)
+ if (fread (e_data, ent_size, (size_t) number, filedata->handle) != number)
{
- error (_("Unable to read in %" BFD_VMA_FMT "u bytes of dynamic data\n"),
- number * ent_size);
+ error (_("Unable to read in %s bytes of dynamic data\n"),
+ bfd_vmatoa ("u", number * ent_size));
free (e_data);
return NULL;
}
i_data = (bfd_vma *) cmalloc ((size_t) number, sizeof (*i_data));
if (i_data == NULL)
{
- error (_("Out of memory allocating space for %" BFD_VMA_FMT "u"
- " dynamic entries\n"),
- number);
+ error (_("Out of memory allocating space for %s dynamic entries\n"),
+ bfd_vmatoa ("u", number));
free (e_data);
return NULL;
}
}
static void
-print_dynamic_symbol (bfd_vma si, unsigned long hn)
+print_dynamic_symbol (Filedata * filedata, bfd_vma si, unsigned long hn)
{
Elf_Internal_Sym * psym;
int n;
putchar (' ');
print_vma (psym->st_size, DEC_5);
- printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
- printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
+ printf (" %-7s", get_symbol_type (filedata, ELF_ST_TYPE (psym->st_info)));
+ printf (" %-6s", get_symbol_binding (filedata, ELF_ST_BIND (psym->st_info)));
- if (elf_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
+ if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
printf (" %-7s", get_solaris_symbol_visibility (psym->st_other));
else
{
table being generated, but for the moment this case is very
rare. */
if (psym->st_other ^ vis)
- printf (" [%s] ", get_symbol_other (psym->st_other ^ vis));
+ printf (" [%s] ", get_symbol_other (filedata, psym->st_other ^ vis));
}
- printf (" %3.3s ", get_symbol_index_type (psym->st_shndx));
+ printf (" %3.3s ", get_symbol_index_type (filedata, psym->st_shndx));
if (VALID_DYNAMIC_NAME (psym->st_name))
print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
else
}
static const char *
-get_symbol_version_string (FILE * file,
+get_symbol_version_string (Filedata * filedata,
bfd_boolean is_dynsym,
const char * strtab,
unsigned long int strtab_size,
unsigned char data[2];
unsigned short vers_data;
unsigned long offset;
+ unsigned short max_vd_ndx;
if (!is_dynsym
|| version_info[DT_VERSIONTAGIDX (DT_VERSYM)] == 0)
return NULL;
- offset = offset_from_vma (file, version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
+ offset = offset_from_vma (filedata, version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
sizeof data + si * sizeof (vers_data));
- if (get_data (&data, file, offset + si * sizeof (vers_data),
+ if (get_data (&data, filedata, offset + si * sizeof (vers_data),
sizeof (data), 1, _("version data")) == NULL)
return NULL;
vers_data = byte_get (data, 2);
- if ((vers_data & VERSYM_HIDDEN) == 0 && vers_data <= 1)
+ if ((vers_data & VERSYM_HIDDEN) == 0 && vers_data == 0)
return NULL;
+ *sym_info = (vers_data & VERSYM_HIDDEN) != 0 ? symbol_hidden : symbol_public;
+ max_vd_ndx = 0;
+
/* Usually we'd only see verdef for defined symbols, and verneed for
undefined symbols. However, symbols defined by the linker in
.dynbss for variables copied from a shared library in order to
Elf_External_Verdaux evda;
unsigned long off;
- off = offset_from_vma (file,
+ off = offset_from_vma (filedata,
version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
sizeof (Elf_External_Verdef));
{
Elf_External_Verdef evd;
- if (get_data (&evd, file, off, sizeof (evd), 1,
+ if (get_data (&evd, filedata, off, sizeof (evd), 1,
_("version def")) == NULL)
{
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);
}
+ if ((ivd.vd_ndx & VERSYM_VERSION) > max_vd_ndx)
+ max_vd_ndx = ivd.vd_ndx & VERSYM_VERSION;
+
off += ivd.vd_next;
}
while (ivd.vd_ndx != (vers_data & VERSYM_VERSION) && ivd.vd_next != 0);
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;
- if (get_data (&evda, file, off, sizeof (evda), 1,
+ if (get_data (&evda, filedata, off, sizeof (evda), 1,
_("version def aux")) != NULL)
{
ivda.vda_name = BYTE_GET (evda.vda_name);
if (psym->st_name != ivda.vda_name)
- {
- *sym_info = ((vers_data & VERSYM_HIDDEN) != 0
- ? symbol_hidden : symbol_public);
- return (ivda.vda_name < strtab_size
- ? strtab + ivda.vda_name : _("<corrupt>"));
- }
+ return (ivda.vda_name < strtab_size
+ ? strtab + ivda.vda_name : _("<corrupt>"));
}
}
}
Elf_Internal_Verneed ivn;
Elf_Internal_Vernaux ivna;
- offset = offset_from_vma (file,
+ offset = offset_from_vma (filedata,
version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
sizeof evn);
do
{
unsigned long vna_off;
- if (get_data (&evn, file, offset, sizeof (evn), 1,
+ if (get_data (&evn, filedata, offset, sizeof (evn), 1,
_("version need")) == NULL)
{
ivna.vna_next = 0;
{
Elf_External_Vernaux evna;
- if (get_data (&evna, file, vna_off, sizeof (evna), 1,
+ if (get_data (&evna, filedata, vna_off, sizeof (evna), 1,
_("version need aux (3)")) == NULL)
{
ivna.vna_next = 0;
return (ivna.vna_name < strtab_size
? strtab + ivna.vna_name : _("<corrupt>"));
}
+ else if ((max_vd_ndx || (vers_data & VERSYM_VERSION) != 1)
+ && (vers_data & VERSYM_VERSION) > max_vd_ndx)
+ return _("<corrupt>");
}
return NULL;
}
/* Dump the symbol table. */
-static int
-process_symbol_table (FILE * file)
+static bfd_boolean
+process_symbol_table (Filedata * filedata)
{
Elf_Internal_Shdr * section;
bfd_size_type nbuckets = 0;
bfd_vma ngnubuckets = 0;
bfd_vma * gnubuckets = NULL;
bfd_vma * gnuchains = NULL;
+ bfd_vma * mipsxlat = NULL;
bfd_vma gnusymidx = 0;
bfd_size_type ngnuchains = 0;
if (!do_syms && !do_dyn_syms && !do_histogram)
- return 1;
+ return TRUE;
if (dynamic_info[DT_HASH]
&& (do_histogram
unsigned char nc[8];
unsigned int hash_ent_size = 4;
- if ((elf_header.e_machine == EM_ALPHA
- || elf_header.e_machine == EM_S390
- || elf_header.e_machine == EM_S390_OLD)
- && elf_header.e_ident[EI_CLASS] == ELFCLASS64)
+ if ((filedata->file_header.e_machine == EM_ALPHA
+ || filedata->file_header.e_machine == EM_S390
+ || filedata->file_header.e_machine == EM_S390_OLD)
+ && filedata->file_header.e_ident[EI_CLASS] == ELFCLASS64)
hash_ent_size = 8;
- if (fseek (file,
+ if (fseek (filedata->handle,
(archive_file_offset
- + offset_from_vma (file, dynamic_info[DT_HASH],
+ + offset_from_vma (filedata, dynamic_info[DT_HASH],
sizeof nb + sizeof nc)),
SEEK_SET))
{
goto no_hash;
}
- if (fread (nb, hash_ent_size, 1, file) != 1)
+ if (fread (nb, hash_ent_size, 1, filedata->handle) != 1)
{
error (_("Failed to read in number of buckets\n"));
goto no_hash;
}
- if (fread (nc, hash_ent_size, 1, file) != 1)
+ if (fread (nc, hash_ent_size, 1, filedata->handle) != 1)
{
error (_("Failed to read in number of chains\n"));
goto no_hash;
nbuckets = byte_get (nb, hash_ent_size);
nchains = byte_get (nc, hash_ent_size);
- buckets = get_dynamic_data (file, nbuckets, hash_ent_size);
- chains = get_dynamic_data (file, nchains, hash_ent_size);
+ buckets = get_dynamic_data (filedata, nbuckets, hash_ent_size);
+ chains = get_dynamic_data (filedata, nchains, hash_ent_size);
no_hash:
if (buckets == NULL || chains == NULL)
{
if (do_using_dynamic)
- return 0;
+ return FALSE;
free (buckets);
free (chains);
buckets = NULL;
bfd_vma i, maxchain = 0xffffffff, bitmaskwords;
bfd_vma buckets_vma;
- if (fseek (file,
+ if (fseek (filedata->handle,
(archive_file_offset
- + offset_from_vma (file, dynamic_info_DT_GNU_HASH,
+ + offset_from_vma (filedata, dynamic_info_DT_GNU_HASH,
sizeof nb)),
SEEK_SET))
{
goto no_gnu_hash;
}
- if (fread (nb, 16, 1, file) != 1)
+ if (fread (nb, 16, 1, filedata->handle) != 1)
{
error (_("Failed to read in number of buckets\n"));
goto no_gnu_hash;
else
buckets_vma += bitmaskwords * 8;
- if (fseek (file,
+ if (fseek (filedata->handle,
(archive_file_offset
- + offset_from_vma (file, buckets_vma, 4)),
+ + offset_from_vma (filedata, buckets_vma, 4)),
SEEK_SET))
{
error (_("Unable to seek to start of dynamic information\n"));
goto no_gnu_hash;
}
- gnubuckets = get_dynamic_data (file, ngnubuckets, 4);
+ gnubuckets = get_dynamic_data (filedata, ngnubuckets, 4);
if (gnubuckets == NULL)
goto no_gnu_hash;
if (gnubuckets[i] != 0)
{
if (gnubuckets[i] < gnusymidx)
- return 0;
+ return FALSE;
if (maxchain == 0xffffffff || gnubuckets[i] > maxchain)
maxchain = gnubuckets[i];
maxchain -= gnusymidx;
- if (fseek (file,
+ if (fseek (filedata->handle,
(archive_file_offset
- + offset_from_vma (file, buckets_vma
+ + offset_from_vma (filedata, buckets_vma
+ 4 * (ngnubuckets + maxchain), 4)),
SEEK_SET))
{
do
{
- if (fread (nb, 4, 1, file) != 1)
+ if (fread (nb, 4, 1, filedata->handle) != 1)
{
error (_("Failed to determine last chain length\n"));
goto no_gnu_hash;
}
while ((byte_get (nb, 4) & 1) == 0);
- if (fseek (file,
+ if (fseek (filedata->handle,
(archive_file_offset
- + offset_from_vma (file, buckets_vma + 4 * ngnubuckets, 4)),
+ + offset_from_vma (filedata, buckets_vma + 4 * ngnubuckets, 4)),
SEEK_SET))
{
error (_("Unable to seek to start of dynamic information\n"));
goto no_gnu_hash;
}
- gnuchains = get_dynamic_data (file, maxchain, 4);
+ gnuchains = get_dynamic_data (filedata, maxchain, 4);
ngnuchains = maxchain;
+ if (gnuchains == NULL)
+ goto no_gnu_hash;
+
+ if (dynamic_info_DT_MIPS_XHASH)
+ {
+ if (fseek (filedata->handle,
+ (archive_file_offset
+ + offset_from_vma (filedata, (buckets_vma
+ + 4 * (ngnubuckets
+ + maxchain)), 4)),
+ SEEK_SET))
+ {
+ error (_("Unable to seek to start of dynamic information\n"));
+ goto no_gnu_hash;
+ }
+
+ mipsxlat = get_dynamic_data (filedata, maxchain, 4);
+ }
+
no_gnu_hash:
+ if (dynamic_info_DT_MIPS_XHASH && mipsxlat == NULL)
+ {
+ free (gnuchains);
+ gnuchains = NULL;
+ }
if (gnuchains == NULL)
{
free (gnubuckets);
gnubuckets = NULL;
ngnubuckets = 0;
if (do_using_dynamic)
- return 0;
+ return FALSE;
}
}
if (dynamic_info[DT_HASH])
{
bfd_vma si;
+ char *visited;
printf (_("\nSymbol table for image:\n"));
if (is_32bit_elf)
else
printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
+ visited = xcmalloc (nchains, 1);
+ memset (visited, 0, nchains);
for (hn = 0; hn < nbuckets; hn++)
{
- if (! buckets[hn])
- continue;
-
- for (si = buckets[hn]; si < nchains && si > 0; si = chains[si])
- print_dynamic_symbol (si, hn);
+ for (si = buckets[hn]; si > 0; si = chains[si])
+ {
+ print_dynamic_symbol (filedata, si, hn);
+ if (si >= nchains || visited[si])
+ {
+ error (_("histogram chain is corrupt\n"));
+ break;
+ }
+ visited[si] = 1;
+ }
}
+ free (visited);
}
if (dynamic_info_DT_GNU_HASH)
{
- printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
+ printf (_("\nSymbol table of `%s' for image:\n"),
+ GNU_HASH_SECTION_NAME);
if (is_32bit_elf)
printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
else
do
{
- print_dynamic_symbol (si, hn);
+ if (dynamic_info_DT_MIPS_XHASH)
+ print_dynamic_symbol (filedata, mipsxlat[off], hn);
+ else
+ print_dynamic_symbol (filedata, si, hn);
si++;
}
while (off < ngnuchains && (gnuchains[off++] & 1) == 0);
}
}
else if ((do_dyn_syms || (do_syms && !do_using_dynamic))
- && section_headers != NULL)
+ && filedata->section_headers != NULL)
{
unsigned int i;
- for (i = 0, section = section_headers;
- i < elf_header.e_shnum;
+ for (i = 0, section = filedata->section_headers;
+ i < filedata->file_header.e_shnum;
i++, section++)
{
unsigned int si;
if (section->sh_entsize == 0)
{
printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
- printable_section_name (section));
+ printable_section_name (filedata, section));
continue;
}
- printf (_("\nSymbol table '%s' contains %lu entries:\n"),
- printable_section_name (section),
- (unsigned long) (section->sh_size / section->sh_entsize));
+ num_syms = section->sh_size / section->sh_entsize;
+ printf (ngettext ("\nSymbol table '%s' contains %lu entry:\n",
+ "\nSymbol table '%s' contains %lu entries:\n",
+ num_syms),
+ printable_section_name (filedata, section),
+ num_syms);
if (is_32bit_elf)
printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
else
printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
- symtab = GET_ELF_SYMBOLS (file, section, & num_syms);
+ symtab = GET_ELF_SYMBOLS (filedata, section, & num_syms);
if (symtab == NULL)
continue;
- if (section->sh_link == elf_header.e_shstrndx)
+ if (section->sh_link == filedata->file_header.e_shstrndx)
{
- strtab = string_table;
- strtab_size = string_table_length;
+ strtab = filedata->string_table;
+ strtab_size = filedata->string_table_length;
}
- else if (section->sh_link < elf_header.e_shnum)
+ else if (section->sh_link < filedata->file_header.e_shnum)
{
Elf_Internal_Shdr * string_sec;
- string_sec = section_headers + section->sh_link;
+ string_sec = filedata->section_headers + section->sh_link;
- strtab = (char *) get_data (NULL, file, string_sec->sh_offset,
+ strtab = (char *) get_data (NULL, filedata, string_sec->sh_offset,
1, string_sec->sh_size,
_("string table"));
strtab_size = strtab != NULL ? string_sec->sh_size : 0;
print_vma (psym->st_value, LONG_HEX);
putchar (' ');
print_vma (psym->st_size, DEC_5);
- printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
- printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
- if (elf_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
+ printf (" %-7s", get_symbol_type (filedata, ELF_ST_TYPE (psym->st_info)));
+ printf (" %-6s", get_symbol_binding (filedata, ELF_ST_BIND (psym->st_info)));
+ if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
printf (" %-7s", get_solaris_symbol_visibility (psym->st_other));
else
{
Note - displaying this information disrupts the layout of the
table being generated, but for the moment this case is very rare. */
if (psym->st_other ^ vis)
- printf (" [%s] ", get_symbol_other (psym->st_other ^ vis));
+ printf (" [%s] ", get_symbol_other (filedata, psym->st_other ^ vis));
}
- printf (" %4s ", get_symbol_index_type (psym->st_shndx));
+ printf (" %4s ", get_symbol_index_type (filedata, psym->st_shndx));
print_symbol (25, psym->st_name < strtab_size
? strtab + psym->st_name : _("<corrupt>"));
version_string
- = get_symbol_version_string (file,
+ = get_symbol_version_string (filedata,
section->sh_type == SHT_DYNSYM,
strtab, strtab_size, si,
psym, &sym_info, &vna_other);
if (ELF_ST_BIND (psym->st_info) == STB_LOCAL
&& si >= section->sh_info
/* Irix 5 and 6 MIPS binaries are known to ignore this requirement. */
- && elf_header.e_machine != EM_MIPS
+ && filedata->file_header.e_machine != EM_MIPS
/* Solaris binaries have been found to violate this requirement as
well. Not sure if this is a bug or an ABI requirement. */
- && elf_header.e_ident[EI_OSABI] != ELFOSABI_SOLARIS)
+ && filedata->file_header.e_ident[EI_OSABI] != ELFOSABI_SOLARIS)
warn (_("local symbol %u found at index >= %s's sh_info value of %u\n"),
- si, printable_section_name (section), section->sh_info);
+ si, printable_section_name (filedata, section), section->sh_info);
}
free (symtab);
- if (strtab != string_table)
+ if (strtab != filedata->string_table)
free (strtab);
}
}
unsigned long maxlength = 0;
unsigned long nzero_counts = 0;
unsigned long nsyms = 0;
- unsigned long chained;
+ char *visited;
- printf (_("\nHistogram for bucket list length (total of %lu buckets):\n"),
+ printf (ngettext ("\nHistogram for bucket list length "
+ "(total of %lu bucket):\n",
+ "\nHistogram for bucket list length "
+ "(total of %lu buckets):\n",
+ (unsigned long) nbuckets),
(unsigned long) nbuckets);
lengths = (unsigned long *) calloc (nbuckets, sizeof (*lengths));
if (lengths == NULL)
{
error (_("Out of memory allocating space for histogram buckets\n"));
- return 0;
+ return FALSE;
}
+ visited = xcmalloc (nchains, 1);
+ memset (visited, 0, nchains);
printf (_(" Length Number %% of total Coverage\n"));
for (hn = 0; hn < nbuckets; ++hn)
{
- for (si = buckets[hn], chained = 0;
- si > 0 && si < nchains && si < nbuckets && chained <= nchains;
- si = chains[si], ++chained)
+ for (si = buckets[hn]; si > 0; si = chains[si])
{
++nsyms;
if (maxlength < ++lengths[hn])
++maxlength;
+ if (si >= nchains || visited[si])
+ {
+ error (_("histogram chain is corrupt\n"));
+ break;
+ }
+ visited[si] = 1;
}
-
- /* PR binutils/17531: A corrupt binary could contain broken
- histogram data. Do not go into an infinite loop trying
- to process it. */
- if (chained > nchains)
- {
- error (_("histogram chain is corrupt\n"));
- break;
- }
}
+ free (visited);
counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
if (counts == NULL)
{
free (lengths);
error (_("Out of memory allocating space for histogram counts\n"));
- return 0;
+ return FALSE;
}
for (hn = 0; hn < nbuckets; ++hn)
unsigned long nzero_counts = 0;
unsigned long nsyms = 0;
- printf (_("\nHistogram for `.gnu.hash' bucket list length (total of %lu buckets):\n"),
+ printf (ngettext ("\nHistogram for `%s' bucket list length "
+ "(total of %lu bucket):\n",
+ "\nHistogram for `%s' bucket list length "
+ "(total of %lu buckets):\n",
+ (unsigned long) ngnubuckets),
+ GNU_HASH_SECTION_NAME,
(unsigned long) ngnubuckets);
lengths = (unsigned long *) calloc (ngnubuckets, sizeof (*lengths));
if (lengths == NULL)
{
error (_("Out of memory allocating space for gnu histogram buckets\n"));
- return 0;
+ return FALSE;
}
printf (_(" Length Number %% of total Coverage\n"));
{
free (lengths);
error (_("Out of memory allocating space for gnu histogram counts\n"));
- return 0;
+ return FALSE;
}
for (hn = 0; hn < ngnubuckets; ++hn)
free (lengths);
free (gnubuckets);
free (gnuchains);
+ free (mipsxlat);
}
- return 1;
+ return TRUE;
}
-static int
-process_syminfo (FILE * file ATTRIBUTE_UNUSED)
+static bfd_boolean
+process_syminfo (Filedata * filedata ATTRIBUTE_UNUSED)
{
unsigned int i;
if (dynamic_syminfo == NULL
|| !do_dynamic)
/* No syminfo, this is ok. */
- return 1;
+ return TRUE;
/* There better should be a dynamic symbol section. */
if (dynamic_symbols == NULL || dynamic_strings == NULL)
- return 0;
+ return FALSE;
if (dynamic_addr)
- printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
+ printf (ngettext ("\nDynamic info segment at offset 0x%lx "
+ "contains %d entry:\n",
+ "\nDynamic info segment at offset 0x%lx "
+ "contains %d entries:\n",
+ dynamic_syminfo_nent),
dynamic_syminfo_offset, dynamic_syminfo_nent);
printf (_(" Num: Name BoundTo Flags\n"));
puts ("");
}
- return 1;
+ return TRUE;
}
-#define IN_RANGE(START,END,ADDR,OFF) \
- (((ADDR) >= (START)) && ((ADDR) + (OFF) < (END)))
+/* A macro which evaluates to TRUE if the region ADDR .. ADDR + NELEM
+ is contained by the region START .. END. The types of ADDR, START
+ and END should all be the same. Note both ADDR + NELEM and END
+ point to just beyond the end of the regions that are being tested. */
+#define IN_RANGE(START,END,ADDR,NELEM) \
+ (((ADDR) >= (START)) && ((ADDR) < (END)) && ((ADDR) + (NELEM) <= (END)))
/* Check to see if the given reloc needs to be handled in a target specific
manner. If so then process the reloc and return TRUE otherwise return
discarded. */
static bfd_boolean
-target_specific_reloc_handling (Elf_Internal_Rela * reloc,
- unsigned char * start,
- unsigned char * end,
- Elf_Internal_Sym * symtab,
- unsigned long num_syms)
+target_specific_reloc_handling (Filedata * filedata,
+ Elf_Internal_Rela * reloc,
+ unsigned char * start,
+ unsigned char * end,
+ Elf_Internal_Sym * symtab,
+ unsigned long num_syms)
{
unsigned int reloc_type = 0;
unsigned long sym_index = 0;
if (reloc)
{
- reloc_type = get_reloc_type (reloc->r_info);
+ reloc_type = get_reloc_type (filedata, reloc->r_info);
sym_index = get_reloc_symindex (reloc->r_info);
}
- switch (elf_header.e_machine)
+ switch (filedata->file_header.e_machine)
{
case EM_MSP430:
case EM_MSP430_OLD:
switch (reloc_type)
{
case 10: /* R_MSP430_SYM_DIFF */
- if (uses_msp430x_relocs ())
+ if (uses_msp430x_relocs (filedata))
break;
/* Fall through. */
case 21: /* R_MSP430X_SYM_DIFF */
case 5: /* R_MSP430_16_BYTE */
case 9: /* R_MSP430_8 */
- if (uses_msp430x_relocs ())
+ if (uses_msp430x_relocs (filedata))
break;
goto handle_sym_diff;
case 2: /* R_MSP430_ABS16 */
case 15: /* R_MSP430X_ABS16 */
- if (! uses_msp430x_relocs ())
+ if (! uses_msp430x_relocs (filedata))
break;
goto handle_sym_diff;
reloc naming functions. */
static bfd_boolean
-is_32bit_abs_reloc (unsigned int reloc_type)
+is_32bit_abs_reloc (Filedata * filedata, unsigned int reloc_type)
{
/* Please keep this table alpha-sorted for ease of visual lookup. */
- switch (elf_header.e_machine)
+ switch (filedata->file_header.e_machine)
{
case EM_386:
case EM_IAMCU:
case EM_AARCH64:
return (reloc_type == 258
|| reloc_type == 1); /* R_AARCH64_ABS32 || R_AARCH64_P32_ABS32 */
+ case EM_BPF:
+ return reloc_type == 11; /* R_BPF_DATA_32 */
case EM_ADAPTEVA_EPIPHANY:
return reloc_type == 3;
case EM_ALPHA:
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_H8_300H:
return reloc_type == 1; /* R_H8_DIR32. */
case EM_IA_64:
- return reloc_type == 0x65 /* R_IA64_SECREL32LSB. */
- || reloc_type == 0x25; /* R_IA64_DIR32LSB. */
+ return (reloc_type == 0x64 /* R_IA64_SECREL32MSB. */
+ || reloc_type == 0x65 /* R_IA64_SECREL32LSB. */
+ || reloc_type == 0x24 /* R_IA64_DIR32MSB. */
+ || reloc_type == 0x25 /* R_IA64_DIR32LSB. */);
case EM_IP2K_OLD:
case EM_IP2K:
return reloc_type == 2; /* R_IP2K_32. */
case EM_68HC11:
case EM_68HC12:
return reloc_type == 6; /* R_M68HC11_32. */
+ case EM_S12Z:
+ return reloc_type == 7 || /* R_S12Z_EXT32 */
+ reloc_type == 6; /* R_S12Z_CW32. */
case EM_MCORE:
return reloc_type == 1; /* R_MCORE_ADDR32. */
case EM_CYGNUS_MEP:
return reloc_type == 1; /* R_OR1K_32. */
case EM_PARISC:
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 == 1; /* R_VAX_32. */
case EM_VISIUM:
return reloc_type == 3; /* R_VISIUM_32. */
+ case EM_WEBASSEMBLY:
+ return reloc_type == 1; /* R_WASM32_32. */
case EM_X86_64:
case EM_L1OM:
case EM_K1OM:
case EM_XTENSA_OLD:
case EM_XTENSA:
return reloc_type == 1; /* R_XTENSA_32. */
+ case EM_Z80:
+ return reloc_type == 6; /* R_Z80_32. */
default:
{
static unsigned int prev_warn = 0;
/* Avoid repeating the same warning multiple times. */
- if (prev_warn != elf_header.e_machine)
+ if (prev_warn != filedata->file_header.e_machine)
error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
- elf_header.e_machine);
- prev_warn = elf_header.e_machine;
+ filedata->file_header.e_machine);
+ prev_warn = filedata->file_header.e_machine;
return FALSE;
}
}
a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
static bfd_boolean
-is_32bit_pcrel_reloc (unsigned int reloc_type)
+is_32bit_pcrel_reloc (Filedata * filedata, unsigned int reloc_type)
{
- switch (elf_header.e_machine)
+ switch (filedata->file_header.e_machine)
/* Please keep this table alpha-sorted for ease of visual lookup. */
{
case EM_386:
return reloc_type == 26; /* R_PPC_REL32. */
case EM_PPC64:
return reloc_type == 26; /* R_PPC64_REL32. */
+ case EM_RISCV:
+ return reloc_type == 57; /* R_RISCV_32_PCREL. */
case EM_S390_OLD:
case EM_S390:
return reloc_type == 5; /* R_390_PC32. */
case EM_L1OM:
case EM_K1OM:
return reloc_type == 2; /* R_X86_64_PC32. */
+ case EM_VAX:
+ return reloc_type == 4; /* R_VAX_PCREL32. */
case EM_XTENSA_OLD:
case EM_XTENSA:
return reloc_type == 14; /* R_XTENSA_32_PCREL. */
a 64-bit absolute RELA relocation used in DWARF debug sections. */
static bfd_boolean
-is_64bit_abs_reloc (unsigned int reloc_type)
+is_64bit_abs_reloc (Filedata * filedata, unsigned int reloc_type)
{
- switch (elf_header.e_machine)
+ switch (filedata->file_header.e_machine)
{
case EM_AARCH64:
return reloc_type == 257; /* R_AARCH64_ABS64. */
case EM_ALPHA:
return reloc_type == 2; /* R_ALPHA_REFQUAD. */
case EM_IA_64:
- return reloc_type == 0x27; /* R_IA64_DIR64LSB. */
+ return (reloc_type == 0x26 /* R_IA64_DIR64MSB. */
+ || reloc_type == 0x27 /* R_IA64_DIR64LSB. */);
case EM_PARISC:
return reloc_type == 80; /* R_PARISC_DIR64. */
case EM_PPC64:
case EM_SPARC32PLUS:
case EM_SPARCV9:
case EM_SPARC:
- return reloc_type == 54; /* R_SPARC_UA64. */
+ return reloc_type == 32 /* R_SPARC_64. */
+ || reloc_type == 54; /* R_SPARC_UA64. */
case EM_X86_64:
case EM_L1OM:
case EM_K1OM:
a 64-bit pc-relative RELA relocation used in DWARF debug sections. */
static bfd_boolean
-is_64bit_pcrel_reloc (unsigned int reloc_type)
+is_64bit_pcrel_reloc (Filedata * filedata, unsigned int reloc_type)
{
- switch (elf_header.e_machine)
+ switch (filedata->file_header.e_machine)
{
case EM_AARCH64:
return reloc_type == 260; /* R_AARCH64_PREL64. */
case EM_ALPHA:
return reloc_type == 11; /* R_ALPHA_SREL64. */
case EM_IA_64:
- return reloc_type == 0x4f; /* R_IA64_PCREL64LSB. */
+ return (reloc_type == 0x4e /* R_IA64_PCREL64MSB. */
+ || reloc_type == 0x4f /* R_IA64_PCREL64LSB. */);
case EM_PARISC:
return reloc_type == 72; /* R_PARISC_PCREL64. */
case EM_PPC64:
a 24-bit absolute RELA relocation used in DWARF debug sections. */
static bfd_boolean
-is_24bit_abs_reloc (unsigned int reloc_type)
+is_24bit_abs_reloc (Filedata * filedata, unsigned int reloc_type)
{
- switch (elf_header.e_machine)
+ switch (filedata->file_header.e_machine)
{
case EM_CYGNUS_MN10200:
case EM_MN10200:
return reloc_type == 4; /* R_MN10200_24. */
case EM_FT32:
return reloc_type == 5; /* R_FT32_20. */
+ case EM_Z80:
+ return reloc_type == 5; /* R_Z80_24. */
default:
return FALSE;
}
a 16-bit absolute RELA relocation used in DWARF debug sections. */
static bfd_boolean
-is_16bit_abs_reloc (unsigned int reloc_type)
+is_16bit_abs_reloc (Filedata * filedata, unsigned int reloc_type)
{
/* Please keep this table alpha-sorted for ease of visual lookup. */
- switch (elf_header.e_machine)
+ switch (filedata->file_header.e_machine)
{
case EM_ARC:
case EM_ARC_COMPACT:
case EM_CYGNUS_D10V:
case EM_D10V:
return reloc_type == 3; /* R_D10V_16. */
+ case EM_FT32:
+ return reloc_type == 2; /* R_FT32_16. */
case EM_H8S:
case EM_H8_300:
case EM_H8_300H:
case EM_MN10300:
return reloc_type == 2; /* R_MN10300_16. */
case EM_MSP430:
- if (uses_msp430x_relocs ())
+ if (uses_msp430x_relocs (filedata))
return reloc_type == 2; /* R_MSP430_ABS16. */
/* Fall through. */
case EM_MSP430_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:
return reloc_type == 2; /* R_XC16C_ABS_16. */
case EM_XGATE:
return reloc_type == 3; /* R_XGATE_16. */
+ case EM_Z80:
+ return reloc_type == 4; /* R_Z80_16. */
+ default:
+ return FALSE;
+ }
+}
+
+/* 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. */
+ case EM_Z80:
+ return reloc_type == 1; /* R_Z80_8. */
+ 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;
}
relocation entries (possibly formerly used for SHT_GROUP sections). */
static bfd_boolean
-is_none_reloc (unsigned int reloc_type)
+is_none_reloc (Filedata * filedata, unsigned int reloc_type)
{
- switch (elf_header.e_machine)
+ switch (filedata->file_header.e_machine)
{
case EM_386: /* R_386_NONE. */
case EM_68K: /* R_68K_NONE. */
case EM_TI_C6000:/* R_C6000_NONE. */
case EM_X86_64: /* R_X86_64_NONE. */
case EM_XC16X:
+ case EM_Z80: /* R_Z80_NONE. */
+ case EM_WEBASSEMBLY: /* R_WASM32_NONE. */
return reloc_type == 0;
case EM_AARCH64:
}
/* Apply relocations to a section.
+ Returns TRUE upon success, FALSE otherwise.
+ If RELOCS_RETURN is non-NULL then it is set to point to the loaded relocs.
+ It is then the caller's responsibility to free them. NUM_RELOCS_RETURN
+ will be set to the number of relocs loaded.
+
Note: So far support has been added only for those relocations
- which can be found in debug sections.
- If RELOCS_RETURN is non-NULL then returns in it a pointer to the
- loaded relocs. It is then the caller's responsibility to free them.
- FIXME: Add support for more relocations ? */
+ which can be found in debug sections. FIXME: Add support for
+ more relocations ? */
-static void
-apply_relocations (void * file,
+static bfd_boolean
+apply_relocations (Filedata * filedata,
const Elf_Internal_Shdr * section,
unsigned char * start,
bfd_size_type size,
* num_relocs_return = 0;
}
- if (elf_header.e_type != ET_REL)
- return;
+ if (filedata->file_header.e_type != ET_REL)
+ /* No relocs to apply. */
+ return TRUE;
/* Find the reloc section associated with the section. */
- for (relsec = section_headers;
- relsec < section_headers + elf_header.e_shnum;
+ for (relsec = filedata->section_headers;
+ relsec < filedata->section_headers + filedata->file_header.e_shnum;
++relsec)
{
bfd_boolean is_rela;
Elf_Internal_Sym * sym;
if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
- || relsec->sh_info >= elf_header.e_shnum
- || section_headers + relsec->sh_info != section
+ || relsec->sh_info >= filedata->file_header.e_shnum
+ || filedata->section_headers + relsec->sh_info != section
|| relsec->sh_size == 0
- || relsec->sh_link >= elf_header.e_shnum)
+ || relsec->sh_link >= filedata->file_header.e_shnum)
continue;
is_rela = relsec->sh_type == SHT_RELA;
if (is_rela)
{
- if (!slurp_rela_relocs ((FILE *) file, relsec->sh_offset,
+ if (!slurp_rela_relocs (filedata, relsec->sh_offset,
relsec->sh_size, & relocs, & num_relocs))
- return;
+ return FALSE;
}
else
{
- if (!slurp_rel_relocs ((FILE *) file, relsec->sh_offset,
+ if (!slurp_rel_relocs (filedata, relsec->sh_offset,
relsec->sh_size, & relocs, & num_relocs))
- return;
+ return FALSE;
}
/* SH uses RELA but uses in place value instead of the addend field. */
- if (elf_header.e_machine == EM_SH)
+ if (filedata->file_header.e_machine == EM_SH)
is_rela = FALSE;
- symsec = section_headers + relsec->sh_link;
+ symsec = filedata->section_headers + relsec->sh_link;
if (symsec->sh_type != SHT_SYMTAB
&& symsec->sh_type != SHT_DYNSYM)
- return;
- symtab = GET_ELF_SYMBOLS ((FILE *) file, symsec, & num_syms);
+ return FALSE;
+ symtab = GET_ELF_SYMBOLS (filedata, symsec, & num_syms);
for (rp = relocs; rp < relocs + num_relocs; ++rp)
{
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_type = get_reloc_type (rp->r_info);
+ reloc_type = get_reloc_type (filedata, rp->r_info);
- if (target_specific_reloc_handling (rp, start, end, symtab, num_syms))
+ if (target_specific_reloc_handling (filedata, rp, start, end, symtab, num_syms))
continue;
- else if (is_none_reloc (reloc_type))
+ else if (is_none_reloc (filedata, reloc_type))
continue;
- else if (is_32bit_abs_reloc (reloc_type)
- || is_32bit_pcrel_reloc (reloc_type))
+ else if (is_32bit_abs_reloc (filedata, reloc_type)
+ || is_32bit_pcrel_reloc (filedata, reloc_type))
reloc_size = 4;
- else if (is_64bit_abs_reloc (reloc_type)
- || is_64bit_pcrel_reloc (reloc_type))
+ else if (is_64bit_abs_reloc (filedata, reloc_type)
+ || is_64bit_pcrel_reloc (filedata, reloc_type))
reloc_size = 8;
- else if (is_24bit_abs_reloc (reloc_type))
+ else if (is_24bit_abs_reloc (filedata, reloc_type))
reloc_size = 3;
- else if (is_16bit_abs_reloc (reloc_type))
+ 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;
+
if (reloc_type != prev_reloc)
warn (_("unable to apply unsupported reloc type %d to section %s\n"),
- reloc_type, printable_section_name (section));
+ reloc_type, printable_section_name (filedata, section));
prev_reloc = reloc_type;
continue;
}
rloc = start + rp->r_offset;
- if ((rloc + reloc_size) > end || (rloc < start))
+ if (!IN_RANGE (start, end, rloc, reloc_size))
{
warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
(unsigned long) rp->r_offset,
- printable_section_name (section));
+ printable_section_name (filedata, section));
continue;
}
if (sym_index >= num_syms)
{
warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
- sym_index, printable_section_name (section));
+ sym_index, printable_section_name (filedata, section));
continue;
}
sym = symtab + sym_index;
&& ELF_ST_TYPE (sym->st_info) != STT_COMMON
&& ELF_ST_TYPE (sym->st_info) > STT_SECTION)
{
- warn (_("skipping unexpected symbol type %s in %ld'th relocation in section %s\n"),
- get_symbol_type (ELF_ST_TYPE (sym->st_info)),
- (long int)(rp - relocs),
- printable_section_name (relsec));
+ warn (_("skipping unexpected symbol type %s in section %s relocation %ld\n"),
+ get_symbol_type (filedata, ELF_ST_TYPE (sym->st_info)),
+ printable_section_name (filedata, relsec),
+ (long int)(rp - relocs));
continue;
}
/* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
partial_inplace. */
if (!is_rela
- || (elf_header.e_machine == EM_XTENSA
+ || (filedata->file_header.e_machine == EM_XTENSA
&& reloc_type == 1)
- || ((elf_header.e_machine == EM_PJ
- || elf_header.e_machine == EM_PJ_OLD)
+ || ((filedata->file_header.e_machine == EM_PJ
+ || filedata->file_header.e_machine == EM_PJ_OLD)
&& 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);
+ || ((filedata->file_header.e_machine == EM_D30V
+ || filedata->file_header.e_machine == EM_CYGNUS_D30V)
+ && 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 (reloc_type)
- || is_64bit_pcrel_reloc (reloc_type))
+ if (is_32bit_pcrel_reloc (filedata, reloc_type)
+ || is_64bit_pcrel_reloc (filedata, reloc_type))
{
/* On HPPA, all pc-relative relocations are biased by 8. */
- if (elf_header.e_machine == EM_PARISC)
+ if (filedata->file_header.e_machine == EM_PARISC)
addend -= 8;
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);
}
free (symtab);
/* Let the target specific reloc processing code know that
we have finished with these relocs. */
- target_specific_reloc_handling (NULL, NULL, NULL, NULL, 0);
+ target_specific_reloc_handling (filedata, NULL, NULL, NULL, NULL, 0);
if (relocs_return)
{
break;
}
+
+ return TRUE;
}
#ifdef SUPPORT_DISASSEMBLY
-static int
-disassemble_section (Elf_Internal_Shdr * section, FILE * file)
+static bfd_boolean
+disassemble_section (Elf_Internal_Shdr * section, Filedata * filedata)
{
- printf (_("\nAssembly dump of section %s\n"), printable_section_name (section));
+ printf (_("\nAssembly dump of section %s\n"), printable_section_name (filedata, section));
/* FIXME: XXX -- to be done --- XXX */
- return 1;
+ return TRUE;
}
#endif
to a malloc'ed buffer or NULL if something went wrong. */
static char *
-get_section_contents (Elf_Internal_Shdr * section, FILE * file)
+get_section_contents (Elf_Internal_Shdr * section, Filedata * filedata)
{
- bfd_size_type num_bytes;
-
- num_bytes = section->sh_size;
+ bfd_size_type num_bytes = section->sh_size;
if (num_bytes == 0 || section->sh_type == SHT_NOBITS)
{
- printf (_("\nSection '%s' has no data to dump.\n"),
- printable_section_name (section));
+ printf (_("Section '%s' has no data to dump.\n"),
+ printable_section_name (filedata, section));
return NULL;
}
- return (char *) get_data (NULL, file, section->sh_offset, 1, num_bytes,
+ return (char *) get_data (NULL, filedata, section->sh_offset, 1, num_bytes,
_("section contents"));
}
/* Uncompresses a section that was compressed using zlib, in place. */
static bfd_boolean
-uncompress_section_contents (unsigned char **buffer,
- dwarf_size_type uncompressed_size,
- dwarf_size_type *size)
+uncompress_section_contents (unsigned char ** buffer,
+ dwarf_size_type uncompressed_size,
+ dwarf_size_type * size)
{
dwarf_size_type compressed_size = *size;
unsigned char * compressed_buffer = *buffer;
return FALSE;
}
-static void
-dump_section_as_strings (Elf_Internal_Shdr * section, FILE * file)
+static bfd_boolean
+dump_section_as_strings (Elf_Internal_Shdr * section, Filedata * filedata)
{
Elf_Internal_Shdr * relsec;
bfd_size_type num_bytes;
unsigned char * start;
bfd_boolean some_strings_shown;
- real_start = start = (unsigned char *) get_section_contents (section,
- file);
+ real_start = start = (unsigned char *) get_section_contents (section, filedata);
if (start == NULL)
- return;
+ /* PR 21820: Do not fail if the section was empty. */
+ return (section->sh_size == 0 || section->sh_type == SHT_NOBITS) ? TRUE : FALSE;
+
num_bytes = section->sh_size;
- printf (_("\nString dump of section '%s':\n"), printable_section_name (section));
+ printf (_("\nString dump of section '%s':\n"), printable_section_name (filedata, section));
if (decompress_dumps)
{
if (chdr.ch_type != ELFCOMPRESS_ZLIB)
{
warn (_("section '%s' has unsupported compress type: %d\n"),
- printable_section_name (section), chdr.ch_type);
- return;
- }
- else if (chdr.ch_addralign != section->sh_addralign)
- {
- warn (_("compressed section '%s' is corrupted\n"),
- printable_section_name (section));
- return;
+ printable_section_name (filedata, section), chdr.ch_type);
+ return FALSE;
}
uncompressed_size = chdr.ch_size;
start += compression_header_size;
else
{
error (_("Unable to decompress section %s\n"),
- printable_section_name (section));
- return;
+ printable_section_name (filedata, section));
+ return FALSE;
}
}
else
case and issue a warning message in order to avoid confusion.
FIXME: Maybe we ought to have an option that dumps a section with
relocs applied ? */
- for (relsec = section_headers;
- relsec < section_headers + elf_header.e_shnum;
+ for (relsec = filedata->section_headers;
+ relsec < filedata->section_headers + filedata->file_header.e_shnum;
++relsec)
{
if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
- || relsec->sh_info >= elf_header.e_shnum
- || section_headers + relsec->sh_info != section
+ || relsec->sh_info >= filedata->file_header.e_shnum
+ || filedata->section_headers + relsec->sh_info != section
|| relsec->sh_size == 0
- || relsec->sh_link >= elf_header.e_shnum)
+ || relsec->sh_link >= filedata->file_header.e_shnum)
continue;
printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
free (real_start);
putchar ('\n');
+ return TRUE;
}
-static void
-dump_section_as_bytes (Elf_Internal_Shdr * section,
- FILE * file,
- bfd_boolean relocate)
+static bfd_boolean
+dump_section_as_bytes (Elf_Internal_Shdr * section,
+ Filedata * filedata,
+ bfd_boolean relocate)
{
Elf_Internal_Shdr * relsec;
bfd_size_type bytes;
unsigned char * real_start;
unsigned char * start;
- real_start = start = (unsigned char *) get_section_contents (section, file);
+ real_start = start = (unsigned char *) get_section_contents (section, filedata);
if (start == NULL)
- return;
+ /* PR 21820: Do not fail if the section was empty. */
+ return (section->sh_size == 0 || section->sh_type == SHT_NOBITS) ? TRUE : FALSE;
+
section_size = section->sh_size;
- printf (_("\nHex dump of section '%s':\n"), printable_section_name (section));
+ printf (_("\nHex dump of section '%s':\n"), printable_section_name (filedata, section));
if (decompress_dumps)
{
if (chdr.ch_type != ELFCOMPRESS_ZLIB)
{
warn (_("section '%s' has unsupported compress type: %d\n"),
- printable_section_name (section), chdr.ch_type);
- return;
- }
- else if (chdr.ch_addralign != section->sh_addralign)
- {
- warn (_("compressed section '%s' is corrupted\n"),
- printable_section_name (section));
- return;
+ printable_section_name (filedata, section), chdr.ch_type);
+ return FALSE;
}
uncompressed_size = chdr.ch_size;
start += compression_header_size;
else
{
error (_("Unable to decompress section %s\n"),
- printable_section_name (section));
+ printable_section_name (filedata, section));
/* FIXME: Print the section anyway ? */
- return;
+ return FALSE;
}
}
else
if (relocate)
{
- apply_relocations (file, section, start, section_size, NULL, NULL);
+ if (! apply_relocations (filedata, section, start, section_size, NULL, NULL))
+ return FALSE;
}
else
{
case and issue a warning message in order to avoid confusion.
FIXME: Maybe we ought to have an option that dumps a section with
relocs applied ? */
- for (relsec = section_headers;
- relsec < section_headers + elf_header.e_shnum;
+ for (relsec = filedata->section_headers;
+ relsec < filedata->section_headers + filedata->file_header.e_shnum;
++relsec)
{
if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
- || relsec->sh_info >= elf_header.e_shnum
- || section_headers + relsec->sh_info != section
+ || relsec->sh_info >= filedata->file_header.e_shnum
+ || filedata->section_headers + relsec->sh_info != section
|| relsec->sh_size == 0
- || relsec->sh_link >= elf_header.e_shnum)
+ || relsec->sh_link >= filedata->file_header.e_shnum)
continue;
printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
free (real_start);
putchar ('\n');
+ return TRUE;
}
-static int
-load_specific_debug_section (enum dwarf_section_display_enum debug,
- const Elf_Internal_Shdr * sec, void * file)
+static ctf_sect_t *
+shdr_to_ctf_sect (ctf_sect_t *buf, Elf_Internal_Shdr *shdr, Filedata *filedata)
{
- struct dwarf_section * section = &debug_displays [debug].section;
- char buf [64];
+ buf->cts_name = SECTION_NAME (shdr);
+ buf->cts_size = shdr->sh_size;
+ buf->cts_entsize = shdr->sh_entsize;
- /* If it is already loaded, do nothing. */
- if (section->start != NULL)
- return 1;
+ return buf;
+}
- snprintf (buf, sizeof (buf), _("%s section data"), section->name);
- section->address = sec->sh_addr;
- section->user_data = NULL;
- section->start = (unsigned char *) get_data (NULL, (FILE *) file,
- sec->sh_offset, 1,
- sec->sh_size, buf);
- if (section->start == NULL)
- section->size = 0;
- else
- {
- unsigned char *start = section->start;
- dwarf_size_type size = sec->sh_size;
- dwarf_size_type uncompressed_size = 0;
+/* Formatting callback function passed to ctf_dump. Returns either the pointer
+ it is passed, or a pointer to newly-allocated storage, in which case
+ dump_ctf() will free it when it no longer needs it. */
- if ((sec->sh_flags & SHF_COMPRESSED) != 0)
- {
- Elf_Internal_Chdr chdr;
- unsigned int compression_header_size;
+static char *dump_ctf_indent_lines (ctf_sect_names_t sect ATTRIBUTE_UNUSED,
+ char *s, void *arg)
+{
+ const char *blanks = arg;
+ char *new_s;
- if (size < (is_32bit_elf
- ? sizeof (Elf32_External_Chdr)
- : sizeof (Elf64_External_Chdr)))
- {
- warn (_("compressed section %s is too small to contain a compression header"),
- section->name);
- return 0;
- }
+ if (asprintf (&new_s, "%s%s", blanks, s) < 0)
+ return s;
+ return new_s;
+}
- compression_header_size = get_compression_header (&chdr, start, size);
+static bfd_boolean
+dump_section_as_ctf (Elf_Internal_Shdr * section, Filedata * filedata)
+{
+ Elf_Internal_Shdr * parent_sec = NULL;
+ Elf_Internal_Shdr * symtab_sec = NULL;
+ Elf_Internal_Shdr * strtab_sec = NULL;
+ void * data = NULL;
+ void * symdata = NULL;
+ void * strdata = NULL;
+ void * parentdata = NULL;
+ ctf_sect_t ctfsect, symsect, strsect, parentsect;
+ ctf_sect_t * symsectp = NULL;
+ ctf_sect_t * strsectp = NULL;
+ ctf_file_t * ctf = NULL;
+ ctf_file_t * parent = NULL;
+
+ const char *things[] = {"Header", "Labels", "Data objects",
+ "Function objects", "Variables", "Types", "Strings",
+ ""};
+ const char **thing;
+ int err;
+ bfd_boolean ret = FALSE;
+ size_t i;
- if (chdr.ch_type != ELFCOMPRESS_ZLIB)
- {
- warn (_("section '%s' has unsupported compress type: %d\n"),
- section->name, chdr.ch_type);
- return 0;
- }
- else if (chdr.ch_addralign != sec->sh_addralign)
- {
- warn (_("compressed section '%s' is corrupted\n"),
- section->name);
- return 0;
- }
- uncompressed_size = chdr.ch_size;
- start += compression_header_size;
- size -= compression_header_size;
- }
- else if (size > 12 && streq ((char *) start, "ZLIB"))
+ shdr_to_ctf_sect (&ctfsect, section, filedata);
+ data = get_section_contents (section, filedata);
+ ctfsect.cts_data = data;
+
+ if (!dump_ctf_symtab_name)
+ dump_ctf_symtab_name = strdup (".symtab");
+
+ if (!dump_ctf_strtab_name)
+ dump_ctf_strtab_name = strdup (".strtab");
+
+ if (dump_ctf_symtab_name && dump_ctf_symtab_name[0] != 0)
+ {
+ if ((symtab_sec = find_section (filedata, dump_ctf_symtab_name)) == NULL)
{
- /* Read the zlib header. In this case, it should be "ZLIB"
+ error (_("No symbol section named %s\n"), dump_ctf_symtab_name);
+ goto fail;
+ }
+ if ((symdata = (void *) get_data (NULL, filedata,
+ symtab_sec->sh_offset, 1,
+ symtab_sec->sh_size,
+ _("symbols"))) == NULL)
+ goto fail;
+ symsectp = shdr_to_ctf_sect (&symsect, symtab_sec, filedata);
+ symsect.cts_data = symdata;
+ }
+ if (dump_ctf_strtab_name && dump_ctf_symtab_name[0] != 0)
+ {
+ if ((strtab_sec = find_section (filedata, dump_ctf_strtab_name)) == NULL)
+ {
+ error (_("No string table section named %s\n"),
+ dump_ctf_strtab_name);
+ goto fail;
+ }
+ if ((strdata = (void *) get_data (NULL, filedata,
+ strtab_sec->sh_offset, 1,
+ strtab_sec->sh_size,
+ _("strings"))) == NULL)
+ goto fail;
+ strsectp = shdr_to_ctf_sect (&strsect, strtab_sec, filedata);
+ strsect.cts_data = strdata;
+ }
+ if (dump_ctf_parent_name)
+ {
+ if ((parent_sec = find_section (filedata, dump_ctf_parent_name)) == NULL)
+ {
+ error (_("No CTF parent section named %s\n"), dump_ctf_parent_name);
+ goto fail;
+ }
+ if ((parentdata = (void *) get_data (NULL, filedata,
+ parent_sec->sh_offset, 1,
+ parent_sec->sh_size,
+ _("CTF parent"))) == NULL)
+ goto fail;
+ shdr_to_ctf_sect (&parentsect, parent_sec, filedata);
+ parentsect.cts_data = parentdata;
+ }
+
+ /* Load the CTF file and dump it. */
+
+ if ((ctf = ctf_bufopen (&ctfsect, symsectp, strsectp, &err)) == NULL)
+ {
+ error (_("CTF open failure: %s\n"), ctf_errmsg (err));
+ goto fail;
+ }
+
+ if (parentdata)
+ {
+ if ((parent = ctf_bufopen (&parentsect, symsectp, strsectp, &err)) == NULL)
+ {
+ error (_("CTF open failure: %s\n"), ctf_errmsg (err));
+ goto fail;
+ }
+
+ ctf_import (ctf, parent);
+ }
+
+ ret = TRUE;
+
+ printf (_("\nDump of CTF section '%s':\n"),
+ printable_section_name (filedata, section));
+
+ for (i = 0, thing = things; *thing[0]; thing++, i++)
+ {
+ ctf_dump_state_t *s = NULL;
+ char *item;
+
+ printf ("\n %s:\n", *thing);
+ while ((item = ctf_dump (ctf, &s, i, dump_ctf_indent_lines,
+ (void *) " ")) != NULL)
+ {
+ printf ("%s\n", item);
+ free (item);
+ }
+
+ if (ctf_errno (ctf))
+ {
+ error (_("Iteration failed: %s, %s\n"), *thing,
+ ctf_errmsg (ctf_errno (ctf)));
+ ret = FALSE;
+ }
+ }
+
+ fail:
+ ctf_file_close (ctf);
+ ctf_file_close (parent);
+ free (parentdata);
+ free (data);
+ free (symdata);
+ free (strdata);
+ return ret;
+}
+
+static bfd_boolean
+load_specific_debug_section (enum dwarf_section_display_enum debug,
+ const Elf_Internal_Shdr * sec,
+ void * data)
+{
+ struct dwarf_section * section = &debug_displays [debug].section;
+ char buf [64];
+ Filedata * filedata = (Filedata *) data;
+
+ if (section->start != NULL)
+ {
+ /* If it is already loaded, do nothing. */
+ if (streq (section->filename, filedata->file_name))
+ return TRUE;
+ free (section->start);
+ }
+
+ snprintf (buf, sizeof (buf), _("%s section data"), section->name);
+ section->address = sec->sh_addr;
+ section->user_data = NULL;
+ section->filename = filedata->file_name;
+ section->start = (unsigned char *) get_data (NULL, filedata,
+ sec->sh_offset, 1,
+ sec->sh_size, buf);
+ if (section->start == NULL)
+ section->size = 0;
+ else
+ {
+ unsigned char *start = section->start;
+ dwarf_size_type size = sec->sh_size;
+ dwarf_size_type uncompressed_size = 0;
+
+ if ((sec->sh_flags & SHF_COMPRESSED) != 0)
+ {
+ Elf_Internal_Chdr chdr;
+ unsigned int compression_header_size;
+
+ if (size < (is_32bit_elf
+ ? sizeof (Elf32_External_Chdr)
+ : sizeof (Elf64_External_Chdr)))
+ {
+ warn (_("compressed section %s is too small to contain a compression header"),
+ section->name);
+ return FALSE;
+ }
+
+ compression_header_size = get_compression_header (&chdr, start, size);
+
+ if (chdr.ch_type != ELFCOMPRESS_ZLIB)
+ {
+ warn (_("section '%s' has unsupported compress type: %d\n"),
+ section->name, chdr.ch_type);
+ return FALSE;
+ }
+ uncompressed_size = chdr.ch_size;
+ start += compression_header_size;
+ size -= compression_header_size;
+ }
+ else if (size > 12 && streq ((char *) start, "ZLIB"))
+ {
+ /* Read the zlib header. In this case, it should be "ZLIB"
followed by the uncompressed section size, 8 bytes in
big-endian order. */
uncompressed_size = start[4]; uncompressed_size <<= 8;
else
{
error (_("Unable to decompress section %s\n"),
- printable_section_name (sec));
- return 0;
+ printable_section_name (filedata, sec));
+ return FALSE;
}
}
}
if (section->start == NULL)
- return 0;
+ return FALSE;
if (debug_displays [debug].relocate)
- apply_relocations ((FILE *) file, sec, section->start, section->size,
- & section->reloc_info, & section->num_relocs);
+ {
+ if (! apply_relocations (filedata, sec, section->start, section->size,
+ & section->reloc_info, & section->num_relocs))
+ return FALSE;
+ }
else
{
section->reloc_info = NULL;
section->num_relocs = 0;
}
- return 1;
+ return TRUE;
}
/* If this is not NULL, load_debug_section will only look for sections
within the list of sections given here. */
-unsigned int *section_subset = NULL;
+static unsigned int * section_subset = NULL;
-int
-load_debug_section (enum dwarf_section_display_enum debug, void * file)
+bfd_boolean
+load_debug_section (enum dwarf_section_display_enum debug, void * data)
{
struct dwarf_section * section = &debug_displays [debug].section;
Elf_Internal_Shdr * sec;
+ Filedata * filedata = (Filedata *) data;
+
+ /* 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 != 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_length
+ = filedata->string_table != NULL ? strs->sh_size : 0;
+ }
+ }
/* Locate the debug section. */
- sec = find_section_in_set (section->uncompressed_name, section_subset);
+ sec = find_section_in_set (filedata, section->uncompressed_name, section_subset);
if (sec != NULL)
section->name = section->uncompressed_name;
else
{
- sec = find_section_in_set (section->compressed_name, section_subset);
+ sec = find_section_in_set (filedata, section->compressed_name, section_subset);
if (sec != NULL)
section->name = section->compressed_name;
}
if (sec == NULL)
- return 0;
+ return FALSE;
/* If we're loading from a subset of sections, and we've loaded
a section matching this name before, it's likely that it's a
if (section_subset != NULL)
free_debug_section (debug);
- return load_specific_debug_section (debug, sec, (FILE *) file);
+ return load_specific_debug_section (debug, sec, data);
}
void
section->size = 0;
}
-static int
-display_debug_section (int shndx, Elf_Internal_Shdr * section, FILE * file)
+static bfd_boolean
+display_debug_section (int shndx, Elf_Internal_Shdr * section, Filedata * filedata)
{
char * name = SECTION_NAME (section);
- const char * print_name = printable_section_name (section);
+ const char * print_name = printable_section_name (filedata, section);
bfd_size_type length;
- int result = 1;
+ bfd_boolean result = TRUE;
int i;
length = section->sh_size;
if (length == 0)
{
printf (_("\nSection '%s' has no debugging data.\n"), print_name);
- return 0;
+ return TRUE;
}
if (section->sh_type == SHT_NOBITS)
{
stripped with the --only-keep-debug command line option. */
printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"),
print_name);
- return 0;
+ return FALSE;
}
if (const_strneq (name, ".gnu.linkonce.wi."))
/* 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 (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 (load_specific_debug_section ((enum dwarf_section_display_enum) i,
- section, file))
- {
- /* 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 (file, shndx);
+ if (secondary)
+ free_debug_section (id);
- result &= debug_displays[i].display (sec, file);
+ 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;
- section_subset = NULL;
+ 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);
- if (secondary || (i != info && i != abbrev))
- free_debug_section ((enum dwarf_section_display_enum) i);
- }
+ result &= display->display (sec, filedata);
- break;
- }
+ section_subset = NULL;
+
+ if (secondary || (id != info && id != abbrev))
+ free_debug_section (id);
+ }
+ break;
+ }
+ }
if (i == max)
{
printf (_("Unrecognized debug section: %s\n"), print_name);
- result = 0;
+ result = FALSE;
}
return result;
based on section name. */
static void
-initialise_dumps_byname (void)
+initialise_dumps_byname (Filedata * filedata)
{
struct dump_list_entry * cur;
for (cur = dump_sects_byname; cur; cur = cur->next)
{
unsigned int i;
- int any;
+ bfd_boolean any = FALSE;
- for (i = 0, any = 0; i < elf_header.e_shnum; i++)
- if (streq (SECTION_NAME (section_headers + i), cur->name))
+ for (i = 0; i < filedata->file_header.e_shnum; i++)
+ if (streq (SECTION_NAME (filedata->section_headers + i), cur->name))
{
- request_dump_bynumber (i, cur->type);
- any = 1;
+ request_dump_bynumber (filedata, i, cur->type);
+ any = TRUE;
}
if (!any)
}
}
-static void
-process_section_contents (FILE * file)
+static bfd_boolean
+process_section_contents (Filedata * filedata)
{
Elf_Internal_Shdr * section;
unsigned int i;
+ bfd_boolean res = TRUE;
if (! do_dump)
- return;
+ return TRUE;
- initialise_dumps_byname ();
+ initialise_dumps_byname (filedata);
- for (i = 0, section = section_headers;
- i < elf_header.e_shnum && i < num_dump_sects;
+ for (i = 0, section = filedata->section_headers;
+ i < filedata->file_header.e_shnum && i < filedata->num_dump_sects;
i++, section++)
{
+ dump_type dump = filedata->dump_sects[i];
+
#ifdef SUPPORT_DISASSEMBLY
- if (dump_sects[i] & DISASS_DUMP)
- disassemble_section (section, file);
+ if (dump & DISASS_DUMP)
+ {
+ if (! disassemble_section (section, filedata))
+ res = FALSE;
+ }
#endif
- if (dump_sects[i] & HEX_DUMP)
- dump_section_as_bytes (section, file, FALSE);
+ if (dump & HEX_DUMP)
+ {
+ if (! dump_section_as_bytes (section, filedata, FALSE))
+ res = FALSE;
+ }
+
+ if (dump & RELOC_DUMP)
+ {
+ if (! dump_section_as_bytes (section, filedata, TRUE))
+ res = FALSE;
+ }
- if (dump_sects[i] & RELOC_DUMP)
- dump_section_as_bytes (section, file, TRUE);
+ if (dump & STRING_DUMP)
+ {
+ if (! dump_section_as_strings (section, filedata))
+ res = FALSE;
+ }
- if (dump_sects[i] & STRING_DUMP)
- dump_section_as_strings (section, file);
+ if (dump & DEBUG_DUMP)
+ {
+ if (! display_debug_section (i, section, filedata))
+ res = FALSE;
+ }
- if (dump_sects[i] & DEBUG_DUMP)
- display_debug_section (i, section, file);
+ if (dump & CTF_DUMP)
+ {
+ if (! dump_section_as_ctf (section, filedata))
+ res = FALSE;
+ }
}
/* Check to see if the user requested a
dump of a section that does not exist. */
- while (i < num_dump_sects)
+ while (i < filedata->num_dump_sects)
{
- if (dump_sects[i])
- warn (_("Section %d was not dumped because it does not exist!\n"), i);
+ if (filedata->dump_sects[i])
+ {
+ warn (_("Section %d was not dumped because it does not exist!\n"), i);
+ res = FALSE;
+ }
i++;
}
+
+ return res;
}
static void
{
if (mask)
{
- int first = 1;
+ bfd_boolean first = TRUE;
+
if (mask & OEX_FPU_INEX)
- fputs ("INEX", stdout), first = 0;
+ fputs ("INEX", stdout), first = FALSE;
if (mask & OEX_FPU_UFLO)
- printf ("%sUFLO", first ? "" : "|"), first = 0;
+ printf ("%sUFLO", first ? "" : "|"), first = FALSE;
if (mask & OEX_FPU_OFLO)
- printf ("%sOFLO", first ? "" : "|"), first = 0;
+ printf ("%sOFLO", first ? "" : "|"), first = FALSE;
if (mask & OEX_FPU_DIV0)
- printf ("%sDIV0", first ? "" : "|"), first = 0;
+ printf ("%sDIV0", first ? "" : "|"), first = FALSE;
if (mask & OEX_FPU_INVAL)
printf ("%sINVAL", first ? "" : "|");
}
}
else
{
- unsigned int len;
-
- val = read_uleb128 (p, &len, end);
- p += len;
+ READ_ULEB (val, p, end);
printf ("%ld (0x%lx)\n", val, val);
}
return p;
}
+/* ARC ABI attributes section. */
+
+static unsigned char *
+display_arc_attribute (unsigned char * p,
+ const unsigned char * const end)
+{
+ unsigned int tag;
+ unsigned int val;
+
+ READ_ULEB (tag, p, end);
+
+ switch (tag)
+ {
+ case Tag_ARC_PCS_config:
+ READ_ULEB (val, p, end);
+ printf (" Tag_ARC_PCS_config: ");
+ switch (val)
+ {
+ case 0:
+ printf (_("Absent/Non standard\n"));
+ break;
+ case 1:
+ printf (_("Bare metal/mwdt\n"));
+ break;
+ case 2:
+ printf (_("Bare metal/newlib\n"));
+ break;
+ case 3:
+ printf (_("Linux/uclibc\n"));
+ break;
+ case 4:
+ printf (_("Linux/glibc\n"));
+ break;
+ default:
+ printf (_("Unknown\n"));
+ break;
+ }
+ break;
+
+ case Tag_ARC_CPU_base:
+ READ_ULEB (val, p, end);
+ printf (" Tag_ARC_CPU_base: ");
+ switch (val)
+ {
+ default:
+ case TAG_CPU_NONE:
+ printf (_("Absent\n"));
+ break;
+ case TAG_CPU_ARC6xx:
+ printf ("ARC6xx\n");
+ break;
+ case TAG_CPU_ARC7xx:
+ printf ("ARC7xx\n");
+ break;
+ case TAG_CPU_ARCEM:
+ printf ("ARCEM\n");
+ break;
+ case TAG_CPU_ARCHS:
+ printf ("ARCHS\n");
+ break;
+ }
+ break;
+
+ case Tag_ARC_CPU_variation:
+ READ_ULEB (val, p, end);
+ printf (" Tag_ARC_CPU_variation: ");
+ switch (val)
+ {
+ default:
+ if (val > 0 && val < 16)
+ printf ("Core%d\n", val);
+ else
+ printf ("Unknown\n");
+ break;
+
+ case 0:
+ printf (_("Absent\n"));
+ break;
+ }
+ break;
+
+ case Tag_ARC_CPU_name:
+ printf (" Tag_ARC_CPU_name: ");
+ p = display_tag_value (-1, p, end);
+ break;
+
+ case Tag_ARC_ABI_rf16:
+ READ_ULEB (val, p, end);
+ printf (" Tag_ARC_ABI_rf16: %s\n", val ? _("yes") : _("no"));
+ break;
+
+ case Tag_ARC_ABI_osver:
+ READ_ULEB (val, p, end);
+ printf (" Tag_ARC_ABI_osver: v%d\n", val);
+ break;
+
+ case Tag_ARC_ABI_pic:
+ case Tag_ARC_ABI_sda:
+ READ_ULEB (val, p, end);
+ printf (tag == Tag_ARC_ABI_sda ? " Tag_ARC_ABI_sda: "
+ : " Tag_ARC_ABI_pic: ");
+ switch (val)
+ {
+ case 0:
+ printf (_("Absent\n"));
+ break;
+ case 1:
+ printf ("MWDT\n");
+ break;
+ case 2:
+ printf ("GNU\n");
+ break;
+ default:
+ printf (_("Unknown\n"));
+ break;
+ }
+ break;
+
+ case Tag_ARC_ABI_tls:
+ READ_ULEB (val, p, end);
+ printf (" Tag_ARC_ABI_tls: %s\n", val ? "r25": "none");
+ break;
+
+ case Tag_ARC_ABI_enumsize:
+ READ_ULEB (val, p, end);
+ printf (" Tag_ARC_ABI_enumsize: %s\n", val ? _("default") :
+ _("smallest"));
+ break;
+
+ case Tag_ARC_ABI_exceptions:
+ READ_ULEB (val, p, end);
+ printf (" Tag_ARC_ABI_exceptions: %s\n", val ? _("OPTFP")
+ : _("default"));
+ break;
+
+ case Tag_ARC_ABI_double_size:
+ READ_ULEB (val, p, end);
+ printf (" Tag_ARC_ABI_double_size: %d\n", val);
+ break;
+
+ case Tag_ARC_ISA_config:
+ printf (" Tag_ARC_ISA_config: ");
+ p = display_tag_value (-1, p, end);
+ break;
+
+ case Tag_ARC_ISA_apex:
+ printf (" Tag_ARC_ISA_apex: ");
+ p = display_tag_value (-1, p, end);
+ break;
+
+ case Tag_ARC_ISA_mpy_option:
+ READ_ULEB (val, p, end);
+ printf (" Tag_ARC_ISA_mpy_option: %d\n", val);
+ break;
+
+ case Tag_ARC_ATR_version:
+ READ_ULEB (val, p, end);
+ printf (" Tag_ARC_ATR_version: %d\n", val);
+ break;
+
+ default:
+ return display_tag_value (tag & 1, p, end);
+ }
+
+ return p;
+}
+
/* ARM EABI attributes section. */
typedef struct
{
static const char * arm_attr_tag_CPU_arch[] =
{"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
- "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8", "", "v8-M.baseline",
- "v8-M.mainline"};
+ "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8", "v8-R", "v8-M.baseline",
+ "v8-M.mainline", "", "", "", "v8.1-M.mainline"};
static const char * arm_attr_tag_ARM_ISA_use[] = {"No", "Yes"};
static const char * arm_attr_tag_THUMB_ISA_use[] =
{"No", "Thumb-1", "Thumb-2", "Yes"};
static const char * arm_attr_tag_MPextension_use_legacy[] =
{"Not Allowed", "Allowed"};
+static const char * arm_attr_tag_MVE_arch[] =
+ {"No MVE", "MVE Integer only", "MVE Integer and FP"};
+
#define LOOKUP(id, name) \
{id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
static arm_attr_public_tag arm_attr_public_tags[] =
LOOKUP(42, MPextension_use),
LOOKUP(44, DIV_use),
LOOKUP(46, DSP_extension),
+ LOOKUP(48, MVE_arch),
{64, "nodefaults", 0, NULL},
{65, "also_compatible_with", 0, NULL},
LOOKUP(66, T2EE_use),
const unsigned char * const end)
{
unsigned int tag;
- unsigned int len;
unsigned int val;
arm_attr_public_tag * attr;
unsigned i;
unsigned int type;
- tag = read_uleb128 (p, &len, end);
- p += len;
+ READ_ULEB (tag, p, end);
attr = NULL;
for (i = 0; i < ARRAY_SIZE (arm_attr_public_tags); i++)
{
switch (tag)
{
case 7: /* Tag_CPU_arch_profile. */
- val = read_uleb128 (p, &len, end);
- p += len;
+ READ_ULEB (val, p, end);
switch (val)
{
case 0: printf (_("None\n")); break;
break;
case 24: /* Tag_align_needed. */
- val = read_uleb128 (p, &len, end);
- p += len;
+ READ_ULEB (val, p, end);
switch (val)
{
case 0: printf (_("None\n")); break;
break;
case 25: /* Tag_align_preserved. */
- val = read_uleb128 (p, &len, end);
- p += len;
+ READ_ULEB (val, p, end);
switch (val)
{
case 0: printf (_("None\n")); break;
case 32: /* Tag_compatibility. */
{
- val = read_uleb128 (p, &len, end);
- p += len;
+ READ_ULEB (val, p, end);
printf (_("flag = %d, vendor = "), val);
if (p < end - 1)
{
break;
case 65: /* Tag_also_compatible_with. */
- val = read_uleb128 (p, &len, end);
- p += len;
+ READ_ULEB (val, p, end);
if (val == 6 /* Tag_CPU_arch. */)
{
- val = read_uleb128 (p, &len, end);
- p += len;
+ READ_ULEB (val, p, end);
if ((unsigned int) val >= ARRAY_SIZE (arm_attr_tag_CPU_arch))
printf ("??? (%d)\n", val);
else
default:
assert (attr->type & 0x80);
- val = read_uleb128 (p, &len, end);
- p += len;
+ READ_ULEB (val, p, end);
type = attr->type & 0x7f;
if (val >= type)
printf ("??? (%d)\n", val);
unsigned char * (* display_proc_gnu_attribute) (unsigned char *, unsigned int, const unsigned char * const),
const unsigned char * const end)
{
- int tag;
- unsigned int len;
+ unsigned int tag;
unsigned int val;
- tag = read_uleb128 (p, &len, end);
- p += len;
+ READ_ULEB (tag, p, end);
/* Tag_compatibility is the only generic GNU attribute defined at
present. */
if (tag == 32)
{
- val = read_uleb128 (p, &len, end);
- p += len;
+ READ_ULEB (val, p, end);
printf (_("flag = %d, vendor = "), val);
if (p == end)
unsigned int tag,
const unsigned char * const end)
{
- unsigned int len;
unsigned int val;
if (tag == Tag_GNU_Power_ABI_FP)
{
- val = read_uleb128 (p, &len, end);
- p += len;
printf (" Tag_GNU_Power_ABI_FP: ");
- if (len == 0)
+ if (p == end)
{
printf (_("<corrupt>\n"));
return p;
}
+ READ_ULEB (val, p, end);
if (val > 15)
printf ("(%#x), ", val);
if (tag == Tag_GNU_Power_ABI_Vector)
{
- val = read_uleb128 (p, &len, end);
- p += len;
printf (" Tag_GNU_Power_ABI_Vector: ");
- if (len == 0)
+ if (p == end)
{
printf (_("<corrupt>\n"));
return p;
}
+ READ_ULEB (val, p, end);
if (val > 3)
printf ("(%#x), ", val);
if (tag == Tag_GNU_Power_ABI_Struct_Return)
{
- val = read_uleb128 (p, &len, end);
- p += len;
printf (" Tag_GNU_Power_ABI_Struct_Return: ");
- if (len == 0)
+ if (p == end)
{
printf (_("<corrupt>\n"));
return p;
}
+ READ_ULEB (val, p, end);
if (val > 2)
printf ("(%#x), ", val);
unsigned int tag,
const unsigned char * const end)
{
- unsigned int len;
- int val;
+ unsigned int val;
if (tag == Tag_GNU_S390_ABI_Vector)
{
- val = read_uleb128 (p, &len, end);
- p += len;
printf (" Tag_GNU_S390_ABI_Vector: ");
+ READ_ULEB (val, p, end);
switch (val)
{
{
if (mask)
{
- int first = 1;
+ bfd_boolean first = TRUE;
if (mask & ELF_SPARC_HWCAP_MUL32)
- fputs ("mul32", stdout), first = 0;
+ fputs ("mul32", stdout), first = FALSE;
if (mask & ELF_SPARC_HWCAP_DIV32)
- printf ("%sdiv32", first ? "" : "|"), first = 0;
+ printf ("%sdiv32", first ? "" : "|"), first = FALSE;
if (mask & ELF_SPARC_HWCAP_FSMULD)
- printf ("%sfsmuld", first ? "" : "|"), first = 0;
+ printf ("%sfsmuld", first ? "" : "|"), first = FALSE;
if (mask & ELF_SPARC_HWCAP_V8PLUS)
- printf ("%sv8plus", first ? "" : "|"), first = 0;
+ printf ("%sv8plus", first ? "" : "|"), first = FALSE;
if (mask & ELF_SPARC_HWCAP_POPC)
- printf ("%spopc", first ? "" : "|"), first = 0;
+ printf ("%spopc", first ? "" : "|"), first = FALSE;
if (mask & ELF_SPARC_HWCAP_VIS)
- printf ("%svis", first ? "" : "|"), first = 0;
+ printf ("%svis", first ? "" : "|"), first = FALSE;
if (mask & ELF_SPARC_HWCAP_VIS2)
- printf ("%svis2", first ? "" : "|"), first = 0;
+ printf ("%svis2", first ? "" : "|"), first = FALSE;
if (mask & ELF_SPARC_HWCAP_ASI_BLK_INIT)
- printf ("%sASIBlkInit", first ? "" : "|"), first = 0;
+ printf ("%sASIBlkInit", first ? "" : "|"), first = FALSE;
if (mask & ELF_SPARC_HWCAP_FMAF)
- printf ("%sfmaf", first ? "" : "|"), first = 0;
+ printf ("%sfmaf", first ? "" : "|"), first = FALSE;
if (mask & ELF_SPARC_HWCAP_VIS3)
- printf ("%svis3", first ? "" : "|"), first = 0;
+ printf ("%svis3", first ? "" : "|"), first = FALSE;
if (mask & ELF_SPARC_HWCAP_HPC)
- printf ("%shpc", first ? "" : "|"), first = 0;
+ printf ("%shpc", first ? "" : "|"), first = FALSE;
if (mask & ELF_SPARC_HWCAP_RANDOM)
- printf ("%srandom", first ? "" : "|"), first = 0;
+ printf ("%srandom", first ? "" : "|"), first = FALSE;
if (mask & ELF_SPARC_HWCAP_TRANS)
- printf ("%strans", first ? "" : "|"), first = 0;
+ printf ("%strans", first ? "" : "|"), first = FALSE;
if (mask & ELF_SPARC_HWCAP_FJFMAU)
- printf ("%sfjfmau", first ? "" : "|"), first = 0;
+ printf ("%sfjfmau", first ? "" : "|"), first = FALSE;
if (mask & ELF_SPARC_HWCAP_IMA)
- printf ("%sima", first ? "" : "|"), first = 0;
+ printf ("%sima", first ? "" : "|"), first = FALSE;
if (mask & ELF_SPARC_HWCAP_ASI_CACHE_SPARING)
- printf ("%scspare", first ? "" : "|"), first = 0;
+ printf ("%scspare", first ? "" : "|"), first = FALSE;
}
else
fputc ('0', stdout);
{
if (mask)
{
- int first = 1;
+ bfd_boolean first = TRUE;
if (mask & ELF_SPARC_HWCAP2_FJATHPLUS)
- fputs ("fjathplus", stdout), first = 0;
+ fputs ("fjathplus", stdout), first = FALSE;
if (mask & ELF_SPARC_HWCAP2_VIS3B)
- printf ("%svis3b", first ? "" : "|"), first = 0;
+ printf ("%svis3b", first ? "" : "|"), first = FALSE;
if (mask & ELF_SPARC_HWCAP2_ADP)
- printf ("%sadp", first ? "" : "|"), first = 0;
+ printf ("%sadp", first ? "" : "|"), first = FALSE;
if (mask & ELF_SPARC_HWCAP2_SPARC5)
- printf ("%ssparc5", first ? "" : "|"), first = 0;
+ printf ("%ssparc5", first ? "" : "|"), first = FALSE;
if (mask & ELF_SPARC_HWCAP2_MWAIT)
- printf ("%smwait", first ? "" : "|"), first = 0;
+ printf ("%smwait", first ? "" : "|"), first = FALSE;
if (mask & ELF_SPARC_HWCAP2_XMPMUL)
- printf ("%sxmpmul", first ? "" : "|"), first = 0;
+ printf ("%sxmpmul", first ? "" : "|"), first = FALSE;
if (mask & ELF_SPARC_HWCAP2_XMONT)
- printf ("%sxmont2", first ? "" : "|"), first = 0;
+ printf ("%sxmont2", first ? "" : "|"), first = FALSE;
if (mask & ELF_SPARC_HWCAP2_NSEC)
- printf ("%snsec", first ? "" : "|"), first = 0;
+ printf ("%snsec", first ? "" : "|"), first = FALSE;
if (mask & ELF_SPARC_HWCAP2_FJATHHPC)
- printf ("%sfjathhpc", first ? "" : "|"), first = 0;
+ printf ("%sfjathhpc", first ? "" : "|"), first = FALSE;
if (mask & ELF_SPARC_HWCAP2_FJDES)
- printf ("%sfjdes", first ? "" : "|"), first = 0;
+ printf ("%sfjdes", first ? "" : "|"), first = FALSE;
if (mask & ELF_SPARC_HWCAP2_FJAES)
- printf ("%sfjaes", first ? "" : "|"), first = 0;
+ printf ("%sfjaes", first ? "" : "|"), first = FALSE;
}
else
fputc ('0', stdout);
unsigned int tag,
const unsigned char * const end)
{
- unsigned int len;
- int val;
+ unsigned int val;
if (tag == Tag_GNU_Sparc_HWCAPS)
{
- val = read_uleb128 (p, &len, end);
- p += len;
+ READ_ULEB (val, p, end);
printf (" Tag_GNU_Sparc_HWCAPS: ");
display_sparc_hwcaps (val);
return p;
}
if (tag == Tag_GNU_Sparc_HWCAPS2)
{
- val = read_uleb128 (p, &len, end);
- p += len;
+ READ_ULEB (val, p, end);
printf (" Tag_GNU_Sparc_HWCAPS2: ");
display_sparc_hwcaps2 (val);
return p;
}
static void
-print_mips_fp_abi_value (int val)
+print_mips_fp_abi_value (unsigned int val)
{
switch (val)
{
{
if (tag == Tag_GNU_MIPS_ABI_FP)
{
- unsigned int len;
- int val;
+ unsigned int val;
- val = read_uleb128 (p, &len, end);
- p += len;
printf (" Tag_GNU_MIPS_ABI_FP: ");
-
+ READ_ULEB (val, p, end);
print_mips_fp_abi_value (val);
-
return p;
}
if (tag == Tag_GNU_MIPS_ABI_MSA)
{
- unsigned int len;
- int val;
+ unsigned int val;
- val = read_uleb128 (p, &len, end);
- p += len;
printf (" Tag_GNU_MIPS_ABI_MSA: ");
+ READ_ULEB (val, p, end);
switch (val)
{
const unsigned char * const end)
{
unsigned int tag;
- unsigned int len;
- int val;
+ unsigned int val;
- tag = read_uleb128 (p, &len, end);
- p += len;
+ READ_ULEB (tag, p, end);
switch (tag)
{
case Tag_ISA:
- val = read_uleb128 (p, &len, end);
- p += len;
printf (" Tag_ISA: ");
+ READ_ULEB (val, p, end);
switch (val)
{
return p;
case Tag_ABI_wchar_t:
- val = read_uleb128 (p, &len, end);
- p += len;
printf (" Tag_ABI_wchar_t: ");
+ READ_ULEB (val, p, end);
switch (val)
{
case 0:
return p;
case Tag_ABI_stack_align_needed:
- val = read_uleb128 (p, &len, end);
- p += len;
printf (" Tag_ABI_stack_align_needed: ");
+ READ_ULEB (val, p, end);
switch (val)
{
case 0:
return p;
case Tag_ABI_stack_align_preserved:
- val = read_uleb128 (p, &len, end);
- p += len;
+ READ_ULEB (val, p, end);
printf (" Tag_ABI_stack_align_preserved: ");
switch (val)
{
return p;
case Tag_ABI_DSBT:
- val = read_uleb128 (p, &len, end);
- p += len;
+ READ_ULEB (val, p, end);
printf (" Tag_ABI_DSBT: ");
switch (val)
{
return p;
case Tag_ABI_PID:
- val = read_uleb128 (p, &len, end);
- p += len;
+ READ_ULEB (val, p, end);
printf (" Tag_ABI_PID: ");
switch (val)
{
return p;
case Tag_ABI_PIC:
- val = read_uleb128 (p, &len, end);
- p += len;
+ READ_ULEB (val, p, end);
printf (" Tag_ABI_PIC: ");
switch (val)
{
return p;
case Tag_ABI_array_object_alignment:
- val = read_uleb128 (p, &len, end);
- p += len;
+ READ_ULEB (val, p, end);
printf (" Tag_ABI_array_object_alignment: ");
switch (val)
{
return p;
case Tag_ABI_array_object_align_expected:
- val = read_uleb128 (p, &len, end);
- p += len;
+ READ_ULEB (val, p, end);
printf (" Tag_ABI_array_object_align_expected: ");
switch (val)
{
case Tag_ABI_compatibility:
{
- val = read_uleb128 (p, &len, end);
- p += len;
+ READ_ULEB (val, p, end);
printf (" Tag_ABI_compatibility: ");
printf (_("flag = %d, vendor = "), val);
if (p < end - 1)
unsigned long addr = 0;
size_t bytes = end - p;
- assert (end > p);
+ assert (end >= p);
while (bytes)
{
int j;
display_msp430x_attribute (unsigned char * p,
const unsigned char * const end)
{
- unsigned int len;
unsigned int val;
unsigned int tag;
- tag = read_uleb128 (p, & len, end);
- p += len;
+ READ_ULEB (tag, p, end);
switch (tag)
{
case OFBA_MSPABI_Tag_ISA:
- val = read_uleb128 (p, &len, end);
- p += len;
printf (" Tag_ISA: ");
+ READ_ULEB (val, p, end);
switch (val)
{
case 0: printf (_("None\n")); break;
break;
case OFBA_MSPABI_Tag_Code_Model:
- val = read_uleb128 (p, &len, end);
- p += len;
printf (" Tag_Code_Model: ");
+ READ_ULEB (val, p, end);
switch (val)
{
case 0: printf (_("None\n")); break;
break;
case OFBA_MSPABI_Tag_Data_Model:
- val = read_uleb128 (p, &len, end);
- p += len;
printf (" Tag_Data_Model: ");
+ READ_ULEB (val, p, end);
switch (val)
{
case 0: printf (_("None\n")); break;
}
else
{
- val = read_uleb128 (p, &len, end);
- p += len;
+ READ_ULEB (val, p, end);
printf ("%d (0x%x)\n", val, val);
}
break;
return p;
}
-static int
-process_attributes (FILE * file,
- const char * public_name,
- unsigned int proc_type,
- unsigned char * (* display_pub_attribute) (unsigned char *, const unsigned char * const),
- unsigned char * (* display_proc_gnu_attribute) (unsigned char *, unsigned int, const unsigned char * const))
+static unsigned char *
+display_msp430_gnu_attribute (unsigned char * p,
+ unsigned int tag,
+ const unsigned char * const end)
+{
+ if (tag == Tag_GNU_MSP430_Data_Region)
+ {
+ unsigned int val;
+
+ printf (" Tag_GNU_MSP430_Data_Region: ");
+ READ_ULEB (val, p, end);
+
+ switch (val)
+ {
+ case Val_GNU_MSP430_Data_Region_Any:
+ printf (_("Any Region\n"));
+ break;
+ case Val_GNU_MSP430_Data_Region_Lower:
+ printf (_("Lower Region Only\n"));
+ break;
+ default:
+ printf ("??? (%u)\n", val);
+ }
+ return p;
+ }
+ return display_tag_value (tag & 1, p, end);
+}
+
+struct riscv_attr_tag_t {
+ const char *name;
+ unsigned int tag;
+};
+
+static struct riscv_attr_tag_t riscv_attr_tag[] =
+{
+#define T(tag) {"Tag_RISCV_" #tag, Tag_RISCV_##tag}
+ T(arch),
+ T(priv_spec),
+ T(priv_spec_minor),
+ T(priv_spec_revision),
+ T(unaligned_access),
+ T(stack_align),
+#undef T
+};
+
+static unsigned char *
+display_riscv_attribute (unsigned char *p,
+ const unsigned char * const end)
+{
+ unsigned int val;
+ unsigned int tag;
+ struct riscv_attr_tag_t *attr = NULL;
+ unsigned i;
+
+ READ_ULEB (tag, p, end);
+
+ /* Find the name of attribute. */
+ for (i = 0; i < ARRAY_SIZE (riscv_attr_tag); i++)
+ {
+ if (riscv_attr_tag[i].tag == tag)
+ {
+ attr = &riscv_attr_tag[i];
+ break;
+ }
+ }
+
+ if (attr)
+ printf (" %s: ", attr->name);
+ else
+ return display_tag_value (tag, p, end);
+
+ switch (tag)
+ {
+ case Tag_RISCV_priv_spec:
+ case Tag_RISCV_priv_spec_minor:
+ case Tag_RISCV_priv_spec_revision:
+ READ_ULEB (val, p, end);
+ printf (_("%u\n"), val);
+ break;
+ case Tag_RISCV_unaligned_access:
+ READ_ULEB (val, p, end);
+ switch (val)
+ {
+ case 0:
+ printf (_("No unaligned access\n"));
+ break;
+ case 1:
+ printf (_("Unaligned access\n"));
+ break;
+ }
+ break;
+ case Tag_RISCV_stack_align:
+ READ_ULEB (val, p, end);
+ printf (_("%u-bytes\n"), val);
+ break;
+ case Tag_RISCV_arch:
+ p = display_tag_value (-1, p, end);
+ break;
+ default:
+ return display_tag_value (tag, p, end);
+ }
+
+ return p;
+}
+
+static bfd_boolean
+process_attributes (Filedata * filedata,
+ const char * public_name,
+ unsigned int proc_type,
+ unsigned char * (* display_pub_attribute) (unsigned char *, const unsigned char * const),
+ unsigned char * (* display_proc_gnu_attribute) (unsigned char *, unsigned int, const unsigned char * const))
{
Elf_Internal_Shdr * sect;
unsigned i;
+ bfd_boolean res = TRUE;
/* Find the section header so that we get the size. */
- for (i = 0, sect = section_headers;
- i < elf_header.e_shnum;
+ for (i = 0, sect = filedata->section_headers;
+ i < filedata->file_header.e_shnum;
i++, sect++)
{
unsigned char * contents;
if (sect->sh_type != proc_type && sect->sh_type != SHT_GNU_ATTRIBUTES)
continue;
- contents = (unsigned char *) get_data (NULL, file, sect->sh_offset, 1,
+ contents = (unsigned char *) get_data (NULL, filedata, sect->sh_offset, 1,
sect->sh_size, _("attributes"));
if (contents == NULL)
- continue;
+ {
+ res = FALSE;
+ continue;
+ }
p = contents;
/* The first character is the version of the attributes.
Currently only version 1, (aka 'A') is recognised here. */
if (*p != 'A')
- printf (_("Unknown attributes version '%c'(%d) - expecting 'A'\n"), *p, *p);
+ {
+ printf (_("Unknown attributes version '%c'(%d) - expecting 'A'\n"), *p, *p);
+ res = FALSE;
+ }
else
{
bfd_vma section_len;
if (section_len <= 4)
{
error (_("Tag section ends prematurely\n"));
+ res = FALSE;
break;
}
attr_len = byte_get (p, 4);
error (_("Bad attribute length (%u > %u)\n"),
(unsigned) attr_len, (unsigned) section_len);
attr_len = section_len;
+ res = FALSE;
}
/* PR 17531: file: 001-101425-0.004 */
else if (attr_len < 5)
{
error (_("Attribute length of %u is too small\n"), (unsigned) attr_len);
+ res = FALSE;
break;
}
if (namelen == 0 || namelen >= attr_len)
{
error (_("Corrupt attribute section name\n"));
+ res = FALSE;
break;
}
while (attr_len > 0 && p < contents + sect->sh_size)
{
int tag;
- int val;
+ unsigned int val;
bfd_vma size;
unsigned char * end;
if (attr_len < 6)
{
error (_("Unused bytes at end of section\n"));
+ res = FALSE;
section_len = 0;
break;
}
{
error (_("Bad subsection length (%u > %u)\n"),
(unsigned) size, (unsigned) attr_len);
+ res = FALSE;
size = attr_len;
}
/* PR binutils/17531: Safe handling of corrupt files. */
{
error (_("Bad subsection length (%u < 6)\n"),
(unsigned) size);
+ res = FALSE;
section_len = 0;
break;
}
do_numlist:
for (;;)
{
- unsigned int j;
-
- val = read_uleb128 (p, &j, end);
- p += j;
+ READ_ULEB (val, p, end);
if (val == 0)
break;
printf (" %d", val);
free (contents);
}
- return 1;
+
+ return res;
}
/* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
fputs ("\n\tMICROMIPS ASE", stdout);
if (mask & AFL_ASE_XPA)
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 & AFL_ASE_LOONGSON_CAM)
+ fputs ("\n\tLoongson CAM ASE", stdout);
+ if (mask & AFL_ASE_LOONGSON_EXT)
+ fputs ("\n\tLoongson EXT ASE", stdout);
+ if (mask & AFL_ASE_LOONGSON_EXT2)
+ fputs ("\n\tLoongson EXT2 ASE", stdout);
if (mask == 0)
fprintf (stdout, "\n\t%s", _("None"));
else if ((mask & ~AFL_ASE_MASK) != 0)
case AFL_EXT_OCTEONP:
fputs ("Cavium Networks OcteonP", stdout);
break;
- case AFL_EXT_LOONGSON_3A:
- fputs ("Loongson 3A", stdout);
- break;
case AFL_EXT_OCTEON:
fputs ("Cavium Networks Octeon", stdout);
break;
case AFL_EXT_LOONGSON_2F:
fputs ("ST Microelectronics Loongson 2F", stdout);
break;
+ case AFL_EXT_INTERAPTIV_MR2:
+ fputs ("Imagination interAptiv MR2", stdout);
+ break;
default:
fprintf (stdout, "%s (%d)", _("Unknown"), isa_ext);
}
}
-static int
+static signed int
get_mips_reg_size (int reg_size)
{
return (reg_size == AFL_REG_NONE) ? 0
: -1;
}
-static int
-process_mips_specific (FILE * file)
+static bfd_boolean
+process_mips_specific (Filedata * filedata)
{
Elf_Internal_Dyn * entry;
Elf_Internal_Shdr *sect = NULL;
bfd_vma local_gotno = 0;
bfd_vma gotsym = 0;
bfd_vma symtabno = 0;
+ bfd_boolean res = TRUE;
- process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
- display_mips_gnu_attribute);
+ if (! process_attributes (filedata, NULL, SHT_GNU_ATTRIBUTES, NULL,
+ display_mips_gnu_attribute))
+ res = FALSE;
- sect = find_section (".MIPS.abiflags");
+ sect = find_section (filedata, ".MIPS.abiflags");
if (sect != NULL)
{
Elf_Internal_ABIFlags_v0 abiflags_in;
if (sizeof (Elf_External_ABIFlags_v0) != sect->sh_size)
- fputs ("\nCorrupt ABI Flags section.\n", stdout);
+ {
+ error (_("Corrupt MIPS ABI Flags section.\n"));
+ res = FALSE;
+ }
else
{
- abiflags_ext = get_data (NULL, file, sect->sh_offset, 1,
+ abiflags_ext = get_data (NULL, filedata, sect->sh_offset, 1,
sect->sh_size, _("MIPS ABI Flags section"));
if (abiflags_ext)
{
/* We have a lot of special sections. Thanks SGI! */
if (dynamic_section == NULL)
- /* No information available. */
- return 0;
+ {
+ /* No dynamic information available. See if there is static GOT. */
+ sect = find_section (filedata, ".got");
+ if (sect != NULL)
+ {
+ unsigned char *data_end;
+ unsigned char *data;
+ bfd_vma ent, end;
+ int addr_size;
+
+ pltgot = sect->sh_addr;
+
+ ent = pltgot;
+ addr_size = (is_32bit_elf ? 4 : 8);
+ end = pltgot + sect->sh_size;
+
+ data = (unsigned char *) get_data (NULL, filedata, sect->sh_offset,
+ end - pltgot, 1,
+ _("Global Offset Table data"));
+ /* PR 12855: Null data is handled gracefully throughout. */
+ data_end = data + (end - pltgot);
+
+ printf (_("\nStatic GOT:\n"));
+ printf (_(" Canonical gp value: "));
+ print_vma (ent + 0x7ff0, LONG_HEX);
+ printf ("\n\n");
+
+ /* In a dynamic binary GOT[0] is reserved for the dynamic
+ loader to store the lazy resolver pointer, however in
+ a static binary it may well have been omitted and GOT
+ reduced to a table of addresses.
+ PR 21344: Check for the entry being fully available
+ before fetching it. */
+ if (data
+ && data + ent - pltgot + addr_size <= data_end
+ && byte_get (data + ent - pltgot, addr_size) == 0)
+ {
+ printf (_(" Reserved entries:\n"));
+ printf (_(" %*s %10s %*s\n"),
+ addr_size * 2, _("Address"), _("Access"),
+ addr_size * 2, _("Value"));
+ ent = print_mips_got_entry (data, pltgot, ent, data_end);
+ printf ("\n");
+ if (ent == (bfd_vma) -1)
+ goto sgot_print_fail;
+
+ /* Check for the MSB of GOT[1] being set, identifying a
+ GNU object. This entry will be used by some runtime
+ loaders, to store the module pointer. Otherwise this
+ is an ordinary local entry.
+ PR 21344: Check for the entry being fully available
+ before fetching it. */
+ if (data
+ && data + ent - pltgot + addr_size <= data_end
+ && (byte_get (data + ent - pltgot, addr_size)
+ >> (addr_size * 8 - 1)) != 0)
+ {
+ ent = print_mips_got_entry (data, pltgot, ent, data_end);
+ printf ("\n");
+ if (ent == (bfd_vma) -1)
+ goto sgot_print_fail;
+ }
+ printf ("\n");
+ }
+
+ if (data != NULL && ent < end)
+ {
+ printf (_(" Local entries:\n"));
+ printf (" %*s %10s %*s\n",
+ addr_size * 2, _("Address"), _("Access"),
+ addr_size * 2, _("Value"));
+ while (ent < end)
+ {
+ ent = print_mips_got_entry (data, pltgot, ent, data_end);
+ printf ("\n");
+ if (ent == (bfd_vma) -1)
+ goto sgot_print_fail;
+ }
+ printf ("\n");
+ }
+
+ sgot_print_fail:
+ if (data)
+ free (data);
+ }
+ return res;
+ }
for (entry = dynamic_section;
/* PR 17531 file: 012-50589-0.004. */
{
case DT_MIPS_LIBLIST:
liblist_offset
- = offset_from_vma (file, entry->d_un.d_val,
+ = offset_from_vma (filedata, entry->d_un.d_val,
liblistno * sizeof (Elf32_External_Lib));
break;
case DT_MIPS_LIBLISTNO:
liblistno = entry->d_un.d_val;
break;
case DT_MIPS_OPTIONS:
- options_offset = offset_from_vma (file, entry->d_un.d_val, 0);
+ options_offset = offset_from_vma (filedata, entry->d_un.d_val, 0);
break;
case DT_MIPS_CONFLICT:
conflicts_offset
- = offset_from_vma (file, entry->d_un.d_val,
+ = offset_from_vma (filedata, entry->d_un.d_val,
conflictsno * sizeof (Elf32_External_Conflict));
break;
case DT_MIPS_CONFLICTNO:
Elf32_External_Lib * elib;
size_t cnt;
- elib = (Elf32_External_Lib *) get_data (NULL, file, liblist_offset,
+ elib = (Elf32_External_Lib *) get_data (NULL, filedata, liblist_offset,
liblistno,
sizeof (Elf32_External_Lib),
_("liblist section data"));
if (elib)
{
- printf (_("\nSection '.liblist' contains %lu entries:\n"),
+ printf (ngettext ("\nSection '.liblist' contains %lu entry:\n",
+ "\nSection '.liblist' contains %lu entries:\n",
+ (unsigned long) liblistno),
(unsigned long) liblistno);
fputs (_(" Library Time Stamp Checksum Version Flags\n"),
stdout);
free (elib);
}
+ else
+ res = FALSE;
}
if (options_offset != 0)
{
Elf_External_Options * eopt;
- Elf_Internal_Options * iopt;
- Elf_Internal_Options * option;
size_t offset;
int cnt;
- sect = section_headers;
+ sect = filedata->section_headers;
/* Find the section header so that we get the size. */
- sect = find_section_by_type (SHT_MIPS_OPTIONS);
+ sect = find_section_by_type (filedata, SHT_MIPS_OPTIONS);
/* PR 17533 file: 012-277276-0.004. */
if (sect == NULL)
{
error (_("No MIPS_OPTIONS header found\n"));
- return 0;
+ return FALSE;
+ }
+ /* PR 24243 */
+ if (sect->sh_size < sizeof (* eopt))
+ {
+ error (_("The MIPS options section is too small.\n"));
+ return FALSE;
}
- eopt = (Elf_External_Options *) get_data (NULL, file, options_offset, 1,
+ eopt = (Elf_External_Options *) get_data (NULL, filedata, options_offset, 1,
sect->sh_size, _("options"));
if (eopt)
{
+ Elf_Internal_Options * iopt;
+ Elf_Internal_Options * option;
+ Elf_Internal_Options * iopt_end;
+
iopt = (Elf_Internal_Options *)
cmalloc ((sect->sh_size / sizeof (eopt)), sizeof (* iopt));
if (iopt == NULL)
{
error (_("Out of memory allocating space for MIPS options\n"));
- return 0;
+ return FALSE;
}
offset = cnt = 0;
option = iopt;
-
+ iopt_end = iopt + (sect->sh_size / sizeof (eopt));
+
while (offset <= sect->sh_size - sizeof (* eopt))
{
Elf_External_Options * eoption;
|| offset + option->size > sect->sh_size)
{
error (_("Invalid size (%u) for MIPS option\n"), option->size);
- return 0;
+ return FALSE;
}
offset += option->size;
++cnt;
}
- printf (_("\nSection '%s' contains %d entries:\n"),
- printable_section_name (sect), cnt);
+ printf (ngettext ("\nSection '%s' contains %d entry:\n",
+ "\nSection '%s' contains %d entries:\n",
+ cnt),
+ printable_section_name (filedata, sect), cnt);
option = iopt;
offset = 0;
/* This shouldn't happen. */
printf (" NULL %d %lx", option->section, option->info);
break;
+
case ODK_REGINFO:
printf (" REGINFO ");
- if (elf_header.e_machine == EM_MIPS)
+ if (filedata->file_header.e_machine == EM_MIPS)
{
- /* 32bit form. */
Elf32_External_RegInfo * ereg;
Elf32_RegInfo reginfo;
+ /* 32bit form. */
+ if (option + 2 > iopt_end)
+ {
+ printf (_("<corrupt>\n"));
+ error (_("Truncated MIPS REGINFO option\n"));
+ cnt = 0;
+ break;
+ }
+
ereg = (Elf32_External_RegInfo *) (option + 1);
+
reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
Elf64_External_RegInfo * ereg;
Elf64_Internal_RegInfo reginfo;
+ if (option + 2 > iopt_end)
+ {
+ printf (_("<corrupt>\n"));
+ error (_("Truncated MIPS REGINFO option\n"));
+ cnt = 0;
+ break;
+ }
+
ereg = (Elf64_External_RegInfo *) (option + 1);
reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
}
++option;
continue;
+
case ODK_EXCEPTIONS:
fputs (" EXCEPTIONS fpe_min(", stdout);
process_mips_fpe_exception (option->info & OEX_FPU_MIN);
if (option->info & OEX_DISMISS)
fputs (" DISMISS", stdout);
break;
+
case ODK_PAD:
fputs (" PAD ", stdout);
if (option->info & OPAD_PREFIX)
if (option->info & OPAD_SYMBOL)
fputs (" SYMBOL", stdout);
break;
+
case ODK_HWPATCH:
fputs (" HWPATCH ", stdout);
if (option->info & OHW_R4KEOP)
if (option->info & OHW_R5KCVTL)
fputs (" R5KCVTL", stdout);
break;
+
case ODK_FILL:
fputs (" FILL ", stdout);
/* XXX Print content of info word? */
break;
+
case ODK_TAGS:
fputs (" TAGS ", stdout);
/* XXX Print content of info word? */
break;
+
case ODK_HWAND:
fputs (" HWAND ", stdout);
if (option->info & OHWA0_R4KEOP_CHECKED)
if (option->info & OHWA0_R4KEOP_CLEAN)
fputs (" R4KEOP_CLEAN", stdout);
break;
+
case ODK_HWOR:
fputs (" HWOR ", stdout);
if (option->info & OHWA0_R4KEOP_CHECKED)
if (option->info & OHWA0_R4KEOP_CLEAN)
fputs (" R4KEOP_CLEAN", stdout);
break;
+
case ODK_GP_GROUP:
printf (" GP_GROUP %#06lx self-contained %#06lx",
option->info & OGP_GROUP,
(option->info & OGP_SELF) >> 16);
break;
+
case ODK_IDENT:
printf (" IDENT %#06lx self-contained %#06lx",
option->info & OGP_GROUP,
(option->info & OGP_SELF) >> 16);
break;
+
default:
/* This shouldn't happen. */
printf (" %3d ??? %d %lx",
free (eopt);
}
+ else
+ res = FALSE;
}
if (conflicts_offset != 0 && conflictsno != 0)
if (dynamic_symbols == NULL)
{
error (_("conflict list found without a dynamic symbol table\n"));
- return 0;
+ return FALSE;
+ }
+
+ /* PR 21345 - print a slightly more helpful error message
+ if we are sure that the cmalloc will fail. */
+ if (conflictsno * sizeof (* iconf) > filedata->file_size)
+ {
+ error (_("Overlarge number of conflicts detected: %lx\n"),
+ (long) conflictsno);
+ return FALSE;
}
iconf = (Elf32_Conflict *) cmalloc (conflictsno, sizeof (* iconf));
if (iconf == NULL)
{
error (_("Out of memory allocating space for dynamic conflicts\n"));
- return 0;
+ return FALSE;
}
if (is_32bit_elf)
Elf32_External_Conflict * econf32;
econf32 = (Elf32_External_Conflict *)
- get_data (NULL, file, conflicts_offset, conflictsno,
+ get_data (NULL, filedata, conflicts_offset, conflictsno,
sizeof (* econf32), _("conflict"));
if (!econf32)
- return 0;
+ return FALSE;
for (cnt = 0; cnt < conflictsno; ++cnt)
iconf[cnt] = BYTE_GET (econf32[cnt]);
Elf64_External_Conflict * econf64;
econf64 = (Elf64_External_Conflict *)
- get_data (NULL, file, conflicts_offset, conflictsno,
+ get_data (NULL, filedata, conflicts_offset, conflictsno,
sizeof (* econf64), _("conflict"));
if (!econf64)
- return 0;
+ return FALSE;
for (cnt = 0; cnt < conflictsno; ++cnt)
iconf[cnt] = BYTE_GET (econf64[cnt]);
free (econf64);
}
- printf (_("\nSection '.conflict' contains %lu entries:\n"),
+ printf (ngettext ("\nSection '.conflict' contains %lu entry:\n",
+ "\nSection '.conflict' contains %lu entries:\n",
+ (unsigned long) conflictsno),
(unsigned long) conflictsno);
puts (_(" Num: Index Value Name"));
{
error (_("The GOT symbol offset (%lu) is greater than the symbol table size (%lu)\n"),
(unsigned long) gotsym, (unsigned long) symtabno);
- return 0;
+ return FALSE;
}
global_end = local_end + (symtabno - gotsym) * addr_size;
if (global_end < local_end)
{
error (_("Too many GOT symbols: %lu\n"), (unsigned long) symtabno);
- return 0;
+ return FALSE;
}
- offset = offset_from_vma (file, pltgot, global_end - pltgot);
- data = (unsigned char *) get_data (NULL, file, offset,
+ offset = offset_from_vma (filedata, pltgot, global_end - pltgot);
+ data = (unsigned char *) get_data (NULL, filedata, offset,
global_end - pltgot, 1,
_("Global Offset Table data"));
- if (data == NULL)
- return 0;
+ /* PR 12855: Null data is handled gracefully throughout. */
data_end = data + (global_end - pltgot);
printf (_("\nPrimary GOT:\n"));
printf (_(" Lazy resolver\n"));
if (ent == (bfd_vma) -1)
goto got_print_fail;
+
+ /* Check for the MSB of GOT[1] being set, denoting a GNU object.
+ This entry will be used by some runtime loaders, to store the
+ module pointer. Otherwise this is an ordinary local entry.
+ PR 21344: Check for the entry being fully available before
+ fetching it. */
if (data
+ && data + ent - pltgot + addr_size <= data_end
&& (byte_get (data + ent - pltgot, addr_size)
>> (addr_size * 8 - 1)) != 0)
{
}
printf ("\n");
- if (ent < local_end)
+ if (data != NULL && ent < local_end)
{
printf (_(" Local entries:\n"));
printf (" %*s %10s %*s\n",
printf ("\n");
}
- if (gotsym < symtabno)
+ if (data != NULL && gotsym < symtabno)
{
int sym_width;
print_vma (psym->st_value, LONG_HEX);
printf (" %-7s %3s ",
- get_symbol_type (ELF_ST_TYPE (psym->st_info)),
- get_symbol_index_type (psym->st_shndx));
+ get_symbol_type (filedata, ELF_ST_TYPE (psym->st_info)),
+ get_symbol_index_type (filedata, psym->st_shndx));
if (VALID_DYNAMIC_NAME (psym->st_name))
print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
int addr_size, sym_width;
Elf_Internal_Rela * rels;
- rel_offset = offset_from_vma (file, jmprel, pltrelsz);
+ rel_offset = offset_from_vma (filedata, jmprel, pltrelsz);
if (pltrel == DT_RELA)
{
- if (!slurp_rela_relocs (file, rel_offset, pltrelsz, &rels, &count))
- return 0;
+ if (!slurp_rela_relocs (filedata, rel_offset, pltrelsz, &rels, &count))
+ return FALSE;
}
else
{
- if (!slurp_rel_relocs (file, rel_offset, pltrelsz, &rels, &count))
- return 0;
+ if (!slurp_rel_relocs (filedata, rel_offset, pltrelsz, &rels, &count))
+ return FALSE;
}
ent = mips_pltgot;
addr_size = (is_32bit_elf ? 4 : 8);
end = mips_pltgot + (2 + count) * addr_size;
- offset = offset_from_vma (file, mips_pltgot, end - mips_pltgot);
- data = (unsigned char *) get_data (NULL, file, offset, end - mips_pltgot,
+ offset = offset_from_vma (filedata, mips_pltgot, end - mips_pltgot);
+ data = (unsigned char *) get_data (NULL, filedata, offset, end - mips_pltgot,
1, _("Procedure Linkage Table data"));
if (data == NULL)
- return 0;
+ return FALSE;
printf ("\nPLT GOT:\n\n");
printf (_(" Reserved entries:\n"));
print_vma (psym->st_value, LONG_HEX);
printf (" %-7s %3s ",
- get_symbol_type (ELF_ST_TYPE (psym->st_info)),
- get_symbol_index_type (psym->st_shndx));
+ get_symbol_type (filedata, ELF_ST_TYPE (psym->st_info)),
+ get_symbol_index_type (filedata, psym->st_shndx));
if (VALID_DYNAMIC_NAME (psym->st_name))
print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
else
free (rels);
}
- return 1;
+ return res;
}
-static int
-process_nds32_specific (FILE * file)
+static bfd_boolean
+process_nds32_specific (Filedata * filedata)
{
Elf_Internal_Shdr *sect = NULL;
- sect = find_section (".nds32_e_flags");
+ sect = find_section (filedata, ".nds32_e_flags");
if (sect != NULL)
{
unsigned int *flag;
printf ("\nNDS32 elf flags section:\n");
- flag = get_data (NULL, file, sect->sh_offset, 1,
+ flag = get_data (NULL, filedata, sect->sh_offset, 1,
sect->sh_size, _("NDS32 elf flags section"));
+ if (! flag)
+ return FALSE;
+
switch ((*flag) & 0x3)
{
case 0:
return TRUE;
}
-static int
-process_gnu_liblist (FILE * file)
+static bfd_boolean
+process_gnu_liblist (Filedata * filedata)
{
Elf_Internal_Shdr * section;
Elf_Internal_Shdr * string_sec;
char * strtab;
size_t strtab_size;
size_t cnt;
+ unsigned long num_liblist;
unsigned i;
+ bfd_boolean res = TRUE;
if (! do_arch)
- return 0;
+ return TRUE;
- for (i = 0, section = section_headers;
- i < elf_header.e_shnum;
+ for (i = 0, section = filedata->section_headers;
+ i < filedata->file_header.e_shnum;
i++, section++)
{
switch (section->sh_type)
{
case SHT_GNU_LIBLIST:
- if (section->sh_link >= elf_header.e_shnum)
+ if (section->sh_link >= filedata->file_header.e_shnum)
break;
elib = (Elf32_External_Lib *)
- get_data (NULL, file, section->sh_offset, 1, section->sh_size,
+ get_data (NULL, filedata, section->sh_offset, 1, section->sh_size,
_("liblist section data"));
if (elib == NULL)
- break;
- string_sec = section_headers + section->sh_link;
+ {
+ res = FALSE;
+ break;
+ }
- strtab = (char *) get_data (NULL, file, string_sec->sh_offset, 1,
+ string_sec = filedata->section_headers + section->sh_link;
+ strtab = (char *) get_data (NULL, filedata, string_sec->sh_offset, 1,
string_sec->sh_size,
_("liblist string table"));
if (strtab == NULL
{
free (elib);
free (strtab);
+ res = FALSE;
break;
}
strtab_size = string_sec->sh_size;
- printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
- printable_section_name (section),
- (unsigned long) (section->sh_size / sizeof (Elf32_External_Lib)));
+ num_liblist = section->sh_size / sizeof (Elf32_External_Lib);
+ printf (ngettext ("\nLibrary list section '%s' contains %lu entries:\n",
+ "\nLibrary list section '%s' contains %lu entries:\n",
+ num_liblist),
+ printable_section_name (filedata, section),
+ num_liblist);
puts (_(" Library Time Stamp Checksum Version Flags"));
}
}
- return 1;
+ return res;
}
static const char *
-get_note_type (unsigned e_type)
+get_note_type (Filedata * filedata, unsigned e_type)
{
static char buff[64];
- if (elf_header.e_type == ET_CORE)
+ if (filedata->file_header.e_type == ET_CORE)
switch (e_type)
{
case NT_AUXV:
return _("NT_PPC_VMX (ppc Altivec registers)");
case NT_PPC_VSX:
return _("NT_PPC_VSX (ppc VSX registers)");
+ case NT_PPC_TAR:
+ return _("NT_PPC_TAR (ppc TAR register)");
+ case NT_PPC_PPR:
+ return _("NT_PPC_PPR (ppc PPR register)");
+ case NT_PPC_DSCR:
+ return _("NT_PPC_DSCR (ppc DSCR register)");
+ case NT_PPC_EBB:
+ return _("NT_PPC_EBB (ppc EBB registers)");
+ case NT_PPC_PMU:
+ return _("NT_PPC_PMU (ppc PMU registers)");
+ case NT_PPC_TM_CGPR:
+ return _("NT_PPC_TM_CGPR (ppc checkpointed GPR registers)");
+ case NT_PPC_TM_CFPR:
+ return _("NT_PPC_TM_CFPR (ppc checkpointed floating point registers)");
+ case NT_PPC_TM_CVMX:
+ return _("NT_PPC_TM_CVMX (ppc checkpointed Altivec registers)");
+ case NT_PPC_TM_CVSX:
+ 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:
+ return _("NT_PPC_TM_CTAR (ppc checkpointed TAR register)");
+ case NT_PPC_TM_CPPR:
+ return _("NT_PPC_TM_CPPR (ppc checkpointed PPR register)");
+ case NT_PPC_TM_CDSCR:
+ return _("NT_PPC_TM_CDSCR (ppc checkpointed DSCR register)");
case NT_386_TLS:
return _("NT_386_TLS (x86 TLS information)");
case NT_386_IOPERM:
return _("NT_S390_VXRS_LOW (s390 vector registers 0-15 upper half)");
case NT_S390_VXRS_HIGH:
return _("NT_S390_VXRS_HIGH (s390 vector registers 16-31)");
+ case NT_S390_GS_CB:
+ return _("NT_S390_GS_CB (s390 guarded-storage registers)");
+ case NT_S390_GS_BC:
+ return _("NT_S390_GS_BC (s390 guarded-storage broadcast control)");
case NT_ARM_VFP:
return _("NT_ARM_VFP (arm VFP registers)");
case NT_ARM_TLS:
return _("NT_VERSION (version)");
case NT_ARCH:
return _("NT_ARCH (architecture)");
+ case NT_GNU_BUILD_ATTRIBUTE_OPEN:
+ return _("OPEN");
+ case NT_GNU_BUILD_ATTRIBUTE_FUNC:
+ return _("func");
default:
break;
}
return buff;
}
-static int
+static bfd_boolean
print_core_note (Elf_Internal_Note *pnote)
{
unsigned int addr_size = is_32bit_elf ? 4 : 8;
unsigned char *descdata, *filenames, *descend;
if (pnote->type != NT_FILE)
- return 1;
+ {
+ if (do_wide)
+ printf ("\n");
+ return TRUE;
+ }
#ifndef BFD64
if (!is_32bit_elf)
{
printf (_(" Cannot decode 64-bit note in 32-bit build\n"));
/* Still "successful". */
- return 1;
+ return TRUE;
}
#endif
if (pnote->descsz < 2 * addr_size)
{
- printf (_(" Malformed note - too short for header\n"));
- return 0;
+ error (_(" Malformed note - too short for header\n"));
+ return FALSE;
}
descdata = (unsigned char *) pnote->descdata;
if (descdata[pnote->descsz - 1] != '\0')
{
- printf (_(" Malformed note - does not end with \\0\n"));
- return 0;
+ error (_(" Malformed note - does not end with \\0\n"));
+ return FALSE;
}
count = byte_get (descdata, addr_size);
page_size = byte_get (descdata, addr_size);
descdata += addr_size;
- if (pnote->descsz < 2 * addr_size + count * 3 * addr_size)
+ if (count > ((bfd_vma) -1 - 2 * addr_size) / (3 * addr_size)
+ || pnote->descsz < 2 * addr_size + count * 3 * addr_size)
{
- printf (_(" Malformed note - too short for supplied file count\n"));
- return 0;
+ error (_(" Malformed note - too short for supplied file count\n"));
+ return FALSE;
}
printf (_(" Page size: "));
if (filenames == descend)
{
- printf (_(" Malformed note - filenames end too early\n"));
- return 0;
+ error (_(" Malformed note - filenames end too early\n"));
+ return FALSE;
}
start = byte_get (descdata, addr_size);
filenames += 1 + strlen ((char *) filenames);
}
- return 1;
+ return TRUE;
}
static const char *
return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
case NT_GNU_GOLD_VERSION:
return _("NT_GNU_GOLD_VERSION (gold version)");
+ case NT_GNU_PROPERTY_TYPE_0:
+ return _("NT_GNU_PROPERTY_TYPE_0");
+ case NT_GNU_BUILD_ATTRIBUTE_OPEN:
+ return _("NT_GNU_BUILD_ATTRIBUTE_OPEN");
+ case NT_GNU_BUILD_ATTRIBUTE_FUNC:
+ return _("NT_GNU_BUILD_ATTRIBUTE_FUNC");
default:
{
static char buff[64];
}
}
-static int
-print_gnu_note (Elf_Internal_Note *pnote)
+static void
+decode_x86_compat_isa (unsigned int bitmask)
{
- /* NB/ Keep this switch statement in sync with get_gnu_elf_note_type (). */
- switch (pnote->type)
+ while (bitmask)
{
- case NT_GNU_BUILD_ID:
- {
- unsigned long i;
+ unsigned int bit = bitmask & (- bitmask);
- printf (_(" Build ID: "));
- for (i = 0; i < pnote->descsz; ++i)
- printf ("%02x", pnote->descdata[i] & 0xff);
- printf ("\n");
- }
- break;
+ 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 (", ");
+ }
+}
- case NT_GNU_ABI_TAG:
- {
- unsigned long os, major, minor, subminor;
- const char *osname;
+static void
+decode_x86_isa (unsigned int bitmask)
+{
+ if (!bitmask)
+ {
+ printf (_("<None>"));
+ return;
+ }
- /* PR 17531: file: 030-599401-0.004. */
- if (pnote->descsz < 16)
- {
- printf (_(" <corrupt GNU_ABI_TAG>\n"));
- break;
- }
+ while (bitmask)
+ {
+ unsigned int bit = bitmask & (- bitmask);
- os = byte_get ((unsigned char *) pnote->descdata, 4);
- major = byte_get ((unsigned char *) pnote->descdata + 4, 4);
- minor = byte_get ((unsigned char *) pnote->descdata + 8, 4);
- subminor = byte_get ((unsigned char *) pnote->descdata + 12, 4);
+ bitmask &= ~ bit;
+ switch (bit)
+ {
+ 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;
+ case GNU_PROPERTY_X86_ISA_1_AVX512_BF16:
+ printf ("AVX512_BF16");
+ break;
+ default:
+ printf (_("<unknown: %x>"), bit);
+ break;
+ }
+ if (bitmask)
+ printf (", ");
+ }
+}
- switch (os)
- {
- case GNU_ABI_TAG_LINUX:
+static void
+decode_x86_feature_1 (unsigned int bitmask)
+{
+ if (!bitmask)
+ {
+ printf (_("<None>"));
+ return;
+ }
+
+ while (bitmask)
+ {
+ unsigned int bit = bitmask & (- bitmask);
+
+ bitmask &= ~ bit;
+ switch (bit)
+ {
+ case GNU_PROPERTY_X86_FEATURE_1_IBT:
+ printf ("IBT");
+ break;
+ case GNU_PROPERTY_X86_FEATURE_1_SHSTK:
+ printf ("SHSTK");
+ break;
+ default:
+ printf (_("<unknown: %x>"), bit);
+ break;
+ }
+ if (bitmask)
+ printf (", ");
+ }
+}
+
+static void
+decode_x86_feature_2 (unsigned int bitmask)
+{
+ if (!bitmask)
+ {
+ printf (_("<None>"));
+ return;
+ }
+
+ 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
+decode_aarch64_feature_1_and (unsigned int bitmask)
+{
+ while (bitmask)
+ {
+ unsigned int bit = bitmask & (- bitmask);
+
+ bitmask &= ~ bit;
+ switch (bit)
+ {
+ case GNU_PROPERTY_AARCH64_FEATURE_1_BTI:
+ printf ("BTI");
+ break;
+
+ case GNU_PROPERTY_AARCH64_FEATURE_1_PAC:
+ printf ("PAC");
+ break;
+
+ default:
+ printf (_("<unknown: %x>"), bit);
+ break;
+ }
+ if (bitmask)
+ printf (", ");
+ }
+}
+
+static void
+print_gnu_property_note (Filedata * filedata, Elf_Internal_Note * pnote)
+{
+ unsigned char * ptr = (unsigned char *) pnote->descdata;
+ unsigned char * ptr_end = ptr + pnote->descsz;
+ unsigned int size = is_32bit_elf ? 4 : 8;
+
+ printf (_(" Properties: "));
+
+ if (pnote->descsz < 8 || (pnote->descsz % size) != 0)
+ {
+ printf (_("<corrupt GNU_PROPERTY_TYPE, size = %#lx>\n"), pnote->descsz);
+ return;
+ }
+
+ while (ptr < ptr_end)
+ {
+ unsigned int j;
+ unsigned int type;
+ unsigned int datasz;
+
+ if ((size_t) (ptr_end - ptr) < 8)
+ {
+ printf (_("<corrupt descsz: %#lx>\n"), pnote->descsz);
+ break;
+ }
+
+ type = byte_get (ptr, 4);
+ datasz = byte_get (ptr + 4, 4);
+
+ ptr += 8;
+
+ if (datasz > (size_t) (ptr_end - ptr))
+ {
+ printf (_("<corrupt type (%#x) datasz: %#x>\n"),
+ type, datasz);
+ break;
+ }
+
+ if (type >= GNU_PROPERTY_LOPROC && type <= GNU_PROPERTY_HIPROC)
+ {
+ if (filedata->file_header.e_machine == EM_X86_64
+ || 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);
+ else
+ bitmask = 0;
+
+ switch (type)
+ {
+ case GNU_PROPERTY_X86_ISA_1_USED:
+ if (datasz != 4)
+ printf (_("x86 ISA used: <corrupt length: %#x> "),
+ datasz);
+ else
+ {
+ printf ("x86 ISA used: ");
+ decode_x86_isa (bitmask);
+ }
+ goto next;
+
+ case GNU_PROPERTY_X86_ISA_1_NEEDED:
+ if (datasz != 4)
+ printf (_("x86 ISA needed: <corrupt length: %#x> "),
+ datasz);
+ else
+ {
+ printf ("x86 ISA needed: ");
+ decode_x86_isa (bitmask);
+ }
+ goto next;
+
+ case GNU_PROPERTY_X86_FEATURE_1_AND:
+ if (datasz != 4)
+ 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
+ {
+ printf ("x86 ISA needed: ");
+ decode_x86_compat_isa (bitmask);
+ }
+ goto next;
+
+ default:
+ break;
+ }
+ }
+ else if (filedata->file_header.e_machine == EM_AARCH64)
+ {
+ if (type == GNU_PROPERTY_AARCH64_FEATURE_1_AND)
+ {
+ printf ("AArch64 feature: ");
+ if (datasz != 4)
+ printf (_("<corrupt length: %#x> "), datasz);
+ else
+ decode_aarch64_feature_1_and (byte_get (ptr, 4));
+ goto next;
+ }
+ }
+ }
+ else
+ {
+ switch (type)
+ {
+ case GNU_PROPERTY_STACK_SIZE:
+ printf (_("stack size: "));
+ if (datasz != size)
+ printf (_("<corrupt length: %#x> "), datasz);
+ else
+ printf ("%#lx", (unsigned long) byte_get (ptr, size));
+ goto next;
+
+ case GNU_PROPERTY_NO_COPY_ON_PROTECTED:
+ printf ("no copy on protected ");
+ if (datasz)
+ printf (_("<corrupt length: %#x> "), datasz);
+ goto next;
+
+ default:
+ break;
+ }
+ }
+
+ if (type < GNU_PROPERTY_LOPROC)
+ printf (_("<unknown type %#x data: "), type);
+ else if (type < GNU_PROPERTY_LOUSER)
+ printf (_("<procesor-specific type %#x data: "), type);
+ else
+ printf (_("<application-specific type %#x data: "), type);
+ for (j = 0; j < datasz; ++j)
+ printf ("%02x ", ptr[j] & 0xff);
+ printf (">");
+
+next:
+ ptr += ((datasz + (size - 1)) & ~ (size - 1));
+ if (ptr == ptr_end)
+ break;
+
+ if (do_wide)
+ printf (", ");
+ else
+ printf ("\n\t");
+ }
+
+ printf ("\n");
+}
+
+static bfd_boolean
+print_gnu_note (Filedata * filedata, Elf_Internal_Note *pnote)
+{
+ /* NB/ Keep this switch statement in sync with get_gnu_elf_note_type (). */
+ switch (pnote->type)
+ {
+ case NT_GNU_BUILD_ID:
+ {
+ unsigned long i;
+
+ printf (_(" Build ID: "));
+ for (i = 0; i < pnote->descsz; ++i)
+ printf ("%02x", pnote->descdata[i] & 0xff);
+ printf ("\n");
+ }
+ break;
+
+ case NT_GNU_ABI_TAG:
+ {
+ unsigned long os, major, minor, subminor;
+ const char *osname;
+
+ /* PR 17531: file: 030-599401-0.004. */
+ if (pnote->descsz < 16)
+ {
+ printf (_(" <corrupt GNU_ABI_TAG>\n"));
+ break;
+ }
+
+ os = byte_get ((unsigned char *) pnote->descdata, 4);
+ major = byte_get ((unsigned char *) pnote->descdata + 4, 4);
+ minor = byte_get ((unsigned char *) pnote->descdata + 8, 4);
+ subminor = byte_get ((unsigned char *) pnote->descdata + 12, 4);
+
+ switch (os)
+ {
+ case GNU_ABI_TAG_LINUX:
osname = "Linux";
break;
case GNU_ABI_TAG_HURD:
printf (_(" Hardware Capabilities: "));
if (pnote->descsz < 8)
{
- printf (_("<corrupt GNU_HWCAP>\n"));
- break;
+ error (_("<corrupt GNU_HWCAP>\n"));
+ return FALSE;
}
num_entries = byte_get ((unsigned char *) pnote->descdata, 4);
mask = byte_get ((unsigned char *) pnote->descdata + 4, 4);
}
break;
+ case NT_GNU_PROPERTY_TYPE_0:
+ print_gnu_property_note (filedata, pnote);
+ break;
+
default:
/* Handle unrecognised types. An error message should have already been
created by get_gnu_elf_note_type(), so all that we need to do is to
break;
}
- return 1;
+ return TRUE;
}
static const char *
}
}
-static int
+static bfd_boolean
print_v850_note (Elf_Internal_Note * pnote)
{
unsigned int val;
if (pnote->descsz != 4)
- return 0;
+ return FALSE;
+
val = byte_get ((unsigned char *) pnote->descdata, pnote->descsz);
if (val == 0)
{
printf (_("not set\n"));
- return 1;
+ return TRUE;
}
switch (pnote->type)
case V850_NOTE_ALIGNMENT:
switch (val)
{
- case EF_RH850_DATA_ALIGN4: printf (_("4-byte\n")); return 1;
- case EF_RH850_DATA_ALIGN8: printf (_("8-byte\n")); return 1;
+ case EF_RH850_DATA_ALIGN4: printf (_("4-byte\n")); return TRUE;
+ case EF_RH850_DATA_ALIGN8: printf (_("8-byte\n")); return TRUE;
}
break;
case V850_NOTE_DATA_SIZE:
switch (val)
{
- case EF_RH850_DOUBLE32: printf (_("4-bytes\n")); return 1;
- case EF_RH850_DOUBLE64: printf (_("8-bytes\n")); return 1;
+ case EF_RH850_DOUBLE32: printf (_("4-bytes\n")); return TRUE;
+ case EF_RH850_DOUBLE64: printf (_("8-bytes\n")); return TRUE;
}
break;
case V850_NOTE_FPU_INFO:
switch (val)
{
- case EF_RH850_FPU20: printf (_("FPU-2.0\n")); return 1;
- case EF_RH850_FPU30: printf (_("FPU-3.0\n")); return 1;
+ case EF_RH850_FPU20: printf (_("FPU-2.0\n")); return TRUE;
+ case EF_RH850_FPU30: printf (_("FPU-3.0\n")); return TRUE;
}
break;
if (val == EF_RH850_SIMD)
{
printf (_("yes\n"));
- return 1;
+ return TRUE;
}
break;
}
printf (_("unknown value: %x\n"), val);
- return 0;
+ return FALSE;
}
-static int
+static bfd_boolean
process_netbsd_elf_note (Elf_Internal_Note * pnote)
{
unsigned int version;
printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u.%u)\n", pnote->descsz,
version, version / 100000000, (version / 1000000) % 100,
(version / 100) % 100);
- return 1;
+ return TRUE;
case NT_NETBSD_MARCH:
- printf (" NetBSD\t0x%08lx\tMARCH <%s>\n", pnote->descsz,
+ printf (" NetBSD\t\t0x%08lx\tMARCH <%s>\n", pnote->descsz,
pnote->descdata);
- return 1;
+ return TRUE;
+
+#ifdef NT_NETBSD_PAX
+ case NT_NETBSD_PAX:
+ version = byte_get ((unsigned char *) pnote->descdata, sizeof (version));
+ printf (" NetBSD\t\t0x%08lx\tPaX <%s%s%s%s%s%s>\n", pnote->descsz,
+ ((version & NT_NETBSD_PAX_MPROTECT) ? "+mprotect" : ""),
+ ((version & NT_NETBSD_PAX_NOMPROTECT) ? "-mprotect" : ""),
+ ((version & NT_NETBSD_PAX_GUARD) ? "+guard" : ""),
+ ((version & NT_NETBSD_PAX_NOGUARD) ? "-guard" : ""),
+ ((version & NT_NETBSD_PAX_ASLR) ? "+ASLR" : ""),
+ ((version & NT_NETBSD_PAX_NOASLR) ? "-ASLR" : ""));
+ return TRUE;
+#endif
default:
- break;
+ printf (" NetBSD\t0x%08lx\tUnknown note type: (0x%08lx)\n", pnote->descsz,
+ pnote->type);
+ return FALSE;
}
-
- printf (" NetBSD\t0x%08lx\tUnknown note type: (0x%08lx)\n", pnote->descsz,
- pnote->type);
- return 1;
}
static const char *
-get_freebsd_elfcore_note_type (unsigned e_type)
+get_freebsd_elfcore_note_type (Filedata * filedata, unsigned e_type)
{
switch (e_type)
{
return _("NT_PROCSTAT_PSSTRINGS (ps_strings data)");
case NT_FREEBSD_PROCSTAT_AUXV:
return _("NT_PROCSTAT_AUXV (auxv data)");
+ case NT_FREEBSD_PTLWPINFO:
+ return _("NT_PTLWPINFO (ptrace_lwpinfo structure)");
}
- return get_note_type (e_type);
+ return get_note_type (filedata, e_type);
}
static const char *
-get_netbsd_elfcore_note_type (unsigned e_type)
+get_netbsd_elfcore_note_type (Filedata * filedata, unsigned e_type)
{
static char buff[64];
- if (e_type == NT_NETBSDCORE_PROCINFO)
+ switch (e_type)
{
+ case NT_NETBSDCORE_PROCINFO:
/* NetBSD core "procinfo" structure. */
return _("NetBSD procinfo structure");
- }
- /* As of Jan 2002 there are no other machine-independent notes
- defined for NetBSD core files. If the note type is less
- than the start of the machine-dependent note types, we don't
- understand it. */
+#ifdef NT_NETBSDCORE_AUXV
+ case NT_NETBSDCORE_AUXV:
+ return _("NetBSD ELF auxiliary vector data");
+#endif
- if (e_type < NT_NETBSDCORE_FIRSTMACH)
- {
- snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
- return buff;
+ default:
+ /* As of Jan 2002 there are no other machine-independent notes
+ defined for NetBSD core files. If the note type is less
+ than the start of the machine-dependent note types, we don't
+ understand it. */
+
+ if (e_type < NT_NETBSDCORE_FIRSTMACH)
+ {
+ snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
+ return buff;
+ }
+ break;
}
- switch (elf_header.e_machine)
+ switch (filedata->file_header.e_machine)
{
/* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
and PT_GETFPREGS == mach+2. */
}
break;
+ /* On SuperH, PT_GETREGS == mach+3 and PT_GETFPREGS == mach+5.
+ There's also old PT___GETREGS40 == mach + 1 for old reg
+ structure which lacks GBR. */
+ case EM_SH:
+ switch (e_type)
+ {
+ case NT_NETBSDCORE_FIRSTMACH + 1:
+ return _("PT___GETREGS40 (old reg structure)");
+ case NT_NETBSDCORE_FIRSTMACH + 3:
+ return _("PT_GETREGS (reg structure)");
+ case NT_NETBSDCORE_FIRSTMACH + 5:
+ return _("PT_GETFPREGS (fpreg structure)");
+ default:
+ break;
+ }
+ break;
+
/* On all other arch's, PT_GETREGS == mach+1 and
PT_GETFPREGS == mach+3. */
default:
return buff;
}
-static int
+static bfd_boolean
print_stapsdt_note (Elf_Internal_Note *pnote)
{
- int addr_size = is_32bit_elf ? 4 : 8;
+ size_t len, maxlen;
+ unsigned long addr_size = is_32bit_elf ? 4 : 8;
char *data = pnote->descdata;
char *data_end = pnote->descdata + pnote->descsz;
bfd_vma pc, base_addr, semaphore;
char *provider, *probe, *arg_fmt;
+ if (pnote->descsz < (addr_size * 3))
+ goto stapdt_note_too_small;
+
pc = byte_get ((unsigned char *) data, addr_size);
data += addr_size;
+
base_addr = byte_get ((unsigned char *) data, addr_size);
data += addr_size;
+
semaphore = byte_get ((unsigned char *) data, addr_size);
data += addr_size;
- provider = data;
- data += strlen (data) + 1;
- probe = data;
- data += strlen (data) + 1;
- arg_fmt = data;
- data += strlen (data) + 1;
+ if (data >= data_end)
+ goto stapdt_note_too_small;
+ maxlen = data_end - data;
+ len = strnlen (data, maxlen);
+ if (len < maxlen)
+ {
+ provider = data;
+ data += len + 1;
+ }
+ else
+ goto stapdt_note_too_small;
+
+ if (data >= data_end)
+ goto stapdt_note_too_small;
+ maxlen = data_end - data;
+ len = strnlen (data, maxlen);
+ if (len < maxlen)
+ {
+ probe = data;
+ data += len + 1;
+ }
+ else
+ goto stapdt_note_too_small;
+
+ if (data >= data_end)
+ goto stapdt_note_too_small;
+ maxlen = data_end - data;
+ len = strnlen (data, maxlen);
+ if (len < maxlen)
+ {
+ arg_fmt = data;
+ data += len + 1;
+ }
+ else
+ goto stapdt_note_too_small;
printf (_(" Provider: %s\n"), provider);
printf (_(" Name: %s\n"), probe);
printf (_(" Arguments: %s\n"), arg_fmt);
return data == data_end;
+
+ stapdt_note_too_small:
+ printf (_(" <corrupt - note is too small>\n"));
+ error (_("corrupt stapdt note - the data size is too small\n"));
+ return FALSE;
}
static const char *
case NT_VMS_PATCHTIME:
return "NT_VMS_PATCHTIME";
default:
- snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
- return buff;
+ snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
+ return buff;
+ }
+}
+
+static bfd_boolean
+print_ia64_vms_note (Elf_Internal_Note * pnote)
+{
+ int maxlen = pnote->descsz;
+
+ if (maxlen < 2 || (unsigned long) maxlen != pnote->descsz)
+ goto desc_size_fail;
+
+ switch (pnote->type)
+ {
+ case NT_VMS_MHD:
+ if (maxlen <= 36)
+ goto desc_size_fail;
+
+ int l = (int) strnlen (pnote->descdata + 34, maxlen - 34);
+
+ printf (_(" Creation date : %.17s\n"), pnote->descdata);
+ printf (_(" Last patch date: %.17s\n"), pnote->descdata + 17);
+ if (l + 34 < maxlen)
+ {
+ printf (_(" Module name : %s\n"), pnote->descdata + 34);
+ if (l + 35 < maxlen)
+ printf (_(" Module version : %s\n"), pnote->descdata + 34 + l + 1);
+ else
+ printf (_(" Module version : <missing>\n"));
+ }
+ else
+ {
+ printf (_(" Module name : <missing>\n"));
+ printf (_(" Module version : <missing>\n"));
+ }
+ break;
+
+ case NT_VMS_LNM:
+ printf (_(" Language: %.*s\n"), maxlen, pnote->descdata);
+ break;
+
+#ifdef BFD64
+ case NT_VMS_FPMODE:
+ printf (_(" Floating Point mode: "));
+ if (maxlen < 8)
+ goto desc_size_fail;
+ /* FIXME: Generate an error if descsz > 8 ? */
+
+ printf ("0x%016" BFD_VMA_FMT "x\n",
+ (bfd_vma) byte_get ((unsigned char *)pnote->descdata, 8));
+ break;
+
+ case NT_VMS_LINKTIME:
+ printf (_(" Link time: "));
+ if (maxlen < 8)
+ goto desc_size_fail;
+ /* FIXME: Generate an error if descsz > 8 ? */
+
+ print_vms_time
+ ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
+ printf ("\n");
+ break;
+
+ case NT_VMS_PATCHTIME:
+ printf (_(" Patch time: "));
+ if (maxlen < 8)
+ goto desc_size_fail;
+ /* FIXME: Generate an error if descsz > 8 ? */
+
+ print_vms_time
+ ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
+ printf ("\n");
+ break;
+
+ case NT_VMS_ORIG_DYN:
+ if (maxlen < 34)
+ goto desc_size_fail;
+
+ printf (_(" Major id: %u, minor id: %u\n"),
+ (unsigned) byte_get ((unsigned char *)pnote->descdata, 4),
+ (unsigned) byte_get ((unsigned char *)pnote->descdata + 4, 4));
+ printf (_(" Last modified : "));
+ print_vms_time
+ ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata + 8, 8));
+ printf (_("\n Link flags : "));
+ printf ("0x%016" BFD_VMA_FMT "x\n",
+ (bfd_vma) byte_get ((unsigned char *)pnote->descdata + 16, 8));
+ printf (_(" Header flags: 0x%08x\n"),
+ (unsigned) byte_get ((unsigned char *)pnote->descdata + 24, 4));
+ printf (_(" Image id : %.*s\n"), maxlen - 32, pnote->descdata + 32);
+ break;
+#endif
+
+ case NT_VMS_IMGNAM:
+ printf (_(" Image name: %.*s\n"), maxlen, pnote->descdata);
+ break;
+
+ case NT_VMS_GSTNAM:
+ printf (_(" Global symbol table name: %.*s\n"), maxlen, pnote->descdata);
+ break;
+
+ case NT_VMS_IMGID:
+ printf (_(" Image id: %.*s\n"), maxlen, pnote->descdata);
+ break;
+
+ case NT_VMS_LINKID:
+ printf (_(" Linker id: %.*s\n"), maxlen, pnote->descdata);
+ break;
+
+ default:
+ return FALSE;
+ }
+
+ return TRUE;
+
+ desc_size_fail:
+ printf (_(" <corrupt - data size is too small>\n"));
+ error (_("corrupt IA64 note: data size is too small\n"));
+ return FALSE;
+}
+
+/* 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 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;
+ static unsigned long strtablen;
+ static Elf_Internal_Sym * symtab;
+ static unsigned long nsyms;
+ Elf_Internal_Sym * saved_sym = NULL;
+ Elf_Internal_Sym * sym;
+
+ if (filedata->section_headers != NULL
+ && (saved_filedata == NULL || filedata != saved_filedata))
+ {
+ Elf_Internal_Shdr * symsec;
+
+ /* Load the symbol and string sections. */
+ for (symsec = filedata->section_headers;
+ symsec < filedata->section_headers + filedata->file_header.e_shnum;
+ symsec ++)
+ {
+ if (symsec->sh_type == SHT_SYMTAB)
+ {
+ symtab = GET_ELF_SYMBOLS (filedata, symsec, & nsyms);
+
+ if (symsec->sh_link < filedata->file_header.e_shnum)
+ {
+ Elf_Internal_Shdr * strtab_sec = filedata->section_headers + symsec->sh_link;
+
+ strtab = (char *) get_data (NULL, filedata, strtab_sec->sh_offset,
+ 1, strtab_sec->sh_size,
+ _("string table"));
+ strtablen = strtab != NULL ? strtab_sec->sh_size : 0;
+ }
+ }
+ }
+ saved_filedata = filedata;
+ }
+
+ if (symtab == NULL || strtab == NULL)
+ return NULL;
+
+ /* Find a symbol whose value matches offset. */
+ for (sym = symtab; sym < symtab + nsyms; sym ++)
+ if (sym->st_value == offset)
+ {
+ if (sym->st_name >= strtablen)
+ /* Huh ? This should not happen. */
+ continue;
+
+ if (strtab[sym->st_name] == 0)
+ continue;
+
+ /* 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
+ and FILE or OBJECT symbols over NOTYPE symbols. We skip
+ FUNC symbols entirely. */
+ switch (ELF_ST_TYPE (sym->st_info))
+ {
+ 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:
+ /* Ignore function symbols. */
+ continue;
+
+ default:
+ break;
+ }
+
+ switch (ELF_ST_BIND (sym->st_info))
+ {
+ case STB_GLOBAL:
+ if (saved_sym == NULL
+ || ELF_ST_TYPE (saved_sym->st_info) != STT_OBJECT)
+ saved_sym = sym;
+ break;
+
+ case STB_LOCAL:
+ if (saved_sym == NULL)
+ saved_sym = sym;
+ break;
+
+ default:
+ break;
+ }
+ }
+ else
+ {
+ if (ELF_ST_TYPE (sym->st_info) != STT_FUNC)
+ continue;
+
+ saved_sym = sym;
+ break;
+ }
+ }
+
+ 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;
+ 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;
+
+ 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)
+ {
+ 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
+ {
+ 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;
+
+ 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;
+ }
+
+ 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)
+ {
+ /* 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 region from %#lx"), start);
+ func_offset = start;
+
+ if (end)
+ {
+ printf (_(" to %#lx"), end);
+ func_end = end;
+ }
+ }
+
+ if (sym && name)
+ printf (_(" (%s)"), name);
+
+ printf ("\n");
+ return TRUE;
+}
+
+static bfd_boolean
+print_gnu_build_attribute_name (Elf_Internal_Note * pnote)
+{
+ static const char string_expected [2] = { GNU_BUILD_ATTRIBUTE_TYPE_STRING, 0 };
+ static const char number_expected [2] = { GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC, 0 };
+ static const char bool_expected [3] = { GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE, GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE, 0 };
+ char name_type;
+ char name_attribute;
+ const char * expected_types;
+ const char * name = pnote->namedata;
+ const char * text;
+ signed int left;
+
+ if (name == NULL || pnote->namesz < 2)
+ {
+ error (_("corrupt name field in GNU build attribute note: size = %ld\n"), pnote->namesz);
+ print_symbol (-20, _(" <corrupt name>"));
+ return FALSE;
+ }
+
+ 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;
+ }
+
+ switch ((name_type = * name))
+ {
+ case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC:
+ case GNU_BUILD_ATTRIBUTE_TYPE_STRING:
+ case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE:
+ case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE:
+ printf ("%c", * name);
+ left --;
+ break;
+ default:
+ error (_("unrecognised attribute type in name field: %d\n"), name_type);
+ print_symbol (-20, _("<unknown name type>"));
+ return FALSE;
}
-}
-static int
-print_ia64_vms_note (Elf_Internal_Note * pnote)
-{
- switch (pnote->type)
+ ++ name;
+ text = NULL;
+
+ switch ((name_attribute = * name))
{
- case NT_VMS_MHD:
- if (pnote->descsz > 36)
- {
- size_t l = strlen (pnote->descdata + 34);
- printf (_(" Creation date : %.17s\n"), pnote->descdata);
- printf (_(" Last patch date: %.17s\n"), pnote->descdata + 17);
- printf (_(" Module name : %s\n"), pnote->descdata + 34);
- printf (_(" Module version : %s\n"), pnote->descdata + 34 + l + 1);
- }
- else
- printf (_(" Invalid size\n"));
+ case GNU_BUILD_ATTRIBUTE_VERSION:
+ text = _("<version>");
+ expected_types = string_expected;
+ ++ name;
break;
- case NT_VMS_LNM:
- printf (_(" Language: %s\n"), pnote->descdata);
+ case GNU_BUILD_ATTRIBUTE_STACK_PROT:
+ text = _("<stack prot>");
+ expected_types = "!+*";
+ ++ name;
break;
-#ifdef BFD64
- case NT_VMS_FPMODE:
- printf (_(" Floating Point mode: "));
- printf ("0x%016" BFD_VMA_FMT "x\n",
- (bfd_vma) byte_get ((unsigned char *)pnote->descdata, 8));
+ case GNU_BUILD_ATTRIBUTE_RELRO:
+ text = _("<relro>");
+ expected_types = bool_expected;
+ ++ name;
break;
- case NT_VMS_LINKTIME:
- printf (_(" Link time: "));
- print_vms_time
- ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
- printf ("\n");
+ case GNU_BUILD_ATTRIBUTE_STACK_SIZE:
+ text = _("<stack size>");
+ expected_types = number_expected;
+ ++ name;
break;
- case NT_VMS_PATCHTIME:
- printf (_(" Patch time: "));
- print_vms_time
- ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
- printf ("\n");
+ case GNU_BUILD_ATTRIBUTE_TOOL:
+ text = _("<tool>");
+ expected_types = string_expected;
+ ++ name;
break;
- case NT_VMS_ORIG_DYN:
- printf (_(" Major id: %u, minor id: %u\n"),
- (unsigned) byte_get ((unsigned char *)pnote->descdata, 4),
- (unsigned) byte_get ((unsigned char *)pnote->descdata + 4, 4));
- printf (_(" Last modified : "));
- print_vms_time
- ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata + 8, 8));
- printf (_("\n Link flags : "));
- printf ("0x%016" BFD_VMA_FMT "x\n",
- (bfd_vma) byte_get ((unsigned char *)pnote->descdata + 16, 8));
- printf (_(" Header flags: 0x%08x\n"),
- (unsigned) byte_get ((unsigned char *)pnote->descdata + 24, 4));
- printf (_(" Image id : %s\n"), pnote->descdata + 32);
+ case GNU_BUILD_ATTRIBUTE_ABI:
+ text = _("<ABI>");
+ expected_types = "$*";
+ ++ name;
break;
-#endif
- case NT_VMS_IMGNAM:
- printf (_(" Image name: %s\n"), pnote->descdata);
+ case GNU_BUILD_ATTRIBUTE_PIC:
+ text = _("<PIC>");
+ expected_types = number_expected;
+ ++ name;
break;
- case NT_VMS_GSTNAM:
- printf (_(" Global symbol table name: %s\n"), pnote->descdata);
+ case GNU_BUILD_ATTRIBUTE_SHORT_ENUM:
+ text = _("<short enum>");
+ expected_types = bool_expected;
+ ++ name;
break;
- case NT_VMS_IMGID:
- printf (_(" Image id: %s\n"), pnote->descdata);
+ default:
+ if (ISPRINT (* name))
+ {
+ int len = strnlen (name, pnote->namesz - (name - pnote->namedata)) + 1;
+
+ if (len > left && ! do_wide)
+ len = left;
+ printf ("%.*s:", len, name);
+ left -= len;
+ name += len;
+ }
+ else
+ {
+ static char tmpbuf [128];
+
+ error (_("unrecognised byte in name field: %d\n"), * name);
+ sprintf (tmpbuf, _("<unknown:_%d>"), * name);
+ text = tmpbuf;
+ name ++;
+ }
+ expected_types = "*$!+";
break;
- case NT_VMS_LINKID:
- printf (_(" Linker id: %s\n"), pnote->descdata);
+ }
+
+ if (text)
+ left -= printf ("%s", text);
+
+ if (strchr (expected_types, name_type) == NULL)
+ warn (_("attribute does not have an expected type (%c)\n"), name_type);
+
+ if ((unsigned long)(name - pnote->namedata) > pnote->namesz)
+ {
+ error (_("corrupt name field: namesz: %lu but parsing gets to %ld\n"),
+ (unsigned long) pnote->namesz,
+ (long) (name - pnote->namedata));
+ return FALSE;
+ }
+
+ if (left < 1 && ! do_wide)
+ return TRUE;
+
+ switch (name_type)
+ {
+ case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC:
+ {
+ unsigned int bytes;
+ unsigned long long val = 0;
+ unsigned int shift = 0;
+ char * decoded = NULL;
+
+ bytes = pnote->namesz - (name - pnote->namedata);
+ if (bytes > 0)
+ /* The -1 is because the name field is always 0 terminated, and we
+ want to be able to ensure that the shift in the while loop below
+ will not overflow. */
+ -- bytes;
+
+ if (bytes > sizeof (val))
+ {
+ error (_("corrupt numeric name field: too many bytes in the value: %x\n"),
+ bytes);
+ bytes = sizeof (val);
+ }
+ /* We do not bother to warn if bytes == 0 as this can
+ happen with some early versions of the gcc plugin. */
+
+ while (bytes --)
+ {
+ unsigned long byte = (* name ++) & 0xff;
+
+ val |= byte << shift;
+ shift += 8;
+ }
+
+ switch (name_attribute)
+ {
+ case GNU_BUILD_ATTRIBUTE_PIC:
+ switch (val)
+ {
+ case 0: decoded = "static"; break;
+ case 1: decoded = "pic"; break;
+ case 2: decoded = "PIC"; break;
+ case 3: decoded = "pie"; break;
+ case 4: decoded = "PIE"; break;
+ default: break;
+ }
+ break;
+ case GNU_BUILD_ATTRIBUTE_STACK_PROT:
+ switch (val)
+ {
+ /* Based upon the SPCT_FLAG_xxx enum values in gcc/cfgexpand.c. */
+ case 0: decoded = "off"; break;
+ case 1: decoded = "on"; break;
+ case 2: decoded = "all"; break;
+ case 3: decoded = "strong"; break;
+ case 4: decoded = "explicit"; break;
+ default: break;
+ }
+ break;
+ default:
+ break;
+ }
+
+ if (decoded != NULL)
+ {
+ print_symbol (-left, decoded);
+ left = 0;
+ }
+ else if (val == 0)
+ {
+ printf ("0x0");
+ left -= 3;
+ }
+ else
+ {
+ if (do_wide)
+ left -= printf ("0x%llx", val);
+ else
+ left -= printf ("0x%-.*llx", left, val);
+ }
+ }
break;
- default:
+ case GNU_BUILD_ATTRIBUTE_TYPE_STRING:
+ left -= print_symbol (- left, name);
+ break;
+ case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE:
+ left -= print_symbol (- left, "true");
+ break;
+ case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE:
+ left -= print_symbol (- left, "false");
break;
}
- return 1;
+
+ if (do_wide && left > 0)
+ printf ("%-*s", left, " ");
+
+ return TRUE;
}
/* Note that by the ELF standard, the name field is already null byte
I.E. the value of namesz for the name "FSF" is 4.
If the value of namesz is zero, there is no name present. */
-static int
-process_note (Elf_Internal_Note * pnote,
- FILE * file ATTRIBUTE_UNUSED,
- Elf_Internal_Shdr * section ATTRIBUTE_UNUSED)
+
+static bfd_boolean
+process_note (Elf_Internal_Note * pnote,
+ Filedata * filedata)
{
const char * name = pnote->namesz ? pnote->namedata : "(NONE)";
const char * nt;
if (pnote->namesz == 0)
/* If there is no note name, then use the default set of
note type strings. */
- nt = get_note_type (pnote->type);
+ nt = get_note_type (filedata, pnote->type);
else if (const_strneq (pnote->namedata, "GNU"))
/* GNU-specific object file notes. */
else if (const_strneq (pnote->namedata, "FreeBSD"))
/* FreeBSD-specific core file notes. */
- nt = get_freebsd_elfcore_note_type (pnote->type);
+ nt = get_freebsd_elfcore_note_type (filedata, pnote->type);
else if (const_strneq (pnote->namedata, "NetBSD-CORE"))
/* NetBSD-specific core file notes. */
- nt = get_netbsd_elfcore_note_type (pnote->type);
+ nt = get_netbsd_elfcore_note_type (filedata, pnote->type);
else if (const_strneq (pnote->namedata, "NetBSD"))
/* NetBSD-specific core file notes. */
return process_netbsd_elf_note (pnote);
+ else if (const_strneq (pnote->namedata, "PaX"))
+ /* NetBSD-specific core file notes. */
+ return process_netbsd_elf_note (pnote);
+
else if (strneq (pnote->namedata, "SPU/", 4))
{
/* SPU-specific core file notes. */
else
/* Don't recognize this note name; just use the default set of
note type strings. */
- nt = get_note_type (pnote->type);
+ nt = get_note_type (filedata, pnote->type);
printf (" ");
- print_symbol (-20, name);
- printf (" 0x%08lx\t%s\n", pnote->descsz, nt);
+
+ if (((const_strneq (pnote->namedata, "GA")
+ && strchr ("*$!+", pnote->namedata[2]) != NULL)
+ || strchr ("*$!+", pnote->namedata[0]) != NULL)
+ && (pnote->type == NT_GNU_BUILD_ATTRIBUTE_OPEN
+ || pnote->type == NT_GNU_BUILD_ATTRIBUTE_FUNC))
+ print_gnu_build_attribute_name (pnote);
+ else
+ print_symbol (-20, name);
+
+ if (do_wide)
+ printf (" 0x%08lx\t%s\t", pnote->descsz, nt);
+ else
+ printf (" 0x%08lx\t%s\n", pnote->descsz, nt);
if (const_strneq (pnote->namedata, "IPF/VMS"))
return print_ia64_vms_note (pnote);
else if (const_strneq (pnote->namedata, "GNU"))
- return print_gnu_note (pnote);
+ return print_gnu_note (filedata, pnote);
else if (const_strneq (pnote->namedata, "stapsdt"))
return print_stapsdt_note (pnote);
else if (const_strneq (pnote->namedata, "CORE"))
return print_core_note (pnote);
+ else if (((const_strneq (pnote->namedata, "GA")
+ && strchr ("*$!+", pnote->namedata[2]) != NULL)
+ || strchr ("*$!+", pnote->namedata[0]) != NULL)
+ && (pnote->type == NT_GNU_BUILD_ATTRIBUTE_OPEN
+ || pnote->type == NT_GNU_BUILD_ATTRIBUTE_FUNC))
+ return print_gnu_build_attribute_description (pnote, filedata);
- else if (pnote->descsz)
+ if (pnote->descsz)
{
unsigned long i;
printf (_(" description data: "));
for (i = 0; i < pnote->descsz; i++)
- printf ("%02x ", pnote->descdata[i]);
- printf ("\n");
+ printf ("%02x ", pnote->descdata[i] & 0xff);
+ if (!do_wide)
+ printf ("\n");
}
- return 1;
+ if (do_wide)
+ printf ("\n");
+
+ return TRUE;
}
-static int
-process_notes_at (FILE * file,
- Elf_Internal_Shdr * section,
- bfd_vma offset,
- bfd_vma length)
+static bfd_boolean
+process_notes_at (Filedata * filedata,
+ Elf_Internal_Shdr * section,
+ bfd_vma offset,
+ bfd_vma length,
+ bfd_vma align)
{
Elf_External_Note * pnotes;
Elf_External_Note * external;
- char * end;
- int res = 1;
+ char * end;
+ bfd_boolean res = TRUE;
if (length <= 0)
- return 0;
+ return FALSE;
if (section)
{
- pnotes = (Elf_External_Note *) get_section_contents (section, file);
+ pnotes = (Elf_External_Note *) get_section_contents (section, filedata);
if (pnotes)
- apply_relocations (file, section, (unsigned char *) pnotes, length, NULL, NULL);
+ {
+ if (! apply_relocations (filedata, section, (unsigned char *) pnotes, length, NULL, NULL))
+ return FALSE;
+ }
}
else
- pnotes = (Elf_External_Note *) get_data (NULL, file, offset, 1, length,
+ pnotes = (Elf_External_Note *) get_data (NULL, filedata, offset, 1, length,
_("notes"));
+
if (pnotes == NULL)
- return 0;
+ return FALSE;
external = pnotes;
if (section)
- printf (_("\nDisplaying notes found in: %s\n"), printable_section_name (section));
+ printf (_("\nDisplaying notes found in: %s\n"), printable_section_name (filedata, section));
else
printf (_("\nDisplaying notes found at file offset 0x%08lx with length 0x%08lx:\n"),
(unsigned long) offset, (unsigned long) length);
- printf (_(" %-20s %10s\tDescription\n"), _("Owner"), _("Data size"));
+ /* 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;
while ((char *) external < end)
{
Elf_Internal_Note inote;
size_t min_notesz;
- char *next;
+ char * next;
char * temp = NULL;
size_t data_remaining = end - (char *) external;
- if (!is_ia64_vms ())
+ if (!is_ia64_vms (filedata))
{
/* PR binutils/15191
Make sure that there is enough data to read. */
min_notesz = offsetof (Elf_External_Note, name);
if (data_remaining < min_notesz)
{
- warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
- (int) data_remaining);
+ warn (ngettext ("Corrupt note: only %ld byte remains, "
+ "not enough for a full note\n",
+ "Corrupt note: only %ld bytes remain, "
+ "not enough for a full note\n",
+ data_remaining),
+ (long) data_remaining);
break;
}
+ data_remaining -= min_notesz;
+
inote.type = BYTE_GET (external->type);
inote.namesz = BYTE_GET (external->namesz);
inote.namedata = external->name;
inote.descsz = BYTE_GET (external->descsz);
- inote.descdata = inote.namedata + align_power (inote.namesz, 2);
- /* PR 17531: file: 3443835e. */
- if (inote.descdata < (char *) pnotes || inote.descdata > end)
- {
- warn (_("Corrupt note: name size is too big: %lx\n"), inote.namesz);
- inote.descdata = inote.namedata;
- inote.namesz = 0;
- }
-
+ inote.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
{
min_notesz = offsetof (Elf64_External_VMS_Note, name);
if (data_remaining < min_notesz)
{
- warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
- (int) data_remaining);
+ warn (ngettext ("Corrupt note: only %ld byte remains, "
+ "not enough for a full note\n",
+ "Corrupt note: only %ld bytes remain, "
+ "not enough for a full note\n",
+ data_remaining),
+ (long) data_remaining);
break;
}
+ data_remaining -= min_notesz;
vms_external = (Elf64_External_VMS_Note *) external;
inote.type = BYTE_GET (vms_external->type);
next = inote.descdata + align_power (inote.descsz, 3);
}
- if (inote.descdata < (char *) external + min_notesz
- || next < (char *) external + min_notesz
- /* PR binutils/17531: file: id:000000,sig:11,src:006986,op:havoc,rep:4. */
- || inote.namedata + inote.namesz < inote.namedata
- || inote.descdata + inote.descsz < inote.descdata
- || data_remaining < (size_t)(next - (char *) external))
+ /* PR 17531: file: 3443835e. */
+ /* PR 17531: file: id:000000,sig:11,src:006986,op:havoc,rep:4. */
+ if ((size_t) (inote.descdata - inote.namedata) < inote.namesz
+ || (size_t) (inote.descdata - inote.namedata) > data_remaining
+ || (size_t) (next - inote.descdata) < inote.descsz
+ || ((size_t) (next - inote.descdata)
+ > data_remaining - (size_t) (inote.descdata - inote.namedata)))
{
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;
}
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
namesz. */
- if (inote.namedata[inote.namesz - 1] != '\0')
+ if (inote.namesz > 0 && inote.namedata[inote.namesz - 1] != '\0')
{
- temp = (char *) malloc (inote.namesz + 1);
- if (temp == NULL)
+ if ((size_t) (inote.descdata - inote.namedata) == inote.namesz)
{
- error (_("Out of memory allocating space for inote name\n"));
- res = 0;
- break;
- }
-
- strncpy (temp, inote.namedata, inote.namesz);
- temp[inote.namesz] = 0;
+ temp = (char *) malloc (inote.namesz + 1);
+ if (temp == NULL)
+ {
+ error (_("Out of memory allocating space for inote name\n"));
+ res = FALSE;
+ break;
+ }
- /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
- inote.namedata = temp;
+ memcpy (temp, inote.namedata, inote.namesz);
+ inote.namedata = temp;
+ }
+ inote.namedata[inote.namesz] = 0;
}
- res &= process_note (& inote, file, section);
+ if (! process_note (& inote, filedata))
+ res = FALSE;
if (temp != NULL)
{
return res;
}
-static int
-process_corefile_note_segments (FILE * file)
+static bfd_boolean
+process_corefile_note_segments (Filedata * filedata)
{
Elf_Internal_Phdr * segment;
unsigned int i;
- int res = 1;
+ bfd_boolean res = TRUE;
- if (! get_program_headers (file))
- return 0;
+ if (! get_program_headers (filedata))
+ return TRUE;
- for (i = 0, segment = program_headers;
- i < elf_header.e_phnum;
+ for (i = 0, segment = filedata->program_headers;
+ i < filedata->file_header.e_phnum;
i++, segment++)
{
if (segment->p_type == PT_NOTE)
- res &= process_notes_at (file, NULL,
- (bfd_vma) segment->p_offset,
- (bfd_vma) segment->p_filesz);
+ if (! process_notes_at (filedata, NULL,
+ (bfd_vma) segment->p_offset,
+ (bfd_vma) segment->p_filesz,
+ (bfd_vma) segment->p_align))
+ res = FALSE;
}
return res;
}
-static int
-process_v850_notes (FILE * file, bfd_vma offset, bfd_vma length)
+static bfd_boolean
+process_v850_notes (Filedata * filedata, bfd_vma offset, bfd_vma length)
{
Elf_External_Note * pnotes;
Elf_External_Note * external;
char * end;
- int res = 1;
+ bfd_boolean res = TRUE;
if (length <= 0)
- return 0;
+ return FALSE;
- pnotes = (Elf_External_Note *) get_data (NULL, file, offset, 1, length,
+ pnotes = (Elf_External_Note *) get_data (NULL, filedata, offset, 1, length,
_("v850 notes"));
if (pnotes == NULL)
- return 0;
+ return FALSE;
external = pnotes;
end = (char*) pnotes + length;
if (! print_v850_note (& inote))
{
- res = 0;
+ res = FALSE;
printf ("<corrupt sizes: namesz: %lx, descsz: %lx>\n",
inote.namesz, inote.descsz);
}
return res;
}
-static int
-process_note_sections (FILE * file)
+static bfd_boolean
+process_note_sections (Filedata * filedata)
{
Elf_Internal_Shdr * section;
unsigned long i;
- int n = 0;
- int res = 1;
+ unsigned int n = 0;
+ bfd_boolean res = TRUE;
- for (i = 0, section = section_headers;
- i < elf_header.e_shnum && section != NULL;
+ for (i = 0, section = filedata->section_headers;
+ i < filedata->file_header.e_shnum && section != NULL;
i++, section++)
{
if (section->sh_type == SHT_NOTE)
{
- res &= process_notes_at (file, section,
- (bfd_vma) section->sh_offset,
- (bfd_vma) section->sh_size);
+ if (! process_notes_at (filedata, section,
+ (bfd_vma) section->sh_offset,
+ (bfd_vma) section->sh_size,
+ (bfd_vma) section->sh_addralign))
+ res = FALSE;
n++;
}
- if (( elf_header.e_machine == EM_V800
- || elf_header.e_machine == EM_V850
- || elf_header.e_machine == EM_CYGNUS_V850)
+ if (( filedata->file_header.e_machine == EM_V800
+ || filedata->file_header.e_machine == EM_V850
+ || filedata->file_header.e_machine == EM_CYGNUS_V850)
&& section->sh_type == SHT_RENESAS_INFO)
{
- res &= process_v850_notes (file,
- (bfd_vma) section->sh_offset,
- (bfd_vma) section->sh_size);
+ if (! process_v850_notes (filedata,
+ (bfd_vma) section->sh_offset,
+ (bfd_vma) section->sh_size))
+ res = FALSE;
n++;
}
}
if (n == 0)
/* Try processing NOTE segments instead. */
- return process_corefile_note_segments (file);
+ return process_corefile_note_segments (filedata);
return res;
}
-static int
-process_notes (FILE * file)
+static bfd_boolean
+process_notes (Filedata * filedata)
{
/* If we have not been asked to display the notes then do nothing. */
if (! do_notes)
- return 1;
+ return TRUE;
- if (elf_header.e_type != ET_CORE)
- return process_note_sections (file);
+ if (filedata->file_header.e_type != ET_CORE)
+ return process_note_sections (filedata);
/* No program headers means no NOTE segment. */
- if (elf_header.e_phnum > 0)
- return process_corefile_note_segments (file);
+ if (filedata->file_header.e_phnum > 0)
+ return process_corefile_note_segments (filedata);
printf (_("No note segments present in the core file.\n"));
- return 1;
+ return TRUE;
}
static unsigned char *
return display_tag_value (tag, start, end);
}
-static int
-process_arch_specific (FILE * file)
+static bfd_boolean
+process_arch_specific (Filedata * filedata)
{
if (! do_arch)
- return 1;
+ return TRUE;
- switch (elf_header.e_machine)
+ switch (filedata->file_header.e_machine)
{
+ case EM_ARC:
+ case EM_ARC_COMPACT:
+ case EM_ARC_COMPACT2:
+ return process_attributes (filedata, "ARC", SHT_ARC_ATTRIBUTES,
+ display_arc_attribute,
+ display_generic_attribute);
case EM_ARM:
- return process_attributes (file, "aeabi", SHT_ARM_ATTRIBUTES,
+ return process_attributes (filedata, "aeabi", SHT_ARM_ATTRIBUTES,
display_arm_attribute,
display_generic_attribute);
case EM_MIPS:
case EM_MIPS_RS3_LE:
- return process_mips_specific (file);
+ return process_mips_specific (filedata);
case EM_MSP430:
- return process_attributes (file, "mspabi", SHT_MSP430_ATTRIBUTES,
- display_msp430x_attribute,
- display_generic_attribute);
+ return process_attributes (filedata, "mspabi", SHT_MSP430_ATTRIBUTES,
+ display_msp430x_attribute,
+ display_msp430_gnu_attribute);
+
+ case EM_RISCV:
+ return process_attributes (filedata, "riscv", SHT_RISCV_ATTRIBUTES,
+ display_riscv_attribute,
+ display_generic_attribute);
case EM_NDS32:
- return process_nds32_specific (file);
+ return process_nds32_specific (filedata);
case EM_PPC:
case EM_PPC64:
- return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
+ return process_attributes (filedata, NULL, SHT_GNU_ATTRIBUTES, NULL,
display_power_gnu_attribute);
case EM_S390:
case EM_S390_OLD:
- return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
+ return process_attributes (filedata, NULL, SHT_GNU_ATTRIBUTES, NULL,
display_s390_gnu_attribute);
case EM_SPARC:
case EM_SPARC32PLUS:
case EM_SPARCV9:
- return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
+ return process_attributes (filedata, NULL, SHT_GNU_ATTRIBUTES, NULL,
display_sparc_gnu_attribute);
case EM_TI_C6000:
- return process_attributes (file, "c6xabi", SHT_C6000_ATTRIBUTES,
+ return process_attributes (filedata, "c6xabi", SHT_C6000_ATTRIBUTES,
display_tic6x_attribute,
display_generic_attribute);
default:
- return process_attributes (file, "gnu", SHT_GNU_ATTRIBUTES,
+ return process_attributes (filedata, "gnu", SHT_GNU_ATTRIBUTES,
display_public_gnu_attributes,
display_generic_attribute);
}
}
-static int
-get_file_header (FILE * file)
+static bfd_boolean
+get_file_header (Filedata * filedata)
{
/* Read in the identity array. */
- if (fread (elf_header.e_ident, EI_NIDENT, 1, file) != 1)
- return 0;
+ if (fread (filedata->file_header.e_ident, EI_NIDENT, 1, filedata->handle) != 1)
+ return FALSE;
/* Determine how to read the rest of the header. */
- switch (elf_header.e_ident[EI_DATA])
+ switch (filedata->file_header.e_ident[EI_DATA])
{
default:
case ELFDATANONE:
}
/* For now we only support 32 bit and 64 bit ELF files. */
- is_32bit_elf = (elf_header.e_ident[EI_CLASS] != ELFCLASS64);
+ is_32bit_elf = (filedata->file_header.e_ident[EI_CLASS] != ELFCLASS64);
/* Read in the rest of the header. */
if (is_32bit_elf)
{
Elf32_External_Ehdr ehdr32;
- if (fread (ehdr32.e_type, sizeof (ehdr32) - EI_NIDENT, 1, file) != 1)
- return 0;
-
- elf_header.e_type = BYTE_GET (ehdr32.e_type);
- elf_header.e_machine = BYTE_GET (ehdr32.e_machine);
- elf_header.e_version = BYTE_GET (ehdr32.e_version);
- elf_header.e_entry = BYTE_GET (ehdr32.e_entry);
- elf_header.e_phoff = BYTE_GET (ehdr32.e_phoff);
- elf_header.e_shoff = BYTE_GET (ehdr32.e_shoff);
- elf_header.e_flags = BYTE_GET (ehdr32.e_flags);
- elf_header.e_ehsize = BYTE_GET (ehdr32.e_ehsize);
- elf_header.e_phentsize = BYTE_GET (ehdr32.e_phentsize);
- elf_header.e_phnum = BYTE_GET (ehdr32.e_phnum);
- elf_header.e_shentsize = BYTE_GET (ehdr32.e_shentsize);
- elf_header.e_shnum = BYTE_GET (ehdr32.e_shnum);
- elf_header.e_shstrndx = BYTE_GET (ehdr32.e_shstrndx);
+ if (fread (ehdr32.e_type, sizeof (ehdr32) - EI_NIDENT, 1, filedata->handle) != 1)
+ return FALSE;
+
+ filedata->file_header.e_type = BYTE_GET (ehdr32.e_type);
+ filedata->file_header.e_machine = BYTE_GET (ehdr32.e_machine);
+ filedata->file_header.e_version = BYTE_GET (ehdr32.e_version);
+ filedata->file_header.e_entry = BYTE_GET (ehdr32.e_entry);
+ filedata->file_header.e_phoff = BYTE_GET (ehdr32.e_phoff);
+ filedata->file_header.e_shoff = BYTE_GET (ehdr32.e_shoff);
+ filedata->file_header.e_flags = BYTE_GET (ehdr32.e_flags);
+ filedata->file_header.e_ehsize = BYTE_GET (ehdr32.e_ehsize);
+ filedata->file_header.e_phentsize = BYTE_GET (ehdr32.e_phentsize);
+ filedata->file_header.e_phnum = BYTE_GET (ehdr32.e_phnum);
+ filedata->file_header.e_shentsize = BYTE_GET (ehdr32.e_shentsize);
+ filedata->file_header.e_shnum = BYTE_GET (ehdr32.e_shnum);
+ filedata->file_header.e_shstrndx = BYTE_GET (ehdr32.e_shstrndx);
}
else
{
{
error (_("This instance of readelf has been built without support for a\n\
64 bit data type and so it cannot read 64 bit ELF files.\n"));
- return 0;
+ return FALSE;
}
- if (fread (ehdr64.e_type, sizeof (ehdr64) - EI_NIDENT, 1, file) != 1)
- return 0;
+ if (fread (ehdr64.e_type, sizeof (ehdr64) - EI_NIDENT, 1, filedata->handle) != 1)
+ return FALSE;
- elf_header.e_type = BYTE_GET (ehdr64.e_type);
- elf_header.e_machine = BYTE_GET (ehdr64.e_machine);
- elf_header.e_version = BYTE_GET (ehdr64.e_version);
- elf_header.e_entry = BYTE_GET (ehdr64.e_entry);
- elf_header.e_phoff = BYTE_GET (ehdr64.e_phoff);
- elf_header.e_shoff = BYTE_GET (ehdr64.e_shoff);
- elf_header.e_flags = BYTE_GET (ehdr64.e_flags);
- elf_header.e_ehsize = BYTE_GET (ehdr64.e_ehsize);
- elf_header.e_phentsize = BYTE_GET (ehdr64.e_phentsize);
- elf_header.e_phnum = BYTE_GET (ehdr64.e_phnum);
- elf_header.e_shentsize = BYTE_GET (ehdr64.e_shentsize);
- elf_header.e_shnum = BYTE_GET (ehdr64.e_shnum);
- elf_header.e_shstrndx = BYTE_GET (ehdr64.e_shstrndx);
+ filedata->file_header.e_type = BYTE_GET (ehdr64.e_type);
+ filedata->file_header.e_machine = BYTE_GET (ehdr64.e_machine);
+ filedata->file_header.e_version = BYTE_GET (ehdr64.e_version);
+ filedata->file_header.e_entry = BYTE_GET (ehdr64.e_entry);
+ filedata->file_header.e_phoff = BYTE_GET (ehdr64.e_phoff);
+ filedata->file_header.e_shoff = BYTE_GET (ehdr64.e_shoff);
+ filedata->file_header.e_flags = BYTE_GET (ehdr64.e_flags);
+ filedata->file_header.e_ehsize = BYTE_GET (ehdr64.e_ehsize);
+ filedata->file_header.e_phentsize = BYTE_GET (ehdr64.e_phentsize);
+ filedata->file_header.e_phnum = BYTE_GET (ehdr64.e_phnum);
+ filedata->file_header.e_shentsize = BYTE_GET (ehdr64.e_shentsize);
+ filedata->file_header.e_shnum = BYTE_GET (ehdr64.e_shnum);
+ filedata->file_header.e_shstrndx = BYTE_GET (ehdr64.e_shstrndx);
}
- if (elf_header.e_shoff)
+ if (filedata->file_header.e_shoff)
{
/* There may be some extensions in the first section header. Don't
bomb if we can't read it. */
if (is_32bit_elf)
- get_32bit_section_headers (file, TRUE);
+ get_32bit_section_headers (filedata, TRUE);
+ else
+ get_64bit_section_headers (filedata, TRUE);
+ }
+
+ return TRUE;
+}
+
+static void
+close_file (Filedata * filedata)
+{
+ if (filedata)
+ {
+ if (filedata->handle)
+ fclose (filedata->handle);
+ free (filedata);
+ }
+}
+
+void
+close_debug_file (void * data)
+{
+ close_file ((Filedata *) data);
+}
+
+static Filedata *
+open_file (const char * pathname)
+{
+ struct stat statbuf;
+ Filedata * filedata = NULL;
+
+ if (stat (pathname, & statbuf) < 0
+ || ! S_ISREG (statbuf.st_mode))
+ goto fail;
+
+ filedata = calloc (1, sizeof * filedata);
+ if (filedata == NULL)
+ goto fail;
+
+ filedata->handle = fopen (pathname, "rb");
+ if (filedata->handle == NULL)
+ goto fail;
+
+ filedata->file_size = (bfd_size_type) statbuf.st_size;
+ filedata->file_name = pathname;
+
+ if (! get_file_header (filedata))
+ goto fail;
+
+ if (filedata->file_header.e_shoff)
+ {
+ bfd_boolean res;
+
+ /* Read the section headers again, this time for real. */
+ if (is_32bit_elf)
+ res = get_32bit_section_headers (filedata, FALSE);
else
- get_64bit_section_headers (file, TRUE);
+ res = get_64bit_section_headers (filedata, FALSE);
+
+ if (!res)
+ goto fail;
+ }
+
+ return filedata;
+
+ fail:
+ if (filedata)
+ {
+ if (filedata->handle)
+ fclose (filedata->handle);
+ free (filedata);
}
+ return NULL;
+}
- return 1;
+void *
+open_debug_file (const char * pathname)
+{
+ return open_file (pathname);
}
/* Process one ELF object file according to the command line options.
This file may actually be stored in an archive. The file is
- positioned at the start of the ELF object. */
+ positioned at the start of the ELF object. Returns TRUE if no
+ problems were encountered, FALSE otherwise. */
-static int
-process_object (char * file_name, FILE * file)
+static bfd_boolean
+process_object (Filedata * filedata)
{
+ bfd_boolean have_separate_files;
unsigned int i;
+ bfd_boolean res = TRUE;
- if (! get_file_header (file))
+ if (! get_file_header (filedata))
{
- error (_("%s: Failed to read file header\n"), file_name);
- return 1;
+ error (_("%s: Failed to read file header\n"), filedata->file_name);
+ return FALSE;
}
/* Initialise per file variables. */
for (i = ARRAY_SIZE (dynamic_info); i--;)
dynamic_info[i] = 0;
dynamic_info_DT_GNU_HASH = 0;
+ dynamic_info_DT_MIPS_XHASH = 0;
/* Process the file. */
if (show_name)
- printf (_("\nFile: %s\n"), file_name);
+ printf (_("\nFile: %s\n"), filedata->file_name);
/* Initialise the dump_sects array from the cmdline_dump_sects array.
Note we do this even if cmdline_dump_sects is empty because we
must make sure that the dump_sets array is zeroed out before each
object file is processed. */
- if (num_dump_sects > num_cmdline_dump_sects)
- memset (dump_sects, 0, num_dump_sects * sizeof (* dump_sects));
+ if (filedata->num_dump_sects > cmdline.num_dump_sects)
+ memset (filedata->dump_sects, 0, filedata->num_dump_sects * sizeof (* filedata->dump_sects));
- if (num_cmdline_dump_sects > 0)
+ if (cmdline.num_dump_sects > 0)
{
- if (num_dump_sects == 0)
+ if (filedata->num_dump_sects == 0)
/* A sneaky way of allocating the dump_sects array. */
- request_dump_bynumber (num_cmdline_dump_sects, 0);
+ request_dump_bynumber (filedata, cmdline.num_dump_sects, 0);
- assert (num_dump_sects >= num_cmdline_dump_sects);
- memcpy (dump_sects, cmdline_dump_sects,
- num_cmdline_dump_sects * sizeof (* dump_sects));
+ assert (filedata->num_dump_sects >= cmdline.num_dump_sects);
+ memcpy (filedata->dump_sects, cmdline.dump_sects,
+ cmdline.num_dump_sects * sizeof (* filedata->dump_sects));
}
- if (! process_file_header ())
- return 1;
+ if (! process_file_header (filedata))
+ return FALSE;
- if (! process_section_headers (file))
+ if (! process_section_headers (filedata))
{
- /* Without loaded section headers we cannot process lots of
- things. */
- do_unwind = do_version = do_dump = do_arch = 0;
+ /* Without loaded section headers we cannot process lots of things. */
+ do_unwind = do_version = do_dump = do_arch = FALSE;
if (! do_using_dynamic)
- do_syms = do_dyn_syms = do_reloc = 0;
+ do_syms = do_dyn_syms = do_reloc = FALSE;
}
- if (! process_section_groups (file))
- {
- /* Without loaded section groups we cannot process unwind. */
- do_unwind = 0;
- }
+ if (! process_section_groups (filedata))
+ /* Without loaded section groups we cannot process unwind. */
+ do_unwind = FALSE;
- if (process_program_headers (file))
- process_dynamic_section (file);
+ if (process_program_headers (filedata))
+ process_dynamic_section (filedata);
+ else
+ res = FALSE;
- process_relocs (file);
+ if (! process_relocs (filedata))
+ res = FALSE;
- process_unwind (file);
+ if (! process_unwind (filedata))
+ res = FALSE;
- process_symbol_table (file);
+ if (! process_symbol_table (filedata))
+ res = FALSE;
- process_syminfo (file);
+ if (! process_syminfo (filedata))
+ res = FALSE;
- process_version_sections (file);
+ if (! process_version_sections (filedata))
+ res = FALSE;
- process_section_contents (file);
+ if (filedata->file_header.e_shstrndx != SHN_UNDEF)
+ have_separate_files = load_separate_debug_files (filedata, filedata->file_name);
+ else
+ have_separate_files = FALSE;
- process_notes (file);
+ if (! process_section_contents (filedata))
+ res = FALSE;
- process_gnu_liblist (file);
+ if (have_separate_files)
+ {
+ separate_info * d;
- process_arch_specific (file);
+ for (d = first_separate_info; d != NULL; d = d->next)
+ {
+ if (! process_section_headers (d->handle))
+ res = FALSE;
+ else if (! process_section_contents (d->handle))
+ res = FALSE;
+ }
- if (program_headers)
- {
- free (program_headers);
- program_headers = NULL;
+ /* The file handles are closed by the call to free_debug_memory() below. */
}
- if (section_headers)
- {
- free (section_headers);
- section_headers = NULL;
- }
+ if (! process_notes (filedata))
+ res = FALSE;
- if (string_table)
- {
- free (string_table);
- string_table = NULL;
- string_table_length = 0;
- }
+ if (! process_gnu_liblist (filedata))
+ res = FALSE;
+
+ if (! process_arch_specific (filedata))
+ res = FALSE;
+
+ free (filedata->program_headers);
+ filedata->program_headers = NULL;
+
+ free (filedata->section_headers);
+ filedata->section_headers = NULL;
+
+ free (filedata->string_table);
+ filedata->string_table = NULL;
+ filedata->string_table_length = 0;
if (dynamic_strings)
{
free_debug_memory ();
- return 0;
+ return res;
}
/* Process an ELF archive.
- On entry the file is positioned just after the ARMAG string. */
+ On entry the file is positioned just after the ARMAG string.
+ Returns TRUE upon success, FALSE otherwise. */
-static int
-process_archive (char * file_name, FILE * file, bfd_boolean is_thin_archive)
+static bfd_boolean
+process_archive (Filedata * filedata, bfd_boolean is_thin_archive)
{
struct archive_info arch;
struct archive_info nested_arch;
size_t got;
- int ret;
+ bfd_boolean ret = TRUE;
- show_name = 1;
+ show_name = TRUE;
/* The ARCH structure is used to hold information about this archive. */
arch.file_name = NULL;
nested_arch.sym_table = NULL;
nested_arch.longnames = NULL;
- if (setup_archive (&arch, file_name, file, is_thin_archive, do_archive_index) != 0)
+ if (setup_archive (&arch, filedata->file_name, filedata->handle,
+ is_thin_archive, do_archive_index) != 0)
{
- ret = 1;
+ ret = FALSE;
goto out;
}
if (do_archive_index)
{
if (arch.sym_table == NULL)
- error (_("%s: unable to dump the index as none was found\n"), file_name);
+ error (_("%s: unable to dump the index as none was found\n"), filedata->file_name);
else
{
unsigned long i, l;
unsigned long current_pos;
printf (_("Index of archive %s: (%lu entries, 0x%lx bytes in the symbol table)\n"),
- file_name, (unsigned long) arch.index_num, arch.sym_size);
- current_pos = ftell (file);
+ filedata->file_name, (unsigned long) arch.index_num, arch.sym_size);
+
+ current_pos = ftell (filedata->handle);
for (i = l = 0; i < arch.index_num; i++)
{
if (l >= arch.sym_size)
{
error (_("%s: end of the symbol table reached before the end of the index\n"),
- file_name);
+ filedata->file_name);
+ ret = FALSE;
break;
}
/* PR 17531: file: 0b6630b2. */
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;
if (l < arch.sym_size)
- error (_("%s: %ld bytes remain in the symbol table, but without corresponding entries in the index table\n"),
- file_name, arch.sym_size - l);
+ {
+ error (ngettext ("%s: %ld byte remains in the symbol table, "
+ "but without corresponding entries in "
+ "the index table\n",
+ "%s: %ld bytes remain in the symbol table, "
+ "but without corresponding entries in "
+ "the index table\n",
+ arch.sym_size - l),
+ filedata->file_name, arch.sym_size - l);
+ ret = FALSE;
+ }
- if (fseek (file, current_pos, SEEK_SET) != 0)
+ if (fseek (filedata->handle, current_pos, SEEK_SET) != 0)
{
- error (_("%s: failed to seek back to start of object files in the archive\n"), file_name);
- ret = 1;
+ error (_("%s: failed to seek back to start of object files in the archive\n"),
+ filedata->file_name);
+ ret = FALSE;
goto out;
}
}
&& !do_histogram && !do_debugging && !do_arch && !do_notes
&& !do_section_groups && !do_dyn_syms)
{
- ret = 0; /* Archive index only. */
+ ret = TRUE; /* Archive index only. */
goto out;
}
}
- ret = 0;
-
while (1)
{
char * name;
char * qualified_name;
/* Read the next archive header. */
- if (fseek (file, arch.next_arhdr_offset, SEEK_SET) != 0)
+ if (fseek (filedata->handle, arch.next_arhdr_offset, SEEK_SET) != 0)
{
- error (_("%s: failed to seek to next archive header\n"), file_name);
- return 1;
+ error (_("%s: failed to seek to next archive header\n"), arch.file_name);
+ return FALSE;
}
- got = fread (&arch.arhdr, 1, sizeof arch.arhdr, file);
+ got = fread (&arch.arhdr, 1, sizeof arch.arhdr, filedata->handle);
if (got != sizeof arch.arhdr)
{
if (got == 0)
break;
- error (_("%s: failed to read archive header\n"), file_name);
- ret = 1;
+ /* PR 24049 - we cannot use filedata->file_name as this will
+ have already been freed. */
+ error (_("%s: failed to read archive header\n"), arch.file_name);
+
+ ret = FALSE;
break;
}
if (memcmp (arch.arhdr.ar_fmag, ARFMAG, 2) != 0)
{
error (_("%s: did not find a valid archive header\n"), arch.file_name);
- ret = 1;
+ ret = FALSE;
break;
}
name = get_archive_member_name (&arch, &nested_arch);
if (name == NULL)
{
- error (_("%s: bad archive file name\n"), file_name);
- ret = 1;
+ error (_("%s: bad archive file name\n"), arch.file_name);
+ ret = FALSE;
break;
}
namelen = strlen (name);
qualified_name = make_qualified_name (&arch, &nested_arch, name);
if (qualified_name == NULL)
{
- error (_("%s: bad archive file name\n"), file_name);
- ret = 1;
+ error (_("%s: bad archive file name\n"), arch.file_name);
+ ret = FALSE;
break;
}
if (is_thin_archive && arch.nested_member_origin == 0)
{
/* This is a proxy for an external member of a thin archive. */
- FILE * member_file;
- char * member_file_name = adjust_relative_path (file_name, name, namelen);
+ Filedata * member_filedata;
+ char * member_file_name = adjust_relative_path
+ (filedata->file_name, name, namelen);
+
if (member_file_name == NULL)
{
- ret = 1;
+ ret = FALSE;
break;
}
- member_file = fopen (member_file_name, "rb");
- if (member_file == NULL)
+ member_filedata = open_file (member_file_name);
+ if (member_filedata == NULL)
{
error (_("Input file '%s' is not readable.\n"), member_file_name);
free (member_file_name);
- ret = 1;
+ ret = FALSE;
break;
}
archive_file_offset = arch.nested_member_origin;
+ member_filedata->file_name = qualified_name;
- ret |= process_object (qualified_name, member_file);
+ if (! process_object (member_filedata))
+ ret = FALSE;
- fclose (member_file);
+ close_file (member_filedata);
free (member_file_name);
}
else if (is_thin_archive)
{
+ Filedata thin_filedata;
+
+ memset (&thin_filedata, 0, sizeof (thin_filedata));
+
/* PR 15140: Allow for corrupt thin archives. */
if (nested_arch.file == NULL)
{
error (_("%s: contains corrupt thin archive: %s\n"),
- file_name, name);
- ret = 1;
+ qualified_name, name);
+ ret = FALSE;
break;
}
if (fseek (nested_arch.file, archive_file_offset, SEEK_SET) != 0)
{
error (_("%s: failed to seek to archive member.\n"), nested_arch.file_name);
- ret = 1;
+ ret = FALSE;
break;
}
- ret |= process_object (qualified_name, nested_arch.file);
+ thin_filedata.handle = nested_arch.file;
+ thin_filedata.file_name = qualified_name;
+
+ if (! process_object (& thin_filedata))
+ ret = FALSE;
}
else
{
archive_file_offset = arch.next_arhdr_offset;
arch.next_arhdr_offset += archive_file_size;
- ret |= process_object (qualified_name, file);
+ filedata->file_name = qualified_name;
+ if (! process_object (filedata))
+ ret = FALSE;
}
- if (dump_sects != NULL)
+ if (filedata->dump_sects != NULL)
{
- free (dump_sects);
- dump_sects = NULL;
- num_dump_sects = 0;
+ free (filedata->dump_sects);
+ filedata->dump_sects = NULL;
+ filedata->num_dump_sects = 0;
}
free (qualified_name);
return ret;
}
-static int
+static bfd_boolean
process_file (char * file_name)
{
- FILE * file;
+ Filedata * filedata = NULL;
struct stat statbuf;
char armag[SARMAG];
- int ret;
+ bfd_boolean ret = TRUE;
if (stat (file_name, &statbuf) < 0)
{
else
error (_("Could not locate '%s'. System error message: %s\n"),
file_name, strerror (errno));
- return 1;
+ return FALSE;
}
if (! S_ISREG (statbuf.st_mode))
{
error (_("'%s' is not an ordinary file\n"), file_name);
- return 1;
+ return FALSE;
+ }
+
+ filedata = calloc (1, sizeof * filedata);
+ if (filedata == NULL)
+ {
+ error (_("Out of memory allocating file data structure\n"));
+ return FALSE;
}
- file = fopen (file_name, "rb");
- if (file == NULL)
+ filedata->file_name = file_name;
+ filedata->handle = fopen (file_name, "rb");
+ if (filedata->handle == NULL)
{
error (_("Input file '%s' is not readable.\n"), file_name);
- return 1;
+ free (filedata);
+ return FALSE;
}
- if (fread (armag, SARMAG, 1, file) != 1)
+ if (fread (armag, SARMAG, 1, filedata->handle) != 1)
{
error (_("%s: Failed to read file's magic number\n"), file_name);
- fclose (file);
- return 1;
+ fclose (filedata->handle);
+ free (filedata);
+ return FALSE;
}
- current_file_size = (bfd_size_type) statbuf.st_size;
+ filedata->file_size = (bfd_size_type) statbuf.st_size;
if (memcmp (armag, ARMAG, SARMAG) == 0)
- ret = process_archive (file_name, file, FALSE);
+ {
+ if (! process_archive (filedata, FALSE))
+ ret = FALSE;
+ }
else if (memcmp (armag, ARMAGT, SARMAG) == 0)
- ret = process_archive (file_name, file, TRUE);
+ {
+ if ( ! process_archive (filedata, TRUE))
+ ret = FALSE;
+ }
else
{
if (do_archive_index)
error (_("File %s is not an archive so its index cannot be displayed.\n"),
file_name);
- rewind (file);
+ rewind (filedata->handle);
archive_file_size = archive_file_offset = 0;
- ret = process_object (file_name, file);
+
+ if (! process_object (filedata))
+ ret = FALSE;
}
- fclose (file);
+ fclose (filedata->handle);
+ free (filedata);
- current_file_size = 0;
return ret;
}
}
/* Needed by the i386 disassembler. */
+
void
db_task_printsym (unsigned int addr)
{
expandargv (&argc, &argv);
- parse_args (argc, argv);
-
- if (num_dump_sects > 0)
- {
- /* Make a copy of the dump_sects array. */
- cmdline_dump_sects = (dump_type *)
- malloc (num_dump_sects * sizeof (* dump_sects));
- if (cmdline_dump_sects == NULL)
- error (_("Out of memory allocating dump request table.\n"));
- else
- {
- memcpy (cmdline_dump_sects, dump_sects,
- num_dump_sects * sizeof (* dump_sects));
- num_cmdline_dump_sects = num_dump_sects;
- }
- }
+ cmdline.file_name = "<cmdline>";
+ parse_args (& cmdline, argc, argv);
if (optind < (argc - 1))
- show_name = 1;
+ show_name = TRUE;
else if (optind >= argc)
{
warn (_("Nothing to do.\n"));
usage (stderr);
}
- err = 0;
+ err = FALSE;
while (optind < argc)
- err |= process_file (argv[optind++]);
+ if (! process_file (argv[optind++]))
+ err = TRUE;
+
+ if (cmdline.dump_sects != NULL)
+ free (cmdline.dump_sects);
- if (dump_sects != NULL)
- free (dump_sects);
- if (cmdline_dump_sects != NULL)
- free (cmdline_dump_sects);
+ free (dump_ctf_symtab_name);
+ free (dump_ctf_strtab_name);
+ free (dump_ctf_parent_name);
- return err;
+ return err ? EXIT_FAILURE : EXIT_SUCCESS;
}