#include <assert.h>
#include <time.h>
#include <zlib.h>
-#ifdef HAVE_WCHAR_H
#include <wchar.h>
-#endif
#if __GNUC__ >= 2
/* Define BFD64 here, even if our default architecture is 32 bit ELF
char * program_name = "readelf";
-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_lto_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 check_all = FALSE;
-static bfd_boolean is_32bit_elf = FALSE;
-static bfd_boolean decompress_dumps = FALSE;
-static bfd_boolean do_not_show_symbol_truncation = FALSE;
-static bfd_boolean do_demangle = FALSE; /* Pretty print C++ symbol names. */
-static bfd_boolean process_links = FALSE;
+static bool show_name = false;
+static bool do_dynamic = false;
+static bool do_syms = false;
+static bool do_dyn_syms = false;
+static bool do_lto_syms = false;
+static bool do_reloc = false;
+static bool do_sections = false;
+static bool do_section_groups = false;
+static bool do_section_details = false;
+static bool do_segments = false;
+static bool do_unwind = false;
+static bool do_using_dynamic = false;
+static bool do_header = false;
+static bool do_dump = false;
+static bool do_version = false;
+static bool do_histogram = false;
+static bool do_debugging = false;
+static bool do_ctf = false;
+static bool do_arch = false;
+static bool do_notes = false;
+static bool do_archive_index = false;
+static bool check_all = false;
+static bool is_32bit_elf = false;
+static bool decompress_dumps = false;
+static bool do_not_show_symbol_truncation = false;
+static bool do_demangle = false; /* Pretty print C++ symbol names. */
+static bool process_links = false;
static int demangle_flags = DMGL_ANSI | DMGL_PARAMS;
+static int sym_base = 0;
static char *dump_ctf_parent_name;
static char *dump_ctf_symtab_name;
typedef struct filedata
{
const char * file_name;
- bfd_boolean is_separate;
+ bool is_separate;
FILE * handle;
bfd_size_type file_size;
Elf_Internal_Ehdr file_header;
bfd_vma * gnuchains;
bfd_vma * mipsxlat;
bfd_vma gnusymidx;
- char program_interpreter[PATH_MAX];
+ char * program_interpreter;
bfd_vma dynamic_info[DT_ENCODING];
bfd_vma dynamic_info_DT_GNU_HASH;
bfd_vma dynamic_info_DT_MIPS_XHASH;
typedef enum print_mode
{
HEX,
+ HEX_5,
DEC,
DEC_5,
UNSIGNED,
+ UNSIGNED_5,
PREFIX_HEX,
+ PREFIX_HEX_5,
FULL_HEX,
- LONG_HEX
+ LONG_HEX,
+ OCTAL,
+ OCTAL_5
}
print_mode;
};
static const char * get_symbol_version_string
- (Filedata *, bfd_boolean, const char *, unsigned long, unsigned,
+ (Filedata *, bool, const char *, unsigned long, unsigned,
Elf_Internal_Sym *, enum versioned_symbol_info *, unsigned short *);
#define UNKNOWN -1
#define DT_VERSIONTAGIDX(tag) (DT_VERNEEDNUM - (tag)) /* Reverse order! */
-#define GET_ELF_SYMBOLS(file, section, sym_count) \
- (is_32bit_elf ? get_32bit_elf_symbols (file, section, sym_count) \
- : get_64bit_elf_symbols (file, section, sym_count))
-
#define VALID_SYMBOL_NAME(strtab, strtab_size, offset) \
(strtab != NULL && offset < strtab_size)
#define VALID_DYNAMIC_NAME(filedata, offset) \
case HEX:
return nc + printf ("%" BFD_VMA_FMT "x", vma);
+ case PREFIX_HEX_5:
+ nc = printf ("0x");
+ /* Fall through. */
+ case HEX_5:
+ return nc + printf ("%05" BFD_VMA_FMT "x", vma);
+
case DEC:
return printf ("%" BFD_VMA_FMT "d", vma);
case UNSIGNED:
return printf ("%" BFD_VMA_FMT "u", vma);
+ case UNSIGNED_5:
+ return printf ("%5" BFD_VMA_FMT "u", vma);
+
+ case OCTAL:
+ return printf ("%" BFD_VMA_FMT "o", vma);
+
+ case OCTAL_5:
+ return printf ("%5" BFD_VMA_FMT "o", vma);
+
default:
/* FIXME: Report unrecognised mode ? */
return 0;
}
}
+
/* Display a symbol on stdout. Handles the display of control characters and
multibye characters (assuming the host environment supports them).
static unsigned int
print_symbol (signed int width, const char * symbol)
{
- bfd_boolean extra_padding = FALSE;
- bfd_boolean do_dots = FALSE;
+ bool extra_padding = false;
+ bool do_dots = false;
signed int num_printed = 0;
#ifdef HAVE_MBSTATE_T
mbstate_t state;
{
/* Keep the width positive. This helps the code below. */
width = - width;
- extra_padding = TRUE;
+ extra_padding = true;
}
else if (width == 0)
return 0;
width_remaining -= 5;
if ((int) width_remaining < 0)
width_remaining = 0;
- do_dots = TRUE;
+ do_dots = true;
}
}
This OS has so many departures from the ELF standard that we test it at
many places. */
-static inline bfd_boolean
+static inline bool
is_ia64_vms (Filedata * filedata)
{
return filedata->file_header.e_machine == EM_IA_64
/* Guess the relocation size commonly used by the specific machines. */
-static bfd_boolean
+static bool
guess_is_rela (unsigned int e_machine)
{
switch (e_machine)
case EM_XGATE:
case EM_NFP:
case EM_BPF:
- return FALSE;
+ return false;
/* Targets that use RELA relocations. */
case EM_68K:
case EM_MICROBLAZE:
case EM_MICROBLAZE_OLD:
case EM_WEBASSEMBLY:
- return TRUE;
+ return true;
case EM_68HC05:
case EM_68HC08:
case EM_TINYJ:
default:
warn (_("Don't know about relocations on this machine architecture\n"));
- return FALSE;
+ return false;
}
}
and the number of relocs loaded is placed in *NRELASP. It is the caller's
responsibility to free the allocated buffer. */
-static bfd_boolean
+static bool
slurp_rela_relocs (Filedata * filedata,
unsigned long rel_offset,
unsigned long rel_size,
erelas = (Elf32_External_Rela *) get_data (NULL, filedata, rel_offset, 1,
rel_size, _("32-bit relocation data"));
if (!erelas)
- return FALSE;
+ return false;
nrelas = rel_size / sizeof (Elf32_External_Rela);
{
free (erelas);
error (_("out of memory parsing relocs\n"));
- return FALSE;
+ return false;
}
for (i = 0; i < nrelas; i++)
erelas = (Elf64_External_Rela *) get_data (NULL, filedata, rel_offset, 1,
rel_size, _("64-bit relocation data"));
if (!erelas)
- return FALSE;
+ return false;
nrelas = rel_size / sizeof (Elf64_External_Rela);
{
free (erelas);
error (_("out of memory parsing relocs\n"));
- return FALSE;
+ return false;
}
for (i = 0; i < nrelas; i++)
*relasp = relas;
*nrelasp = nrelas;
- return TRUE;
+ return true;
}
/* Load REL type relocations from FILEDATA at REL_OFFSET extending for REL_SIZE bytes.
and the number of relocs loaded is placed in *NRELSP. It is the caller's
responsibility to free the allocated buffer. */
-static bfd_boolean
+static bool
slurp_rel_relocs (Filedata * filedata,
unsigned long rel_offset,
unsigned long rel_size,
erels = (Elf32_External_Rel *) get_data (NULL, filedata, rel_offset, 1,
rel_size, _("32-bit relocation data"));
if (!erels)
- return FALSE;
+ return false;
nrels = rel_size / sizeof (Elf32_External_Rel);
{
free (erels);
error (_("out of memory parsing relocs\n"));
- return FALSE;
+ return false;
}
for (i = 0; i < nrels; i++)
erels = (Elf64_External_Rel *) get_data (NULL, filedata, rel_offset, 1,
rel_size, _("64-bit relocation data"));
if (!erels)
- return FALSE;
+ return false;
nrels = rel_size / sizeof (Elf64_External_Rel);
{
free (erels);
error (_("out of memory parsing relocs\n"));
- return FALSE;
+ return false;
}
for (i = 0; i < nrels; i++)
*relsp = rels;
*nrelsp = nrels;
- return TRUE;
+ return true;
}
/* Returns the reloc type extracted from the reloc info field. */
return is_32bit_elf ? ELF32_R_SYM (reloc_info) : ELF64_R_SYM (reloc_info);
}
-static inline bfd_boolean
+static inline bool
uses_msp430x_relocs (Filedata * filedata)
{
return
/* Display the contents of the relocation data found at the specified
offset. */
-static bfd_boolean
+static bool
dump_relocations (Filedata * filedata,
unsigned long rel_offset,
unsigned long rel_size,
char * strtab,
unsigned long strtablen,
int is_rela,
- bfd_boolean is_dynsym)
+ bool is_dynsym)
{
unsigned long i;
Elf_Internal_Rela * rels;
- bfd_boolean res = TRUE;
+ bool res = true;
if (is_rela == UNKNOWN)
is_rela = guess_is_rela (filedata->file_header.e_machine);
if (is_rela)
{
if (!slurp_rela_relocs (filedata, rel_offset, rel_size, &rels, &rel_size))
- return FALSE;
+ return false;
}
else
{
if (!slurp_rel_relocs (filedata, rel_offset, rel_size, &rels, &rel_size))
- return FALSE;
+ return false;
}
if (is_32bit_elf)
putchar (' ');
printf (_("<unknown addend: %lx>"),
(unsigned long) rels[i].r_addend);
- res = FALSE;
+ res = false;
}
}
else if (symtab_index)
{
error (_(" bad symbol index: %08lx in reloc\n"),
(unsigned long) symtab_index);
- res = FALSE;
+ res = false;
}
else
{
{
error (_("<corrupt string table index: %3ld>\n"),
psym->st_name);
- res = FALSE;
+ res = false;
}
else
{
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";
+ case EM_INTELGT: return "Intel Graphics Technology";
/* 210 */
case EM_KM32: return "KM211 KM32 32-bit processor";
case EM_KMX32: return "KM211 KMX32 32-bit processor";
case EM_ARC_COMPACT3: return "Synopsys ARCv2.3 32-bit";
case EM_KVX: return "Kalray VLIW core of the MPPA processor family";
case EM_65816: return "WDC 65816/65C816";
- case EM_LOONGARCH: return "Loongson Loongarch";
+ case EM_LOONGARCH: return "LoongArch";
case EM_KF32: return "ChipON KungFu32";
/* Large numbers... */
decode_ARM_machine_flags (unsigned e_flags, char buf[])
{
unsigned eabi;
- bfd_boolean unknown = FALSE;
+ bool unknown = false;
eabi = EF_ARM_EABI_VERSION (e_flags);
e_flags &= ~ EF_ARM_EABIMASK;
default:
strcat (buf, ", <unrecognized EABI>");
if (e_flags)
- unknown = TRUE;
+ unknown = true;
break;
case EF_ARM_EABI_VER1:
break;
default:
- unknown = TRUE;
+ unknown = true;
break;
}
}
break;
default:
- unknown = TRUE;
+ unknown = true;
break;
}
}
break;
default:
- unknown = TRUE;
+ unknown = true;
break;
}
}
break;
default:
- unknown = TRUE;
+ unknown = true;
break;
}
}
break;
default:
- unknown = TRUE;
+ unknown = true;
break;
}
}
unsigned arch;
unsigned config;
unsigned version;
- bfd_boolean has_fpu = FALSE;
+ bool has_fpu = false;
unsigned int r = 0;
static const char *ABI_STRINGS[] =
if (config & E_NDS32_HAS_FPU_INST)
{
- has_fpu = TRUE;
+ has_fpu = true;
r += snprintf (buf + r, size -r, ", FPU_SP");
}
if (config & E_NDS32_HAS_FPU_DP_INST)
{
- has_fpu = TRUE;
+ has_fpu = true;
r += snprintf (buf + r, size -r, ", FPU_DP");
}
if (config & E_NDS32_HAS_FPU_MAC_INST)
{
- has_fpu = TRUE;
+ has_fpu = true;
r += snprintf (buf + r, size -r, ", FPU_MAC");
}
OPTION_WITH_SYMBOL_VERSIONS,
OPTION_RECURSE_LIMIT,
OPTION_NO_RECURSE_LIMIT,
- OPTION_NO_DEMANGLING
+ OPTION_NO_DEMANGLING,
+ OPTION_SYM_BASE
};
static struct option options[] =
{"ctf-strings", required_argument, 0, OPTION_CTF_STRINGS},
{"ctf-parent", required_argument, 0, OPTION_CTF_PARENT},
#endif
+ {"sym-base", optional_argument, 0, OPTION_SYM_BASE},
{0, no_argument, 0, 0}
};
{
fprintf (stream, _("Usage: readelf <option(s)> elf-file(s)\n"));
fprintf (stream, _(" Display information about the contents of ELF format files\n"));
- fprintf (stream, _(" Options are:\n\
- -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
- -h --file-header Display the ELF file header\n\
- -l --program-headers Display the program headers\n\
- --segments An alias for --program-headers\n\
- -S --section-headers Display the sections' header\n\
- --sections An alias for --section-headers\n\
- -g --section-groups Display the section groups\n\
- -t --section-details Display the section details\n\
- -e --headers Equivalent to: -h -l -S\n\
- -s --syms Display the symbol table\n\
- --symbols An alias for --syms\n\
- --dyn-syms Display the dynamic symbol table\n\
- --lto-syms Display LTO symbol tables\n\
+ fprintf (stream, _(" Options are:\n"));
+ fprintf (stream, _("\
+ -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n"));
+ fprintf (stream, _("\
+ -h --file-header Display the ELF file header\n"));
+ fprintf (stream, _("\
+ -l --program-headers Display the program headers\n"));
+ fprintf (stream, _("\
+ --segments An alias for --program-headers\n"));
+ fprintf (stream, _("\
+ -S --section-headers Display the sections' header\n"));
+ fprintf (stream, _("\
+ --sections An alias for --section-headers\n"));
+ fprintf (stream, _("\
+ -g --section-groups Display the section groups\n"));
+ fprintf (stream, _("\
+ -t --section-details Display the section details\n"));
+ fprintf (stream, _("\
+ -e --headers Equivalent to: -h -l -S\n"));
+ fprintf (stream, _("\
+ -s --syms Display the symbol table\n"));
+ fprintf (stream, _("\
+ --symbols An alias for --syms\n"));
+ fprintf (stream, _("\
+ --dyn-syms Display the dynamic symbol table\n"));
+ fprintf (stream, _("\
+ --lto-syms Display LTO symbol tables\n"));
+ fprintf (stream, _("\
+ --sym-base=[0|8|10|16] \n\
+ Force base for symbol sizes. The options are \n\
+ mixed (the default), octal, decimal, hexadecimal.\n"));
+ fprintf (stream, _("\
-C --demangle[=STYLE] Decode low-level symbol names into user-level names\n\
The STYLE, if specified, can be `auto' (the default),\n\
`gnu', `lucid', `arm', `hp', `edg', `gnu-v3', `java'\n\
- or `gnat'\n\
- --no-demangle Do not demangle low-level symbol names. (This is the default)\n\
- --recurse-limit Enable a demangling recursion limit. (This is the default)\n\
- --no-recurse-limit Disable a demangling recursion limit\n\
- -n --notes Display the core notes (if present)\n\
- -r --relocs Display the relocations (if present)\n\
- -u --unwind Display the unwind info (if present)\n\
- -d --dynamic Display the dynamic section (if present)\n\
- -V --version-info Display the version sections (if present)\n\
- -A --arch-specific Display architecture specific information (if any)\n\
- -c --archive-index Display the symbol/file index in an archive\n\
- -D --use-dynamic Use the dynamic section info when displaying symbols\n\
- -L --lint|--enable-checks Display warning messages for possible problems\n\
+ or `gnat'\n"));
+ fprintf (stream, _("\
+ --no-demangle Do not demangle low-level symbol names. (default)\n"));
+ fprintf (stream, _("\
+ --recurse-limit Enable a demangling recursion limit. (default)\n"));
+ fprintf (stream, _("\
+ --no-recurse-limit Disable a demangling recursion limit\n"));
+ fprintf (stream, _("\
+ -n --notes Display the core notes (if present)\n"));
+ fprintf (stream, _("\
+ -r --relocs Display the relocations (if present)\n"));
+ fprintf (stream, _("\
+ -u --unwind Display the unwind info (if present)\n"));
+ fprintf (stream, _("\
+ -d --dynamic Display the dynamic section (if present)\n"));
+ fprintf (stream, _("\
+ -V --version-info Display the version sections (if present)\n"));
+ fprintf (stream, _("\
+ -A --arch-specific Display architecture specific information (if any)\n"));
+ fprintf (stream, _("\
+ -c --archive-index Display the symbol/file index in an archive\n"));
+ fprintf (stream, _("\
+ -D --use-dynamic Use the dynamic section info when displaying symbols\n"));
+ fprintf (stream, _("\
+ -L --lint|--enable-checks\n\
+ Display warning messages for possible problems\n"));
+ fprintf (stream, _("\
-x --hex-dump=<number|name>\n\
- Dump the contents of section <number|name> as bytes\n\
+ Dump the contents of section <number|name> as bytes\n"));
+ fprintf (stream, _("\
-p --string-dump=<number|name>\n\
- Dump the contents of section <number|name> as strings\n\
+ Dump the contents of section <number|name> as strings\n"));
+ fprintf (stream, _("\
-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[lLiaprmfFsoORtUuTgAc] or\n\
- --debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
- =frames-interp,=str,=str-offsets,=loc,=Ranges,=pubtypes,\n\
- =gdb_index,=trace_info,=trace_abbrev,=trace_aranges,\n\
- =addr,=cu_index]\n\
- Display the contents of DWARF debug sections\n\
- -wk,--debug-dump=links Display the contents of sections that link to separate debuginfo files\n\
- -P,--process-links Display the contents of non-debug sections in separate debuginfo files. (Implies -wK)\n"));
+ Dump the relocated contents of section <number|name>\n"));
+ fprintf (stream, _("\
+ -z --decompress Decompress section before dumping it\n"));
+ fprintf (stream, _("\
+ -w --debug-dump[a/=abbrev, A/=addr, r/=aranges, c/=cu_index, L/=decodedline,\n\
+ f/=frames, F/=frames-interp, g/=gdb_index, i/=info, o/=loc,\n\
+ m/=macro, p/=pubnames, t/=pubtypes, R/=Ranges, l/=rawline,\n\
+ s/=str, O/=str-offsets, u/=trace_abbrev, T/=trace_aranges,\n\
+ U/=trace_info]\n\
+ Display the contents of DWARF debug sections\n"));
+ fprintf (stream, _("\
+ -wk --debug-dump=links Display the contents of sections that link to separate\n\
+ debuginfo files\n"));
+ fprintf (stream, _("\
+ -P --process-links Display the contents of non-debug sections in separate\n\
+ debuginfo files. (Implies -wK)\n"));
#if DEFAULT_FOR_FOLLOW_LINKS
fprintf (stream, _("\
- -wK,--debug-dump=follow-links Follow links to separate debug info files (default)\n\
- -wN,--debug-dump=no-follow-links Do not follow links to separate debug info files\n\
-"));
+ -wK --debug-dump=follow-links\n\
+ Follow links to separate debug info files (default)\n"));
+ fprintf (stream, _("\
+ -wN --debug-dump=no-follow-links\n\
+ Do not follow links to separate debug info files\n"));
#else
fprintf (stream, _("\
- -wK,--debug-dump=follow-links Follow links to separate debug info files\n\
- -wN,--debug-dump=no-follow-links Do not follow links to separate debug info files (default)\n\
-"));
+ -wK --debug-dump=follow-links\n\
+ Follow links to separate debug info files\n"));
+ fprintf (stream, _("\
+ -wN --debug-dump=no-follow-links\n\
+ Do not follow links to separate debug info files\n\
+ (default)\n"));
#endif
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"));
+ --dwarf-depth=N Do not display DIEs at depth N or greater\n"));
+ fprintf (stream, _("\
+ --dwarf-start=N Display DIEs starting at offset N\n"));
#ifdef ENABLE_LIBCTF
fprintf (stream, _("\
- --ctf=<number|name> Display CTF info from section <number|name>\n\
+ --ctf=<number|name> Display CTF info from section <number|name>\n"));
+ fprintf (stream, _("\
--ctf-parent=<number|name>\n\
- Use section <number|name> as the CTF parent\n\n\
+ Use section <number|name> as the CTF parent\n"));
+ fprintf (stream, _("\
--ctf-symbols=<number|name>\n\
- Use section <number|name> as the CTF external symtab\n\n\
+ Use section <number|name> as the CTF external symtab\n"));
+ fprintf (stream, _("\
--ctf-strings=<number|name>\n\
- Use section <number|name> as the CTF external strtab\n\n"));
+ Use section <number|name> as the CTF external strtab\n"));
#endif
#ifdef SUPPORT_DISASSEMBLY
Disassemble the contents of section <number|name>\n"));
#endif
fprintf (stream, _("\
- -I --histogram Display histogram of bucket list lengths\n\
- -W --wide Allow output width to exceed 80 characters\n\
- -T --silent-truncation If a symbol name is truncated, do not add a suffix [...]\n\
- @<file> Read options from <file>\n\
- -H --help Display this information\n\
+ -I --histogram Display histogram of bucket list lengths\n"));
+ fprintf (stream, _("\
+ -W --wide Allow output width to exceed 80 characters\n"));
+ fprintf (stream, _("\
+ -T --silent-truncation If a symbol name is truncated, do not add [...] suffix\n"));
+ fprintf (stream, _("\
+ @<file> Read options from <file>\n"));
+ fprintf (stream, _("\
+ -H --help Display this information\n"));
+ fprintf (stream, _("\
-v --version Display the version number of readelf\n"));
if (REPORT_BUGS_TO[0] && stream == stdout)
int section;
char * cp;
- do_dump++;
+ do_dump = true;
section = strtoul (optarg, & cp, 0);
if (! *cp && section >= 0)
break;
case 'a':
- 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;
+ 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 = TRUE;
+ do_section_groups = true;
break;
case 't':
case 'N':
- do_sections = TRUE;
- do_section_details = TRUE;
+ do_sections = true;
+ do_section_details = true;
break;
case 'e':
- do_header = TRUE;
- do_sections = TRUE;
- do_segments = TRUE;
+ do_header = true;
+ do_sections = true;
+ do_segments = true;
break;
case 'A':
- do_arch = TRUE;
+ do_arch = true;
break;
case 'D':
- do_using_dynamic = TRUE;
+ do_using_dynamic = true;
break;
case 'r':
- do_reloc = TRUE;
+ do_reloc = true;
break;
case 'u':
- do_unwind = TRUE;
+ do_unwind = true;
break;
case 'h':
- do_header = TRUE;
+ do_header = true;
break;
case 'l':
- do_segments = TRUE;
+ do_segments = true;
break;
case 's':
- do_syms = TRUE;
+ do_syms = true;
break;
case 'S':
- do_sections = TRUE;
+ do_sections = true;
break;
case 'd':
- do_dynamic = TRUE;
+ do_dynamic = true;
break;
case 'I':
- do_histogram = TRUE;
+ do_histogram = true;
break;
case 'n':
- do_notes = TRUE;
+ do_notes = true;
break;
case 'c':
- do_archive_index = TRUE;
+ do_archive_index = true;
break;
case 'L':
- do_checks = TRUE;
+ do_checks = true;
break;
case 'P':
- process_links = TRUE;
- do_follow_links = TRUE;
+ process_links = true;
+ do_follow_links = true;
break;
case 'x':
request_dump (dumpdata, HEX_DUMP);
request_dump (dumpdata, RELOC_DUMP);
break;
case 'z':
- decompress_dumps = TRUE;
+ decompress_dumps = true;
break;
case 'w':
- do_dump = TRUE;
+ do_dump = true;
if (optarg == NULL)
{
- do_debugging = TRUE;
+ do_debugging = true;
dwarf_select_sections_all ();
}
else
{
- do_debugging = FALSE;
+ do_debugging = false;
dwarf_select_sections_by_letters (optarg);
}
break;
case OPTION_DEBUG_DUMP:
- do_dump = TRUE;
+ do_dump = true;
if (optarg == NULL)
- do_debugging = TRUE;
+ {
+ do_debugging = true;
+ dwarf_select_sections_all ();
+ }
else
{
- do_debugging = FALSE;
+ do_debugging = false;
dwarf_select_sections_by_names (optarg);
}
break;
}
break;
case OPTION_DWARF_CHECK:
- dwarf_check = TRUE;
+ dwarf_check = true;
break;
case OPTION_CTF_DUMP:
- do_ctf = TRUE;
+ do_ctf = true;
request_dump (dumpdata, CTF_DUMP);
break;
case OPTION_CTF_SYMBOLS:
dump_ctf_parent_name = strdup (optarg);
break;
case OPTION_DYN_SYMS:
- do_dyn_syms = TRUE;
+ do_dyn_syms = true;
break;
case OPTION_LTO_SYMS:
- do_lto_syms = TRUE;
+ do_lto_syms = true;
break;
#ifdef SUPPORT_DISASSEMBLY
case 'i':
print_version (program_name);
break;
case 'V':
- do_version = TRUE;
+ do_version = true;
break;
case 'W':
- do_wide = TRUE;
+ do_wide = true;
break;
case 'T':
- do_not_show_symbol_truncation = TRUE;
+ do_not_show_symbol_truncation = true;
break;
case 'C':
- do_demangle = TRUE;
+ do_demangle = true;
if (optarg != NULL)
{
enum demangling_styles style;
}
break;
case OPTION_NO_DEMANGLING:
- do_demangle = FALSE;
+ do_demangle = false;
break;
case OPTION_RECURSE_LIMIT:
demangle_flags &= ~ DMGL_NO_RECURSE_LIMIT;
/* Ignored for backward compatibility. */
break;
+ case OPTION_SYM_BASE:
+ sym_base = 0;
+ if (optarg != NULL)
+ {
+ sym_base = strtoul (optarg, NULL, 0);
+ switch (sym_base)
+ {
+ case 0:
+ case 8:
+ case 10:
+ case 16:
+ break;
+
+ default:
+ sym_base = 0;
+ break;
+ }
+ }
+ break;
+
default:
/* xgettext:c-format */
error (_("Invalid option '-%c'\n"), c);
{
if (do_checks)
{
- check_all = TRUE;
- do_dynamic = do_syms = do_reloc = do_unwind = do_sections = TRUE;
- do_segments = do_header = do_dump = do_version = TRUE;
- do_histogram = do_debugging = do_arch = do_notes = TRUE;
- do_section_groups = do_archive_index = do_dyn_syms = TRUE;
- do_lto_syms = TRUE;
+ check_all = true;
+ do_dynamic = do_syms = do_reloc = do_unwind = do_sections = true;
+ do_segments = do_header = do_dump = do_version = true;
+ do_histogram = do_debugging = do_arch = do_notes = true;
+ do_section_groups = do_archive_index = do_dyn_syms = true;
+ do_lto_syms = true;
}
else
usage (stderr);
/* Decode the data held in 'filedata->file_header'. */
-static bfd_boolean
+static bool
process_file_header (Filedata * filedata)
{
Elf_Internal_Ehdr * header = & filedata->file_header;
{
error
(_("Not an ELF file - it has the wrong magic bytes at the start\n"));
- return FALSE;
+ return false;
}
if (! filedata->is_separate)
filedata->section_headers = NULL;
}
- return TRUE;
+ 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
+static bool
get_32bit_program_headers (Filedata * filedata, Elf_Internal_Phdr * pheaders)
{
Elf32_External_Phdr * phdrs;
/* PR binutils/17531: Cope with unexpected section header sizes. */
if (size == 0 || num == 0)
- return FALSE;
+ return false;
if (size < sizeof * phdrs)
{
error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
- return FALSE;
+ return false;
}
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, filedata, filedata->file_header.e_phoff,
size, num, _("program headers"));
if (phdrs == NULL)
- return FALSE;
+ return false;
for (i = 0, internal = pheaders, external = phdrs;
i < filedata->file_header.e_phnum;
}
free (phdrs);
- return TRUE;
+ 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
+static bool
get_64bit_program_headers (Filedata * filedata, Elf_Internal_Phdr * pheaders)
{
Elf64_External_Phdr * phdrs;
/* PR binutils/17531: Cope with unexpected section header sizes. */
if (size == 0 || num == 0)
- return FALSE;
+ return false;
if (size < sizeof * phdrs)
{
error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
- return FALSE;
+ return false;
}
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, filedata, filedata->file_header.e_phoff,
size, num, _("program headers"));
if (!phdrs)
- return FALSE;
+ return false;
for (i = 0, internal = pheaders, external = phdrs;
i < filedata->file_header.e_phnum;
}
free (phdrs);
- return TRUE;
+ return true;
}
/* Returns TRUE if the program headers were read into `program_headers'. */
-static bfd_boolean
+static bool
get_program_headers (Filedata * filedata)
{
Elf_Internal_Phdr * phdrs;
/* Check cache of prior read. */
if (filedata->program_headers != NULL)
- return TRUE;
+ return true;
/* Be kind to memory checkers by looking for
e_phnum values which we know must be invalid. */
{
error (_("Too many program headers - %#x - the file is not that big\n"),
filedata->file_header.e_phnum);
- return FALSE;
+ return false;
}
phdrs = (Elf_Internal_Phdr *) cmalloc (filedata->file_header.e_phnum,
{
error (_("Out of memory reading %u program headers\n"),
filedata->file_header.e_phnum);
- return FALSE;
+ return false;
}
if (is_32bit_elf
: get_64bit_program_headers (filedata, phdrs))
{
filedata->program_headers = phdrs;
- return TRUE;
+ return true;
}
free (phdrs);
- return FALSE;
+ return false;
}
/* Returns TRUE if the program headers were loaded. */
-static bfd_boolean
+static bool
process_program_headers (Filedata * filedata)
{
Elf_Internal_Phdr * segment;
{
warn (_("possibly corrupt ELF header - it has a non-zero program"
" header offset, but no program headers\n"));
- return FALSE;
+ return false;
}
else if (do_segments)
{
else
printf (_("\nThere are no program headers in this file.\n"));
}
- return TRUE;
+ return true;
}
if (do_segments && !do_header)
}
if (! get_program_headers (filedata))
- return TRUE;
+ return true;
if (do_segments)
{
break;
case PT_INTERP:
- if (fseek (filedata->handle,
- filedata->archive_file_offset + (long) segment->p_offset,
- SEEK_SET))
+ if (segment->p_offset >= filedata->file_size
+ || segment->p_filesz > filedata->file_size - segment->p_offset
+ || segment->p_filesz - 1 >= (size_t) -2
+ || fseek (filedata->handle,
+ filedata->archive_file_offset + (long) segment->p_offset,
+ SEEK_SET))
error (_("Unable to find program interpreter name\n"));
else
{
- char fmt [32];
- int ret = snprintf (fmt, sizeof (fmt), "%%%ds", PATH_MAX - 1);
-
- if (ret >= (int) sizeof (fmt) || ret < 0)
- error (_("Internal error: failed to create format string to display program interpreter\n"));
-
- filedata->program_interpreter[0] = 0;
- if (fscanf (filedata->handle, fmt,
- filedata->program_interpreter) <= 0)
- error (_("Unable to read program interpreter name\n"));
+ size_t len = segment->p_filesz;
+ free (filedata->program_interpreter);
+ filedata->program_interpreter = xmalloc (len + 1);
+ len = fread (filedata->program_interpreter, 1, len,
+ filedata->handle);
+ filedata->program_interpreter[len] = 0;
if (do_segments)
printf (_(" [Requesting program interpreter: %s]\n"),
}
}
- return TRUE;
+ return true;
}
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 (Filedata * filedata, bfd_boolean probe)
+static bool
+get_32bit_section_headers (Filedata * filedata, bool probe)
{
Elf32_External_Shdr * shdrs;
Elf_Internal_Shdr * internal;
/* PR binutils/17531: Cope with unexpected section header sizes. */
if (size == 0 || num == 0)
- return FALSE;
+ 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;
+ 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"));
size, num,
probe ? NULL : _("section headers"));
if (shdrs == NULL)
- return FALSE;
+ return false;
- 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;
+ return false;
}
for (i = 0, internal = filedata->section_headers;
}
free (shdrs);
- return TRUE;
+ return true;
}
/* Like get_32bit_section_headers, except that it fetches 64-bit headers. */
-static bfd_boolean
-get_64bit_section_headers (Filedata * filedata, bfd_boolean probe)
+static bool
+get_64bit_section_headers (Filedata * filedata, bool probe)
{
Elf64_External_Shdr * shdrs;
Elf_Internal_Shdr * internal;
/* PR binutils/17531: Cope with unexpected section header sizes. */
if (size == 0 || num == 0)
- return FALSE;
+ 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;
+ return false;
}
if (! probe && size > sizeof * shdrs)
size, num,
probe ? NULL : _("section headers"));
if (shdrs == NULL)
- return FALSE;
+ return false;
- 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;
+ return false;
}
for (i = 0, internal = filedata->section_headers;
}
free (shdrs);
- return TRUE;
+ return true;
+}
+
+static bool
+get_section_headers (Filedata *filedata, bool probe)
+{
+ if (filedata->section_headers != NULL)
+ return true;
+
+ if (filedata->file_header.e_shoff == 0)
+ return true;
+
+ if (is_32bit_elf)
+ return get_32bit_section_headers (filedata, probe);
+ else
+ return get_64bit_section_headers (filedata, probe);
}
static Elf_Internal_Sym *
return isyms;
}
+static Elf_Internal_Sym *
+get_elf_symbols (Filedata *filedata,
+ Elf_Internal_Shdr *section,
+ unsigned long *num_syms_return)
+{
+ if (is_32bit_elf)
+ return get_32bit_elf_symbols (filedata, section, num_syms_return);
+ else
+ return get_64bit_elf_symbols (filedata, section, num_syms_return);
+}
+
static const char *
get_elf_section_flags (Filedata * filedata, bfd_vma sh_flags)
{
}
}
-static bfd_boolean
+static bool
process_section_headers (Filedata * filedata)
{
Elf_Internal_Shdr * section;
unsigned int i;
- free (filedata->section_headers);
- filedata->section_headers = NULL;
- free (filedata->dynamic_symbols);
- filedata->dynamic_symbols = NULL;
- filedata->num_dynamic_syms = 0;
- free (filedata->dynamic_strings);
- filedata->dynamic_strings = NULL;
- filedata->dynamic_strings_length = 0;
- free (filedata->dynamic_syminfo);
- filedata->dynamic_syminfo = NULL;
- while (filedata->symtab_shndx_list != NULL)
- {
- elf_section_list *next = filedata->symtab_shndx_list->next;
- free (filedata->symtab_shndx_list);
- filedata->symtab_shndx_list = next;
- }
-
if (filedata->file_header.e_shnum == 0)
{
/* PR binutils/12467. */
{
warn (_("possibly corrupt ELF file header - it has a non-zero"
" section header offset, but no section headers\n"));
- return FALSE;
+ return false;
}
else if (do_sections)
printf (_("\nThere are no sections in this file.\n"));
- return TRUE;
+ return true;
}
if (do_sections && !do_header)
(unsigned long) filedata->file_header.e_shoff);
}
- if (is_32bit_elf)
- {
- if (! get_32bit_section_headers (filedata, FALSE))
- return FALSE;
- }
- else
- {
- if (! get_64bit_section_headers (filedata, FALSE))
- return FALSE;
- }
+ if (!get_section_headers (filedata, false))
+ return false;
/* Read in the string table, so that we have names to display. */
if (filedata->file_header.e_shstrndx != SHN_UNDEF
CHECK_ENTSIZE (section, i, Sym);
filedata->dynamic_symbols
- = GET_ELF_SYMBOLS (filedata, section, &filedata->num_dynamic_syms);
+ = get_elf_symbols (filedata, section, &filedata->num_dynamic_syms);
filedata->dynamic_symtab_section = section;
break;
|| do_debug_str || do_debug_str_offsets || do_debug_loc
|| do_debug_ranges
|| do_debug_addr || do_debug_cu_index || do_debug_links)
- && (const_strneq (name, ".debug_")
- || const_strneq (name, ".zdebug_")))
+ && (startswith (name, ".debug_")
+ || startswith (name, ".zdebug_")))
{
if (name[1] == 'z')
name += sizeof (".zdebug_") - 1;
name += sizeof (".debug_") - 1;
if (do_debugging
- || (do_debug_info && const_strneq (name, "info"))
- || (do_debug_info && const_strneq (name, "types"))
- || (do_debug_abbrevs && const_strneq (name, "abbrev"))
+ || (do_debug_info && startswith (name, "info"))
+ || (do_debug_info && startswith (name, "types"))
+ || (do_debug_abbrevs && startswith (name, "abbrev"))
|| (do_debug_lines && strcmp (name, "line") == 0)
- || (do_debug_lines && const_strneq (name, "line."))
- || (do_debug_pubnames && const_strneq (name, "pubnames"))
- || (do_debug_pubtypes && const_strneq (name, "pubtypes"))
- || (do_debug_pubnames && const_strneq (name, "gnu_pubnames"))
- || (do_debug_pubtypes && const_strneq (name, "gnu_pubtypes"))
- || (do_debug_aranges && const_strneq (name, "aranges"))
- || (do_debug_ranges && const_strneq (name, "ranges"))
- || (do_debug_ranges && const_strneq (name, "rnglists"))
- || (do_debug_frames && const_strneq (name, "frame"))
- || (do_debug_macinfo && const_strneq (name, "macinfo"))
- || (do_debug_macinfo && const_strneq (name, "macro"))
- || (do_debug_str && const_strneq (name, "str"))
- || (do_debug_links && const_strneq (name, "sup"))
- || (do_debug_str_offsets && const_strneq (name, "str_offsets"))
- || (do_debug_loc && const_strneq (name, "loc"))
- || (do_debug_loc && const_strneq (name, "loclists"))
- || (do_debug_addr && const_strneq (name, "addr"))
- || (do_debug_cu_index && const_strneq (name, "cu_index"))
- || (do_debug_cu_index && const_strneq (name, "tu_index"))
+ || (do_debug_lines && startswith (name, "line."))
+ || (do_debug_pubnames && startswith (name, "pubnames"))
+ || (do_debug_pubtypes && startswith (name, "pubtypes"))
+ || (do_debug_pubnames && startswith (name, "gnu_pubnames"))
+ || (do_debug_pubtypes && startswith (name, "gnu_pubtypes"))
+ || (do_debug_aranges && startswith (name, "aranges"))
+ || (do_debug_ranges && startswith (name, "ranges"))
+ || (do_debug_ranges && startswith (name, "rnglists"))
+ || (do_debug_frames && startswith (name, "frame"))
+ || (do_debug_macinfo && startswith (name, "macinfo"))
+ || (do_debug_macinfo && startswith (name, "macro"))
+ || (do_debug_str && startswith (name, "str"))
+ || (do_debug_links && startswith (name, "sup"))
+ || (do_debug_str_offsets && startswith (name, "str_offsets"))
+ || (do_debug_loc && startswith (name, "loc"))
+ || (do_debug_loc && startswith (name, "loclists"))
+ || (do_debug_addr && startswith (name, "addr"))
+ || (do_debug_cu_index && startswith (name, "cu_index"))
+ || (do_debug_cu_index && startswith (name, "tu_index"))
)
request_dump_bynumber (&filedata->dump, 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."))
+ && startswith (name, ".gnu.linkonce.wi."))
request_dump_bynumber (&filedata->dump, i, DEBUG_DUMP);
else if (do_debug_frames && streq (name, ".eh_frame"))
request_dump_bynumber (&filedata->dump, i, DEBUG_DUMP);
/* Trace sections for Itanium VMS. */
else if ((do_debugging || do_trace_info || do_trace_abbrevs
|| do_trace_aranges)
- && const_strneq (name, ".trace_"))
+ && startswith (name, ".trace_"))
{
name += sizeof (".trace_") - 1;
request_dump_bynumber (&filedata->dump, i, DEBUG_DUMP);
}
else if ((do_debugging || do_debug_links)
- && (const_strneq (name, ".gnu_debuglink")
- || const_strneq (name, ".gnu_debugaltlink")))
+ && (startswith (name, ".gnu_debuglink")
+ || startswith (name, ".gnu_debugaltlink")))
request_dump_bynumber (&filedata->dump, i, DEBUG_DUMP);
}
if (! do_sections)
- return TRUE;
+ return true;
if (filedata->is_separate && ! process_links)
- return TRUE;
+ return true;
if (filedata->is_separate)
printf (_("\nSection Headers in linked file '%s':\n"), filedata->file_name);
printf ("p (processor specific)\n");
}
- return TRUE;
+ return true;
}
-static bfd_boolean
+static bool
get_symtab (Filedata *filedata, Elf_Internal_Shdr *symsec,
Elf_Internal_Sym **symtab, unsigned long *nsyms,
char **strtab, unsigned long *strtablen)
{
*strtab = NULL;
*strtablen = 0;
- *symtab = GET_ELF_SYMBOLS (filedata, symsec, nsyms);
+ *symtab = get_elf_symbols (filedata, symsec, nsyms);
if (*symtab == NULL)
- return FALSE;
+ return false;
if (symsec->sh_link != 0)
{
free (*symtab);
*symtab = NULL;
*nsyms = 0;
- return FALSE;
+ return false;
}
strsec = filedata->section_headers + symsec->sh_link;
free (*symtab);
*symtab = NULL;
*nsyms = 0;
- return FALSE;
+ return false;
}
*strtablen = strsec->sh_size;
}
- return TRUE;
+ return true;
}
static const char *
return buff;
}
-static bfd_boolean
+static bool
process_section_groups (Filedata * filedata)
{
Elf_Internal_Shdr * section;
/* Don't process section groups unless needed. */
if (!do_unwind && !do_section_groups)
- return TRUE;
+ return true;
if (filedata->file_header.e_shnum == 0)
{
else
printf (_("\nThere are no section groups in this file.\n"));
}
- return TRUE;
+ return true;
}
if (filedata->section_headers == NULL)
{
error (_("Section headers are not available!\n"));
/* PR 13622: This can happen with a corrupt ELF header. */
- return FALSE;
+ return false;
}
filedata->section_headers_groups
{
error (_("Out of memory reading %u section group headers\n"),
filedata->file_header.e_shnum);
- return FALSE;
+ return false;
}
/* Scan the sections for the group section. */
printf (_("\nThere are no section groups in this file.\n"));
}
- return TRUE;
+ return true;
}
filedata->section_groups = (struct group *) calloc (filedata->group_count,
{
error (_("Out of memory reading %lu groups\n"),
(unsigned long) filedata->group_count);
- return FALSE;
+ return false;
}
symtab_sec = NULL;
if (filedata->is_separate)
printf (_("Section groups in linked file '%s'\n"), filedata->file_name);
-
+
for (i = 0, section = filedata->section_headers, group = filedata->section_groups;
i < filedata->file_header.e_shnum;
i++, section++)
{
symtab_sec = sec;
free (symtab);
- symtab = GET_ELF_SYMBOLS (filedata, symtab_sec, & num_syms);
+ symtab = get_elf_symbols (filedata, symtab_sec, & num_syms);
}
if (symtab == NULL)
/* Intel C/C++ compiler may put section 0 in a
section group. We just warn it the first time
and ignore it afterwards. */
- static bfd_boolean warned = FALSE;
+ static bool warned = false;
if (!warned)
{
error (_("section 0 in group section [%5u]\n"),
filedata->section_headers_groups [entry]->group_index);
- warned = TRUE;
+ warned = true;
}
}
}
free (symtab);
free (strtab);
- return TRUE;
+ return true;
}
/* Data used to display dynamic fixups. */
/* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
library). */
-static bfd_boolean
+static bool
dump_ia64_vms_dynamic_fixups (Filedata * filedata,
struct ia64_vms_dynfixup * fixup,
const char * strtab,
sizeof (*imfs), fixup->fixup_rela_cnt,
_("dynamic section image fixups"));
if (!imfs)
- return FALSE;
+ return false;
if (fixup->needed < strtab_sz)
lib_name = strtab + fixup->needed;
}
free (imfs);
- return TRUE;
+ return true;
}
/* Display IA-64 OpenVMS dynamic relocations (used to relocate an image). */
-static bfd_boolean
+static bool
dump_ia64_vms_dynamic_relocs (Filedata * filedata, struct ia64_vms_dynimgrela *imgrela)
{
Elf64_External_VMS_IMAGE_RELA *imrs;
sizeof (*imrs), imgrela->img_rela_cnt,
_("dynamic section image relocations"));
if (!imrs)
- return FALSE;
+ return false;
printf (_("\nImage relocs\n"));
printf
}
free (imrs);
- return TRUE;
+ return true;
}
/* Display IA-64 OpenVMS dynamic relocations and fixups. */
-static bfd_boolean
+static bool
process_ia64_vms_dynamic_relocs (Filedata * filedata)
{
struct ia64_vms_dynfixup fixup;
bfd_vma strtab_off = 0;
bfd_vma strtab_sz = 0;
char *strtab = NULL;
- bfd_boolean res = TRUE;
+ bool res = true;
memset (&fixup, 0, sizeof (fixup));
memset (&imgrela, 0, sizeof (imgrela));
case DT_IA_64_VMS_FIXUP_RELA_OFF:
fixup.fixup_rela_off = entry->d_un.d_val;
if (! dump_ia64_vms_dynamic_fixups (filedata, &fixup, strtab, strtab_sz))
- res = FALSE;
+ res = false;
break;
case DT_IA_64_VMS_IMG_RELA_CNT:
imgrela.img_rela_cnt = entry->d_un.d_val;
case DT_IA_64_VMS_IMG_RELA_OFF:
imgrela.img_rela_off = entry->d_un.d_val;
if (! dump_ia64_vms_dynamic_relocs (filedata, &imgrela))
- res = FALSE;
+ res = false;
break;
default:
}
dynamic_relocations [] =
{
- { "REL", DT_REL, DT_RELSZ, FALSE },
- { "RELA", DT_RELA, DT_RELASZ, TRUE },
+ { "REL", DT_REL, DT_RELSZ, false },
+ { "RELA", DT_RELA, DT_RELASZ, true },
{ "PLT", DT_JMPREL, DT_PLTRELSZ, UNKNOWN }
};
/* Process the reloc section. */
-static bfd_boolean
+static bool
process_relocs (Filedata * filedata)
{
unsigned long rel_size;
unsigned long rel_offset;
if (!do_reloc)
- return TRUE;
+ return true;
if (do_using_dynamic)
{
int is_rela;
const char * name;
- bfd_boolean has_dynamic_reloc;
+ bool has_dynamic_reloc;
unsigned int i;
- has_dynamic_reloc = FALSE;
+ has_dynamic_reloc = false;
for (i = 0; i < ARRAY_SIZE (dynamic_relocations); i++)
{
rel_offset = filedata->dynamic_info[dynamic_relocations [i].reloc];
if (rel_size)
- has_dynamic_reloc = TRUE;
+ has_dynamic_reloc = true;
if (is_rela == UNKNOWN)
{
switch (filedata->dynamic_info[DT_PLTREL])
{
case DT_REL:
- is_rela = FALSE;
+ is_rela = false;
break;
case DT_RELA:
- is_rela = TRUE;
+ is_rela = true;
break;
}
}
printf
(_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
name, rel_offset, rel_size);
-
dump_relocations (filedata,
offset_from_vma (filedata, rel_offset, rel_size),
filedata->num_dynamic_syms,
filedata->dynamic_strings,
filedata->dynamic_strings_length,
- is_rela, TRUE /* is_dynamic */);
+ is_rela, true /* is_dynamic */);
}
}
if (is_ia64_vms (filedata))
if (process_ia64_vms_dynamic_relocs (filedata))
- has_dynamic_reloc = TRUE;
+ has_dynamic_reloc = true;
if (! has_dynamic_reloc)
{
{
Elf_Internal_Shdr * section;
unsigned long i;
- bfd_boolean found = FALSE;
+ bool found = false;
for (i = 0, section = filedata->section_headers;
i < filedata->file_header.e_shnum;
else
dump_relocations (filedata, rel_offset, rel_size,
NULL, 0, NULL, 0, is_rela,
- FALSE /* is_dynamic */);
+ false /* is_dynamic */);
- found = TRUE;
+ found = true;
}
}
}
}
- return TRUE;
+ return true;
}
/* An absolute address consists of a section and an offset. If the
unsigned long strtab_size; /* Size of string table. */
};
-static bfd_boolean
+static bool
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;
+ bool res = true;
aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
for (nfuns = 0, j = 0; j < aux->nsyms; j++)
{
warn (_("Invalid section %u in table entry %ld\n"),
tp->info.section, (long) (tp - aux->table));
- res = FALSE;
+ res = false;
continue;
}
offset += filedata->section_headers[tp->info.section].sh_addr;
{
warn (_("Invalid offset %lx in table entry %ld\n"),
(long) tp->info.offset, (long) (tp - aux->table));
- res = FALSE;
+ res = false;
continue;
}
return res;
}
-static bfd_boolean
+static bool
slurp_ia64_unwind_table (Filedata * filedata,
struct ia64_unw_aux_info * aux,
Elf_Internal_Shdr * sec)
if (filedata->file_header.e_phnum)
{
if (! get_program_headers (filedata))
- return FALSE;
+ return false;
for (seg = filedata->program_headers;
seg < filedata->program_headers + filedata->file_header.e_phnum;
table = (unsigned char *) get_data (NULL, filedata, sec->sh_offset, 1, size,
_("unwind table"));
if (!table)
- return FALSE;
+ return false;
aux->table_len = size / (3 * eh_addr_size);
aux->table = (struct ia64_unw_table_entry *)
free (aux->table);
aux->table = NULL;
aux->table_len = 0;
- return FALSE;
+ return false;
}
for (rp = rela; rp < rela + nrelas; ++rp)
continue;
}
- if (! const_strneq (relname, "R_IA64_SEGREL"))
+ if (! startswith (relname, "R_IA64_SEGREL"))
{
warn (_("Skipping unexpected relocation type: %s\n"), relname);
continue;
free (rela);
}
- return TRUE;
+ return true;
}
-static bfd_boolean
+static bool
ia64_process_unwind (Filedata * filedata)
{
Elf_Internal_Shdr * sec;
Elf_Internal_Shdr * unwsec = NULL;
unsigned long i, unwcount = 0, unwstart = 0;
struct ia64_unw_aux_info aux;
- bfd_boolean res = TRUE;
+ bool res = true;
memset (& aux, 0, sizeof (aux));
}
if (!get_symtab (filedata, sec, &aux.symtab, &aux.nsyms,
&aux.strtab, &aux.strtab_size))
- return FALSE;
+ return false;
}
else if (sec->sh_type == SHT_IA_64_UNWIND)
unwcount++;
}
}
else if (SECTION_NAME_VALID (unwsec)
- && strneq (SECTION_NAME (unwsec),
- ELF_STRING_ia64_unwind_once, len))
+ && startswith (SECTION_NAME (unwsec),
+ ELF_STRING_ia64_unwind_once))
{
/* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
len2 = sizeof (ELF_STRING_ia64_unwind_info_once) - 1;
i < filedata->file_header.e_shnum;
++i, ++sec)
if (SECTION_NAME_VALID (sec)
- && strneq (SECTION_NAME (sec),
- ELF_STRING_ia64_unwind_info_once, len2)
+ && startswith (SECTION_NAME (sec),
+ ELF_STRING_ia64_unwind_info_once)
&& streq (SECTION_NAME (sec) + len2, suffix))
break;
}
len2 = sizeof (ELF_STRING_ia64_unwind_info) - 1;
suffix = "";
if (SECTION_NAME_VALID (unwsec)
- && strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind, len))
+ && startswith (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind))
suffix = SECTION_NAME (unwsec) + len;
for (i = 0, sec = filedata->section_headers;
i < filedata->file_header.e_shnum;
++i, ++sec)
if (SECTION_NAME_VALID (sec)
- && strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info, len2)
+ && startswith (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info)
&& streq (SECTION_NAME (sec) + len2, suffix))
break;
}
unsigned long strtab_size; /* Size of string table. */
};
-static bfd_boolean
+static bool
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;
+ bool res = true;
aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
for (nfuns = 0, j = 0; j < aux->nsyms; j++)
return res;
}
-static bfd_boolean
+static bool
slurp_hppa_unwind_table (Filedata * filedata,
struct hppa_unw_aux_info * aux,
Elf_Internal_Shdr * sec)
if (filedata->file_header.e_phnum)
{
if (! get_program_headers (filedata))
- return FALSE;
+ return false;
for (seg = filedata->program_headers;
seg < filedata->program_headers + filedata->file_header.e_phnum;
table = (unsigned char *) get_data (NULL, filedata, sec->sh_offset, 1, size,
_("unwind table"));
if (!table)
- return FALSE;
+ return false;
unw_ent_size = 16;
nentries = size / unw_ent_size;
if (!slurp_rela_relocs (filedata, relsec->sh_offset, relsec->sh_size,
& rela, & nrelas))
- return FALSE;
+ return false;
for (rp = rela; rp < rela + nrelas; ++rp)
{
}
/* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
- if (! const_strneq (relname, "R_PARISC_SEGREL"))
+ if (! startswith (relname, "R_PARISC_SEGREL"))
{
warn (_("Skipping unexpected relocation type: %s\n"), relname);
continue;
free (rela);
}
- return TRUE;
+ return true;
}
-static bfd_boolean
+static bool
hppa_process_unwind (Filedata * filedata)
{
struct hppa_unw_aux_info aux;
Elf_Internal_Shdr * unwsec = NULL;
Elf_Internal_Shdr * sec;
unsigned long i;
- bfd_boolean res = TRUE;
+ bool res = true;
if (filedata->string_table == NULL)
- return FALSE;
+ return false;
memset (& aux, 0, sizeof (aux));
}
if (!get_symtab (filedata, sec, &aux.symtab, &aux.nsyms,
&aux.strtab, &aux.strtab_size))
- return FALSE;
+ return false;
}
else if (SECTION_NAME_VALID (sec)
&& streq (SECTION_NAME (sec), ".PARISC.unwind"))
num_unwind);
if (! slurp_hppa_unwind_table (filedata, &aux, sec))
- res = FALSE;
+ res = false;
if (res && aux.table_len > 0)
{
if (! dump_hppa_unwind (filedata, &aux))
- res = FALSE;
+ res = false;
}
free ((char *) aux.table);
reloc was applied store -1 there.
5) Return TRUE upon success, FALSE otherwise. */
-static bfd_boolean
+static bool
get_unwind_section_word (Filedata * filedata,
struct arm_unw_aux_info * aux,
struct arm_section * arm_sec,
Elf_Internal_Sym *sym;
const char * relname;
unsigned int word;
- bfd_boolean wrapped;
+ bool wrapped;
if (sec == NULL || arm_sec == NULL)
- return FALSE;
+ return false;
addr->section = SHN_UNDEF;
addr->offset = 0;
if (!slurp_rel_relocs (aux->filedata, relsec->sh_offset,
relsec->sh_size,
& arm_sec->rela, & arm_sec->nrelas))
- return FALSE;
+ return false;
}
else /* relsec->sh_type == SHT_RELA */
{
if (!slurp_rela_relocs (aux->filedata, relsec->sh_offset,
relsec->sh_size,
& arm_sec->rela, & arm_sec->nrelas))
- return FALSE;
+ return false;
}
break;
}
/* If there is no unwind data we can do nothing. */
if (arm_sec->data == NULL)
- return FALSE;
+ return false;
/* If the offset is invalid then fail. */
if (/* PR 21343 *//* PR 18879 */
sec->sh_size < 4
|| word_offset > (sec->sh_size - 4)
|| ((bfd_signed_vma) word_offset) < 0)
- return FALSE;
+ return false;
/* Get the word at the required offset. */
word = byte_get (arm_sec->data + word_offset, 4);
if (arm_sec->rela == NULL)
{
* wordp = word;
- return TRUE;
+ return true;
}
/* Look through the relocs to find the one that applies to the provided offset. */
- wrapped = FALSE;
+ wrapped = false;
for (rp = arm_sec->next_rela; rp != arm_sec->rela + arm_sec->nrelas; rp++)
{
bfd_vma prelval, offset;
if (rp->r_offset > word_offset && !wrapped)
{
rp = arm_sec->rela;
- wrapped = TRUE;
+ wrapped = true;
}
if (rp->r_offset > word_offset)
break;
*wordp = word;
arm_sec->next_rela = rp;
- return TRUE;
+ return true;
}
static const char *tic6x_unwind_regnames[16] =
data_offset += 4; \
if (! get_unwind_section_word (filedata, aux, data_arm_sec, data_sec, \
data_offset, & word, & addr, NULL)) \
- return FALSE; \
+ return false; \
remaining = 4; \
more_words--; \
} \
else \
{ \
printf (_("[Truncated opcode]\n")); \
- return FALSE; \
+ return false; \
} \
printf ("0x%02x ", OP)
-static bfd_boolean
+static bool
decode_arm_unwind_bytecode (Filedata * filedata,
struct arm_unw_aux_info * aux,
unsigned int word,
struct arm_section * data_arm_sec)
{
struct absaddr addr;
- bfd_boolean res = TRUE;
+ bool res = true;
/* Decode the unwinding instructions. */
while (1)
else
{
unsigned int mask = ((op & 0x0f) << 8) | op2;
- bfd_boolean first = TRUE;
+ bool first = true;
int i;
printf ("pop {");
if (mask & (1 << i))
{
if (first)
- first = FALSE;
+ first = false;
else
printf (", ");
printf ("r%d", 4 + i);
else if ((op & 0xf0) == 0xa0)
{
int end = 4 + (op & 0x07);
- bfd_boolean first = TRUE;
+ bool first = true;
int i;
printf (" pop {");
for (i = 4; i <= end; i++)
{
if (first)
- first = FALSE;
+ first = false;
else
printf (", ");
printf ("r%d", i);
else
{
unsigned int mask = op2 & 0x0f;
- bfd_boolean first = TRUE;
+ bool first = true;
int i;
printf ("pop {");
if (mask & (1 << i))
{
if (first)
- first = FALSE;
+ first = false;
else
printf (", ");
printf ("r%d", i);
if (i == sizeof (buf))
{
error (_("corrupt change to vsp\n"));
- res = FALSE;
+ res = false;
}
else
{
- offset = read_leb128 (buf, buf + i + 1, FALSE, &len, NULL);
+ 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;
- bfd_boolean first = TRUE;
+ bool first = true;
int i;
printf ("pop {");
if (mask & (1 << i))
{
if (first)
- first = FALSE;
+ first = false;
else
printf (", ");
printf ("wCGR%d", i);
else
{
printf (_(" [unsupported opcode]"));
- res = FALSE;
+ res = false;
}
printf ("\n");
return res;
}
-static bfd_boolean
+static bool
decode_tic6x_unwind_bytecode (Filedata * filedata,
struct arm_unw_aux_info * aux,
unsigned int word,
if (i == sizeof (buf))
{
warn (_("Corrupt stack pointer adjustment detected\n"));
- return FALSE;
+ return false;
}
- offset = read_leb128 (buf, buf + i + 1, FALSE, &len, NULL);
+ 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;
+ return true;
}
static bfd_vma
return offset + where;
}
-static bfd_boolean
+static bool
decode_arm_unwind (Filedata * filedata,
struct arm_unw_aux_info * aux,
unsigned int word,
unsigned int more_words = 0;
struct absaddr addr;
bfd_vma sym_name = (bfd_vma) -1;
- bfd_boolean res = TRUE;
+ bool res = true;
if (remaining == 0)
{
the personality routine. */
if (! get_unwind_section_word (filedata, aux, data_arm_sec, data_sec, data_offset,
& word, & addr, & sym_name))
- return FALSE;
+ return false;
remaining = 4;
}
encoding, starting with one byte giving the number of
words. */
if (procname != NULL
- && (const_strneq (procname, "__gcc_personality_v0")
- || const_strneq (procname, "__gxx_personality_v0")
- || const_strneq (procname, "__gcj_personality_v0")
- || const_strneq (procname, "__gnu_objc_personality_v0")))
+ && (startswith (procname, "__gcc_personality_v0")
+ || startswith (procname, "__gxx_personality_v0")
+ || startswith (procname, "__gcj_personality_v0")
+ || startswith (procname, "__gnu_objc_personality_v0")))
{
remaining = 0;
more_words = 1;
if (!remaining)
{
printf (_(" [Truncated data]\n"));
- return FALSE;
+ return false;
}
more_words = word >> 24;
word <<= 8;
per_index = -1;
}
else
- return TRUE;
+ return true;
}
else
{
&& (word & 0x70000000))
{
warn (_("Corrupt ARM compact model table entry: %x \n"), word);
- res = FALSE;
+ res = false;
}
per_index = (word >> 24) & 0x7f;
{
if (! decode_arm_unwind_bytecode (filedata, aux, word, remaining, more_words,
data_offset, data_sec, data_arm_sec))
- res = FALSE;
+ res = false;
}
else
{
warn (_("Unknown ARM compact model index encountered\n"));
printf (_(" [reserved]\n"));
- res = FALSE;
+ res = false;
}
break;
{
if (! decode_tic6x_unwind_bytecode (filedata, aux, word, remaining, more_words,
data_offset, data_sec, data_arm_sec))
- res = FALSE;
+ res = false;
}
else if (per_index < 5)
{
default:
error (_("Unsupported architecture type %d encountered when decoding unwind table\n"),
filedata->file_header.e_machine);
- res = FALSE;
+ res = false;
}
/* Decode the descriptors. Not implemented. */
return res;
}
-static bfd_boolean
+static bool
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;
+ bool 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 FALSE;
+ return false;
}
/* ARM EHABI, Section 5:
if (exidx_fn & 0x80000000)
{
warn (_("corrupt index table entry: %x\n"), exidx_fn);
- res = FALSE;
+ res = false;
}
fn = arm_expand_prel31 (filedata, 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 (filedata, table_sec));
- res = FALSE;
+ res = false;
continue;
}
}
{
warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
(unsigned long) table);
- res = FALSE;
+ res = false;
continue;
}
if (! decode_arm_unwind (filedata, aux, 0, 0, table_offset, table_sec,
&extab_arm_sec))
- res = FALSE;
+ res = false;
}
}
/* Used for both ARM and C6X unwinding tables. */
-static bfd_boolean
+static bool
arm_process_unwind (Filedata * filedata)
{
struct arm_unw_aux_info aux;
Elf_Internal_Shdr *sec;
unsigned long i;
unsigned int sec_type;
- bfd_boolean res = TRUE;
+ bool res = true;
switch (filedata->file_header.e_machine)
{
default:
error (_("Unsupported architecture type %d encountered when processing unwind table\n"),
filedata->file_header.e_machine);
- return FALSE;
+ return false;
}
if (filedata->string_table == NULL)
- return FALSE;
+ return false;
memset (& aux, 0, sizeof (aux));
aux.filedata = filedata;
}
if (!get_symtab (filedata, sec, &aux.symtab, &aux.nsyms,
&aux.strtab, &aux.strtab_size))
- return FALSE;
+ return false;
}
else if (sec->sh_type == sec_type)
unwsec = sec;
num_unwind);
if (! dump_arm_unwind (filedata, &aux, sec))
- res = FALSE;
+ res = false;
}
}
return res;
}
-static bfd_boolean
+static bool
+no_processor_specific_unwind (Filedata * filedata ATTRIBUTE_UNUSED)
+{
+ printf (_("No processor specific unwind information to decode\n"));
+ return true;
+}
+
+static bool
process_unwind (Filedata * filedata)
{
struct unwind_handler
{
unsigned int machtype;
- bfd_boolean (* handler)(Filedata *);
+ bool (* 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 },
+ { EM_386, no_processor_specific_unwind },
+ { EM_X86_64, no_processor_specific_unwind },
{ 0, NULL }
};
int i;
if (!do_unwind)
- return TRUE;
+ return true;
for (i = 0; handlers[i].handler != NULL; i++)
if (filedata->file_header.e_machine == handlers[i].machtype)
printf (_("\nThe decoding of unwind sections for machine type %s is not currently supported.\n"),
get_machine_name (filedata->file_header.e_machine));
- return TRUE;
+ return true;
}
static void
"RLD_ORDER_SAFE"
};
unsigned int cnt;
- bfd_boolean first = TRUE;
+ bool 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 = FALSE;
+ first = false;
}
}
break;
{ DT_HP_GROUP, "HP_GROUP" },
{ DT_HP_PROTECT_LINKAGE_TABLE, "HP_PROTECT_LINKAGE_TABLE" }
};
- bfd_boolean first = TRUE;
+ bool first = true;
size_t cnt;
bfd_vma val = entry->d_un.d_val;
if (! first)
putchar (' ');
fputs (flags[cnt].str, stdout);
- first = FALSE;
+ first = false;
val ^= flags[cnt].bit;
}
putchar ('\n');
}
-static bfd_boolean
+static bool
get_32bit_dynamic_section (Filedata * filedata)
{
Elf32_External_Dyn * edyn;
filedata->dynamic_size,
_("dynamic section"));
if (!edyn)
- return FALSE;
+ 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) filedata->dynamic_nent);
free (edyn);
- return FALSE;
+ return false;
}
for (ext = edyn, entry = filedata->dynamic_section;
free (edyn);
- return TRUE;
+ return true;
}
-static bfd_boolean
+static bool
get_64bit_dynamic_section (Filedata * filedata)
{
Elf64_External_Dyn * edyn;
filedata->dynamic_size,
_("dynamic section"));
if (!edyn)
- return FALSE;
+ 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) filedata->dynamic_nent);
free (edyn);
- return FALSE;
+ return false;
}
/* Convert from external to internal formats. */
free (edyn);
- return TRUE;
+ return true;
+}
+
+static bool
+get_dynamic_section (Filedata *filedata)
+{
+ if (filedata->dynamic_section)
+ return true;
+
+ if (is_32bit_elf)
+ return get_32bit_dynamic_section (filedata);
+ else
+ return get_64bit_dynamic_section (filedata);
}
static void
print_dynamic_flags (bfd_vma flags)
{
- bfd_boolean first = TRUE;
+ bool first = true;
while (flags)
{
flags &= ~ flag;
if (first)
- first = FALSE;
+ first = false;
else
putc (' ', stdout);
/* Parse and display the contents of the dynamic section. */
-static bfd_boolean
+static bool
process_dynamic_section (Filedata * filedata)
{
Elf_Internal_Dyn * entry;
printf (_("\nThere is no dynamic section in this file.\n"));
}
- return TRUE;
+ return true;
}
- if (is_32bit_elf)
- {
- if (! get_32bit_dynamic_section (filedata))
- return FALSE;
- }
- else
- {
- if (! get_64bit_dynamic_section (filedata))
- return FALSE;
- }
+ if (!get_dynamic_section (filedata))
+ return false;
/* Find the appropriate symbol table. */
if (filedata->dynamic_symbols == NULL || do_histogram)
{
error (_("Cannot interpret virtual addresses "
"without program headers.\n"));
- return FALSE;
+ return false;
}
for (seg = filedata->program_headers;
{
/* See PR 21379 for a reproducer. */
error (_("Invalid PT_LOAD entry\n"));
- return FALSE;
+ return false;
}
if (vma >= (seg->p_vaddr & -seg->p_align)
section.sh_name = filedata->string_table_length;
filedata->dynamic_symbols
- = GET_ELF_SYMBOLS (filedata, §ion,
+ = get_elf_symbols (filedata, §ion,
&filedata->num_dynamic_syms);
if (filedata->dynamic_symbols == NULL
|| filedata->num_dynamic_syms != num_of_syms)
{
error (_("Corrupt DT_SYMTAB dynamic entry\n"));
- return FALSE;
+ return false;
}
break;
}
get_data (NULL, filedata, filedata->dynamic_syminfo_offset,
1, syminsz, _("symbol information"));
if (!extsyminfo)
- return FALSE;
+ return false;
if (filedata->dynamic_syminfo != NULL)
{
error (_("Out of memory allocating %lu bytes "
"for dynamic symbol info\n"),
(unsigned long) syminsz);
- return FALSE;
+ return false;
}
filedata->dynamic_syminfo_nent
case DT_NEEDED:
printf (_("Shared library: [%s]"), name);
- if (streq (name, filedata->program_interpreter))
+ if (filedata->program_interpreter
+ && streq (name, filedata->program_interpreter))
printf (_(" program interpreter"));
break;
}
}
- return TRUE;
+ return true;
}
static char *
/* Display the contents of the version sections. */
-static bfd_boolean
+static bool
process_version_sections (Filedata * filedata)
{
Elf_Internal_Shdr * section;
unsigned i;
- bfd_boolean found = FALSE;
+ bool found = false;
if (! do_version)
- return TRUE;
+ return true;
for (i = 0, section = filedata->section_headers;
i < filedata->file_header.e_shnum;
unsigned long cnt;
char * endbuf;
- found = TRUE;
+ found = true;
if (filedata->is_separate)
printf (ngettext ("\nIn linked file '%s' the version definition section '%s' contains %u entry:\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 cnt;
char * endbuf;
- found = TRUE;
+ found = true;
if (filedata->is_separate)
printf (ngettext ("\nIn linked file '%s' the version needs section '%s' contains %u entry:\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"),
if (link_section->sh_link >= filedata->file_header.e_shnum)
break;
- found = TRUE;
+ found = true;
- symbols = GET_ELF_SYMBOLS (filedata, link_section, & num_syms);
+ symbols = get_elf_symbols (filedata, link_section, & num_syms);
if (symbols == NULL)
break;
printf (_("\nNo version information found in this file.\n"));
}
- return TRUE;
+ return true;
}
static const char *
static const char *
get_symbol_version_string (Filedata * filedata,
- bfd_boolean is_dynsym,
+ bool is_dynsym,
const char * strtab,
unsigned long int strtab_size,
unsigned int si,
return NULL;
}
+/* Display a symbol size on stdout. Format is based on --sym-base setting. */
+
+static unsigned int
+print_dynamic_symbol_size (bfd_vma vma, int base)
+{
+ switch (base)
+ {
+ case 8:
+ return print_vma (vma, OCTAL_5);
+
+ case 10:
+ return print_vma (vma, UNSIGNED_5);
+
+ case 16:
+ return print_vma (vma, PREFIX_HEX_5);
+
+ case 0:
+ default:
+ return print_vma (vma, DEC_5);
+ }
+}
+
static void
print_dynamic_symbol (Filedata *filedata, unsigned long si,
Elf_Internal_Sym *symtab,
const char *version_string;
enum versioned_symbol_info sym_info;
unsigned short vna_other;
+ bool is_valid;
+ const char * sstr;
Elf_Internal_Sym *psym = symtab + si;
printf ("%6ld: ", si);
print_vma (psym->st_value, LONG_HEX);
putchar (' ');
- print_vma (psym->st_size, DEC_5);
+ print_dynamic_symbol_size (psym->st_size, sym_base);
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 (" %4s ", get_symbol_index_type (filedata, psym->st_shndx));
- bfd_boolean is_valid = VALID_SYMBOL_NAME (strtab, strtab_size,
- psym->st_name);
- const char * sstr = is_valid ? strtab + psym->st_name : _("<corrupt>");
+ if (ELF_ST_TYPE (psym->st_info) == STT_SECTION
+ && psym->st_shndx < filedata->file_header.e_shnum
+ && psym->st_name == 0)
+ {
+ is_valid = SECTION_NAME_VALID (filedata->section_headers + psym->st_shndx);
+ sstr = is_valid ?
+ SECTION_NAME_PRINT (filedata->section_headers + psym->st_shndx)
+ : _("<corrupt>");
+ }
+ else
+ {
+ is_valid = VALID_SYMBOL_NAME (strtab, strtab_size, psym->st_name);
+ sstr = is_valid ? strtab + psym->st_name : _("<corrupt>");
+ }
version_string
= get_symbol_version_string (filedata,
FIXME: The format of LTO symbol tables is not formalized.
So this code could need changing in the future. */
-static bfd_boolean
+static bool
display_lto_symtab (Filedata * filedata,
Elf_Internal_Shdr * section)
{
else
printf (_("\nLTO Symbol table '%s' is empty!\n"),
printable_section_name (filedata, section));
-
- return TRUE;
+
+ return true;
}
if (section->sh_size > filedata->file_size)
error (_("Section %s has an invalid sh_size of 0x%lx\n"),
printable_section_name (filedata, section),
(unsigned long) section->sh_size);
- return FALSE;
+ return false;
}
void * alloced_data = get_data (NULL, filedata, section->sh_offset,
section->sh_size, 1, _("LTO symbols"));
if (alloced_data == NULL)
- return FALSE;
+ return false;
/* Look for extended data for the symbol table. */
Elf_Internal_Shdr * ext;
free (alloced_data);
free (ext_data_orig);
free (ext_name);
- return TRUE;
+ return true;
fail:
error (_("Buffer overrun encountered whilst decoding LTO symbol table\n"));
free (alloced_data);
free (ext_data_orig);
free (ext_name);
- return FALSE;
+ return false;
}
/* Display LTO symbol tables. */
-static bfd_boolean
+static bool
process_lto_symbol_tables (Filedata * filedata)
{
Elf_Internal_Shdr * section;
unsigned int i;
- bfd_boolean res = TRUE;
+ bool res = true;
if (!do_lto_syms)
- return TRUE;
+ return true;
if (filedata->section_headers == NULL)
- return TRUE;
+ return true;
for (i = 0, section = filedata->section_headers;
i < filedata->file_header.e_shnum;
i++, section++)
if (SECTION_NAME_VALID (section)
- && CONST_STRNEQ (SECTION_NAME (section), ".gnu.lto_.symtab."))
+ && startswith (SECTION_NAME (section), ".gnu.lto_.symtab."))
res &= display_lto_symtab (filedata, section);
return res;
/* Dump the symbol table. */
-static bfd_boolean
+static bool
process_symbol_table (Filedata * filedata)
{
Elf_Internal_Shdr * section;
if (!do_syms && !do_dyn_syms && !do_histogram)
- return TRUE;
+ return true;
if ((filedata->dynamic_info[DT_HASH] || filedata->dynamic_info_DT_GNU_HASH)
&& do_syms
else
printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
- symtab = GET_ELF_SYMBOLS (filedata, section, & num_syms);
+ symtab = get_elf_symbols (filedata, section, & num_syms);
if (symtab == NULL)
continue;
filedata->ngnuchains = 0;
free (filedata->mipsxlat);
filedata->mipsxlat = NULL;
- return TRUE;
+ return true;
err_out:
free (filedata->gnubuckets);
filedata->nbuckets = 0;
free (filedata->chains);
filedata->chains = NULL;
- return FALSE;
+ return false;
}
-static bfd_boolean
+static bool
process_syminfo (Filedata * filedata)
{
unsigned int i;
if (filedata->dynamic_syminfo == NULL
|| !do_dynamic)
/* No syminfo, this is ok. */
- return TRUE;
+ return true;
/* There better should be a dynamic symbol section. */
if (filedata->dynamic_symbols == NULL || filedata->dynamic_strings == NULL)
- return FALSE;
+ return false;
if (filedata->is_separate)
printf (ngettext ("\nIn linked file '%s: the dynamic info segment at offset 0x%lx contains %d entry:\n",
puts ("");
}
- return TRUE;
+ return true;
}
/* A macro which evaluates to TRUE if the region ADDR .. ADDR + NELEM
for the current section has finished, and any saved state should be
discarded. */
-static bfd_boolean
+static bool
target_specific_reloc_handling (Filedata * filedata,
Elf_Internal_Rela * reloc,
unsigned char * start,
if (reloc == NULL)
{
saved_sym = NULL;
- return TRUE;
+ return true;
}
switch (reloc_type)
sym_index);
else
saved_sym = symtab + sym_index;
- return TRUE;
+ return true;
case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
case 3: /* R_MSP430_16 or R_MSP430_ABS8 */
case 11: /* R_MSP430_GNU_SET_ULEB128 */
case 22: /* R_MSP430X_GNU_SET_ULEB128 */
if (reloc->r_offset < (size_t) (end - start))
- read_leb128 (start + reloc->r_offset, end, FALSE,
+ read_leb128 (start + reloc->r_offset, end, false,
&reloc_size, &leb_ret);
break;
default:
}
saved_sym = NULL;
- return TRUE;
+ return true;
}
break;
if (reloc == NULL)
{
saved_sym = NULL;
- return TRUE;
+ return true;
}
switch (reloc_type)
{
case 34: /* R_MN10300_ALIGN */
- return TRUE;
+ return true;
case 33: /* R_MN10300_SYM_DIFF */
if (sym_index >= num_syms)
error (_("MN10300_SYM_DIFF reloc contains invalid symbol index %lu\n"),
sym_index);
else
saved_sym = symtab + sym_index;
- return TRUE;
+ return true;
case 1: /* R_MN10300_32 */
case 2: /* R_MN10300_16 */
}
saved_sym = NULL;
- return TRUE;
+ return true;
}
break;
default:
if (reloc == NULL)
{
saved_sym1 = saved_sym2 = 0;
- return TRUE;
+ return true;
}
switch (reloc_type)
saved_sym2 = symtab[sym_index].st_value;
saved_sym2 += reloc->r_addend;
}
- return TRUE;
+ return true;
case 0x83: /* R_RL78_OPsub. */
value = saved_sym1 - saved_sym2;
saved_sym2 = saved_sym1 = 0;
- return TRUE;
+ return true;
break;
case 0x41: /* R_RL78_ABS32. */
error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
(long) reloc->r_offset);
value = 0;
- return TRUE;
+ return true;
case 0x43: /* R_RL78_ABS16. */
if (IN_RANGE (start, end, start + reloc->r_offset, 2))
error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
(long) reloc->r_offset);
value = 0;
- return TRUE;
+ return true;
default:
break;
}
}
- return FALSE;
+ return false;
}
/* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
the reloc-macros.h header, in the same way that it already creates the
reloc naming functions. */
-static bfd_boolean
+static bool
is_32bit_abs_reloc (Filedata * filedata, unsigned int reloc_type)
{
/* Please keep this table alpha-sorted for ease of visual lookup. */
error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
filedata->file_header.e_machine);
prev_warn = filedata->file_header.e_machine;
- return FALSE;
+ return false;
}
}
}
/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
-static bfd_boolean
+static bool
is_32bit_pcrel_reloc (Filedata * filedata, unsigned int reloc_type)
{
switch (filedata->file_header.e_machine)
have already tested for target coverage in is_32bit_abs_reloc. A
more helpful warning message will be generated by apply_relocations
anyway, so just return. */
- return FALSE;
+ return false;
}
}
/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
a 64-bit absolute RELA relocation used in DWARF debug sections. */
-static bfd_boolean
+static bool
is_64bit_abs_reloc (Filedata * filedata, unsigned int reloc_type)
{
switch (filedata->file_header.e_machine)
case EM_MIPS:
return reloc_type == 18; /* R_MIPS_64. */
default:
- return FALSE;
+ return false;
}
}
/* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
a 64-bit pc-relative RELA relocation used in DWARF debug sections. */
-static bfd_boolean
+static bool
is_64bit_pcrel_reloc (Filedata * filedata, unsigned int reloc_type)
{
switch (filedata->file_header.e_machine)
case EM_TILEGX:
return reloc_type == 5; /* R_TILEGX_64_PCREL. */
default:
- return FALSE;
+ return false;
}
}
/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
a 24-bit absolute RELA relocation used in DWARF debug sections. */
-static bfd_boolean
+static bool
is_24bit_abs_reloc (Filedata * filedata, unsigned int reloc_type)
{
switch (filedata->file_header.e_machine)
case EM_Z80:
return reloc_type == 5; /* R_Z80_24. */
default:
- return FALSE;
+ return false;
}
}
/* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
a 16-bit absolute RELA relocation used in DWARF debug sections. */
-static bfd_boolean
+static bool
is_16bit_abs_reloc (Filedata * filedata, unsigned int reloc_type)
{
/* Please keep this table alpha-sorted for ease of visual lookup. */
case EM_Z80:
return reloc_type == 4; /* R_Z80_16. */
default:
- return FALSE;
+ 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
+static bool
is_8bit_abs_reloc (Filedata * filedata, unsigned int reloc_type)
{
switch (filedata->file_header.e_machine)
case EM_Z80:
return reloc_type == 1; /* R_Z80_8. */
default:
- return FALSE;
+ 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
+static bool
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;
+ 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
+static bool
is_32bit_inplace_add_reloc (Filedata * filedata, unsigned int reloc_type)
{
/* Please keep this table alpha-sorted for ease of visual lookup. */
case EM_RISCV:
return reloc_type == 35; /* R_RISCV_ADD32. */
default:
- return FALSE;
+ 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
+static bool
is_32bit_inplace_sub_reloc (Filedata * filedata, unsigned int reloc_type)
{
/* Please keep this table alpha-sorted for ease of visual lookup. */
case EM_RISCV:
return reloc_type == 39; /* R_RISCV_SUB32. */
default:
- return FALSE;
+ 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
+static bool
is_64bit_inplace_add_reloc (Filedata * filedata, unsigned int reloc_type)
{
/* Please keep this table alpha-sorted for ease of visual lookup. */
case EM_RISCV:
return reloc_type == 36; /* R_RISCV_ADD64. */
default:
- return FALSE;
+ 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
+static bool
is_64bit_inplace_sub_reloc (Filedata * filedata, unsigned int reloc_type)
{
/* Please keep this table alpha-sorted for ease of visual lookup. */
case EM_RISCV:
return reloc_type == 40; /* R_RISCV_SUB64. */
default:
- return FALSE;
+ 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
+static bool
is_16bit_inplace_add_reloc (Filedata * filedata, unsigned int reloc_type)
{
/* Please keep this table alpha-sorted for ease of visual lookup. */
case EM_RISCV:
return reloc_type == 34; /* R_RISCV_ADD16. */
default:
- return FALSE;
+ 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
+static bool
is_16bit_inplace_sub_reloc (Filedata * filedata, unsigned int reloc_type)
{
/* Please keep this table alpha-sorted for ease of visual lookup. */
case EM_RISCV:
return reloc_type == 38; /* R_RISCV_SUB16. */
default:
- return FALSE;
+ 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
+static bool
is_8bit_inplace_add_reloc (Filedata * filedata, unsigned int reloc_type)
{
/* Please keep this table alpha-sorted for ease of visual lookup. */
case EM_RISCV:
return reloc_type == 33; /* R_RISCV_ADD8. */
default:
- return FALSE;
+ 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
+static bool
is_8bit_inplace_sub_reloc (Filedata * filedata, unsigned int reloc_type)
{
/* Please keep this table alpha-sorted for ease of visual lookup. */
case EM_RISCV:
return reloc_type == 37; /* R_RISCV_SUB8. */
default:
- return FALSE;
+ 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
+static bool
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;
+ return false;
}
}
/* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
relocation entries (possibly formerly used for SHT_GROUP sections). */
-static bfd_boolean
+static bool
is_none_reloc (Filedata * filedata, unsigned int reloc_type)
{
switch (filedata->file_header.e_machine)
|| reloc_type == 61 /* R_XTENSA_NDIFF16. */
|| reloc_type == 62 /* R_XTENSA_NDIFF32. */);
}
- return FALSE;
+ return false;
}
/* Returns TRUE if there is a relocation against
section NAME at OFFSET bytes. */
-bfd_boolean
+bool
reloc_at (struct dwarf_section * dsec, dwarf_vma offset)
{
Elf_Internal_Rela * relocs;
Elf_Internal_Rela * rp;
if (dsec == NULL || dsec->reloc_info == NULL)
- return FALSE;
+ return false;
relocs = (Elf_Internal_Rela *) dsec->reloc_info;
for (rp = relocs; rp < relocs + dsec->num_relocs; ++rp)
if (rp->r_offset == offset)
- return TRUE;
+ return true;
- return FALSE;
+ return false;
}
/* Apply relocations to a section.
which can be found in debug sections. FIXME: Add support for
more relocations ? */
-static bfd_boolean
+static bool
apply_relocations (Filedata * filedata,
const Elf_Internal_Shdr * section,
unsigned char * start,
if (filedata->file_header.e_type != ET_REL)
/* No relocs to apply. */
- return TRUE;
+ return true;
/* Find the reloc section associated with the section. */
for (relsec = filedata->section_headers;
relsec < filedata->section_headers + filedata->file_header.e_shnum;
++relsec)
{
- bfd_boolean is_rela;
+ bool is_rela;
unsigned long num_relocs;
Elf_Internal_Rela * relocs;
Elf_Internal_Rela * rp;
symsec = filedata->section_headers + relsec->sh_link;
if (symsec->sh_type != SHT_SYMTAB
&& symsec->sh_type != SHT_DYNSYM)
- return FALSE;
+ return false;
is_rela = relsec->sh_type == SHT_RELA;
{
if (!slurp_rela_relocs (filedata, relsec->sh_offset,
relsec->sh_size, & relocs, & num_relocs))
- return FALSE;
+ return false;
}
else
{
if (!slurp_rel_relocs (filedata, relsec->sh_offset,
relsec->sh_size, & relocs, & num_relocs))
- return FALSE;
+ return false;
}
/* SH uses RELA but uses in place value instead of the addend field. */
if (filedata->file_header.e_machine == EM_SH)
- is_rela = FALSE;
+ is_rela = false;
- symtab = GET_ELF_SYMBOLS (filedata, symsec, & num_syms);
+ 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;
+ bfd_vma addend;
+ unsigned int reloc_type;
+ unsigned int reloc_size;
+ bool reloc_inplace = false;
+ bool reloc_subtract = false;
+ unsigned char *rloc;
+ unsigned long sym_index;
reloc_type = get_reloc_type (filedata, rp->r_info);
|| is_32bit_inplace_add_reloc (filedata, reloc_type))
{
reloc_size = 4;
- reloc_inplace = TRUE;
+ 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;
+ 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;
+ 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;
+ reloc_inplace = true;
}
else if ((reloc_subtract = is_6bit_inplace_sub_reloc (filedata,
reloc_type)))
{
reloc_size = 1;
- reloc_inplace = TRUE;
+ reloc_inplace = true;
}
else
{
break;
}
- return TRUE;
+ return true;
}
#ifdef SUPPORT_DISASSEMBLY
-static bfd_boolean
+static bool
disassemble_section (Elf_Internal_Shdr * section, Filedata * filedata)
{
printf (_("\nAssembly dump of section %s\n"), printable_section_name (filedata, section));
/* FIXME: XXX -- to be done --- XXX */
- return TRUE;
+ return true;
}
#endif
/* Uncompresses a section that was compressed using zlib, in place. */
-static bfd_boolean
+static bool
uncompress_section_contents (unsigned char ** buffer,
dwarf_size_type uncompressed_size,
dwarf_size_type * size)
*buffer = uncompressed_buffer;
*size = uncompressed_size;
- return TRUE;
+ return true;
fail:
free (uncompressed_buffer);
/* Indicate decompression failure. */
*buffer = NULL;
- return FALSE;
+ return false;
}
-static bfd_boolean
+static bool
dump_section_as_strings (Elf_Internal_Shdr * section, Filedata * filedata)
{
- Elf_Internal_Shdr * relsec;
- bfd_size_type num_bytes;
- unsigned char * data;
- unsigned char * end;
- unsigned char * real_start;
- unsigned char * start;
- bfd_boolean some_strings_shown;
+ Elf_Internal_Shdr *relsec;
+ bfd_size_type num_bytes;
+ unsigned char *data;
+ unsigned char *end;
+ unsigned char *real_start;
+ unsigned char *start;
+ bool some_strings_shown;
real_start = start = (unsigned char *) get_section_contents (section, filedata);
if (start == NULL)
/* PR 21820: Do not fail if the section was empty. */
- return (section->sh_size == 0 || section->sh_type == SHT_NOBITS) ? TRUE : FALSE;
+ return section->sh_size == 0 || section->sh_type == SHT_NOBITS;
num_bytes = section->sh_size;
- printf (_("\nString dump of section '%s':\n"), printable_section_name (filedata, section));
+ if (filedata->is_separate)
+ printf (_("\nString dump of section '%s' in linked file %s:\n"),
+ printable_section_name (filedata, section),
+ filedata->file_name);
+ else
+ printf (_("\nString dump of section '%s':\n"),
+ printable_section_name (filedata, section));
if (decompress_dumps)
{
data = start;
end = start + num_bytes;
- some_strings_shown = FALSE;
+ some_strings_shown = false;
#ifdef HAVE_MBSTATE_T
mbstate_t state;
memset (& state, 0, sizeof (state));
#endif
- bfd_boolean continuing = FALSE;
+ bool continuing = false;
while (data < end)
{
if (continuing)
{
printf (" ");
- continuing = FALSE;
+ continuing = false;
}
else
{
{
printf ("\\n\n");
if (*data != 0)
- continuing = TRUE;
+ continuing = true;
break;
}
printf (_("<corrupt>\n"));
data = end;
}
- some_strings_shown = TRUE;
+ some_strings_shown = true;
}
}
free (real_start);
putchar ('\n');
- return TRUE;
+ return true;
error_out:
free (real_start);
- return FALSE;
+ return false;
}
-static bfd_boolean
-dump_section_as_bytes (Elf_Internal_Shdr * section,
- Filedata * filedata,
- bfd_boolean relocate)
+static bool
+dump_section_as_bytes (Elf_Internal_Shdr *section,
+ Filedata *filedata,
+ bool relocate)
{
Elf_Internal_Shdr * relsec;
bfd_size_type bytes;
real_start = start = (unsigned char *) get_section_contents (section, filedata);
if (start == NULL)
/* PR 21820: Do not fail if the section was empty. */
- return (section->sh_size == 0 || section->sh_type == SHT_NOBITS) ? TRUE : FALSE;
+ return section->sh_size == 0 || section->sh_type == SHT_NOBITS;
section_size = section->sh_size;
- printf (_("\nHex dump of section '%s':\n"), printable_section_name (filedata, section));
+ if (filedata->is_separate)
+ printf (_("\nHex dump of section '%s' in linked file %s:\n"),
+ printable_section_name (filedata, section),
+ filedata->file_name);
+ else
+ printf (_("\nHex dump of section '%s':\n"),
+ printable_section_name (filedata, section));
if (decompress_dumps)
{
free (real_start);
putchar ('\n');
- return TRUE;
+ return true;
error_out:
free (real_start);
- return FALSE;
+ return false;
}
#ifdef ENABLE_LIBCTF
return err;
}
-static bfd_boolean
+static bool
dump_section_as_ctf (Elf_Internal_Shdr * section, Filedata * filedata)
{
Elf_Internal_Shdr * parent_sec = NULL;
ctf_dict_t * parent = NULL;
int err;
- bfd_boolean ret = FALSE;
+ bool ret = false;
shdr_to_ctf_sect (&ctfsect, section, filedata);
data = get_section_contents (section, filedata);
symsectp = shdr_to_ctf_sect (&symsect, symtab_sec, filedata);
symsect.cts_data = symdata;
}
+
if (dump_ctf_strtab_name && dump_ctf_strtab_name[0] != 0)
{
if ((strtab_sec = find_section (filedata, dump_ctf_strtab_name)) == NULL)
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)
goto fail;
}
- ret = TRUE;
+ ret = true;
- printf (_("\nDump of CTF section '%s':\n"),
- printable_section_name (filedata, section));
+ if (filedata->is_separate)
+ printf (_("\nDump of CTF section '%s' in linked file %s:\n"),
+ printable_section_name (filedata, section),
+ filedata->file_name);
+ else
+ printf (_("\nDump of CTF section '%s':\n"),
+ printable_section_name (filedata, section));
if ((err = ctf_archive_iter (ctfa, dump_ctf_archive_member, parent)) != 0)
{
dump_ctf_errs (NULL);
error (_("CTF member open failure: %s\n"), ctf_errmsg (err));
- ret = FALSE;
+ ret = false;
}
fail:
}
#endif
-static bfd_boolean
+static bool
load_specific_debug_section (enum dwarf_section_display_enum debug,
const Elf_Internal_Shdr * sec,
void * data)
{
/* If it is already loaded, do nothing. */
if (streq (section->filename, filedata->file_name))
- return TRUE;
+ return true;
free (section->start);
}
{
warn (_("compressed section %s is too small to contain a compression header\n"),
section->name);
- return FALSE;
+ return false;
}
compression_header_size = get_compression_header (&chdr, start, size);
if (compression_header_size == 0)
/* An error message will have already been generated
by get_compression_header. */
- return FALSE;
+ return false;
if (chdr.ch_type != ELFCOMPRESS_ZLIB)
{
warn (_("section '%s' has unsupported compress type: %d\n"),
section->name, chdr.ch_type);
- return FALSE;
+ return false;
}
uncompressed_size = chdr.ch_size;
start += compression_header_size;
{
error (_("Unable to decompress section %s\n"),
printable_section_name (filedata, sec));
- return FALSE;
+ return false;
}
}
}
if (section->start == NULL)
- return FALSE;
+ return false;
if (debug_displays [debug].relocate)
{
if (! apply_relocations (filedata, sec, section->start, section->size,
& section->reloc_info, & section->num_relocs))
- return FALSE;
+ return false;
}
else
{
section->num_relocs = 0;
}
- return TRUE;
+ return true;
}
#if HAVE_LIBDEBUGINFOD
/* Check if this is the build-id note. If so then convert the build-id
bytes to a hex string. */
if (inote.namesz > 0
- && const_strneq (inote.namedata, "GNU")
+ && startswith (inote.namedata, "GNU")
&& inote.type == NT_GNU_BUILD_ID)
{
unsigned long j;
within the list of sections given here. */
static unsigned int * section_subset = NULL;
-bfd_boolean
+bool
load_debug_section (enum dwarf_section_display_enum debug, void * data)
{
struct dwarf_section * section = &debug_displays [debug].section;
/* Without section headers we cannot find any sections. */
if (filedata->section_headers == NULL)
- return FALSE;
+ return false;
if (filedata->string_table == NULL
&& filedata->file_header.e_shstrndx != SHN_UNDEF
section->name = section->compressed_name;
}
if (sec == NULL)
- return FALSE;
+ 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->num_relocs = 0;
}
-static bfd_boolean
+static bool
display_debug_section (int shndx, Elf_Internal_Shdr * section, Filedata * filedata)
{
char * name = SECTION_NAME_VALID (section) ? SECTION_NAME (section) : "";
const char * print_name = printable_section_name (filedata, section);
bfd_size_type length;
- bfd_boolean result = TRUE;
+ bool result = true;
int i;
length = section->sh_size;
if (length == 0)
{
printf (_("\nSection '%s' has no debugging data.\n"), print_name);
- return TRUE;
+ 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 FALSE;
+ return false;
}
- if (const_strneq (name, ".gnu.linkonce.wi."))
+ if (startswith (name, ".gnu.linkonce.wi."))
name = ".debug_info";
/* See if we know how to display the contents of this section. */
struct dwarf_section * sec = & display->section;
if (streq (sec->uncompressed_name, name)
- || (id == line && const_strneq (name, ".debug_line."))
+ || (id == line && startswith (name, ".debug_line."))
|| streq (sec->compressed_name, name))
{
- bfd_boolean secondary = (section != find_section (filedata, name));
+ bool secondary = (section != find_section (filedata, name));
if (secondary)
free_debug_section (id);
- if (i == line && const_strneq (name, ".debug_line."))
+ if (i == line && startswith (name, ".debug_line."))
sec->name = name;
else if (streq (sec->uncompressed_name, name))
sec->name = sec->uncompressed_name;
if (i == max)
{
printf (_("Unrecognized debug section: %s\n"), print_name);
- result = FALSE;
+ result = false;
}
return result;
for (cur = dump_sects_byname; cur; cur = cur->next)
{
unsigned int i;
- bfd_boolean any = FALSE;
+ bool any = false;
for (i = 0; i < filedata->file_header.e_shnum; i++)
if (SECTION_NAME_VALID (filedata->section_headers + i)
&& streq (SECTION_NAME (filedata->section_headers + i), cur->name))
{
request_dump_bynumber (&filedata->dump, i, cur->type);
- any = TRUE;
+ any = true;
}
- if (!any)
- {
- if (filedata->is_separate)
- warn (_("Section '%s' in linked file '%s' was not dumped because it does not exist\n"),
- cur->name, filedata->file_name);
- else
- warn (_("Section '%s' was not dumped because it does not exist\n"),
- cur->name);
- }
+ if (!any && !filedata->is_separate)
+ warn (_("Section '%s' was not dumped because it does not exist\n"),
+ cur->name);
}
}
-static bfd_boolean
+static bool
process_section_contents (Filedata * filedata)
{
Elf_Internal_Shdr * section;
unsigned int i;
- bfd_boolean res = TRUE;
+ bool res = true;
if (! do_dump)
- return TRUE;
+ return true;
initialise_dumps_byname (filedata);
if (filedata->is_separate && ! process_links)
dump &= DEBUG_DUMP;
-
+
#ifdef SUPPORT_DISASSEMBLY
if (dump & DISASS_DUMP)
{
if (! disassemble_section (section, filedata))
- res = FALSE;
+ res = false;
}
#endif
if (dump & HEX_DUMP)
{
- if (! dump_section_as_bytes (section, filedata, FALSE))
- res = FALSE;
+ 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_section_as_bytes (section, filedata, true))
+ res = false;
}
if (dump & STRING_DUMP)
{
if (! dump_section_as_strings (section, filedata))
- res = FALSE;
+ res = false;
}
if (dump & DEBUG_DUMP)
{
if (! display_debug_section (i, section, filedata))
- res = FALSE;
+ res = false;
}
#ifdef ENABLE_LIBCTF
if (dump & CTF_DUMP)
{
if (! dump_section_as_ctf (section, filedata))
- res = FALSE;
+ res = false;
}
#endif
}
- /* Check to see if the user requested a
- dump of a section that does not exist. */
- while (i < filedata->dump.num_dump_sects)
+ if (! filedata->is_separate)
{
- if (filedata->dump.dump_sects[i])
- {
- if (filedata->is_separate)
- warn (_("Section %d in linked file '%s' was not dumped because it does not exist!\n"),
- i, filedata->file_name);
- else
+ /* Check to see if the user requested a
+ dump of a section that does not exist. */
+ for (; i < filedata->dump.num_dump_sects; i++)
+ if (filedata->dump.dump_sects[i])
+ {
warn (_("Section %d was not dumped because it does not exist!\n"), i);
- res = FALSE;
- }
- i++;
+ res = false;
+ }
}
return res;
{
if (mask)
{
- bfd_boolean first = TRUE;
+ bool first = true;
if (mask & OEX_FPU_INEX)
- fputs ("INEX", stdout), first = FALSE;
+ fputs ("INEX", stdout), first = false;
if (mask & OEX_FPU_UFLO)
- printf ("%sUFLO", first ? "" : "|"), first = FALSE;
+ printf ("%sUFLO", first ? "" : "|"), first = false;
if (mask & OEX_FPU_OFLO)
- printf ("%sOFLO", first ? "" : "|"), first = FALSE;
+ printf ("%sOFLO", first ? "" : "|"), first = false;
if (mask & OEX_FPU_DIV0)
- printf ("%sDIV0", first ? "" : "|"), first = FALSE;
+ printf ("%sDIV0", first ? "" : "|"), first = false;
if (mask & OEX_FPU_INVAL)
printf ("%sINVAL", first ? "" : "|");
}
{
if (mask)
{
- bfd_boolean first = TRUE;
+ bool first = true;
if (mask & ELF_SPARC_HWCAP_MUL32)
- fputs ("mul32", stdout), first = FALSE;
+ fputs ("mul32", stdout), first = false;
if (mask & ELF_SPARC_HWCAP_DIV32)
- printf ("%sdiv32", first ? "" : "|"), first = FALSE;
+ printf ("%sdiv32", first ? "" : "|"), first = false;
if (mask & ELF_SPARC_HWCAP_FSMULD)
- printf ("%sfsmuld", first ? "" : "|"), first = FALSE;
+ printf ("%sfsmuld", first ? "" : "|"), first = false;
if (mask & ELF_SPARC_HWCAP_V8PLUS)
- printf ("%sv8plus", first ? "" : "|"), first = FALSE;
+ printf ("%sv8plus", first ? "" : "|"), first = false;
if (mask & ELF_SPARC_HWCAP_POPC)
- printf ("%spopc", first ? "" : "|"), first = FALSE;
+ printf ("%spopc", first ? "" : "|"), first = false;
if (mask & ELF_SPARC_HWCAP_VIS)
- printf ("%svis", first ? "" : "|"), first = FALSE;
+ printf ("%svis", first ? "" : "|"), first = false;
if (mask & ELF_SPARC_HWCAP_VIS2)
- printf ("%svis2", first ? "" : "|"), first = FALSE;
+ printf ("%svis2", first ? "" : "|"), first = false;
if (mask & ELF_SPARC_HWCAP_ASI_BLK_INIT)
- printf ("%sASIBlkInit", first ? "" : "|"), first = FALSE;
+ printf ("%sASIBlkInit", first ? "" : "|"), first = false;
if (mask & ELF_SPARC_HWCAP_FMAF)
- printf ("%sfmaf", first ? "" : "|"), first = FALSE;
+ printf ("%sfmaf", first ? "" : "|"), first = false;
if (mask & ELF_SPARC_HWCAP_VIS3)
- printf ("%svis3", first ? "" : "|"), first = FALSE;
+ printf ("%svis3", first ? "" : "|"), first = false;
if (mask & ELF_SPARC_HWCAP_HPC)
- printf ("%shpc", first ? "" : "|"), first = FALSE;
+ printf ("%shpc", first ? "" : "|"), first = false;
if (mask & ELF_SPARC_HWCAP_RANDOM)
- printf ("%srandom", first ? "" : "|"), first = FALSE;
+ printf ("%srandom", first ? "" : "|"), first = false;
if (mask & ELF_SPARC_HWCAP_TRANS)
- printf ("%strans", first ? "" : "|"), first = FALSE;
+ printf ("%strans", first ? "" : "|"), first = false;
if (mask & ELF_SPARC_HWCAP_FJFMAU)
- printf ("%sfjfmau", first ? "" : "|"), first = FALSE;
+ printf ("%sfjfmau", first ? "" : "|"), first = false;
if (mask & ELF_SPARC_HWCAP_IMA)
- printf ("%sima", first ? "" : "|"), first = FALSE;
+ printf ("%sima", first ? "" : "|"), first = false;
if (mask & ELF_SPARC_HWCAP_ASI_CACHE_SPARING)
- printf ("%scspare", first ? "" : "|"), first = FALSE;
+ printf ("%scspare", first ? "" : "|"), first = false;
}
else
fputc ('0', stdout);
{
if (mask)
{
- bfd_boolean first = TRUE;
+ bool first = true;
if (mask & ELF_SPARC_HWCAP2_FJATHPLUS)
- fputs ("fjathplus", stdout), first = FALSE;
+ fputs ("fjathplus", stdout), first = false;
if (mask & ELF_SPARC_HWCAP2_VIS3B)
- printf ("%svis3b", first ? "" : "|"), first = FALSE;
+ printf ("%svis3b", first ? "" : "|"), first = false;
if (mask & ELF_SPARC_HWCAP2_ADP)
- printf ("%sadp", first ? "" : "|"), first = FALSE;
+ printf ("%sadp", first ? "" : "|"), first = false;
if (mask & ELF_SPARC_HWCAP2_SPARC5)
- printf ("%ssparc5", first ? "" : "|"), first = FALSE;
+ printf ("%ssparc5", first ? "" : "|"), first = false;
if (mask & ELF_SPARC_HWCAP2_MWAIT)
- printf ("%smwait", first ? "" : "|"), first = FALSE;
+ printf ("%smwait", first ? "" : "|"), first = false;
if (mask & ELF_SPARC_HWCAP2_XMPMUL)
- printf ("%sxmpmul", first ? "" : "|"), first = FALSE;
+ printf ("%sxmpmul", first ? "" : "|"), first = false;
if (mask & ELF_SPARC_HWCAP2_XMONT)
- printf ("%sxmont2", first ? "" : "|"), first = FALSE;
+ printf ("%sxmont2", first ? "" : "|"), first = false;
if (mask & ELF_SPARC_HWCAP2_NSEC)
- printf ("%snsec", first ? "" : "|"), first = FALSE;
+ printf ("%snsec", first ? "" : "|"), first = false;
if (mask & ELF_SPARC_HWCAP2_FJATHHPC)
- printf ("%sfjathhpc", first ? "" : "|"), first = FALSE;
+ printf ("%sfjathhpc", first ? "" : "|"), first = false;
if (mask & ELF_SPARC_HWCAP2_FJDES)
- printf ("%sfjdes", first ? "" : "|"), first = FALSE;
+ printf ("%sfjdes", first ? "" : "|"), first = false;
if (mask & ELF_SPARC_HWCAP2_FJAES)
- printf ("%sfjaes", first ? "" : "|"), first = FALSE;
+ printf ("%sfjaes", first ? "" : "|"), first = false;
}
else
fputc ('0', stdout);
return p;
}
-static bfd_boolean
+static bool
process_attributes (Filedata * filedata,
const char * public_name,
unsigned int proc_type,
{
Elf_Internal_Shdr * sect;
unsigned i;
- bfd_boolean res = TRUE;
+ bool res = true;
/* Find the section header so that we get the size. */
for (i = 0, sect = filedata->section_headers;
sect->sh_size, _("attributes"));
if (contents == NULL)
{
- res = FALSE;
+ res = false;
continue;
}
if (*p != 'A')
{
printf (_("Unknown attributes version '%c'(%d) - expecting 'A'\n"), *p, *p);
- res = FALSE;
+ res = false;
}
else
{
{
bfd_vma attr_len;
unsigned int namelen;
- bfd_boolean public_section;
- bfd_boolean gnu_section;
+ bool public_section;
+ bool gnu_section;
if (section_len <= 4)
{
error (_("Tag section ends prematurely\n"));
- res = FALSE;
+ 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;
+ 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;
+ res = false;
break;
}
if (namelen == 0 || namelen >= attr_len)
{
error (_("Corrupt attribute section name\n"));
- res = FALSE;
+ res = false;
break;
}
putchar ('\n');
if (public_name && streq ((char *) p, public_name))
- public_section = TRUE;
+ public_section = true;
else
- public_section = FALSE;
+ public_section = false;
if (streq ((char *) p, "gnu"))
- gnu_section = TRUE;
+ gnu_section = true;
else
- gnu_section = FALSE;
+ gnu_section = false;
p += namelen;
attr_len -= namelen;
if (attr_len < 6)
{
error (_("Unused bytes at end of section\n"));
- res = FALSE;
+ res = false;
section_len = 0;
break;
}
{
error (_("Bad subsection length (%u > %u)\n"),
(unsigned) size, (unsigned) attr_len);
- res = FALSE;
+ res = false;
size = attr_len;
}
/* PR binutils/17531: Safe handling of corrupt files. */
{
error (_("Bad subsection length (%u < 6)\n"),
(unsigned) size);
- res = FALSE;
+ res = false;
section_len = 0;
break;
}
break;
default:
printf (_("Unknown tag: %d\n"), tag);
- public_section = FALSE;
+ public_section = false;
break;
}
: -1;
}
-static bfd_boolean
+static bool
process_mips_specific (Filedata * filedata)
{
Elf_Internal_Dyn * entry;
bfd_vma local_gotno = 0;
bfd_vma gotsym = 0;
bfd_vma symtabno = 0;
- bfd_boolean res = TRUE;
+ bool res = true;
if (! process_attributes (filedata, NULL, SHT_GNU_ATTRIBUTES, NULL,
display_mips_gnu_attribute))
- res = FALSE;
+ res = false;
sect = find_section (filedata, ".MIPS.abiflags");
if (sizeof (Elf_External_ABIFlags_v0) != sect->sh_size)
{
error (_("Corrupt MIPS ABI Flags section.\n"));
- res = FALSE;
+ res = false;
}
else
{
free (elib);
}
else
- res = FALSE;
+ res = false;
}
if (options_offset != 0)
if (sect == NULL)
{
error (_("No MIPS_OPTIONS header found\n"));
- return FALSE;
+ return false;
}
/* PR 24243 */
if (sect->sh_size < sizeof (* eopt))
{
error (_("The MIPS options section is too small.\n"));
- return FALSE;
+ return false;
}
eopt = (Elf_External_Options *) get_data (NULL, filedata, options_offset, 1,
error (_("Invalid size (%u) for MIPS option\n"),
optsize);
free (eopt);
- return FALSE;
+ return false;
}
offset += optsize;
++cnt;
free (eopt);
}
else
- res = FALSE;
+ res = false;
}
if (conflicts_offset != 0 && conflictsno != 0)
if (filedata->dynamic_symbols == NULL)
{
error (_("conflict list found without a dynamic symbol table\n"));
- return FALSE;
+ return false;
}
/* PR 21345 - print a slightly more helpful error message
{
error (_("Overlarge number of conflicts detected: %lx\n"),
(long) conflictsno);
- return FALSE;
+ return false;
}
iconf = (Elf32_Conflict *) cmalloc (conflictsno, sizeof (* iconf));
if (iconf == NULL)
{
error (_("Out of memory allocating space for dynamic conflicts\n"));
- return FALSE;
+ return false;
}
if (is_32bit_elf)
if (!econf32)
{
free (iconf);
- return FALSE;
+ return false;
}
for (cnt = 0; cnt < conflictsno; ++cnt)
if (!econf64)
{
free (iconf);
- return FALSE;
+ return false;
}
for (cnt = 0; cnt < conflictsno; ++cnt)
{
error (_("The GOT symbol offset (%lu) is greater than the symbol table size (%lu)\n"),
(unsigned long) gotsym, (unsigned long) symtabno);
- return FALSE;
+ 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 FALSE;
+ return false;
}
offset = offset_from_vma (filedata, pltgot, global_end - pltgot);
if (pltrel == DT_RELA)
{
if (!slurp_rela_relocs (filedata, rel_offset, pltrelsz, &rels, &count))
- return FALSE;
+ return false;
}
else
{
if (!slurp_rel_relocs (filedata, rel_offset, pltrelsz, &rels, &count))
- return FALSE;
+ return false;
}
ent = mips_pltgot;
if (data == NULL)
{
free (rels);
- return FALSE;
+ return false;
}
printf ("\nPLT GOT:\n\n");
return res;
}
-static bfd_boolean
+static bool
process_nds32_specific (Filedata * filedata)
{
Elf_Internal_Shdr *sect = NULL;
_("NDS32 elf flags section"));
if (buf == NULL)
- return FALSE;
+ return false;
flag = byte_get (buf, 4);
free (buf);
}
}
- return TRUE;
+ return true;
}
-static bfd_boolean
+static bool
process_gnu_liblist (Filedata * filedata)
{
Elf_Internal_Shdr * section;
size_t cnt;
unsigned long num_liblist;
unsigned i;
- bfd_boolean res = TRUE;
+ bool res = true;
if (! do_arch)
- return TRUE;
+ return true;
for (i = 0, section = filedata->section_headers;
i < filedata->file_header.e_shnum;
if (elib == NULL)
{
- res = FALSE;
+ res = false;
break;
}
{
free (elib);
free (strtab);
- res = FALSE;
+ res = false;
break;
}
strtab_size = string_sec->sh_size;
return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
case NT_ARM_HW_WATCH:
return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
+ case NT_ARM_SVE:
+ return _("NT_ARM_SVE (AArch SVE registers)");
+ case NT_ARM_PAC_MASK:
+ return _("NT_ARM_PAC_MASK (AArch pointer authentication code masks)");
+ case NT_ARM_TAGGED_ADDR_CTRL:
+ return _("NT_ARM_TAGGED_ADDR_CTRL (AArch tagged address control)");
case NT_ARC_V2:
return _("NT_ARC_V2 (ARC HS accumulator/extra registers)");
case NT_RISCV_CSR:
return _("NT_SIGINFO (siginfo_t data)");
case NT_FILE:
return _("NT_FILE (mapped files)");
+ case NT_MEMTAG:
+ return _("NT_MEMTAG (memory tags)");
default:
break;
}
return buff;
}
-static bfd_boolean
+static bool
print_core_note (Elf_Internal_Note *pnote)
{
unsigned int addr_size = is_32bit_elf ? 4 : 8;
{
if (do_wide)
printf ("\n");
- return TRUE;
+ return true;
}
#ifndef BFD64
{
printf (_(" Cannot decode 64-bit note in 32-bit build\n"));
/* Still "successful". */
- return TRUE;
+ return true;
}
#endif
if (pnote->descsz < 2 * addr_size)
{
error (_(" Malformed note - too short for header\n"));
- return FALSE;
+ return false;
}
descdata = (unsigned char *) pnote->descdata;
if (descdata[pnote->descsz - 1] != '\0')
{
error (_(" Malformed note - does not end with \\0\n"));
- return FALSE;
+ return false;
}
count = byte_get (descdata, addr_size);
|| pnote->descsz < 2 * addr_size + count * 3 * addr_size)
{
error (_(" Malformed note - too short for supplied file count\n"));
- return FALSE;
+ return false;
}
printf (_(" Page size: "));
if (filenames == descend)
{
error (_(" Malformed note - filenames end too early\n"));
- return FALSE;
+ return false;
}
start = byte_get (descdata, addr_size);
filenames += 1 + strlen ((char *) filenames);
}
- return TRUE;
+ return true;
}
static const char *
printf ("\n");
}
-static bfd_boolean
+static bool
print_gnu_note (Filedata * filedata, Elf_Internal_Note *pnote)
{
/* NB/ Keep this switch statement in sync with get_gnu_elf_note_type (). */
if (pnote->descsz < 8)
{
error (_("<corrupt GNU_HWCAP>\n"));
- return FALSE;
+ return false;
}
num_entries = byte_get ((unsigned char *) pnote->descdata, 4);
mask = byte_get ((unsigned char *) pnote->descdata + 4, 4);
break;
}
- return TRUE;
+ return true;
}
static const char *
}
}
-static bfd_boolean
+static bool
print_v850_note (Elf_Internal_Note * pnote)
{
unsigned int val;
if (pnote->descsz != 4)
- return FALSE;
+ return false;
val = byte_get ((unsigned char *) pnote->descdata, pnote->descsz);
if (val == 0)
{
printf (_("not set\n"));
- return TRUE;
+ return true;
}
switch (pnote->type)
case V850_NOTE_ALIGNMENT:
switch (val)
{
- case EF_RH850_DATA_ALIGN4: printf (_("4-byte\n")); return TRUE;
- case EF_RH850_DATA_ALIGN8: printf (_("8-byte\n")); return TRUE;
+ 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 TRUE;
- case EF_RH850_DOUBLE64: printf (_("8-bytes\n")); return TRUE;
+ 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 TRUE;
- case EF_RH850_FPU30: printf (_("FPU-3.0\n")); return TRUE;
+ 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 TRUE;
+ return true;
}
break;
}
printf (_("unknown value: %x\n"), val);
- return FALSE;
+ return false;
}
-static bfd_boolean
+static bool
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 TRUE;
+ return true;
case NT_NETBSD_MARCH:
printf (" NetBSD\t\t0x%08lx\tMARCH <%s>\n", pnote->descsz,
pnote->descdata);
- return TRUE;
+ return true;
-#ifdef NT_NETBSD_PAX
case NT_NETBSD_PAX:
if (pnote->descsz < 1)
break;
((version & NT_NETBSD_PAX_NOGUARD) ? "-guard" : ""),
((version & NT_NETBSD_PAX_ASLR) ? "+ASLR" : ""),
((version & NT_NETBSD_PAX_NOASLR) ? "-ASLR" : ""));
- return TRUE;
-#endif
+ return true;
}
printf (" NetBSD\t0x%08lx\tUnknown note type: (0x%08lx)\n",
pnote->descsz, pnote->type);
- return FALSE;
+ return false;
}
static const char *
/* NetBSD core "procinfo" structure. */
return _("NetBSD procinfo structure");
-#ifdef NT_NETBSDCORE_AUXV
case NT_NETBSDCORE_AUXV:
return _("NetBSD ELF auxiliary vector data");
-#endif
-#ifdef NT_NETBSDCORE_LWPSTATUS
case NT_NETBSDCORE_LWPSTATUS:
return _("PT_LWPSTATUS (ptrace_lwpstatus structure)");
-#endif
default:
/* As of Jan 2020 there are no other machine-independent notes
return buff;
}
-static bfd_boolean
+static bool
print_stapsdt_note (Elf_Internal_Note *pnote)
{
size_t len, maxlen;
stapdt_note_too_small:
printf (_(" <corrupt - note is too small>\n"));
error (_("corrupt stapdt note - the data size is too small\n"));
- return FALSE;
+ return false;
}
static const char *
}
}
-static bfd_boolean
+static bool
print_ia64_vms_note (Elf_Internal_Note * pnote)
{
int maxlen = pnote->descsz;
break;
default:
- return FALSE;
+ return false;
}
- return TRUE;
+ 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;
+ return false;
}
struct build_attr_cache {
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)
+get_symbol_for_build_attribute (Filedata *filedata,
+ unsigned long offset,
+ bool is_open_attr,
+ const char **pname)
{
Elf_Internal_Sym *saved_sym = NULL;
Elf_Internal_Sym *sym;
/* Returns true iff addr1 and addr2 are in the same section. */
-static bfd_boolean
+static bool
same_section (Filedata * filedata, unsigned long addr1, unsigned long addr2)
{
Elf_Internal_Shdr * a1;
return a1 == a2 && a1 != NULL;
}
-static bfd_boolean
+static bool
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;
+ 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;
+ Elf_Internal_Sym *sym;
+ const char *name;
+ unsigned long start;
+ unsigned long end;
+ bool is_open_attr = pnote->type == NT_GNU_BUILD_ATTRIBUTE_OPEN;
switch (pnote->descsz)
{
else
printf (_(" Applies to region from %#lx\n"), func_offset);
}
- return TRUE;
+ return true;
case 4:
start = byte_get ((unsigned char *) pnote->descdata, 4);
default:
error (_(" <invalid description size: %lx>\n"), pnote->descsz);
printf (_(" <invalid descsz>"));
- return FALSE;
+ return false;
}
name = NULL;
printf (_(" (%s)"), name);
printf ("\n");
- return TRUE;
+ return true;
}
-static bfd_boolean
+static bool
print_gnu_build_attribute_name (Elf_Internal_Note * pnote)
{
static const char string_expected [2] = { GNU_BUILD_ATTRIBUTE_TYPE_STRING, 0 };
{
error (_("corrupt name field in GNU build attribute note: size = %ld\n"), pnote->namesz);
print_symbol (-20, _(" <corrupt name>"));
- return FALSE;
+ return false;
}
if (do_wide)
{
error (_("corrupt name field in GNU build attribute note: size = %ld\n"), pnote->namesz);
print_symbol (-20, _(" <corrupt name>"));
- return FALSE;
+ return false;
}
printf ("GA");
default:
error (_("unrecognised attribute type in name field: %d\n"), name_type);
print_symbol (-20, _("<unknown name type>"));
- return FALSE;
+ return false;
}
++ name;
error (_("corrupt name field: namesz: %lu but parsing gets to %ld\n"),
(unsigned long) pnote->namesz,
(long) (name - pnote->namedata));
- return FALSE;
+ return false;
}
if (left < 1 && ! do_wide)
- return TRUE;
+ return true;
switch (name_type)
{
if (do_wide && left > 0)
printf ("%-*s", left, " ");
- return TRUE;
+ return true;
}
/* Note that by the ELF standard, the name field is already null byte
If the value of namesz is zero, there is no name present. */
-static bfd_boolean
+static bool
process_note (Elf_Internal_Note * pnote,
Filedata * filedata)
{
note type strings. */
nt = get_note_type (filedata, pnote->type);
- else if (const_strneq (pnote->namedata, "GNU"))
+ else if (startswith (pnote->namedata, "GNU"))
/* GNU-specific object file notes. */
nt = get_gnu_elf_note_type (pnote->type);
- else if (const_strneq (pnote->namedata, "FreeBSD"))
+ else if (startswith (pnote->namedata, "FreeBSD"))
/* FreeBSD-specific core file notes. */
nt = get_freebsd_elfcore_note_type (filedata, pnote->type);
- else if (const_strneq (pnote->namedata, "NetBSD-CORE"))
+ else if (startswith (pnote->namedata, "NetBSD-CORE"))
/* NetBSD-specific core file notes. */
nt = get_netbsd_elfcore_note_type (filedata, pnote->type);
- else if (const_strneq (pnote->namedata, "NetBSD"))
+ else if (startswith (pnote->namedata, "NetBSD"))
/* NetBSD-specific core file notes. */
return process_netbsd_elf_note (pnote);
- else if (const_strneq (pnote->namedata, "PaX"))
+ else if (startswith (pnote->namedata, "PaX"))
/* NetBSD-specific core file notes. */
return process_netbsd_elf_note (pnote);
- else if (strneq (pnote->namedata, "SPU/", 4))
+ else if (startswith (pnote->namedata, "SPU/"))
{
/* SPU-specific core file notes. */
nt = pnote->namedata + 4;
name = "SPU";
}
- else if (const_strneq (pnote->namedata, "IPF/VMS"))
+ else if (startswith (pnote->namedata, "IPF/VMS"))
/* VMS/ia64-specific file notes. */
nt = get_ia64_vms_note_type (pnote->type);
- else if (const_strneq (pnote->namedata, "stapsdt"))
+ else if (startswith (pnote->namedata, "stapsdt"))
nt = get_stapsdt_note_type (pnote->type);
else
printf (" ");
- if (((const_strneq (pnote->namedata, "GA")
+ if (((startswith (pnote->namedata, "GA")
&& strchr ("*$!+", pnote->namedata[2]) != NULL)
|| strchr ("*$!+", pnote->namedata[0]) != NULL)
&& (pnote->type == NT_GNU_BUILD_ATTRIBUTE_OPEN
else
printf (" 0x%08lx\t%s\n", pnote->descsz, nt);
- if (const_strneq (pnote->namedata, "IPF/VMS"))
+ if (startswith (pnote->namedata, "IPF/VMS"))
return print_ia64_vms_note (pnote);
- else if (const_strneq (pnote->namedata, "GNU"))
+ else if (startswith (pnote->namedata, "GNU"))
return print_gnu_note (filedata, pnote);
- else if (const_strneq (pnote->namedata, "stapsdt"))
+ else if (startswith (pnote->namedata, "stapsdt"))
return print_stapsdt_note (pnote);
- else if (const_strneq (pnote->namedata, "CORE"))
+ else if (startswith (pnote->namedata, "CORE"))
return print_core_note (pnote);
- else if (((const_strneq (pnote->namedata, "GA")
+ else if (((startswith (pnote->namedata, "GA")
&& strchr ("*$!+", pnote->namedata[2]) != NULL)
|| strchr ("*$!+", pnote->namedata[0]) != NULL)
&& (pnote->type == NT_GNU_BUILD_ATTRIBUTE_OPEN
if (do_wide)
printf ("\n");
- return TRUE;
+ return true;
}
-static bfd_boolean
+static bool
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;
- bfd_boolean res = TRUE;
+ Elf_External_Note *pnotes;
+ Elf_External_Note *external;
+ char *end;
+ bool res = true;
if (length <= 0)
- return FALSE;
+ return false;
if (section)
{
if (! apply_relocations (filedata, section, (unsigned char *) pnotes, length, NULL, NULL))
{
free (pnotes);
- return FALSE;
+ return false;
}
}
}
_("notes"));
if (pnotes == NULL)
- return FALSE;
+ return false;
external = pnotes;
warn (_("Corrupt note: alignment %ld, expecting 4 or 8\n"),
(long) align);
free (pnotes);
- return FALSE;
+ return false;
}
printf (_(" %-20s %-10s\tDescription\n"), _("Owner"), _("Data size"));
if (temp == NULL)
{
error (_("Out of memory allocating space for inote name\n"));
- res = FALSE;
+ res = false;
break;
}
}
if (! process_note (& inote, filedata))
- res = FALSE;
+ res = false;
free (temp);
temp = NULL;
return res;
}
-static bfd_boolean
+static bool
process_corefile_note_segments (Filedata * filedata)
{
- Elf_Internal_Phdr * segment;
+ Elf_Internal_Phdr *segment;
unsigned int i;
- bfd_boolean res = TRUE;
+ bool res = true;
if (! get_program_headers (filedata))
- return TRUE;
+ return true;
for (i = 0, segment = filedata->program_headers;
i < filedata->file_header.e_phnum;
(bfd_vma) segment->p_offset,
(bfd_vma) segment->p_filesz,
(bfd_vma) segment->p_align))
- res = FALSE;
+ res = false;
}
return res;
}
-static bfd_boolean
+static bool
process_v850_notes (Filedata * filedata, bfd_vma offset, bfd_vma length)
{
Elf_External_Note * pnotes;
Elf_External_Note * external;
char * end;
- bfd_boolean res = TRUE;
+ bool res = true;
if (length <= 0)
- return FALSE;
+ return false;
pnotes = (Elf_External_Note *) get_data (NULL, filedata, offset, 1, length,
_("v850 notes"));
if (pnotes == NULL)
- return FALSE;
+ return false;
external = pnotes;
end = (char*) pnotes + length;
if (! print_v850_note (& inote))
{
- res = FALSE;
+ res = false;
printf ("<corrupt sizes: namesz: %lx, descsz: %lx>\n",
inote.namesz, inote.descsz);
}
return res;
}
-static bfd_boolean
+static bool
process_note_sections (Filedata * filedata)
{
- Elf_Internal_Shdr * section;
+ Elf_Internal_Shdr *section;
unsigned long i;
unsigned int n = 0;
- bfd_boolean res = TRUE;
+ bool res = true;
for (i = 0, section = filedata->section_headers;
i < filedata->file_header.e_shnum && section != NULL;
(bfd_vma) section->sh_offset,
(bfd_vma) section->sh_size,
(bfd_vma) section->sh_addralign))
- res = FALSE;
+ res = false;
n++;
}
if (! process_v850_notes (filedata,
(bfd_vma) section->sh_offset,
(bfd_vma) section->sh_size))
- res = FALSE;
+ res = false;
n++;
}
}
return res;
}
-static bfd_boolean
+static bool
process_notes (Filedata * filedata)
{
/* If we have not been asked to display the notes then do nothing. */
if (! do_notes)
- return TRUE;
+ return true;
if (filedata->file_header.e_type != ET_CORE)
return process_note_sections (filedata);
else
printf (_("No notes found file.\n"));
- return TRUE;
+ return true;
}
static unsigned char *
return display_tag_value (tag, start, end);
}
-static bfd_boolean
+static bool
process_arch_specific (Filedata * filedata)
{
if (! do_arch)
- return TRUE;
+ return true;
switch (filedata->file_header.e_machine)
{
}
}
-static bfd_boolean
+static bool
get_file_header (Filedata * filedata)
{
/* Read in the identity array. */
if (fread (filedata->file_header.e_ident, EI_NIDENT, 1, filedata->handle) != 1)
- return FALSE;
+ return false;
/* Determine how to read the rest of the header. */
switch (filedata->file_header.e_ident[EI_DATA])
Elf32_External_Ehdr ehdr32;
if (fread (ehdr32.e_type, sizeof (ehdr32) - EI_NIDENT, 1, filedata->handle) != 1)
- return FALSE;
+ return false;
filedata->file_header.e_type = BYTE_GET (ehdr32.e_type);
filedata->file_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 FALSE;
+ return false;
}
if (fread (ehdr64.e_type, sizeof (ehdr64) - EI_NIDENT, 1, filedata->handle) != 1)
- return FALSE;
+ return false;
filedata->file_header.e_type = BYTE_GET (ehdr64.e_type);
filedata->file_header.e_machine = BYTE_GET (ehdr64.e_machine);
filedata->file_header.e_shstrndx = BYTE_GET (ehdr64.e_shstrndx);
}
- if (filedata->file_header.e_shoff)
+ return true;
+}
+
+static void
+free_filedata (Filedata *filedata)
+{
+ free (filedata->program_interpreter);
+ filedata->program_interpreter = NULL;
+
+ 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;
+
+ free (filedata->dump.dump_sects);
+ filedata->dump.dump_sects = NULL;
+ filedata->dump.num_dump_sects = 0;
+
+ free (filedata->dynamic_strings);
+ filedata->dynamic_strings = NULL;
+ filedata->dynamic_strings_length = 0;
+
+ free (filedata->dynamic_symbols);
+ filedata->dynamic_symbols = NULL;
+ filedata->num_dynamic_syms = 0;
+
+ free (filedata->dynamic_syminfo);
+ filedata->dynamic_syminfo = NULL;
+
+ free (filedata->dynamic_section);
+ filedata->dynamic_section = NULL;
+
+ while (filedata->symtab_shndx_list != NULL)
{
- /* 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 (filedata, TRUE);
- else
- get_64bit_section_headers (filedata, TRUE);
+ elf_section_list *next = filedata->symtab_shndx_list->next;
+ free (filedata->symtab_shndx_list);
+ filedata->symtab_shndx_list = next;
}
- return TRUE;
+ free (filedata->section_headers_groups);
+ filedata->section_headers_groups = NULL;
+
+ if (filedata->section_groups)
+ {
+ size_t i;
+ struct group_list * g;
+ struct group_list * next;
+
+ for (i = 0; i < filedata->group_count; i++)
+ {
+ for (g = filedata->section_groups [i].root; g != NULL; g = next)
+ {
+ next = g->next;
+ free (g);
+ }
+ }
+
+ free (filedata->section_groups);
+ filedata->section_groups = NULL;
+ }
}
static void
void
close_debug_file (void * data)
{
+ free_filedata ((Filedata *) data);
close_file ((Filedata *) data);
}
static Filedata *
-open_file (const char * pathname, bfd_boolean is_separate)
+open_file (const char * pathname, bool is_separate)
{
struct stat statbuf;
Filedata * filedata = NULL;
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
- res = get_64bit_section_headers (filedata, FALSE);
-
- if (!res)
- goto fail;
- }
+ if (!get_section_headers (filedata, false))
+ goto fail;
return filedata;
void *
open_debug_file (const char * pathname)
{
- return open_file (pathname, TRUE);
+ return open_file (pathname, true);
+}
+
+static void
+initialise_dump_sects (Filedata * filedata)
+{
+ /* 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 (filedata->dump.num_dump_sects > cmdline.num_dump_sects)
+ memset (filedata->dump.dump_sects, 0,
+ filedata->dump.num_dump_sects * sizeof (*filedata->dump.dump_sects));
+
+ if (cmdline.num_dump_sects > 0)
+ {
+ if (filedata->dump.num_dump_sects == 0)
+ /* A sneaky way of allocating the dump_sects array. */
+ request_dump_bynumber (&filedata->dump, cmdline.num_dump_sects, 0);
+
+ assert (filedata->dump.num_dump_sects >= cmdline.num_dump_sects);
+ memcpy (filedata->dump.dump_sects, cmdline.dump_sects,
+ cmdline.num_dump_sects * sizeof (*filedata->dump.dump_sects));
+ }
}
/* Process one ELF object file according to the command line options.
positioned at the start of the ELF object. Returns TRUE if no
problems were encountered, FALSE otherwise. */
-static bfd_boolean
+static bool
process_object (Filedata * filedata)
{
- bfd_boolean have_separate_files;
+ bool have_separate_files;
unsigned int i;
- bfd_boolean res;
+ bool res;
if (! get_file_header (filedata))
{
error (_("%s: Failed to read file header\n"), filedata->file_name);
- return FALSE;
+ return false;
}
/* Initialise per file variables. */
if (show_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 (filedata->dump.num_dump_sects > cmdline.num_dump_sects)
- memset (filedata->dump.dump_sects, 0,
- filedata->dump.num_dump_sects * sizeof (*filedata->dump.dump_sects));
-
- if (cmdline.num_dump_sects > 0)
- {
- if (filedata->dump.num_dump_sects == 0)
- /* A sneaky way of allocating the dump_sects array. */
- request_dump_bynumber (&filedata->dump, cmdline.num_dump_sects, 0);
+ initialise_dump_sects (filedata);
- assert (filedata->dump.num_dump_sects >= cmdline.num_dump_sects);
- memcpy (filedata->dump.dump_sects, cmdline.dump_sects,
- cmdline.num_dump_sects * sizeof (*filedata->dump.dump_sects));
- }
+ /* There may be some extensions in the first section header. Don't
+ bomb if we can't read it. */
+ get_section_headers (filedata, true);
if (! process_file_header (filedata))
- return FALSE;
+ {
+ res = false;
+ goto out;
+ }
if (! process_section_headers (filedata))
{
/* Without loaded section headers we cannot process lots of things. */
- do_unwind = do_version = do_dump = do_arch = FALSE;
+ do_unwind = do_version = do_dump = do_arch = false;
if (! do_using_dynamic)
- do_syms = do_dyn_syms = do_reloc = FALSE;
+ do_syms = do_dyn_syms = do_reloc = false;
}
if (! process_section_groups (filedata))
/* Without loaded section groups we cannot process unwind. */
- do_unwind = FALSE;
+ do_unwind = false;
res = process_program_headers (filedata);
if (res)
res = process_dynamic_section (filedata);
if (! process_relocs (filedata))
- res = FALSE;
+ res = false;
if (! process_unwind (filedata))
- res = FALSE;
+ res = false;
if (! process_symbol_table (filedata))
- res = FALSE;
+ res = false;
if (! process_lto_symbol_tables (filedata))
- res = FALSE;
+ res = false;
if (! process_syminfo (filedata))
- res = FALSE;
+ res = false;
if (! process_version_sections (filedata))
- res = FALSE;
+ res = false;
if (filedata->file_header.e_shstrndx != SHN_UNDEF)
have_separate_files = load_separate_debug_files (filedata, filedata->file_name);
else
- have_separate_files = FALSE;
+ have_separate_files = false;
if (! process_section_contents (filedata))
- res = FALSE;
+ res = false;
if (have_separate_files)
{
for (d = first_separate_info; d != NULL; d = d->next)
{
+ initialise_dump_sects (d->handle);
+
if (process_links && ! process_file_header (d->handle))
- res = FALSE;
+ res = false;
else if (! process_section_headers (d->handle))
- res = FALSE;
+ res = false;
else if (! process_section_contents (d->handle))
- res = FALSE;
+ res = false;
else if (process_links)
{
if (! process_section_groups (d->handle))
- res = FALSE;
+ res = false;
if (! process_program_headers (d->handle))
- res = FALSE;
+ res = false;
if (! process_dynamic_section (d->handle))
- res = FALSE;
+ res = false;
if (! process_relocs (d->handle))
- res = FALSE;
+ res = false;
if (! process_unwind (d->handle))
- res = FALSE;
+ res = false;
if (! process_symbol_table (d->handle))
- res = FALSE;
+ res = false;
if (! process_lto_symbol_tables (d->handle))
- res = FALSE;
+ res = false;
if (! process_syminfo (d->handle))
- res = FALSE;
+ res = false;
if (! process_version_sections (d->handle))
- res = FALSE;
+ res = false;
if (! process_notes (d->handle))
- res = FALSE;
+ res = false;
}
}
}
if (! process_notes (filedata))
- res = FALSE;
+ res = false;
if (! process_gnu_liblist (filedata))
- res = FALSE;
+ 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;
-
- free (filedata->dump.dump_sects);
- filedata->dump.dump_sects = NULL;
- filedata->dump.num_dump_sects = 0;
+ res = false;
- free (filedata->dynamic_strings);
- filedata->dynamic_strings = NULL;
- filedata->dynamic_strings_length = 0;
-
- free (filedata->dynamic_symbols);
- filedata->dynamic_symbols = NULL;
- filedata->num_dynamic_syms = 0;
-
- free (filedata->dynamic_syminfo);
- filedata->dynamic_syminfo = NULL;
-
- free (filedata->dynamic_section);
- filedata->dynamic_section = NULL;
-
- while (filedata->symtab_shndx_list != NULL)
- {
- elf_section_list *next = filedata->symtab_shndx_list->next;
- free (filedata->symtab_shndx_list);
- filedata->symtab_shndx_list = next;
- }
-
- free (filedata->section_headers_groups);
- filedata->section_headers_groups = NULL;
-
- if (filedata->section_groups)
- {
- struct group_list * g;
- struct group_list * next;
-
- for (i = 0; i < filedata->group_count; i++)
- {
- for (g = filedata->section_groups [i].root; g != NULL; g = next)
- {
- next = g->next;
- free (g);
- }
- }
-
- free (filedata->section_groups);
- filedata->section_groups = NULL;
- }
+ out:
+ free_filedata (filedata);
free_debug_memory ();
On entry the file is positioned just after the ARMAG string.
Returns TRUE upon success, FALSE otherwise. */
-static bfd_boolean
-process_archive (Filedata * filedata, bfd_boolean is_thin_archive)
+static bool
+process_archive (Filedata * filedata, bool is_thin_archive)
{
struct archive_info arch;
struct archive_info nested_arch;
size_t got;
- bfd_boolean ret = TRUE;
+ bool ret = true;
- show_name = TRUE;
+ show_name = true;
/* The ARCH structure is used to hold information about this archive. */
arch.file_name = NULL;
filedata->file_size, is_thin_archive,
do_archive_index) != 0)
{
- ret = FALSE;
+ ret = false;
goto out;
}
error (_("%s: end of the symbol table reached "
"before the end of the index\n"),
filedata->file_name);
- ret = FALSE;
+ ret = false;
break;
}
/* PR 17531: file: 0b6630b2. */
"the index table\n",
arch.sym_size - l),
filedata->file_name, arch.sym_size - l);
- ret = FALSE;
+ ret = false;
}
if (fseek (filedata->handle, current_pos, SEEK_SET) != 0)
error (_("%s: failed to seek back to start of object files "
"in the archive\n"),
filedata->file_name);
- ret = FALSE;
+ ret = false;
goto out;
}
}
&& !do_histogram && !do_debugging && !do_arch && !do_notes
&& !do_section_groups && !do_dyn_syms)
{
- ret = TRUE; /* Archive index only. */
+ ret = true; /* Archive index only. */
goto out;
}
}
{
error (_("%s: failed to seek to next archive header\n"),
arch.file_name);
- ret = FALSE;
+ ret = false;
break;
}
got = fread (&arch.arhdr, 1, sizeof arch.arhdr, filedata->handle);
have already been freed. */
error (_("%s: failed to read archive header\n"), arch.file_name);
- ret = FALSE;
+ 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 = FALSE;
+ ret = false;
break;
}
if (name == NULL)
{
error (_("%s: bad archive file name\n"), arch.file_name);
- ret = FALSE;
+ ret = false;
break;
}
namelen = strlen (name);
{
error (_("%s: bad archive file name\n"), arch.file_name);
free (name);
- ret = FALSE;
+ ret = false;
break;
}
if (member_file_name == NULL)
{
free (qualified_name);
- ret = FALSE;
+ ret = false;
break;
}
- member_filedata = open_file (member_file_name, FALSE);
+ member_filedata = open_file (member_file_name, false);
if (member_filedata == NULL)
{
error (_("Input file '%s' is not readable.\n"), member_file_name);
free (member_file_name);
free (qualified_name);
- ret = FALSE;
+ ret = false;
break;
}
member_filedata->file_name = qualified_name;
if (! process_object (member_filedata))
- ret = FALSE;
+ ret = false;
close_file (member_filedata);
free (member_file_name);
qualified_name, name);
free (qualified_name);
free (name);
- ret = FALSE;
+ ret = false;
break;
}
free (name);
error (_("%s: failed to seek to archive member.\n"),
nested_arch.file_name);
free (qualified_name);
- ret = FALSE;
+ ret = false;
break;
}
thin_filedata.file_name = qualified_name;
if (! process_object (& thin_filedata))
- ret = FALSE;
+ ret = false;
}
else
{
filedata->archive_file_offset = arch.next_arhdr_offset;
filedata->file_name = qualified_name;
if (! process_object (filedata))
- ret = FALSE;
+ ret = false;
arch.next_arhdr_offset += filedata->archive_file_size;
/* Stop looping with "negative" archive_file_size. */
if (arch.next_arhdr_offset < filedata->archive_file_size)
return ret;
}
-static bfd_boolean
+static bool
process_file (char * file_name)
{
Filedata * filedata = NULL;
struct stat statbuf;
char armag[SARMAG];
- bfd_boolean ret = TRUE;
+ bool ret = true;
if (stat (file_name, &statbuf) < 0)
{
else
error (_("Could not locate '%s'. System error message: %s\n"),
file_name, strerror (errno));
- return FALSE;
+ return false;
}
if (! S_ISREG (statbuf.st_mode))
{
error (_("'%s' is not an ordinary file\n"), file_name);
- return FALSE;
+ return false;
}
filedata = calloc (1, sizeof * filedata);
if (filedata == NULL)
{
error (_("Out of memory allocating file data structure\n"));
- return FALSE;
+ return false;
}
filedata->file_name = file_name;
{
error (_("Input file '%s' is not readable.\n"), file_name);
free (filedata);
- return FALSE;
+ return false;
}
if (fread (armag, SARMAG, 1, filedata->handle) != 1)
error (_("%s: Failed to read file's magic number\n"), file_name);
fclose (filedata->handle);
free (filedata);
- return FALSE;
+ return false;
}
filedata->file_size = (bfd_size_type) statbuf.st_size;
- filedata->is_separate = FALSE;
+ filedata->is_separate = false;
if (memcmp (armag, ARMAG, SARMAG) == 0)
{
- if (! process_archive (filedata, FALSE))
- ret = FALSE;
+ if (! process_archive (filedata, false))
+ ret = false;
}
else if (memcmp (armag, ARMAGT, SARMAG) == 0)
{
- if ( ! process_archive (filedata, TRUE))
- ret = FALSE;
+ if ( ! process_archive (filedata, true))
+ ret = false;
}
else
{
filedata->archive_file_size = filedata->archive_file_offset = 0;
if (! process_object (filedata))
- ret = FALSE;
+ ret = false;
}
fclose (filedata->handle);
{
int err;
-#if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
+#ifdef HAVE_LC_MESSAGES
setlocale (LC_MESSAGES, "");
#endif
-#if defined (HAVE_SETLOCALE)
setlocale (LC_CTYPE, "");
-#endif
bindtextdomain (PACKAGE, LOCALEDIR);
textdomain (PACKAGE);
if (optind < (argc - 1))
/* When displaying information for more than one file,
prefix the information with the file name. */
- show_name = TRUE;
+ show_name = true;
else if (optind >= argc)
{
/* Ensure that the warning is always displayed. */
- do_checks = TRUE;
+ do_checks = true;
warn (_("Nothing to do.\n"));
usage (stderr);
}
- err = FALSE;
+ err = false;
while (optind < argc)
if (! process_file (argv[optind++]))
- err = TRUE;
+ err = true;
free (cmdline.dump_sects);
projects / thirdparty / binutils-gdb.git / blobdiff