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_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;
struct group_list
{
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
+ (FILE *, bfd_boolean, const char *, unsigned long, unsigned,
+ Elf_Internal_Sym *, enum versioned_symbol_info *, unsigned short *);
#define UNKNOWN -1
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)
{
return find_section (name);
}
-/* Read an unsigned LEB128 encoded value from p. Set *PLEN to the number of
- bytes read. */
+/* Read an unsigned LEB128 encoded value from DATA.
+ Set *LENGTH_RETURN to the number of bytes read. */
static inline unsigned long
-read_uleb128 (unsigned char *data,
- unsigned int *length_return,
+read_uleb128 (unsigned char * data,
+ unsigned int * length_return,
const unsigned char * const end)
{
return read_leb128 (data, length_return, FALSE, end);
}
-/* 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
+static inline bfd_boolean
is_ia64_vms (void)
{
return elf_header.e_machine == EM_IA_64
/* 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)
}
}
-static int
+/* Load RELA type relocations from FILE 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 (FILE * file,
unsigned long rel_offset,
unsigned long rel_size,
erelas = (Elf32_External_Rela *) get_data (NULL, file, 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++)
erelas = (Elf64_External_Rela *) get_data (NULL, file, 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++)
free (erelas);
}
+
*relasp = relas;
*nrelasp = nrelas;
- return 1;
+ return TRUE;
}
-static int
+/* Load REL type relocations from FILE 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 (FILE * file,
unsigned long rel_offset,
unsigned long rel_size,
erels = (Elf32_External_Rel *) get_data (NULL, file, 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++)
erels = (Elf64_External_Rel *) get_data (NULL, file, 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++)
free (erels);
}
+
*relsp = rels;
*nrelsp = nrels;
- return 1;
+ return TRUE;
}
/* Returns the reloc type extracted from the reloc info field. */
/* Display the contents of the relocation data found at the specified
offset. */
-static void
+static bfd_boolean
dump_relocations (FILE * file,
unsigned long rel_offset,
unsigned long rel_size,
char * strtab,
unsigned long strtablen,
int is_rela,
- int is_dynsym)
+ 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);
if (is_rela)
{
if (!slurp_rela_relocs (file, rel_offset, rel_size, &rels, &rel_size))
- return;
+ return FALSE;
}
else
{
if (!slurp_rel_relocs (file, rel_offset, rel_size, &rels, &rel_size))
- return;
+ return FALSE;
}
if (is_32bit_elf)
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;
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);
}
free (rels);
+
+ return res;
}
static const char *
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;
}
}
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))
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;
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");
}
{
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 *
{
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 *
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_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;
}
-
- return NULL;
}
static const char *
case 0x6ffffffc: return "PT_SUNWDTRACE";
case 0x6ffffffd: return "PT_SUNWCAP";
case 0x6fffffff: return "PT_HISUNW";
- default: return NULL;
+ default: return NULL;
}
}
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 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 *
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;
}
}
{
switch (sh_type)
{
- case SHT_V850_SCOMMON: return "V850 Small Common";
- case SHT_V850_TCOMMON: return "V850 Tiny Common";
- case SHT_V850_ZCOMMON: return "V850 Zero Common";
- case SHT_RENESAS_IOP: return "RENESAS IOP";
- case SHT_RENESAS_INFO: return "RENESAS INFO";
- default: return NULL;
+ 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;
}
}
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 (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_DYN_SYMS:
- do_dyn_syms++;
+ do_dyn_syms = TRUE;
break;
#ifdef SUPPORT_DISASSEMBLY
case 'i':
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'. */
-static int
+static bfd_boolean
process_file_header (void)
{
if ( elf_header.e_ident[EI_MAG0] != ELFMAG0
{
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);
if (do_header)
{
- int i;
+ unsigned i;
printf (_("ELF Header:\n"));
printf (_(" Magic: "));
section_headers = NULL;
}
- return 1;
+ return TRUE;
}
static bfd_boolean
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
+static bfd_boolean
get_program_headers (FILE * file)
{
Elf_Internal_Phdr * phdrs;
/* Check cache of prior read. */
if (program_headers != NULL)
- return 1;
+ return TRUE;
phdrs = (Elf_Internal_Phdr *) cmalloc (elf_header.e_phnum,
sizeof (Elf_Internal_Phdr));
{
error (_("Out of memory reading %u program headers\n"),
elf_header.e_phnum);
- return 0;
+ return FALSE;
}
if (is_32bit_elf
: get_64bit_program_headers (file, phdrs))
{
program_headers = phdrs;
- return 1;
+ 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
+static bfd_boolean
process_program_headers (FILE * file)
{
Elf_Internal_Phdr * segment;
{
/* 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"));
+ {
+ 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)
}
if (! get_program_headers (file))
- return 0;
+ return TRUE;
if (do_segments)
{
}
}
- return 1;
+ return TRUE;
}
{
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 [] =
{
}
}
-static int
+static bfd_boolean
process_section_headers (FILE * file)
{
Elf_Internal_Shdr * section;
{
/* 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"));
+ {
+ 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)
if (is_32bit_elf)
{
if (! get_32bit_section_headers (file, FALSE))
- return 0;
+ return FALSE;
+ }
+ else
+ {
+ if (! get_64bit_section_headers (file, 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
}
if (! do_sections)
- return 1;
+ return TRUE;
if (elf_header.e_shnum > 1)
printf (_("\nSection Headers:\n"));
printf ("p (processor specific)\n");
}
- return 1;
+ return TRUE;
}
static const char *
return buff;
}
-static int
+static bfd_boolean
process_section_groups (FILE * file)
{
Elf_Internal_Shdr * section;
/* Don't process section groups unless needed. */
if (!do_unwind && !do_section_groups)
- return 1;
+ return TRUE;
if (elf_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)
{
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,
{
error (_("Out of memory reading %u section group headers\n"),
elf_header.e_shnum);
- return 0;
+ return FALSE;
}
/* Scan the sections for the group section. */
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;
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;
}
}
}
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 (FILE * file,
+ 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,
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
+static bfd_boolean
dump_ia64_vms_dynamic_relocs (FILE *file, struct ia64_vms_dynimgrela *imgrela)
{
Elf64_External_VMS_IMAGE_RELA *imrs;
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
+static bfd_boolean
process_ia64_vms_dynamic_relocs (FILE *file)
{
struct ia64_vms_dynfixup fixup;
struct ia64_vms_dynimgrela imgrela;
Elf_Internal_Dyn *entry;
- int res = 0;
bfd_vma strtab_off = 0;
bfd_vma strtab_sz = 0;
char *strtab = NULL;
+ bfd_boolean res = TRUE;
memset (&fixup, 0, sizeof (fixup));
memset (&imgrela, 0, sizeof (imgrela));
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 (file, &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 (file, &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
+static bfd_boolean
process_relocs (FILE * file)
{
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)
{
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 (process_ia64_vms_dynamic_relocs (file))
+ 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;
}
else
dump_relocations (file, rel_offset, rel_size,
- NULL, 0, NULL, 0, is_rela, 0);
+ NULL, 0, NULL, 0, is_rela,
+ FALSE /* is_dynamic */);
- found = 1;
+ found = TRUE;
}
}
printf (_("\nThere are no relocations in this file.\n"));
}
- return 1;
+ return TRUE;
}
/* An absolute address consists of a section and an offset. If the
*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
+static bfd_boolean
dump_ia64_unwind (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++)
{
warn (_("Invalid offset %lx in table entry %ld\n"),
(long) tp->info.offset, (long) (tp - aux->table));
+ res = FALSE;
continue;
}
}
free (aux->funtab);
+
+ return res;
}
static bfd_boolean
return TRUE;
}
-static void
+static bfd_boolean
ia64_process_unwind (FILE * file)
{
Elf_Internal_Shdr * sec;
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));
{
error (_("Multiple auxillary string tables encountered\n"));
free (aux.strtab);
+ res = FALSE;
}
aux.strtab = (char *) get_data (NULL, file, strsec->sh_offset,
1, strsec->sh_size,
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
+static bfd_boolean
dump_hppa_unwind (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++)
printf ("\n");
free (aux->funtab);
+
+ return res;
}
-static int
+static bfd_boolean
slurp_hppa_unwind_table (FILE * file,
struct hppa_unw_aux_info * aux,
Elf_Internal_Shdr * sec)
/* First, find the starting address of the segment that includes
this section. */
-
if (elf_header.e_phnum)
{
if (! get_program_headers (file))
- return 0;
+ return FALSE;
for (seg = program_headers;
seg < program_headers + elf_header.e_phnum;
table = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1, size,
_("unwind table"));
if (!table)
- return 0;
+ return FALSE;
unw_ent_size = 16;
nentries = size / unw_ent_size;
if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
& rela, & nrelas))
- return 0;
+ return FALSE;
for (rp = rela; rp < rela + nrelas; ++rp)
{
aux->table_len = nentries;
- return 1;
+ return TRUE;
}
-static void
+static bfd_boolean
hppa_process_unwind (FILE * file)
{
struct hppa_unw_aux_info aux;
Elf_Internal_Shdr * strsec;
Elf_Internal_Shdr * sec;
unsigned long i;
+ bfd_boolean res = TRUE;
if (string_table == NULL)
- return;
+ return FALSE;
memset (& aux, 0, sizeof (aux));
{
error (_("Multiple auxillary string tables encountered\n"));
free (aux.strtab);
+ res = FALSE;
}
aux.strtab = (char *) get_data (NULL, file, strsec->sh_offset,
1, strsec->sh_size,
(unsigned long) sec->sh_offset,
(unsigned long) (sec->sh_size / (2 * eh_addr_size + 8)));
- slurp_hppa_unwind_table (file, &aux, sec);
+ if (! slurp_hppa_unwind_table (file, &aux, sec))
+ res = FALSE;
+
if (aux.table_len > 0)
- dump_hppa_unwind (&aux);
+ {
+ if (! dump_hppa_unwind (&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
data_offset += 4; \
if (! get_unwind_section_word (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
+static bfd_boolean
decode_arm_unwind_bytecode (struct arm_unw_aux_info * aux,
unsigned int word,
unsigned int remaining,
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);
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
+static bfd_boolean
decode_tic6x_unwind_bytecode (struct arm_unw_aux_info * aux,
unsigned int word,
unsigned int remaining,
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
/* 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);
}
putchar ('\n');
}
+
+ return TRUE;
}
static bfd_vma
return offset + where;
}
-static void
+static bfd_boolean
decode_arm_unwind (struct arm_unw_aux_info * aux,
unsigned int word,
unsigned int remaining,
unsigned int more_words = 0;
struct absaddr addr;
bfd_vma sym_name = (bfd_vma) -1;
+ bfd_boolean res = FALSE;
if (remaining == 0)
{
the personality routine. */
if (! get_unwind_section_word (aux, data_arm_sec, data_sec, data_offset,
& word, & addr, & sym_name))
- return;
+ return FALSE;
remaining = 4;
}
if (!remaining)
{
printf (_(" [Truncated data]\n"));
- return;
+ return FALSE;
}
more_words = word >> 24;
word <<= 8;
per_index = -1;
}
else
- return;
+ return TRUE;
}
else
{
if (elf_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);
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 (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 (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);
+ res = FALSE;
}
/* Decode the descriptors. Not implemented. */
+
+ return res;
}
-static void
+static bfd_boolean
dump_arm_unwind (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));
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);
warn (_("Unwind entry contains corrupt offset (0x%lx) into section %s\n"),
(unsigned long) table_offset,
printable_section_name (table_sec));
+ res = FALSE;
continue;
}
}
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 (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
+static bfd_boolean
arm_process_unwind (FILE *file)
{
struct arm_unw_aux_info aux;
Elf_Internal_Shdr *sec;
unsigned long i;
unsigned int sec_type;
+ bfd_boolean res = TRUE;
switch (elf_header.e_machine)
{
default:
error (_("Unsupported architecture type %d encountered when processing unwind table\n"),
elf_header.e_machine);
- return;
+ return FALSE;
}
if (string_table == NULL)
- return;
+ return FALSE;
memset (& aux, 0, sizeof (aux));
aux.file = file;
{
error (_("Multiple string tables found in file.\n"));
free (aux.strtab);
+ res = FALSE;
}
aux.strtab = get_data (NULL, file, strsec->sh_offset,
1, strsec->sh_size, _("string table"));
(unsigned long) sec->sh_offset,
(unsigned long) (sec->sh_size / (2 * eh_addr_size)));
- dump_arm_unwind (&aux, sec);
+ if (! dump_arm_unwind (&aux, sec))
+ res = FALSE;
}
}
free (aux.symtab);
if (aux.strtab)
free ((char *) aux.strtab);
+
+ return res;
}
-static void
+static bfd_boolean
process_unwind (FILE * file)
{
struct unwind_handler
{
- int machtype;
- void (* handler)(FILE *);
+ unsigned int machtype;
+ bfd_boolean (* handler)(FILE *);
} 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;
- }
+ return handlers[i].handler (file);
printf (_("\nThe decoding of unwind sections for machine type %s is not currently supported.\n"),
get_machine_name (elf_header.e_machine));
+ return TRUE;
}
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;
{ 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
+static bfd_boolean
get_32bit_dynamic_section (FILE * file)
{
Elf32_External_Dyn * edyn;
edyn = (Elf32_External_Dyn *) get_data (NULL, file, 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
+static bfd_boolean
get_64bit_dynamic_section (FILE * file)
{
Elf64_External_Dyn * edyn;
edyn = (Elf64_External_Dyn *) get_data (NULL, file, 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
+static bfd_boolean
process_dynamic_section (FILE * file)
{
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;
+ return FALSE;
+ }
+ else
+ {
+ if (! get_64bit_dynamic_section (file))
+ return FALSE;
}
- else if (! get_64bit_dynamic_section (file))
- return 0;
/* Find the appropriate symbol table. */
if (dynamic_symbols == NULL)
get_data (NULL, file, dynamic_syminfo_offset, 1, syminsz,
_("symbol information"));
if (!extsyminfo)
- return 0;
+ return FALSE;
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);
print_vma (entry->d_tag, FULL_HEX);
dtype = get_dynamic_type (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)
}
}
- return 1;
+ return TRUE;
}
static char *
/* Display the contents of the version sections. */
-static int
+static bfd_boolean
process_version_sections (FILE * file)
{
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;
unsigned int end;
char * endbuf;
- found = 1;
+ found = TRUE;
printf (_("\nVersion definition section '%s' contains %u entries:\n"),
printable_section_name (section),
unsigned int cnt;
char * endbuf;
- found = 1;
+ found = TRUE;
printf (_("\nVersion needs section '%s' contains %u entries:\n"),
printable_section_name (section), section->sh_info);
if (link_section->sh_link >= elf_header.e_shnum)
break;
- found = 1;
+ found = TRUE;
symbols = GET_ELF_SYMBOLS (file, link_section, & num_syms);
if (symbols == NULL)
if (! found)
printf (_("\nNo version information found in this file.\n"));
- return 1;
+ return TRUE;
}
static const char *
{
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;
}
}
}
/* Dump the symbol table. */
-static int
+static bfd_boolean
process_symbol_table (FILE * file)
{
Elf_Internal_Shdr * section;
bfd_size_type ngnuchains = 0;
if (!do_syms && !do_dyn_syms && !do_histogram)
- return 1;
+ return TRUE;
if (dynamic_info[DT_HASH]
&& (do_histogram
if (buckets == NULL || chains == NULL)
{
if (do_using_dynamic)
- return 0;
+ return FALSE;
free (buckets);
free (chains);
buckets = NULL;
if (gnubuckets[i] != 0)
{
if (gnubuckets[i] < gnusymidx)
- return 0;
+ return FALSE;
if (maxchain == 0xffffffff || gnubuckets[i] > maxchain)
maxchain = gnubuckets[i];
gnubuckets = NULL;
ngnubuckets = 0;
if (do_using_dynamic)
- return 0;
+ return FALSE;
}
}
if (lengths == NULL)
{
error (_("Out of memory allocating space for histogram buckets\n"));
- return 0;
+ return FALSE;
}
printf (_(" Length Number %% of total Coverage\n"));
{
free (lengths);
error (_("Out of memory allocating space for histogram counts\n"));
- return 0;
+ return FALSE;
}
for (hn = 0; hn < nbuckets; ++hn)
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 (gnuchains);
}
- return 1;
+ return TRUE;
}
-static int
+static bfd_boolean
process_syminfo (FILE * file 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"),
puts ("");
}
- return 1;
+ return TRUE;
}
#define IN_RANGE(START,END,ADDR,OFF) \
}
/* 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
+static bfd_boolean
apply_relocations (void * file,
const Elf_Internal_Shdr * section,
unsigned char * start,
{
Elf_Internal_Shdr * relsec;
unsigned char * end = start + size;
+ bfd_boolean res = TRUE;
if (relocs_return != NULL)
{
}
if (elf_header.e_type != ET_REL)
- return;
+ /* No relocs to apply. */
+ return TRUE;
/* Find the reloc section associated with the section. */
for (relsec = section_headers;
{
if (!slurp_rela_relocs ((FILE *) file, relsec->sh_offset,
relsec->sh_size, & relocs, & num_relocs))
- return;
+ return FALSE;
}
else
{
if (!slurp_rel_relocs ((FILE *) file, 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. */
symsec = section_headers + relsec->sh_link;
if (symsec->sh_type != SHT_SYMTAB
&& symsec->sh_type != SHT_DYNSYM)
- return;
+ return FALSE;
symtab = GET_ELF_SYMBOLS ((FILE *) file, symsec, & num_syms);
for (rp = relocs; rp < relocs + num_relocs; ++rp)
warn (_("unable to apply unsupported reloc type %d to section %s\n"),
reloc_type, printable_section_name (section));
prev_reloc = reloc_type;
+ res = FALSE;
continue;
}
warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
(unsigned long) rp->r_offset,
printable_section_name (section));
+ res = FALSE;
continue;
}
{
warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
sym_index, printable_section_name (section));
+ res = FALSE;
continue;
}
sym = symtab + sym_index;
get_symbol_type (ELF_ST_TYPE (sym->st_info)),
(long int)(rp - relocs),
printable_section_name (relsec));
+ res = FALSE;
continue;
}
break;
}
+
+ return res;
}
#ifdef SUPPORT_DISASSEMBLY
-static int
+static bfd_boolean
disassemble_section (Elf_Internal_Shdr * section, FILE * file)
{
printf (_("\nAssembly dump of section %s\n"), printable_section_name (section));
/* FIXME: XXX -- to be done --- XXX */
- return 1;
+ return TRUE;
}
#endif
return FALSE;
}
-static void
+static bfd_boolean
dump_section_as_strings (Elf_Internal_Shdr * section, FILE * file)
{
Elf_Internal_Shdr * relsec;
real_start = start = (unsigned char *) get_section_contents (section,
file);
if (start == NULL)
- return;
+ return FALSE;
num_bytes = section->sh_size;
printf (_("\nString dump of section '%s':\n"), printable_section_name (section));
{
warn (_("section '%s' has unsupported compress type: %d\n"),
printable_section_name (section), chdr.ch_type);
- return;
+ return FALSE;
}
else if (chdr.ch_addralign != section->sh_addralign)
{
warn (_("compressed section '%s' is corrupted\n"),
printable_section_name (section));
- return;
+ return FALSE;
}
uncompressed_size = chdr.ch_size;
start += compression_header_size;
{
error (_("Unable to decompress section %s\n"),
printable_section_name (section));
- return;
+ return FALSE;
}
}
else
free (real_start);
putchar ('\n');
+ return TRUE;
}
-static void
+static bfd_boolean
dump_section_as_bytes (Elf_Internal_Shdr * section,
FILE * file,
bfd_boolean relocate)
real_start = start = (unsigned char *) get_section_contents (section, file);
if (start == NULL)
- return;
+ return FALSE;
+
section_size = section->sh_size;
printf (_("\nHex dump of section '%s':\n"), printable_section_name (section));
{
warn (_("section '%s' has unsupported compress type: %d\n"),
printable_section_name (section), chdr.ch_type);
- return;
+ return FALSE;
}
else if (chdr.ch_addralign != section->sh_addralign)
{
warn (_("compressed section '%s' is corrupted\n"),
printable_section_name (section));
- return;
+ return FALSE;
}
uncompressed_size = chdr.ch_size;
start += compression_header_size;
error (_("Unable to decompress section %s\n"),
printable_section_name (section));
/* FIXME: Print the section anyway ? */
- return;
+ return FALSE;
}
}
else
if (relocate)
{
- apply_relocations (file, section, start, section_size, NULL, NULL);
+ if (! apply_relocations (file, section, start, section_size, NULL, NULL))
+ return FALSE;
}
else
{
free (real_start);
putchar ('\n');
+ return TRUE;
}
-static int
+static bfd_boolean
load_specific_debug_section (enum dwarf_section_display_enum debug,
const Elf_Internal_Shdr * sec, void * file)
{
/* If it is already loaded, do nothing. */
if (section->start != NULL)
- return 1;
+ return TRUE;
snprintf (buf, sizeof (buf), _("%s section data"), section->name);
section->address = sec->sh_addr;
{
warn (_("compressed section %s is too small to contain a compression header"),
section->name);
- return 0;
+ return FALSE;
}
compression_header_size = get_compression_header (&chdr, start, size);
{
warn (_("section '%s' has unsupported compress type: %d\n"),
section->name, chdr.ch_type);
- return 0;
+ return FALSE;
}
else if (chdr.ch_addralign != sec->sh_addralign)
{
warn (_("compressed section '%s' is corrupted\n"),
section->name);
- return 0;
+ return FALSE;
}
uncompressed_size = chdr.ch_size;
start += compression_header_size;
{
error (_("Unable to decompress section %s\n"),
printable_section_name (sec));
- return 0;
+ 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 ((FILE *) file, 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
+bfd_boolean
load_debug_section (enum dwarf_section_display_enum debug, void * file)
{
struct dwarf_section * section = &debug_displays [debug].section;
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
section->size = 0;
}
-static int
+static bfd_boolean
display_debug_section (int shndx, Elf_Internal_Shdr * section, FILE * file)
{
char * name = SECTION_NAME (section);
const char * print_name = printable_section_name (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."))
if (i == max)
{
printf (_("Unrecognized debug section: %s\n"), print_name);
- result = 0;
+ result = FALSE;
}
return result;
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++)
+ for (i = 0; i < elf_header.e_shnum; i++)
if (streq (SECTION_NAME (section_headers + i), cur->name))
{
request_dump_bynumber (i, cur->type);
- any = 1;
+ any = TRUE;
}
if (!any)
}
}
-static void
+static bfd_boolean
process_section_contents (FILE * file)
{
Elf_Internal_Shdr * section;
unsigned int i;
+ bfd_boolean res = TRUE;
if (! do_dump)
- return;
+ return TRUE;
initialise_dumps_byname ();
disassemble_section (section, file);
#endif
if (dump_sects[i] & HEX_DUMP)
- dump_section_as_bytes (section, file, FALSE);
+ {
+ if (! dump_section_as_bytes (section, file, FALSE))
+ res = FALSE;
+ }
if (dump_sects[i] & RELOC_DUMP)
- dump_section_as_bytes (section, file, TRUE);
+ {
+ if (! dump_section_as_bytes (section, file, TRUE))
+ res = FALSE;
+ }
if (dump_sects[i] & STRING_DUMP)
- dump_section_as_strings (section, file);
+ {
+ if (! dump_section_as_strings (section, file))
+ res = FALSE;
+ }
if (dump_sects[i] & DEBUG_DUMP)
- display_debug_section (i, section, file);
+ {
+ if (! display_debug_section (i, section, file))
+ res = FALSE;
+ }
}
/* Check to see if the user requested a
while (i < num_dump_sects)
{
if (dump_sects[i])
- warn (_("Section %d was not dumped because it does not exist!\n"), 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 ? "" : "|");
}
{
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);
}
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;
if (tag == Tag_GNU_MIPS_ABI_MSA)
{
unsigned int len;
- int val;
+ unsigned int val;
val = read_uleb128 (p, &len, end);
p += len;
return p;
}
-static int
+static bfd_boolean
process_attributes (FILE * file,
const char * public_name,
unsigned int proc_type,
{
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;
contents = (unsigned char *) get_data (NULL, file, 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;
}
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;
}
free (contents);
}
- return 1;
+
+ return res;
}
/* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
}
}
-static int
+static signed int
get_mips_reg_size (int reg_size)
{
return (reg_size == AFL_REG_NONE) ? 0
: -1;
}
-static int
+static bfd_boolean
process_mips_specific (FILE * file)
{
Elf_Internal_Dyn * entry;
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 (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
+ display_mips_gnu_attribute))
+ res = FALSE;
sect = find_section (".MIPS.abiflags");
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,
/* We have a lot of special sections. Thanks SGI! */
if (dynamic_section == NULL)
/* No information available. */
- return 0;
+ return res;
for (entry = dynamic_section;
/* PR 17531 file: 012-50589-0.004. */
free (elib);
}
+ else
+ res = FALSE;
}
if (options_offset != 0)
if (sect == NULL)
{
error (_("No MIPS_OPTIONS header found\n"));
- return 0;
+ return FALSE;
}
eopt = (Elf_External_Options *) get_data (NULL, file, options_offset, 1,
if (iopt == NULL)
{
error (_("Out of memory allocating space for MIPS options\n"));
- return 0;
+ return FALSE;
}
offset = cnt = 0;
|| offset + option->size > sect->sh_size)
{
error (_("Invalid size (%u) for MIPS option\n"), option->size);
- return 0;
+ return FALSE;
}
offset += option->size;
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;
}
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)
get_data (NULL, file, conflicts_offset, conflictsno,
sizeof (* econf32), _("conflict"));
if (!econf32)
- return 0;
+ return FALSE;
for (cnt = 0; cnt < conflictsno; ++cnt)
iconf[cnt] = BYTE_GET (econf32[cnt]);
get_data (NULL, file, conflicts_offset, conflictsno,
sizeof (* econf64), _("conflict"));
if (!econf64)
- return 0;
+ return FALSE;
for (cnt = 0; cnt < conflictsno; ++cnt)
iconf[cnt] = BYTE_GET (econf64[cnt]);
{
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);
global_end - pltgot, 1,
_("Global Offset Table data"));
if (data == NULL)
- return 0;
+ return FALSE;
data_end = data + (global_end - pltgot);
printf (_("\nPrimary GOT:\n"));
if (pltrel == DT_RELA)
{
if (!slurp_rela_relocs (file, rel_offset, pltrelsz, &rels, &count))
- return 0;
+ return FALSE;
}
else
{
if (!slurp_rel_relocs (file, rel_offset, pltrelsz, &rels, &count))
- return 0;
+ return FALSE;
}
ent = mips_pltgot;
data = (unsigned char *) get_data (NULL, file, 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"));
free (rels);
}
- return 1;
+ return res;
}
-static int
+static bfd_boolean
process_nds32_specific (FILE * file)
{
Elf_Internal_Shdr *sect = NULL;
flag = get_data (NULL, file, sect->sh_offset, 1,
sect->sh_size, _("NDS32 elf flags section"));
+ if (! flag)
+ return FALSE;
+
switch ((*flag) & 0x3)
{
case 0:
return TRUE;
}
-static int
+static bfd_boolean
process_gnu_liblist (FILE * file)
{
Elf_Internal_Shdr * section;
size_t strtab_size;
size_t cnt;
unsigned i;
+ bfd_boolean res = TRUE;
if (! do_arch)
- return 0;
+ return TRUE;
for (i = 0, section = section_headers;
i < elf_header.e_shnum;
_("liblist section data"));
if (elib == NULL)
- break;
- string_sec = section_headers + section->sh_link;
+ {
+ res = FALSE;
+ break;
+ }
+ string_sec = section_headers + section->sh_link;
strtab = (char *) get_data (NULL, file, string_sec->sh_offset, 1,
string_sec->sh_size,
_("liblist string table"));
{
free (elib);
free (strtab);
+ res = FALSE;
break;
}
strtab_size = string_sec->sh_size;
}
}
- return 1;
+ return res;
}
static const char *
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;
+ 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);
if (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 *
}
}
-static int
+static bfd_boolean
print_gnu_note (Elf_Internal_Note *pnote)
{
/* NB/ Keep this switch statement in sync with get_gnu_elf_note_type (). */
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;
}
- 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,
pnote->descdata);
- return 1;
+ return TRUE;
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 *
return buff;
}
-static int
+static bfd_boolean
print_stapsdt_note (Elf_Internal_Note *pnote)
{
int addr_size = is_32bit_elf ? 4 : 8;
}
}
-static int
+static bfd_boolean
print_ia64_vms_note (Elf_Internal_Note * pnote)
{
switch (pnote->type)
printf (_(" Linker id: %s\n"), pnote->descdata);
break;
default:
- break;
+ return FALSE;
}
- return 1;
+ 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
+static bfd_boolean
process_note (Elf_Internal_Note * pnote,
FILE * file ATTRIBUTE_UNUSED,
Elf_Internal_Shdr * section ATTRIBUTE_UNUSED)
printf ("\n");
}
- return 1;
+ return TRUE;
}
-static int
+static bfd_boolean
process_notes_at (FILE * file,
Elf_Internal_Shdr * section,
bfd_vma offset,
Elf_External_Note * pnotes;
Elf_External_Note * external;
char * end;
- int res = 1;
+ bfd_boolean res = TRUE;
if (length <= 0)
- return 0;
+ return FALSE;
if (section)
{
pnotes = (Elf_External_Note *) get_section_contents (section, file);
if (pnotes)
- apply_relocations (file, section, (unsigned char *) pnotes, length, NULL, NULL);
+ {
+ if (! apply_relocations (file, section, (unsigned char *) pnotes, length, NULL, NULL))
+ return FALSE;
+ }
}
else
pnotes = (Elf_External_Note *) get_data (NULL, file, offset, 1, length,
_("notes"));
if (pnotes == NULL)
- return 0;
+ return FALSE;
external = pnotes;
if (temp == NULL)
{
error (_("Out of memory allocating space for inote name\n"));
- res = 0;
+ res = FALSE;
break;
}
inote.namedata = temp;
}
- res &= process_note (& inote, file, section);
+ if (! process_note (& inote, file, section))
+ res = FALSE;
if (temp != NULL)
{
return res;
}
-static int
+static bfd_boolean
process_corefile_note_segments (FILE * file)
{
Elf_Internal_Phdr * segment;
unsigned int i;
- int res = 1;
+ bfd_boolean res = TRUE;
if (! get_program_headers (file))
- return 0;
+ return TRUE;
for (i = 0, segment = program_headers;
i < elf_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 (file, NULL,
+ (bfd_vma) segment->p_offset,
+ (bfd_vma) segment->p_filesz))
+ res = FALSE;
}
return res;
}
-static int
+static bfd_boolean
process_v850_notes (FILE * file, 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,
_("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
+static bfd_boolean
process_note_sections (FILE * file)
{
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;
{
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 (file, section,
+ (bfd_vma) section->sh_offset,
+ (bfd_vma) section->sh_size))
+ res = FALSE;
n++;
}
|| elf_header.e_machine == EM_CYGNUS_V850)
&& section->sh_type == SHT_RENESAS_INFO)
{
- res &= process_v850_notes (file,
- (bfd_vma) section->sh_offset,
- (bfd_vma) section->sh_size);
+ if (! process_v850_notes (file,
+ (bfd_vma) section->sh_offset,
+ (bfd_vma) section->sh_size))
+ res = FALSE;
n++;
}
}
return res;
}
-static int
+static bfd_boolean
process_notes (FILE * file)
{
/* 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);
return process_corefile_note_segments (file);
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
+static bfd_boolean
process_arch_specific (FILE * file)
{
if (! do_arch)
- return 1;
+ return TRUE;
switch (elf_header.e_machine)
{
}
}
-static int
+static bfd_boolean
get_file_header (FILE * file)
{
/* Read in the identity array. */
if (fread (elf_header.e_ident, EI_NIDENT, 1, file) != 1)
- return 0;
+ return FALSE;
/* Determine how to read the rest of the header. */
switch (elf_header.e_ident[EI_DATA])
Elf32_External_Ehdr ehdr32;
if (fread (ehdr32.e_type, sizeof (ehdr32) - EI_NIDENT, 1, file) != 1)
- return 0;
+ return FALSE;
elf_header.e_type = BYTE_GET (ehdr32.e_type);
elf_header.e_machine = BYTE_GET (ehdr32.e_machine);
{
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;
+ return FALSE;
elf_header.e_type = BYTE_GET (ehdr64.e_type);
elf_header.e_machine = BYTE_GET (ehdr64.e_machine);
get_64bit_section_headers (file, TRUE);
}
- return 1;
+ return TRUE;
}
/* 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
+static bfd_boolean
process_object (char * file_name, FILE * file)
{
unsigned int i;
+ bfd_boolean res = TRUE;
if (! get_file_header (file))
{
error (_("%s: Failed to read file header\n"), file_name);
- return 1;
+ return FALSE;
}
/* Initialise per file variables. */
}
if (! process_file_header ())
- return 1;
+ return FALSE;
if (! process_section_headers (file))
{
- /* 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;
- }
+ /* Without loaded section groups we cannot process unwind. */
+ do_unwind = FALSE;
if (process_program_headers (file))
process_dynamic_section (file);
+ else
+ res = FALSE;
- process_relocs (file);
+ if (! process_relocs (file))
+ res = FALSE;
- process_unwind (file);
+ if (! process_unwind (file))
+ res = FALSE;
- process_symbol_table (file);
+ if (! process_symbol_table (file))
+ res = FALSE;
- process_syminfo (file);
+ if (! process_syminfo (file))
+ res = FALSE;
- process_version_sections (file);
+ if (! process_version_sections (file))
+ res = FALSE;
- process_section_contents (file);
+ if (! process_section_contents (file))
+ res = FALSE;
- process_notes (file);
+ if (! process_notes (file))
+ res = FALSE;
- process_gnu_liblist (file);
+ if (! process_gnu_liblist (file))
+ res = FALSE;
- process_arch_specific (file);
+ if (! process_arch_specific (file))
+ res = FALSE;
if (program_headers)
{
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
+static bfd_boolean
process_archive (char * file_name, FILE * file, 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;
if (setup_archive (&arch, file_name, file, is_thin_archive, do_archive_index) != 0)
{
- ret = 1;
+ ret = FALSE;
goto out;
}
{
error (_("%s: end of the symbol table reached before the end of the index\n"),
file_name);
+ ret = FALSE;
break;
}
/* PR 17531: file: 0b6630b2. */
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 (_("%s: %ld bytes remain in the symbol table, but without corresponding entries in the index table\n"),
+ file_name, arch.sym_size - l);
+ ret = FALSE;
+ }
if (fseek (file, current_pos, SEEK_SET) != 0)
{
error (_("%s: failed to seek back to start of object files in the archive\n"), file_name);
- ret = 1;
+ 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;
if (fseek (file, arch.next_arhdr_offset, SEEK_SET) != 0)
{
error (_("%s: failed to seek to next archive header\n"), file_name);
- return 1;
+ return FALSE;
}
got = fread (&arch.arhdr, 1, sizeof arch.arhdr, file);
if (got != sizeof arch.arhdr)
if (got == 0)
break;
error (_("%s: failed to read archive header\n"), file_name);
- ret = 1;
+ 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;
}
if (name == NULL)
{
error (_("%s: bad archive file name\n"), file_name);
- ret = 1;
+ ret = FALSE;
break;
}
namelen = strlen (name);
if (qualified_name == NULL)
{
error (_("%s: bad archive file name\n"), file_name);
- ret = 1;
+ ret = FALSE;
break;
}
/* 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);
+
if (member_file_name == NULL)
{
- ret = 1;
+ ret = FALSE;
break;
}
{
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;
- ret |= process_object (qualified_name, member_file);
+ if (! process_object (qualified_name, member_file))
+ ret = FALSE;
fclose (member_file);
free (member_file_name);
{
error (_("%s: contains corrupt thin archive: %s\n"),
file_name, name);
- ret = 1;
+ 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);
+ if (! process_object (qualified_name, nested_arch.file))
+ ret = FALSE;
}
else
{
archive_file_offset = arch.next_arhdr_offset;
arch.next_arhdr_offset += archive_file_size;
- ret |= process_object (qualified_name, file);
+ if (! process_object (qualified_name, file))
+ ret = FALSE;
}
if (dump_sects != NULL)
return ret;
}
-static int
+static bfd_boolean
process_file (char * file_name)
{
FILE * file;
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;
}
file = fopen (file_name, "rb");
if (file == NULL)
{
error (_("Input file '%s' is not readable.\n"), file_name);
- return 1;
+ return FALSE;
}
if (fread (armag, SARMAG, 1, file) != 1)
{
error (_("%s: Failed to read file's magic number\n"), file_name);
fclose (file);
- return 1;
+ return FALSE;
}
current_file_size = (bfd_size_type) statbuf.st_size;
if (memcmp (armag, ARMAG, SARMAG) == 0)
- ret = process_archive (file_name, file, FALSE);
+ {
+ if (! process_archive (file_name, file, FALSE))
+ ret = FALSE;
+ }
else if (memcmp (armag, ARMAGT, SARMAG) == 0)
- ret = process_archive (file_name, file, TRUE);
+ {
+ if ( ! process_archive (file_name, file, TRUE))
+ ret = FALSE;
+ }
else
{
if (do_archive_index)
rewind (file);
archive_file_size = archive_file_offset = 0;
- ret = process_object (file_name, file);
+
+ if (! process_object (file_name, file))
+ ret = FALSE;
}
fclose (file);
-
current_file_size = 0;
+
return ret;
}
}
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 (dump_sects != NULL)
free (dump_sects);
if (cmdline_dump_sects != NULL)
free (cmdline_dump_sects);
- return err;
+ return err ? EXIT_FAILURE : EXIT_SUCCESS;
}