* sysdep.h (POISON_BFD_BOOLEAN): Define.
* addr2line.c, * ar.c, * arsup.c, * bfdtest2.c, * binemul.c,
* binemul.h, * bucomm.c, * bucomm.h, * budbg.h, * coffgrok.c,
* debug.c, * debug.h, * dlltool.c, * dwarf.c, * dwarf.h,
* elfedit.c, * emul_aix.c, * mclex.c, * nm.c, * objcopy.c,
* objdump.c, * od-macho.c, * prdbg.c, * rdcoff.c, * rddbg.c,
* readelf.c, * rename.c, * stabs.c, * strings.c, * windint.h,
* windmc.c, * windmc.h, * windres.c, * winduni.c,
* wrstabs.c: Replace bfd_boolean with bool, FALSE with false,
and TRUE with true throughout.
+2021-03-31 Alan Modra <amodra@gmail.com>
+
+ * sysdep.h (POISON_BFD_BOOLEAN): Define.
+ * addr2line.c, * ar.c, * arsup.c, * bfdtest2.c, * binemul.c,
+ * binemul.h, * bucomm.c, * bucomm.h, * budbg.h, * coffgrok.c,
+ * debug.c, * debug.h, * dlltool.c, * dwarf.c, * dwarf.h,
+ * elfedit.c, * emul_aix.c, * mclex.c, * nm.c, * objcopy.c,
+ * objdump.c, * od-macho.c, * prdbg.c, * rdcoff.c, * rddbg.c,
+ * readelf.c, * rename.c, * stabs.c, * strings.c, * windint.h,
+ * windmc.c, * windmc.h, * windres.c, * winduni.c,
+ * wrstabs.c: Replace bfd_boolean with bool, FALSE with false,
+ and TRUE with true throughout.
+
2021-03-31 Alan Modra <amodra@gmail.com>
* coffdump.c: Include stdint.h in place of bfd_stdint.h.
#include "bucomm.h"
#include "elf-bfd.h"
-static bfd_boolean unwind_inlines; /* -i, unwind inlined functions. */
-static bfd_boolean with_addresses; /* -a, show addresses. */
-static bfd_boolean with_functions; /* -f, show function names. */
-static bfd_boolean do_demangle; /* -C, demangle names. */
-static bfd_boolean pretty_print; /* -p, print on one line. */
-static bfd_boolean base_names; /* -s, strip directory names. */
+static bool unwind_inlines; /* -i, unwind inlined functions. */
+static bool with_addresses; /* -a, show addresses. */
+static bool with_functions; /* -f, show function names. */
+static bool do_demangle; /* -C, demangle names. */
+static bool pretty_print; /* -p, print on one line. */
+static bool base_names; /* -s, strip directory names. */
/* Flags passed to the name demangler. */
static int demangle_flags = DMGL_PARAMS | DMGL_ANSI;
{
long storage;
long symcount;
- bfd_boolean dynamic = FALSE;
+ bool dynamic = false;
if ((bfd_get_file_flags (abfd) & HAS_SYMS) == 0)
return;
if (storage == 0)
{
storage = bfd_get_dynamic_symtab_upper_bound (abfd);
- dynamic = TRUE;
+ dynamic = true;
}
if (storage < 0)
bfd_fatal (bfd_get_filename (abfd));
static const char *functionname;
static unsigned int line;
static unsigned int discriminator;
-static bfd_boolean found;
+static bool found;
/* Look for an address in a section. This is called via
bfd_map_over_sections. */
printf ("\n");
}
- found = FALSE;
+ found = false;
if (section)
find_offset_in_section (abfd, section);
else
else
printf ("?\n");
if (!unwind_inlines)
- found = FALSE;
+ found = false;
else
found = bfd_find_inliner_info (abfd, &filename, &functionname,
&line);
case 0:
break; /* We've been given a long option. */
case 'a':
- with_addresses = TRUE;
+ with_addresses = true;
break;
case 'b':
target = optarg;
break;
case 'C':
- do_demangle = TRUE;
+ do_demangle = true;
if (optarg != NULL)
{
enum demangling_styles style;
file_name = optarg;
break;
case 's':
- base_names = TRUE;
+ base_names = true;
break;
case 'f':
- with_functions = TRUE;
+ with_functions = true;
break;
case 'p':
- pretty_print = TRUE;
+ pretty_print = true;
break;
case 'v':
case 'V':
usage (stdout, 0);
break;
case 'i':
- unwind_inlines = TRUE;
+ unwind_inlines = true;
break;
case 'j':
section_name = optarg;
static void move_members (bfd *, char **files_to_move);
static void replace_members
- (bfd *, char **files_to_replace, bfd_boolean quick);
+ (bfd *, char **files_to_replace, bool quick);
static void print_descr (bfd * abfd);
static void write_archive (bfd *);
static int ranlib_only (const char *archname);
/* For extract/delete only. If COUNTED_NAME_MODE is TRUE, we only
extract the COUNTED_NAME_COUNTER instance of that name. */
-static bfd_boolean counted_name_mode = 0;
+static bool counted_name_mode = 0;
static int counted_name_counter = 0;
/* Whether to truncate names of files stored in the archive. */
-static bfd_boolean ar_truncate = FALSE;
+static bool ar_truncate = false;
/* Whether to use a full file name match when searching an archive.
This is convenient for archives created by the Microsoft lib
program. */
-static bfd_boolean full_pathname = FALSE;
+static bool full_pathname = false;
/* Whether to create a "thin" archive (symbol index only -- no files). */
-static bfd_boolean make_thin_archive = FALSE;
+static bool make_thin_archive = false;
#define LIBDEPS "__.LIBDEP"
/* Text to store in the __.LIBDEP archive element for the linker to use. */
for (; count > 0; files++, count--)
{
- bfd_boolean found = FALSE;
+ bool found = false;
match_count = 0;
for (head = arch->archive_next; head; head = head->archive_next)
continue;
}
- found = TRUE;
+ found = true;
function (head);
head->archive_pass = 1;
/* PR binutils/15796: Once a file has been matched, do not
}
}
\f
-bfd_boolean operation_alters_arch = FALSE;
+bool operation_alters_arch = false;
static void
usage (int help)
break;
case 'd':
operation = del;
- operation_alters_arch = TRUE;
+ operation_alters_arch = true;
break;
case 'm':
operation = move;
- operation_alters_arch = TRUE;
+ operation_alters_arch = true;
break;
case 'p':
operation = print_files;
break;
case 'q':
operation = quick_append;
- operation_alters_arch = TRUE;
+ operation_alters_arch = true;
break;
case 'r':
operation = replace;
- operation_alters_arch = TRUE;
+ operation_alters_arch = true;
break;
case 't':
operation = print_table;
display_offsets = 1;
break;
case 'V':
- show_version = TRUE;
+ show_version = true;
break;
case 's':
write_armap = 1;
mri_mode = 1;
break;
case 'N':
- counted_name_mode = TRUE;
+ counted_name_mode = true;
break;
case 'f':
- ar_truncate = TRUE;
+ ar_truncate = true;
break;
case 'P':
- full_pathname = TRUE;
+ full_pathname = true;
break;
case 'T':
- make_thin_archive = TRUE;
+ make_thin_archive = true;
break;
case 'D':
- deterministic = TRUE;
+ deterministic = true;
break;
case 'U':
- deterministic = FALSE;
+ deterministic = false;
break;
case OPTION_PLUGIN:
#if BFD_SUPPORTS_PLUGINS
ranlib_main (int argc, char **argv)
{
int arg_index, status = 0;
- bfd_boolean touch = FALSE;
+ bool touch = false;
int c;
while ((c = getopt_long (argc, argv, "DhHUvVt", long_options, NULL)) != EOF)
switch (c)
{
case 'D':
- deterministic = TRUE;
+ deterministic = true;
break;
case 'U':
- deterministic = FALSE;
+ deterministic = false;
break;
case 'h':
case 'H':
show_help = 1;
break;
case 't':
- touch = TRUE;
+ touch = true;
break;
case 'v':
case 'V':
obfd->flags |= BFD_ARCHIVE_FULL_PATH;
if (make_thin_archive || bfd_is_thin_archive (iarch))
- bfd_set_thin_archive (obfd, TRUE);
+ bfd_set_thin_archive (obfd, true);
if (!bfd_set_archive_head (obfd, contents_head))
bfd_fatal (old_name);
/* We don't care if this fails; we might be creating the archive. */
bfd_close (iarch);
- if (smart_rename (new_name, old_name, tmpfd, NULL, FALSE) != 0)
+ if (smart_rename (new_name, old_name, tmpfd, NULL, false) != 0)
xexit (1);
free (old_name);
free (new_name);
delete_members (bfd *arch, char **files_to_delete)
{
bfd **current_ptr_ptr;
- bfd_boolean found;
- bfd_boolean something_changed = FALSE;
+ bool found;
+ bool something_changed = false;
int match_count;
for (; *files_to_delete != NULL; ++files_to_delete)
if (!strcmp (*files_to_delete, "__.SYMDEF"))
{
- arch->has_armap = FALSE;
+ arch->has_armap = false;
write_armap = -1;
continue;
}
- found = FALSE;
+ found = false;
match_count = 0;
current_ptr_ptr = &(arch->archive_next);
while (*current_ptr_ptr)
}
else
{
- found = TRUE;
- something_changed = TRUE;
+ found = true;
+ something_changed = true;
if (verbose)
printf ("d - %s\n",
*files_to_delete);
/* Ought to default to replacing in place, but this is existing practice! */
static void
-replace_members (bfd *arch, char **files_to_move, bfd_boolean quick)
+replace_members (bfd *arch, char **files_to_move, bool quick)
{
- bfd_boolean changed = FALSE;
+ bool changed = false;
bfd **after_bfd; /* New entries go after this one. */
bfd *current;
bfd **current_ptr;
normalize (bfd_get_filename (current), arch)) == 0
&& current->arelt_data != NULL)
{
- bfd_boolean replaced;
+ bool replaced;
if (newer_only)
{
struct stat fsbuf, asbuf;
{
/* Snip out this entry from the chain. */
*current_ptr = (*current_ptr)->archive_next;
- changed = TRUE;
+ changed = true;
}
goto next_file;
want to hack multiple references. */
for (ptr = list; ptr; ptr = ptr->next)
{
- bfd_boolean found = FALSE;
+ bool found = false;
bfd *prev = arch;
for (head = arch->archive_next; head; head = head->archive_next)
if (bfd_get_filename (head) != NULL
&& FILENAME_CMP (ptr->name, bfd_get_filename (head)) == 0)
{
- found = TRUE;
+ found = true;
function (head, prev);
}
prev = head;
static void
ar_directory_doer (bfd *abfd, bfd *ignore ATTRIBUTE_UNUSED)
{
- print_arelt_descr(outfile, abfd, verbose, FALSE);
+ print_arelt_descr(outfile, abfd, verbose, false);
}
void
}
}
- smart_rename (temp_name, real_name, temp_fd, NULL, FALSE);
+ smart_rename (temp_name, real_name, temp_fd, NULL, false);
obfd = 0;
free (temp_name);
free (real_name);
return fstat (fileno ((FILE*) stream), sb);\r
}\r
\r
-static bfd_boolean\r
+static bool\r
check_format_any (struct bfd *abfd, bfd_format format)\r
{\r
char** targets = NULL;\r
\r
if (bfd_check_format_matches (abfd, format, &targets))\r
- return TRUE;\r
+ return true;\r
\r
if (targets)\r
{\r
return bfd_check_format (abfd, format);\r
}\r
\r
- return FALSE;\r
+ return false;\r
}\r
\r
int\r
fprintf (fp, _(" No emulation specific options\n"));
}
-bfd_boolean
+bool
ar_emul_append (bfd **after_bfd, char *file_name, const char *target,
- bfd_boolean verbose, bfd_boolean flatten)
+ bool verbose, bool flatten)
{
bfd *new_bfd;
return bin_dummy_emulation.ar_append (after_bfd, new_bfd,
verbose, flatten);
- return FALSE;
+ return false;
}
-bfd_boolean
+bool
ar_emul_append_bfd (bfd **after_bfd, bfd *new_bfd,
- bfd_boolean verbose, bfd_boolean flatten)
+ bool verbose, bool flatten)
{
if (bin_dummy_emulation.ar_append)
return bin_dummy_emulation.ar_append (after_bfd, new_bfd,
verbose, flatten);
- return FALSE;
+ return false;
}
-static bfd_boolean
+static bool
any_ok (bfd *new_bfd ATTRIBUTE_UNUSED)
{
- return TRUE;
+ return true;
}
-bfd_boolean
+bool
do_ar_emul_append (bfd **after_bfd, bfd *new_bfd,
- bfd_boolean verbose, bfd_boolean flatten,
- bfd_boolean (*check) (bfd *))
+ bool verbose, bool flatten,
+ bool (*check) (bfd *))
{
/* When flattening, add the members of an archive instead of the
archive itself. */
if (flatten && bfd_check_format (new_bfd, bfd_archive))
{
bfd *elt;
- bfd_boolean added = FALSE;
+ bool added = false;
for (elt = bfd_openr_next_archived_file (new_bfd, NULL);
elt;
elt = bfd_openr_next_archived_file (new_bfd, elt))
{
- if (do_ar_emul_append (after_bfd, elt, verbose, TRUE, check))
+ if (do_ar_emul_append (after_bfd, elt, verbose, true, check))
{
- added = TRUE;
+ added = true;
after_bfd = &((*after_bfd)->archive_next);
}
}
}
if (!check (new_bfd))
- return FALSE;
+ return false;
AR_EMUL_APPEND_PRINT_VERBOSE (verbose, bfd_get_filename (new_bfd));
new_bfd->archive_next = *after_bfd;
*after_bfd = new_bfd;
- return TRUE;
+ return true;
}
-bfd_boolean
+bool
ar_emul_default_append (bfd **after_bfd, bfd *new_bfd,
- bfd_boolean verbose, bfd_boolean flatten)
+ bool verbose, bool flatten)
{
return do_ar_emul_append (after_bfd, new_bfd, verbose, flatten, any_ok);
}
-bfd_boolean
+bool
ar_emul_replace (bfd **after_bfd, char *file_name, const char *target,
- bfd_boolean verbose)
+ bool verbose)
{
bfd *new_bfd;
return bin_dummy_emulation.ar_replace (after_bfd, new_bfd,
verbose);
- return FALSE;
+ return false;
}
-bfd_boolean
+bool
ar_emul_replace_bfd (bfd **after_bfd, bfd *new_bfd,
- bfd_boolean verbose)
+ bool verbose)
{
if (bin_dummy_emulation.ar_replace)
return bin_dummy_emulation.ar_replace (after_bfd, new_bfd,
verbose);
- return FALSE;
+ return false;
}
-bfd_boolean
+bool
ar_emul_default_replace (bfd **after_bfd, bfd *new_bfd,
- bfd_boolean verbose)
+ bool verbose)
{
AR_EMUL_REPLACE_PRINT_VERBOSE (verbose, bfd_get_filename (new_bfd));
new_bfd->archive_next = *after_bfd;
*after_bfd = new_bfd;
- return TRUE;
+ return true;
}
-bfd_boolean
+bool
ar_emul_parse_arg (char *arg)
{
if (bin_dummy_emulation.ar_parse_arg)
return bin_dummy_emulation.ar_parse_arg (arg);
- return FALSE;
+ return false;
}
-bfd_boolean
+bool
ar_emul_default_parse_arg (char *arg ATTRIBUTE_UNUSED)
{
- return FALSE;
+ return false;
}
extern void ar_emul_usage (FILE *);
extern void ar_emul_default_usage (FILE *);
-extern bfd_boolean ar_emul_append (bfd **, char *, const char *,
- bfd_boolean, bfd_boolean);
-extern bfd_boolean ar_emul_append_bfd (bfd **, bfd *,
- bfd_boolean, bfd_boolean);
-extern bfd_boolean ar_emul_default_append (bfd **, bfd *,
- bfd_boolean, bfd_boolean);
-extern bfd_boolean do_ar_emul_append (bfd **, bfd *,
- bfd_boolean, bfd_boolean,
- bfd_boolean (*)(bfd *));
-extern bfd_boolean ar_emul_replace (bfd **, char *, const char *,
- bfd_boolean);
-extern bfd_boolean ar_emul_replace_bfd (bfd **, bfd *,
- bfd_boolean);
-extern bfd_boolean ar_emul_default_replace (bfd **, bfd *,
- bfd_boolean);
-extern bfd_boolean ar_emul_parse_arg (char *);
-extern bfd_boolean ar_emul_default_parse_arg (char *);
+extern bool ar_emul_append (bfd **, char *, const char *, bool, bool);
+extern bool ar_emul_append_bfd (bfd **, bfd *, bool, bool);
+extern bool ar_emul_default_append (bfd **, bfd *, bool, bool);
+extern bool do_ar_emul_append (bfd **, bfd *, bool, bool, bool (*)(bfd *));
+extern bool ar_emul_replace (bfd **, char *, const char *, bool);
+extern bool ar_emul_replace_bfd (bfd **, bfd *, bool);
+extern bool ar_emul_default_replace (bfd **, bfd *, bool);
+extern bool ar_emul_parse_arg (char *);
+extern bool ar_emul_default_parse_arg (char *);
/* Macros for common output. */
typedef struct bin_emulation_xfer_struct
{
/* Print out the extra options. */
- void (* ar_usage) (FILE *fp);
- bfd_boolean (* ar_append) (bfd **, bfd *, bfd_boolean, bfd_boolean);
- bfd_boolean (* ar_replace) (bfd **, bfd *, bfd_boolean);
- bfd_boolean (* ar_parse_arg) (char *);
+ void (*ar_usage) (FILE *fp);
+ bool (*ar_append) (bfd **, bfd *, bool, bool);
+ bool (*ar_replace) (bfd **, bfd *, bool);
+ bool (*ar_parse_arg) (char *);
}
bin_emulation_xfer_type;
Mode User\tGroup\tSize\tDate Name */
void
-print_arelt_descr (FILE *file, bfd *abfd, bfd_boolean verbose, bfd_boolean offsets)
+print_arelt_descr (FILE *file, bfd *abfd, bool verbose, bool offsets)
{
struct stat buf;
is valid for writing. For security reasons absolute paths
and paths containing /../ are not allowed. See PR 17533. */
-bfd_boolean
+bool
is_valid_archive_path (char const * pathname)
{
const char * n = pathname;
if (IS_ABSOLUTE_PATH (n))
- return FALSE;
+ return false;
while (*n)
{
if (*n == '.' && *++n == '.' && ( ! *++n || IS_DIR_SEPARATOR (*n)))
- return FALSE;
+ return false;
while (*n && ! IS_DIR_SEPARATOR (*n))
n++;
n++;
}
- return TRUE;
+ return true;
}
int display_info (void);
-void print_arelt_descr (FILE *, bfd *, bfd_boolean, bfd_boolean);
+void print_arelt_descr (FILE *, bfd *, bool, bool);
char *make_tempname (const char *, int *);
char *make_tempdir (const char *);
off_t get_file_size (const char *);
-bfd_boolean is_valid_archive_path (char const *);
+bool is_valid_archive_path (char const *);
extern char *program_name;
extern void set_times (const char *, const struct stat *);
extern int smart_rename (const char *, const char *, int,
- struct stat *, bfd_boolean);
+ struct stat *, bool);
/* In libiberty. */
/* Routine used to read generic debugging information. */
-extern void *read_debugging_info (bfd *, asymbol **, long, bfd_boolean);
+extern void *read_debugging_info (bfd *, asymbol **, long, bool);
/* Routine used to print generic debugging information. */
-extern bfd_boolean print_debugging_info
+extern bool print_debugging_info
(FILE *, void *, bfd *, asymbol **,
- char * (*) (struct bfd *, const char *, int), bfd_boolean);
+ char * (*) (struct bfd *, const char *, int), bool);
/* Routines used to read and write stabs information. */
-extern void *start_stab (void *, bfd *, bfd_boolean, asymbol **, long);
+extern void *start_stab (void *, bfd *, bool, asymbol **, long);
-extern bfd_boolean finish_stab (void *, void *);
+extern bool finish_stab (void *, void *);
-extern bfd_boolean parse_stab
+extern bool parse_stab
(void *, void *, int, int, bfd_vma, const char *);
-extern bfd_boolean write_stabs_in_sections_debugging_info
+extern bool write_stabs_in_sections_debugging_info
(bfd *, void *, bfd_byte **, bfd_size_type *, bfd_byte **, bfd_size_type *);
/* Routine used to read COFF debugging information. */
-extern bfd_boolean parse_coff (bfd *, asymbol **, long, void *);
+extern bool parse_coff (bfd *, asymbol **, long, void *);
#endif
doit (void)
{
unsigned int i;
- bfd_boolean infile = FALSE;
+ bool infile = false;
struct coff_ofile *head =
(struct coff_ofile *) xmalloc (sizeof (struct coff_ofile));
if (infile)
pop_scope ();
else
- infile = TRUE;
+ infile = true;
push_scope (1);
file_scope = n->scope = top_scope;
struct debug_indirect_type *kindirect;
/* DEBUG_KIND_INT. */
/* Whether the integer is unsigned. */
- bfd_boolean kint;
+ bool kint;
/* DEBUG_KIND_STRUCT, DEBUG_KIND_UNION, DEBUG_KIND_CLASS,
DEBUG_KIND_UNION_CLASS. */
struct debug_class_type *kclass;
/* NULL terminated array of argument types. */
debug_type *arg_types;
/* Whether the function takes a variable number of arguments. */
- bfd_boolean varargs;
+ bool varargs;
};
/* Information kept for a range. */
/* Upper bound. */
bfd_signed_vma upper;
/* Whether this array is really a string. */
- bfd_boolean stringp;
+ bool stringp;
};
/* Information kept for a set. */
/* Base type. */
debug_type type;
/* Whether this set is really a bitstring. */
- bfd_boolean bitstringp;
+ bool bitstringp;
};
/* Information kept for an offset type (a based pointer). */
/* A NULL terminated array of argument types. */
debug_type *arg_types;
/* Whether the method takes a variable number of arguments. */
- bfd_boolean varargs;
+ bool varargs;
};
/* Information kept for a named type. */
/* Visibility of the field. */
enum debug_visibility visibility;
/* Whether this is a static member. */
- bfd_boolean static_member;
+ bool static_member;
union
{
/* If static_member is false. */
/* Bit position of the base class in the object. */
unsigned int bitpos;
/* Whether the base class is virtual. */
- bfd_boolean is_virtual;
+ bool is_virtual;
/* Visibility of the base class. */
enum debug_visibility visibility;
};
/* The visibility of the function. */
enum debug_visibility visibility;
/* Whether the function is const. */
- bfd_boolean constp;
+ bool constp;
/* Whether the function is volatile. */
- bfd_boolean volatilep;
+ bool volatilep;
/* The offset to the function in the virtual function table. */
bfd_vma voffset;
/* If voffset is VOFFSET_STATIC_METHOD, this is a static method. */
(struct debug_handle *, enum debug_type_kind, unsigned int);
static struct debug_type_s *debug_get_real_type
(void *, debug_type, struct debug_type_real_list *);
-static bfd_boolean debug_write_name
+static bool debug_write_name
(struct debug_handle *, const struct debug_write_fns *, void *,
struct debug_name *);
-static bfd_boolean debug_write_type
+static bool debug_write_type
(struct debug_handle *, const struct debug_write_fns *, void *,
struct debug_type_s *, struct debug_name *);
-static bfd_boolean debug_write_class_type
+static bool debug_write_class_type
(struct debug_handle *, const struct debug_write_fns *, void *,
struct debug_type_s *, const char *);
-static bfd_boolean debug_write_function
+static bool debug_write_function
(struct debug_handle *, const struct debug_write_fns *, void *,
const char *, enum debug_object_linkage, struct debug_function *);
-static bfd_boolean debug_write_block
+static bool debug_write_block
(struct debug_handle *, const struct debug_write_fns *, void *,
struct debug_block *);
-static bfd_boolean debug_write_linenos
+static bool debug_write_linenos
(struct debug_handle *, const struct debug_write_fns *, void *, bfd_vma);
-static bfd_boolean debug_set_class_id
+static bool debug_set_class_id
(struct debug_handle *, const char *, struct debug_type_s *);
-static bfd_boolean debug_type_samep
+static bool debug_type_samep
(struct debug_handle *, struct debug_type_s *, struct debug_type_s *);
-static bfd_boolean debug_class_type_samep
+static bool debug_class_type_samep
(struct debug_handle *, struct debug_type_s *, struct debug_type_s *);
\f
/* Issue an error message. */
/* Set the source filename. This implicitly starts a new compilation
unit. */
-bfd_boolean
+bool
debug_set_filename (void *handle, const char *name)
{
struct debug_handle *info = (struct debug_handle *) handle;
info->current_block = NULL;
info->current_lineno = NULL;
- return TRUE;
+ return true;
}
/* Change source files to the given file name. This is used for
include files in a single compilation unit. */
-bfd_boolean
+bool
debug_start_source (void *handle, const char *name)
{
struct debug_handle *info = (struct debug_handle *) handle;
if (info->current_unit == NULL)
{
debug_error (_("debug_start_source: no debug_set_filename call"));
- return FALSE;
+ return false;
}
for (f = info->current_unit->files; f != NULL; f = f->next)
if (filename_cmp (f->filename, name) == 0)
{
info->current_file = f;
- return TRUE;
+ return true;
}
}
info->current_file = f;
- return TRUE;
+ return true;
}
/* Record a function definition. This implicitly starts a function
debug_record_parameter. FIXME: There is no way to specify nested
functions. */
-bfd_boolean
+bool
debug_record_function (void *handle, const char *name,
- debug_type return_type, bfd_boolean global,
+ debug_type return_type, bool global,
bfd_vma addr)
{
struct debug_handle *info = (struct debug_handle *) handle;
if (name == NULL)
name = "";
if (return_type == NULL)
- return FALSE;
+ return false;
if (info->current_unit == NULL)
{
debug_error (_("debug_record_function: no debug_set_filename call"));
- return FALSE;
+ return false;
}
f = (struct debug_function *) xmalloc (sizeof *f);
? DEBUG_LINKAGE_GLOBAL
: DEBUG_LINKAGE_STATIC));
if (n == NULL)
- return FALSE;
+ return false;
n->u.function = f;
- return TRUE;
+ return true;
}
/* Record a parameter for the current function. */
-bfd_boolean
+bool
debug_record_parameter (void *handle, const char *name, debug_type type,
enum debug_parm_kind kind, bfd_vma val)
{
struct debug_parameter *p, **pp;
if (name == NULL || type == NULL)
- return FALSE;
+ return false;
if (info->current_unit == NULL
|| info->current_function == NULL)
{
debug_error (_("debug_record_parameter: no current function"));
- return FALSE;
+ return false;
}
p = (struct debug_parameter *) xmalloc (sizeof *p);
;
*pp = p;
- return TRUE;
+ return true;
}
/* End a function. FIXME: This should handle function nesting. */
-bfd_boolean
+bool
debug_end_function (void *handle, bfd_vma addr)
{
struct debug_handle *info = (struct debug_handle *) handle;
|| info->current_function == NULL)
{
debug_error (_("debug_end_function: no current function"));
- return FALSE;
+ return false;
}
if (info->current_block->parent != NULL)
{
debug_error (_("debug_end_function: some blocks were not closed"));
- return FALSE;
+ return false;
}
info->current_block->end = addr;
info->current_function = NULL;
info->current_block = NULL;
- return TRUE;
+ return true;
}
/* Start a block in a function. All local information will be
debug_start_block and debug_end_block may be nested. The bfd_vma
argument is the address at which this block starts. */
-bfd_boolean
+bool
debug_start_block (void *handle, bfd_vma addr)
{
struct debug_handle *info = (struct debug_handle *) handle;
|| info->current_block == NULL)
{
debug_error (_("debug_start_block: no current block"));
- return FALSE;
+ return false;
}
b = (struct debug_block *) xmalloc (sizeof *b);
info->current_block = b;
- return TRUE;
+ return true;
}
/* Finish a block in a function. This matches the call to
debug_start_block. The argument is the address at which this block
ends. */
-bfd_boolean
+bool
debug_end_block (void *handle, bfd_vma addr)
{
struct debug_handle *info = (struct debug_handle *) handle;
|| info->current_block == NULL)
{
debug_error (_("debug_end_block: no current block"));
- return FALSE;
+ return false;
}
parent = info->current_block->parent;
if (parent == NULL)
{
debug_error (_("debug_end_block: attempt to close top level block"));
- return FALSE;
+ return false;
}
info->current_block->end = addr;
info->current_block = parent;
- return TRUE;
+ return true;
}
/* Associate a line number in the current source file and function
with a given address. */
-bfd_boolean
+bool
debug_record_line (void *handle, unsigned long lineno, bfd_vma addr)
{
struct debug_handle *info = (struct debug_handle *) handle;
if (info->current_unit == NULL)
{
debug_error (_("debug_record_line: no current unit"));
- return FALSE;
+ return false;
}
l = info->current_lineno;
{
l->linenos[i] = lineno;
l->addrs[i] = addr;
- return TRUE;
+ return true;
}
}
}
info->current_lineno = l;
- return TRUE;
+ return true;
}
/* Start a named common block. This is a block of variables that may
move in memory. */
-bfd_boolean
+bool
debug_start_common_block (void *handle ATTRIBUTE_UNUSED,
const char *name ATTRIBUTE_UNUSED)
{
/* FIXME */
debug_error (_("debug_start_common_block: not implemented"));
- return FALSE;
+ return false;
}
/* End a named common block. */
-bfd_boolean
+bool
debug_end_common_block (void *handle ATTRIBUTE_UNUSED,
const char *name ATTRIBUTE_UNUSED)
{
/* FIXME */
debug_error (_("debug_end_common_block: not implemented"));
- return FALSE;
+ return false;
}
/* Record a named integer constant. */
-bfd_boolean
+bool
debug_record_int_const (void *handle, const char *name, bfd_vma val)
{
struct debug_handle *info = (struct debug_handle *) handle;
struct debug_name *n;
if (name == NULL)
- return FALSE;
+ return false;
n = debug_add_to_current_namespace (info, name, DEBUG_OBJECT_INT_CONSTANT,
DEBUG_LINKAGE_NONE);
if (n == NULL)
- return FALSE;
+ return false;
n->u.int_constant = val;
- return TRUE;
+ return true;
}
/* Record a named floating point constant. */
-bfd_boolean
+bool
debug_record_float_const (void *handle, const char *name, double val)
{
struct debug_handle *info = (struct debug_handle *) handle;
struct debug_name *n;
if (name == NULL)
- return FALSE;
+ return false;
n = debug_add_to_current_namespace (info, name, DEBUG_OBJECT_FLOAT_CONSTANT,
DEBUG_LINKAGE_NONE);
if (n == NULL)
- return FALSE;
+ return false;
n->u.float_constant = val;
- return TRUE;
+ return true;
}
/* Record a typed constant with an integral value. */
-bfd_boolean
+bool
debug_record_typed_const (void *handle, const char *name, debug_type type,
bfd_vma val)
{
struct debug_typed_constant *tc;
if (name == NULL || type == NULL)
- return FALSE;
+ return false;
n = debug_add_to_current_namespace (info, name, DEBUG_OBJECT_TYPED_CONSTANT,
DEBUG_LINKAGE_NONE);
if (n == NULL)
- return FALSE;
+ return false;
tc = (struct debug_typed_constant *) xmalloc (sizeof *tc);
memset (tc, 0, sizeof *tc);
n->u.typed_constant = tc;
- return TRUE;
+ return true;
}
/* Record a label. */
-bfd_boolean
+bool
debug_record_label (void *handle ATTRIBUTE_UNUSED,
const char *name ATTRIBUTE_UNUSED,
debug_type type ATTRIBUTE_UNUSED,
{
/* FIXME. */
debug_error (_("debug_record_label: not implemented"));
- return FALSE;
+ return false;
}
/* Record a variable. */
-bfd_boolean
+bool
debug_record_variable (void *handle, const char *name, debug_type type,
enum debug_var_kind kind, bfd_vma val)
{
struct debug_variable *v;
if (name == NULL || type == NULL)
- return FALSE;
+ return false;
if (info->current_unit == NULL
|| info->current_file == NULL)
{
debug_error (_("debug_record_variable: no current file"));
- return FALSE;
+ return false;
}
if (kind == DEBUG_GLOBAL || kind == DEBUG_STATIC)
n = debug_add_to_namespace (info, nsp, name, DEBUG_OBJECT_VARIABLE, linkage);
if (n == NULL)
- return FALSE;
+ return false;
v = (struct debug_variable *) xmalloc (sizeof *v);
memset (v, 0, sizeof *v);
n->u.variable = v;
- return TRUE;
+ return true;
}
/* Make a type with a given kind and size. */
if the integer is unsigned. */
debug_type
-debug_make_int_type (void *handle, unsigned int size, bfd_boolean unsignedp)
+debug_make_int_type (void *handle, unsigned int size, bool unsignedp)
{
struct debug_handle *info = (struct debug_handle *) handle;
struct debug_type_s *t;
The fourth argument is a NULL terminated array of fields. */
debug_type
-debug_make_struct_type (void *handle, bfd_boolean structp, bfd_vma size,
+debug_make_struct_type (void *handle, bool structp, bfd_vma size,
debug_field *fields)
{
struct debug_handle *info = (struct debug_handle *) handle;
object has its own virtual function table. */
debug_type
-debug_make_object_type (void *handle, bfd_boolean structp, bfd_vma size,
+debug_make_object_type (void *handle, bool structp, bfd_vma size,
debug_field *fields, debug_baseclass *baseclasses,
debug_method *methods, debug_type vptrbase,
- bfd_boolean ownvptr)
+ bool ownvptr)
{
struct debug_handle *info = (struct debug_handle *) handle;
struct debug_type_s *t;
debug_type
debug_make_function_type (void *handle, debug_type type,
- debug_type *arg_types, bfd_boolean varargs)
+ debug_type *arg_types, bool varargs)
{
struct debug_handle *info = (struct debug_handle *) handle;
struct debug_type_s *t;
debug_type
debug_make_array_type (void *handle, debug_type element_type,
debug_type range_type, bfd_signed_vma lower,
- bfd_signed_vma upper, bfd_boolean stringp)
+ bfd_signed_vma upper, bool stringp)
{
struct debug_handle *info = (struct debug_handle *) handle;
struct debug_type_s *t;
CHILL. */
debug_type
-debug_make_set_type (void *handle, debug_type type, bfd_boolean bitstringp)
+debug_make_set_type (void *handle, debug_type type, bool bitstringp)
{
struct debug_handle *info = (struct debug_handle *) handle;
struct debug_type_s *t;
debug_type
debug_make_method_type (void *handle, debug_type return_type,
debug_type domain_type, debug_type *arg_types,
- bfd_boolean varargs)
+ bool varargs)
{
struct debug_handle *info = (struct debug_handle *) handle;
struct debug_type_s *t;
debug_baseclass
debug_make_baseclass (void *handle ATTRIBUTE_UNUSED, debug_type type,
- bfd_vma bitpos, bfd_boolean is_virtual,
+ bfd_vma bitpos, bool is_virtual,
enum debug_visibility visibility)
{
struct debug_baseclass_s *b;
f->name = name;
f->type = type;
- f->static_member = FALSE;
+ f->static_member = false;
f->u.f.bitpos = bitpos;
f->u.f.bitsize = bitsize;
f->visibility = visibility;
f->name = name;
f->type = type;
- f->static_member = TRUE;
+ f->static_member = true;
f->u.s.physname = physname;
f->visibility = visibility;
debug_make_method_variant (void *handle ATTRIBUTE_UNUSED,
const char *physname, debug_type type,
enum debug_visibility visibility,
- bfd_boolean constp, bfd_boolean volatilep,
+ bool constp, bool volatilep,
bfd_vma voffset, debug_type context)
{
struct debug_method_variant_s *m;
debug_make_static_method_variant (void *handle ATTRIBUTE_UNUSED,
const char *physname, debug_type type,
enum debug_visibility visibility,
- bfd_boolean constp, bfd_boolean volatilep)
+ bool constp, bool volatilep)
{
struct debug_method_variant_s *m;
/* Record the size of a given type. */
-bfd_boolean
+bool
debug_record_type_size (void *handle ATTRIBUTE_UNUSED, debug_type type,
unsigned int size)
{
type->size = size;
- return TRUE;
+ return true;
}
/* Find a named type. */
const debug_type *
debug_get_parameter_types (void *handle, debug_type type,
- bfd_boolean *pvarargs)
+ bool *pvarargs)
{
if (type == NULL)
return NULL;
/* Write out the debugging information. This is given a handle to
debugging information, and a set of function pointers to call. */
-bfd_boolean
+bool
debug_write (void *handle, const struct debug_write_fns *fns, void *fhandle)
{
struct debug_handle *info = (struct debug_handle *) handle;
for (u = info->units; u != NULL; u = u->next)
{
struct debug_file *f;
- bfd_boolean first_file;
+ bool first_file;
info->current_write_lineno = u->linenos;
info->current_write_lineno_index = 0;
if (! (*fns->start_compilation_unit) (fhandle, u->files->filename))
- return FALSE;
+ return false;
- first_file = TRUE;
+ first_file = true;
for (f = u->files; f != NULL; f = f->next)
{
struct debug_name *n;
if (first_file)
- first_file = FALSE;
+ first_file = false;
else if (! (*fns->start_source) (fhandle, f->filename))
- return FALSE;
+ return false;
if (f->globals != NULL)
for (n = f->globals->list; n != NULL; n = n->next)
if (! debug_write_name (info, fns, fhandle, n))
- return FALSE;
+ return false;
}
/* Output any line number information which hasn't already been
handled. */
if (! debug_write_linenos (info, fns, fhandle, (bfd_vma) -1))
- return FALSE;
+ return false;
}
- return TRUE;
+ return true;
}
/* Write out an element in a namespace. */
-static bfd_boolean
+static bool
debug_write_name (struct debug_handle *info,
const struct debug_write_fns *fns, void *fhandle,
struct debug_name *n)
case DEBUG_OBJECT_TYPE:
if (! debug_write_type (info, fns, fhandle, n->u.type, n)
|| ! (*fns->typdef) (fhandle, n->name))
- return FALSE;
- return TRUE;
+ return false;
+ return true;
case DEBUG_OBJECT_TAG:
if (! debug_write_type (info, fns, fhandle, n->u.tag, n))
- return FALSE;
+ return false;
return (*fns->tag) (fhandle, n->name);
case DEBUG_OBJECT_VARIABLE:
if (! debug_write_type (info, fns, fhandle, n->u.variable->type,
(struct debug_name *) NULL))
- return FALSE;
+ return false;
return (*fns->variable) (fhandle, n->name, n->u.variable->kind,
n->u.variable->val);
case DEBUG_OBJECT_FUNCTION:
case DEBUG_OBJECT_TYPED_CONSTANT:
if (! debug_write_type (info, fns, fhandle, n->u.typed_constant->type,
(struct debug_name *) NULL))
- return FALSE;
+ return false;
return (*fns->typed_constant) (fhandle, n->name,
n->u.typed_constant->val);
default:
abort ();
- return FALSE;
+ return false;
}
/*NOTREACHED*/
}
then the name argument is a tag from a DEBUG_KIND_TAGGED type which
points to this one. */
-static bfd_boolean
+static bool
debug_write_type (struct debug_handle *info,
const struct debug_write_fns *fns, void *fhandle,
struct debug_type_s *type, struct debug_name *name)
if (! debug_set_class_id (info,
type->u.knamed->name->name,
real))
- return FALSE;
+ return false;
}
id = real->u.kclass->id;
}
{
case DEBUG_KIND_ILLEGAL:
debug_error (_("debug_write_type: illegal type encountered"));
- return FALSE;
+ return false;
case DEBUG_KIND_INDIRECT:
return debug_write_type (info, fns, fhandle, *type->u.kindirect->slot,
name);
if (type->u.kclass->id <= info->base_id)
{
if (! debug_set_class_id (info, tag, type))
- return FALSE;
+ return false;
}
if (info->mark == type->u.kclass->mark)
: 0),
type->kind == DEBUG_KIND_STRUCT,
type->size))
- return FALSE;
+ return false;
if (type->u.kclass != NULL
&& type->u.kclass->fields != NULL)
{
(struct debug_name *) NULL)
|| ! (*fns->struct_field) (fhandle, f->name, f->u.f.bitpos,
f->u.f.bitsize, f->visibility))
- return FALSE;
+ return false;
}
}
return (*fns->end_struct_type) (fhandle);
case DEBUG_KIND_POINTER:
if (! debug_write_type (info, fns, fhandle, type->u.kpointer,
(struct debug_name *) NULL))
- return FALSE;
+ return false;
return (*fns->pointer_type) (fhandle);
case DEBUG_KIND_FUNCTION:
if (! debug_write_type (info, fns, fhandle,
type->u.kfunction->return_type,
(struct debug_name *) NULL))
- return FALSE;
+ return false;
if (type->u.kfunction->arg_types == NULL)
is = -1;
else
if (! debug_write_type (info, fns, fhandle,
type->u.kfunction->arg_types[is],
(struct debug_name *) NULL))
- return FALSE;
+ return false;
}
return (*fns->function_type) (fhandle, is,
type->u.kfunction->varargs);
case DEBUG_KIND_REFERENCE:
if (! debug_write_type (info, fns, fhandle, type->u.kreference,
(struct debug_name *) NULL))
- return FALSE;
+ return false;
return (*fns->reference_type) (fhandle);
case DEBUG_KIND_RANGE:
if (! debug_write_type (info, fns, fhandle, type->u.krange->type,
(struct debug_name *) NULL))
- return FALSE;
+ return false;
return (*fns->range_type) (fhandle, type->u.krange->lower,
type->u.krange->upper);
case DEBUG_KIND_ARRAY:
|| ! debug_write_type (info, fns, fhandle,
type->u.karray->range_type,
(struct debug_name *) NULL))
- return FALSE;
+ return false;
return (*fns->array_type) (fhandle, type->u.karray->lower,
type->u.karray->upper,
type->u.karray->stringp);
case DEBUG_KIND_SET:
if (! debug_write_type (info, fns, fhandle, type->u.kset->type,
(struct debug_name *) NULL))
- return FALSE;
+ return false;
return (*fns->set_type) (fhandle, type->u.kset->bitstringp);
case DEBUG_KIND_OFFSET:
if (! debug_write_type (info, fns, fhandle, type->u.koffset->base_type,
|| ! debug_write_type (info, fns, fhandle,
type->u.koffset->target_type,
(struct debug_name *) NULL))
- return FALSE;
+ return false;
return (*fns->offset_type) (fhandle);
case DEBUG_KIND_METHOD:
if (! debug_write_type (info, fns, fhandle,
type->u.kmethod->return_type,
(struct debug_name *) NULL))
- return FALSE;
+ return false;
if (type->u.kmethod->arg_types == NULL)
is = -1;
else
if (! debug_write_type (info, fns, fhandle,
type->u.kmethod->arg_types[is],
(struct debug_name *) NULL))
- return FALSE;
+ return false;
}
if (type->u.kmethod->domain_type != NULL)
{
if (! debug_write_type (info, fns, fhandle,
type->u.kmethod->domain_type,
(struct debug_name *) NULL))
- return FALSE;
+ return false;
}
return (*fns->method_type) (fhandle,
type->u.kmethod->domain_type != NULL,
case DEBUG_KIND_CONST:
if (! debug_write_type (info, fns, fhandle, type->u.kconst,
(struct debug_name *) NULL))
- return FALSE;
+ return false;
return (*fns->const_type) (fhandle);
case DEBUG_KIND_VOLATILE:
if (! debug_write_type (info, fns, fhandle, type->u.kvolatile,
(struct debug_name *) NULL))
- return FALSE;
+ return false;
return (*fns->volatile_type) (fhandle);
case DEBUG_KIND_NAMED:
return debug_write_type (info, fns, fhandle, type->u.knamed->type,
type->u.knamed->name);
default:
abort ();
- return FALSE;
+ return false;
}
}
/* Write out a class type. */
-static bfd_boolean
+static bool
debug_write_class_type (struct debug_handle *info,
const struct debug_write_fns *fns, void *fhandle,
struct debug_type_s *type, const char *tag)
if (type->u.kclass->id <= info->base_id)
{
if (! debug_set_class_id (info, tag, type))
- return FALSE;
+ return false;
}
if (info->mark == type->u.kclass->mark)
{
if (! debug_write_type (info, fns, fhandle, vptrbase,
(struct debug_name *) NULL))
- return FALSE;
+ return false;
}
}
type->size,
vptrbase != NULL,
vptrbase == type))
- return FALSE;
+ return false;
if (type->u.kclass != NULL)
{
f = type->u.kclass->fields[i];
if (! debug_write_type (info, fns, fhandle, f->type,
(struct debug_name *) NULL))
- return FALSE;
+ return false;
if (f->static_member)
{
if (! (*fns->class_static_member) (fhandle, f->name,
f->u.s.physname,
f->visibility))
- return FALSE;
+ return false;
}
else
{
if (! (*fns->struct_field) (fhandle, f->name, f->u.f.bitpos,
f->u.f.bitsize, f->visibility))
- return FALSE;
+ return false;
}
}
}
b = type->u.kclass->baseclasses[i];
if (! debug_write_type (info, fns, fhandle, b->type,
(struct debug_name *) NULL))
- return FALSE;
+ return false;
if (! (*fns->class_baseclass) (fhandle, b->bitpos, b->is_virtual,
b->visibility))
- return FALSE;
+ return false;
}
}
m = type->u.kclass->methods[i];
if (! (*fns->class_start_method) (fhandle, m->name))
- return FALSE;
+ return false;
for (j = 0; m->variants[j] != NULL; j++)
{
struct debug_method_variant_s *v;
{
if (! debug_write_type (info, fns, fhandle, v->context,
(struct debug_name *) NULL))
- return FALSE;
+ return false;
}
if (! debug_write_type (info, fns, fhandle, v->type,
(struct debug_name *) NULL))
- return FALSE;
+ return false;
if (v->voffset != VOFFSET_STATIC_METHOD)
{
if (! (*fns->class_method_variant) (fhandle, v->physname,
v->volatilep,
v->voffset,
v->context != NULL))
- return FALSE;
+ return false;
}
else
{
v->visibility,
v->constp,
v->volatilep))
- return FALSE;
+ return false;
}
}
if (! (*fns->class_end_method) (fhandle))
- return FALSE;
+ return false;
}
}
}
/* Write out information for a function. */
-static bfd_boolean
+static bool
debug_write_function (struct debug_handle *info,
const struct debug_write_fns *fns, void *fhandle,
const char *name, enum debug_object_linkage linkage,
struct debug_block *b;
if (! debug_write_linenos (info, fns, fhandle, function->blocks->start))
- return FALSE;
+ return false;
if (! debug_write_type (info, fns, fhandle, function->return_type,
(struct debug_name *) NULL))
- return FALSE;
+ return false;
if (! (*fns->start_function) (fhandle, name,
linkage == DEBUG_LINKAGE_GLOBAL))
- return FALSE;
+ return false;
for (p = function->parameters; p != NULL; p = p->next)
{
if (! debug_write_type (info, fns, fhandle, p->type,
(struct debug_name *) NULL)
|| ! (*fns->function_parameter) (fhandle, p->name, p->kind, p->val))
- return FALSE;
+ return false;
}
for (b = function->blocks; b != NULL; b = b->next)
{
if (! debug_write_block (info, fns, fhandle, b))
- return FALSE;
+ return false;
}
return (*fns->end_function) (fhandle);
/* Write out information for a block. */
-static bfd_boolean
+static bool
debug_write_block (struct debug_handle *info,
const struct debug_write_fns *fns, void *fhandle,
struct debug_block *block)
struct debug_block *b;
if (! debug_write_linenos (info, fns, fhandle, block->start))
- return FALSE;
+ return false;
/* I can't see any point to writing out a block with no local
variables, so we don't bother, except for the top level block. */
if (block->locals != NULL || block->parent == NULL)
{
if (! (*fns->start_block) (fhandle, block->start))
- return FALSE;
+ return false;
}
if (block->locals != NULL)
for (n = block->locals->list; n != NULL; n = n->next)
{
if (! debug_write_name (info, fns, fhandle, n))
- return FALSE;
+ return false;
}
}
for (b = block->children; b != NULL; b = b->next)
{
if (! debug_write_block (info, fns, fhandle, b))
- return FALSE;
+ return false;
}
if (! debug_write_linenos (info, fns, fhandle, block->end))
- return FALSE;
+ return false;
if (block->locals != NULL || block->parent == NULL)
{
if (! (*fns->end_block) (fhandle, block->end))
- return FALSE;
+ return false;
}
- return TRUE;
+ return true;
}
/* Write out line number information up to ADDRESS. */
-static bfd_boolean
+static bool
debug_write_linenos (struct debug_handle *info,
const struct debug_write_fns *fns, void *fhandle,
bfd_vma address)
break;
if (l->addrs[info->current_write_lineno_index] >= address)
- return TRUE;
+ return true;
if (! (*fns->lineno) (fhandle, l->file->filename,
l->linenos[info->current_write_lineno_index],
l->addrs[info->current_write_lineno_index]))
- return FALSE;
+ return false;
++info->current_write_lineno_index;
}
info->current_write_lineno_index = 0;
}
- return TRUE;
+ return true;
}
/* Get the ID number for a class. If during the same call to
name, we use the same ID. This type of things happens because the
same struct will be defined by multiple compilation units. */
-static bfd_boolean
+static bool
debug_set_class_id (struct debug_handle *info, const char *tag,
struct debug_type_s *type)
{
c = type->u.kclass;
if (c->id > info->base_id)
- return TRUE;
+ return true;
for (l = info->id_list; l != NULL; l = l->next)
{
if (debug_type_samep (info, l->type, type))
{
c->id = l->type->u.kclass->id;
- return TRUE;
+ return true;
}
}
l->next = info->id_list;
info->id_list = l;
- return TRUE;
+ return true;
}
/* See if two types are the same. At this point, we don't care about
tags and the like. */
-static bfd_boolean
+static bool
debug_type_samep (struct debug_handle *info, struct debug_type_s *t1,
struct debug_type_s *t2)
{
struct debug_type_compare_list *l;
struct debug_type_compare_list top;
- bfd_boolean ret;
+ bool ret;
if (t1 == NULL)
return t2 == NULL;
if (t2 == NULL)
- return FALSE;
+ return false;
while (t1->kind == DEBUG_KIND_INDIRECT)
{
t1 = *t1->u.kindirect->slot;
if (t1 == NULL)
- return FALSE;
+ return false;
}
while (t2->kind == DEBUG_KIND_INDIRECT)
{
t2 = *t2->u.kindirect->slot;
if (t2 == NULL)
- return FALSE;
+ return false;
}
if (t1 == t2)
- return TRUE;
+ return true;
/* As a special case, permit a typedef to match a tag, since C++
debugging output will sometimes add a typedef where C debugging
if (t1->kind != t2->kind
|| t1->size != t2->size)
- return FALSE;
+ return false;
/* Get rid of the trivial cases first. */
switch (t1->kind)
case DEBUG_KIND_FLOAT:
case DEBUG_KIND_COMPLEX:
case DEBUG_KIND_BOOL:
- return TRUE;
+ return true;
case DEBUG_KIND_INT:
return t1->u.kint == t2->u.kint;
}
for (l = info->compare_list; l != NULL; l = l->next)
{
if (l->t1 == t1 && l->t2 == t2)
- return TRUE;
+ return true;
}
top.t1 = t1;
{
default:
abort ();
- ret = FALSE;
+ ret = false;
break;
case DEBUG_KIND_STRUCT:
if (t1->u.kclass == NULL)
ret = t2->u.kclass == NULL;
else if (t2->u.kclass == NULL)
- ret = FALSE;
+ ret = false;
else if (t1->u.kclass->id > info->base_id
&& t1->u.kclass->id == t2->u.kclass->id)
- ret = TRUE;
+ ret = true;
else
ret = debug_class_type_samep (info, t1, t2);
break;
if (t1->u.kenum == NULL)
ret = t2->u.kenum == NULL;
else if (t2->u.kenum == NULL)
- ret = FALSE;
+ ret = false;
else
{
const char **pn1, **pn2;
t2->u.kfunction->return_type)
|| ((t1->u.kfunction->arg_types == NULL)
!= (t2->u.kfunction->arg_types == NULL)))
- ret = FALSE;
+ ret = false;
else if (t1->u.kfunction->arg_types == NULL)
- ret = TRUE;
+ ret = true;
else
{
struct debug_type_s **a1, **a2;
t2->u.kmethod->domain_type)
|| ((t1->u.kmethod->arg_types == NULL)
!= (t2->u.kmethod->arg_types == NULL)))
- ret = FALSE;
+ ret = false;
else if (t1->u.kmethod->arg_types == NULL)
- ret = TRUE;
+ ret = true;
else
{
struct debug_type_s **a1, **a2;
/* See if two classes are the same. This is a subroutine of
debug_type_samep. */
-static bfd_boolean
+static bool
debug_class_type_samep (struct debug_handle *info, struct debug_type_s *t1,
struct debug_type_s *t2)
{
|| (c1->baseclasses == NULL) != (c2->baseclasses == NULL)
|| (c1->methods == NULL) != (c2->methods == NULL)
|| (c1->vptrbase == NULL) != (c2->vptrbase == NULL))
- return FALSE;
+ return false;
if (c1->fields != NULL)
{
if (f1->name[0] != f2->name[0]
|| f1->visibility != f2->visibility
|| f1->static_member != f2->static_member)
- return FALSE;
+ return false;
if (f1->static_member)
{
if (strcmp (f1->u.s.physname, f2->u.s.physname) != 0)
- return FALSE;
+ return false;
}
else
{
if (f1->u.f.bitpos != f2->u.f.bitpos
|| f1->u.f.bitsize != f2->u.f.bitsize)
- return FALSE;
+ return false;
}
/* We do the checks which require function calls last. We
don't require that the types of fields have the same
f1->type, NULL),
debug_get_real_type ((void *) info,
f2->type, NULL)))
- return FALSE;
+ return false;
}
if (*pf1 != NULL || *pf2 != NULL)
- return FALSE;
+ return false;
}
if (c1->vptrbase != NULL)
{
if (! debug_type_samep (info, c1->vptrbase, c2->vptrbase))
- return FALSE;
+ return false;
}
if (c1->baseclasses != NULL)
|| b1->is_virtual != b2->is_virtual
|| b1->visibility != b2->visibility
|| ! debug_type_samep (info, b1->type, b2->type))
- return FALSE;
+ return false;
}
if (*pb1 != NULL || *pb2 != NULL)
- return FALSE;
+ return false;
}
if (c1->methods != NULL)
if (m1->name[0] != m2->name[0]
|| strcmp (m1->name, m2->name) != 0
|| (m1->variants == NULL) != (m2->variants == NULL))
- return FALSE;
+ return false;
if (m1->variants == NULL)
{
struct debug_method_variant_s **pv1, **pv2;
|| (v1->context == NULL) != (v2->context == NULL)
|| strcmp (v1->physname, v2->physname) != 0
|| ! debug_type_samep (info, v1->type, v2->type))
- return FALSE;
+ return false;
if (v1->context != NULL)
{
if (! debug_type_samep (info, v1->context,
v2->context))
- return FALSE;
+ return false;
}
}
if (*pv1 != NULL || *pv2 != NULL)
- return FALSE;
+ return false;
}
}
if (*pm1 != NULL || *pm2 != NULL)
- return FALSE;
+ return false;
}
- return TRUE;
+ return true;
}
{
/* This is called at the start of each new compilation unit with the
name of the main file in the new unit. */
- bfd_boolean (*start_compilation_unit) (void *, const char *);
+ bool (*start_compilation_unit) (void *, const char *);
/* This is called at the start of each source file within a
compilation unit, before outputting any global information for
that file. The argument is the name of the file. */
- bfd_boolean (*start_source) (void *, const char *);
+ bool (*start_source) (void *, const char *);
/* Each writer must keep a stack of types. */
/* Push an empty type onto the type stack. This type can appear if
there is a reference to a type which is never defined. */
- bfd_boolean (*empty_type) (void *);
+ bool (*empty_type) (void *);
/* Push a void type onto the type stack. */
- bfd_boolean (*void_type) (void *);
+ bool (*void_type) (void *);
/* Push an integer type onto the type stack, given the size and
whether it is unsigned. */
- bfd_boolean (*int_type) (void *, unsigned int, bfd_boolean);
+ bool (*int_type) (void *, unsigned int, bool);
/* Push a floating type onto the type stack, given the size. */
- bfd_boolean (*float_type) (void *, unsigned int);
+ bool (*float_type) (void *, unsigned int);
/* Push a complex type onto the type stack, given the size. */
- bfd_boolean (*complex_type) (void *, unsigned int);
+ bool (*complex_type) (void *, unsigned int);
- /* Push a bfd_boolean type onto the type stack, given the size. */
- bfd_boolean (*bool_type) (void *, unsigned int);
+ /* Push a bool type onto the type stack, given the size. */
+ bool (*bool_type) (void *, unsigned int);
/* Push an enum type onto the type stack, given the tag, a NULL
terminated array of names and the associated values. If there is
no tag, the tag argument will be NULL. If this is an undefined
enum, the names and values arguments will be NULL. */
- bfd_boolean (*enum_type)
+ bool (*enum_type)
(void *, const char *, const char **, bfd_signed_vma *);
/* Pop the top type on the type stack, and push a pointer to that
type onto the type stack. */
- bfd_boolean (*pointer_type) (void *);
+ bool (*pointer_type) (void *);
/* Push a function type onto the type stack. The second argument
indicates the number of argument types that have been pushed onto
function takes a variable number of arguments. The return type
of the function is pushed onto the type stack below the argument
types, if any. */
- bfd_boolean (*function_type) (void *, int, bfd_boolean);
+ bool (*function_type) (void *, int, bool);
/* Pop the top type on the type stack, and push a reference to that
type onto the type stack. */
- bfd_boolean (*reference_type) (void *);
+ bool (*reference_type) (void *);
/* Pop the top type on the type stack, and push a range of that type
with the given lower and upper bounds onto the type stack. */
- bfd_boolean (*range_type) (void *, bfd_signed_vma, bfd_signed_vma);
+ bool (*range_type) (void *, bfd_signed_vma, bfd_signed_vma);
/* Push an array type onto the type stack. The top type on the type
stack is the range, and the next type on the type stack is the
element type. These should be popped before the array type is
pushed. The arguments are the lower bound, the upper bound, and
whether the array is a string. */
- bfd_boolean (*array_type)
- (void *, bfd_signed_vma, bfd_signed_vma, bfd_boolean);
+ bool (*array_type)
+ (void *, bfd_signed_vma, bfd_signed_vma, bool);
/* Pop the top type on the type stack, and push a set of that type
onto the type stack. The argument indicates whether this set is
a bitstring. */
- bfd_boolean (*set_type) (void *, bfd_boolean);
+ bool (*set_type) (void *, bool);
/* Push an offset type onto the type stack. The top type on the
type stack is the target type, and the next type on the type
stack is the base type. These should be popped before the offset
type is pushed. */
- bfd_boolean (*offset_type) (void *);
+ bool (*offset_type) (void *);
/* Push a method type onto the type stack. If the second argument
is TRUE, the top type on the stack is the class to which the
type on the type stack below the domain and the argument types is
the return type of the method. All these types must be popped,
and then the method type must be pushed. */
- bfd_boolean (*method_type) (void *, bfd_boolean, int, bfd_boolean);
+ bool (*method_type) (void *, bool, int, bool);
/* Pop the top type off the type stack, and push a const qualified
version of that type onto the type stack. */
- bfd_boolean (*const_type) (void *);
+ bool (*const_type) (void *);
/* Pop the top type off the type stack, and push a volatile
qualified version of that type onto the type stack. */
- bfd_boolean (*volatile_type) (void *);
+ bool (*volatile_type) (void *);
/* Start building a struct. This is followed by calls to the
struct_field function, and finished by a call to the
for a union. The fifth argument is the size. If this is an
undefined struct or union, the size will be 0 and struct_field
will not be called before end_struct_type is called. */
- bfd_boolean (*start_struct_type)
- (void *, const char *, unsigned int, bfd_boolean, unsigned int);
+ bool (*start_struct_type)
+ (void *, const char *, unsigned int, bool, unsigned int);
/* Add a field to the struct type currently being built. The type
of the field should be popped off the type stack. The arguments
are the name, the bit position, the bit size (may be zero if the
field is not packed), and the visibility. */
- bfd_boolean (*struct_field)
+ bool (*struct_field)
(void *, const char *, bfd_vma, bfd_vma, enum debug_visibility);
/* Finish building a struct, and push it onto the type stack. */
- bfd_boolean (*end_struct_type) (void *);
+ bool (*end_struct_type) (void *);
/* Start building a class. This is followed by calls to several
functions: struct_field, class_static_member, class_baseclass,
found in the type itself, and is FALSE if the type of the object
holding the virtual function table should be popped from the type
stack. */
- bfd_boolean (*start_class_type)
- (void *, const char *, unsigned int, bfd_boolean, unsigned int,
- bfd_boolean, bfd_boolean);
+ bool (*start_class_type)
+ (void *, const char *, unsigned int, bool, unsigned int, bool, bool);
/* Add a static member to the class currently being built. The
arguments are the field name, the physical name, and the
visibility. The type must be popped off the type stack. */
- bfd_boolean (*class_static_member)
+ bool (*class_static_member)
(void *, const char *, const char *, enum debug_visibility);
/* Add a baseclass to the class currently being built. The type of
the baseclass must be popped off the type stack. The arguments
are the bit position, whether the class is virtual, and the
visibility. */
- bfd_boolean (*class_baseclass)
- (void *, bfd_vma, bfd_boolean, enum debug_visibility);
+ bool (*class_baseclass)
+ (void *, bfd_vma, bool, enum debug_visibility);
/* Start adding a method to the class currently being built. This
is followed by calls to class_method_variant and
method which take different arguments. The method is finished
with a call to class_end_method. The argument is the method
name. */
- bfd_boolean (*class_start_method) (void *, const char *);
+ bool (*class_start_method) (void *, const char *);
/* Describe a variant to the class method currently being built.
The type of the variant must be popped off the type stack. The
const, whether the variant is volatile, the offset in the virtual
function table, and whether the context is on the type stack
(below the variant type). */
- bfd_boolean (*class_method_variant)
- (void *, const char *, enum debug_visibility, bfd_boolean,
- bfd_boolean, bfd_vma, bfd_boolean);
+ bool (*class_method_variant)
+ (void *, const char *, enum debug_visibility, bool, bool, bfd_vma, bool);
/* Describe a static variant to the class method currently being
built. The arguments are the same as for class_method_variant,
except that the last two arguments are omitted. The type of the
variant must be popped off the type stack. */
- bfd_boolean (*class_static_method_variant)
- (void *, const char *, enum debug_visibility, bfd_boolean,
- bfd_boolean);
+ bool (*class_static_method_variant)
+ (void *, const char *, enum debug_visibility, bool, bool);
/* Finish describing a class method. */
- bfd_boolean (*class_end_method) (void *);
+ bool (*class_end_method) (void *);
/* Finish describing a class, and push it onto the type stack. */
- bfd_boolean (*end_class_type) (void *);
+ bool (*end_class_type) (void *);
/* Push a type on the stack which was given a name by an earlier
call to typdef. */
- bfd_boolean (*typedef_type) (void *, const char *);
+ bool (*typedef_type) (void *, const char *);
/* Push a tagged type on the stack which was defined earlier. If
the second argument is not NULL, the type was defined by a call
for a struct (class) being defined, in between the call to
start_struct_type (start_class_type) and the call to
end_struct_type (end_class_type). */
- bfd_boolean (*tag_type)
+ bool (*tag_type)
(void *, const char *, unsigned int, enum debug_type_kind);
/* Pop the type stack, and typedef it to the given name. */
- bfd_boolean (*typdef) (void *, const char *);
+ bool (*typdef) (void *, const char *);
/* Pop the type stack, and declare it as a tagged struct or union or
enum or whatever. The tag passed down here is redundant, since
was also passed when enum_type, start_struct_type, or
start_class_type was called. */
- bfd_boolean (*tag) (void *, const char *);
+ bool (*tag) (void *, const char *);
/* This is called to record a named integer constant. */
- bfd_boolean (*int_constant) (void *, const char *, bfd_vma);
+ bool (*int_constant) (void *, const char *, bfd_vma);
/* This is called to record a named floating point constant. */
- bfd_boolean (*float_constant) (void *, const char *, double);
+ bool (*float_constant) (void *, const char *, double);
/* This is called to record a typed integer constant. The type is
popped off the type stack. */
- bfd_boolean (*typed_constant) (void *, const char *, bfd_vma);
+ bool (*typed_constant) (void *, const char *, bfd_vma);
/* This is called to record a variable. The type is popped off the
type stack. */
- bfd_boolean (*variable)
+ bool (*variable)
(void *, const char *, enum debug_var_kind, bfd_vma);
/* Start writing out a function. The return type must be popped off
- the stack. The bfd_boolean is TRUE if the function is global. This
+ the stack. The bool is TRUE if the function is global. This
is followed by calls to function_parameter, followed by block
information. */
- bfd_boolean (*start_function) (void *, const char *, bfd_boolean);
+ bool (*start_function) (void *, const char *, bool);
/* Record a function parameter for the current function. The type
must be popped off the stack. */
- bfd_boolean (*function_parameter)
+ bool (*function_parameter)
(void *, const char *, enum debug_parm_kind, bfd_vma);
/* Start writing out a block. There is at least one top level block
per function. Blocks may be nested. The argument is the
starting address of the block. */
- bfd_boolean (*start_block) (void *, bfd_vma);
+ bool (*start_block) (void *, bfd_vma);
/* Finish writing out a block. The argument is the ending address
of the block. */
- bfd_boolean (*end_block) (void *, bfd_vma);
+ bool (*end_block) (void *, bfd_vma);
/* Finish writing out a function. */
- bfd_boolean (*end_function) (void *);
+ bool (*end_function) (void *);
/* Record line number information for the current compilation unit. */
- bfd_boolean (*lineno) (void *, const char *, unsigned long, bfd_vma);
+ bool (*lineno) (void *, const char *, unsigned long, bfd_vma);
};
/* Exported functions. */
/* Set the source filename. This implicitly starts a new compilation
unit. */
-extern bfd_boolean debug_set_filename (void *, const char *);
+extern bool debug_set_filename (void *, const char *);
/* Change source files to the given file name. This is used for
include files in a single compilation unit. */
-extern bfd_boolean debug_start_source (void *, const char *);
+extern bool debug_start_source (void *, const char *);
/* Record a function definition. This implicitly starts a function
block. The debug_type argument is the type of the return value.
- The bfd_boolean indicates whether the function is globally visible.
+ The bool indicates whether the function is globally visible.
The bfd_vma is the address of the start of the function. Currently
the parameter types are specified by calls to
debug_record_parameter. */
-extern bfd_boolean debug_record_function
- (void *, const char *, debug_type, bfd_boolean, bfd_vma);
+extern bool debug_record_function
+ (void *, const char *, debug_type, bool, bfd_vma);
/* Record a parameter for the current function. */
-extern bfd_boolean debug_record_parameter
+extern bool debug_record_parameter
(void *, const char *, debug_type, enum debug_parm_kind, bfd_vma);
/* End a function definition. The argument is the address where the
function ends. */
-extern bfd_boolean debug_end_function (void *, bfd_vma);
+extern bool debug_end_function (void *, bfd_vma);
/* Start a block in a function. All local information will be
recorded in this block, until the matching call to debug_end_block.
debug_start_block and debug_end_block may be nested. The argument
is the address at which this block starts. */
-extern bfd_boolean debug_start_block (void *, bfd_vma);
+extern bool debug_start_block (void *, bfd_vma);
/* Finish a block in a function. This matches the call to
debug_start_block. The argument is the address at which this block
ends. */
-extern bfd_boolean debug_end_block (void *, bfd_vma);
+extern bool debug_end_block (void *, bfd_vma);
/* Associate a line number in the current source file with a given
address. */
-extern bfd_boolean debug_record_line (void *, unsigned long, bfd_vma);
+extern bool debug_record_line (void *, unsigned long, bfd_vma);
/* Start a named common block. This is a block of variables that may
move in memory. */
-extern bfd_boolean debug_start_common_block (void *, const char *);
+extern bool debug_start_common_block (void *, const char *);
/* End a named common block. */
-extern bfd_boolean debug_end_common_block (void *, const char *);
+extern bool debug_end_common_block (void *, const char *);
/* Record a named integer constant. */
-extern bfd_boolean debug_record_int_const (void *, const char *, bfd_vma);
+extern bool debug_record_int_const (void *, const char *, bfd_vma);
/* Record a named floating point constant. */
-extern bfd_boolean debug_record_float_const (void *, const char *, double);
+extern bool debug_record_float_const (void *, const char *, double);
/* Record a typed constant with an integral value. */
-extern bfd_boolean debug_record_typed_const
+extern bool debug_record_typed_const
(void *, const char *, debug_type, bfd_vma);
/* Record a label. */
-extern bfd_boolean debug_record_label
+extern bool debug_record_label
(void *, const char *, debug_type, bfd_vma);
/* Record a variable. */
-extern bfd_boolean debug_record_variable
+extern bool debug_record_variable
(void *, const char *, debug_type, enum debug_var_kind, bfd_vma);
/* Make an indirect type. The first argument is a pointer to the
extern debug_type debug_make_void_type (void *);
-/* Make an integer type of a given size. The bfd_boolean argument is TRUE
+/* Make an integer type of a given size. The bool argument is TRUE
if the integer is unsigned. */
-extern debug_type debug_make_int_type (void *, unsigned int, bfd_boolean);
+extern debug_type debug_make_int_type (void *, unsigned int, bool);
/* Make a floating point type of a given size. FIXME: On some
platforms, like an Alpha, you probably need to be able to specify
The fourth argument is a NULL terminated array of fields. */
extern debug_type debug_make_struct_type
- (void *, bfd_boolean, bfd_vma, debug_field *);
+ (void *, bool, bfd_vma, debug_field *);
/* Make an object type. The first three arguments after the handle
are the same as for debug_make_struct_type. The next arguments are
a NULL terminated array of base classes, a NULL terminated array of
methods, the type of the object holding the virtual function table
- if it is not this object, and a bfd_boolean which is TRUE if this
+ if it is not this object, and a bool which is TRUE if this
object has its own virtual function table. */
extern debug_type debug_make_object_type
- (void *, bfd_boolean, bfd_vma, debug_field *, debug_baseclass *,
- debug_method *, debug_type, bfd_boolean);
+ (void *, bool, bfd_vma, debug_field *, debug_baseclass *,
+ debug_method *, debug_type, bool);
/* Make an enumeration type. The arguments are a null terminated
array of strings, and an array of corresponding values. */
are unknown. */
extern debug_type debug_make_function_type
- (void *, debug_type, debug_type *, bfd_boolean);
+ (void *, debug_type, debug_type *, bool);
/* Make a reference to a given type. */
extern debug_type debug_make_array_type
(void *, debug_type, debug_type, bfd_signed_vma, bfd_signed_vma,
- bfd_boolean);
+ bool);
/* Make a set of a given type. For example, a Pascal set type. The
- bfd_boolean argument is TRUE if this set is actually a bitstring, as in
+ bool argument is TRUE if this set is actually a bitstring, as in
CHILL. */
-extern debug_type debug_make_set_type (void *, debug_type, bfd_boolean);
+extern debug_type debug_make_set_type (void *, debug_type, bool);
/* Make a type for a pointer which is relative to an object. The
second argument is the type of the object to which the pointer is
the argument types from the mangled name. */
extern debug_type debug_make_method_type
- (void *, debug_type, debug_type, debug_type *, bfd_boolean);
+ (void *, debug_type, debug_type, debug_type *, bool);
/* Make a const qualified version of a given type. */
class. */
extern debug_baseclass debug_make_baseclass
- (void *, debug_type, bfd_vma, bfd_boolean, enum debug_visibility);
+ (void *, debug_type, bfd_vma, bool, enum debug_visibility);
/* Make a field for a struct. The second argument is the name. The
third argument is the type of the field. The fourth argument is
function context. */
extern debug_method_variant debug_make_method_variant
- (void *, const char *, debug_type, enum debug_visibility, bfd_boolean,
- bfd_boolean, bfd_vma, debug_type);
+ (void *, const char *, debug_type, enum debug_visibility, bool,
+ bool, bfd_vma, debug_type);
/* Make a static method argument. The arguments are the same as for
debug_make_method_variant, except that the last two are omitted
since a static method can not also be virtual. */
extern debug_method_variant debug_make_static_method_variant
- (void *, const char *, debug_type, enum debug_visibility, bfd_boolean,
- bfd_boolean);
+ (void *, const char *, debug_type, enum debug_visibility, bool,
+ bool);
/* Name a type. This returns a new type with an attached name. */
/* Record the size of a given type. */
-extern bfd_boolean debug_record_type_size (void *, debug_type, unsigned int);
+extern bool debug_record_type_size (void *, debug_type, unsigned int);
/* Find a named type. */
method type (actually, parameter types are not currently stored for
function types). This may be used to determine whether a method
type is a stub method or not. The last argument points to a
- bfd_boolean which is set to TRUE if the function takes a variable
+ bool which is set to TRUE if the function takes a variable
number of arguments. */
extern const debug_type *debug_get_parameter_types
- (void *, debug_type, bfd_boolean *);
+ (void *, debug_type, bool *);
/* Get the target type of a pointer or reference or const or volatile
type. */
first void * is the debugging handle. The second void * is a handle
which is passed to the functions. */
-extern bfd_boolean debug_write
+extern bool debug_write
(void *, const struct debug_write_fns *, void *);
#endif /* DEBUG_H */
static char *imp_name;
static char *delayimp_name;
static char *identify_imp_name;
-static bfd_boolean identify_strict;
+static bool identify_strict;
/* Types used to implement a linked list of dllnames associated
with the specified import lib. Used by the identify_* code.
/* Types used to pass data to iterator functions. */
typedef struct symname_search_data_t
{
- const char * symname;
- bfd_boolean found;
+ const char *symname;
+ bool found;
} symname_search_data_type;
typedef struct identify_data_t
{
- dll_name_list_type * list;
- bfd_boolean ms_style_implib;
+ dll_name_list_type *list;
+ bool ms_style_implib;
} identify_data_type;
/* TRUE if we should export all symbols. Otherwise, we only export
symbols listed in .drectve sections or in the def file. */
-static bfd_boolean export_all_symbols;
+static bool export_all_symbols;
/* TRUE if we should exclude the symbols in DEFAULT_EXCLUDES when
exporting all symbols. */
-static bfd_boolean do_default_excludes = TRUE;
+static bool do_default_excludes = true;
-static bfd_boolean use_nul_prefixed_import_tables = FALSE;
+static bool use_nul_prefixed_import_tables = false;
/* Default symbols to exclude when exporting all the symbols. */
static const char *default_excludes = "DllMain@12,DllEntryPoint@0,impure_ptr";
/* TRUE if we should add __imp_<SYMBOL> to import libraries for backward
compatibility to old Cygwin releases. */
-static bfd_boolean create_compat_implib;
+static bool create_compat_implib;
/* TRUE if we have to write PE+ import libraries. */
-static bfd_boolean create_for_pep;
+static bool create_for_pep;
static char *def_file;
int how_dljtab_roff1; /* Offset for the ind 32 reloc into idata 5. */
int how_dljtab_roff2; /* Offset for the ind 32 reloc into idata 5. */
int how_dljtab_roff3; /* Offset for the ind 32 reloc into idata 5. */
- bfd_boolean how_seh;
+ bool how_seh;
const char *trampoline;
};
".global", ".space", ".align\t2",".align\t4", "-mapcs-32",
"pe-arm-little", bfd_arch_arm,
arm_jtab, sizeof (arm_jtab), 8,
- 0, 0, 0, 0, 0, FALSE, 0
+ 0, 0, 0, 0, 0, false, 0
}
,
{
"jmp *", ".global", ".space", ".align\t2",".align\t4", "",
"pe-i386",bfd_arch_i386,
i386_jtab, sizeof (i386_jtab), 2,
- i386_dljtab, sizeof (i386_dljtab), 2, 7, 12, FALSE, i386_trampoline
+ i386_dljtab, sizeof (i386_dljtab), 2, 7, 12, false, i386_trampoline
}
,
{
".global", ".space", ".align\t2",".align\t4", "-mthumb-interwork",
"pe-arm-little", bfd_arch_arm,
thumb_jtab, sizeof (thumb_jtab), 12,
- 0, 0, 0, 0, 0, FALSE, 0
+ 0, 0, 0, 0, 0, false, 0
}
,
#define MARM_INTERWORK 3
".global", ".space", ".align\t2",".align\t4", "-mthumb-interwork",
"pe-arm-little", bfd_arch_arm,
arm_interwork_jtab, sizeof (arm_interwork_jtab), 12,
- 0, 0, 0, 0, 0, FALSE, 0
+ 0, 0, 0, 0, 0, false, 0
}
,
{
".global", ".space", ".align\t2",".align\t4", "",
"pe-mcore-big", bfd_arch_mcore,
mcore_be_jtab, sizeof (mcore_be_jtab), 8,
- 0, 0, 0, 0, 0, FALSE, 0
+ 0, 0, 0, 0, 0, false, 0
}
,
{
".global", ".space", ".align\t2",".align\t4", "-EL",
"pe-mcore-little", bfd_arch_mcore,
mcore_le_jtab, sizeof (mcore_le_jtab), 8,
- 0, 0, 0, 0, 0, FALSE, 0
+ 0, 0, 0, 0, 0, false, 0
}
,
{
".global", ".space", ".align\t2",".align\t4", "",
"elf32-mcore-big", bfd_arch_mcore,
mcore_be_jtab, sizeof (mcore_be_jtab), 8,
- 0, 0, 0, 0, 0, FALSE, 0
+ 0, 0, 0, 0, 0, false, 0
}
,
{
".global", ".space", ".align\t2",".align\t4", "-EL",
"elf32-mcore-little", bfd_arch_mcore,
mcore_le_jtab, sizeof (mcore_le_jtab), 8,
- 0, 0, 0, 0, 0, FALSE, 0
+ 0, 0, 0, 0, 0, false, 0
}
,
{
".global", ".space", ".align\t2",".align\t4", "-mapcs-32",
"pe-arm-wince-little", bfd_arch_arm,
arm_jtab, sizeof (arm_jtab), 8,
- 0, 0, 0, 0, 0, FALSE, 0
+ 0, 0, 0, 0, 0, false, 0
}
,
{
"jmp *", ".global", ".space", ".align\t2",".align\t4", "",
"pe-x86-64",bfd_arch_i386,
i386_jtab, sizeof (i386_jtab), 2,
- i386_x64_dljtab, sizeof (i386_x64_dljtab), 2, 9, 14, TRUE, i386_x64_trampoline
+ i386_x64_dljtab, sizeof (i386_x64_dljtab), 2, 9, 14, true, i386_x64_trampoline
}
,
{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }
static void scan_drectve_symbols (bfd *);
static void scan_filtered_symbols (bfd *, void *, long, unsigned int);
static void add_excludes (const char *);
-static bfd_boolean match_exclude (const char *);
+static bool match_exclude (const char *);
static void set_default_excludes (void);
static long filter_symbols (bfd *, void *, long, unsigned int);
static void scan_all_symbols (bfd *);
static void identify_search_archive
(bfd *, void (*) (bfd *, bfd *, void *), void *);
static void identify_search_member (bfd *, bfd *, void *);
-static bfd_boolean identify_process_section_p (asection *, bfd_boolean);
+static bool identify_process_section_p (asection *, bool);
static void identify_search_section (bfd *, asection *, void *);
static void identify_member_contains_symname (bfd *, bfd *, void *);
asymbol *sym;
const char *symbol_name;
- sym = bfd_minisymbol_to_symbol (abfd, FALSE, from, store);
+ sym = bfd_minisymbol_to_symbol (abfd, false, from, store);
if (sym == NULL)
bfd_fatal (bfd_get_filename (abfd));
/* See if STRING is on the list of symbols to exclude. */
-static bfd_boolean
+static bool
match_exclude (const char *string)
{
struct string_list *excl_item;
for (excl_item = excludes; excl_item; excl_item = excl_item->next)
if (strcmp (string, excl_item->string) == 0)
- return TRUE;
- return FALSE;
+ return true;
+ return false;
}
/* Add the default list of symbols to exclude. */
int keep = 0;
asymbol *sym;
- sym = bfd_minisymbol_to_symbol (abfd, FALSE, (const void *) from, store);
+ sym = bfd_minisymbol_to_symbol (abfd, false, (const void *) from, store);
if (sym == NULL)
bfd_fatal (bfd_get_filename (abfd));
return;
}
- symcount = bfd_read_minisymbols (abfd, FALSE, &minisyms, &size);
+ symcount = bfd_read_minisymbols (abfd, false, &minisyms, &size);
if (symcount < 0)
bfd_fatal (bfd_get_filename (abfd));
search_data->symname,
strlen (search_data->symname)) == 0)
{
- search_data->found = TRUE;
+ search_data->found = true;
break;
}
}
/* Initialize identify_data. */
identify_data.list = dll_name_list_create ();
- identify_data.ms_style_implib = FALSE;
+ identify_data.ms_style_implib = false;
/* Initialize search_data. */
search_data.symname = "__NULL_IMPORT_DESCRIPTOR";
- search_data.found = FALSE;
+ search_data.found = false;
if (bfd_init () != BFD_INIT_MAGIC)
fatal (_("fatal error: libbfd ABI mismatch"));
identify_member_contains_symname,
(void *)(& search_data));
if (search_data.found)
- identify_data.ms_style_implib = TRUE;
+ identify_data.ms_style_implib = true;
/* Rewind the bfd. */
if (! bfd_close (abfd))
By default, this is .idata$7 (.idata$6 if the import library is
ms-style). */
-static bfd_boolean
-identify_process_section_p (asection * section, bfd_boolean ms_style_implib)
+static bool
+identify_process_section_p (asection * section, bool ms_style_implib)
{
static const char * SECTION_NAME = ".idata$7";
static const char * MS_SECTION_NAME = ".idata$6";
(ms_style_implib ? MS_SECTION_NAME : SECTION_NAME);
if (strcmp (section_name, section->name) == 0)
- return TRUE;
- return FALSE;
+ return true;
+ return false;
}
/* If *section has contents and its name is .idata$7 (.idata$6 if
bfd_byte *data = 0;
bfd_size_type datasize;
identify_data_type * identify_data = (identify_data_type *)obj;
- bfd_boolean ms_style = identify_data->ms_style_implib;
+ bool ms_style = identify_data->ms_style_implib;
if ((section->flags & SEC_HAS_CONTENTS) == 0)
return;
switch (c)
{
case OPTION_EXPORT_ALL_SYMS:
- export_all_symbols = TRUE;
+ export_all_symbols = true;
break;
case OPTION_NO_EXPORT_ALL_SYMS:
- export_all_symbols = FALSE;
+ export_all_symbols = false;
break;
case OPTION_EXCLUDE_SYMS:
add_excludes (optarg);
break;
case OPTION_NO_DEFAULT_EXCLUDES:
- do_default_excludes = FALSE;
+ do_default_excludes = false;
break;
case OPTION_USE_NUL_PREFIXED_IMPORT_TABLES:
- use_nul_prefixed_import_tables = TRUE;
+ use_nul_prefixed_import_tables = true;
break;
case OPTION_ADD_STDCALL_UNDERSCORE:
add_stdcall_underscore = 1;
symbols in the .drectve section. The default excludes are meant
to avoid exporting DLL entry point and Cygwin32 impure_ptr. */
if (! export_all_symbols)
- do_default_excludes = FALSE;
+ do_default_excludes = false;
if (do_default_excludes)
set_default_excludes ();
struct dwo_info * next;
} dwo_info;
-static dwo_info * first_dwo_info = NULL;
-static bfd_boolean need_dwo_info;
+static dwo_info *first_dwo_info = NULL;
+static bool need_dwo_info;
separate_info * first_separate_info = NULL;
int do_wide;
int do_debug_links;
int do_follow_links = DEFAULT_FOR_FOLLOW_LINKS;
-bfd_boolean do_checks;
+bool do_checks;
int dwarf_cutoff_level = -1;
unsigned long dwarf_start_die;
static struct cu_tu_set *cu_sets = NULL;
static struct cu_tu_set *tu_sets = NULL;
-static bfd_boolean load_cu_tu_indexes (void *);
+static bool load_cu_tu_indexes (void *);
/* An array that indicates for a given level of CU nesting whether
the latest DW_AT_type seen for that level was a signed type or
an unsigned type. */
#define MAX_CU_NESTING (1 << 8)
-static bfd_boolean level_type_signed[MAX_CU_NESTING];
+static bool level_type_signed[MAX_CU_NESTING];
/* Values for do_debug_lines. */
#define FLAG_DEBUG_LINES_RAW 1
dwarf_vma
read_leb128 (unsigned char *data,
const unsigned char *const end,
- bfd_boolean sign,
+ bool sign,
unsigned int *length_return,
int *status_return)
{
static const char *
fetch_indexed_string (dwarf_vma idx, struct cu_tu_set *this_set,
- dwarf_vma offset_size, bfd_boolean dwo)
+ dwarf_vma offset_size, bool dwo)
{
enum dwarf_section_display_enum str_sec_idx = dwo ? str_dwo : str;
enum dwarf_section_display_enum idx_sec_idx = dwo ? str_index_dwo : str_index;
found starting at DATA. */
static void
-get_type_signedness (abbrev_entry * entry,
- const struct dwarf_section * section,
- unsigned char * data,
- unsigned const char * end,
- dwarf_vma cu_offset,
- dwarf_vma pointer_size,
- dwarf_vma offset_size,
- int dwarf_version,
- bfd_boolean * is_signed,
- unsigned int nesting)
+get_type_signedness (abbrev_entry *entry,
+ const struct dwarf_section *section,
+ unsigned char *data,
+ unsigned const char *end,
+ dwarf_vma cu_offset,
+ dwarf_vma pointer_size,
+ dwarf_vma offset_size,
+ int dwarf_version,
+ bool *is_signed,
+ unsigned int nesting)
{
abbrev_attr * attr;
- * is_signed = FALSE;
+ * is_signed = false;
#define MAX_NESTING 20
if (nesting > MAX_NESTING)
case DW_ATE_unsigned:
case DW_ATE_unsigned_char:
case DW_ATE_unsigned_fixed:
- * is_signed = FALSE;
+ * is_signed = false;
break;
default:
case DW_ATE_imaginary_float:
case DW_ATE_decimal_float:
case DW_ATE_signed_fixed:
- * is_signed = TRUE;
+ * is_signed = true;
break;
}
break;
}
static void
-read_and_print_leb128 (unsigned char * data,
- unsigned int * bytes_read,
- unsigned const char * end,
- bfd_boolean is_signed)
+read_and_print_leb128 (unsigned char *data,
+ unsigned int *bytes_read,
+ unsigned const char *end,
+ bool is_signed)
{
int status;
dwarf_vma val = read_leb128 (data, end, is_signed, bytes_read, &status);
return;
}
- bfd_boolean is_signed =
+ bool is_signed =
(level > 0 && level <= MAX_CU_NESTING)
- ? level_type_signed [level - 1] : FALSE;
+ ? level_type_signed [level - 1] : false;
printf ("(");
while (uvalue)
if (!do_loc)
{
const char *suffix = strrchr (section->name, '.');
- bfd_boolean dwo = suffix && strcmp (suffix, ".dwo") == 0;
+ bool dwo = suffix && strcmp (suffix, ".dwo") == 0;
if (do_wide)
/* We have already displayed the form name. */
case DW_FORM_strx2:
case DW_FORM_strx3:
case DW_FORM_strx4:
- add_dwo_name (fetch_indexed_string (uvalue, this_set, offset_size, FALSE), cu_offset);
+ add_dwo_name (fetch_indexed_string (uvalue, this_set, offset_size, false), cu_offset);
break;
case DW_FORM_string:
add_dwo_name ((const char *) orig_data, cu_offset);
case DW_FORM_strx2:
case DW_FORM_strx3:
case DW_FORM_strx4:
- add_dwo_dir (fetch_indexed_string (uvalue, this_set, offset_size, FALSE), cu_offset);
+ add_dwo_dir (fetch_indexed_string (uvalue, this_set, offset_size, false), cu_offset);
break;
case DW_FORM_string:
add_dwo_dir ((const char *) orig_data, cu_offset);
if (level >= 0 && level < MAX_CU_NESTING
&& uvalue < (size_t) (end - start))
{
- bfd_boolean is_signed = FALSE;
- abbrev_entry * type_abbrev;
- unsigned char * type_data;
- unsigned long type_cu_offset;
+ bool is_signed = false;
+ abbrev_entry *type_abbrev;
+ unsigned char *type_data;
+ unsigned long type_cu_offset;
type_abbrev = get_type_abbrev_from_form (form, uvalue, cu_offset,
section, NULL, & type_data, & type_cu_offset);
following debug links, then attempt to load the requested section
from one of the separate debug info files. */
-static bfd_boolean
+static bool
load_debug_section_with_follow (enum dwarf_section_display_enum sec_enum,
void * handle)
{
}
}
- return TRUE;
+ return true;
}
if (do_follow_links)
/* FIXME: We should check to see if any of the remaining debug info
files also contain this section, and, umm, do something about it. */
- return TRUE;
+ return true;
}
}
}
- return FALSE;
+ return false;
}
static void
-introduce (struct dwarf_section * section, bfd_boolean raw)
+introduce (struct dwarf_section * section, bool raw)
{
if (raw)
{
Returns TRUE upon success. Otherwise an error or warning message is
printed and FALSE is returned. */
-static bfd_boolean
-process_debug_info (struct dwarf_section * section,
- void * file,
- enum dwarf_section_display_enum abbrev_sec,
- bfd_boolean do_loc,
- bfd_boolean do_types)
+static bool
+process_debug_info (struct dwarf_section * section,
+ void *file,
+ enum dwarf_section_display_enum abbrev_sec,
+ bool do_loc,
+ bool do_types)
{
unsigned char *start = section->start;
unsigned char *end = start + section->size;
{
warn (_("Reserved length value (0x%s) found in section %s\n"),
dwarf_vmatoa ("x", length), section->name);
- return FALSE;
+ return false;
}
else
section_begin += length + 4;
{
warn (_("Corrupt unit length (0x%s) found in section %s\n"),
dwarf_vmatoa ("x", length), section->name);
- return FALSE;
+ return false;
}
}
if (num_units == 0)
{
error (_("No comp units in %s section ?\n"), section->name);
- return FALSE;
+ return false;
}
/* Then allocate an array to hold the information. */
error (_("Not enough memory for a debug info array of %u entries\n"),
num_units);
alloc_num_debug_info_entries = num_debug_info_entries = 0;
- return FALSE;
+ return false;
}
/* PR 17531: file: 92ca3797.
{
warn (_("Unable to locate %s section!\n"),
debug_displays [abbrev_sec].section.uncompressed_name);
- return FALSE;
+ return false;
}
if (!do_loc && dwarf_start_die == 0)
- introduce (section, FALSE);
+ introduce (section, false);
free_all_abbrevs ();
free (cu_abbrev_map);
if (compunit.cu_version < 5)
SAFE_BYTE_GET_AND_INC (compunit.cu_pointer_size, hdrptr, 1, end);
- bfd_boolean do_dwo_id = FALSE;
+ bool do_dwo_id = false;
uint64_t dwo_id = 0;
if (compunit.cu_unit_type == DW_UT_split_compile
|| compunit.cu_unit_type == DW_UT_skeleton)
{
SAFE_BYTE_GET_AND_INC (dwo_id, hdrptr, 8, end);
- do_dwo_id = TRUE;
+ do_dwo_id = true;
}
/* PR 17512: file: 001-108546-0.001:0.1. */
}
}
if (dwarf_start_die != 0 && level < saved_level)
- return TRUE;
+ return true;
continue;
}
}
warn (_("DIE at offset 0x%lx refers to abbreviation number %lu which does not exist\n"),
die_offset, abbrev_number);
- return FALSE;
+ return false;
}
if (!do_loc && do_printing)
if (!do_loc)
printf ("\n");
- return TRUE;
+ return true;
}
/* Locate and scan the .debug_info section in the file and record the pointer
(void) load_cu_tu_indexes (file);
if (load_debug_section_with_follow (info, file)
- && process_debug_info (&debug_displays [info].section, file, abbrev, TRUE, FALSE))
+ && process_debug_info (&debug_displays [info].section, file, abbrev, true, false))
return num_debug_info_entries;
if (load_debug_section_with_follow (info_dwo, file)
&& process_debug_info (&debug_displays [info_dwo].section, file,
- abbrev_dwo, TRUE, FALSE))
+ abbrev_dwo, true, false))
return num_debug_info_entries;
num_debug_info_entries = DEBUG_INFO_UNAVAILABLE;
}
static unsigned char *
-display_formatted_table (unsigned char * data,
- unsigned char * start,
- unsigned char * end,
- const DWARF2_Internal_LineInfo * linfo,
- struct dwarf_section * section,
- bfd_boolean is_dir)
+display_formatted_table (unsigned char *data,
+ unsigned char *start,
+ unsigned char *end,
+ const DWARF2_Internal_LineInfo *linfo,
+ struct dwarf_section *section,
+ bool is_dir)
{
unsigned char *format_start, format_count, *format, formati;
dwarf_vma data_count, datai;
dwarf_vma checksum_len;
- introduce (section, TRUE);
+ introduce (section, true);
if (section->size < 4)
{
error (_("corrupt .debug_sup section: size is too small\n"));
}
start += sup_filename_len + 1;
- checksum_len = read_leb128 (start, end, FALSE /* unsigned */, & num_read, & status);
+ checksum_len = read_leb128 (start, end, false /* unsigned */, & num_read, & status);
if (status)
{
error (_("corrupt .debug_sup section: bad LEB128 field for checksum length\n"));
unsigned char *start = section->start;
int verbose_view = 0;
- introduce (section, TRUE);
+ introduce (section, true);
while (data < end)
{
load_debug_section_with_follow (line_str, file);
data = display_formatted_table (data, start, end, &linfo, section,
- TRUE);
+ true);
data = display_formatted_table (data, start, end, &linfo, section,
- FALSE);
+ false);
}
else
{
{
static DWARF2_Internal_LineInfo saved_linfo;
- introduce (section, FALSE);
+ introduce (section, false);
while (data < end)
{
we test for that later on. */
load_debug_info (file);
- introduce (section, FALSE);
+ introduce (section, false);
while (start < end)
{
unsigned char *curr = start;
enum dwarf_macinfo_record_type op;
- introduce (section, FALSE);
+ introduce (section, false);
while (curr < end)
{
unsigned char *end = start + section->size;
unsigned char *curr = start;
unsigned char *extended_op_buf[256];
- bfd_boolean is_dwo = FALSE;
+ bool is_dwo = false;
const char *suffix = strrchr (section->name, '.');
if (suffix && strcmp (suffix, ".dwo") == 0)
- is_dwo = TRUE;
+ is_dwo = true;
load_debug_section_with_follow (str, file);
load_debug_section_with_follow (line, file);
load_debug_section_with_follow (str_index, file);
- introduce (section, FALSE);
+ introduce (section, false);
while (curr < end)
{
READ_ULEB (lineno, curr, end);
READ_ULEB (offset, curr, end);
string = (const unsigned char *)
- fetch_indexed_string (offset, NULL, offset_size, FALSE);
+ fetch_indexed_string (offset, NULL, offset_size, false);
if (op == DW_MACRO_define_strx)
printf (" DW_MACRO_define_strx ");
else
unsigned char *start = section->start;
const unsigned char *end = start + section->size;
- introduce (section, FALSE);
+ introduce (section, false);
do
{
/* Return true when ADDR is the maximum address, when addresses are
POINTER_SIZE bytes long. */
-static bfd_boolean
+static bool
is_max_address (dwarf_vma addr, unsigned int pointer_size)
{
dwarf_vma mask = ~(~(dwarf_vma) 1 << (pointer_size * 8 - 1));
unsigned char *next = start, *vnext = vstart;
unsigned int *array = NULL;
const char *suffix = strrchr (section->name, '.');
- bfd_boolean is_dwo = FALSE;
+ bool is_dwo = false;
int is_loclists = strstr (section->name, "debug_loclists") != NULL;
dwarf_vma expected_start = 0;
if (suffix && strcmp (suffix, ".dwo") == 0)
- is_dwo = TRUE;
+ is_dwo = true;
bytes = section->size;
if (!locs_sorted)
array = (unsigned int *) xcmalloc (num_loc_list, sizeof (unsigned int));
- introduce (section, FALSE);
+ introduce (section, false);
if (reloc_at (section, 0))
printf (_(" Warning: This section has relocations - addresses seen here may not be accurate.\n\n"));
return 0;
}
- introduce (section, FALSE);
+ introduce (section, false);
while (bytes)
{
static int
display_debug_info (struct dwarf_section *section, void *file)
{
- return process_debug_info (section, file, section->abbrev_sec, FALSE, FALSE);
+ return process_debug_info (section, file, section->abbrev_sec, false, false);
}
static int
display_debug_types (struct dwarf_section *section, void *file)
{
- return process_debug_info (section, file, section->abbrev_sec, FALSE, TRUE);
+ return process_debug_info (section, file, section->abbrev_sec, false, true);
}
static int
display_trace_info (struct dwarf_section *section, void *file)
{
- return process_debug_info (section, file, section->abbrev_sec, FALSE, TRUE);
+ return process_debug_info (section, file, section->abbrev_sec, false, true);
}
static int
unsigned char *start = section->start;
unsigned char *end = start + section->size;
- introduce (section, FALSE);
+ introduce (section, false);
/* It does not matter if this load fails,
we test for that later on. */
return 0;
}
- introduce (section, FALSE);
+ introduce (section, false);
/* PR 17531: file: cf38d01b.
We use xcalloc because a corrupt file may not have initialised all of the
unsigned char *curr = start;
const char *suffix = strrchr (section->name, '.');
- bfd_boolean dwo = suffix && strcmp (suffix, ".dwo") == 0;
+ bool dwo = suffix && strcmp (suffix, ".dwo") == 0;
if (dwo)
load_debug_section_with_follow (str_dwo, file);
else
load_debug_section_with_follow (str, file);
- introduce (section, FALSE);
+ introduce (section, false);
while (curr < end)
{
warn (_("Range lists in %s section start at 0x%lx\n"),
section->name, (unsigned long) range_entries[0].ranges_offset);
- introduce (section, FALSE);
+ introduce (section, false);
printf (_(" Offset Begin End\n"));
Frame_Chunk *chunks = NULL, *forward_refs = NULL;
Frame_Chunk *remembered_state = NULL;
Frame_Chunk *rs;
- bfd_boolean is_eh = strcmp (section->name, ".eh_frame") == 0;
+ bool is_eh = strcmp (section->name, ".eh_frame") == 0;
unsigned int max_regs = 0;
const char *bad_reg = _("bad register: ");
unsigned int saved_eh_addr_size = eh_addr_size;
- introduce (section, FALSE);
+ introduce (section, false);
while (start < end)
{
unsigned int encoded_ptr_size = saved_eh_addr_size;
unsigned int offset_size;
unsigned int initial_length_size;
- bfd_boolean all_nops;
+ bool all_nops;
static Frame_Chunk fde_fc;
saved_start = start;
start = tmp;
}
- all_nops = TRUE;
+ all_nops = true;
/* Now we know what registers are used, make a second pass over
the chunk, this time actually printing out the info. */
/* Make a note if something other than DW_CFA_nop happens. */
if (op != DW_CFA_nop)
- all_nops = FALSE;
+ all_nops = false;
/* Warning: if you add any more cases to this switch, be
sure to add them to the corresponding switch above. */
const unsigned char *const section_end = section->start + section->size;
unsigned char *unit_end;
- introduce (section, FALSE);
+ introduce (section, false);
load_debug_section_with_follow (str, file);
uint32_t augmentation_string_size;
unsigned int i;
unsigned long sec_off;
- bfd_boolean augmentation_printable;
+ bool augmentation_printable;
const char *augmentation_string;
unit_start = hdrptr;
printf (_("Augmentation string:"));
- augmentation_printable = TRUE;
+ augmentation_printable = true;
augmentation_string = (const char *) hdrptr;
for (i = 0; i < augmentation_string_size; i++)
printf (" %02x", uc);
if (uc != 0 && !ISPRINT (uc))
- augmentation_printable = FALSE;
+ augmentation_printable = false;
}
if (augmentation_printable)
const unsigned char * filename;
unsigned int filelen;
- introduce (section, FALSE);
+ introduce (section, false);
/* The .gnu_debuglink section is formatted as:
(c-string) Filename.
/* The documentation for the format of this file is in gdb/dwarf2read.c. */
- introduce (section, FALSE);
+ introduce (section, false);
if (section->size < 6 * sizeof (uint32_t))
{
if (do_display)
{
- introduce (section, FALSE);
+ introduce (section, false);
printf (_(" Version: %u\n"), version);
if (version >= 2)
unsigned char *poffsets = ppool + (size_t) ncols * 4;
unsigned char *psizes = poffsets + (size_t) nused * ncols * 4;
unsigned char *pend = psizes + (size_t) nused * ncols * 4;
- bfd_boolean is_tu_index;
+ bool is_tu_index;
struct cu_tu_set *this_set = NULL;
unsigned int row;
unsigned char *prow;
section sets that we can use to associate a .debug_info.dwo section
with its associated .debug_abbrev.dwo section in a .dwp file. */
-static bfd_boolean
+static bool
load_cu_tu_indexes (void *file)
{
/* If we have already loaded (or tried to load) the CU and TU indexes
then do not bother to repeat the task. */
if (cu_tu_indexes_read == -1)
{
- cu_tu_indexes_read = TRUE;
+ cu_tu_indexes_read = true;
if (load_debug_section_with_follow (dwp_cu_index, file))
if (! process_cu_tu_index (&debug_displays [dwp_cu_index].section, 0))
- cu_tu_indexes_read = FALSE;
+ cu_tu_indexes_read = false;
if (load_debug_section_with_follow (dwp_tu_index, file))
if (! process_cu_tu_index (&debug_displays [dwp_tu_index].section, 0))
- cu_tu_indexes_read = FALSE;
+ cu_tu_indexes_read = false;
}
- return (bfd_boolean) cu_tu_indexes_read;
+ return (bool) cu_tu_indexes_read;
}
/* Find the set of sections that includes section SHNDX. */
return ~crc & 0xffffffff;
}
-typedef bfd_boolean (* check_func_type) (const char *, void *);
-typedef const char * (* parse_func_type) (struct dwarf_section *, void *);
+typedef bool (*check_func_type) (const char *, void *);
+typedef const char *(* parse_func_type) (struct dwarf_section *, void *);
-static bfd_boolean
+static bool
check_gnu_debuglink (const char * pathname, void * crc_pointer)
{
static unsigned char buffer [8 * 1024];
sep_data = open_debug_file (pathname);
if (sep_data == NULL)
- return FALSE;
+ return false;
/* Yes - we are opening the file twice... */
f = fopen (pathname, "rb");
/* Paranoia: This should never happen. */
close_debug_file (sep_data);
warn (_("Unable to reopen separate debug info file: %s\n"), pathname);
- return FALSE;
+ return false;
}
while ((count = fread (buffer, 1, sizeof (buffer), f)) > 0)
close_debug_file (sep_data);
warn (_("Separate debug info file %s found, but CRC does not match - ignoring\n"),
pathname);
- return FALSE;
+ return false;
}
- return TRUE;
+ return true;
}
static const char *
return name;
}
-static bfd_boolean
+static bool
check_gnu_debugaltlink (const char * filename, void * data ATTRIBUTE_UNUSED)
{
void * sep_data = open_debug_file (filename);
if (sep_data == NULL)
- return FALSE;
+ return false;
/* FIXME: We should now extract the build-id in the separate file
and check it... */
- return TRUE;
+ return true;
}
typedef struct build_id_data
file. If successful, store the path of the file in filename and
return TRUE, otherwise return FALSE. */
-static bfd_boolean
+static bool
debuginfod_fetch_separate_debug_info (struct dwarf_section * section,
char ** filename,
void * file)
filelen = strnlen ((const char *)section->start, section->size);
if (filelen == section->size)
/* Corrupt debugaltlink. */
- return FALSE;
+ return false;
build_id = section->start + filelen + 1;
build_id_len = section->size - (filelen + 1);
if (build_id_len == 0)
- return FALSE;
+ return false;
}
else
- return FALSE;
+ return false;
if (build_id)
{
client = debuginfod_begin ();
if (client == NULL)
- return FALSE;
+ return false;
/* Query debuginfod servers for the target file. If found its path
will be stored in filename. */
/* File successfully retrieved. Close fd since we want to
use open_debug_file () on filename instead. */
close (fd);
- return TRUE;
+ return true;
}
}
- return FALSE;
+ return false;
}
#endif
If TRUE is returned then the linked list starting at first_separate_info
will be populated with open file handles. */
-bfd_boolean
+bool
load_separate_debug_files (void * file, const char * filename)
{
/* Skip this operation if we are not interested in debug links. */
if (! do_follow_links && ! do_debug_links)
- return FALSE;
+ return false;
/* See if there are any dwo links. */
if (load_debug_section (str, file)
free_dwo_info ();
if (process_debug_info (& debug_displays[info].section, file, abbrev,
- TRUE, FALSE))
+ true, false))
{
- bfd_boolean introduced = FALSE;
- dwo_info * dwinfo;
- const char * dir = NULL;
- const char * id = NULL;
- const char * name = NULL;
+ bool introduced = false;
+ dwo_info *dwinfo;
+ const char *dir = NULL;
+ const char *id = NULL;
+ const char *name = NULL;
for (dwinfo = first_dwo_info; dwinfo != NULL; dwinfo = dwinfo->next)
{
{
printf (_("The %s section contains link(s) to dwo file(s):\n\n"),
debug_displays [info].section.uncompressed_name);
- introduced = TRUE;
+ introduced = true;
}
printf (_(" Name: %s\n"), name);
if (! do_follow_links)
/* The other debug links will be displayed by display_debug_links()
so we do not need to do any further processing here. */
- return FALSE;
+ return false;
/* FIXME: We do not check for the presence of both link sections in the same file. */
/* FIXME: We do not check for the presence of multiple, same-name debuglink sections. */
check_for_and_load_links (file, filename);
if (first_separate_info != NULL)
- return TRUE;
+ return true;
do_follow_links = 0;
- return FALSE;
+ return false;
}
void
struct dwarf_section_display debug_displays[] =
{
- { { ".debug_abbrev", ".zdebug_abbrev", NO_ABBREVS }, display_debug_abbrev, &do_debug_abbrevs, FALSE },
- { { ".debug_aranges", ".zdebug_aranges", NO_ABBREVS }, display_debug_aranges, &do_debug_aranges, TRUE },
- { { ".debug_frame", ".zdebug_frame", NO_ABBREVS }, display_debug_frames, &do_debug_frames, TRUE },
- { { ".debug_info", ".zdebug_info", ABBREV (abbrev)}, display_debug_info, &do_debug_info, TRUE },
- { { ".debug_line", ".zdebug_line", NO_ABBREVS }, display_debug_lines, &do_debug_lines, TRUE },
- { { ".debug_pubnames", ".zdebug_pubnames", NO_ABBREVS }, display_debug_pubnames, &do_debug_pubnames, FALSE },
- { { ".debug_gnu_pubnames", ".zdebug_gnu_pubnames", NO_ABBREVS }, display_debug_gnu_pubnames, &do_debug_pubnames, FALSE },
- { { ".eh_frame", "", NO_ABBREVS }, display_debug_frames, &do_debug_frames, TRUE },
- { { ".debug_macinfo", ".zdebug_macinfo", NO_ABBREVS }, display_debug_macinfo, &do_debug_macinfo, FALSE },
- { { ".debug_macro", ".zdebug_macro", NO_ABBREVS }, display_debug_macro, &do_debug_macinfo, TRUE },
- { { ".debug_str", ".zdebug_str", NO_ABBREVS }, display_debug_str, &do_debug_str, FALSE },
- { { ".debug_line_str", ".zdebug_line_str", NO_ABBREVS }, display_debug_str, &do_debug_str, FALSE },
- { { ".debug_loc", ".zdebug_loc", NO_ABBREVS }, display_debug_loc, &do_debug_loc, TRUE },
- { { ".debug_loclists", ".zdebug_loclists", NO_ABBREVS }, display_debug_loc, &do_debug_loc, TRUE },
- { { ".debug_pubtypes", ".zdebug_pubtypes", NO_ABBREVS }, display_debug_pubnames, &do_debug_pubtypes, FALSE },
- { { ".debug_gnu_pubtypes", ".zdebug_gnu_pubtypes", NO_ABBREVS }, display_debug_gnu_pubnames, &do_debug_pubtypes, FALSE },
- { { ".debug_ranges", ".zdebug_ranges", NO_ABBREVS }, display_debug_ranges, &do_debug_ranges, TRUE },
- { { ".debug_rnglists", ".zdebug_rnglists", NO_ABBREVS }, display_debug_ranges, &do_debug_ranges, TRUE },
- { { ".debug_static_func", ".zdebug_static_func", NO_ABBREVS }, display_debug_not_supported, NULL, FALSE },
- { { ".debug_static_vars", ".zdebug_static_vars", NO_ABBREVS }, display_debug_not_supported, NULL, FALSE },
- { { ".debug_types", ".zdebug_types", ABBREV (abbrev) }, display_debug_types, &do_debug_info, TRUE },
- { { ".debug_weaknames", ".zdebug_weaknames", NO_ABBREVS }, display_debug_not_supported, NULL, FALSE },
- { { ".gdb_index", "", NO_ABBREVS }, display_gdb_index, &do_gdb_index, FALSE },
- { { ".debug_names", "", NO_ABBREVS }, display_debug_names, &do_gdb_index, FALSE },
- { { ".trace_info", "", ABBREV (trace_abbrev) }, display_trace_info, &do_trace_info, TRUE },
- { { ".trace_abbrev", "", NO_ABBREVS }, display_debug_abbrev, &do_trace_abbrevs, FALSE },
- { { ".trace_aranges", "", NO_ABBREVS }, display_debug_aranges, &do_trace_aranges, FALSE },
- { { ".debug_info.dwo", ".zdebug_info.dwo", ABBREV (abbrev_dwo) }, display_debug_info, &do_debug_info, TRUE },
- { { ".debug_abbrev.dwo", ".zdebug_abbrev.dwo", NO_ABBREVS }, display_debug_abbrev, &do_debug_abbrevs, FALSE },
- { { ".debug_types.dwo", ".zdebug_types.dwo", ABBREV (abbrev_dwo) }, display_debug_types, &do_debug_info, TRUE },
- { { ".debug_line.dwo", ".zdebug_line.dwo", NO_ABBREVS }, display_debug_lines, &do_debug_lines, TRUE },
- { { ".debug_loc.dwo", ".zdebug_loc.dwo", NO_ABBREVS }, display_debug_loc, &do_debug_loc, TRUE },
- { { ".debug_macro.dwo", ".zdebug_macro.dwo", NO_ABBREVS }, display_debug_macro, &do_debug_macinfo, TRUE },
- { { ".debug_macinfo.dwo", ".zdebug_macinfo.dwo", NO_ABBREVS }, display_debug_macinfo, &do_debug_macinfo, FALSE },
- { { ".debug_str.dwo", ".zdebug_str.dwo", NO_ABBREVS }, display_debug_str, &do_debug_str, TRUE },
- { { ".debug_str_offsets", ".zdebug_str_offsets", NO_ABBREVS }, display_debug_str_offsets, &do_debug_str_offsets, TRUE },
- { { ".debug_str_offsets.dwo", ".zdebug_str_offsets.dwo", NO_ABBREVS }, display_debug_str_offsets, &do_debug_str_offsets, TRUE },
- { { ".debug_addr", ".zdebug_addr", NO_ABBREVS }, display_debug_addr, &do_debug_addr, TRUE },
- { { ".debug_cu_index", "", NO_ABBREVS }, display_cu_index, &do_debug_cu_index, FALSE },
- { { ".debug_tu_index", "", NO_ABBREVS }, display_cu_index, &do_debug_cu_index, FALSE },
- { { ".gnu_debuglink", "", NO_ABBREVS }, display_debug_links, &do_debug_links, FALSE },
- { { ".gnu_debugaltlink", "", NO_ABBREVS }, display_debug_links, &do_debug_links, FALSE },
- { { ".debug_sup", "", NO_ABBREVS }, display_debug_sup, &do_debug_links, FALSE },
+ { { ".debug_abbrev", ".zdebug_abbrev", NO_ABBREVS }, display_debug_abbrev, &do_debug_abbrevs, false },
+ { { ".debug_aranges", ".zdebug_aranges", NO_ABBREVS }, display_debug_aranges, &do_debug_aranges, true },
+ { { ".debug_frame", ".zdebug_frame", NO_ABBREVS }, display_debug_frames, &do_debug_frames, true },
+ { { ".debug_info", ".zdebug_info", ABBREV (abbrev)}, display_debug_info, &do_debug_info, true },
+ { { ".debug_line", ".zdebug_line", NO_ABBREVS }, display_debug_lines, &do_debug_lines, true },
+ { { ".debug_pubnames", ".zdebug_pubnames", NO_ABBREVS }, display_debug_pubnames, &do_debug_pubnames, false },
+ { { ".debug_gnu_pubnames", ".zdebug_gnu_pubnames", NO_ABBREVS }, display_debug_gnu_pubnames, &do_debug_pubnames, false },
+ { { ".eh_frame", "", NO_ABBREVS }, display_debug_frames, &do_debug_frames, true },
+ { { ".debug_macinfo", ".zdebug_macinfo", NO_ABBREVS }, display_debug_macinfo, &do_debug_macinfo, false },
+ { { ".debug_macro", ".zdebug_macro", NO_ABBREVS }, display_debug_macro, &do_debug_macinfo, true },
+ { { ".debug_str", ".zdebug_str", NO_ABBREVS }, display_debug_str, &do_debug_str, false },
+ { { ".debug_line_str", ".zdebug_line_str", NO_ABBREVS }, display_debug_str, &do_debug_str, false },
+ { { ".debug_loc", ".zdebug_loc", NO_ABBREVS }, display_debug_loc, &do_debug_loc, true },
+ { { ".debug_loclists", ".zdebug_loclists", NO_ABBREVS }, display_debug_loc, &do_debug_loc, true },
+ { { ".debug_pubtypes", ".zdebug_pubtypes", NO_ABBREVS }, display_debug_pubnames, &do_debug_pubtypes, false },
+ { { ".debug_gnu_pubtypes", ".zdebug_gnu_pubtypes", NO_ABBREVS }, display_debug_gnu_pubnames, &do_debug_pubtypes, false },
+ { { ".debug_ranges", ".zdebug_ranges", NO_ABBREVS }, display_debug_ranges, &do_debug_ranges, true },
+ { { ".debug_rnglists", ".zdebug_rnglists", NO_ABBREVS }, display_debug_ranges, &do_debug_ranges, true },
+ { { ".debug_static_func", ".zdebug_static_func", NO_ABBREVS }, display_debug_not_supported, NULL, false },
+ { { ".debug_static_vars", ".zdebug_static_vars", NO_ABBREVS }, display_debug_not_supported, NULL, false },
+ { { ".debug_types", ".zdebug_types", ABBREV (abbrev) }, display_debug_types, &do_debug_info, true },
+ { { ".debug_weaknames", ".zdebug_weaknames", NO_ABBREVS }, display_debug_not_supported, NULL, false },
+ { { ".gdb_index", "", NO_ABBREVS }, display_gdb_index, &do_gdb_index, false },
+ { { ".debug_names", "", NO_ABBREVS }, display_debug_names, &do_gdb_index, false },
+ { { ".trace_info", "", ABBREV (trace_abbrev) }, display_trace_info, &do_trace_info, true },
+ { { ".trace_abbrev", "", NO_ABBREVS }, display_debug_abbrev, &do_trace_abbrevs, false },
+ { { ".trace_aranges", "", NO_ABBREVS }, display_debug_aranges, &do_trace_aranges, false },
+ { { ".debug_info.dwo", ".zdebug_info.dwo", ABBREV (abbrev_dwo) }, display_debug_info, &do_debug_info, true },
+ { { ".debug_abbrev.dwo", ".zdebug_abbrev.dwo", NO_ABBREVS }, display_debug_abbrev, &do_debug_abbrevs, false },
+ { { ".debug_types.dwo", ".zdebug_types.dwo", ABBREV (abbrev_dwo) }, display_debug_types, &do_debug_info, true },
+ { { ".debug_line.dwo", ".zdebug_line.dwo", NO_ABBREVS }, display_debug_lines, &do_debug_lines, true },
+ { { ".debug_loc.dwo", ".zdebug_loc.dwo", NO_ABBREVS }, display_debug_loc, &do_debug_loc, true },
+ { { ".debug_macro.dwo", ".zdebug_macro.dwo", NO_ABBREVS }, display_debug_macro, &do_debug_macinfo, true },
+ { { ".debug_macinfo.dwo", ".zdebug_macinfo.dwo", NO_ABBREVS }, display_debug_macinfo, &do_debug_macinfo, false },
+ { { ".debug_str.dwo", ".zdebug_str.dwo", NO_ABBREVS }, display_debug_str, &do_debug_str, true },
+ { { ".debug_str_offsets", ".zdebug_str_offsets", NO_ABBREVS }, display_debug_str_offsets, &do_debug_str_offsets, true },
+ { { ".debug_str_offsets.dwo", ".zdebug_str_offsets.dwo", NO_ABBREVS }, display_debug_str_offsets, &do_debug_str_offsets, true },
+ { { ".debug_addr", ".zdebug_addr", NO_ABBREVS }, display_debug_addr, &do_debug_addr, true },
+ { { ".debug_cu_index", "", NO_ABBREVS }, display_cu_index, &do_debug_cu_index, false },
+ { { ".debug_tu_index", "", NO_ABBREVS }, display_cu_index, &do_debug_cu_index, false },
+ { { ".gnu_debuglink", "", NO_ABBREVS }, display_debug_links, &do_debug_links, false },
+ { { ".gnu_debugaltlink", "", NO_ABBREVS }, display_debug_links, &do_debug_links, false },
+ { { ".debug_sup", "", NO_ABBREVS }, display_debug_sup, &do_debug_links, false },
/* Separate debug info files can containt their own .debug_str section,
and this might be in *addition* to a .debug_str section already present
in the main file. Hence we need to have two entries for .debug_str. */
- { { ".debug_str", ".zdebug_str", NO_ABBREVS }, display_debug_str, &do_debug_str, FALSE },
+ { { ".debug_str", ".zdebug_str", NO_ABBREVS }, display_debug_str, &do_debug_str, false },
};
/* A static assertion. */
and a pointer to a function that can decode it. */
struct dwarf_section_display
{
- struct dwarf_section section;
- int (* display) (struct dwarf_section *, void *);
- int * enabled;
- bfd_boolean relocate;
+ struct dwarf_section section;
+ int (*display) (struct dwarf_section *, void *);
+ int *enabled;
+ bool relocate;
};
extern struct dwarf_section_display debug_displays [];
extern int do_wide;
extern int do_debug_links;
extern int do_follow_links;
-extern bfd_boolean do_checks;
+extern bool do_checks;
extern int dwarf_cutoff_level;
extern unsigned long dwarf_start_die;
extern void init_dwarf_regnames_by_bfd_arch_and_mach (enum bfd_architecture arch,
unsigned long mach);
-extern bfd_boolean load_debug_section (enum dwarf_section_display_enum, void *);
-extern void free_debug_section (enum dwarf_section_display_enum);
-extern bfd_boolean load_separate_debug_files (void *, const char *);
-extern void close_debug_file (void *);
-extern void * open_debug_file (const char *);
+extern bool load_debug_section (enum dwarf_section_display_enum, void *);
+extern void free_debug_section (enum dwarf_section_display_enum);
+extern bool load_separate_debug_files (void *, const char *);
+extern void close_debug_file (void *);
+extern void *open_debug_file (const char *);
extern void free_debug_memory (void);
/* A callback into the client. Returns TRUE if there is a
relocation against the given debug section at the given
offset. */
-extern bfd_boolean reloc_at (struct dwarf_section *, dwarf_vma);
+extern bool reloc_at (struct dwarf_section *, dwarf_vma);
extern dwarf_vma read_leb128 (unsigned char *, const unsigned char *const,
- bfd_boolean, unsigned int *, int *);
+ bool, unsigned int *, int *);
#if HAVE_LIBDEBUGINFOD
extern unsigned char * get_build_id (void *);
do \
{ \
unsigned int _len; \
- read_leb128 (start, end, FALSE, &_len, NULL); \
+ read_leb128 (start, end, false, &_len, NULL); \
start += _len; \
} \
while (0)
do \
{ \
unsigned int _len; \
- read_leb128 (start, end, TRUE, &_len, NULL); \
+ read_leb128 (start, end, true, &_len, NULL); \
start += _len; \
} \
while (0)
unsigned int _len; \
int _status; \
\
- _val = read_leb128 (start, end, FALSE, &_len, &_status); \
+ _val = read_leb128 (start, end, false, &_len, &_status); \
start += _len; \
(var) = _val; \
if ((var) != _val) \
unsigned int _len; \
int _status; \
\
- _val = read_leb128 (start, end, TRUE, &_len, &_status); \
+ _val = read_leb128 (start, end, true, &_len, &_status); \
start += _len; \
(var) = _val; \
if ((var) != _val) \
static int
process_archive (const char * file_name, FILE * file,
- bfd_boolean is_thin_archive)
+ bool is_thin_archive)
{
struct archive_info arch;
struct archive_info nested_arch;
if (fstat (fileno (file), &statbuf) < 0
|| setup_archive (&arch, file_name, file, statbuf.st_size,
- is_thin_archive, FALSE) != 0)
+ is_thin_archive, false) != 0)
{
ret = 1;
goto out;
}
if (memcmp (armag, ARMAG, SARMAG) == 0)
- ret = process_archive (file_name, file, FALSE);
+ ret = process_archive (file_name, file, false);
else if (memcmp (armag, ARMAGT, SARMAG) == 0)
- ret = process_archive (file_name, file, TRUE);
+ ret = process_archive (file_name, file, true);
else
{
rewind (file);
/* Default to <bigaf>. */
/* FIXME: write only variable. */
-static bfd_boolean big_archive = TRUE;
+static bool big_archive = true;
/* Whether to include 32 bit objects. */
-static bfd_boolean X32 = TRUE;
+static bool X32 = true;
/* Whether to include 64 bit objects. */
-static bfd_boolean X64 = FALSE;
+static bool X64 = false;
static void
ar_emul_aix_usage (FILE *fp)
fprintf (fp, _(" [-X32_64] - accepts 32 and 64 bit objects\n"));
}
-static bfd_boolean
+static bool
check_aix (bfd *try_bfd)
{
extern const bfd_target rs6000_xcoff_vec;
if (bfd_check_format (try_bfd, bfd_object))
{
if (!X32 && try_bfd->xvec == &rs6000_xcoff_vec)
- return FALSE;
+ return false;
if (!X64 && (try_bfd->xvec == &rs6000_xcoff64_vec
|| try_bfd->xvec == &rs6000_xcoff64_aix_vec))
- return FALSE;
+ return false;
}
- return TRUE;
+ return true;
}
-static bfd_boolean
+static bool
ar_emul_aix_append (bfd **after_bfd, bfd *new_bfd,
- bfd_boolean verbose, bfd_boolean flatten)
+ bool verbose, bool flatten)
{
return do_ar_emul_append (after_bfd, new_bfd, verbose, flatten, check_aix);
}
-static bfd_boolean
+static bool
ar_emul_aix_replace (bfd **after_bfd, bfd *new_bfd,
- bfd_boolean verbose)
+ bool verbose)
{
if (!check_aix (new_bfd))
- return FALSE;
+ return false;
AR_EMUL_REPLACE_PRINT_VERBOSE (verbose, bfd_get_filename (new_bfd));
new_bfd->archive_next = *after_bfd;
*after_bfd = new_bfd;
- return TRUE;
+ return true;
}
-static bfd_boolean
+static bool
ar_emul_aix_parse_arg (char *arg)
{
if (startswith (arg, "-X32_64"))
{
- big_archive = TRUE;
- X32 = TRUE;
- X64 = TRUE;
+ big_archive = true;
+ X32 = true;
+ X64 = true;
}
else if (startswith (arg, "-X32"))
{
- big_archive = TRUE;
- X32 = TRUE;
- X64 = FALSE;
+ big_archive = true;
+ X32 = true;
+ X64 = false;
}
else if (startswith (arg, "-X64"))
{
- big_archive = TRUE;
- X32 = FALSE;
- X64 = TRUE;
+ big_archive = true;
+ X32 = false;
+ X64 = true;
}
else if (startswith (arg, "-g"))
{
- big_archive = FALSE;
- X32 = TRUE;
- X64 = FALSE;
+ big_archive = false;
+ X32 = true;
+ X64 = false;
}
else
- return FALSE;
+ return false;
- return TRUE;
+ return true;
}
struct bin_emulation_xfer_struct bin_aix_emulation =
#include <assert.h>
/* Exported globals. */
-bfd_boolean mclex_want_nl = FALSE;
-bfd_boolean mclex_want_line = FALSE;
-bfd_boolean mclex_want_filename = FALSE;
+bool mclex_want_nl = false;
+bool mclex_want_line = false;
+bool mclex_want_filename = false;
/* Local globals. */
static unichar *input_stream = NULL;
&& (input_stream_pos[1] == '\n'
|| (input_stream_pos[1] == '\r' && input_stream_pos[2] == '\n')))
{
- mclex_want_line = FALSE;
+ mclex_want_line = false;
return skip_until_eol () ? MCENDLINE : -1;
}
if (!skip_until_eol ())
input_line += 1;
if (mclex_want_nl && ch == '\n')
{
- mclex_want_nl = FALSE;
+ mclex_want_nl = false;
return NL;
}
}
++input_stream_pos;
if (mclex_want_filename)
{
- mclex_want_filename = FALSE;
+ mclex_want_filename = false;
if (ch == '"')
{
start_token++;
if (info != NULL && info->elfinfo && with_symbol_versions)
{
const char *version_string;
- bfd_boolean hidden;
+ bool hidden;
version_string
= bfd_get_symbol_version_string (abfd, &info->elfinfo->symbol,
- FALSE, &hidden);
+ false, &hidden);
if (version_string && version_string[0])
{
const char *at = "@@";
{
symindex idx = BFD_NO_MORE_SYMBOLS;
carsym *thesym;
- bfd_boolean everprinted = FALSE;
+ bool everprinted = false;
for (idx = bfd_get_next_mapent (abfd, idx, &thesym);
idx != BFD_NO_MORE_SYMBOLS;
if (!everprinted)
{
printf (_("\nArchive index:\n"));
- everprinted = TRUE;
+ everprinted = true;
}
elt = bfd_get_elt_at_index (abfd, idx);
if (elt == NULL)
\f
/* True when we can report missing plugin error. */
-bfd_boolean report_plugin_err = TRUE;
+bool report_plugin_err = true;
/* Choose which symbol entries to print;
compact them downward to get rid of the rest.
Return the number of symbols to be printed. */
static long
-filter_symbols (bfd *abfd, bfd_boolean is_dynamic, void *minisyms,
+filter_symbols (bfd *abfd, bool is_dynamic, void *minisyms,
long symcount, unsigned int size)
{
bfd_byte *from, *fromend, *to;
&& strcmp (sym->name + (sym->name[2] == '_'), "__gnu_lto_slim") == 0
&& report_plugin_err)
{
- report_plugin_err = FALSE;
+ report_plugin_err = false;
non_fatal (_("%s: plugin needed to handle lto object"),
bfd_get_filename (abfd));
}
/* These globals are used to pass information into the sorting
routines. */
static bfd *sort_bfd;
-static bfd_boolean sort_dynamic;
+static bool sort_dynamic;
static asymbol *sort_x;
static asymbol *sort_y;
size. */
static long
-sort_symbols_by_size (bfd *abfd, bfd_boolean is_dynamic, void *minisyms,
+sort_symbols_by_size (bfd *abfd, bool is_dynamic, void *minisyms,
long symcount, unsigned int size,
struct size_sym **symsizesp)
{
/* Print the symbols when sorting by size. */
static void
-print_size_symbols (bfd * abfd,
- bfd_boolean is_dynamic,
- struct size_sym * symsizes,
- long symcount,
- bfd * archive_bfd)
+print_size_symbols (bfd *abfd,
+ bool is_dynamic,
+ struct size_sym *symsizes,
+ long symcount,
+ bfd *archive_bfd)
{
asymbol *store;
struct size_sym *from;
SIZE is the size of a symbol in MINISYMS. */
static void
-print_symbols (bfd * abfd,
- bfd_boolean is_dynamic,
- void * minisyms,
- long symcount,
- unsigned int size,
- bfd * archive_bfd)
+print_symbols (bfd *abfd,
+ bool is_dynamic,
+ void *minisyms,
+ long symcount,
+ unsigned int size,
+ bfd *archive_bfd)
{
asymbol *store;
bfd_byte *from;
LTO plugin. */
if (abfd->lto_slim_object)
{
- report_plugin_err = FALSE;
+ report_plugin_err = false;
non_fatal (_("%s: plugin needed to handle lto object"),
bfd_get_filename (abfd));
}
}
}
-static bfd_boolean
+static bool
display_file (char *filename)
{
- bfd_boolean retval = TRUE;
+ bool retval = true;
bfd *file;
char **matching;
if (get_file_size (filename) < 1)
- return FALSE;
+ return false;
file = bfd_openr (filename, target ? target : plugin_target);
if (file == NULL)
{
bfd_nonfatal (filename);
- return FALSE;
+ return false;
}
/* If printing line numbers, decompress the debug sections. */
list_matching_formats (matching);
free (matching);
}
- retval = FALSE;
+ retval = false;
}
if (!bfd_close (file))
struct is_specified_symbol_predicate_data
{
- const char * name;
- bfd_boolean found;
+ const char *name;
+ bool found;
};
/* A node includes symbol name mapping to support redefine_sym. */
static int interleave = 0; /* Initialised to 4 in copy_main(). */
static int copy_width = 1;
-static bfd_boolean keep_section_symbols = FALSE ;/* True if section symbols should be retained. */
-static bfd_boolean verbose; /* Print file and target names. */
-static bfd_boolean preserve_dates; /* Preserve input file timestamp. */
+static bool keep_section_symbols = false ;/* True if section symbols should be retained. */
+static bool verbose; /* Print file and target names. */
+static bool preserve_dates; /* Preserve input file timestamp. */
static int deterministic = -1; /* Enable deterministic archives. */
static int status = 0; /* Exit status. */
-static bfd_boolean merge_notes = FALSE; /* Merge note sections. */
+static bool merge_notes = false; /* Merge note sections. */
typedef struct merged_note_section
{
/* Structure used to hold lists of sections and actions to take. */
struct section_list
{
- struct section_list * next; /* Next section to change. */
- const char * pattern; /* Section name pattern. */
- bfd_boolean used; /* Whether this entry was used. */
+ struct section_list *next; /* Next section to change. */
+ const char *pattern; /* Section name pattern. */
+ bool used; /* Whether this entry was used. */
- unsigned int context; /* What to do with matching sections. */
+ unsigned int context; /* What to do with matching sections. */
/* Flag bits used in the context field.
- COPY and REMOVE are mutually exlusive. SET and ALTER are mutually exclusive. */
+ COPY and REMOVE are mutually exlusive.
+ SET and ALTER are mutually exclusive. */
#define SECTION_CONTEXT_REMOVE (1 << 0) /* Remove this section. */
#define SECTION_CONTEXT_COPY (1 << 1) /* Copy this section, delete all non-copied section. */
#define SECTION_CONTEXT_KEEP (1 << 2) /* Keep this section. */
#define SECTION_CONTEXT_REMOVE_RELOCS (1 << 8) /* Remove relocations for this section. */
#define SECTION_CONTEXT_SET_ALIGNMENT (1 << 9) /* Set alignment for section. */
- bfd_vma vma_val; /* Amount to change by or set to. */
- bfd_vma lma_val; /* Amount to change by or set to. */
- flagword flags; /* What to set the section flags to. */
- unsigned int alignment; /* Alignment of output section. */
+ bfd_vma vma_val; /* Amount to change by or set to. */
+ bfd_vma lma_val; /* Amount to change by or set to. */
+ flagword flags; /* What to set the section flags to. */
+ unsigned int alignment; /* Alignment of output section. */
};
static struct section_list *change_sections;
/* TRUE if some sections are to be removed. */
-static bfd_boolean sections_removed;
+static bool sections_removed;
/* TRUE if only some sections are to be copied. */
-static bfd_boolean sections_copied;
+static bool sections_copied;
/* Changes to the start address. */
static bfd_vma change_start = 0;
-static bfd_boolean set_start_set = FALSE;
+static bool set_start_set = false;
static bfd_vma set_start;
/* Changes to section addresses. */
static bfd_vma change_section_address = 0;
/* Filling gaps between sections. */
-static bfd_boolean gap_fill_set = FALSE;
+static bool gap_fill_set = false;
static bfd_byte gap_fill = 0;
/* Pad to a given address. */
-static bfd_boolean pad_to_set = FALSE;
+static bool pad_to_set = false;
static bfd_vma pad_to;
/* Use alternative machine code? */
static const char * gnu_debuglink_filename = NULL;
/* Whether to convert debugging information. */
-static bfd_boolean convert_debugging = FALSE;
+static bool convert_debugging = false;
/* Whether to compress/decompress DWARF debug sections. */
static enum
static enum bfd_link_elf_stt_common do_elf_stt_common = unchanged;
/* Whether to change the leading character in symbol names. */
-static bfd_boolean change_leading_char = FALSE;
+static bool change_leading_char = false;
/* Whether to remove the leading character from global symbol names. */
-static bfd_boolean remove_leading_char = FALSE;
+static bool remove_leading_char = false;
/* Whether to permit wildcard in symbol comparison. */
-static bfd_boolean wildcard = FALSE;
+static bool wildcard = false;
/* True if --localize-hidden is in effect. */
-static bfd_boolean localize_hidden = FALSE;
+static bool localize_hidden = false;
/* List of symbols to strip, keep, localize, keep-global, weaken,
or redefine. */
static char *weaken_specific_buffer = NULL;
/* If this is TRUE, we weaken global symbols (set BSF_WEAK). */
-static bfd_boolean weaken = FALSE;
+static bool weaken = false;
/* If this is TRUE, we retain BSF_FILE symbols. */
-static bfd_boolean keep_file_symbols = FALSE;
+static bool keep_file_symbols = false;
/* Prefix symbols/sections. */
static char *prefix_symbols_string = 0;
static char *prefix_alloc_sections_string = 0;
/* True if --extract-symbol was passed on the command line. */
-static bfd_boolean extract_symbol = FALSE;
+static bool extract_symbol = false;
/* If `reverse_bytes' is nonzero, then reverse the order of every chunk
of <reverse_bytes> bytes within each output section. */
/* Restrict the generation of Srecords to type S3 only.
This variable is defined in bfd/srec.c and can be toggled
on by the --srec-forceS3 command line switch. */
-extern bfd_boolean _bfd_srec_forceS3;
+extern bool _bfd_srec_forceS3;
/* Width of data in bytes for verilog output.
This variable is declared in bfd/verilog.c and can be modified by
static void get_sections (bfd *, asection *, void *);
static int compare_section_lma (const void *, const void *);
static void mark_symbols_used_in_relocations (bfd *, asection *, void *);
-static bfd_boolean write_debugging_info (bfd *, void *, long *, asymbol ***);
+static bool write_debugging_info (bfd *, void *, long *, asymbol ***);
static const char *lookup_sym_redefinition (const char *);
static const char *find_section_rename (const char *, flagword *);
\f
entry as used. */
static struct section_list *
-find_section_list (const char *name, bfd_boolean add, unsigned int context)
+find_section_list (const char *name, bool add, unsigned int context)
{
struct section_list *p, *match = NULL;
{
if (fnmatch (p->pattern + 1, name, 0) == 0)
{
- p->used = TRUE;
+ p->used = true;
return NULL;
}
}
if (! add)
{
if (match != NULL)
- match->used = TRUE;
+ match->used = true;
return match;
}
p = (struct section_list *) xmalloc (sizeof (struct section_list));
p->pattern = name;
- p->used = FALSE;
+ p->used = false;
p->context = context;
p->vma_val = 0;
p->lma_val = 0;
char * eol;
char * name;
char * name_end;
- int finished = FALSE;
+ int finished = false;
for (eol = line;; eol ++)
{
/* Cope with \n\r. */
if (eol[1] == '\r')
++ eol;
- finished = TRUE;
+ finished = true;
break;
case '\r':
/* Cope with \r\n. */
if (eol[1] == '\n')
++ eol;
- finished = TRUE;
+ finished = true;
break;
case 0:
- finished = TRUE;
+ finished = true;
break;
case '#':
{
if (! fnmatch (slot_name, d->name, 0))
{
- d->found = TRUE;
+ d->found = true;
/* Continue traversal, there might be a non-match rule. */
return 1;
}
{
if (! fnmatch (slot_name + 1, d->name, 0))
{
- d->found = FALSE;
+ d->found = false;
/* Stop traversal. */
return 0;
}
return 1;
}
-static bfd_boolean
+static bool
is_specified_symbol (const char *name, htab_t htab)
{
if (wildcard)
struct is_specified_symbol_predicate_data data;
data.name = name;
- data.found = FALSE;
+ data.found = false;
htab_traverse (htab, is_specified_symbol_predicate, &data);
/* Return TRUE if the section is a DWO section. */
-static bfd_boolean
+static bool
is_dwo_section (bfd *abfd ATTRIBUTE_UNUSED, asection *sec)
{
const char *name;
int len;
if (sec == NULL || (name = bfd_section_name (sec)) == NULL)
- return FALSE;
+ return false;
len = strlen (name);
if (len < 5)
- return FALSE;
+ return false;
return strncmp (name + len - 4, ".dwo", 4) == 0;
}
/* Return TRUE if section SEC is in the update list. */
-static bfd_boolean
+static bool
is_update_section (bfd *abfd ATTRIBUTE_UNUSED, asection *sec)
{
if (update_sections != NULL)
pupdate = pupdate->next)
{
if (strcmp (sec->name, pupdate->name) == 0)
- return TRUE;
+ return true;
}
}
- return FALSE;
+ return false;
}
-static bfd_boolean
+static bool
is_mergeable_note_section (bfd * abfd, asection * sec)
{
if (merge_notes
/* FIXME: We currently only support merging GNU_BUILD_NOTEs.
We should add support for more note types. */
&& (startswith (sec->name, GNU_BUILD_ATTRS_SECTION_NAME)))
- return TRUE;
+ return true;
- return FALSE;
+ return false;
}
/* See if a non-group section is being removed. */
-static bfd_boolean
+static bool
is_strip_section_1 (bfd *abfd ATTRIBUTE_UNUSED, asection *sec)
{
- if (find_section_list (bfd_section_name (sec), FALSE, SECTION_CONTEXT_KEEP)
+ if (find_section_list (bfd_section_name (sec), false, SECTION_CONTEXT_KEEP)
!= NULL)
- return FALSE;
+ return false;
if (sections_removed || sections_copied)
{
struct section_list *p;
struct section_list *q;
- p = find_section_list (bfd_section_name (sec), FALSE,
+ p = find_section_list (bfd_section_name (sec), false,
SECTION_CONTEXT_REMOVE);
- q = find_section_list (bfd_section_name (sec), FALSE,
+ q = find_section_list (bfd_section_name (sec), false,
SECTION_CONTEXT_COPY);
if (p && q)
bfd_section_name (sec));
if (p != NULL)
- return TRUE;
+ return true;
if (sections_copied && q == NULL)
- return TRUE;
+ return true;
}
if ((bfd_section_flags (sec) & SEC_DEBUGGING) != 0)
This section has for pe-coff special meaning. See
pe-dll.c file in ld, and peXXigen.c in bfd for details. */
if (strcmp (bfd_section_name (sec), ".reloc") != 0)
- return TRUE;
+ return true;
}
if (strip_symbols == STRIP_DWO)
return is_dwo_section (abfd, sec);
if (strip_symbols == STRIP_NONDEBUG)
- return FALSE;
+ return false;
}
if (strip_symbols == STRIP_NONDWO)
return !is_dwo_section (abfd, sec);
- return FALSE;
+ return false;
}
/* See if a section is being removed. */
-static bfd_boolean
+static bool
is_strip_section (bfd *abfd ATTRIBUTE_UNUSED, asection *sec)
{
if (is_strip_section_1 (abfd, sec))
- return TRUE;
+ return true;
if ((bfd_section_flags (sec) & SEC_GROUP) != 0)
{
gsym = group_signature (sec);
/* Strip groups without a valid signature. */
if (gsym == NULL)
- return TRUE;
+ return true;
/* PR binutils/3181
If we are going to strip the group signature symbol, then
if ((strip_symbols == STRIP_ALL
&& !is_specified_symbol (gname, keep_specific_htab))
|| is_specified_symbol (gname, strip_specific_htab))
- return TRUE;
+ return true;
/* Remove the group section if all members are removed. */
first = elt = elf_next_in_group (sec);
while (elt != NULL)
{
if (!is_strip_section_1 (abfd, elt))
- return FALSE;
+ return false;
elt = elf_next_in_group (elt);
if (elt == first)
break;
}
- return TRUE;
+ return true;
}
- return FALSE;
+ return false;
}
-static bfd_boolean
+static bool
is_nondebug_keep_contents_section (bfd *ibfd, asection *isection)
{
/* Always keep ELF note sections. */
if (bfd_get_flavour (ibfd) == bfd_target_coff_flavour)
return strcmp (bfd_section_name (isection), ".buildid") == 0;
- return FALSE;
+ return false;
}
/* Return true if SYM is a hidden symbol. */
-static bfd_boolean
+static bool
is_hidden_symbol (asymbol *sym)
{
elf_symbol_type *elf_sym;
{
case STV_HIDDEN:
case STV_INTERNAL:
- return TRUE;
+ return true;
}
- return FALSE;
+ return false;
}
/* Empty name is hopefully never a valid symbol name. */
static const char * empty_name = "";
-static bfd_boolean
+static bool
need_sym_before (struct addsym_node **node, const char *sym)
{
int count;
free ((char *) ptr->othersym);
ptr->othersym = empty_name;
*node = ptr;
- return TRUE;
+ return true;
}
ptr = ptr->next;
}
- return FALSE;
+ return false;
}
static asymbol *
asymbol *sym = from[src_count];
flagword flags = sym->flags;
char *name = (char *) bfd_asymbol_name (sym);
- bfd_boolean keep;
- bfd_boolean used_in_reloc = FALSE;
- bfd_boolean undefined;
- bfd_boolean rem_leading_char;
- bfd_boolean add_leading_char;
+ bool keep;
+ bool used_in_reloc = false;
+ bool undefined;
+ bool rem_leading_char;
+ bool add_leading_char;
undefined = bfd_is_und_section (bfd_asymbol_section (sym));
{
name[0] = bfd_get_symbol_leading_char (obfd);
bfd_set_asymbol_name (sym, name);
- rem_leading_char = FALSE;
- add_leading_char = FALSE;
+ rem_leading_char = false;
+ add_leading_char = false;
}
/* Remove leading char. */
}
if (strip_symbols == STRIP_ALL)
- keep = FALSE;
+ keep = false;
else if ((flags & BSF_KEEP) != 0 /* Used in relocation. */
|| ((flags & BSF_SECTION_SYM) != 0
&& ((*bfd_asymbol_section (sym)->symbol_ptr_ptr)->flags
& BSF_KEEP) != 0))
{
- keep = TRUE;
- used_in_reloc = TRUE;
+ keep = true;
+ used_in_reloc = true;
}
else if (relocatable /* Relocatable file. */
&& ((flags & (BSF_GLOBAL | BSF_WEAK)) != 0
|| bfd_is_com_section (bfd_asymbol_section (sym))))
- keep = TRUE;
+ keep = true;
else if (bfd_decode_symclass (sym) == 'I')
/* Global symbols in $idata sections need to be retained
even if relocatable is FALSE. External users of the
library containing the $idata section may reference these
symbols. */
- keep = TRUE;
+ keep = true;
else if ((flags & BSF_GLOBAL) != 0 /* Global symbol. */
|| (flags & BSF_WEAK) != 0
|| undefined
else if (bfd_coff_get_comdat_section (abfd, bfd_asymbol_section (sym)))
/* COMDAT sections store special information in local
symbols, so we cannot risk stripping any of them. */
- keep = TRUE;
+ keep = true;
else /* Local symbol. */
keep = (strip_symbols != STRIP_UNNEEDED
&& (discard_locals != LOCALS_ALL
status = 1;
}
else
- keep = FALSE;
+ keep = false;
}
if (keep
&& !(flags & BSF_KEEP)
&& is_specified_symbol (name, strip_unneeded_htab))
- keep = FALSE;
+ keep = false;
if (!keep
&& ((keep_file_symbols && (flags & BSF_FILE))
|| is_specified_symbol (name, keep_specific_htab)))
- keep = TRUE;
+ keep = true;
if (keep && is_strip_section (abfd, bfd_asymbol_section (sym)))
- keep = FALSE;
+ keep = false;
if (keep)
{
/* Copy unknown object file IBFD onto OBFD.
Returns TRUE upon success, FALSE otherwise. */
-static bfd_boolean
+static bool
copy_unknown_object (bfd *ibfd, bfd *obfd)
{
char *cbuf;
if (bfd_stat_arch_elt (ibfd, &buf) != 0)
{
bfd_nonfatal_message (NULL, ibfd, NULL, NULL);
- return FALSE;
+ return false;
}
size = buf.st_size;
{
non_fatal (_("stat returns negative size for `%s'"),
bfd_get_archive_filename (ibfd));
- return FALSE;
+ return false;
}
if (bfd_seek (ibfd, (file_ptr) 0, SEEK_SET) != 0)
{
bfd_nonfatal (bfd_get_archive_filename (ibfd));
- return FALSE;
+ return false;
}
if (verbose)
{
bfd_nonfatal_message (NULL, ibfd, NULL, NULL);
free (cbuf);
- return FALSE;
+ return false;
}
if (bfd_bwrite (cbuf, (bfd_size_type) tocopy, obfd)
{
bfd_nonfatal_message (NULL, obfd, NULL, NULL);
free (cbuf);
- return FALSE;
+ return false;
}
ncopied += tocopy;
unknown object in an archive. */
chmod (bfd_get_filename (obfd), buf.st_mode | S_IRUSR);
free (cbuf);
- return TRUE;
+ return true;
}
typedef struct objcopy_internal_note
/* Returns TRUE iff PNOTE1 overlaps or adjoins PNOTE2. */
-static bfd_boolean
+static bool
overlaps_or_adjoins (objcopy_internal_note * pnote1,
objcopy_internal_note * pnote2)
{
return BFD_ALIGN (pnote2->end, 16) < pnote1->start;
if (pnote1->end < pnote2->end)
- return TRUE;
+ return true;
if (pnote2->end < pnote1->end)
- return TRUE;
+ return true;
- return FALSE;
+ return false;
}
/* Returns TRUE iff NEEDLE is fully contained by HAYSTACK. */
-static bfd_boolean
+static bool
contained_by (objcopy_internal_note * needle,
objcopy_internal_note * haystack)
{
return needle->start >= haystack->start && needle->end <= haystack->end;
}
-static bfd_boolean
+static bool
is_open_note (objcopy_internal_note * pnote)
{
return pnote->note.type == NT_GNU_BUILD_ATTRIBUTE_OPEN;
}
-static bfd_boolean
+static bool
is_func_note (objcopy_internal_note * pnote)
{
return pnote->note.type == NT_GNU_BUILD_ATTRIBUTE_FUNC;
}
-static bfd_boolean
+static bool
is_deleted_note (objcopy_internal_note * pnote)
{
return pnote->note.type == 0;
}
-static bfd_boolean
+static bool
is_version_note (objcopy_internal_note * pnote)
{
return (pnote->note.namesz > 4
&& pnote->note.namedata[3] == GNU_BUILD_ATTRIBUTE_VERSION);
}
-static bfd_boolean
+static bool
is_64bit (bfd * abfd)
{
/* Should never happen, but let's be paranoid. */
if (bfd_get_flavour (abfd) != bfd_target_elf_flavour)
- return FALSE;
+ return false;
return elf_elfheader (abfd)->e_ident[EI_CLASS] == ELFCLASS64;
}
/* Copy object file IBFD onto OBFD.
Returns TRUE upon success, FALSE otherwise. */
-static bfd_boolean
+static bool
copy_object (bfd *ibfd, bfd *obfd, const bfd_arch_info_type *input_arch)
{
bfd_vma start;
may need to tidy temporary files. */
non_fatal (_("unable to change endianness of '%s'"),
bfd_get_archive_filename (ibfd));
- return FALSE;
+ return false;
}
if (ibfd->read_only)
{
non_fatal (_("unable to modify '%s' due to errors"),
bfd_get_archive_filename (ibfd));
- return FALSE;
+ return false;
}
if (!bfd_set_format (obfd, bfd_get_format (ibfd)))
{
bfd_nonfatal_message (NULL, obfd, NULL, NULL);
- return FALSE;
+ return false;
}
if (ibfd->sections == NULL)
{
non_fatal (_("error: the input file '%s' has no sections"),
bfd_get_archive_filename (ibfd));
- return FALSE;
+ return false;
}
if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour)
{
non_fatal (_("--compress-debug-sections=[zlib|zlib-gnu|zlib-gabi] is unsupported on `%s'"),
bfd_get_archive_filename (ibfd));
- return FALSE;
+ return false;
}
if (do_elf_stt_common)
{
non_fatal (_("--elf-stt-common=[yes|no] is unsupported on `%s'"),
bfd_get_archive_filename (ibfd));
- return FALSE;
+ return false;
}
}
|| !bfd_set_file_flags (obfd, flags))
{
bfd_nonfatal_message (NULL, ibfd, NULL, NULL);
- return FALSE;
+ return false;
}
}
non_fatal (_("Output file cannot represent architecture `%s'"),
bfd_printable_arch_mach (bfd_get_arch (ibfd),
bfd_get_mach (ibfd)));
- return FALSE;
+ return false;
}
if (!bfd_set_format (obfd, bfd_get_format (ibfd)))
{
bfd_nonfatal_message (NULL, ibfd, NULL, NULL);
- return FALSE;
+ return false;
}
if (bfd_get_flavour (obfd) == bfd_target_coff_flavour
if (symsize < 0)
{
bfd_nonfatal_message (NULL, ibfd, NULL, NULL);
- return FALSE;
+ return false;
}
osympp = isympp = (asymbol **) xmalloc (symsize);
if (symcount < 0)
{
bfd_nonfatal_message (NULL, ibfd, NULL, NULL);
- return FALSE;
+ return false;
}
/* PR 17512: file: d6323821
If the symbol table could not be loaded do not pretend that we have
{
flagword flags;
- pset = find_section_list (padd->name, FALSE,
+ pset = find_section_list (padd->name, false,
SECTION_CONTEXT_SET_FLAGS);
if (pset != NULL)
{
{
bfd_nonfatal_message (NULL, obfd, NULL,
_("can't add section '%s'"), padd->name);
- return FALSE;
+ return false;
}
else
{
bfd_nonfatal_message (NULL, obfd, NULL,
_("can't create section `%s'"),
padd->name);
- return FALSE;
+ return false;
}
}
if (!bfd_set_section_size (padd->section, padd->size))
{
bfd_nonfatal_message (NULL, obfd, padd->section, NULL);
- return FALSE;
+ return false;
}
- pset = find_section_list (padd->name, FALSE,
+ pset = find_section_list (padd->name, false,
SECTION_CONTEXT_SET_VMA | SECTION_CONTEXT_ALTER_VMA);
if (pset != NULL
&& !bfd_set_section_vma (padd->section, pset->vma_val))
{
bfd_nonfatal_message (NULL, obfd, padd->section, NULL);
- return FALSE;
+ return false;
}
- pset = find_section_list (padd->name, FALSE,
+ pset = find_section_list (padd->name, false,
SECTION_CONTEXT_SET_LMA | SECTION_CONTEXT_ALTER_LMA);
if (pset != NULL)
{
(padd->section, bfd_section_alignment (padd->section)))
{
bfd_nonfatal_message (NULL, obfd, padd->section, NULL);
- return FALSE;
+ return false;
}
}
}
if (pupdate->section == NULL)
{
non_fatal (_("error: %s not found, can't be updated"), pupdate->name);
- return FALSE;
+ return false;
}
osec = pupdate->section->output_section;
if (!bfd_set_section_size (osec, pupdate->size))
{
bfd_nonfatal_message (NULL, obfd, osec, NULL);
- return FALSE;
+ return false;
}
}
}
strerror (errno));
free (contents);
fclose (f);
- return FALSE;
+ return false;
}
}
else
bfd_nonfatal_message (NULL, obfd, NULL,
_("cannot create debug link section `%s'"),
gnu_debuglink_filename);
- return FALSE;
+ return false;
}
/* Special processing for PE format files. We
have been created, but before their contents are set. */
dhandle = NULL;
if (convert_debugging)
- dhandle = read_debugging_info (ibfd, isympp, symcount, FALSE);
+ dhandle = read_debugging_info (ibfd, isympp, symcount, false);
if ((obfd->flags & (EXEC_P | DYNAMIC)) != 0
&& (obfd->flags & HAS_RELOC) == 0)
if (bfd_get_error () != bfd_error_no_error)
{
status = 1;
- return FALSE;
+ return false;
}
}
if (convert_debugging && dhandle != NULL)
{
- bfd_boolean res;
+ bool res;
res = write_debugging_info (obfd, dhandle, &symcount, &osympp);
if (! res)
{
status = 1;
- return FALSE;
+ return false;
}
}
0, padd->size))
{
bfd_nonfatal_message (NULL, obfd, padd->section, NULL);
- return FALSE;
+ return false;
}
}
}
0, pupdate->size))
{
bfd_nonfatal_message (NULL, obfd, osec, NULL);
- return FALSE;
+ return false;
}
}
}
bfd_nonfatal_message
(NULL, obfd, osec,
_("error: failed to copy merged notes into output"));
- return FALSE;
+ return false;
}
merged = merged->next;
bfd_nonfatal_message (NULL, obfd, NULL,
_("cannot fill debug link section `%s'"),
gnu_debuglink_filename);
- return FALSE;
+ return false;
}
}
{
bfd_nonfatal_message (NULL, obfd, osections[i], NULL);
free (buf);
- return FALSE;
+ return false;
}
left -= now;
{
bfd_nonfatal_message (NULL, obfd, NULL,
_("error copying private BFD data"));
- return FALSE;
+ return false;
}
/* Switch to the alternate machine code. We have to do this at the
}
}
- return TRUE;
+ return true;
}
/* Read each archive element in turn from IBFD, copy the
static void
copy_archive (bfd *ibfd, bfd *obfd, const char *output_target,
- bfd_boolean force_output_target,
+ bool force_output_target,
const bfd_arch_info_type *input_arch)
{
struct name_list
strerror (errno));
if (strip_symbols == STRIP_ALL)
- obfd->has_armap = FALSE;
+ obfd->has_armap = false;
else
obfd->has_armap = ibfd->has_armap;
obfd->is_thin_archive = ibfd->is_thin_archive;
bfd *last_element;
struct stat buf;
int stat_status = 0;
- bfd_boolean del = TRUE;
- bfd_boolean ok_object;
+ bool del = true;
+ bool ok_object;
/* PR binutils/17533: Do not allow directory traversal
outside of the current directory tree by archive members. */
if (del && bfd_get_arch (this_element) == bfd_arch_unknown)
/* Try again as an unknown object file. */
- ok_object = FALSE;
+ ok_object = false;
else if (!bfd_close (output_bfd))
{
bfd_nonfatal_message (output_name, NULL, NULL, NULL);
if (bfd_check_format (ibfd, bfd_archive))
{
- bfd_boolean force_output_target;
+ bool force_output_target;
bfd *obfd;
/* bfd_get_target does not return the correct value until
if (output_target == NULL)
{
output_target = bfd_get_target (ibfd);
- force_output_target = FALSE;
+ force_output_target = false;
}
else
- force_output_target = TRUE;
+ force_output_target = true;
if (ofd >= 0)
obfd = bfd_fdopenw (output_filename, output_target, ofd);
const char * name;
const char * new_name;
char *prefix = NULL;
- bfd_boolean make_nobits;
+ bool make_nobits;
unsigned int alignment;
if (is_strip_section (ibfd, isection))
name = n;
}
- make_nobits = FALSE;
+ make_nobits = false;
- p = find_section_list (bfd_section_name (isection), FALSE,
+ p = find_section_list (bfd_section_name (isection), false,
SECTION_CONTEXT_SET_FLAGS);
if (p != NULL)
{
flags &= ~(SEC_HAS_CONTENTS | SEC_LOAD | SEC_GROUP);
if (bfd_get_flavour (obfd) == bfd_target_elf_flavour)
{
- make_nobits = TRUE;
+ make_nobits = true;
/* Twiddle the input section flags so that it seems to
elf.c:copy_private_bfd_data that section flags have not
}
vma = bfd_section_vma (isection);
- p = find_section_list (bfd_section_name (isection), FALSE,
+ p = find_section_list (bfd_section_name (isection), false,
SECTION_CONTEXT_ALTER_VMA | SECTION_CONTEXT_SET_VMA);
if (p != NULL)
{
}
lma = isection->lma;
- p = find_section_list (bfd_section_name (isection), FALSE,
+ p = find_section_list (bfd_section_name (isection), false,
SECTION_CONTEXT_ALTER_LMA | SECTION_CONTEXT_SET_LMA);
if (p != NULL)
{
osection->lma = lma;
- p = find_section_list (bfd_section_name (isection), FALSE,
+ p = find_section_list (bfd_section_name (isection), false,
SECTION_CONTEXT_SET_ALIGNMENT);
if (p != NULL)
alignment = p->alignment;
/* Return TRUE if input section ISECTION should be skipped. */
-static bfd_boolean
-skip_section (bfd *ibfd, sec_ptr isection, bfd_boolean skip_copy)
+static bool
+skip_section (bfd *ibfd, sec_ptr isection, bool skip_copy)
{
sec_ptr osection;
bfd_size_type size;
/* If we have already failed earlier on,
do not keep on generating complaints now. */
if (status != 0)
- return TRUE;
+ return true;
if (extract_symbol)
- return TRUE;
+ return true;
if (is_strip_section (ibfd, isection))
- return TRUE;
+ return true;
if (is_update_section (ibfd, isection))
- return TRUE;
+ return true;
/* When merging a note section we skip the copying of the contents,
but not the copying of the relocs associated with the contents. */
if (skip_copy && is_mergeable_note_section (ibfd, isection))
- return TRUE;
+ return true;
flags = bfd_section_flags (isection);
if ((flags & SEC_GROUP) != 0)
- return TRUE;
+ return true;
osection = isection->output_section;
size = bfd_section_size (isection);
if (size == 0 || osection == 0)
- return TRUE;
+ return true;
- return FALSE;
+ return false;
}
/* Add section SECTION_PATTERN to the list of sections that will have their
static void
handle_remove_relocations_option (const char *section_pattern)
{
- find_section_list (section_pattern, TRUE, SECTION_CONTEXT_REMOVE_RELOCS);
+ find_section_list (section_pattern, true, SECTION_CONTEXT_REMOVE_RELOCS);
}
/* Return TRUE if ISECTION from IBFD should have its relocations removed,
removed from a section that does not have relocations then this
function will still return TRUE. */
-static bfd_boolean
+static bool
discard_relocations (bfd *ibfd ATTRIBUTE_UNUSED, asection *isection)
{
- return (find_section_list (bfd_section_name (isection), FALSE,
+ return (find_section_list (bfd_section_name (isection), false,
SECTION_CONTEXT_REMOVE_RELOCS) != NULL);
}
static void
handle_remove_section_option (const char *section_pattern)
{
- find_section_list (section_pattern, TRUE, SECTION_CONTEXT_REMOVE);
+ find_section_list (section_pattern, true, SECTION_CONTEXT_REMOVE);
if (strncmp (section_pattern, ".rel", 4) == 0)
{
section_pattern += 4;
if (*section_pattern)
handle_remove_relocations_option (section_pattern);
}
- sections_removed = TRUE;
+ sections_removed = true;
}
/* Copy relocations in input section ISECTION of IBFD to an output
long relcount;
sec_ptr osection;
- if (skip_section (ibfd, isection, FALSE))
+ if (skip_section (ibfd, isection, false))
return;
osection = isection->output_section;
sec_ptr osection;
bfd_size_type size;
- if (skip_section (ibfd, isection, TRUE))
+ if (skip_section (ibfd, isection, true))
return;
osection = isection->output_section;
free (memhunk);
}
else if ((p = find_section_list (bfd_section_name (isection),
- FALSE, SECTION_CONTEXT_SET_FLAGS)) != NULL
+ false, SECTION_CONTEXT_SET_FLAGS)) != NULL
&& (p->flags & SEC_HAS_CONTENTS) != 0)
{
void *memhunk = xmalloc (size);
/* Write out debugging information. */
-static bfd_boolean
+static bool
write_debugging_info (bfd *obfd, void *dhandle,
long *symcountp ATTRIBUTE_UNUSED,
asymbol ***symppp ATTRIBUTE_UNUSED)
if (! write_stabs_in_sections_debugging_info (obfd, dhandle, &syms,
&symsize, &strings,
&stringsize))
- return FALSE;
+ return false;
flags = SEC_HAS_CONTENTS | SEC_READONLY | SEC_DEBUGGING;
stabsec = bfd_make_section_with_flags (obfd, ".stab", flags);
bfd_nonfatal_message (NULL, obfd, NULL,
_("can't create debugging section"));
free (strings);
- return FALSE;
+ return false;
}
/* We can get away with setting the section contents now because
bfd_nonfatal_message (NULL, obfd, NULL,
_("can't set debugging section contents"));
free (strings);
- return FALSE;
+ return false;
}
- return TRUE;
+ return true;
}
bfd_nonfatal_message (NULL, obfd, NULL,
_("don't know how to write debugging information for %s"),
bfd_get_target (obfd));
- return FALSE;
+ return false;
}
/* If neither -D nor -U was specified explicitly,
{
char *input_target = NULL;
char *output_target = NULL;
- bfd_boolean show_version = FALSE;
- bfd_boolean formats_info = FALSE;
+ bool show_version = false;
+ bool formats_info = false;
int c;
int i;
char *output_file = NULL;
- bfd_boolean merge_notes_set = FALSE;
+ bool merge_notes_set = false;
while ((c = getopt_long (argc, argv, "I:O:F:K:MN:R:o:sSpdgxXHhVvwDU",
strip_options, (int *) 0)) != EOF)
handle_remove_section_option (optarg);
break;
case OPTION_KEEP_SECTION:
- find_section_list (optarg, TRUE, SECTION_CONTEXT_KEEP);
+ find_section_list (optarg, true, SECTION_CONTEXT_KEEP);
break;
case OPTION_REMOVE_RELOCS:
handle_remove_relocations_option (optarg);
add_specific_symbol (optarg, keep_specific_htab);
break;
case 'M':
- merge_notes = TRUE;
- merge_notes_set = TRUE;
+ merge_notes = true;
+ merge_notes_set = true;
break;
case OPTION_NO_MERGE_NOTES:
- merge_notes = FALSE;
- merge_notes_set = TRUE;
+ merge_notes = false;
+ merge_notes_set = true;
break;
case 'N':
add_specific_symbol (optarg, strip_specific_htab);
output_file = optarg;
break;
case 'p':
- preserve_dates = TRUE;
+ preserve_dates = true;
break;
case 'D':
- deterministic = TRUE;
+ deterministic = true;
break;
case 'U':
- deterministic = FALSE;
+ deterministic = false;
break;
case 'x':
discard_locals = LOCALS_ALL;
discard_locals = LOCALS_START_L;
break;
case 'v':
- verbose = TRUE;
+ verbose = true;
break;
case 'V':
- show_version = TRUE;
+ show_version = true;
break;
case OPTION_FORMATS_INFO:
- formats_info = TRUE;
+ formats_info = true;
break;
case OPTION_ONLY_KEEP_DEBUG:
strip_symbols = STRIP_NONDEBUG;
keep_file_symbols = 1;
break;
case OPTION_KEEP_SECTION_SYMBOLS:
- keep_section_symbols = TRUE;
+ keep_section_symbols = true;
break;
case 0:
/* We've been given a long option. */
break;
case 'w':
- wildcard = TRUE;
+ wildcard = true;
break;
case 'H':
case 'h':
|| strip_symbols == STRIP_UNNEEDED
|| strip_symbols == STRIP_NONDEBUG
|| strip_symbols == STRIP_NONDWO))
- merge_notes = TRUE;
+ merge_notes = true;
if (formats_info)
{
char *tmpname;
char *input_target = NULL;
char *output_target = NULL;
- bfd_boolean show_version = FALSE;
- bfd_boolean change_warn = TRUE;
- bfd_boolean formats_info = FALSE;
- bfd_boolean use_globalize = FALSE;
- bfd_boolean use_keep_global = FALSE;
+ bool show_version = false;
+ bool change_warn = true;
+ bool formats_info = false;
+ bool use_globalize = false;
+ bool use_keep_global = false;
int c;
int tmpfd = -1;
int copyfd;
break;
case 'j':
- find_section_list (optarg, TRUE, SECTION_CONTEXT_COPY);
- sections_copied = TRUE;
+ find_section_list (optarg, true, SECTION_CONTEXT_COPY);
+ sections_copied = true;
break;
case 'R':
break;
case OPTION_KEEP_SECTION:
- find_section_list (optarg, TRUE, SECTION_CONTEXT_KEEP);
+ find_section_list (optarg, true, SECTION_CONTEXT_KEEP);
break;
case OPTION_REMOVE_RELOCS:
break;
case 'M':
- merge_notes = TRUE;
+ merge_notes = true;
break;
case OPTION_NO_MERGE_NOTES:
- merge_notes = FALSE;
+ merge_notes = false;
break;
case 'N':
break;
case OPTION_GLOBALIZE_SYMBOL:
- use_globalize = TRUE;
+ use_globalize = true;
add_specific_symbol (optarg, globalize_specific_htab);
break;
case 'G':
- use_keep_global = TRUE;
+ use_keep_global = true;
add_specific_symbol (optarg, keepglobal_specific_htab);
break;
break;
case 'p':
- preserve_dates = TRUE;
+ preserve_dates = true;
break;
case 'D':
- deterministic = TRUE;
+ deterministic = true;
break;
case 'U':
- deterministic = FALSE;
+ deterministic = false;
break;
case 'w':
- wildcard = TRUE;
+ wildcard = true;
break;
case 'x':
break;
case 'v':
- verbose = TRUE;
+ verbose = true;
break;
case 'V':
- show_version = TRUE;
+ show_version = true;
break;
case OPTION_FORMATS_INFO:
- formats_info = TRUE;
+ formats_info = true;
break;
case OPTION_WEAKEN:
- weaken = TRUE;
+ weaken = true;
break;
case OPTION_ADD_SECTION:
strncpy (name, optarg, len);
name[len] = '\0';
- p = find_section_list (name, TRUE, context);
+ p = find_section_list (name, true, context);
val = parse_vma (s + 1, option);
if (*s == '-')
break;
case OPTION_CHANGE_WARNINGS:
- change_warn = TRUE;
+ change_warn = true;
break;
case OPTION_CHANGE_LEADING_CHAR:
- change_leading_char = TRUE;
+ change_leading_char = true;
break;
case OPTION_COMPRESS_DEBUG_SECTIONS:
break;
case OPTION_DEBUGGING:
- convert_debugging = TRUE;
+ convert_debugging = true;
break;
case OPTION_DECOMPRESS_DEBUG_SECTIONS:
non_fatal (_("Warning: truncating gap-fill from 0x%s to 0x%x"),
buff, gap_fill);
}
- gap_fill_set = TRUE;
+ gap_fill_set = true;
}
break;
case OPTION_NO_CHANGE_WARNINGS:
- change_warn = FALSE;
+ change_warn = false;
break;
case OPTION_PAD_TO:
pad_to = parse_vma (optarg, "--pad-to");
- pad_to_set = TRUE;
+ pad_to_set = true;
break;
case OPTION_REMOVE_LEADING_CHAR:
- remove_leading_char = TRUE;
+ remove_leading_char = true;
break;
case OPTION_REDEFINE_SYM:
strncpy (name, optarg, len);
name[len] = '\0';
- p = find_section_list (name, TRUE, SECTION_CONTEXT_SET_FLAGS);
+ p = find_section_list (name, true, SECTION_CONTEXT_SET_FLAGS);
p->flags = parse_flags (s + 1);
}
strncpy (name, optarg, len);
name[len] = '\0';
- p = find_section_list (name, TRUE, SECTION_CONTEXT_SET_ALIGNMENT);
+ p = find_section_list (name, true, SECTION_CONTEXT_SET_ALIGNMENT);
if (p)
p->alignment = palign;
}
case OPTION_SET_START:
set_start = parse_vma (optarg, "--set-start");
- set_start_set = TRUE;
+ set_start_set = true;
break;
case OPTION_SREC_LEN:
break;
case OPTION_SREC_FORCES3:
- _bfd_srec_forceS3 = TRUE;
+ _bfd_srec_forceS3 = true;
break;
case OPTION_STRIP_SYMBOLS:
break;
case OPTION_KEEP_SECTION_SYMBOLS:
- keep_section_symbols = TRUE;
+ keep_section_symbols = true;
break;
case OPTION_LOCALIZE_HIDDEN:
- localize_hidden = TRUE;
+ localize_hidden = true;
break;
case OPTION_LOCALIZE_SYMBOLS:
break;
case OPTION_GLOBALIZE_SYMBOLS:
- use_globalize = TRUE;
+ use_globalize = true;
add_specific_symbols (optarg, globalize_specific_htab,
&globalize_specific_buffer);
break;
case OPTION_KEEPGLOBAL_SYMBOLS:
- use_keep_global = TRUE;
+ use_keep_global = true;
add_specific_symbols (optarg, keepglobal_specific_htab,
&keepglobal_specific_buffer);
break;
break;
case OPTION_EXTRACT_SYMBOL:
- extract_symbol = TRUE;
+ extract_symbol = true;
break;
case OPTION_REVERSE_BYTES:
static int show_version = 0; /* Show the version number. */
static int dump_section_contents; /* -s */
static int dump_section_headers; /* -h */
-static bfd_boolean dump_file_header; /* -f */
+static bool dump_file_header; /* -f */
static int dump_symtab; /* -t */
static int dump_dynamic_symtab; /* -T */
static int dump_reloc_info; /* -r */
static int no_addresses; /* --no-addresses */
static int prefix_addresses; /* --prefix-addresses */
static int with_line_numbers; /* -l */
-static bfd_boolean with_source_code; /* -S */
+static bool with_source_code; /* -S */
static int show_raw_insn; /* --show-raw-insn */
static int dump_dwarf_section_info; /* --dwarf */
static int dump_stab_section_info; /* --stabs */
static char *dump_ctf_section_name;
static char *dump_ctf_parent_name; /* --ctf-parent */
static int do_demangle; /* -C, --demangle */
-static bfd_boolean disassemble; /* -d */
-static bfd_boolean disassemble_all; /* -D */
+static bool disassemble; /* -d */
+static bool disassemble_all; /* -D */
static int disassemble_zeroes; /* --disassemble-zeroes */
-static bfd_boolean formats_info; /* -i */
+static bool formats_info; /* -i */
static int wide_output; /* -w */
static int insn_width; /* --insn-width */
static bfd_vma start_address = (bfd_vma) -1; /* --start-address */
static int dump_special_syms = 0; /* --special-syms */
static bfd_vma adjust_section_vma = 0; /* --adjust-vma */
static int file_start_context = 0; /* --file-start-context */
-static bfd_boolean display_file_offsets;/* -F */
+static bool display_file_offsets; /* -F */
static const char *prefix; /* --prefix */
static int prefix_strip; /* --prefix-strip */
static size_t prefix_length;
-static bfd_boolean unwind_inlines; /* --inlines. */
+static bool unwind_inlines; /* --inlines. */
static const char * disasm_sym; /* Disassembly start symbol. */
static const char * source_comment; /* --source_comment. */
-static bfd_boolean visualize_jumps = FALSE; /* --visualize-jumps. */
-static bfd_boolean color_output = FALSE; /* --visualize-jumps=color. */
-static bfd_boolean extended_color_output = FALSE; /* --visualize-jumps=extended-color. */
-static int process_links = FALSE; /* --process-links. */
+static bool visualize_jumps = false; /* --visualize-jumps. */
+static bool color_output = false; /* --visualize-jumps=color. */
+static bool extended_color_output = false; /* --visualize-jumps=extended-color. */
+static int process_links = false; /* --process-links. */
static int demangle_flags = DMGL_ANSI | DMGL_PARAMS;
/* A structure to record the sections mentioned in -j switches. */
struct only
{
- const char * name; /* The name of the section. */
- bfd_boolean seen; /* A flag to indicate that the section has been found in one or more input files. */
- struct only * next; /* Pointer to the next structure in the list. */
+ const char *name; /* The name of the section. */
+ bool seen; /* A flag to indicate that the section has been found in one or more input files. */
+ struct only *next; /* Pointer to the next structure in the list. */
};
/* Pointer to an array of 'only' structures.
This pointer is NULL if the -j switch has not been used. */
function. */
struct objdump_disasm_info
{
- bfd * abfd;
- bfd_boolean require_sec;
- arelent ** dynrelbuf;
- long dynrelcount;
+ bfd *abfd;
+ bool require_sec;
+ arelent **dynrelbuf;
+ long dynrelcount;
disassembler_ftype disassemble_fn;
- arelent * reloc;
- const char * symbol;
+ arelent *reloc;
+ const char *symbol;
};
/* Architecture to disassemble for, or default if NULL. */
{"line-numbers", no_argument, NULL, 'l'},
{"no-show-raw-insn", no_argument, &show_raw_insn, -1},
{"no-addresses", no_argument, &no_addresses, 1},
- {"process-links", no_argument, &process_links, TRUE},
+ {"process-links", no_argument, &process_links, true},
{"prefix-addresses", no_argument, &prefix_addresses, 1},
{"recurse-limit", no_argument, NULL, OPTION_RECURSE_LIMIT},
{"recursion-limit", no_argument, NULL, OPTION_RECURSE_LIMIT},
\f
/* Returns TRUE if the specified section should be dumped. */
-static bfd_boolean
+static bool
process_section_p (asection * section)
{
struct only * only;
if (only_list == NULL)
- return TRUE;
+ return true;
for (only = only_list; only; only = only->next)
if (strcmp (only->name, section->name) == 0)
{
- only->seen = TRUE;
- return TRUE;
+ only->seen = true;
+ return true;
}
- return FALSE;
+ return false;
}
/* Add an entry to the 'only' list. */
only = xmalloc (sizeof * only);
only->name = name;
- only->seen = FALSE;
+ only->seen = false;
only->next = only_list;
only_list = only;
}
static void
free_only_list (void)
{
- bfd_boolean at_least_one_seen = FALSE;
+ bool at_least_one_seen = false;
struct only * only;
struct only * next;
for (only = only_list; only; only = only->next)
if (only->seen)
{
- at_least_one_seen = TRUE;
+ at_least_one_seen = true;
break;
}
table of sorted symbol names, even if they are marked as
debugging/section symbols. */
-static bfd_boolean
+static bool
is_significant_symbol_name (const char * name)
{
return strncmp (name, ".plt", 4) == 0 || strcmp (name, ".got") == 0;
const char *bn;
size_t anl;
size_t bnl;
- bfd_boolean as, af, bs, bf;
+ bool as, af, bs, bf;
flagword aflags;
flagword bflags;
static void
objdump_print_value (bfd_vma vma, struct disassemble_info *inf,
- bfd_boolean skip_zeroes)
+ bool skip_zeroes)
{
char buf[30];
char *p;
{
char *alloc;
const char *name, *version_string = NULL;
- bfd_boolean hidden = FALSE;
+ bool hidden = false;
alloc = NULL;
name = bfd_asymbol_name (sym);
}
if ((sym->flags & (BSF_SECTION_SYM | BSF_SYNTHETIC)) == 0)
- version_string = bfd_get_symbol_version_string (abfd, sym, TRUE,
+ version_string = bfd_get_symbol_version_string (abfd, sym, true,
&hidden);
if (bfd_is_und_section (bfd_asymbol_section (sym)))
- hidden = TRUE;
+ hidden = true;
name = sanitize_string (name);
free (alloc);
}
-static inline bfd_boolean
-sym_ok (bfd_boolean want_section,
- bfd * abfd ATTRIBUTE_UNUSED,
- long place,
- asection * sec,
- struct disassemble_info * inf)
+static inline bool
+sym_ok (bool want_section,
+ bfd *abfd ATTRIBUTE_UNUSED,
+ long place,
+ asection *sec,
+ struct disassemble_info *inf)
{
if (want_section)
{
the same owner. */
if (sorted_syms[place]->section->owner == sec->owner
&& sorted_syms[place]->section != sec)
- return FALSE;
+ return false;
/* Note - we cannot just compare section pointers because they could
be different, but the same... Ie the symbol that we are trying to
will be the same. */
if (strcmp (bfd_section_name (sorted_syms[place]->section),
bfd_section_name (sec)) != 0)
- return FALSE;
+ return false;
}
return inf->symbol_is_valid (sorted_syms[place], inf);
bfd *abfd;
asection *sec;
unsigned int opb;
- bfd_boolean want_section;
+ bool want_section;
long rel_count;
if (sorted_symcount < 1)
&& (bfd_asymbol_value (sorted_syms[min])
== bfd_asymbol_value (sorted_syms[thisplace])))
{
- if (sym_ok (TRUE, abfd, min, sec, inf))
+ if (sym_ok (true, abfd, min, sec, inf))
{
thisplace = min;
static void
objdump_print_addr_with_sym (bfd *abfd, asection *sec, asymbol *sym,
bfd_vma vma, struct disassemble_info *inf,
- bfd_boolean skip_zeroes)
+ bool skip_zeroes)
{
if (!no_addresses)
{
if (vma < secaddr)
{
(*inf->fprintf_func) (inf->stream, "-0x");
- objdump_print_value (secaddr - vma, inf, TRUE);
+ objdump_print_value (secaddr - vma, inf, true);
}
else if (vma > secaddr)
{
(*inf->fprintf_func) (inf->stream, "+0x");
- objdump_print_value (vma - secaddr, inf, TRUE);
+ objdump_print_value (vma - secaddr, inf, true);
}
(*inf->fprintf_func) (inf->stream, ">");
}
else if (bfd_asymbol_value (sym) > vma)
{
(*inf->fprintf_func) (inf->stream, "-0x");
- objdump_print_value (bfd_asymbol_value (sym) - vma, inf, TRUE);
+ objdump_print_value (bfd_asymbol_value (sym) - vma, inf, true);
}
else if (vma > bfd_asymbol_value (sym))
{
(*inf->fprintf_func) (inf->stream, "+0x");
- objdump_print_value (vma - bfd_asymbol_value (sym), inf, TRUE);
+ objdump_print_value (vma - bfd_asymbol_value (sym), inf, true);
}
(*inf->fprintf_func) (inf->stream, ">");
static void
objdump_print_addr (bfd_vma vma,
struct disassemble_info *inf,
- bfd_boolean skip_zeroes)
+ bool skip_zeroes)
{
struct objdump_disasm_info *aux;
asymbol *sym = NULL;
- bfd_boolean skip_find = FALSE;
+ bool skip_find = false;
aux = (struct objdump_disasm_info *) inf->application_data;
vma += bfd_asymbol_value (sym);
if (bfd_is_und_section (bfd_asymbol_section (sym)))
- skip_find = TRUE;
+ skip_find = true;
}
if (!skip_find)
const char *functionname;
unsigned int linenumber;
unsigned int discriminator;
- bfd_boolean reloc;
+ bool reloc;
char *path = NULL;
if (! with_line_numbers && ! with_source_code)
path_up[PATH_MAX] = '\0';
filename = path;
- reloc = TRUE;
+ reloc = true;
}
else
- reloc = FALSE;
+ reloc = false;
if (with_line_numbers)
{
/* Test if an address is one of the start addresses of a jump. */
-static bfd_boolean
+static bool
jump_info_is_start_address (const struct jump_info *ji, bfd_vma address)
{
- bfd_boolean result = FALSE;
+ bool result = false;
size_t i;
for (i = ji->start.count; i-- > 0;)
if (address == ji->start.addresses[i])
{
- result = TRUE;
+ result = true;
break;
}
/* Test if an address is the target address of a jump. */
-static bfd_boolean
+static bool
jump_info_is_end_address (const struct jump_info *ji, bfd_vma address)
{
return (address == ji->end);
/* Test if two jumps intersect. */
-static bfd_boolean
+static bool
jump_info_intersect (const struct jump_info *a,
const struct jump_info *b)
{
{
/* Test if the jump intersects with any
jump from current group. */
- bfd_boolean ok = TRUE;
+ bool ok = true;
struct jump_info *it_collision;
for (it_collision = base;
/* This jump intersects so we leave it out. */
if (jump_info_intersect (it_collision, it))
{
- ok = FALSE;
+ ok = false;
break;
}
}
/* Disassemble some data in memory between given values. */
static void
-disassemble_bytes (struct disassemble_info * inf,
- disassembler_ftype disassemble_fn,
- bfd_boolean insns,
- bfd_byte * data,
- bfd_vma start_offset,
- bfd_vma stop_offset,
- bfd_vma rel_offset,
- arelent *** relppp,
- arelent ** relppend)
+disassemble_bytes (struct disassemble_info *inf,
+ disassembler_ftype disassemble_fn,
+ bool insns,
+ bfd_byte *data,
+ bfd_vma start_offset,
+ bfd_vma stop_offset,
+ bfd_vma rel_offset,
+ arelent ***relppp,
+ arelent **relppend)
{
struct objdump_disasm_info *aux;
asection *section;
addr_offset = start_offset;
while (addr_offset < stop_offset)
{
- bfd_boolean need_nl = FALSE;
+ bool need_nl = false;
octets = 0;
}
else
{
- aux->require_sec = TRUE;
+ aux->require_sec = true;
objdump_print_address (section->vma + addr_offset, inf);
- aux->require_sec = FALSE;
+ aux->require_sec = false;
putchar (' ');
}
if (!wide_output)
putchar ('\n');
else
- need_nl = TRUE;
+ need_nl = true;
}
while ((*relppp) < relppend
if (!no_addresses)
{
objdump_print_value (section->vma - rel_offset + q->address,
- inf, TRUE);
+ inf, true);
printf (": ");
}
}
else
printf ("+0x");
- objdump_print_value (addend, inf, TRUE);
+ objdump_print_value (addend, inf, true);
}
printf ("\n");
- need_nl = FALSE;
+ need_nl = false;
}
++(*relppp);
}
static void
disassemble_section (bfd *abfd, asection *section, void *inf)
{
- const struct elf_backend_data * bed;
- bfd_vma sign_adjust = 0;
- struct disassemble_info * pinfo = (struct disassemble_info *) inf;
- struct objdump_disasm_info * paux;
- unsigned int opb = pinfo->octets_per_byte;
- bfd_byte * data = NULL;
- bfd_size_type datasize = 0;
- arelent ** rel_pp = NULL;
- arelent ** rel_ppstart = NULL;
- arelent ** rel_ppend;
- bfd_vma stop_offset;
- asymbol * sym = NULL;
- long place = 0;
- long rel_count;
- bfd_vma rel_offset;
- unsigned long addr_offset;
- bfd_boolean do_print;
+ const struct elf_backend_data *bed;
+ bfd_vma sign_adjust = 0;
+ struct disassemble_info *pinfo = (struct disassemble_info *) inf;
+ struct objdump_disasm_info *paux;
+ unsigned int opb = pinfo->octets_per_byte;
+ bfd_byte *data = NULL;
+ bfd_size_type datasize = 0;
+ arelent **rel_pp = NULL;
+ arelent **rel_ppstart = NULL;
+ arelent **rel_ppend;
+ bfd_vma stop_offset;
+ asymbol *sym = NULL;
+ long place = 0;
+ long rel_count;
+ bfd_vma rel_offset;
+ unsigned long addr_offset;
+ bool do_print;
enum loop_control
{
stop_offset_reached,
printf (_("\nDisassembly of section %s:\n"), sanitize_string (section->name));
/* Find the nearest symbol forwards from our current position. */
- paux->require_sec = TRUE;
+ paux->require_sec = true;
sym = (asymbol *) find_symbol_for_address (section->vma + addr_offset,
(struct disassemble_info *) inf,
&place);
- paux->require_sec = FALSE;
+ paux->require_sec = false;
/* PR 9774: If the target used signed addresses then we must make
sure that we sign extend the value that we calculate for 'addr'
bfd_vma addr;
asymbol *nextsym;
bfd_vma nextstop_offset;
- bfd_boolean insns;
+ bool insns;
addr = section->vma + addr_offset;
addr = ((addr & ((sign_adjust << 1) - 1)) ^ sign_adjust) - sign_adjust;
{
case function_sym:
if (sym->flags & BSF_FUNCTION)
- do_print = FALSE;
+ do_print = false;
break;
case stop_offset_reached:
that the name of sym is different from
paux->symbol. */
if (! bfd_is_local_label (abfd, sym))
- do_print = FALSE;
+ do_print = false;
break;
}
}
if the current symbol matches the requested symbol. */
if (streq (name, paux->symbol))
{
- do_print = TRUE;
+ do_print = true;
if (sym->flags & BSF_FUNCTION)
{
{
pinfo->fprintf_func (pinfo->stream, "\n");
objdump_print_addr_with_sym (abfd, section, sym, addr,
- pinfo, FALSE);
+ pinfo, false);
pinfo->fprintf_func (pinfo->stream, ":\n");
}
&& (strstr (bfd_asymbol_name (sym), "gcc2_compiled")
== NULL))
|| (sym->flags & BSF_FUNCTION) != 0)
- insns = TRUE;
+ insns = true;
else
- insns = FALSE;
+ insns = false;
if (do_print)
{
disasm_info.application_data = (void *) &aux;
aux.abfd = abfd;
- aux.require_sec = FALSE;
+ aux.require_sec = false;
aux.dynrelbuf = NULL;
aux.dynrelcount = 0;
aux.reloc = NULL;
disasm_info.octets_per_byte = bfd_octets_per_byte (abfd, NULL);
disasm_info.skip_zeroes = DEFAULT_SKIP_ZEROES;
disasm_info.skip_zeroes_at_end = DEFAULT_SKIP_ZEROES_AT_END;
- disasm_info.disassembler_needs_relocs = FALSE;
+ disasm_info.disassembler_needs_relocs = false;
if (bfd_big_endian (abfd))
disasm_info.display_endian = disasm_info.endian = BFD_ENDIAN_BIG;
disassemble_free_target (&disasm_info);
}
\f
-static bfd_boolean
+static bool
load_specific_debug_section (enum dwarf_section_display_enum debug,
asection *sec, void *file)
{
bfd_byte *contents;
bfd_size_type amt;
size_t alloced;
- bfd_boolean ret;
+ bool ret;
if (section->start != NULL)
{
/* If it is already loaded, do nothing. */
if (streq (section->filename, bfd_get_filename (abfd)))
- return TRUE;
+ return true;
free (section->start);
}
printf (_("\nSection '%s' has an invalid size: %#llx.\n"),
sanitize_string (section->name),
(unsigned long long) section->size);
- return FALSE;
+ return false;
}
section->start = contents = xmalloc (alloced);
free_debug_section (debug);
printf (_("\nCan't get contents for section '%s'.\n"),
sanitize_string (section->name));
- return FALSE;
+ return false;
}
- return TRUE;
+ return true;
}
-bfd_boolean
+bool
reloc_at (struct dwarf_section * dsec, dwarf_vma offset)
{
arelent ** relocs;
arelent * rp;
if (dsec == NULL || dsec->reloc_info == NULL)
- return FALSE;
+ return false;
relocs = (arelent **) dsec->reloc_info;
for (; (rp = * relocs) != NULL; ++ relocs)
if (rp->address == offset)
- return TRUE;
+ return true;
- return FALSE;
+ return false;
}
-bfd_boolean
+bool
load_debug_section (enum dwarf_section_display_enum debug, void *file)
{
struct dwarf_section *section = &debug_displays [debug].section;
if (section->start != NULL)
{
if (streq (section->filename, bfd_get_filename (abfd)))
- return TRUE;
+ return true;
}
/* Locate the debug section. */
section->name = section->compressed_name;
}
if (sec == NULL)
- return FALSE;
+ return false;
return load_specific_debug_section (debug, sec, file);
}
{
printf (_("No %s section present\n\n"),
sanitize_string (sect_name));
- return FALSE;
+ return false;
}
if (!bfd_malloc_and_get_section (abfd, stabsect, &contents))
/* Clear all options. */
for (opt = (*desc)->options; opt->name; opt++)
- opt->selected = FALSE;
+ opt->selected = false;
/* Decode options. */
b = dump_private_options;
for (opt = (*desc)->options; opt->name; opt++)
if (strcmp (opt->name, b) == 0)
{
- opt->selected = TRUE;
+ opt->selected = true;
break;
}
if (opt->name == NULL)
/* Should perhaps share code and display with nm? */
static void
-dump_symbols (bfd *abfd ATTRIBUTE_UNUSED, bfd_boolean dynamic)
+dump_symbols (bfd *abfd ATTRIBUTE_UNUSED, bool dynamic)
{
asymbol **current;
long max_count;
{
if ((section->flags & SEC_DEBUGGING) == 0)
{
- bfd_boolean *has_reloc_p = (bfd_boolean *) arg;
+ bool *has_reloc_p = (bool *) arg;
section->vma += adjust_section_vma;
if (*has_reloc_p)
section->lma += adjust_section_vma;
/* Dump selected contents of ABFD. */
static void
-dump_bfd (bfd *abfd, bfd_boolean is_mainfile)
+dump_bfd (bfd *abfd, bool is_mainfile)
{
const struct elf_backend_data * bed;
separate_info * i;
for (i = first_separate_info; i != NULL; i = i->next)
- dump_bfd (i->handle, FALSE);
+ dump_bfd (i->handle, false);
}
}
bfd_find_nearest_line will not do the right thing. */
if (adjust_section_vma != 0)
{
- bfd_boolean has_reloc = (abfd->flags & HAS_RELOC);
+ bool has_reloc = (abfd->flags & HAS_RELOC);
bfd_map_over_sections (abfd, adjust_addresses, &has_reloc);
}
sanitize_string (bfd_get_filename (abfd)),
abfd->xvec->name);
if (dump_ar_hdrs)
- print_arelt_descr (stdout, abfd, TRUE, FALSE);
+ print_arelt_descr (stdout, abfd, true, false);
if (dump_file_header)
dump_bfd_header (abfd);
if (dump_private_headers)
}
if (dump_symtab)
- dump_symbols (abfd, FALSE);
+ dump_symbols (abfd, false);
if (dump_dynamic_symtab)
- dump_symbols (abfd, TRUE);
+ dump_symbols (abfd, true);
if (dump_dwarf_section_info)
dump_dwarf (abfd);
if (dump_ctf_section_info)
{
void *dhandle;
- dhandle = read_debugging_info (abfd, syms, symcount, TRUE);
+ dhandle = read_debugging_info (abfd, syms, symcount, true);
if (dhandle != NULL)
{
if (!print_debugging_info (stdout, dhandle, abfd, syms,
if (bfd_check_format_matches (abfd, bfd_object, &matching))
{
- dump_bfd (abfd, TRUE);
+ dump_bfd (abfd, true);
return;
}
if (bfd_check_format_matches (abfd, bfd_core, &matching))
{
- dump_bfd (abfd, TRUE);
+ dump_bfd (abfd, true);
return;
}
}
static void
-display_file (char *filename, char *target, bfd_boolean last_file)
+display_file (char *filename, char *target, bool last_file)
{
bfd *file;
{
int c;
char *target = default_target;
- bfd_boolean seenflag = FALSE;
+ bool seenflag = false;
#if defined (HAVE_SETLOCALE)
#if defined (HAVE_LC_MESSAGES)
add_only (optarg);
break;
case 'F':
- display_file_offsets = TRUE;
+ display_file_offsets = true;
break;
case 'l':
- with_line_numbers = TRUE;
+ with_line_numbers = true;
break;
case 'b':
target = optarg;
break;
case 'C':
- do_demangle = TRUE;
+ do_demangle = true;
if (optarg != NULL)
{
enum demangling_styles style;
demangle_flags |= DMGL_NO_RECURSE_LIMIT;
break;
case 'w':
- do_wide = wide_output = TRUE;
+ do_wide = wide_output = true;
break;
case OPTION_ADJUST_VMA:
adjust_section_vma = parse_vma (optarg, "--adjust-vma");
fatal (_("error: instruction width must be positive"));
break;
case OPTION_INLINES:
- unwind_inlines = TRUE;
+ unwind_inlines = true;
break;
case OPTION_VISUALIZE_JUMPS:
- visualize_jumps = TRUE;
- color_output = FALSE;
- extended_color_output = FALSE;
+ visualize_jumps = true;
+ color_output = false;
+ extended_color_output = false;
if (optarg != NULL)
{
if (streq (optarg, "color"))
- color_output = TRUE;
+ color_output = true;
else if (streq (optarg, "extended-color"))
{
- color_output = TRUE;
- extended_color_output = TRUE;
+ color_output = true;
+ extended_color_output = true;
}
else if (streq (optarg, "off"))
- visualize_jumps = FALSE;
+ visualize_jumps = false;
else
nonfatal (_("unrecognized argument to --visualize-option"));
}
break;
case 'f':
- dump_file_header = TRUE;
- seenflag = TRUE;
+ dump_file_header = true;
+ seenflag = true;
break;
case 'i':
- formats_info = TRUE;
- seenflag = TRUE;
+ formats_info = true;
+ seenflag = true;
break;
case 'I':
add_include_path (optarg);
break;
case 'p':
- dump_private_headers = TRUE;
- seenflag = TRUE;
+ dump_private_headers = true;
+ seenflag = true;
break;
case 'P':
dump_private_options = optarg;
- seenflag = TRUE;
+ seenflag = true;
break;
case 'x':
- dump_private_headers = TRUE;
- dump_symtab = TRUE;
- dump_reloc_info = TRUE;
- dump_file_header = TRUE;
- dump_ar_hdrs = TRUE;
- dump_section_headers = TRUE;
- seenflag = TRUE;
+ dump_private_headers = true;
+ dump_symtab = true;
+ dump_reloc_info = true;
+ dump_file_header = true;
+ dump_ar_hdrs = true;
+ dump_section_headers = true;
+ seenflag = true;
break;
case 't':
- dump_symtab = TRUE;
- seenflag = TRUE;
+ dump_symtab = true;
+ seenflag = true;
break;
case 'T':
- dump_dynamic_symtab = TRUE;
- seenflag = TRUE;
+ dump_dynamic_symtab = true;
+ seenflag = true;
break;
case 'd':
- disassemble = TRUE;
- seenflag = TRUE;
+ disassemble = true;
+ seenflag = true;
disasm_sym = optarg;
break;
case 'z':
- disassemble_zeroes = TRUE;
+ disassemble_zeroes = true;
break;
case 'D':
- disassemble = TRUE;
- disassemble_all = TRUE;
- seenflag = TRUE;
+ disassemble = true;
+ disassemble_all = true;
+ seenflag = true;
break;
case 'S':
- disassemble = TRUE;
- with_source_code = TRUE;
- seenflag = TRUE;
+ disassemble = true;
+ with_source_code = true;
+ seenflag = true;
break;
case OPTION_SOURCE_COMMENT:
- disassemble = TRUE;
- with_source_code = TRUE;
- seenflag = TRUE;
+ disassemble = true;
+ with_source_code = true;
+ seenflag = true;
if (optarg)
source_comment = xstrdup (sanitize_string (optarg));
else
break;
case 'g':
dump_debugging = 1;
- seenflag = TRUE;
+ seenflag = true;
break;
case 'e':
dump_debugging = 1;
dump_debugging_tags = 1;
- do_demangle = TRUE;
- seenflag = TRUE;
+ do_demangle = true;
+ seenflag = true;
break;
case 'L':
- process_links = TRUE;
- do_follow_links = TRUE;
+ process_links = true;
+ do_follow_links = true;
break;
case 'W':
- dump_dwarf_section_info = TRUE;
- seenflag = TRUE;
+ dump_dwarf_section_info = true;
+ seenflag = true;
if (optarg)
dwarf_select_sections_by_letters (optarg);
else
dwarf_select_sections_all ();
break;
case OPTION_DWARF:
- dump_dwarf_section_info = TRUE;
- seenflag = TRUE;
+ dump_dwarf_section_info = true;
+ seenflag = true;
if (optarg)
dwarf_select_sections_by_names (optarg);
else
}
break;
case OPTION_DWARF_CHECK:
- dwarf_check = TRUE;
+ dwarf_check = true;
break;
#ifdef ENABLE_LIBCTF
case OPTION_CTF:
- dump_ctf_section_info = TRUE;
+ dump_ctf_section_info = true;
dump_ctf_section_name = xstrdup (optarg);
- seenflag = TRUE;
+ seenflag = true;
break;
case OPTION_CTF_PARENT:
dump_ctf_parent_name = xstrdup (optarg);
break;
#endif
case 'G':
- dump_stab_section_info = TRUE;
- seenflag = TRUE;
+ dump_stab_section_info = true;
+ seenflag = true;
break;
case 's':
- dump_section_contents = TRUE;
- seenflag = TRUE;
+ dump_section_contents = true;
+ seenflag = true;
break;
case 'r':
- dump_reloc_info = TRUE;
- seenflag = TRUE;
+ dump_reloc_info = true;
+ seenflag = true;
break;
case 'R':
- dump_dynamic_reloc_info = TRUE;
- seenflag = TRUE;
+ dump_dynamic_reloc_info = true;
+ seenflag = true;
break;
case 'a':
- dump_ar_hdrs = TRUE;
- seenflag = TRUE;
+ dump_ar_hdrs = true;
+ seenflag = true;
break;
case 'h':
- dump_section_headers = TRUE;
- seenflag = TRUE;
+ dump_section_headers = true;
+ seenflag = true;
break;
case 'v':
case 'V':
- show_version = TRUE;
- seenflag = TRUE;
+ show_version = true;
+ seenflag = true;
break;
case 'H':
else
{
if (optind == argc)
- display_file ("a.out", target, TRUE);
+ display_file ("a.out", target, true);
else
for (; optind < argc;)
{
}
static void
-dump_dysymtab (bfd *abfd, bfd_mach_o_load_command *cmd, bfd_boolean verbose)
+dump_dysymtab (bfd *abfd, bfd_mach_o_load_command *cmd, bool verbose)
{
bfd_mach_o_dysymtab_command *dysymtab = &cmd->command.dysymtab;
bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
}
-static bfd_boolean
+static bool
load_and_dump (bfd *abfd, ufile_ptr off, unsigned int len,
void (*dump)(bfd *abfd, unsigned char *buf, unsigned int len,
ufile_ptr off))
unsigned char *buf;
if (len == 0)
- return TRUE;
+ return true;
buf = xmalloc (len);
&& bfd_bread (buf, len, abfd) == len)
dump (abfd, buf, len, off);
else
- return FALSE;
+ return false;
free (buf);
- return TRUE;
+ return true;
}
static const bfd_mach_o_xlat_name bfd_mach_o_dyld_rebase_type_name[] =
static void
dump_dyld_info (bfd *abfd, bfd_mach_o_load_command *cmd,
- bfd_boolean verbose)
+ bool verbose)
{
bfd_mach_o_dyld_info_command *dinfo = &cmd->command.dyld_info;
static void
dump_load_command (bfd *abfd, bfd_mach_o_load_command *cmd,
- unsigned int idx, bfd_boolean verbose)
+ unsigned int idx, bool verbose)
{
bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
const char *cmd_name;
for (cmd = mdata->first_command, i = 0; cmd != NULL; cmd = cmd->next, i++)
{
if (cmd32 == 0)
- dump_load_command (abfd, cmd, i, FALSE);
+ dump_load_command (abfd, cmd, i, false);
else if (cmd->type == cmd32 || cmd->type == cmd64)
- dump_load_command (abfd, cmd, i, TRUE);
+ dump_load_command (abfd, cmd, i, true);
}
}
};
static void indent (struct pr_handle *);
-static bfd_boolean push_type (struct pr_handle *, const char *);
-static bfd_boolean prepend_type (struct pr_handle *, const char *);
-static bfd_boolean append_type (struct pr_handle *, const char *);
-static bfd_boolean substitute_type (struct pr_handle *, const char *);
-static bfd_boolean indent_type (struct pr_handle *);
+static bool push_type (struct pr_handle *, const char *);
+static bool prepend_type (struct pr_handle *, const char *);
+static bool append_type (struct pr_handle *, const char *);
+static bool substitute_type (struct pr_handle *, const char *);
+static bool indent_type (struct pr_handle *);
static char *pop_type (struct pr_handle *);
-static void print_vma (bfd_vma, char *, bfd_boolean, bfd_boolean);
-static bfd_boolean pr_fix_visibility
- (struct pr_handle *, enum debug_visibility);
-static bfd_boolean pr_start_compilation_unit (void *, const char *);
-static bfd_boolean pr_start_source (void *, const char *);
-static bfd_boolean pr_empty_type (void *);
-static bfd_boolean pr_void_type (void *);
-static bfd_boolean pr_int_type (void *, unsigned int, bfd_boolean);
-static bfd_boolean pr_float_type (void *, unsigned int);
-static bfd_boolean pr_complex_type (void *, unsigned int);
-static bfd_boolean pr_bool_type (void *, unsigned int);
-static bfd_boolean pr_enum_type
+static void print_vma (bfd_vma, char *, bool, bool);
+static bool pr_fix_visibility (struct pr_handle *, enum debug_visibility);
+static bool pr_start_compilation_unit (void *, const char *);
+static bool pr_start_source (void *, const char *);
+static bool pr_empty_type (void *);
+static bool pr_void_type (void *);
+static bool pr_int_type (void *, unsigned int, bool);
+static bool pr_float_type (void *, unsigned int);
+static bool pr_complex_type (void *, unsigned int);
+static bool pr_bool_type (void *, unsigned int);
+static bool pr_enum_type
(void *, const char *, const char **, bfd_signed_vma *);
-static bfd_boolean pr_pointer_type (void *);
-static bfd_boolean pr_function_type (void *, int, bfd_boolean);
-static bfd_boolean pr_reference_type (void *);
-static bfd_boolean pr_range_type (void *, bfd_signed_vma, bfd_signed_vma);
-static bfd_boolean pr_array_type
- (void *, bfd_signed_vma, bfd_signed_vma, bfd_boolean);
-static bfd_boolean pr_set_type (void *, bfd_boolean);
-static bfd_boolean pr_offset_type (void *);
-static bfd_boolean pr_method_type (void *, bfd_boolean, int, bfd_boolean);
-static bfd_boolean pr_const_type (void *);
-static bfd_boolean pr_volatile_type (void *);
-static bfd_boolean pr_start_struct_type
- (void *, const char *, unsigned int, bfd_boolean, unsigned int);
-static bfd_boolean pr_struct_field
+static bool pr_pointer_type (void *);
+static bool pr_function_type (void *, int, bool);
+static bool pr_reference_type (void *);
+static bool pr_range_type (void *, bfd_signed_vma, bfd_signed_vma);
+static bool pr_array_type (void *, bfd_signed_vma, bfd_signed_vma, bool);
+static bool pr_set_type (void *, bool);
+static bool pr_offset_type (void *);
+static bool pr_method_type (void *, bool, int, bool);
+static bool pr_const_type (void *);
+static bool pr_volatile_type (void *);
+static bool pr_start_struct_type
+ (void *, const char *, unsigned int, bool, unsigned int);
+static bool pr_struct_field
(void *, const char *, bfd_vma, bfd_vma, enum debug_visibility);
-static bfd_boolean pr_end_struct_type (void *);
-static bfd_boolean pr_start_class_type
- (void *, const char *, unsigned int, bfd_boolean, unsigned int,
- bfd_boolean, bfd_boolean);
-static bfd_boolean pr_class_static_member
+static bool pr_end_struct_type (void *);
+static bool pr_start_class_type
+ (void *, const char *, unsigned int, bool, unsigned int, bool, bool);
+static bool pr_class_static_member
(void *, const char *, const char *, enum debug_visibility);
-static bfd_boolean pr_class_baseclass
- (void *, bfd_vma, bfd_boolean, enum debug_visibility);
-static bfd_boolean pr_class_start_method (void *, const char *);
-static bfd_boolean pr_class_method_variant
- (void *, const char *, enum debug_visibility, bfd_boolean, bfd_boolean,
- bfd_vma, bfd_boolean);
-static bfd_boolean pr_class_static_method_variant
- (void *, const char *, enum debug_visibility, bfd_boolean, bfd_boolean);
-static bfd_boolean pr_class_end_method (void *);
-static bfd_boolean pr_end_class_type (void *);
-static bfd_boolean pr_typedef_type (void *, const char *);
-static bfd_boolean pr_tag_type
+static bool pr_class_baseclass
+ (void *, bfd_vma, bool, enum debug_visibility);
+static bool pr_class_start_method (void *, const char *);
+static bool pr_class_method_variant
+ (void *, const char *, enum debug_visibility, bool, bool, bfd_vma, bool);
+static bool pr_class_static_method_variant
+ (void *, const char *, enum debug_visibility, bool, bool);
+static bool pr_class_end_method (void *);
+static bool pr_end_class_type (void *);
+static bool pr_typedef_type (void *, const char *);
+static bool pr_tag_type
(void *, const char *, unsigned int, enum debug_type_kind);
-static bfd_boolean pr_typdef (void *, const char *);
-static bfd_boolean pr_tag (void *, const char *);
-static bfd_boolean pr_int_constant (void *, const char *, bfd_vma);
-static bfd_boolean pr_float_constant (void *, const char *, double);
-static bfd_boolean pr_typed_constant (void *, const char *, bfd_vma);
-static bfd_boolean pr_variable
- (void *, const char *, enum debug_var_kind, bfd_vma);
-static bfd_boolean pr_start_function (void *, const char *, bfd_boolean);
-static bfd_boolean pr_function_parameter
+static bool pr_typdef (void *, const char *);
+static bool pr_tag (void *, const char *);
+static bool pr_int_constant (void *, const char *, bfd_vma);
+static bool pr_float_constant (void *, const char *, double);
+static bool pr_typed_constant (void *, const char *, bfd_vma);
+static bool pr_variable (void *, const char *, enum debug_var_kind, bfd_vma);
+static bool pr_start_function (void *, const char *, bool);
+static bool pr_function_parameter
(void *, const char *, enum debug_parm_kind, bfd_vma);
-static bfd_boolean pr_start_block (void *, bfd_vma);
-static bfd_boolean pr_end_block (void *, bfd_vma);
-static bfd_boolean pr_end_function (void *);
-static bfd_boolean pr_lineno (void *, const char *, unsigned long, bfd_vma);
-static bfd_boolean append_parent (struct pr_handle *, const char *);
+static bool pr_start_block (void *, bfd_vma);
+static bool pr_end_block (void *, bfd_vma);
+static bool pr_end_function (void *);
+static bool pr_lineno (void *, const char *, unsigned long, bfd_vma);
+static bool append_parent (struct pr_handle *, const char *);
/* Only used by tg_ code. */
-static bfd_boolean tg_fix_visibility
+static bool tg_fix_visibility
(struct pr_handle *, enum debug_visibility);
static void find_address_in_section (bfd *, asection *, void *);
static void translate_addresses (bfd *, char *, FILE *, asymbol **);
static const char *visibility_name (enum debug_visibility);
/* Tags style replacements. */
-static bfd_boolean tg_start_compilation_unit (void *, const char *);
-static bfd_boolean tg_start_source (void *, const char *);
-static bfd_boolean tg_enum_type
+static bool tg_start_compilation_unit (void *, const char *);
+static bool tg_start_source (void *, const char *);
+static bool tg_enum_type
(void *, const char *, const char **, bfd_signed_vma *);
-static bfd_boolean tg_start_struct_type
- (void *, const char *, unsigned int, bfd_boolean, unsigned int);
-static bfd_boolean pr_struct_field
+static bool tg_start_struct_type
+ (void *, const char *, unsigned int, bool, unsigned int);
+static bool pr_struct_field
(void *, const char *, bfd_vma, bfd_vma, enum debug_visibility);
-static bfd_boolean tg_struct_field
+static bool tg_struct_field
(void *, const char *, bfd_vma, bfd_vma, enum debug_visibility);
-static bfd_boolean tg_struct_field
+static bool tg_struct_field
(void *, const char *, bfd_vma, bfd_vma, enum debug_visibility);
-static bfd_boolean tg_end_struct_type (void *);
-static bfd_boolean tg_start_class_type
- (void *, const char *, unsigned int, bfd_boolean, unsigned int, bfd_boolean, bfd_boolean);
-static bfd_boolean tg_class_static_member
+static bool tg_end_struct_type (void *);
+static bool tg_start_class_type
+ (void *, const char *, unsigned int, bool, unsigned int, bool, bool);
+static bool tg_class_static_member
(void *, const char *, const char *, enum debug_visibility);
-static bfd_boolean tg_class_baseclass
- (void *, bfd_vma, bfd_boolean, enum debug_visibility);
-static bfd_boolean tg_class_method_variant
- (void *, const char *, enum debug_visibility, bfd_boolean, bfd_boolean, bfd_vma, bfd_boolean);
-static bfd_boolean tg_class_static_method_variant
- (void *, const char *, enum debug_visibility, bfd_boolean, bfd_boolean);
-static bfd_boolean tg_end_class_type (void *);
-static bfd_boolean tg_tag_type
+static bool tg_class_baseclass (void *, bfd_vma, bool, enum debug_visibility);
+static bool tg_class_method_variant
+ (void *, const char *, enum debug_visibility, bool, bool, bfd_vma, bool);
+static bool tg_class_static_method_variant
+ (void *, const char *, enum debug_visibility, bool, bool);
+static bool tg_end_class_type (void *);
+static bool tg_tag_type
(void *, const char *, unsigned int, enum debug_type_kind);
-static bfd_boolean tg_typdef (void *, const char *);
-static bfd_boolean tg_tag (void *, const char *);
-static bfd_boolean tg_int_constant (void *, const char *, bfd_vma);
-static bfd_boolean tg_float_constant (void *, const char *, double);
-static bfd_boolean tg_typed_constant (void *, const char *, bfd_vma);
-static bfd_boolean tg_variable
- (void *, const char *, enum debug_var_kind, bfd_vma);
-static bfd_boolean tg_start_function (void *, const char *, bfd_boolean);
-static bfd_boolean tg_function_parameter
+static bool tg_typdef (void *, const char *);
+static bool tg_tag (void *, const char *);
+static bool tg_int_constant (void *, const char *, bfd_vma);
+static bool tg_float_constant (void *, const char *, double);
+static bool tg_typed_constant (void *, const char *, bfd_vma);
+static bool tg_variable (void *, const char *, enum debug_var_kind, bfd_vma);
+static bool tg_start_function (void *, const char *, bool);
+static bool tg_function_parameter
(void *, const char *, enum debug_parm_kind, bfd_vma);
-static bfd_boolean tg_start_block (void *, bfd_vma);
-static bfd_boolean tg_end_block (void *, bfd_vma);
-static bfd_boolean tg_lineno (void *, const char *, unsigned long, bfd_vma);
+static bool tg_start_block (void *, bfd_vma);
+static bool tg_end_block (void *, bfd_vma);
+static bool tg_lineno (void *, const char *, unsigned long, bfd_vma);
\f
static const struct debug_write_fns pr_fns =
{
\f
/* Print out the generic debugging information recorded in dhandle. */
-bfd_boolean
+bool
print_debugging_info (FILE *f, void *dhandle, bfd *abfd, asymbol **syms,
char * (*demangler) (struct bfd *, const char *, int),
- bfd_boolean as_tags)
+ bool as_tags)
{
struct pr_handle info;
/* Push a type on the type stack. */
-static bfd_boolean
+static bool
push_type (struct pr_handle *info, const char *type)
{
struct pr_stack *n;
if (type == NULL)
- return FALSE;
+ return false;
n = (struct pr_stack *) xmalloc (sizeof *n);
memset (n, 0, sizeof *n);
n->next = info->stack;
info->stack = n;
- return TRUE;
+ return true;
}
/* Prepend a string onto the type on the top of the type stack. */
-static bfd_boolean
+static bool
prepend_type (struct pr_handle *info, const char *s)
{
char *n;
free (info->stack->type);
info->stack->type = n;
- return TRUE;
+ return true;
}
/* Append a string to the type on the top of the type stack. */
-static bfd_boolean
+static bool
append_type (struct pr_handle *info, const char *s)
{
unsigned int len;
if (s == NULL)
- return FALSE;
+ return false;
assert (info->stack != NULL);
len + strlen (s) + 1);
strcpy (info->stack->type + len, s);
- return TRUE;
+ return true;
}
/* Append a string to the parents on the top of the type stack. */
-static bfd_boolean
+static bool
append_parent (struct pr_handle *info, const char *s)
{
unsigned int len;
if (s == NULL)
- return FALSE;
+ return false;
assert (info->stack != NULL);
len + strlen (s) + 1);
strcpy (info->stack->parents + len, s);
- return TRUE;
+ return true;
}
/* We use an underscore to indicate where the name should go in a type
string. This function substitutes a string for the underscore. If
there is no underscore, the name follows the type. */
-static bfd_boolean
+static bool
substitute_type (struct pr_handle *info, const char *s)
{
char *u;
free (info->stack->type);
info->stack->type = n;
- return TRUE;
+ return true;
}
if (strchr (s, '|') != NULL
{
if (! prepend_type (info, "(")
|| ! append_type (info, ")"))
- return FALSE;
+ return false;
}
if (*s == '\0')
- return TRUE;
+ return true;
return (append_type (info, " ")
&& append_type (info, s));
/* Indent the type at the top of the stack by appending spaces. */
-static bfd_boolean
+static bool
indent_type (struct pr_handle *info)
{
unsigned int i;
for (i = 0; i < info->indent; i++)
{
if (! append_type (info, " "))
- return FALSE;
+ return false;
}
- return TRUE;
+ return true;
}
/* Pop a type from the type stack. */
/* Print a VMA value into a string. */
static void
-print_vma (bfd_vma vma, char *buf, bfd_boolean unsignedp, bfd_boolean hexp)
+print_vma (bfd_vma vma, char *buf, bool unsignedp, bool hexp)
{
if (sizeof (vma) <= sizeof (unsigned long))
{
\f
/* Start a new compilation unit. */
-static bfd_boolean
+static bool
pr_start_compilation_unit (void *p, const char *filename)
{
struct pr_handle *info = (struct pr_handle *) p;
fprintf (info->f, "%s:\n", filename);
- return TRUE;
+ return true;
}
/* Start a source file within a compilation unit. */
-static bfd_boolean
+static bool
pr_start_source (void *p, const char *filename)
{
struct pr_handle *info = (struct pr_handle *) p;
fprintf (info->f, " %s:\n", filename);
- return TRUE;
+ return true;
}
/* Push an empty type onto the type stack. */
-static bfd_boolean
+static bool
pr_empty_type (void *p)
{
struct pr_handle *info = (struct pr_handle *) p;
/* Push a void type onto the type stack. */
-static bfd_boolean
+static bool
pr_void_type (void *p)
{
struct pr_handle *info = (struct pr_handle *) p;
/* Push an integer type onto the type stack. */
-static bfd_boolean
-pr_int_type (void *p, unsigned int size, bfd_boolean unsignedp)
+static bool
+pr_int_type (void *p, unsigned int size, bool unsignedp)
{
struct pr_handle *info = (struct pr_handle *) p;
char ab[40];
/* Push a floating type onto the type stack. */
-static bfd_boolean
+static bool
pr_float_type (void *p, unsigned int size)
{
struct pr_handle *info = (struct pr_handle *) p;
/* Push a complex type onto the type stack. */
-static bfd_boolean
+static bool
pr_complex_type (void *p, unsigned int size)
{
struct pr_handle *info = (struct pr_handle *) p;
if (! pr_float_type (p, size))
- return FALSE;
+ return false;
return prepend_type (info, "complex ");
}
-/* Push a bfd_boolean type onto the type stack. */
+/* Push a bool type onto the type stack. */
-static bfd_boolean
+static bool
pr_bool_type (void *p, unsigned int size)
{
struct pr_handle *info = (struct pr_handle *) p;
/* Push an enum type onto the type stack. */
-static bfd_boolean
+static bool
pr_enum_type (void *p, const char *tag, const char **names,
bfd_signed_vma *values)
{
bfd_signed_vma val;
if (! push_type (info, "enum "))
- return FALSE;
+ return false;
if (tag != NULL)
{
if (! append_type (info, tag)
|| ! append_type (info, " "))
- return FALSE;
+ return false;
}
if (! append_type (info, "{ "))
- return FALSE;
+ return false;
if (names == NULL)
{
if (! append_type (info, "/* undefined */"))
- return FALSE;
+ return false;
}
else
{
if (i > 0)
{
if (! append_type (info, ", "))
- return FALSE;
+ return false;
}
if (! append_type (info, names[i]))
- return FALSE;
+ return false;
if (values[i] != val)
{
char ab[22];
- print_vma (values[i], ab, FALSE, FALSE);
+ print_vma (values[i], ab, false, false);
if (! append_type (info, " = ")
|| ! append_type (info, ab))
- return FALSE;
+ return false;
val = values[i];
}
/* Turn the top type on the stack into a pointer. */
-static bfd_boolean
+static bool
pr_pointer_type (void *p)
{
struct pr_handle *info = (struct pr_handle *) p;
/* Turn the top type on the stack into a function returning that type. */
-static bfd_boolean
-pr_function_type (void *p, int argcount, bfd_boolean varargs)
+static bool
+pr_function_type (void *p, int argcount, bool varargs)
{
struct pr_handle *info = (struct pr_handle *) p;
char **arg_types;
if (! substitute_type (info, ""))
{
free (arg_types);
- return FALSE;
+ return false;
}
arg_types[i] = pop_type (info);
if (arg_types[i] == NULL)
{
free (arg_types);
- return FALSE;
+ return false;
}
len += strlen (arg_types[i]) + 2;
}
strcat (s, ")");
if (! substitute_type (info, s))
- return FALSE;
+ return false;
free (s);
- return TRUE;
+ return true;
}
/* Turn the top type on the stack into a reference to that type. */
-static bfd_boolean
+static bool
pr_reference_type (void *p)
{
struct pr_handle *info = (struct pr_handle *) p;
/* Make a range type. */
-static bfd_boolean
+static bool
pr_range_type (void *p, bfd_signed_vma lower, bfd_signed_vma upper)
{
struct pr_handle *info = (struct pr_handle *) p;
assert (info->stack != NULL);
if (! substitute_type (info, ""))
- return FALSE;
+ return false;
- print_vma (lower, abl, FALSE, FALSE);
- print_vma (upper, abu, FALSE, FALSE);
+ print_vma (lower, abl, false, false);
+ print_vma (upper, abu, false, false);
return (prepend_type (info, "range (")
&& append_type (info, "):")
/* Make an array type. */
-static bfd_boolean
+static bool
pr_array_type (void *p, bfd_signed_vma lower, bfd_signed_vma upper,
- bfd_boolean stringp)
+ bool stringp)
{
struct pr_handle *info = (struct pr_handle *) p;
char *range_type;
range_type = pop_type (info);
if (range_type == NULL)
- return FALSE;
+ return false;
if (lower == 0)
{
sprintf (ab, "|[]");
else
{
- print_vma (upper + 1, abu, FALSE, FALSE);
+ print_vma (upper + 1, abu, false, false);
sprintf (ab, "|[%s]", abu);
}
}
else
{
- print_vma (lower, abl, FALSE, FALSE);
- print_vma (upper, abu, FALSE, FALSE);
+ print_vma (lower, abl, false, false);
+ print_vma (upper, abu, false, false);
sprintf (ab, "|[%s:%s]", abl, abu);
}
if (! substitute_type (info, ab))
- return FALSE;
+ return false;
if (strcmp (range_type, "int") != 0)
{
if (! append_type (info, ":")
|| ! append_type (info, range_type))
- return FALSE;
+ return false;
}
if (stringp)
{
if (! append_type (info, " /* string */"))
- return FALSE;
+ return false;
}
- return TRUE;
+ return true;
}
/* Make a set type. */
-static bfd_boolean
-pr_set_type (void *p, bfd_boolean bitstringp)
+static bool
+pr_set_type (void *p, bool bitstringp)
{
struct pr_handle *info = (struct pr_handle *) p;
if (! substitute_type (info, ""))
- return FALSE;
+ return false;
if (! prepend_type (info, "set { ")
|| ! append_type (info, " }"))
- return FALSE;
+ return false;
if (bitstringp)
{
if (! append_type (info, "/* bitstring */"))
- return FALSE;
+ return false;
}
- return TRUE;
+ return true;
}
/* Make an offset type. */
-static bfd_boolean
+static bool
pr_offset_type (void *p)
{
struct pr_handle *info = (struct pr_handle *) p;
char *t;
if (! substitute_type (info, ""))
- return FALSE;
+ return false;
t = pop_type (info);
if (t == NULL)
- return FALSE;
+ return false;
return (substitute_type (info, "")
&& prepend_type (info, " ")
/* Make a method type. */
-static bfd_boolean
-pr_method_type (void *p, bfd_boolean domain, int argcount, bfd_boolean varargs)
+static bool
+pr_method_type (void *p, bool domain, int argcount, bool varargs)
{
struct pr_handle *info = (struct pr_handle *) p;
unsigned int len;
else
{
if (! substitute_type (info, ""))
- return FALSE;
+ return false;
domain_type = pop_type (info);
if (domain_type == NULL)
- return FALSE;
+ return false;
if (startswith (domain_type, "class ")
&& strchr (domain_type + sizeof "class " - 1, ' ') == NULL)
domain_type += sizeof "class " - 1;
if (! substitute_type (info, ""))
{
free (arg_types);
- return FALSE;
+ return false;
}
arg_types[i] = pop_type (info);
if (arg_types[i] == NULL)
{
free (arg_types);
- return FALSE;
+ return false;
}
len += strlen (arg_types[i]) + 2;
}
strcat (s, ")");
if (! substitute_type (info, s))
- return FALSE;
+ return false;
free (s);
- return TRUE;
+ return true;
}
/* Make a const qualified type. */
-static bfd_boolean
+static bool
pr_const_type (void *p)
{
struct pr_handle *info = (struct pr_handle *) p;
/* Make a volatile qualified type. */
-static bfd_boolean
+static bool
pr_volatile_type (void *p)
{
struct pr_handle *info = (struct pr_handle *) p;
/* Start accumulating a struct type. */
-static bfd_boolean
+static bool
pr_start_struct_type (void *p, const char *tag, unsigned int id,
- bfd_boolean structp, unsigned int size)
+ bool structp, unsigned int size)
{
struct pr_handle *info = (struct pr_handle *) p;
info->indent += 2;
if (! push_type (info, structp ? "struct " : "union "))
- return FALSE;
+ return false;
if (tag != NULL)
{
if (! append_type (info, tag))
- return FALSE;
+ return false;
}
else
{
sprintf (idbuf, "%%anon%u", id);
if (! append_type (info, idbuf))
- return FALSE;
+ return false;
}
if (! append_type (info, " {"))
- return FALSE;
+ return false;
if (size != 0 || tag != NULL)
{
char ab[30];
if (! append_type (info, " /*"))
- return FALSE;
+ return false;
if (size != 0)
{
sprintf (ab, " size %u", size);
if (! append_type (info, ab))
- return FALSE;
+ return false;
}
if (tag != NULL)
{
sprintf (ab, " id %u", id);
if (! append_type (info, ab))
- return FALSE;
+ return false;
}
if (! append_type (info, " */"))
- return FALSE;
+ return false;
}
if (! append_type (info, "\n"))
- return FALSE;
+ return false;
info->stack->visibility = DEBUG_VISIBILITY_PUBLIC;
/* Output the visibility of a field in a struct. */
-static bfd_boolean
+static bool
pr_fix_visibility (struct pr_handle *info, enum debug_visibility visibility)
{
const char *s = NULL;
assert (info->stack != NULL);
if (info->stack->visibility == visibility)
- return TRUE;
+ return true;
switch (visibility)
{
break;
default:
abort ();
- return FALSE;
+ return false;
}
/* Trim off a trailing space in the struct string, to make the
if (! append_type (info, s)
|| ! append_type (info, ":\n")
|| ! indent_type (info))
- return FALSE;
+ return false;
info->stack->visibility = visibility;
- return TRUE;
+ return true;
}
/* Add a field to a struct type. */
-static bfd_boolean
+static bool
pr_struct_field (void *p, const char *name, bfd_vma bitpos, bfd_vma bitsize,
enum debug_visibility visibility)
{
char *t;
if (! substitute_type (info, name))
- return FALSE;
+ return false;
if (! append_type (info, "; /* "))
- return FALSE;
+ return false;
if (bitsize != 0)
{
- print_vma (bitsize, ab, TRUE, FALSE);
+ print_vma (bitsize, ab, true, false);
if (! append_type (info, "bitsize ")
|| ! append_type (info, ab)
|| ! append_type (info, ", "))
- return FALSE;
+ return false;
}
- print_vma (bitpos, ab, TRUE, FALSE);
+ print_vma (bitpos, ab, true, false);
if (! append_type (info, "bitpos ")
|| ! append_type (info, ab)
|| ! append_type (info, " */\n")
|| ! indent_type (info))
- return FALSE;
+ return false;
t = pop_type (info);
if (t == NULL)
- return FALSE;
+ return false;
if (! pr_fix_visibility (info, visibility))
- return FALSE;
+ return false;
return append_type (info, t);
}
/* Finish a struct type. */
-static bfd_boolean
+static bool
pr_end_struct_type (void *p)
{
struct pr_handle *info = (struct pr_handle *) p;
*s++ = '}';
*s = '\0';
- return TRUE;
+ return true;
}
/* Start a class type. */
-static bfd_boolean
+static bool
pr_start_class_type (void *p, const char *tag, unsigned int id,
- bfd_boolean structp, unsigned int size,
- bfd_boolean vptr, bfd_boolean ownvptr)
+ bool structp, unsigned int size,
+ bool vptr, bool ownvptr)
{
struct pr_handle *info = (struct pr_handle *) p;
char *tv = NULL;
{
tv = pop_type (info);
if (tv == NULL)
- return FALSE;
+ return false;
}
if (! push_type (info, structp ? "class " : "union class "))
- return FALSE;
+ return false;
if (tag != NULL)
{
if (! append_type (info, tag))
- return FALSE;
+ return false;
}
else
{
sprintf (idbuf, "%%anon%u", id);
if (! append_type (info, idbuf))
- return FALSE;
+ return false;
}
if (! append_type (info, " {"))
- return FALSE;
+ return false;
if (size != 0 || vptr || ownvptr || tag != NULL)
{
if (! append_type (info, " /*"))
- return FALSE;
+ return false;
if (size != 0)
{
sprintf (ab, "%u", size);
if (! append_type (info, " size ")
|| ! append_type (info, ab))
- return FALSE;
+ return false;
}
if (vptr)
{
if (! append_type (info, " vtable "))
- return FALSE;
+ return false;
if (ownvptr)
{
if (! append_type (info, "self "))
- return FALSE;
+ return false;
}
else
{
if (! append_type (info, tv)
|| ! append_type (info, " "))
- return FALSE;
+ return false;
}
}
sprintf (ab, " id %u", id);
if (! append_type (info, ab))
- return FALSE;
+ return false;
}
if (! append_type (info, " */"))
- return FALSE;
+ return false;
}
info->stack->visibility = DEBUG_VISIBILITY_PRIVATE;
/* Add a static member to a class. */
-static bfd_boolean
+static bool
pr_class_static_member (void *p, const char *name, const char *physname,
enum debug_visibility visibility)
{
char *t;
if (! substitute_type (info, name))
- return FALSE;
+ return false;
if (! prepend_type (info, "static ")
|| ! append_type (info, "; /* ")
|| ! append_type (info, physname)
|| ! append_type (info, " */\n")
|| ! indent_type (info))
- return FALSE;
+ return false;
t = pop_type (info);
if (t == NULL)
- return FALSE;
+ return false;
if (! pr_fix_visibility (info, visibility))
- return FALSE;
+ return false;
return append_type (info, t);
}
/* Add a base class to a class. */
-static bfd_boolean
-pr_class_baseclass (void *p, bfd_vma bitpos, bfd_boolean is_virtual,
+static bool
+pr_class_baseclass (void *p, bfd_vma bitpos, bool is_virtual,
enum debug_visibility visibility)
{
struct pr_handle *info = (struct pr_handle *) p;
assert (info->stack != NULL && info->stack->next != NULL);
if (! substitute_type (info, ""))
- return FALSE;
+ return false;
t = pop_type (info);
if (t == NULL)
- return FALSE;
+ return false;
if (startswith (t, "class "))
t += sizeof "class " - 1;
/* Push it back on to take advantage of the prepend_type and
append_type routines. */
if (! push_type (info, t))
- return FALSE;
+ return false;
if (is_virtual)
{
if (! prepend_type (info, "virtual "))
- return FALSE;
+ return false;
}
switch (visibility)
}
if (! prepend_type (info, prefix))
- return FALSE;
+ return false;
if (bitpos != 0)
{
- print_vma (bitpos, ab, TRUE, FALSE);
+ print_vma (bitpos, ab, true, false);
if (! append_type (info, " /* bitpos ")
|| ! append_type (info, ab)
|| ! append_type (info, " */"))
- return FALSE;
+ return false;
}
/* Now the top of the stack is something like "public A / * bitpos
if (*l == ':')
break;
if (! prepend_type (info, l == s ? " : " : ", "))
- return FALSE;
+ return false;
t = pop_type (info);
if (t == NULL)
- return FALSE;
+ return false;
n = (char *) xmalloc (strlen (info->stack->type) + strlen (t) + 1);
memcpy (n, info->stack->type, s - info->stack->type);
free (t);
- return TRUE;
+ return true;
}
/* Start adding a method to a class. */
-static bfd_boolean
+static bool
pr_class_start_method (void *p, const char *name)
{
struct pr_handle *info = (struct pr_handle *) p;
assert (info->stack != NULL);
info->stack->method = name;
- return TRUE;
+ return true;
}
/* Add a variant to a method. */
-static bfd_boolean
+static bool
pr_class_method_variant (void *p, const char *physname,
enum debug_visibility visibility,
- bfd_boolean constp, bfd_boolean volatilep,
- bfd_vma voffset, bfd_boolean context)
+ bool constp, bool volatilep,
+ bfd_vma voffset, bool context)
{
struct pr_handle *info = (struct pr_handle *) p;
char *method_type;
if (volatilep)
{
if (! append_type (info, " volatile"))
- return FALSE;
+ return false;
}
if (constp)
{
if (! append_type (info, " const"))
- return FALSE;
+ return false;
}
/* Stick the name of the method into its type. */
(context
? info->stack->next->next->method
: info->stack->next->method)))
- return FALSE;
+ return false;
/* Get the type. */
method_type = pop_type (info);
if (method_type == NULL)
- return FALSE;
+ return false;
/* Pull off the context type if there is one. */
if (! context)
{
context_type = pop_type (info);
if (context_type == NULL)
- return FALSE;
+ return false;
}
/* Now the top of the stack is the class. */
if (! pr_fix_visibility (info, visibility))
- return FALSE;
+ return false;
if (! append_type (info, method_type)
|| ! append_type (info, " /* ")
|| ! append_type (info, physname)
|| ! append_type (info, " "))
- return FALSE;
+ return false;
if (context || voffset != 0)
{
char ab[22];
if (! append_type (info, "context ")
|| ! append_type (info, context_type)
|| ! append_type (info, " "))
- return FALSE;
+ return false;
}
- print_vma (voffset, ab, TRUE, FALSE);
+ print_vma (voffset, ab, true, false);
if (! append_type (info, "voffset ")
|| ! append_type (info, ab))
- return FALSE;
+ return false;
}
return (append_type (info, " */;\n")
/* Add a static variant to a method. */
-static bfd_boolean
+static bool
pr_class_static_method_variant (void *p, const char *physname,
enum debug_visibility visibility,
- bfd_boolean constp, bfd_boolean volatilep)
+ bool constp, bool volatilep)
{
struct pr_handle *info = (struct pr_handle *) p;
char *method_type;
if (volatilep)
{
if (! append_type (info, " volatile"))
- return FALSE;
+ return false;
}
if (constp)
{
if (! append_type (info, " const"))
- return FALSE;
+ return false;
}
/* Mark it as static. */
if (! prepend_type (info, "static "))
- return FALSE;
+ return false;
/* Stick the name of the method into its type. */
if (! substitute_type (info, info->stack->next->method))
- return FALSE;
+ return false;
/* Get the type. */
method_type = pop_type (info);
if (method_type == NULL)
- return FALSE;
+ return false;
/* Now the top of the stack is the class. */
if (! pr_fix_visibility (info, visibility))
- return FALSE;
+ return false;
return (append_type (info, method_type)
&& append_type (info, " /* ")
/* Finish up a method. */
-static bfd_boolean
+static bool
pr_class_end_method (void *p)
{
struct pr_handle *info = (struct pr_handle *) p;
info->stack->method = NULL;
- return TRUE;
+ return true;
}
/* Finish up a class. */
-static bfd_boolean
+static bool
pr_end_class_type (void *p)
{
return pr_end_struct_type (p);
/* Push a type on the stack using a typedef name. */
-static bfd_boolean
+static bool
pr_typedef_type (void *p, const char *name)
{
struct pr_handle *info = (struct pr_handle *) p;
/* Push a type on the stack using a tag name. */
-static bfd_boolean
+static bool
pr_tag_type (void *p, const char *name, unsigned int id,
enum debug_type_kind kind)
{
break;
default:
/* PR 25625: Corrupt input can trigger this case. */
- return FALSE;
+ return false;
}
if (! push_type (info, t))
- return FALSE;
+ return false;
if (name != NULL)
tag = name;
else
}
if (! append_type (info, tag))
- return FALSE;
+ return false;
if (name != NULL && kind != DEBUG_KIND_ENUM)
{
sprintf (idbuf, " /* id %u */", id);
if (! append_type (info, idbuf))
- return FALSE;
+ return false;
}
- return TRUE;
+ return true;
}
/* Output a typedef. */
-static bfd_boolean
+static bool
pr_typdef (void *p, const char *name)
{
struct pr_handle *info = (struct pr_handle *) p;
char *s;
if (! substitute_type (info, name))
- return FALSE;
+ return false;
s = pop_type (info);
if (s == NULL)
- return FALSE;
+ return false;
indent (info);
fprintf (info->f, "typedef %s;\n", s);
free (s);
- return TRUE;
+ return true;
}
/* Output a tag. The tag should already be in the string on the
stack, so all we have to do here is print it out. */
-static bfd_boolean
+static bool
pr_tag (void *p, const char *name ATTRIBUTE_UNUSED)
{
struct pr_handle *info = (struct pr_handle *) p;
t = pop_type (info);
if (t == NULL)
- return FALSE;
+ return false;
indent (info);
fprintf (info->f, "%s;\n", t);
free (t);
- return TRUE;
+ return true;
}
/* Output an integer constant. */
-static bfd_boolean
+static bool
pr_int_constant (void *p, const char *name, bfd_vma val)
{
struct pr_handle *info = (struct pr_handle *) p;
char ab[22];
indent (info);
- print_vma (val, ab, FALSE, FALSE);
+ print_vma (val, ab, false, false);
fprintf (info->f, "const int %s = %s;\n", name, ab);
- return TRUE;
+ return true;
}
/* Output a floating point constant. */
-static bfd_boolean
+static bool
pr_float_constant (void *p, const char *name, double val)
{
struct pr_handle *info = (struct pr_handle *) p;
indent (info);
fprintf (info->f, "const double %s = %g;\n", name, val);
- return TRUE;
+ return true;
}
/* Output a typed constant. */
-static bfd_boolean
+static bool
pr_typed_constant (void *p, const char *name, bfd_vma val)
{
struct pr_handle *info = (struct pr_handle *) p;
t = pop_type (info);
if (t == NULL)
- return FALSE;
+ return false;
indent (info);
- print_vma (val, ab, FALSE, FALSE);
+ print_vma (val, ab, false, false);
fprintf (info->f, "const %s %s = %s;\n", t, name, ab);
free (t);
- return TRUE;
+ return true;
}
/* Output a variable. */
-static bfd_boolean
+static bool
pr_variable (void *p, const char *name, enum debug_var_kind kind,
bfd_vma val)
{
char ab[22];
if (! substitute_type (info, name))
- return FALSE;
+ return false;
t = pop_type (info);
if (t == NULL)
- return FALSE;
+ return false;
indent (info);
switch (kind)
default:
break;
}
- print_vma (val, ab, TRUE, TRUE);
+ print_vma (val, ab, true, true);
fprintf (info->f, "%s /* %s */;\n", t, ab);
free (t);
- return TRUE;
+ return true;
}
/* Start outputting a function. */
-static bfd_boolean
-pr_start_function (void *p, const char *name, bfd_boolean global)
+static bool
+pr_start_function (void *p, const char *name, bool global)
{
struct pr_handle *info = (struct pr_handle *) p;
char *t;
if (! substitute_type (info, name))
- return FALSE;
+ return false;
t = pop_type (info);
if (t == NULL)
- return FALSE;
+ return false;
indent (info);
if (! global)
info->parameter = 1;
- return TRUE;
+ return true;
}
/* Output a function parameter. */
-static bfd_boolean
+static bool
pr_function_parameter (void *p, const char *name,
enum debug_parm_kind kind, bfd_vma val)
{
|| kind == DEBUG_PARM_REF_REG)
{
if (! pr_reference_type (p))
- return FALSE;
+ return false;
}
if (! substitute_type (info, name))
- return FALSE;
+ return false;
t = pop_type (info);
if (t == NULL)
- return FALSE;
+ return false;
if (info->parameter != 1)
fprintf (info->f, ", ");
if (kind == DEBUG_PARM_REG || kind == DEBUG_PARM_REF_REG)
fprintf (info->f, "register ");
- print_vma (val, ab, TRUE, TRUE);
+ print_vma (val, ab, true, true);
fprintf (info->f, "%s /* %s */", t, ab);
free (t);
++info->parameter;
- return TRUE;
+ return true;
}
/* Start writing out a block. */
-static bfd_boolean
+static bool
pr_start_block (void *p, bfd_vma addr)
{
struct pr_handle *info = (struct pr_handle *) p;
}
indent (info);
- print_vma (addr, ab, TRUE, TRUE);
+ print_vma (addr, ab, true, true);
fprintf (info->f, "{ /* %s */\n", ab);
info->indent += 2;
- return TRUE;
+ return true;
}
/* Write out line number information. */
-static bfd_boolean
+static bool
pr_lineno (void *p, const char *filename, unsigned long lineno, bfd_vma addr)
{
struct pr_handle *info = (struct pr_handle *) p;
char ab[22];
indent (info);
- print_vma (addr, ab, TRUE, TRUE);
+ print_vma (addr, ab, true, true);
fprintf (info->f, "/* file %s line %lu addr %s */\n", filename, lineno, ab);
- return TRUE;
+ return true;
}
/* Finish writing out a block. */
-static bfd_boolean
+static bool
pr_end_block (void *p, bfd_vma addr)
{
struct pr_handle *info = (struct pr_handle *) p;
info->indent -= 2;
indent (info);
- print_vma (addr, ab, TRUE, TRUE);
+ print_vma (addr, ab, true, true);
fprintf (info->f, "} /* %s */\n", ab);
- return TRUE;
+ return true;
}
/* Finish writing out a function. */
-static bfd_boolean
+static bool
pr_end_function (void *p ATTRIBUTE_UNUSED)
{
- return TRUE;
+ return true;
}
\f
/* Tags style generation functions start here. */
static const char *filename;
static const char *functionname;
static unsigned int line;
-static bfd_boolean found;
+static bool found;
/* Look for an address in a section. This is called via
bfd_map_over_sections. */
translate_addresses (bfd *abfd, char *addr_hex, FILE *f, asymbol **syms)
{
pc = bfd_scan_vma (addr_hex, NULL, 16);
- found = FALSE;
+ found = false;
bfd_map_over_sections (abfd, find_address_in_section, syms);
if (! found)
/* Start a new compilation unit. */
-static bfd_boolean
+static bool
tg_start_compilation_unit (void * p, const char *fname ATTRIBUTE_UNUSED)
{
struct pr_handle *info = (struct pr_handle *) p;
/* Should it be relative? best way to do it here?. */
info->filename = strdup (fname);
- return TRUE;
+ return true;
}
/* Start a source file within a compilation unit. */
-static bfd_boolean
+static bool
tg_start_source (void *p, const char *fname)
{
struct pr_handle *info = (struct pr_handle *) p;
/* Should it be relative? best way to do it here?. */
info->filename = strdup (fname);
- return TRUE;
+ return true;
}
/* Push an enum type onto the type stack. */
-static bfd_boolean
+static bool
tg_enum_type (void *p, const char *tag, const char **names,
bfd_signed_vma *values)
{
char ab[22];
if (! pr_enum_type (p, tag, names, values))
- return FALSE;
+ return false;
name = tag ? tag : "unknown";
/* Generate an entry for the enum. */
{
for (i = 0; names[i] != NULL; i++)
{
- print_vma (values[i], ab, FALSE, FALSE);
+ print_vma (values[i], ab, false, false);
fprintf (info->f, "%s\t%s\t0;\"\tkind:g\tenum:%s\tvalue:%s\n",
names[i], info->filename, name, ab);
}
}
- return TRUE;
+ return true;
}
/* Start accumulating a struct type. */
-static bfd_boolean
+static bool
tg_start_struct_type (void *p, const char *tag, unsigned int id,
- bfd_boolean structp,
+ bool structp,
unsigned int size ATTRIBUTE_UNUSED)
{
struct pr_handle *info = (struct pr_handle *) p;
}
if (! push_type (info, name))
- return FALSE;
+ return false;
info->stack->flavor = structp ? "struct" : "union";
/* Output the visibility of a field in a struct. */
-static bfd_boolean
+static bool
tg_fix_visibility (struct pr_handle *info, enum debug_visibility visibility)
{
assert (info->stack != NULL);
if (info->stack->visibility == visibility)
- return TRUE;
+ return true;
assert (info->stack->visibility != DEBUG_VISIBILITY_IGNORE);
info->stack->visibility = visibility;
- return TRUE;
+ return true;
}
/* Add a field to a struct type. */
-static bfd_boolean
+static bool
tg_struct_field (void *p, const char *name, bfd_vma bitpos ATTRIBUTE_UNUSED,
bfd_vma bitsize ATTRIBUTE_UNUSED,
enum debug_visibility visibility)
t = pop_type (info);
if (t == NULL)
- return FALSE;
+ return false;
if (! tg_fix_visibility (info, visibility))
- return FALSE;
+ return false;
/* It happens, a bug? */
if (! name[0])
- return TRUE;
+ return true;
fprintf (info->f, "%s\t%s\t0;\"\tkind:m\ttype:%s\t%s:%s\taccess:%s\n",
name, info->filename, t, info->stack->flavor, info->stack->type,
visibility_name (visibility));
- return TRUE;
+ return true;
}
/* Finish a struct type. */
-static bfd_boolean
+static bool
tg_end_struct_type (void *p ATTRIBUTE_UNUSED)
{
assert (((struct pr_handle *) p)->stack != NULL);
- return TRUE;
+ return true;
}
/* Start a class type. */
-static bfd_boolean
+static bool
tg_start_class_type (void *p, const char *tag, unsigned int id,
- bfd_boolean structp, unsigned int size,
- bfd_boolean vptr, bfd_boolean ownvptr)
+ bool structp, unsigned int size,
+ bool vptr, bool ownvptr)
{
struct pr_handle *info = (struct pr_handle *) p;
char *tv = NULL;
{
tv = pop_type (info);
if (tv == NULL)
- return FALSE;
+ return false;
}
if (tag != NULL)
}
if (! push_type (info, name))
- return FALSE;
+ return false;
info->stack->flavor = structp ? "class" : "union class";
info->stack->parents = NULL;
if (vptr)
{
if (! append_type (info, " vtable "))
- return FALSE;
+ return false;
if (ownvptr)
{
if (! append_type (info, "self "))
- return FALSE;
+ return false;
}
else
{
if (! append_type (info, tv)
|| ! append_type (info, " "))
- return FALSE;
+ return false;
}
}
}
info->stack->visibility = DEBUG_VISIBILITY_PRIVATE;
- return TRUE;
+ return true;
}
/* Add a static member to a class. */
-static bfd_boolean
+static bool
tg_class_static_member (void *p, const char *name,
const char *physname ATTRIBUTE_UNUSED,
enum debug_visibility visibility)
len_class = strlen (info->stack->next->type);
full_name = (char *) xmalloc (len_var + len_class + 3);
if (! full_name)
- return FALSE;
+ return false;
sprintf (full_name, "%s::%s", info->stack->next->type, name);
if (! substitute_type (info, full_name))
{
free (full_name);
- return FALSE;
+ return false;
}
if (! prepend_type (info, "static "))
{
free (full_name);
- return FALSE;
+ return false;
}
t = pop_type (info);
if (t == NULL)
{
free (full_name);
- return FALSE;
+ return false;
}
if (! tg_fix_visibility (info, visibility))
{
free (t);
free (full_name);
- return FALSE;
+ return false;
}
fprintf (info->f, "%s\t%s\t0;\"\tkind:x\ttype:%s\tclass:%s\taccess:%s\n",
free (t);
free (full_name);
- return TRUE;
+ return true;
}
/* Add a base class to a class. */
-static bfd_boolean
+static bool
tg_class_baseclass (void *p, bfd_vma bitpos ATTRIBUTE_UNUSED,
- bfd_boolean is_virtual, enum debug_visibility visibility)
+ bool is_virtual, enum debug_visibility visibility)
{
struct pr_handle *info = (struct pr_handle *) p;
char *t;
t = pop_type (info);
if (t == NULL)
- return FALSE;
+ return false;
if (startswith (t, "class "))
t += sizeof "class " - 1;
/* Push it back on to take advantage of the prepend_type and
append_type routines. */
if (! push_type (info, t))
- return FALSE;
+ return false;
if (is_virtual)
{
if (! prepend_type (info, "virtual "))
- return FALSE;
+ return false;
}
switch (visibility)
}
if (! prepend_type (info, prefix))
- return FALSE;
+ return false;
t = pop_type (info);
if (t == NULL)
- return FALSE;
+ return false;
if (info->stack->num_parents && ! append_parent (info, ", "))
- return FALSE;
+ return false;
if (! append_parent (info, t))
- return FALSE;
+ return false;
info->stack->num_parents++;
free (t);
- return TRUE;
+ return true;
}
/* Add a variant to a method. */
-static bfd_boolean
+static bool
tg_class_method_variant (void *p, const char *physname ATTRIBUTE_UNUSED,
enum debug_visibility visibility,
- bfd_boolean constp, bfd_boolean volatilep,
+ bool constp, bool volatilep,
bfd_vma voffset ATTRIBUTE_UNUSED,
- bfd_boolean context)
+ bool context)
{
struct pr_handle *info = (struct pr_handle *) p;
char *method_type;
if (volatilep)
{
if (! append_type (info, " volatile"))
- return FALSE;
+ return false;
}
if (constp)
{
if (! append_type (info, " const"))
- return FALSE;
+ return false;
}
method_name = strdup (context ? info->stack->next->next->method
if (! substitute_type (info, method_name))
{
free (method_name);
- return FALSE;
+ return false;
}
/* Get the type. */
if (method_type == NULL)
{
free (method_name);
- return FALSE;
+ return false;
}
/* Pull off the context type if there is one. */
{
free (method_type);
free (method_name);
- return FALSE;
+ return false;
}
}
free (method_type);
free (method_name);
free (context_type);
- return FALSE;
+ return false;
}
fprintf (info->f, "%s\t%s\t0;\"\tkind:p\ttype:%s\tclass:%s\n",
free (method_name);
free (context_type);
- return TRUE;
+ return true;
}
/* Add a static variant to a method. */
-static bfd_boolean
+static bool
tg_class_static_method_variant (void *p,
const char *physname ATTRIBUTE_UNUSED,
enum debug_visibility visibility,
- bfd_boolean constp, bfd_boolean volatilep)
+ bool constp, bool volatilep)
{
struct pr_handle *info = (struct pr_handle *) p;
char *method_type;
if (volatilep)
{
if (! append_type (info, " volatile"))
- return FALSE;
+ return false;
}
if (constp)
{
if (! append_type (info, " const"))
- return FALSE;
+ return false;
}
/* Mark it as static. */
if (! prepend_type (info, "static "))
- return FALSE;
+ return false;
method_name = strdup (info->stack->next->method);
/* Stick the name of the method into its type. */
if (! substitute_type (info, info->stack->next->method))
{
free (method_name);
- return FALSE;
+ return false;
}
/* Get the type. */
if (method_type == NULL)
{
free (method_name);
- return FALSE;
+ return false;
}
/* Now the top of the stack is the class. */
{
free (method_type);
free (method_name);
- return FALSE;
+ return false;
}
fprintf (info->f, "%s\t%s\t0;\"\tkind:p\ttype:%s\tclass:%s\taccess:%s\n",
free (method_type);
free (method_name);
- return TRUE;
+ return true;
}
/* Finish up a class. */
-static bfd_boolean
+static bool
tg_end_class_type (void *p)
{
struct pr_handle *info = (struct pr_handle *) p;
/* Push a type on the stack using a tag name. */
-static bfd_boolean
+static bool
tg_tag_type (void *p, const char *name, unsigned int id,
enum debug_type_kind kind)
{
break;
default:
abort ();
- return FALSE;
+ return false;
}
if (! push_type (info, t))
- return FALSE;
+ return false;
if (name != NULL)
tag = name;
else
}
if (! append_type (info, tag))
- return FALSE;
+ return false;
- return TRUE;
+ return true;
}
/* Output a typedef. */
-static bfd_boolean
+static bool
tg_typdef (void *p, const char *name)
{
struct pr_handle *info = (struct pr_handle *) p;
s = pop_type (info);
if (s == NULL)
- return FALSE;
+ return false;
fprintf (info->f, "%s\t%s\t0;\"\tkind:t\ttype:%s\n", name,
info->filename, s);
free (s);
- return TRUE;
+ return true;
}
/* Output a tag. The tag should already be in the string on the
stack, so all we have to do here is print it out. */
-static bfd_boolean
+static bool
tg_tag (void *p ATTRIBUTE_UNUSED, const char *name ATTRIBUTE_UNUSED)
{
struct pr_handle *info = (struct pr_handle *) p;
t = pop_type (info);
if (t == NULL)
- return FALSE;
+ return false;
free (t);
- return TRUE;
+ return true;
}
/* Output an integer constant. */
-static bfd_boolean
+static bool
tg_int_constant (void *p, const char *name, bfd_vma val)
{
struct pr_handle *info = (struct pr_handle *) p;
char ab[22];
indent (info);
- print_vma (val, ab, FALSE, FALSE);
+ print_vma (val, ab, false, false);
fprintf (info->f, "%s\t%s\t0;\"\tkind:v\ttype:const int\tvalue:%s\n",
name, info->filename, ab);
- return TRUE;
+ return true;
}
/* Output a floating point constant. */
-static bfd_boolean
+static bool
tg_float_constant (void *p, const char *name, double val)
{
struct pr_handle *info = (struct pr_handle *) p;
indent (info);
fprintf (info->f, "%s\t%s\t0;\"\tkind:v\ttype:const double\tvalue:%g\n",
name, info->filename, val);
- return TRUE;
+ return true;
}
/* Output a typed constant. */
-static bfd_boolean
+static bool
tg_typed_constant (void *p, const char *name, bfd_vma val)
{
struct pr_handle *info = (struct pr_handle *) p;
t = pop_type (info);
if (t == NULL)
- return FALSE;
+ return false;
indent (info);
- print_vma (val, ab, FALSE, FALSE);
+ print_vma (val, ab, false, false);
fprintf (info->f, "%s\t%s\t0;\"\tkind:v\ttype:const %s\tvalue:%s\n",
name, info->filename, t, ab);
free (t);
- return TRUE;
+ return true;
}
/* Output a variable. */
-static bfd_boolean
+static bool
tg_variable (void *p, const char *name, enum debug_var_kind kind,
bfd_vma val ATTRIBUTE_UNUSED)
{
t = pop_type (info);
if (t == NULL)
- return FALSE;
+ return false;
dname = NULL;
if (info->demangler)
free (t);
- return TRUE;
+ return true;
}
/* Start outputting a function. */
-static bfd_boolean
-tg_start_function (void *p, const char *name, bfd_boolean global)
+static bool
+tg_start_function (void *p, const char *name, bool global)
{
struct pr_handle *info = (struct pr_handle *) p;
char *dname;
dname = info->demangler (info->abfd, name, demangle_flags);
if (! substitute_type (info, dname ? dname : name))
- return FALSE;
+ return false;
info->stack->method = NULL;
if (dname != NULL)
info->stack->parents = strdup (name);
if (! info->stack->method && ! append_type (info, "("))
- return FALSE;
+ return false;
info->parameter = 1;
- return TRUE;
+ return true;
}
/* Output a function parameter. */
-static bfd_boolean
+static bool
tg_function_parameter (void *p, const char *name, enum debug_parm_kind kind,
bfd_vma val ATTRIBUTE_UNUSED)
{
|| kind == DEBUG_PARM_REF_REG)
{
if (! pr_reference_type (p))
- return FALSE;
+ return false;
}
if (! substitute_type (info, name))
- return FALSE;
+ return false;
t = pop_type (info);
if (t == NULL)
- return FALSE;
+ return false;
if (! info->stack->method)
{
if (info->parameter != 1 && ! append_type (info, ", "))
- return FALSE;
+ return false;
if (kind == DEBUG_PARM_REG || kind == DEBUG_PARM_REF_REG)
if (! append_type (info, "register "))
- return FALSE;
+ return false;
if (! append_type (info, t))
- return FALSE;
+ return false;
}
free (t);
++info->parameter;
- return TRUE;
+ return true;
}
/* Start writing out a block. */
-static bfd_boolean
+static bool
tg_start_block (void *p, bfd_vma addr)
{
struct pr_handle *info = (struct pr_handle *) p;
char ab[22], kind, *partof;
char *t;
- bfd_boolean local;
+ bool local;
if (info->parameter > 0)
{
fprintf (info->f, "%s\t%s\t", info->stack->parents, info->filename);
free (info->stack->parents);
- print_vma (addr, ab, TRUE, TRUE);
+ print_vma (addr, ab, true, true);
translate_addresses (info->abfd, ab, info->f, info->syms);
local = info->stack->flavor != NULL;
if (info->stack->method && *info->stack->method)
kind = 'f';
partof = NULL;
if (! info->stack->method && ! append_type (info, ")"))
- return FALSE;
+ return false;
}
t = pop_type (info);
if (t == NULL)
- return FALSE;
+ return false;
fprintf (info->f, ";\"\tkind:%c\ttype:%s", kind, t);
if (local)
fputs ("\tfile:", info->f);
fputc ('\n', info->f);
}
- return TRUE;
+ return true;
}
/* Write out line number information. */
-static bfd_boolean
+static bool
tg_lineno (void *p ATTRIBUTE_UNUSED, const char *fname ATTRIBUTE_UNUSED,
unsigned long lineno ATTRIBUTE_UNUSED,
bfd_vma addr ATTRIBUTE_UNUSED)
{
- return TRUE;
+ return true;
}
/* Finish writing out a block. */
-static bfd_boolean
+static bool
tg_end_block (void *p ATTRIBUTE_UNUSED, bfd_vma addr ATTRIBUTE_UNUSED)
{
- return TRUE;
+ return true;
}
/* Convert the visibility value into a human readable name. */
break;
default:
abort ();
- return FALSE;
+ return false;
}
return s;
}
static debug_type *coff_get_slot (struct coff_types *, long);
static debug_type parse_coff_type
(bfd *, struct coff_symbols *, struct coff_types *, long, int,
- union internal_auxent *, bfd_boolean, void *);
+ union internal_auxent *, bool, void *);
static debug_type parse_coff_base_type
(bfd *, struct coff_symbols *, struct coff_types *, long, int,
union internal_auxent *, void *);
static debug_type parse_coff_enum_type
(bfd *, struct coff_symbols *, struct coff_types *,
union internal_auxent *, void *);
-static bfd_boolean parse_coff_symbol
+static bool parse_coff_symbol
(bfd *, struct coff_types *, asymbol *, long, struct internal_syment *,
- void *, debug_type, bfd_boolean);
-static bfd_boolean external_coff_symbol_p (int sym_class);
+ void *, debug_type, bool);
+static bool external_coff_symbol_p (int sym_class);
\f
/* Return the slot for a type. */
static debug_type
parse_coff_type (bfd *abfd, struct coff_symbols *symbols,
struct coff_types *types, long coff_symno, int ntype,
- union internal_auxent *pauxent, bfd_boolean useaux,
+ union internal_auxent *pauxent, bool useaux,
void *dhandle)
{
debug_type type;
type = parse_coff_type (abfd, symbols, types, coff_symno, newtype,
pauxent, useaux, dhandle);
type = debug_make_function_type (dhandle, type, (debug_type *) NULL,
- FALSE);
+ false);
}
else if (ISARY (ntype))
{
}
type = parse_coff_type (abfd, symbols, types, coff_symno, newtype,
- pauxent, FALSE, dhandle);
+ pauxent, false, dhandle);
type = debug_make_array_type (dhandle, type,
parse_coff_base_type (abfd, symbols,
types,
coff_symno,
T_INT,
NULL, dhandle),
- 0, n - 1, FALSE);
+ 0, n - 1, false);
}
else
{
union internal_auxent *pauxent, void *dhandle)
{
debug_type ret;
- bfd_boolean set_basic;
+ bool set_basic;
const char *name;
debug_type *slot;
&& types->basic[ntype] != DEBUG_TYPE_NULL)
return types->basic[ntype];
- set_basic = TRUE;
+ set_basic = true;
name = NULL;
switch (ntype)
break;
case T_CHAR:
- ret = debug_make_int_type (dhandle, 1, FALSE);
+ ret = debug_make_int_type (dhandle, 1, false);
name = "char";
break;
case T_SHORT:
- ret = debug_make_int_type (dhandle, 2, FALSE);
+ ret = debug_make_int_type (dhandle, 2, false);
name = "short";
break;
case T_INT:
/* FIXME: Perhaps the size should depend upon the architecture. */
- ret = debug_make_int_type (dhandle, 4, FALSE);
+ ret = debug_make_int_type (dhandle, 4, false);
name = "int";
break;
case T_LONG:
- ret = debug_make_int_type (dhandle, 4, FALSE);
+ ret = debug_make_int_type (dhandle, 4, false);
name = "long";
break;
break;
case T_UCHAR:
- ret = debug_make_int_type (dhandle, 1, TRUE);
+ ret = debug_make_int_type (dhandle, 1, true);
name = "unsigned char";
break;
case T_USHORT:
- ret = debug_make_int_type (dhandle, 2, TRUE);
+ ret = debug_make_int_type (dhandle, 2, true);
name = "unsigned short";
break;
case T_UINT:
- ret = debug_make_int_type (dhandle, 4, TRUE);
+ ret = debug_make_int_type (dhandle, 4, true);
name = "unsigned int";
break;
case T_ULONG:
- ret = debug_make_int_type (dhandle, 4, TRUE);
+ ret = debug_make_int_type (dhandle, 4, true);
name = "unsigned long";
break;
case T_STRUCT:
if (pauxent == NULL)
- ret = debug_make_struct_type (dhandle, TRUE, 0,
+ ret = debug_make_struct_type (dhandle, true, 0,
(debug_field *) NULL);
else
ret = parse_coff_struct_type (abfd, symbols, types, ntype, pauxent,
slot = coff_get_slot (types, coff_symno);
*slot = ret;
- set_basic = FALSE;
+ set_basic = false;
break;
case T_UNION:
if (pauxent == NULL)
- ret = debug_make_struct_type (dhandle, FALSE, 0, (debug_field *) NULL);
+ ret = debug_make_struct_type (dhandle, false, 0, (debug_field *) NULL);
else
ret = parse_coff_struct_type (abfd, symbols, types, ntype, pauxent,
dhandle);
slot = coff_get_slot (types, coff_symno);
*slot = ret;
- set_basic = FALSE;
+ set_basic = false;
break;
case T_ENUM:
slot = coff_get_slot (types, coff_symno);
*slot = ret;
- set_basic = FALSE;
+ set_basic = false;
break;
}
int alloc;
debug_field *fields;
int count;
- bfd_boolean done;
+ bool done;
symend = pauxent->x_sym.x_fcnary.x_fcn.x_endndx.l;
fields = (debug_field *) xmalloc (alloc * sizeof *fields);
count = 0;
- done = FALSE;
+ done = false;
while (! done
&& symbols->coff_symno < symend
&& symbols->symno < symbols->symcount)
break;
case C_EOS:
- done = TRUE;
+ done = true;
break;
}
debug_field f;
ftype = parse_coff_type (abfd, symbols, types, this_coff_symno,
- syment.n_type, psubaux, TRUE, dhandle);
+ syment.n_type, psubaux, true, dhandle);
f = debug_make_field (dhandle, bfd_asymbol_name (sym), ftype,
bitpos, bitsize, DEBUG_VISIBILITY_PUBLIC);
if (f == DEBUG_FIELD_NULL)
const char **names;
bfd_signed_vma *vals;
int count;
- bfd_boolean done;
+ bool done;
symend = pauxent->x_sym.x_fcnary.x_fcn.x_endndx.l;
vals = (bfd_signed_vma *) xmalloc (alloc * sizeof *vals);
count = 0;
- done = FALSE;
+ done = false;
while (! done
&& symbols->coff_symno < symend
&& symbols->symno < symbols->symcount)
break;
case C_EOS:
- done = TRUE;
+ done = true;
break;
}
}
/* Handle a single COFF symbol. */
-static bfd_boolean
+static bool
parse_coff_symbol (bfd *abfd ATTRIBUTE_UNUSED, struct coff_types *types,
asymbol *sym, long coff_symno,
struct internal_syment *psyment, void *dhandle,
- debug_type type, bfd_boolean within_function)
+ debug_type type, bool within_function)
{
switch (psyment->n_sclass)
{
case C_AUTO:
if (! debug_record_variable (dhandle, bfd_asymbol_name (sym), type,
DEBUG_LOCAL, bfd_asymbol_value (sym)))
- return FALSE;
+ return false;
break;
case C_WEAKEXT:
case C_EXT:
if (! debug_record_variable (dhandle, bfd_asymbol_name (sym), type,
DEBUG_GLOBAL, bfd_asymbol_value (sym)))
- return FALSE;
+ return false;
break;
case C_STAT:
? DEBUG_LOCAL_STATIC
: DEBUG_STATIC),
bfd_asymbol_value (sym)))
- return FALSE;
+ return false;
break;
case C_REG:
/* FIXME: We may need to convert the register number. */
if (! debug_record_variable (dhandle, bfd_asymbol_name (sym), type,
DEBUG_REGISTER, bfd_asymbol_value (sym)))
- return FALSE;
+ return false;
break;
case C_LABEL:
case C_ARG:
if (! debug_record_parameter (dhandle, bfd_asymbol_name (sym), type,
DEBUG_PARM_STACK, bfd_asymbol_value (sym)))
- return FALSE;
+ return false;
break;
case C_REGPARM:
/* FIXME: We may need to convert the register number. */
if (! debug_record_parameter (dhandle, bfd_asymbol_name (sym), type,
DEBUG_PARM_REG, bfd_asymbol_value (sym)))
- return FALSE;
+ return false;
break;
case C_TPDEF:
type = debug_name_type (dhandle, bfd_asymbol_name (sym), type);
if (type == DEBUG_TYPE_NULL)
- return FALSE;
+ return false;
break;
case C_STRTAG:
type = debug_tag_type (dhandle, bfd_asymbol_name (sym), type);
if (type == DEBUG_TYPE_NULL)
- return FALSE;
+ return false;
/* Store the named type into the slot, so that references get
the name. */
break;
}
- return TRUE;
+ return true;
}
/* Determine if a symbol has external visibility. */
-static bfd_boolean
+static bool
external_coff_symbol_p (int sym_class)
{
switch (sym_class)
{
case C_EXT:
case C_WEAKEXT:
- return TRUE;
+ return true;
default:
break;
}
- return FALSE;
+ return false;
}
/* This is the main routine. It looks through all the symbols and
handles them. */
-bfd_boolean
+bool
parse_coff (bfd *abfd, asymbol **syms, long symcount, void *dhandle)
{
struct coff_symbols symbols;
int fntype;
bfd_vma fnend;
alent *linenos;
- bfd_boolean within_function;
+ bool within_function;
long this_coff_symno;
symbols.syms = syms;
fntype = 0;
fnend = 0;
linenos = NULL;
- within_function = FALSE;
+ within_function = false;
while (symbols.symno < symcount)
{
{
non_fatal (_("bfd_coff_get_syment failed: %s"),
bfd_errmsg (bfd_get_error ()));
- return FALSE;
+ return false;
}
name = bfd_asymbol_name (sym);
{
non_fatal (_("bfd_coff_get_auxent failed: %s"),
bfd_errmsg (bfd_get_error ()));
- return FALSE;
+ return false;
}
paux = &auxent;
}
/* The last C_FILE symbol points to the first external
symbol. */
if (! debug_set_filename (dhandle, "*globals*"))
- return FALSE;
+ return false;
}
switch (syment.n_sclass)
case C_FILE:
next_c_file = syment.n_value;
if (! debug_set_filename (dhandle, name))
- return FALSE;
+ return false;
break;
case C_STAT:
break;
}
type = parse_coff_type (abfd, &symbols, &types, this_coff_symno,
- syment.n_type, paux, TRUE, dhandle);
+ syment.n_type, paux, true, dhandle);
if (type == DEBUG_TYPE_NULL)
- return FALSE;
+ return false;
if (! parse_coff_symbol (abfd, &types, sym, this_coff_symno, &syment,
dhandle, type, within_function))
- return FALSE;
+ return false;
break;
case C_FCN:
{
non_fatal (_("%ld: .bf without preceding function"),
this_coff_symno);
- return FALSE;
+ return false;
}
type = parse_coff_type (abfd, &symbols, &types, this_coff_symno,
- DECREF (fntype), paux, FALSE, dhandle);
+ DECREF (fntype), paux, false, dhandle);
if (type == DEBUG_TYPE_NULL)
- return FALSE;
+ return false;
if (! debug_record_function (dhandle, fnname, type,
external_coff_symbol_p (fnclass),
bfd_asymbol_value (sym)))
- return FALSE;
+ return false;
if (linenos != NULL)
{
if (! debug_record_line (dhandle,
linenos->line_number + base,
linenos->u.offset + addr))
- return FALSE;
+ return false;
++linenos;
}
}
fnclass = 0;
fntype = 0;
- within_function = TRUE;
+ within_function = true;
}
else if (strcmp (name, ".ef") == 0)
{
if (! within_function)
{
non_fatal (_("%ld: unexpected .ef\n"), this_coff_symno);
- return FALSE;
+ return false;
}
if (bfd_asymbol_value (sym) > fnend)
fnend = bfd_asymbol_value (sym);
if (! debug_end_function (dhandle, fnend))
- return FALSE;
+ return false;
fnend = 0;
- within_function = FALSE;
+ within_function = false;
}
break;
if (strcmp (name, ".bb") == 0)
{
if (! debug_start_block (dhandle, bfd_asymbol_value (sym)))
- return FALSE;
+ return false;
}
else if (strcmp (name, ".eb") == 0)
{
if (! debug_end_block (dhandle, bfd_asymbol_value (sym)))
- return FALSE;
+ return false;
}
break;
default:
type = parse_coff_type (abfd, &symbols, &types, this_coff_symno,
- syment.n_type, paux, TRUE, dhandle);
+ syment.n_type, paux, true, dhandle);
if (type == DEBUG_TYPE_NULL)
- return FALSE;
+ return false;
if (! parse_coff_symbol (abfd, &types, sym, this_coff_symno, &syment,
dhandle, type, within_function))
- return FALSE;
+ return false;
break;
}
}
- return TRUE;
+ return true;
}
#include "debug.h"
#include "budbg.h"
-static bfd_boolean read_section_stabs_debugging_info
- (bfd *, asymbol **, long, void *, bfd_boolean *);
-static bfd_boolean read_symbol_stabs_debugging_info
- (bfd *, asymbol **, long, void *, bfd_boolean *);
+static bool read_section_stabs_debugging_info
+ (bfd *, asymbol **, long, void *, bool *);
+static bool read_symbol_stabs_debugging_info
+ (bfd *, asymbol **, long, void *, bool *);
static void save_stab (int, int, bfd_vma, const char *);
static void stab_context (void);
static void free_saved_stabs (void);
void *
read_debugging_info (bfd *abfd, asymbol **syms, long symcount,
- bfd_boolean no_messages)
+ bool no_messages)
{
void *dhandle;
- bfd_boolean found;
+ bool found;
dhandle = debug_init ();
if (dhandle == NULL)
{
if (! parse_coff (abfd, syms, symcount, dhandle))
goto err_exit;
- found = TRUE;
+ found = true;
}
if (! found)
/* Read stabs in sections debugging information from a BFD. */
-static bfd_boolean
+static bool
read_section_stabs_debugging_info (bfd *abfd, asymbol **syms, long symcount,
- void *dhandle, bfd_boolean *pfound)
+ void *dhandle, bool *pfound)
{
static struct
{
unsigned int i;
void *shandle;
- *pfound = FALSE;
+ *pfound = false;
shandle = NULL;
for (i = 0; i < sizeof names / sizeof names[0]; i++)
bfd_errmsg (bfd_get_error ()));
free (shandle);
free (stabs);
- return FALSE;
+ return false;
}
strsize = bfd_section_size (strsec);
free (shandle);
free (strings);
free (stabs);
- return FALSE;
+ return false;
}
/* Zero terminate the strings table, just in case. */
strings [strsize] = 0;
if (shandle == NULL)
{
- shandle = start_stab (dhandle, abfd, TRUE, syms, symcount);
+ shandle = start_stab (dhandle, abfd, true, syms, symcount);
if (shandle == NULL)
{
free (strings);
free (stabs);
- return FALSE;
+ return false;
}
}
- *pfound = TRUE;
+ *pfound = true;
stroff = 0;
next_stroff = 0;
free (shandle);
free (stabs);
free (strings);
- return FALSE;
+ return false;
}
/* Don't free f, since I think the stabs code
if (shandle != NULL)
{
if (! finish_stab (dhandle, shandle))
- return FALSE;
+ return false;
}
- return TRUE;
+ return true;
}
/* Read stabs in the symbol table. */
-static bfd_boolean
+static bool
read_symbol_stabs_debugging_info (bfd *abfd, asymbol **syms, long symcount,
- void *dhandle, bfd_boolean *pfound)
+ void *dhandle, bool *pfound)
{
void *shandle;
asymbol **ps, **symend;
if (shandle == NULL)
{
- shandle = start_stab (dhandle, abfd, FALSE, syms, symcount);
+ shandle = start_stab (dhandle, abfd, false, syms, symcount);
if (shandle == NULL)
- return FALSE;
+ return false;
}
- *pfound = TRUE;
+ *pfound = true;
s = i.name;
if (s == NULL || strlen (s) < 1)
- return FALSE;
+ return false;
f = NULL;
while (strlen (s) > 0
{
stab_context ();
free_saved_stabs ();
- return FALSE;
+ return false;
}
/* Don't free f, since I think the stabs code expects
if (shandle != NULL)
{
if (! finish_stab (dhandle, shandle))
- return FALSE;
+ return false;
}
- return TRUE;
+ return true;
}
\f
/* Record stabs strings, so that we can give some context for errors. */
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 char *dump_ctf_parent_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;
};
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
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
{
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");
}
int section;
char * cp;
- do_dump = TRUE;
+ 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;
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;
{
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)
{
}
}
- 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 *)
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 *)
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 Elf_Internal_Sym *
}
}
-static bfd_boolean
+static bool
process_section_headers (Filedata * filedata)
{
Elf_Internal_Shdr * section;
{
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)
if (is_32bit_elf)
{
- if (! get_32bit_section_headers (filedata, FALSE))
- return FALSE;
+ if (! get_32bit_section_headers (filedata, false))
+ return false;
}
else
{
- if (! get_64bit_section_headers (filedata, FALSE))
- return FALSE;
+ if (! get_64bit_section_headers (filedata, false))
+ return false;
}
/* Read in the string table, so that we have names to display. */
}
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)
*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;
/* 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;
}
}
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)
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++;
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)
{
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;
}
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
process_unwind (Filedata * filedata)
{
struct unwind_handler
{
unsigned int machtype;
- bfd_boolean (* handler)(Filedata *);
+ bool (* handler)(Filedata *);
} handlers[] =
{
{ EM_ARM, arm_process_unwind },
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 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;
+ return false;
}
else
{
if (! get_64bit_dynamic_section (filedata))
- return FALSE;
+ return false;
}
/* Find the appropriate symbol table. */
{
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)
|| 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
}
}
- 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",
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",
if (link_section->sh_link >= filedata->file_header.e_shnum)
break;
- found = TRUE;
+ found = true;
symbols = GET_ELF_SYMBOLS (filedata, link_section, & num_syms);
if (symbols == NULL)
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,
}
printf (" %4s ", get_symbol_index_type (filedata, psym->st_shndx));
- bfd_boolean is_valid = VALID_SYMBOL_NAME (strtab, strtab_size,
- psym->st_name);
+ bool is_valid = VALID_SYMBOL_NAME (strtab, strtab_size, psym->st_name);
const char * sstr = is_valid ? strtab + psym->st_name : _("<corrupt>");
version_string
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)
{
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;
/* 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
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);
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)
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;
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);
goto fail;
}
- ret = TRUE;
+ ret = true;
if (filedata->is_separate)
printf (_("\nDump of CTF section '%s' in linked file %s:\n"),
{
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
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."))
|| (id == line && const_strneq (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 == 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 && !filedata->is_separate)
}
}
-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 (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
}
if (filedata->dump.dump_sects[i])
{
warn (_("Section %d was not dumped because it does not exist!\n"), i);
- res = FALSE;
+ res = false;
}
}
{
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 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:
((version & NT_NETBSD_PAX_NOGUARD) ? "-guard" : ""),
((version & NT_NETBSD_PAX_ASLR) ? "+ASLR" : ""),
((version & NT_NETBSD_PAX_NOASLR) ? "-ASLR" : ""));
- return TRUE;
+ return true;
#endif
}
printf (" NetBSD\t0x%08lx\tUnknown note type: (0x%08lx)\n",
pnote->descsz, pnote->type);
- return FALSE;
+ return false;
}
static const char *
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)
{
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);
/* 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);
+ get_32bit_section_headers (filedata, true);
else
- get_64bit_section_headers (filedata, TRUE);
+ get_64bit_section_headers (filedata, true);
}
- return TRUE;
+ return true;
}
static void
}
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 (filedata->file_header.e_shoff)
{
- bfd_boolean res;
+ bool res;
/* Read the section headers again, this time for real. */
if (is_32bit_elf)
- res = get_32bit_section_headers (filedata, FALSE);
+ res = get_32bit_section_headers (filedata, false);
else
- res = get_64bit_section_headers (filedata, FALSE);
+ res = get_64bit_section_headers (filedata, false);
if (!res)
goto fail;
void *
open_debug_file (const char * pathname)
{
- return open_file (pathname, TRUE);
+ return open_file (pathname, true);
}
static void
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. */
initialise_dump_sects (filedata);
if (! process_file_header (filedata))
- return FALSE;
+ return false;
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)
{
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;
+ res = false;
free (filedata->program_headers);
filedata->program_headers = NULL;
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);
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);
int
smart_rename (const char *from, const char *to, int fromfd,
- struct stat *target_stat, bfd_boolean preserve_dates)
+ struct stat *target_stat, bool preserve_dates)
{
int ret;
/* The BFD. */
bfd *abfd;
/* TRUE if this is stabs in sections. */
- bfd_boolean sections;
+ bool sections;
/* The symbol table. */
asymbol **syms;
/* The number of symbols. */
int gcc_compiled;
/* Whether an N_OPT symbol was seen that was not generated by gcc,
so that we can detect the SunPRO compiler. */
- bfd_boolean n_opt_found;
+ bool n_opt_found;
/* The main file name. */
char *main_filename;
/* A stack of unfinished N_BINCL files. */
/* A list of finished N_BINCL files. */
struct bincl_file *bincl_list;
/* Whether we are inside a function or not. */
- bfd_boolean within_function;
+ bool within_function;
/* The address of the end of the function, used if we have seen an
N_FUN symbol while in a function. This is -1 if we have not seen
an N_FUN (the normal case). */
struct stab_tag *tags;
/* Set by parse_stab_type if it sees a structure defined as a cross
reference to itself. Reset by parse_stab_type otherwise. */
- bfd_boolean self_crossref;
+ bool self_crossref;
};
/* A list of these structures is used to hold pending variable
static void bad_stab (const char *);
static void warn_stab (const char *, const char *);
-static bfd_boolean parse_stab_string
+static bool parse_stab_string
(void *, struct stab_handle *, int, int, bfd_vma,
const char *, const char *);
static debug_type parse_stab_type
(void *, struct stab_handle *, const char *, const char **,
debug_type **, const char *);
-static bfd_boolean parse_stab_type_number
+static bool parse_stab_type_number
(const char **, int *, const char *);
static debug_type parse_stab_range_type
(void *, struct stab_handle *, const char *, const char **,
(void *, const char **, const char *);
static debug_type parse_stab_struct_type
(void *, struct stab_handle *, const char *, const char **,
- bfd_boolean, const int *, const char *);
-static bfd_boolean parse_stab_baseclasses
+ bool, const int *, const char *);
+static bool parse_stab_baseclasses
(void *, struct stab_handle *, const char **, debug_baseclass **,
const char *);
-static bfd_boolean parse_stab_struct_fields
+static bool parse_stab_struct_fields
(void *, struct stab_handle *, const char **, debug_field **,
- bfd_boolean *, const char *);
-static bfd_boolean parse_stab_cpp_abbrev
+ bool *, const char *);
+static bool parse_stab_cpp_abbrev
(void *, struct stab_handle *, const char **, debug_field *, const char *);
-static bfd_boolean parse_stab_one_struct_field
+static bool parse_stab_one_struct_field
(void *, struct stab_handle *, const char **, const char *,
- debug_field *, bfd_boolean *, const char *);
-static bfd_boolean parse_stab_members
+ debug_field *, bool *, const char *);
+static bool parse_stab_members
(void *, struct stab_handle *, const char *, const char **, const int *,
debug_method **, const char *);
static debug_type parse_stab_argtypes
(void *, struct stab_handle *, debug_type, const char *, const char *,
- debug_type, const char *, bfd_boolean, bfd_boolean, const char **);
-static bfd_boolean parse_stab_tilde_field
+ debug_type, const char *, bool, bool, const char **);
+static bool parse_stab_tilde_field
(void *, struct stab_handle *, const char **, const int *, debug_type *,
- bfd_boolean *, const char *);
+ bool *, const char *);
static debug_type parse_stab_array_type
- (void *, struct stab_handle *, const char **, bfd_boolean, const char *);
+ (void *, struct stab_handle *, const char **, bool, const char *);
static void push_bincl (struct stab_handle *, const char *, bfd_vma);
static const char *pop_bincl (struct stab_handle *);
-static bfd_boolean find_excl (struct stab_handle *, const char *, bfd_vma);
-static bfd_boolean stab_record_variable
+static bool find_excl (struct stab_handle *, const char *, bfd_vma);
+static bool stab_record_variable
(void *, struct stab_handle *, const char *, debug_type,
enum debug_var_kind, bfd_vma);
-static bfd_boolean stab_emit_pending_vars (void *, struct stab_handle *);
+static bool stab_emit_pending_vars (void *, struct stab_handle *);
static debug_type *stab_find_slot (struct stab_handle *, const int *);
static debug_type stab_find_type (void *, struct stab_handle *, const int *);
-static bfd_boolean stab_record_type
+static bool stab_record_type
(void *, struct stab_handle *, const int *, debug_type);
static debug_type stab_xcoff_builtin_type
(void *, struct stab_handle *, int);
static debug_type stab_find_tagged_type
(void *, struct stab_handle *, const char *, int, enum debug_type_kind);
static debug_type *stab_demangle_argtypes
- (void *, struct stab_handle *, const char *, bfd_boolean *, unsigned int);
+ (void *, struct stab_handle *, const char *, bool *, unsigned int);
static debug_type *stab_demangle_v3_argtypes
- (void *, struct stab_handle *, const char *, bfd_boolean *);
+ (void *, struct stab_handle *, const char *, bool *);
static debug_type *stab_demangle_v3_arglist
- (void *, struct stab_handle *, struct demangle_component *, bfd_boolean *);
+ (void *, struct stab_handle *, struct demangle_component *, bool *);
static debug_type stab_demangle_v3_arg
(void *, struct stab_handle *, struct demangle_component *, debug_type,
- bfd_boolean *);
+ bool *);
static int demangle_flags = DMGL_ANSI;
/* Read a number from a string. */
static bfd_vma
-parse_number (const char **pp, bfd_boolean *poverflow, const char *p_end)
+parse_number (const char **pp, bool *poverflow, const char *p_end)
{
unsigned long ul;
const char *orig;
if (poverflow != NULL)
- *poverflow = FALSE;
+ *poverflow = false;
orig = *pp;
if (orig >= p_end)
if (sizeof (bfd_vma) > sizeof (unsigned long))
{
const char *p;
- bfd_boolean neg;
+ bool neg;
int base;
bfd_vma over, lastdig;
- bfd_boolean overflow;
+ bool overflow;
bfd_vma v;
/* Our own version of strtoul, for a bfd_vma. */
p = orig;
- neg = FALSE;
+ neg = false;
if (*p == '+')
++p;
else if (*p == '-')
{
- neg = TRUE;
+ neg = true;
++p;
}
over = ((bfd_vma) (bfd_signed_vma) -1) / (bfd_vma) base;
lastdig = ((bfd_vma) (bfd_signed_vma) -1) % (bfd_vma) base;
- overflow = FALSE;
+ overflow = false;
v = 0;
while (1)
{
if (v > over || (v == over && (bfd_vma) d > lastdig))
{
- overflow = TRUE;
+ overflow = true;
break;
}
}
/* If we get here, the number is too large to represent in a
bfd_vma. */
if (poverflow != NULL)
- *poverflow = TRUE;
+ *poverflow = true;
else
warn_stab (orig, _("numeric overflow"));
/* Create a handle to parse stabs symbols with. */
void *
-start_stab (void *dhandle ATTRIBUTE_UNUSED, bfd *abfd, bfd_boolean sections,
+start_stab (void *dhandle ATTRIBUTE_UNUSED, bfd *abfd, bool sections,
asymbol **syms, long symcount)
{
struct stab_handle *ret;
/* When we have processed all the stabs information, we need to go
through and fill in all the undefined tags. */
-bfd_boolean
+bool
finish_stab (void *dhandle, void *handle)
{
struct stab_handle *info = (struct stab_handle *) handle;
{
if (! stab_emit_pending_vars (dhandle, info)
|| ! debug_end_function (dhandle, info->function_end))
- return FALSE;
- info->within_function = FALSE;
+ return false;
+ info->within_function = false;
info->function_end = (bfd_vma) -1;
}
kind = DEBUG_KIND_STRUCT;
st->slot = debug_make_undefined_tagged_type (dhandle, st->name, kind);
if (st->slot == DEBUG_TYPE_NULL)
- return FALSE;
+ return false;
}
- return TRUE;
+ return true;
}
/* Handle a single stabs symbol. */
-bfd_boolean
+bool
parse_stab (void *dhandle, void *handle, int type, int desc, bfd_vma value,
const char *string)
{
&& (type != N_SO || *string == '\0' || value != info->so_value))
{
if (! debug_set_filename (dhandle, info->so_string))
- return FALSE;
+ return false;
info->main_filename = info->so_string;
info->gcc_compiled = 0;
- info->n_opt_found = FALSE;
+ info->n_opt_found = false;
/* Generally, for stabs in the symbol table, the N_LBRAC and
N_RBRAC symbols are relative to the N_SO symbol value. */
if (! info->within_function)
{
fprintf (stderr, _("N_LBRAC not within function\n"));
- return FALSE;
+ return false;
}
/* Start an inner lexical block. */
(value
+ info->file_start_offset
+ info->function_start_offset)))
- return FALSE;
+ return false;
/* Emit any pending variable definitions. */
if (! stab_emit_pending_vars (dhandle, info))
- return FALSE;
+ return false;
++info->block_depth;
break;
if we do, we probably need to emit them before closing the
block. */
if (! stab_emit_pending_vars (dhandle, info))
- return FALSE;
+ return false;
/* End an inner lexical block. */
if (! debug_end_block (dhandle,
(value
+ info->file_start_offset
+ info->function_start_offset)))
- return FALSE;
+ return false;
--info->block_depth;
if (info->block_depth < 0)
{
fprintf (stderr, _("Too many N_RBRACs\n"));
- return FALSE;
+ return false;
}
break;
endval = info->function_end;
if (! stab_emit_pending_vars (dhandle, info)
|| ! debug_end_function (dhandle, endval))
- return FALSE;
- info->within_function = FALSE;
+ return false;
+ info->within_function = false;
info->function_end = (bfd_vma) -1;
}
/* An empty string is emitted by gcc at the end of a compilation
unit. */
if (*string == '\0')
- return TRUE;
+ return true;
/* Just accumulate strings until we see a non N_SO symbol. If
the string starts with a directory separator or some other
case N_SOL:
/* Start an include file. */
if (! debug_start_source (dhandle, string))
- return FALSE;
+ return false;
break;
case N_BINCL:
/* Start an include file which may be replaced. */
push_bincl (info, string, value);
if (! debug_start_source (dhandle, string))
- return FALSE;
+ return false;
break;
case N_EINCL:
/* End an N_BINCL include. */
if (! debug_start_source (dhandle, pop_bincl (info)))
- return FALSE;
+ return false;
break;
case N_EXCL:
/* This is a duplicate of a header file named by N_BINCL which
was eliminated by the linker. */
if (! find_excl (info, string, value))
- return FALSE;
+ return false;
break;
case N_SLINE:
if (! debug_record_line (dhandle, desc,
value + (info->within_function
? info->function_start_offset : 0)))
- return FALSE;
+ return false;
break;
case N_BCOMM:
if (! debug_start_common_block (dhandle, string))
- return FALSE;
+ return false;
break;
case N_ECOMM:
if (! debug_end_common_block (dhandle, string))
- return FALSE;
+ return false;
break;
case N_FUN:
value += info->function_start_offset;
if (! stab_emit_pending_vars (dhandle, info)
|| ! debug_end_function (dhandle, value))
- return FALSE;
- info->within_function = FALSE;
+ return false;
+ info->within_function = false;
info->function_end = (bfd_vma) -1;
}
break;
endval = info->function_end;
if (! stab_emit_pending_vars (dhandle, info)
|| ! debug_end_function (dhandle, endval))
- return FALSE;
+ return false;
info->function_end = (bfd_vma) -1;
}
/* For stabs in sections, line numbers and block addresses
are offsets from the start of the function. */
if (info->sections)
info->function_start_offset = value;
- info->within_function = TRUE;
+ info->within_function = true;
}
if (! parse_stab_string (dhandle, info, type, desc, value, string, string_end))
- return FALSE;
+ return false;
}
break;
else if (string != NULL && strcmp (string, "gcc_compiled.") == 0)
info->gcc_compiled = 1;
else
- info->n_opt_found = TRUE;
+ info->n_opt_found = true;
break;
case N_OBJ:
break;
}
- return TRUE;
+ return true;
}
/* Parse the stabs string. */
-static bfd_boolean
+static bool
parse_stab_string (void *dhandle, struct stab_handle *info, int stabtype,
int desc ATTRIBUTE_UNUSED, bfd_vma value,
const char *string, const char * string_end)
char *name;
int type;
debug_type dtype;
- bfd_boolean synonym;
- bfd_boolean self_crossref;
+ bool synonym;
+ bool self_crossref;
debug_type *slot;
p = strchr (string, ':');
if (p == NULL)
- return TRUE;
+ return true;
while (p[1] == ':')
{
if (p == NULL)
{
bad_stab (string);
- return FALSE;
+ return false;
}
}
else if (*p == 0)
{
bad_stab (string);
- return FALSE;
+ return false;
}
else
type = *p++;
if (*p != '=')
{
bad_stab (string);
- return FALSE;
+ return false;
}
++p;
switch (*p++)
case 'r':
/* Floating point constant. */
if (! debug_record_float_const (dhandle, name, atof (p)))
- return FALSE;
+ return false;
break;
case 'i':
/* Integer constant. */
other languages probably should have at least unsigned as
well as signed constants. */
if (! debug_record_int_const (dhandle, name, atoi (p)))
- return FALSE;
+ return false;
break;
case 'e':
/* SYMBOL:c=eTYPE,INTVALUE for a constant symbol whose value
dtype = parse_stab_type (dhandle, info, (const char *) NULL,
&p, (debug_type **) NULL, string_end);
if (dtype == DEBUG_TYPE_NULL)
- return FALSE;
+ return false;
if (*p != ',')
{
bad_stab (string);
- return FALSE;
+ return false;
}
if (! debug_record_typed_const (dhandle, name, dtype, atoi (p)))
- return FALSE;
+ return false;
break;
default:
bad_stab (string);
- return FALSE;
+ return false;
}
break;
dtype = parse_stab_type (dhandle, info, (const char *) NULL,
&p, (debug_type **) NULL, string_end);
if (dtype == DEBUG_TYPE_NULL)
- return FALSE;
+ return false;
if (! debug_record_label (dhandle, name, dtype, value))
- return FALSE;
+ return false;
break;
case 'f':
dtype = parse_stab_type (dhandle, info, (const char *) NULL, &p,
(debug_type **) NULL, string_end);
if (dtype == DEBUG_TYPE_NULL)
- return FALSE;
+ return false;
if (! debug_record_function (dhandle, name, dtype, type == 'F', value))
- return FALSE;
+ return false;
/* Sun acc puts declared types of arguments here. We don't care
about their actual types (FIXME -- we should remember the whole
if (parse_stab_type (dhandle, info, (const char *) NULL, &p,
(debug_type **) NULL, string_end)
== DEBUG_TYPE_NULL)
- return FALSE;
+ return false;
}
break;
dtype = parse_stab_type (dhandle, info, (const char *) NULL, &p,
(debug_type **) NULL, string_end);
if (dtype == DEBUG_TYPE_NULL)
- return FALSE;
+ return false;
if (name != NULL)
{
char leading;
if (! stab_record_variable (dhandle, info, name, dtype, DEBUG_GLOBAL,
value))
- return FALSE;
+ return false;
}
break;
dtype = parse_stab_type (dhandle, info, (const char *) NULL, &p,
(debug_type **) NULL, string_end);
if (dtype == DEBUG_TYPE_NULL)
- return FALSE;
+ return false;
if (! stab_record_variable (dhandle, info, name, dtype, DEBUG_LOCAL,
value))
- return FALSE;
+ return false;
break;
case 'p':
debug_type ftype;
ftype = debug_make_function_type (dhandle, dtype,
- (debug_type *) NULL, FALSE);
+ (debug_type *) NULL, false);
dtype = debug_make_pointer_type (dhandle, ftype);
}
}
if (dtype == DEBUG_TYPE_NULL)
- return FALSE;
+ return false;
if (! debug_record_parameter (dhandle, name, dtype, DEBUG_PARM_STACK,
value))
- return FALSE;
+ return false;
/* FIXME: At this point gdb considers rearranging the parameter
address on a big endian machine if it is smaller than an int.
if (parse_stab_type (dhandle, info, (const char *) NULL, &p,
(debug_type **) NULL, string_end)
== DEBUG_TYPE_NULL)
- return FALSE;
+ return false;
}
break;
}
dtype = parse_stab_type (dhandle, info, (const char *) NULL, &p,
(debug_type **) NULL, string_end);
if (dtype == DEBUG_TYPE_NULL)
- return FALSE;
+ return false;
if (! debug_record_parameter (dhandle, name, dtype, DEBUG_PARM_REG,
value))
- return FALSE;
+ return false;
break;
case 'r':
dtype = parse_stab_type (dhandle, info, (const char *) NULL, &p,
(debug_type **) NULL, string_end);
if (dtype == DEBUG_TYPE_NULL)
- return FALSE;
+ return false;
if (! stab_record_variable (dhandle, info, name, dtype, DEBUG_REGISTER,
value))
- return FALSE;
+ return false;
/* FIXME: At this point gdb checks to combine pairs of 'p' and
'r' stabs into a single 'P' stab. */
dtype = parse_stab_type (dhandle, info, (const char *) NULL, &p,
(debug_type **) NULL, string_end);
if (dtype == DEBUG_TYPE_NULL)
- return FALSE;
+ return false;
if (! stab_record_variable (dhandle, info, name, dtype, DEBUG_STATIC,
value))
- return FALSE;
+ return false;
break;
case 't':
/* A typedef. */
dtype = parse_stab_type (dhandle, info, name, &p, &slot, string_end);
if (dtype == DEBUG_TYPE_NULL)
- return FALSE;
+ return false;
if (name == NULL)
{
/* A nameless type. Nothing to do. */
- return TRUE;
+ return true;
}
dtype = debug_name_type (dhandle, name, dtype);
if (dtype == DEBUG_TYPE_NULL)
- return FALSE;
+ return false;
if (slot != NULL)
*slot = dtype;
by 't' which means we are typedef'ing it as well. */
if (*p != 't')
{
- synonym = FALSE;
+ synonym = false;
/* FIXME: gdb sets synonym to TRUE if the current language
is C++. */
}
else
{
- synonym = TRUE;
+ synonym = true;
++p;
}
dtype = parse_stab_type (dhandle, info, name, &p, &slot, string_end);
if (dtype == DEBUG_TYPE_NULL)
- return FALSE;
+ return false;
if (name == NULL)
- return TRUE;
+ return true;
/* INFO->SELF_CROSSREF is set by parse_stab_type if this type is
a cross reference to itself. These are generated by some
dtype = debug_tag_type (dhandle, name, dtype);
if (dtype == DEBUG_TYPE_NULL)
- return FALSE;
+ return false;
if (slot != NULL)
*slot = dtype;
{
dtype = debug_name_type (dhandle, name, dtype);
if (dtype == DEBUG_TYPE_NULL)
- return FALSE;
+ return false;
if (slot != NULL)
*slot = dtype;
dtype = parse_stab_type (dhandle, info, (const char *) NULL, &p,
(debug_type **) NULL, string_end);
if (dtype == DEBUG_TYPE_NULL)
- return FALSE;
+ return false;
/* FIXME: gdb checks os9k_stabs here. */
if (! stab_record_variable (dhandle, info, name, dtype,
DEBUG_LOCAL_STATIC, value))
- return FALSE;
+ return false;
break;
case 'v':
dtype = parse_stab_type (dhandle, info, (const char *) NULL, &p,
(debug_type **) NULL, string_end);
if (dtype == DEBUG_TYPE_NULL)
- return FALSE;
+ return false;
if (! debug_record_parameter (dhandle, name, dtype, DEBUG_PARM_REFERENCE,
value))
- return FALSE;
+ return false;
break;
case 'a':
dtype = parse_stab_type (dhandle, info, (const char *) NULL, &p,
(debug_type **) NULL, string_end);
if (dtype == DEBUG_TYPE_NULL)
- return FALSE;
+ return false;
if (! debug_record_parameter (dhandle, name, dtype, DEBUG_PARM_REF_REG,
value))
- return FALSE;
+ return false;
break;
case 'X':
dtype = parse_stab_type (dhandle, info, (const char *) NULL, &p,
(debug_type **) NULL, string_end);
if (dtype == DEBUG_TYPE_NULL)
- return FALSE;
+ return false;
if (! stab_record_variable (dhandle, info, name, dtype, DEBUG_LOCAL,
value))
- return FALSE;
+ return false;
break;
case 'Y':
while (*p != ';')
++p;
++p;
- return TRUE;
+ return true;
}
/* TODO SUNPro C++ support:
Support default arguments after F,P parameters
default:
bad_stab (string);
- return FALSE;
+ return false;
}
/* FIXME: gdb converts structure values to structure pointers in a
couple of cases, depending upon the target. */
- return TRUE;
+ return true;
}
/* Parse a stabs type. The typename argument is non-NULL if this is a
const char *orig;
int typenums[2];
int size;
- bfd_boolean stringp;
+ bool stringp;
int descriptor;
debug_type dtype;
return DEBUG_TYPE_NULL;
size = -1;
- stringp = FALSE;
+ stringp = false;
- info->self_crossref = FALSE;
+ info->self_crossref = false;
/* Read type number if present. The type number may be omitted.
for instance in a two-dimensional array declared with type
break;
case 'S':
- stringp = TRUE;
+ stringp = true;
break;
case 0:
if (type_name != NULL
&& strncmp (type_name, *pp, p - *pp) == 0
&& type_name[p - *pp] == '\0')
- info->self_crossref = TRUE;
+ info->self_crossref = true;
dtype = stab_find_tagged_type (dhandle, info, *pp, p - *pp, code);
(dhandle,
parse_stab_type (dhandle, info, (const char *) NULL, pp,
(debug_type **) NULL, p_end),
- (debug_type *) NULL, FALSE));
+ (debug_type *) NULL, false));
break;
case 'k':
++*pp;
dtype = debug_make_method_type (dhandle, return_type,
DEBUG_TYPE_NULL,
- (debug_type *) NULL, FALSE);
+ (debug_type *) NULL, false);
}
else
{
debug_type *args;
unsigned int n;
unsigned int alloc;
- bfd_boolean varargs;
+ bool varargs;
domain = parse_stab_type (dhandle, info, (const char *) NULL,
pp, (debug_type **) NULL, p_end);
the void type. */
if (n == 0
|| debug_get_type_kind (dhandle, args[n - 1]) != DEBUG_KIND_VOID)
- varargs = TRUE;
+ varargs = true;
else
{
--n;
- varargs = FALSE;
+ varargs = false;
}
args[n] = DEBUG_TYPE_NULL;
single number N is equivalent to (0,N). Return the two numbers by
storing them in the vector TYPENUMS. */
-static bfd_boolean
+static bool
parse_stab_type_number (const char **pp, int *typenums, const char *p_end)
{
const char *orig;
if (**pp != '(')
{
typenums[0] = 0;
- typenums[1] = (int) parse_number (pp, (bfd_boolean *) NULL, p_end);
- return TRUE;
+ typenums[1] = (int) parse_number (pp, (bool *) NULL, p_end);
+ return true;
}
++*pp;
- typenums[0] = (int) parse_number (pp, (bfd_boolean *) NULL, p_end);
+ typenums[0] = (int) parse_number (pp, (bool *) NULL, p_end);
if (**pp != ',')
{
bad_stab (orig);
- return FALSE;
+ return false;
}
++*pp;
- typenums[1] = (int) parse_number (pp, (bfd_boolean *) NULL, p_end);
+ typenums[1] = (int) parse_number (pp, (bool *) NULL, p_end);
if (**pp != ')')
{
bad_stab (orig);
- return FALSE;
+ return false;
}
++*pp;
- return TRUE;
+ return true;
}
/* Parse a range type. */
{
const char *orig;
int rangenums[2];
- bfd_boolean self_subrange;
+ bool self_subrange;
debug_type index_type;
const char *s2, *s3;
bfd_signed_vma n2, n3;
- bfd_boolean ov2, ov3;
+ bool ov2, ov3;
orig = *pp;
if (orig >= p_end)
{
if (startswith (s2, LLLOW)
&& startswith (s3, LLHIGH))
- return debug_make_int_type (dhandle, 8, FALSE);
+ return debug_make_int_type (dhandle, 8, false);
if (! ov2
&& n2 == 0
&& startswith (s3, ULLHIGH))
- return debug_make_int_type (dhandle, 8, TRUE);
+ return debug_make_int_type (dhandle, 8, true);
}
warn_stab (orig, _("numeric overflow"));
if (type_name != NULL)
{
if (strcmp (type_name, "long long int") == 0)
- return debug_make_int_type (dhandle, 8, FALSE);
+ return debug_make_int_type (dhandle, 8, false);
else if (strcmp (type_name, "long long unsigned int") == 0)
- return debug_make_int_type (dhandle, 8, TRUE);
+ return debug_make_int_type (dhandle, 8, true);
}
/* FIXME: The size here really depends upon the target. */
- return debug_make_int_type (dhandle, 4, TRUE);
+ return debug_make_int_type (dhandle, 4, true);
}
/* A range of 0 to 127 is char. */
if (self_subrange && n2 == 0 && n3 == 127)
- return debug_make_int_type (dhandle, 1, FALSE);
+ return debug_make_int_type (dhandle, 1, false);
/* FIXME: gdb checks for the language CHILL here. */
if (n2 == 0)
{
if (n3 < 0)
- return debug_make_int_type (dhandle, - n3, TRUE);
+ return debug_make_int_type (dhandle, - n3, true);
else if (n3 == 0xff)
- return debug_make_int_type (dhandle, 1, TRUE);
+ return debug_make_int_type (dhandle, 1, true);
else if (n3 == 0xffff)
- return debug_make_int_type (dhandle, 2, TRUE);
+ return debug_make_int_type (dhandle, 2, true);
else if (n3 == (bfd_signed_vma) 0xffffffff)
- return debug_make_int_type (dhandle, 4, TRUE);
+ return debug_make_int_type (dhandle, 4, true);
#ifdef BFD64
else if (n3 == (bfd_signed_vma) 0xffffffffffffffffLL)
- return debug_make_int_type (dhandle, 8, TRUE);
+ return debug_make_int_type (dhandle, 8, true);
#endif
}
else if (n3 == 0
&& n2 < 0
&& (self_subrange || n2 == -8))
- return debug_make_int_type (dhandle, - n2, TRUE);
+ return debug_make_int_type (dhandle, - n2, true);
else if (n2 == - n3 - 1 || n2 == n3 + 1)
{
if (n3 == 0x7f)
- return debug_make_int_type (dhandle, 1, FALSE);
+ return debug_make_int_type (dhandle, 1, false);
else if (n3 == 0x7fff)
- return debug_make_int_type (dhandle, 2, FALSE);
+ return debug_make_int_type (dhandle, 2, false);
else if (n3 == 0x7fffffff)
- return debug_make_int_type (dhandle, 4, FALSE);
+ return debug_make_int_type (dhandle, 4, false);
#ifdef BFD64
else if (n3 == ((((bfd_vma) 0x7fffffff) << 32) | 0xffffffff))
- return debug_make_int_type (dhandle, 8, FALSE);
+ return debug_make_int_type (dhandle, 8, false);
#endif
}
}
/* Does this actually ever happen? Is that why we are worrying
about dealing with it rather than just calling error_type? */
warn_stab (orig, _("missing index type"));
- index_type = debug_make_int_type (dhandle, 4, FALSE);
+ index_type = debug_make_int_type (dhandle, 4, false);
}
return debug_make_range_type (dhandle, index_type, n2, n3);
parse_stab_sun_builtin_type (void *dhandle, const char **pp, const char * p_end)
{
const char *orig;
- bfd_boolean unsignedp;
+ bool unsignedp;
bfd_vma bits;
orig = *pp;
switch (**pp)
{
case 's':
- unsignedp = FALSE;
+ unsignedp = false;
break;
case 'u':
- unsignedp = TRUE;
+ unsignedp = true;
break;
default:
bad_stab (orig);
by this type, except that unsigned short is 4 instead of 2.
Since this information is redundant with the third number,
we will ignore it. */
- (void) parse_number (pp, (bfd_boolean *) NULL, p_end);
+ (void) parse_number (pp, (bool *) NULL, p_end);
if (**pp != ';')
{
bad_stab (orig);
++*pp;
/* The second number is always 0, so ignore it too. */
- (void) parse_number (pp, (bfd_boolean *) NULL, p_end);
+ (void) parse_number (pp, (bool *) NULL, p_end);
if (**pp != ';')
{
bad_stab (orig);
++*pp;
/* The third number is the number of bits for this type. */
- bits = parse_number (pp, (bfd_boolean *) NULL, p_end);
+ bits = parse_number (pp, (bool *) NULL, p_end);
/* The type *should* end with a semicolon. If it are embedded
in a larger type the semicolon may be the only way to know where
/* The first number has more details about the type, for example
FN_COMPLEX. */
- details = parse_number (pp, (bfd_boolean *) NULL, p_end);
+ details = parse_number (pp, (bool *) NULL, p_end);
if (**pp != ';')
{
bad_stab (orig);
}
/* The second number is the number of bytes occupied by this type */
- bytes = parse_number (pp, (bfd_boolean *) NULL, p_end);
+ bytes = parse_number (pp, (bool *) NULL, p_end);
if (**pp != ';')
{
bad_stab (orig);
name = savestring (*pp, p - *pp);
*pp = p + 1;
- val = (bfd_signed_vma) parse_number (pp, (bfd_boolean *) NULL, p_end);
+ val = (bfd_signed_vma) parse_number (pp, (bool *) NULL, p_end);
if (**pp != ',')
{
bad_stab (orig);
*PP will point to "4a:1,0,32;;". */
static debug_type
-parse_stab_struct_type (void * dhandle,
- struct stab_handle * info,
- const char * tagname,
- const char ** pp,
- bfd_boolean structp,
- const int * typenums,
- const char * p_end)
+parse_stab_struct_type (void *dhandle,
+ struct stab_handle *info,
+ const char *tagname,
+ const char **pp,
+ bool structp,
+ const int *typenums,
+ const char *p_end)
{
bfd_vma size;
debug_baseclass *baseclasses;
debug_field *fields = NULL;
- bfd_boolean statics;
+ bool statics;
debug_method *methods;
debug_type vptrbase;
- bfd_boolean ownvptr;
+ bool ownvptr;
/* Get the size. */
- size = parse_number (pp, (bfd_boolean *) NULL, p_end);
+ size = parse_number (pp, (bool *) NULL, p_end);
/* Get the other information. */
if (! parse_stab_baseclasses (dhandle, info, pp, &baseclasses, p_end)
Return TRUE for success, FALSE for failure. */
-static bfd_boolean
+static bool
parse_stab_baseclasses (void * dhandle,
struct stab_handle * info,
const char ** pp,
orig = *pp;
if (orig >= p_end)
- return FALSE;
+ return false;
if (**pp != '!')
{
/* No base classes. */
- return TRUE;
+ return true;
}
++*pp;
- c = (unsigned int) parse_number (pp, (bfd_boolean *) NULL, p_end);
+ c = (unsigned int) parse_number (pp, (bool *) NULL, p_end);
if (**pp != ',')
{
bad_stab (orig);
- return FALSE;
+ return false;
}
++*pp;
for (i = 0; i < c; i++)
{
- bfd_boolean is_virtual;
+ bool is_virtual;
enum debug_visibility visibility;
bfd_vma bitpos;
debug_type type;
switch (**pp)
{
case '0':
- is_virtual = FALSE;
+ is_virtual = false;
break;
case '1':
- is_virtual = TRUE;
+ is_virtual = true;
break;
case 0:
bad_stab (orig);
- return FALSE;
+ return false;
default:
warn_stab (orig, _("unknown virtual character for baseclass"));
- is_virtual = FALSE;
+ is_virtual = false;
break;
}
++*pp;
break;
case 0:
bad_stab (orig);
- return FALSE;
+ return false;
default:
warn_stab (orig, _("unknown visibility character for baseclass"));
visibility = DEBUG_VISIBILITY_PUBLIC;
/* The remaining value is the bit offset of the portion of the
object corresponding to this baseclass. Always zero in the
absence of multiple inheritance. */
- bitpos = parse_number (pp, (bfd_boolean *) NULL, p_end);
+ bitpos = parse_number (pp, (bool *) NULL, p_end);
if (**pp != ',')
{
bad_stab (orig);
- return FALSE;
+ return false;
}
++*pp;
type = parse_stab_type (dhandle, info, (const char *) NULL, pp,
(debug_type **) NULL, p_end);
if (type == DEBUG_TYPE_NULL)
- return FALSE;
+ return false;
classes[i] = debug_make_baseclass (dhandle, type, bitpos, is_virtual,
visibility);
if (classes[i] == DEBUG_BASECLASS_NULL)
- return FALSE;
+ return false;
if (**pp != ';')
- return FALSE;
+ return false;
++*pp;
}
*retp = classes;
- return TRUE;
+ return true;
}
/* Read struct or class data fields. They have the form:
Returns 1 for success, 0 for failure. */
-static bfd_boolean
-parse_stab_struct_fields (void * dhandle,
- struct stab_handle * info,
- const char ** pp,
- debug_field ** retp,
- bfd_boolean * staticsp,
- const char * p_end)
+static bool
+parse_stab_struct_fields (void *dhandle,
+ struct stab_handle *info,
+ const char **pp,
+ debug_field **retp,
+ bool *staticsp,
+ const char * p_end)
{
const char *orig;
const char *p;
unsigned int alloc;
*retp = NULL;
- *staticsp = FALSE;
+ *staticsp = false;
orig = *pp;
if (orig >= p_end)
- return FALSE;
+ return false;
c = 0;
alloc = 10;
if (! parse_stab_cpp_abbrev (dhandle, info, pp, fields + c, p_end))
{
free (fields);
- return FALSE;
+ return false;
}
++c;
continue;
{
bad_stab (orig);
free (fields);
- return FALSE;
+ return false;
}
if (p[1] == ':')
if (! parse_stab_one_struct_field (dhandle, info, pp, p, fields + c,
staticsp, p_end))
- return FALSE;
+ return false;
++c;
}
*retp = fields;
- return TRUE;
+ return true;
}
/* Special GNU C++ name. */
-static bfd_boolean
+static bool
parse_stab_cpp_abbrev (void * dhandle,
struct stab_handle * info,
const char ** pp,
orig = *pp;
if (orig >= p_end)
- return FALSE;
+ return false;
if (**pp != 'v')
{
bad_stab (*pp);
- return FALSE;
+ return false;
}
++*pp;
if (cpp_abbrev == 0)
{
bad_stab (orig);
- return FALSE;
+ return false;
}
++*pp;
context = parse_stab_type (dhandle, info, (const char *) NULL, pp,
(debug_type **) NULL, p_end);
if (context == DEBUG_TYPE_NULL)
- return FALSE;
+ return false;
switch (cpp_abbrev)
{
if (**pp != ':')
{
bad_stab (orig);
- return FALSE;
+ return false;
}
++*pp;
if (**pp != ',')
{
bad_stab (orig);
- return FALSE;
+ return false;
}
++*pp;
- bitpos = parse_number (pp, (bfd_boolean *) NULL, p_end);
+ bitpos = parse_number (pp, (bool *) NULL, p_end);
if (**pp != ';')
{
bad_stab (orig);
- return FALSE;
+ return false;
}
++*pp;
*retp = debug_make_field (dhandle, name, type, bitpos, 0,
DEBUG_VISIBILITY_PRIVATE);
if (*retp == DEBUG_FIELD_NULL)
- return FALSE;
+ return false;
- return TRUE;
+ return true;
}
/* Parse a single field in a struct or union. */
-static bfd_boolean
-parse_stab_one_struct_field (void * dhandle,
- struct stab_handle * info,
- const char ** pp,
- const char * p,
- debug_field * retp,
- bfd_boolean * staticsp,
- const char * p_end)
+static bool
+parse_stab_one_struct_field (void *dhandle,
+ struct stab_handle *info,
+ const char **pp,
+ const char *p,
+ debug_field *retp,
+ bool *staticsp,
+ const char *p_end)
{
const char *orig;
char *name;
orig = *pp;
if (orig >= p_end)
- return FALSE;
+ return false;
/* FIXME: gdb checks ARM_DEMANGLING here. */
break;
case 0:
bad_stab (orig);
- return FALSE;
+ return false;
default:
warn_stab (orig, _("unknown visibility character for field"));
visibility = DEBUG_VISIBILITY_PUBLIC;
if (type == DEBUG_TYPE_NULL)
{
free (name);
- return FALSE;
+ return false;
}
if (**pp == ':')
{
bad_stab (orig);
free (name);
- return FALSE;
+ return false;
}
varname = savestring (*pp, p - *pp);
*retp = debug_make_static_member (dhandle, name, type, varname,
visibility);
- *staticsp = TRUE;
+ *staticsp = true;
- return TRUE;
+ return true;
}
if (**pp != ',')
{
bad_stab (orig);
free (name);
- return FALSE;
+ return false;
}
++*pp;
- bitpos = parse_number (pp, (bfd_boolean *) NULL, p_end);
+ bitpos = parse_number (pp, (bool *) NULL, p_end);
if (**pp != ',')
{
bad_stab (orig);
free (name);
- return FALSE;
+ return false;
}
++*pp;
- bitsize = parse_number (pp, (bfd_boolean *) NULL, p_end);
+ bitsize = parse_number (pp, (bool *) NULL, p_end);
if (**pp != ';')
{
bad_stab (orig);
free (name);
- return FALSE;
+ return false;
}
++*pp;
*retp = debug_make_field (dhandle, name, type, bitpos, bitsize, visibility);
- return TRUE;
+ return true;
}
/* Read member function stabs info for C++ classes. The form of each member
$ is the CPLUS_MARKER (usually '$'), `*' holds the place for an operator
name (such as `+=') and `.' marks the end of the operator name. */
-static bfd_boolean
+static bool
parse_stab_members (void * dhandle,
struct stab_handle * info,
const char * tagname,
orig = *pp;
if (orig >= p_end)
- return FALSE;
+ return false;
alloc = 0;
methods = NULL;
do
{
debug_type type;
- bfd_boolean stub;
+ bool stub;
enum debug_visibility visibility;
- bfd_boolean constp, volatilep, staticp;
+ bool constp, volatilep, staticp;
bfd_vma voffset;
debug_type context;
const char *physname;
- bfd_boolean varargs;
+ bool varargs;
if (look_ahead_type != DEBUG_TYPE_NULL)
{
goto fail;
}
- stub = FALSE;
+ stub = false;
if (debug_get_type_kind (dhandle, type) == DEBUG_KIND_METHOD
&& debug_get_parameter_types (dhandle, type, &varargs) == NULL)
- stub = TRUE;
+ stub = true;
argtypes = savestring (*pp, p - *pp);
*pp = p + 1;
}
++*pp;
- constp = FALSE;
- volatilep = FALSE;
+ constp = false;
+ volatilep = false;
switch (**pp)
{
case 'A':
break;
case 'B':
/* const member function. */
- constp = TRUE;
+ constp = true;
++*pp;
break;
case 'C':
/* volatile member function. */
- volatilep = TRUE;
+ volatilep = true;
++*pp;
break;
case 'D':
/* const volatile member function. */
- constp = TRUE;
- volatilep = TRUE;
+ constp = true;
+ volatilep = true;
++*pp;
break;
case '*':
break;
}
- staticp = FALSE;
+ staticp = false;
switch (**pp)
{
case '*':
bit is supposedly set to distinguish
pointers-to-methods from virtual function indices. */
++*pp;
- voffset = parse_number (pp, (bfd_boolean *) NULL, p_end);
+ voffset = parse_number (pp, (bool *) NULL, p_end);
if (**pp != ';')
{
bad_stab (orig);
case '?':
/* static member function. */
++*pp;
- staticp = TRUE;
+ staticp = true;
voffset = 0;
context = DEBUG_TYPE_NULL;
if (strncmp (argtypes, name, strlen (name)) != 0)
- stub = TRUE;
+ stub = true;
break;
default:
*retp = methods;
- return TRUE;
+ return true;
fail:
free (name);
free (variants);
free (argtypes);
- return FALSE;
+ return false;
}
/* Parse a string representing argument types for a method. Stabs
parse_stab_argtypes (void *dhandle, struct stab_handle *info,
debug_type class_type, const char *fieldname,
const char *tagname, debug_type return_type,
- const char *argtypes, bfd_boolean constp,
- bfd_boolean volatilep, const char **pphysname)
+ const char *argtypes, bool constp,
+ bool volatilep, const char **pphysname)
{
- bfd_boolean is_full_physname_constructor;
- bfd_boolean is_constructor;
- bfd_boolean is_destructor;
- bfd_boolean is_v3;
+ bool is_full_physname_constructor;
+ bool is_constructor;
+ bool is_destructor;
+ bool is_v3;
debug_type *args;
- bfd_boolean varargs;
+ bool varargs;
unsigned int physname_len = 0;
/* Constructors are sometimes handled specially. */
args = (debug_type *) xmalloc (sizeof *args);
*args = NULL;
return debug_make_method_type (dhandle, return_type, class_type, args,
- FALSE);
+ false);
}
args = stab_demangle_argtypes (dhandle, info, *pphysname, &varargs, physname_len);
This function is called when we have parsed all the method declarations,
so we can look for the vptr base class info. */
-static bfd_boolean
-parse_stab_tilde_field (void * dhandle,
- struct stab_handle * info,
- const char ** pp,
- const int * typenums,
- debug_type * retvptrbase,
- bfd_boolean * retownvptr,
- const char * p_end)
+static bool
+parse_stab_tilde_field (void *dhandle,
+ struct stab_handle *info,
+ const char **pp,
+ const int *typenums,
+ debug_type *retvptrbase,
+ bool *retownvptr,
+ const char *p_end)
{
const char *orig;
const char *hold;
int vtypenums[2];
*retvptrbase = DEBUG_TYPE_NULL;
- *retownvptr = FALSE;
+ *retownvptr = false;
orig = *pp;
if (orig >= p_end)
- return FALSE;
+ return false;
/* If we are positioned at a ';', then skip it. */
if (**pp == ';')
++*pp;
if (**pp != '~')
- return TRUE;
+ return true;
++*pp;
if (**pp == '=' || **pp == '+' || **pp == '-')
}
if (**pp != '%')
- return TRUE;
+ return true;
++*pp;
hold = *pp;
/* The next number is the type number of the base class (possibly
our own class) which supplies the vtable for this class. */
if (! parse_stab_type_number (pp, vtypenums, p_end))
- return FALSE;
+ return false;
if (vtypenums[0] == typenums[0]
&& vtypenums[1] == typenums[1])
- *retownvptr = TRUE;
+ *retownvptr = true;
else
{
debug_type vtype;
if (*p != ';')
{
bad_stab (orig);
- return FALSE;
+ return false;
}
*retvptrbase = vtype;
*pp = p + 1;
}
- return TRUE;
+ return true;
}
/* Read a definition of an array type. */
static debug_type
-parse_stab_array_type (void * dhandle,
- struct stab_handle * info,
- const char ** pp,
- bfd_boolean stringp,
- const char * p_end)
+parse_stab_array_type (void *dhandle,
+ struct stab_handle *info,
+ const char **pp,
+ bool stringp,
+ const char *p_end)
{
const char *orig;
const char *p;
int typenums[2];
debug_type index_type;
- bfd_boolean adjustable;
+ bool adjustable;
bfd_signed_vma lower, upper;
debug_type element_type;
index_type = debug_find_named_type (dhandle, "int");
if (index_type == DEBUG_TYPE_NULL)
{
- index_type = debug_make_int_type (dhandle, 4, FALSE);
+ index_type = debug_make_int_type (dhandle, 4, false);
if (index_type == DEBUG_TYPE_NULL)
return DEBUG_TYPE_NULL;
}
}
++*pp;
- adjustable = FALSE;
+ adjustable = false;
if (! ISDIGIT (**pp) && **pp != '-' && **pp != 0)
{
++*pp;
- adjustable = TRUE;
+ adjustable = true;
}
- lower = (bfd_signed_vma) parse_number (pp, (bfd_boolean *) NULL, p_end);
+ lower = (bfd_signed_vma) parse_number (pp, (bool *) NULL, p_end);
if (**pp != ';')
{
bad_stab (orig);
if (! ISDIGIT (**pp) && **pp != '-' && **pp != 0)
{
++*pp;
- adjustable = TRUE;
+ adjustable = true;
}
- upper = (bfd_signed_vma) parse_number (pp, (bfd_boolean *) NULL, p_end);
+ upper = (bfd_signed_vma) parse_number (pp, (bool *) NULL, p_end);
if (**pp != ';')
{
bad_stab (orig);
/* Handle an N_EXCL: get the types from the corresponding N_BINCL. */
-static bfd_boolean
+static bool
find_excl (struct stab_handle *info, const char *name, bfd_vma hash)
{
struct bincl_file *l;
{
warn_stab (name, _("Undefined N_EXCL"));
info->file_types[info->files - 1] = NULL;
- return TRUE;
+ return true;
}
info->file_types[info->files - 1] = l->file_types;
- return TRUE;
+ return true;
}
/* Handle a variable definition. gcc emits variable definitions for a
it. The SunPRO compiler emits variable definitions after the
N_LBRAC, so we can call debug_record_variable immediately. */
-static bfd_boolean
+static bool
stab_record_variable (void *dhandle, struct stab_handle *info,
const char *name, debug_type type,
enum debug_var_kind kind, bfd_vma val)
v->val = val;
info->pending = v;
- return TRUE;
+ return true;
}
/* Emit pending variable definitions. This is called after we see the
N_LBRAC that starts the block. */
-static bfd_boolean
+static bool
stab_emit_pending_vars (void *dhandle, struct stab_handle *info)
{
struct stab_pending_var *v;
struct stab_pending_var *next;
if (! debug_record_variable (dhandle, v->name, v->type, v->kind, v->val))
- return FALSE;
+ return false;
next = v->next;
free (v);
info->pending = NULL;
- return TRUE;
+ return true;
}
/* Find the slot for a type in the database. */
/* Record that a given type number refers to a given type. */
-static bfd_boolean
+static bool
stab_record_type (void *dhandle ATTRIBUTE_UNUSED, struct stab_handle *info,
const int *typenums, debug_type type)
{
slot = stab_find_slot (info, typenums);
if (slot == NULL)
- return FALSE;
+ return false;
/* gdb appears to ignore type redefinitions, so we do as well. */
*slot = type;
- return TRUE;
+ return true;
}
/* Return an XCOFF builtin type. */
/* The size of this and all the other types are fixed, defined
by the debugging format. */
name = "int";
- rettype = debug_make_int_type (dhandle, 4, FALSE);
+ rettype = debug_make_int_type (dhandle, 4, false);
break;
case 2:
name = "char";
- rettype = debug_make_int_type (dhandle, 1, FALSE);
+ rettype = debug_make_int_type (dhandle, 1, false);
break;
case 3:
name = "short";
- rettype = debug_make_int_type (dhandle, 2, FALSE);
+ rettype = debug_make_int_type (dhandle, 2, false);
break;
case 4:
name = "long";
- rettype = debug_make_int_type (dhandle, 4, FALSE);
+ rettype = debug_make_int_type (dhandle, 4, false);
break;
case 5:
name = "unsigned char";
- rettype = debug_make_int_type (dhandle, 1, TRUE);
+ rettype = debug_make_int_type (dhandle, 1, true);
break;
case 6:
name = "signed char";
- rettype = debug_make_int_type (dhandle, 1, FALSE);
+ rettype = debug_make_int_type (dhandle, 1, false);
break;
case 7:
name = "unsigned short";
- rettype = debug_make_int_type (dhandle, 2, TRUE);
+ rettype = debug_make_int_type (dhandle, 2, true);
break;
case 8:
name = "unsigned int";
- rettype = debug_make_int_type (dhandle, 4, TRUE);
+ rettype = debug_make_int_type (dhandle, 4, true);
break;
case 9:
name = "unsigned";
- rettype = debug_make_int_type (dhandle, 4, TRUE);
+ rettype = debug_make_int_type (dhandle, 4, true);
break;
case 10:
name = "unsigned long";
- rettype = debug_make_int_type (dhandle, 4, TRUE);
+ rettype = debug_make_int_type (dhandle, 4, true);
break;
case 11:
name = "void";
break;
case 15:
name = "integer";
- rettype = debug_make_int_type (dhandle, 4, FALSE);
+ rettype = debug_make_int_type (dhandle, 4, false);
break;
case 16:
name = "boolean";
case 20:
/* FIXME */
name = "character";
- rettype = debug_make_int_type (dhandle, 1, TRUE);
+ rettype = debug_make_int_type (dhandle, 1, true);
break;
case 21:
name = "logical*1";
break;
case 27:
name = "integer*1";
- rettype = debug_make_int_type (dhandle, 1, FALSE);
+ rettype = debug_make_int_type (dhandle, 1, false);
break;
case 28:
name = "integer*2";
- rettype = debug_make_int_type (dhandle, 2, FALSE);
+ rettype = debug_make_int_type (dhandle, 2, false);
break;
case 29:
name = "integer*4";
- rettype = debug_make_int_type (dhandle, 4, FALSE);
+ rettype = debug_make_int_type (dhandle, 4, false);
break;
case 30:
/* FIXME */
name = "wchar";
- rettype = debug_make_int_type (dhandle, 2, FALSE);
+ rettype = debug_make_int_type (dhandle, 2, false);
break;
case 31:
name = "long long";
- rettype = debug_make_int_type (dhandle, 8, FALSE);
+ rettype = debug_make_int_type (dhandle, 8, false);
break;
case 32:
name = "unsigned long long";
- rettype = debug_make_int_type (dhandle, 8, TRUE);
+ rettype = debug_make_int_type (dhandle, 8, true);
break;
case 33:
name = "logical*8";
break;
case 34:
name = "integer*8";
- rettype = debug_make_int_type (dhandle, 8, FALSE);
+ rettype = debug_make_int_type (dhandle, 8, false);
break;
default:
abort ();
/* The array of arguments we are building. */
debug_type *args;
/* Whether the method takes a variable number of arguments. */
- bfd_boolean varargs;
+ bool varargs;
/* The array of types we have remembered. */
struct stab_demangle_typestring *typestrings;
/* The number of typestrings. */
static void stab_bad_demangle (const char *);
static unsigned int stab_demangle_count (const char **);
-static bfd_boolean stab_demangle_get_count (const char **, unsigned int *);
-static bfd_boolean stab_demangle_prefix
+static bool stab_demangle_get_count (const char **, unsigned int *);
+static bool stab_demangle_prefix
(struct stab_demangle_info *, const char **, unsigned int);
-static bfd_boolean stab_demangle_function_name
+static bool stab_demangle_function_name
(struct stab_demangle_info *, const char **, const char *);
-static bfd_boolean stab_demangle_signature
+static bool stab_demangle_signature
(struct stab_demangle_info *, const char **);
-static bfd_boolean stab_demangle_qualified
+static bool stab_demangle_qualified
(struct stab_demangle_info *, const char **, debug_type *);
-static bfd_boolean stab_demangle_template
+static bool stab_demangle_template
(struct stab_demangle_info *, const char **, char **);
-static bfd_boolean stab_demangle_class
+static bool stab_demangle_class
(struct stab_demangle_info *, const char **, const char **);
-static bfd_boolean stab_demangle_args
- (struct stab_demangle_info *, const char **, debug_type **, bfd_boolean *);
-static bfd_boolean stab_demangle_arg
+static bool stab_demangle_args
+ (struct stab_demangle_info *, const char **, debug_type **, bool *);
+static bool stab_demangle_arg
(struct stab_demangle_info *, const char **, debug_type **,
unsigned int *, unsigned int *);
-static bfd_boolean stab_demangle_type
+static bool stab_demangle_type
(struct stab_demangle_info *, const char **, debug_type *);
-static bfd_boolean stab_demangle_fund_type
+static bool stab_demangle_fund_type
(struct stab_demangle_info *, const char **, debug_type *);
-static bfd_boolean stab_demangle_remember_type
+static bool stab_demangle_remember_type
(struct stab_demangle_info *, const char *, int);
/* Warn about a bad demangling. */
/* Require a count in a string. The count may be multiple digits, in
which case it must end in an underscore. */
-static bfd_boolean
+static bool
stab_demangle_get_count (const char **pp, unsigned int *pi)
{
if (! ISDIGIT (**pp))
- return FALSE;
+ return false;
*pi = **pp - '0';
++*pp;
}
}
- return TRUE;
+ return true;
}
/* This function demangles a physical name, returning a NULL
static debug_type *
stab_demangle_argtypes (void *dhandle, struct stab_handle *info,
- const char *physname, bfd_boolean *pvarargs,
+ const char *physname, bool *pvarargs,
unsigned int physname_len)
{
struct stab_demangle_info minfo;
minfo.dhandle = dhandle;
minfo.info = info;
minfo.args = NULL;
- minfo.varargs = FALSE;
+ minfo.varargs = false;
minfo.typestring_alloc = 10;
minfo.typestrings = ((struct stab_demangle_typestring *)
xmalloc (minfo.typestring_alloc
/* Demangle the prefix of the mangled name. */
-static bfd_boolean
+static bool
stab_demangle_prefix (struct stab_demangle_info *minfo, const char **pp,
unsigned int physname_len)
{
if (scan == NULL)
{
stab_bad_demangle (*pp);
- return FALSE;
+ return false;
}
--scan;
{
/* This is a GNU style constructor name. */
*pp = scan + 2;
- return TRUE;
+ return true;
}
else if (scan == *pp
&& ! ISDIGIT (scan[2])
if (scan == NULL || scan[2] == '\0')
{
stab_bad_demangle (*pp);
- return FALSE;
+ return false;
}
return stab_demangle_function_name (minfo, pp, scan);
else
{
stab_bad_demangle (*pp);
- return FALSE;
+ return false;
}
/*NOTREACHED*/
}
double underscore which separates the function name from the
signature. */
-static bfd_boolean
+static bool
stab_demangle_function_name (struct stab_demangle_info *minfo,
const char **pp, const char *scan)
{
/* This is a type conversion operator. */
tem = name + 5;
if (! stab_demangle_type (minfo, &tem, (debug_type *) NULL))
- return FALSE;
+ return false;
}
else if (name[0] == '_'
&& name[1] == '_'
/* This is a type conversion operator. */
tem = name + 4;
if (! stab_demangle_type (minfo, &tem, (debug_type *) NULL))
- return FALSE;
+ return false;
}
- return TRUE;
+ return true;
}
/* Demangle the signature. This is where the argument types are
found. */
-static bfd_boolean
+static bool
stab_demangle_signature (struct stab_demangle_info *minfo, const char **pp)
{
const char *orig;
- bfd_boolean expect_func, func_done;
+ bool expect_func, func_done;
const char *hold;
orig = *pp;
- expect_func = FALSE;
- func_done = FALSE;
+ expect_func = false;
+ func_done = false;
hold = NULL;
while (**pp != '\0')
hold = *pp;
if (! stab_demangle_qualified (minfo, pp, (debug_type *) NULL)
|| ! stab_demangle_remember_type (minfo, hold, *pp - hold))
- return FALSE;
- expect_func = TRUE;
+ return false;
+ expect_func = true;
hold = NULL;
break;
hold = *pp;
if (! stab_demangle_class (minfo, pp, (const char **) NULL)
|| ! stab_demangle_remember_type (minfo, hold, *pp - hold))
- return FALSE;
- expect_func = TRUE;
+ return false;
+ expect_func = true;
hold = NULL;
break;
/* Function. I don't know if this actually happens with g++
output. */
hold = NULL;
- func_done = TRUE;
+ func_done = true;
++*pp;
if (! stab_demangle_args (minfo, pp, &minfo->args, &minfo->varargs))
- return FALSE;
+ return false;
break;
case 't':
hold = *pp;
if (! stab_demangle_template (minfo, pp, (char **) NULL)
|| ! stab_demangle_remember_type (minfo, hold, *pp - hold))
- return FALSE;
+ return false;
hold = NULL;
- expect_func = TRUE;
+ expect_func = true;
break;
case '_':
has been mangled by some algorithm we don't know how to
deal with. So just reject the entire demangling. */
stab_bad_demangle (orig);
- return FALSE;
+ return false;
default:
/* Assume we have stumbled onto the first outermost function
argument token, and start processing args. */
- func_done = TRUE;
+ func_done = true;
if (! stab_demangle_args (minfo, pp, &minfo->args, &minfo->varargs))
- return FALSE;
+ return false;
break;
}
if (expect_func)
{
- func_done = TRUE;
+ func_done = true;
if (! stab_demangle_args (minfo, pp, &minfo->args, &minfo->varargs))
- return FALSE;
+ return false;
}
}
first case, and need to ensure that the '(void)' gets added
to the current declp. */
if (! stab_demangle_args (minfo, pp, &minfo->args, &minfo->varargs))
- return FALSE;
+ return false;
}
- return TRUE;
+ return true;
}
/* Demangle a qualified name, such as "Q25Outer5Inner" which is the
mangled form of "Outer::Inner". */
-static bfd_boolean
+static bool
stab_demangle_qualified (struct stab_demangle_info *minfo, const char **pp,
debug_type *ptype)
{
if (! ISDIGIT (*p) || *p == '0')
{
stab_bad_demangle (orig);
- return FALSE;
+ return false;
}
qualifiers = atoi (p);
while (ISDIGIT (*p))
if (*p != '_')
{
stab_bad_demangle (orig);
- return FALSE;
+ return false;
}
*pp = p + 1;
break;
case '0':
default:
stab_bad_demangle (orig);
- return FALSE;
+ return false;
}
context = DEBUG_TYPE_NULL;
if (! stab_demangle_template (minfo, pp,
ptype != NULL ? &name : NULL))
- return FALSE;
+ return false;
if (ptype != NULL)
{
DEBUG_KIND_CLASS);
free (name);
if (context == DEBUG_TYPE_NULL)
- return FALSE;
+ return false;
}
}
else
if (strlen (*pp) < len)
{
stab_bad_demangle (orig);
- return FALSE;
+ return false;
}
if (ptype != NULL)
if (ft == NULL)
{
free (name);
- return FALSE;
+ return false;
}
dn = debug_get_type_name (minfo->dhandle, ft);
if (dn != NULL && strcmp (dn, name) == 0)
? DEBUG_KIND_ILLEGAL
: DEBUG_KIND_CLASS));
if (context == DEBUG_TYPE_NULL)
- return FALSE;
+ return false;
}
}
}
if (ptype != NULL)
*ptype = context;
- return TRUE;
+ return true;
}
/* Demangle a template. If PNAME is not NULL, this sets *PNAME to a
string representation of the template. */
-static bfd_boolean
+static bool
stab_demangle_template (struct stab_demangle_info *minfo, const char **pp,
char **pname)
{
if (r == 0 || strlen (*pp) < r)
{
stab_bad_demangle (orig);
- return FALSE;
+ return false;
}
*pp += r;
if (stab_demangle_get_count (pp, &r) == 0)
{
stab_bad_demangle (orig);
- return FALSE;
+ return false;
}
for (i = 0; i < r; i++)
/* This is a type parameter. */
++*pp;
if (! stab_demangle_type (minfo, pp, (debug_type *) NULL))
- return FALSE;
+ return false;
}
else
{
const char *old_p;
- bfd_boolean pointerp, realp, integralp, charp, boolp;
- bfd_boolean done;
+ bool pointerp, realp, integralp, charp, boolp;
+ bool done;
old_p = *pp;
- pointerp = FALSE;
- realp = FALSE;
- integralp = FALSE;
- charp = FALSE;
- boolp = FALSE;
- done = FALSE;
+ pointerp = false;
+ realp = false;
+ integralp = false;
+ charp = false;
+ boolp = false;
+ done = false;
/* This is a value parameter. */
if (! stab_demangle_type (minfo, pp, (debug_type *) NULL))
- return FALSE;
+ return false;
while (*old_p != '\0' && ! done)
{
case 'P':
case 'p':
case 'R':
- pointerp = TRUE;
- done = TRUE;
+ pointerp = true;
+ done = true;
break;
case 'C': /* Const. */
case 'S': /* Signed. */
++old_p;
break;
case 'Q': /* Qualified name. */
- integralp = TRUE;
- done = TRUE;
+ integralp = true;
+ done = true;
break;
case 'T': /* Remembered type. */
abort ();
case 'i': /* Int. */
case 's': /* Short. */
case 'w': /* Wchar_t. */
- integralp = TRUE;
- done = TRUE;
+ integralp = true;
+ done = true;
break;
case 'b': /* Bool. */
- boolp = TRUE;
- done = TRUE;
+ boolp = true;
+ done = true;
break;
case 'c': /* Char. */
- charp = TRUE;
- done = TRUE;
+ charp = true;
+ done = true;
break;
case 'r': /* Long double. */
case 'd': /* Double. */
case 'f': /* Float. */
- realp = TRUE;
- done = TRUE;
+ realp = true;
+ done = true;
break;
default:
/* Assume it's a user defined integral type. */
- integralp = TRUE;
- done = TRUE;
+ integralp = true;
+ done = true;
break;
}
}
if (val == 0)
{
stab_bad_demangle (orig);
- return FALSE;
+ return false;
}
}
else if (boolp)
if (val != 0 && val != 1)
{
stab_bad_demangle (orig);
- return FALSE;
+ return false;
}
}
else if (realp)
if (len == 0)
{
stab_bad_demangle (orig);
- return FALSE;
+ return false;
}
*pp += len;
}
{
stab_bad_demangle (orig);
free (s3);
- return FALSE;
+ return false;
}
/* Eliminating all spaces, except those between > characters,
free (s3);
}
- return TRUE;
+ return true;
}
/* Demangle a class name. */
-static bfd_boolean
+static bool
stab_demangle_class (struct stab_demangle_info *minfo ATTRIBUTE_UNUSED,
const char **pp, const char **pstart)
{
if (strlen (*pp) < n)
{
stab_bad_demangle (orig);
- return FALSE;
+ return false;
}
if (pstart != NULL)
*pp += n;
- return TRUE;
+ return true;
}
/* Demangle function arguments. If the pargs argument is not NULL, it
is set to a NULL terminated array holding the arguments. */
-static bfd_boolean
+static bool
stab_demangle_args (struct stab_demangle_info *minfo, const char **pp,
- debug_type **pargs, bfd_boolean *pvarargs)
+ debug_type **pargs, bool *pvarargs)
{
const char *orig;
unsigned int alloc, count;
if (pargs != NULL)
{
*pargs = (debug_type *) xmalloc (alloc * sizeof **pargs);
- *pvarargs = FALSE;
+ *pvarargs = false;
}
count = 0;
if (! stab_demangle_get_count (pp, &r))
{
stab_bad_demangle (orig);
- return FALSE;
+ return false;
}
}
if (! stab_demangle_get_count (pp, &t))
{
stab_bad_demangle (orig);
- return FALSE;
+ return false;
}
if (t >= minfo->typestring_count)
{
stab_bad_demangle (orig);
- return FALSE;
+ return false;
}
while (r-- > 0)
{
tem = minfo->typestrings[t].typestring;
if (! stab_demangle_arg (minfo, &tem, pargs, &count, &alloc))
- return FALSE;
+ return false;
}
}
else
{
if (! stab_demangle_arg (minfo, pp, pargs, &count, &alloc))
- return FALSE;
+ return false;
}
}
if (**pp == 'e')
{
if (pargs != NULL)
- *pvarargs = TRUE;
+ *pvarargs = true;
++*pp;
}
- return TRUE;
+ return true;
}
/* Demangle a single argument. */
-static bfd_boolean
+static bool
stab_demangle_arg (struct stab_demangle_info *minfo, const char **pp,
debug_type **pargs, unsigned int *pcount,
unsigned int *palloc)
if (! stab_demangle_type (minfo, pp,
pargs == NULL ? (debug_type *) NULL : &type)
|| ! stab_demangle_remember_type (minfo, start, *pp - start))
- return FALSE;
+ return false;
if (pargs != NULL)
{
if (type == DEBUG_TYPE_NULL)
- return FALSE;
+ return false;
if (*pcount + 1 >= *palloc)
{
++*pcount;
}
- return TRUE;
+ return true;
}
/* Demangle a type. If the ptype argument is not NULL, *ptype is set
to the newly allocated type. */
-static bfd_boolean
+static bool
stab_demangle_type (struct stab_demangle_info *minfo, const char **pp,
debug_type *ptype)
{
/* A pointer type. */
++*pp;
if (! stab_demangle_type (minfo, pp, ptype))
- return FALSE;
+ return false;
if (ptype != NULL)
*ptype = debug_make_pointer_type (minfo->dhandle, *ptype);
break;
/* A reference type. */
++*pp;
if (! stab_demangle_type (minfo, pp, ptype))
- return FALSE;
+ return false;
if (ptype != NULL)
*ptype = debug_make_reference_type (minfo->dhandle, *ptype);
break;
if (! ISDIGIT (**pp))
{
stab_bad_demangle (orig);
- return FALSE;
+ return false;
}
high *= 10;
high += **pp - '0';
if (**pp != '_')
{
stab_bad_demangle (orig);
- return FALSE;
+ return false;
}
++*pp;
if (! stab_demangle_type (minfo, pp, ptype))
- return FALSE;
+ return false;
if (ptype != NULL)
{
debug_type int_type;
int_type = debug_find_named_type (minfo->dhandle, "int");
if (int_type == NULL)
- int_type = debug_make_int_type (minfo->dhandle, 4, FALSE);
+ int_type = debug_make_int_type (minfo->dhandle, 4, false);
*ptype = debug_make_array_type (minfo->dhandle, *ptype, int_type,
- 0, high, FALSE);
+ 0, high, false);
}
}
break;
if (! stab_demangle_get_count (pp, &i))
{
stab_bad_demangle (orig);
- return FALSE;
+ return false;
}
if (i >= minfo->typestring_count)
{
stab_bad_demangle (orig);
- return FALSE;
+ return false;
}
p = minfo->typestrings[i].typestring;
if (! stab_demangle_type (minfo, &p, ptype))
- return FALSE;
+ return false;
}
break;
/* A function. */
{
debug_type *args;
- bfd_boolean varargs;
+ bool varargs;
++*pp;
if (! stab_demangle_args (minfo, pp,
? (debug_type **) NULL
: &args),
(ptype == NULL
- ? (bfd_boolean *) NULL
+ ? (bool *) NULL
: &varargs)))
- return FALSE;
+ return false;
if (**pp != '_')
{
/* cplus_demangle will accept a function without a return
type, but I don't know when that will happen, or what
to do if it does. */
stab_bad_demangle (orig);
- return FALSE;
+ return false;
}
++*pp;
if (! stab_demangle_type (minfo, pp, ptype))
- return FALSE;
+ return false;
if (ptype != NULL)
*ptype = debug_make_function_type (minfo->dhandle, *ptype, args,
varargs);
case 'M':
case 'O':
{
- bfd_boolean memberp;
+ bool memberp;
debug_type class_type = DEBUG_TYPE_NULL;
debug_type *args;
- bfd_boolean varargs;
+ bool varargs;
unsigned int n;
const char *name;
memberp = **pp == 'M';
args = NULL;
- varargs = FALSE;
+ varargs = false;
++*pp;
if (ISDIGIT (**pp))
if (strlen (*pp) < n)
{
stab_bad_demangle (orig);
- return FALSE;
+ return false;
}
name = *pp;
*pp += n;
name, (int) n,
DEBUG_KIND_CLASS);
if (class_type == DEBUG_TYPE_NULL)
- return FALSE;
+ return false;
}
}
else if (**pp == 'Q')
(ptype == NULL
? (debug_type *) NULL
: &class_type)))
- return FALSE;
+ return false;
}
else
{
stab_bad_demangle (orig);
- return FALSE;
+ return false;
}
if (memberp)
if (**pp != 'F')
{
stab_bad_demangle (orig);
- return FALSE;
+ return false;
}
++*pp;
if (! stab_demangle_args (minfo, pp,
? (debug_type **) NULL
: &args),
(ptype == NULL
- ? (bfd_boolean *) NULL
+ ? (bool *) NULL
: &varargs)))
- return FALSE;
+ return false;
}
if (**pp != '_')
{
stab_bad_demangle (orig);
- return FALSE;
+ return false;
}
++*pp;
if (! stab_demangle_type (minfo, pp, ptype))
- return FALSE;
+ return false;
if (ptype != NULL)
{
case 'G':
++*pp;
if (! stab_demangle_type (minfo, pp, ptype))
- return FALSE;
+ return false;
break;
case 'C':
++*pp;
if (! stab_demangle_type (minfo, pp, ptype))
- return FALSE;
+ return false;
if (ptype != NULL)
*ptype = debug_make_const_type (minfo->dhandle, *ptype);
break;
case 'Q':
{
if (! stab_demangle_qualified (minfo, pp, ptype))
- return FALSE;
+ return false;
}
break;
default:
if (! stab_demangle_fund_type (minfo, pp, ptype))
- return FALSE;
+ return false;
break;
}
- return TRUE;
+ return true;
}
/* Demangle a fundamental type. If the ptype argument is not NULL,
*ptype is set to the newly allocated type. */
-static bfd_boolean
+static bool
stab_demangle_fund_type (struct stab_demangle_info *minfo, const char **pp,
debug_type *ptype)
{
const char *orig;
- bfd_boolean constp, volatilep, unsignedp, signedp;
- bfd_boolean done;
+ bool constp, volatilep, unsignedp, signedp;
+ bool done;
orig = *pp;
- constp = FALSE;
- volatilep = FALSE;
- unsignedp = FALSE;
- signedp = FALSE;
+ constp = false;
+ volatilep = false;
+ unsignedp = false;
+ signedp = false;
- done = FALSE;
+ done = false;
while (! done)
{
switch (**pp)
{
case 'C':
- constp = TRUE;
+ constp = true;
++*pp;
break;
case 'U':
- unsignedp = TRUE;
+ unsignedp = true;
++*pp;
break;
case 'S':
- signedp = TRUE;
+ signedp = true;
++*pp;
break;
case 'V':
- volatilep = TRUE;
+ volatilep = true;
++*pp;
break;
default:
- done = TRUE;
+ done = true;
break;
}
}
{
*ptype = debug_find_named_type (minfo->dhandle, "__wchar_t");
if (*ptype == DEBUG_TYPE_NULL)
- *ptype = debug_make_int_type (minfo->dhandle, 2, TRUE);
+ *ptype = debug_make_int_type (minfo->dhandle, 2, true);
}
++*pp;
break;
if (! ISDIGIT (**pp))
{
stab_bad_demangle (orig);
- return FALSE;
+ return false;
}
/* Fall through. */
case '0': case '1': case '2': case '3': case '4':
const char *hold;
if (! stab_demangle_class (minfo, pp, &hold))
- return FALSE;
+ return false;
if (ptype != NULL)
{
char *name;
hold, *pp - hold,
DEBUG_KIND_ILLEGAL);
if (*ptype == DEBUG_TYPE_NULL)
- return FALSE;
+ return false;
}
}
}
if (! stab_demangle_template (minfo, pp,
ptype != NULL ? &name : NULL))
- return FALSE;
+ return false;
if (ptype != NULL)
{
*ptype = stab_find_tagged_type (minfo->dhandle, minfo->info,
DEBUG_KIND_CLASS);
free (name);
if (*ptype == DEBUG_TYPE_NULL)
- return FALSE;
+ return false;
}
}
break;
default:
stab_bad_demangle (orig);
- return FALSE;
+ return false;
}
if (ptype != NULL)
*ptype = debug_make_volatile_type (minfo->dhandle, *ptype);
}
- return TRUE;
+ return true;
}
/* Remember a type string in a demangled string. */
-static bfd_boolean
+static bool
stab_demangle_remember_type (struct stab_demangle_info *minfo,
const char *p, int len)
{
minfo->typestrings[minfo->typestring_count].len = (unsigned int) len;
++minfo->typestring_count;
- return TRUE;
+ return true;
}
\f
/* Demangle names encoded using the g++ V3 ABI. The newer versions of
static debug_type *
stab_demangle_v3_argtypes (void *dhandle, struct stab_handle *info,
- const char *physname, bfd_boolean *pvarargs)
+ const char *physname, bool *pvarargs)
{
struct demangle_component *dc;
void *mem;
static debug_type *
stab_demangle_v3_arglist (void *dhandle, struct stab_handle *info,
struct demangle_component *arglist,
- bfd_boolean *pvarargs)
+ bool *pvarargs)
{
struct demangle_component *dc;
unsigned int alloc, count;
alloc = 10;
pargs = (debug_type *) xmalloc (alloc * sizeof *pargs);
- *pvarargs = FALSE;
+ *pvarargs = false;
count = 0;
dc = dc->u.s_binary.right)
{
debug_type arg;
- bfd_boolean varargs;
+ bool varargs;
if (dc->type != DEMANGLE_COMPONENT_ARGLIST)
{
{
if (varargs)
{
- *pvarargs = TRUE;
+ *pvarargs = true;
continue;
}
free (pargs);
static debug_type
stab_demangle_v3_arg (void *dhandle, struct stab_handle *info,
struct demangle_component *dc, debug_type context,
- bfd_boolean *pvarargs)
+ bool *pvarargs)
{
debug_type dt;
if (pvarargs != NULL)
- *pvarargs = FALSE;
+ *pvarargs = false;
switch (dc->type)
{
case DEMANGLE_COMPONENT_FUNCTION_TYPE:
{
debug_type *pargs;
- bfd_boolean varargs;
+ bool varargs;
if (dc->u.s_binary.left == NULL)
{
/* The mangling is based on the type, but does not itself
indicate what the sizes are. So we have to guess. */
if (strcmp (p, "signed char") == 0)
- ret = debug_make_int_type (dhandle, 1, FALSE);
+ ret = debug_make_int_type (dhandle, 1, false);
else if (strcmp (p, "bool") == 0)
ret = debug_make_bool_type (dhandle, 1);
else if (strcmp (p, "char") == 0)
- ret = debug_make_int_type (dhandle, 1, FALSE);
+ ret = debug_make_int_type (dhandle, 1, false);
else if (strcmp (p, "double") == 0)
ret = debug_make_float_type (dhandle, 8);
else if (strcmp (p, "long double") == 0)
else if (strcmp (p, "__float128") == 0)
ret = debug_make_float_type (dhandle, 16);
else if (strcmp (p, "unsigned char") == 0)
- ret = debug_make_int_type (dhandle, 1, TRUE);
+ ret = debug_make_int_type (dhandle, 1, true);
else if (strcmp (p, "int") == 0)
- ret = debug_make_int_type (dhandle, 4, FALSE);
+ ret = debug_make_int_type (dhandle, 4, false);
else if (strcmp (p, "unsigned int") == 0)
- ret = debug_make_int_type (dhandle, 4, TRUE);
+ ret = debug_make_int_type (dhandle, 4, true);
else if (strcmp (p, "long") == 0)
- ret = debug_make_int_type (dhandle, 4, FALSE);
+ ret = debug_make_int_type (dhandle, 4, false);
else if (strcmp (p, "unsigned long") == 0)
- ret = debug_make_int_type (dhandle, 4, TRUE);
+ ret = debug_make_int_type (dhandle, 4, true);
else if (strcmp (p, "__int128") == 0)
- ret = debug_make_int_type (dhandle, 16, FALSE);
+ ret = debug_make_int_type (dhandle, 16, false);
else if (strcmp (p, "unsigned __int128") == 0)
- ret = debug_make_int_type (dhandle, 16, TRUE);
+ ret = debug_make_int_type (dhandle, 16, true);
else if (strcmp (p, "short") == 0)
- ret = debug_make_int_type (dhandle, 2, FALSE);
+ ret = debug_make_int_type (dhandle, 2, false);
else if (strcmp (p, "unsigned short") == 0)
- ret = debug_make_int_type (dhandle, 2, TRUE);
+ ret = debug_make_int_type (dhandle, 2, true);
else if (strcmp (p, "void") == 0)
ret = debug_make_void_type (dhandle);
else if (strcmp (p, "wchar_t") == 0)
- ret = debug_make_int_type (dhandle, 4, TRUE);
+ ret = debug_make_int_type (dhandle, 4, true);
else if (strcmp (p, "long long") == 0)
- ret = debug_make_int_type (dhandle, 8, FALSE);
+ ret = debug_make_int_type (dhandle, 8, false);
else if (strcmp (p, "unsigned long long") == 0)
- ret = debug_make_int_type (dhandle, 8, TRUE);
+ ret = debug_make_int_type (dhandle, 8, true);
else if (strcmp (p, "...") == 0)
{
if (pvarargs == NULL)
fprintf (stderr, _("Unexpected demangled varargs\n"));
else
- *pvarargs = TRUE;
+ *pvarargs = true;
ret = NULL;
}
else
static int string_min;
/* Whether or not we include all whitespace as a graphic char. */
-static bfd_boolean include_all_whitespace;
+static bool include_all_whitespace;
/* TRUE means print address within file for each string. */
-static bfd_boolean print_addresses;
+static bool print_addresses;
/* TRUE means print filename for each string. */
-static bfd_boolean print_filenames;
+static bool print_filenames;
/* TRUE means for object files scan only the data section. */
-static bfd_boolean datasection_only;
+static bool datasection_only;
/* The BFD object file format. */
static char *target;
{NULL, 0, NULL, 0}
};
-static bfd_boolean strings_file (char *);
+static bool strings_file (char *);
static void print_strings (const char *, FILE *, file_ptr, int, int, char *);
static void usage (FILE *, int) ATTRIBUTE_NORETURN;
\f
{
int optc;
int exit_status = 0;
- bfd_boolean files_given = FALSE;
+ bool files_given = false;
char *s;
int numeric_opt = 0;
expandargv (&argc, &argv);
string_min = 4;
- include_all_whitespace = FALSE;
- print_addresses = FALSE;
- print_filenames = FALSE;
+ include_all_whitespace = false;
+ print_addresses = false;
+ print_filenames = false;
if (DEFAULT_STRINGS_ALL)
- datasection_only = FALSE;
+ datasection_only = false;
else
- datasection_only = TRUE;
+ datasection_only = true;
target = NULL;
encoding = 's';
output_separator = NULL;
switch (optc)
{
case 'a':
- datasection_only = FALSE;
+ datasection_only = false;
break;
case 'd':
- datasection_only = TRUE;
+ datasection_only = true;
break;
case 'f':
- print_filenames = TRUE;
+ print_filenames = true;
break;
case 'H':
break;
case 'w':
- include_all_whitespace = TRUE;
+ include_all_whitespace = true;
break;
case 'o':
- print_addresses = TRUE;
+ print_addresses = true;
address_radix = 8;
break;
case 't':
- print_addresses = TRUE;
+ print_addresses = true;
if (optarg[1] != '\0')
usage (stderr, 1);
switch (optarg[0])
if (optind >= argc)
{
- datasection_only = FALSE;
+ datasection_only = false;
SET_BINARY (fileno (stdin));
print_strings ("{standard input}", stdin, 0, 0, 0, (char *) NULL);
- files_given = TRUE;
+ files_given = true;
}
else
{
for (; optind < argc; ++optind)
{
if (strcmp (argv[optind], "-") == 0)
- datasection_only = FALSE;
+ datasection_only = false;
else
{
- files_given = TRUE;
+ files_given = true;
exit_status |= !strings_file (argv[optind]);
}
}
static void
strings_a_section (bfd *abfd, asection *sect, const char *filename,
- bfd_boolean *got_a_section)
+ bool *got_a_section)
{
bfd_size_type sectsize;
bfd_byte *mem;
return;
}
- *got_a_section = TRUE;
+ *got_a_section = true;
print_strings (filename, NULL, sect->filepos, 0, sectsize, (char *) mem);
free (mem);
}
Return TRUE if successful,
FALSE if not (such as if FILE is not an object file). */
-static bfd_boolean
+static bool
strings_object_file (const char *file)
{
bfd *abfd;
asection *s;
- bfd_boolean got_a_section;
+ bool got_a_section;
abfd = bfd_openr (file, target);
if (abfd == NULL)
/* Treat the file as a non-object file. */
- return FALSE;
+ return false;
/* This call is mainly for its side effect of reading in the sections.
We follow the traditional behavior of `strings' in that we don't
if (!bfd_check_format (abfd, bfd_object))
{
bfd_close (abfd);
- return FALSE;
+ return false;
}
- got_a_section = FALSE;
+ got_a_section = false;
for (s = abfd->sections; s != NULL; s = s->next)
strings_a_section (abfd, s, file, &got_a_section);
if (!bfd_close (abfd))
{
bfd_nonfatal (file);
- return FALSE;
+ return false;
}
return got_a_section;
/* Print the strings in FILE. Return TRUE if ok, FALSE if an error occurs. */
-static bfd_boolean
+static bool
strings_file (char *file)
{
struct stat st;
else
non_fatal (_("Warning: could not locate '%s'. reason: %s"),
file, strerror (errno));
- return FALSE;
+ return false;
}
else if (S_ISDIR (st.st_mode))
{
non_fatal (_("Warning: '%s' is a directory"), file);
- return FALSE;
+ return false;
}
/* If we weren't told to scan the whole file,
{
fprintf (stderr, "%s: ", program_name);
perror (file);
- return FALSE;
+ return false;
}
print_strings (file, stream, (file_ptr) 0, 0, 0, (char *) 0);
{
fprintf (stderr, "%s: ", program_name);
perror (file);
- return FALSE;
+ return false;
}
}
- return TRUE;
+ return true;
}
\f
/* Read the next character, return EOF if none available.
#define HOST_WIDEST_INT long
#endif
+#define POISON_BFD_BOOLEAN 1
+
#endif /* _BIN_SYSDEP_H */
};
#define BIN_TOOLBAR_SIZE 12
-extern bfd_boolean target_is_bigendian;
+extern bool target_is_bigendian;
typedef struct windres_bfd
{
struct bin_messagetable_item *res;
} mc_msg_item;
-bfd_boolean target_is_bigendian = 0;
+bool target_is_bigendian = 0;
const char *def_target_arch;
/* Globals and static variable definitions. */
void mc_set_content (const unichar *);
/* Lexer control variables. Used by mcparser.y file. */
-extern bfd_boolean mclex_want_nl;
-extern bfd_boolean mclex_want_line;
-extern bfd_boolean mclex_want_filename;
+extern bool mclex_want_nl;
+extern bool mclex_want_line;
+extern bool mclex_want_filename;
void mc_fatal (const char *, ...);
void mc_warn (const char *, ...);
int verbose = 0;
-bfd_boolean target_is_bigendian = 0;
+bool target_is_bigendian = 0;
const char *def_target_arch;
static void set_endianness (bfd *, const char *);
#if defined (_WIN32) && !defined (__CYGWIN__)
/* For Windows shells, quote "like this". */
{
- bfd_boolean quoted = FALSE;
+ bool quoted = false;
dest = buf;
if (strchr (string, ' '))
{
- quoted = TRUE;
+ quoted = true;
*dest++ = '"';
}
{
rc_uint_type ret = 0;
#if defined (_WIN32) || defined (__CYGWIN__)
- WINBOOL used_def = FALSE;
+ WINBOOL used_def = false;
ret = (rc_uint_type) WideCharToMultiByte (cp, 0, u, -1, mb, mb_len,
NULL, & used_def);
/* The size of the type. */
unsigned int size;
/* Whether type string defines a new type. */
- bfd_boolean definition;
+ bool definition;
/* String defining struct fields. */
char *fields;
/* NULL terminated array of strings defining base classes for a
static struct bfd_hash_entry *string_hash_newfunc
(struct bfd_hash_entry *, struct bfd_hash_table *, const char *);
-static bfd_boolean stab_write_symbol
+static bool stab_write_symbol
(struct stab_write_handle *, int, int, bfd_vma, const char *);
-static bfd_boolean stab_push_string
- (struct stab_write_handle *, const char *, long, bfd_boolean, unsigned int);
-static bfd_boolean stab_push_defined_type
+static bool stab_push_string
+ (struct stab_write_handle *, const char *, long, bool, unsigned int);
+static bool stab_push_defined_type
(struct stab_write_handle *, long, unsigned int);
static char *stab_pop_type (struct stab_write_handle *);
-static bfd_boolean stab_modify_type
+static bool stab_modify_type
(struct stab_write_handle *, int, unsigned int, long **, size_t *);
static long stab_get_struct_index
(struct stab_write_handle *, const char *, unsigned int,
enum debug_type_kind, unsigned int *);
-static bfd_boolean stab_class_method_var
+static bool stab_class_method_var
(struct stab_write_handle *, const char *, enum debug_visibility,
- bfd_boolean, bfd_boolean, bfd_boolean, bfd_vma, bfd_boolean);
-static bfd_boolean stab_start_compilation_unit (void *, const char *);
-static bfd_boolean stab_start_source (void *, const char *);
-static bfd_boolean stab_empty_type (void *);
-static bfd_boolean stab_void_type (void *);
-static bfd_boolean stab_int_type (void *, unsigned int, bfd_boolean);
-static bfd_boolean stab_float_type (void *, unsigned int);
-static bfd_boolean stab_complex_type (void *, unsigned int);
-static bfd_boolean stab_bool_type (void *, unsigned int);
-static bfd_boolean stab_enum_type
+ bool, bool, bool, bfd_vma, bool);
+static bool stab_start_compilation_unit (void *, const char *);
+static bool stab_start_source (void *, const char *);
+static bool stab_empty_type (void *);
+static bool stab_void_type (void *);
+static bool stab_int_type (void *, unsigned int, bool);
+static bool stab_float_type (void *, unsigned int);
+static bool stab_complex_type (void *, unsigned int);
+static bool stab_bool_type (void *, unsigned int);
+static bool stab_enum_type
(void *, const char *, const char **, bfd_signed_vma *);
-static bfd_boolean stab_pointer_type (void *);
-static bfd_boolean stab_function_type (void *, int, bfd_boolean);
-static bfd_boolean stab_reference_type (void *);
-static bfd_boolean stab_range_type (void *, bfd_signed_vma, bfd_signed_vma);
-static bfd_boolean stab_array_type
- (void *, bfd_signed_vma, bfd_signed_vma, bfd_boolean);
-static bfd_boolean stab_set_type (void *, bfd_boolean);
-static bfd_boolean stab_offset_type (void *);
-static bfd_boolean stab_method_type (void *, bfd_boolean, int, bfd_boolean);
-static bfd_boolean stab_const_type (void *);
-static bfd_boolean stab_volatile_type (void *);
-static bfd_boolean stab_start_struct_type
- (void *, const char *, unsigned int, bfd_boolean, unsigned int);
-static bfd_boolean stab_struct_field
+static bool stab_pointer_type (void *);
+static bool stab_function_type (void *, int, bool);
+static bool stab_reference_type (void *);
+static bool stab_range_type (void *, bfd_signed_vma, bfd_signed_vma);
+static bool stab_array_type
+ (void *, bfd_signed_vma, bfd_signed_vma, bool);
+static bool stab_set_type (void *, bool);
+static bool stab_offset_type (void *);
+static bool stab_method_type (void *, bool, int, bool);
+static bool stab_const_type (void *);
+static bool stab_volatile_type (void *);
+static bool stab_start_struct_type
+ (void *, const char *, unsigned int, bool, unsigned int);
+static bool stab_struct_field
(void *, const char *, bfd_vma, bfd_vma, enum debug_visibility);
-static bfd_boolean stab_end_struct_type (void *);
-static bfd_boolean stab_start_class_type
- (void *, const char *, unsigned int, bfd_boolean, unsigned int,
- bfd_boolean, bfd_boolean);
-static bfd_boolean stab_class_static_member
+static bool stab_end_struct_type (void *);
+static bool stab_start_class_type
+ (void *, const char *, unsigned int, bool, unsigned int,
+ bool, bool);
+static bool stab_class_static_member
(void *, const char *, const char *, enum debug_visibility);
-static bfd_boolean stab_class_baseclass
- (void *, bfd_vma, bfd_boolean, enum debug_visibility);
-static bfd_boolean stab_class_start_method (void *, const char *);
-static bfd_boolean stab_class_method_variant
- (void *, const char *, enum debug_visibility, bfd_boolean, bfd_boolean,
- bfd_vma, bfd_boolean);
-static bfd_boolean stab_class_static_method_variant
- (void *, const char *, enum debug_visibility, bfd_boolean, bfd_boolean);
-static bfd_boolean stab_class_end_method (void *);
-static bfd_boolean stab_end_class_type (void *);
-static bfd_boolean stab_typedef_type (void *, const char *);
-static bfd_boolean stab_tag_type
+static bool stab_class_baseclass
+ (void *, bfd_vma, bool, enum debug_visibility);
+static bool stab_class_start_method (void *, const char *);
+static bool stab_class_method_variant
+ (void *, const char *, enum debug_visibility, bool, bool,
+ bfd_vma, bool);
+static bool stab_class_static_method_variant
+ (void *, const char *, enum debug_visibility, bool, bool);
+static bool stab_class_end_method (void *);
+static bool stab_end_class_type (void *);
+static bool stab_typedef_type (void *, const char *);
+static bool stab_tag_type
(void *, const char *, unsigned int, enum debug_type_kind);
-static bfd_boolean stab_typdef (void *, const char *);
-static bfd_boolean stab_tag (void *, const char *);
-static bfd_boolean stab_int_constant (void *, const char *, bfd_vma);
-static bfd_boolean stab_float_constant (void *, const char *, double);
-static bfd_boolean stab_typed_constant (void *, const char *, bfd_vma);
-static bfd_boolean stab_variable
+static bool stab_typdef (void *, const char *);
+static bool stab_tag (void *, const char *);
+static bool stab_int_constant (void *, const char *, bfd_vma);
+static bool stab_float_constant (void *, const char *, double);
+static bool stab_typed_constant (void *, const char *, bfd_vma);
+static bool stab_variable
(void *, const char *, enum debug_var_kind, bfd_vma);
-static bfd_boolean stab_start_function (void *, const char *, bfd_boolean);
-static bfd_boolean stab_function_parameter
+static bool stab_start_function (void *, const char *, bool);
+static bool stab_function_parameter
(void *, const char *, enum debug_parm_kind, bfd_vma);
-static bfd_boolean stab_start_block (void *, bfd_vma);
-static bfd_boolean stab_end_block (void *, bfd_vma);
-static bfd_boolean stab_end_function (void *);
-static bfd_boolean stab_lineno (void *, const char *, unsigned long, bfd_vma);
+static bool stab_start_block (void *, bfd_vma);
+static bool stab_end_block (void *, bfd_vma);
+static bool stab_end_function (void *);
+static bool stab_lineno (void *, const char *, unsigned long, bfd_vma);
static const struct debug_write_fns stab_fns =
{
/* Add a symbol to the stabs debugging information we are building. */
-static bfd_boolean
+static bool
stab_write_symbol (struct stab_write_handle *info, int type, int desc,
bfd_vma value, const char *string)
{
{
struct string_hash_entry *h;
- h = string_hash_lookup (&info->strhash, string, TRUE, TRUE);
+ h = string_hash_lookup (&info->strhash, string, true, true);
if (h == NULL)
{
non_fatal (_("string_hash_lookup failed: %s"),
bfd_errmsg (bfd_get_error ()));
- return FALSE;
+ return false;
}
if (h->index != -1)
strx = h->index;
info->symbols_size += STAB_SYMBOL_SIZE;
- return TRUE;
+ return true;
}
/* Push a string on to the type stack. */
-static bfd_boolean
+static bool
stab_push_string (struct stab_write_handle *info, const char *string,
- long tindex, bfd_boolean definition, unsigned int size)
+ long tindex, bool definition, unsigned int size)
{
struct stab_type_stack *s;
s->next = info->type_stack;
info->type_stack = s;
- return TRUE;
+ return true;
}
/* Push a type index which has already been defined. */
-static bfd_boolean
+static bool
stab_push_defined_type (struct stab_write_handle *info, long tindex,
unsigned int size)
{
char buf[20];
sprintf (buf, "%ld", tindex);
- return stab_push_string (info, buf, tindex, FALSE, size);
+ return stab_push_string (info, buf, tindex, false, size);
}
/* Pop a type off the type stack. The caller is responsible for
the symbols, *PSYMSIZE the size of the symbols, *PSTRINGS to the
strings, and *PSTRINGSIZE to the size of the strings. */
-bfd_boolean
+bool
write_stabs_in_sections_debugging_info (bfd *abfd, void *dhandle,
bfd_byte **psyms,
bfd_size_type *psymsize,
{
non_fatal ("bfd_hash_table_init_failed: %s",
bfd_errmsg (bfd_get_error ()));
- return FALSE;
+ return false;
}
info.type_stack = NULL;
/* The initial symbol holds the string size. */
if (! stab_write_symbol (&info, 0, 0, 0, (const char *) NULL))
- return FALSE;
+ return false;
/* Output an initial N_SO symbol. */
info.so_offset = info.symbols_size;
if (! stab_write_symbol (&info, N_SO, 0, 0, bfd_get_filename (abfd)))
- return FALSE;
+ return false;
if (! debug_write (dhandle, &stab_fns, (void *) &info))
- return FALSE;
+ return false;
if (info.pending_lbrac != (bfd_vma) -1)
- return FALSE;
+ return false;
/* Output a trailing N_SO. */
if (! stab_write_symbol (&info, N_SO, 0, info.last_text_address,
(const char *) NULL))
- return FALSE;
+ return false;
/* Put the string size in the initial symbol. */
bfd_put_32 (abfd, info.strings_size, info.symbols + 8);
p += strlen ((char *) p) + 1;
}
- return TRUE;
+ return true;
}
/* Start writing out information for a compilation unit. */
-static bfd_boolean
+static bool
stab_start_compilation_unit (void *p, const char *filename)
{
struct stab_write_handle *info = (struct stab_write_handle *) p;
/* Start writing out information for a particular source file. */
-static bfd_boolean
+static bool
stab_start_source (void *p, const char *filename)
{
struct stab_write_handle *info = (struct stab_write_handle *) p;
/* Push an empty type. This shouldn't normally happen. We just use a
void type. */
-static bfd_boolean
+static bool
stab_empty_type (void *p)
{
struct stab_write_handle *info = (struct stab_write_handle *) p;
sprintf (buf, "%ld=%ld", tindex, tindex);
- return stab_push_string (info, buf, tindex, FALSE, 0);
+ return stab_push_string (info, buf, tindex, false, 0);
}
}
/* Push a void type. */
-static bfd_boolean
+static bool
stab_void_type (void *p)
{
struct stab_write_handle *info = (struct stab_write_handle *) p;
sprintf (buf, "%ld=%ld", tindex, tindex);
- return stab_push_string (info, buf, tindex, TRUE, 0);
+ return stab_push_string (info, buf, tindex, true, 0);
}
}
/* Push an integer type. */
-static bfd_boolean
-stab_int_type (void *p, unsigned int size, bfd_boolean unsignedp)
+static bool
+stab_int_type (void *p, unsigned int size, bool unsignedp)
{
struct stab_write_handle *info = (struct stab_write_handle *) p;
long *cache;
if (size <= 0 || (size > sizeof (long) && size != 8))
{
non_fatal (_("stab_int_type: bad size %u"), size);
- return FALSE;
+ return false;
}
if (unsignedp)
abort ();
}
- return stab_push_string (info, buf, tindex, TRUE, size);
+ return stab_push_string (info, buf, tindex, true, size);
}
}
/* Push a floating point type. */
-static bfd_boolean
+static bool
stab_float_type (void *p, unsigned int size)
{
struct stab_write_handle *info = (struct stab_write_handle *) p;
char buf[50];
/* Floats are defined as a subrange of int. */
- if (! stab_int_type (info, 4, FALSE))
- return FALSE;
+ if (! stab_int_type (info, 4, false))
+ return false;
int_type = stab_pop_type (info);
tindex = info->type_index;
free (int_type);
- return stab_push_string (info, buf, tindex, TRUE, size);
+ return stab_push_string (info, buf, tindex, true, size);
}
}
/* Push a complex type. */
-static bfd_boolean
+static bool
stab_complex_type (void *p, unsigned int size)
{
struct stab_write_handle *info = (struct stab_write_handle *) p;
sprintf (buf, "%ld=r%ld;%u;0;", tindex, tindex, size);
- return stab_push_string (info, buf, tindex, TRUE, size * 2);
+ return stab_push_string (info, buf, tindex, true, size * 2);
}
-/* Push a bfd_boolean type. We use an XCOFF predefined type, since gdb
+/* Push a bool type. We use an XCOFF predefined type, since gdb
always recognizes them. */
-static bfd_boolean
+static bool
stab_bool_type (void *p, unsigned int size)
{
struct stab_write_handle *info = (struct stab_write_handle *) p;
/* Push an enum type. */
-static bfd_boolean
+static bool
stab_enum_type (void *p, const char *tag, const char **names,
bfd_signed_vma *vals)
{
if (names == NULL)
{
if (tag == NULL)
- return FALSE;
+ return false;
buf = (char *) xmalloc (10 + strlen (tag));
sprintf (buf, "xe%s:", tag);
/* FIXME: The size is just a guess. */
- if (! stab_push_string (info, buf, 0, FALSE, 4))
- return FALSE;
+ if (! stab_push_string (info, buf, 0, false, 4))
+ return false;
free (buf);
- return TRUE;
+ return true;
}
len = 10;
if (tag == NULL)
{
/* FIXME: The size is just a guess. */
- if (! stab_push_string (info, buf, 0, FALSE, 4))
- return FALSE;
+ if (! stab_push_string (info, buf, 0, false, 4))
+ return false;
}
else
{
/* FIXME: The size is just a guess. */
if (! stab_write_symbol (info, N_LSYM, 0, 0, buf)
|| ! stab_push_defined_type (info, tindex, 4))
- return FALSE;
+ return false;
}
free (buf);
- return TRUE;
+ return true;
}
/* Push a modification of the top type on the stack. Cache the
results in CACHE and CACHE_ALLOC. */
-static bfd_boolean
+static bool
stab_modify_type (struct stab_write_handle *info, int mod,
unsigned int size, long **cache, size_t *cache_alloc)
{
char *s, *buf;
if (info->type_stack == NULL)
- return FALSE;
+ return false;
targindex = info->type_stack->index;
if (targindex <= 0
|| cache == NULL)
{
- bfd_boolean definition;
+ bool definition;
/* Either the target type has no index, or we aren't caching
this modifier. Either way we have no way of recording the
sprintf (buf, "%c%s", mod, s);
free (s);
if (! stab_push_string (info, buf, 0, definition, size))
- return FALSE;
+ return false;
free (buf);
}
else
referenced). */
free (stab_pop_type (info));
if (! stab_push_defined_type (info, tindex, size))
- return FALSE;
+ return false;
}
else
{
(*cache)[targindex] = tindex;
- if (! stab_push_string (info, buf, tindex, TRUE, size))
- return FALSE;
+ if (! stab_push_string (info, buf, tindex, true, size))
+ return false;
free (buf);
}
}
- return TRUE;
+ return true;
}
/* Push a pointer type. */
-static bfd_boolean
+static bool
stab_pointer_type (void *p)
{
struct stab_write_handle *info = (struct stab_write_handle *) p;
/* Push a function type. */
-static bfd_boolean
+static bool
stab_function_type (void *p, int argcount,
- bfd_boolean varargs ATTRIBUTE_UNUSED)
+ bool varargs ATTRIBUTE_UNUSED)
{
struct stab_write_handle *info = (struct stab_write_handle *) p;
int i;
free (s);
if (! stab_write_symbol (info, N_LSYM, 0, 0, buf))
- return FALSE;
+ return false;
free (buf);
}
/* Push a reference type. */
-static bfd_boolean
+static bool
stab_reference_type (void *p)
{
struct stab_write_handle *info = (struct stab_write_handle *) p;
/* Push a range type. */
-static bfd_boolean
+static bool
stab_range_type (void *p, bfd_signed_vma low, bfd_signed_vma high)
{
struct stab_write_handle *info = (struct stab_write_handle *) p;
- bfd_boolean definition;
+ bool definition;
unsigned int size;
char *s, *buf;
free (s);
if (! stab_push_string (info, buf, 0, definition, size))
- return FALSE;
+ return false;
free (buf);
- return TRUE;
+ return true;
}
/* Push an array type. */
-static bfd_boolean
+static bool
stab_array_type (void *p, bfd_signed_vma low, bfd_signed_vma high,
- bfd_boolean stringp)
+ bool stringp)
{
struct stab_write_handle *info = (struct stab_write_handle *) p;
- bfd_boolean definition;
+ bool definition;
unsigned int element_size;
char *range, *element, *buf;
long tindex;
attribute. */
tindex = info->type_index;
++info->type_index;
- definition = TRUE;
+ definition = true;
sprintf (buf, "%ld=@S;", tindex);
}
else
size = element_size * ((high - low) + 1);
if (! stab_push_string (info, buf, tindex, definition, size))
- return FALSE;
+ return false;
free (buf);
- return TRUE;
+ return true;
}
/* Push a set type. */
-static bfd_boolean
-stab_set_type (void *p, bfd_boolean bitstringp)
+static bool
+stab_set_type (void *p, bool bitstringp)
{
struct stab_write_handle *info = (struct stab_write_handle *) p;
- bfd_boolean definition;
+ bool definition;
char *s, *buf;
long tindex;
attribute. */
tindex = info->type_index;
++info->type_index;
- definition = TRUE;
+ definition = true;
sprintf (buf, "%ld=@S;", tindex);
}
free (s);
if (! stab_push_string (info, buf, tindex, definition, 0))
- return FALSE;
+ return false;
free (buf);
- return TRUE;
+ return true;
}
/* Push an offset type. */
-static bfd_boolean
+static bool
stab_offset_type (void *p)
{
struct stab_write_handle *info = (struct stab_write_handle *) p;
- bfd_boolean definition;
+ bool definition;
char *target, *base, *buf;
definition = info->type_stack->definition;
free (target);
if (! stab_push_string (info, buf, 0, definition, 0))
- return FALSE;
+ return false;
free (buf);
- return TRUE;
+ return true;
}
/* Push a method type. */
-static bfd_boolean
-stab_method_type (void *p, bfd_boolean domainp, int argcount,
- bfd_boolean varargs)
+static bool
+stab_method_type (void *p, bool domainp, int argcount,
+ bool varargs)
{
struct stab_write_handle *info = (struct stab_write_handle *) p;
- bfd_boolean definition;
+ bool definition;
char *domain, *return_type, *buf;
char **args;
int i;
if (! domainp)
{
if (! stab_empty_type (p))
- return FALSE;
+ return false;
}
definition = info->type_stack->definition;
{
args = (char **) xmalloc (1 * sizeof (*args));
if (! stab_empty_type (p))
- return FALSE;
+ return false;
definition = definition || info->type_stack->definition;
args[0] = stab_pop_type (info);
argcount = 1;
if (! varargs)
{
if (! stab_empty_type (p))
- return FALSE;
+ return false;
definition = definition || info->type_stack->definition;
args[argcount] = stab_pop_type (info);
++argcount;
free (args);
if (! stab_push_string (info, buf, 0, definition, 0))
- return FALSE;
+ return false;
free (buf);
- return TRUE;
+ return true;
}
/* Push a const version of a type. */
-static bfd_boolean
+static bool
stab_const_type (void *p)
{
struct stab_write_handle *info = (struct stab_write_handle *) p;
/* Push a volatile version of a type. */
-static bfd_boolean
+static bool
stab_volatile_type (void *p)
{
struct stab_write_handle *info = (struct stab_write_handle *) p;
/* Start outputting a struct. We ignore the tag, and handle it in
stab_tag. */
-static bfd_boolean
+static bool
stab_start_struct_type (void *p, const char *tag, unsigned int id,
- bfd_boolean structp, unsigned int size)
+ bool structp, unsigned int size)
{
struct stab_write_handle *info = (struct stab_write_handle *) p;
long tindex;
- bfd_boolean definition;
+ bool definition;
char buf[40];
if (id == 0)
{
tindex = 0;
*buf = '\0';
- definition = FALSE;
+ definition = false;
}
else
{
tindex = stab_get_struct_index (info, tag, id, DEBUG_KIND_ILLEGAL,
&size);
if (tindex < 0)
- return FALSE;
+ return false;
sprintf (buf, "%ld=", tindex);
- definition = TRUE;
+ definition = true;
}
sprintf (buf + strlen (buf), "%c%u",
size);
if (! stab_push_string (info, buf, tindex, definition, size))
- return FALSE;
+ return false;
info->type_stack->fields = (char *) xmalloc (1);
info->type_stack->fields[0] = '\0';
- return TRUE;
+ return true;
}
/* Add a field to a struct. */
-static bfd_boolean
+static bool
stab_struct_field (void *p, const char *name, bfd_vma bitpos,
bfd_vma bitsize, enum debug_visibility visibility)
{
struct stab_write_handle *info = (struct stab_write_handle *) p;
- bfd_boolean definition;
+ bool definition;
unsigned int size;
char *s, *n;
const char *vis;
/* Add this field to the end of the current struct fields, which is
currently on the top of the stack. */
if (info->type_stack->fields == NULL)
- return FALSE;
+ return false;
n = (char *) xmalloc (strlen (info->type_stack->fields)
+ strlen (name)
info->type_stack->fields = n;
if (definition)
- info->type_stack->definition = TRUE;
+ info->type_stack->definition = true;
- return TRUE;
+ return true;
}
/* Finish up a struct. */
-static bfd_boolean
+static bool
stab_end_struct_type (void *p)
{
struct stab_write_handle *info = (struct stab_write_handle *) p;
- bfd_boolean definition;
+ bool definition;
long tindex;
unsigned int size;
char *fields, *first, *buf;
if (info->type_stack == NULL || info->type_stack->fields == NULL)
- return FALSE;
+ return false;
definition = info->type_stack->definition;
tindex = info->type_stack->index;
free (fields);
if (! stab_push_string (info, buf, tindex, definition, size))
- return FALSE;
+ return false;
free (buf);
- return TRUE;
+ return true;
}
/* Start outputting a class. */
-static bfd_boolean
+static bool
stab_start_class_type (void *p, const char *tag, unsigned int id,
- bfd_boolean structp, unsigned int size,
- bfd_boolean vptr, bfd_boolean ownvptr)
+ bool structp, unsigned int size,
+ bool vptr, bool ownvptr)
{
struct stab_write_handle *info = (struct stab_write_handle *) p;
- bfd_boolean definition = FALSE;
+ bool definition = false;
char *vstring = NULL;
if (vptr && !ownvptr)
}
if (! stab_start_struct_type (p, tag, id, structp, size))
- return FALSE;
+ return false;
if (vptr)
{
if (ownvptr)
{
if (info->type_stack->index < 1)
- return FALSE;
+ return false;
vtable = (char *) xmalloc (20);
sprintf (vtable, "~%%%ld", info->type_stack->index);
}
else
{
if (vstring == NULL)
- return FALSE;
+ return false;
vtable = (char *) xmalloc (strlen (vstring) + 3);
sprintf (vtable, "~%%%s", vstring);
free (vstring);
if (definition)
- info->type_stack->definition = TRUE;
+ info->type_stack->definition = true;
}
info->type_stack->vtable = vtable;
}
- return TRUE;
+ return true;
}
/* Add a static member to the class on the type stack. */
-static bfd_boolean
+static bool
stab_class_static_member (void *p, const char *name, const char *physname,
enum debug_visibility visibility)
{
struct stab_write_handle *info = (struct stab_write_handle *) p;
- bfd_boolean definition;
+ bool definition;
char *s, *n;
const char *vis;
currently on the top of the stack. */
if (info->type_stack->fields == NULL)
- return FALSE;
+ return false;
n = (char *) xmalloc (strlen (info->type_stack->fields)
+ strlen (name)
+ strlen (s)
info->type_stack->fields = n;
if (definition)
- info->type_stack->definition = TRUE;
+ info->type_stack->definition = true;
- return TRUE;
+ return true;
}
/* Add a base class to the class on the type stack. */
-static bfd_boolean
-stab_class_baseclass (void *p, bfd_vma bitpos, bfd_boolean is_virtual,
+static bool
+stab_class_baseclass (void *p, bfd_vma bitpos, bool is_virtual,
enum debug_visibility visibility)
{
struct stab_write_handle *info = (struct stab_write_handle *) p;
- bfd_boolean definition;
+ bool definition;
char *s;
char *buf;
unsigned int c;
/* Add the new baseclass to the existing ones. */
if (info->type_stack == NULL || info->type_stack->fields == NULL)
- return FALSE;
+ return false;
if (info->type_stack->baseclasses == NULL)
c = 0;
info->type_stack->baseclasses = baseclasses;
if (definition)
- info->type_stack->definition = TRUE;
+ info->type_stack->definition = true;
- return TRUE;
+ return true;
}
/* Start adding a method to the class on the type stack. */
-static bfd_boolean
+static bool
stab_class_start_method (void *p, const char *name)
{
struct stab_write_handle *info = (struct stab_write_handle *) p;
char *m;
if (info->type_stack == NULL || info->type_stack->fields == NULL)
- return FALSE;
+ return false;
if (info->type_stack->methods == NULL)
{
info->type_stack->methods = m;
- return TRUE;
+ return true;
}
/* Add a variant, either static or not, to the current method. */
-static bfd_boolean
+static bool
stab_class_method_var (struct stab_write_handle *info, const char *physname,
enum debug_visibility visibility,
- bfd_boolean staticp, bfd_boolean constp,
- bfd_boolean volatilep, bfd_vma voffset,
- bfd_boolean contextp)
+ bool staticp, bool constp,
+ bool volatilep, bfd_vma voffset,
+ bool contextp)
{
- bfd_boolean definition;
+ bool definition;
char *type;
char *context = NULL;
char visc, qualc, typec;
}
if (info->type_stack == NULL || info->type_stack->methods == NULL)
- return FALSE;
+ return false;
switch (visibility)
{
}
if (definition)
- info->type_stack->definition = TRUE;
+ info->type_stack->definition = true;
- return TRUE;
+ return true;
}
/* Add a variant to the current method. */
-static bfd_boolean
+static bool
stab_class_method_variant (void *p, const char *physname,
enum debug_visibility visibility,
- bfd_boolean constp, bfd_boolean volatilep,
- bfd_vma voffset, bfd_boolean contextp)
+ bool constp, bool volatilep,
+ bfd_vma voffset, bool contextp)
{
struct stab_write_handle *info = (struct stab_write_handle *) p;
- return stab_class_method_var (info, physname, visibility, FALSE, constp,
+ return stab_class_method_var (info, physname, visibility, false, constp,
volatilep, voffset, contextp);
}
/* Add a static variant to the current method. */
-static bfd_boolean
+static bool
stab_class_static_method_variant (void *p, const char *physname,
enum debug_visibility visibility,
- bfd_boolean constp, bfd_boolean volatilep)
+ bool constp, bool volatilep)
{
struct stab_write_handle *info = (struct stab_write_handle *) p;
- return stab_class_method_var (info, physname, visibility, TRUE, constp,
- volatilep, 0, FALSE);
+ return stab_class_method_var (info, physname, visibility, true, constp,
+ volatilep, 0, false);
}
/* Finish up a method. */
-static bfd_boolean
+static bool
stab_class_end_method (void *p)
{
struct stab_write_handle *info = (struct stab_write_handle *) p;
if (info->type_stack == NULL || info->type_stack->methods == NULL)
- return FALSE;
+ return false;
/* We allocated enough room on info->type_stack->methods to add the
trailing semicolon. */
strcat (info->type_stack->methods, ";");
- return TRUE;
+ return true;
}
/* Finish up a class. */
-static bfd_boolean
+static bool
stab_end_class_type (void *p)
{
struct stab_write_handle *info = (struct stab_write_handle *) p;
if (info->type_stack == NULL
|| info->type_stack->string == NULL
|| info->type_stack->fields == NULL)
- return FALSE;
+ return false;
/* Work out the size we need to allocate for the class definition. */
free (info->type_stack->string);
info->type_stack->string = buf;
- return TRUE;
+ return true;
}
/* Push a typedef which was previously defined. */
-static bfd_boolean
+static bool
stab_typedef_type (void *p, const char *name)
{
struct stab_write_handle *info = (struct stab_write_handle *) p;
struct string_hash_entry *h;
- h = string_hash_lookup (&info->typedef_hash, name, FALSE, FALSE);
+ h = string_hash_lookup (&info->typedef_hash, name, false, false);
if (h == NULL || h->index < 1)
- return FALSE;
+ return false;
return stab_push_defined_type (info, h->index, h->size);
}
/* Push a struct, union or class tag. */
-static bfd_boolean
+static bool
stab_tag_type (void *p, const char *name, unsigned int id,
enum debug_type_kind kind)
{
tindex = stab_get_struct_index (info, name, id, kind, &size);
if (tindex < 0)
- return FALSE;
+ return false;
return stab_push_defined_type (info, tindex, size);
}
/* Define a typedef. */
-static bfd_boolean
+static bool
stab_typdef (void *p, const char *name)
{
struct stab_write_handle *info = (struct stab_write_handle *) p;
free (s);
if (! stab_write_symbol (info, N_LSYM, 0, 0, buf))
- return FALSE;
+ return false;
free (buf);
- h = string_hash_lookup (&info->typedef_hash, name, TRUE, FALSE);
+ h = string_hash_lookup (&info->typedef_hash, name, true, false);
if (h == NULL)
{
non_fatal (_("string_hash_lookup failed: %s"),
bfd_errmsg (bfd_get_error ()));
- return FALSE;
+ return false;
}
/* I don't think we care about redefinitions. */
h->index = tindex;
h->size = size;
- return TRUE;
+ return true;
}
/* Define a tag. */
-static bfd_boolean
+static bool
stab_tag (void *p, const char *tag)
{
struct stab_write_handle *info = (struct stab_write_handle *) p;
free (s);
if (! stab_write_symbol (info, N_LSYM, 0, 0, buf))
- return FALSE;
+ return false;
free (buf);
- return TRUE;
+ return true;
}
/* Define an integer constant. */
-static bfd_boolean
+static bool
stab_int_constant (void *p, const char *name, bfd_vma val)
{
struct stab_write_handle *info = (struct stab_write_handle *) p;
sprintf (buf, "%s:c=i%ld", name, (long) val);
if (! stab_write_symbol (info, N_LSYM, 0, 0, buf))
- return FALSE;
+ return false;
free (buf);
- return TRUE;
+ return true;
}
/* Define a floating point constant. */
-static bfd_boolean
+static bool
stab_float_constant (void *p, const char *name, double val)
{
struct stab_write_handle *info = (struct stab_write_handle *) p;
sprintf (buf, "%s:c=f%g", name, val);
if (! stab_write_symbol (info, N_LSYM, 0, 0, buf))
- return FALSE;
+ return false;
free (buf);
- return TRUE;
+ return true;
}
/* Define a typed constant. */
-static bfd_boolean
+static bool
stab_typed_constant (void *p, const char *name, bfd_vma val)
{
struct stab_write_handle *info = (struct stab_write_handle *) p;
free (s);
if (! stab_write_symbol (info, N_LSYM, 0, 0, buf))
- return FALSE;
+ return false;
free (buf);
- return TRUE;
+ return true;
}
/* Record a variable. */
-static bfd_boolean
+static bool
stab_variable (void *p, const char *name, enum debug_var_kind kind,
bfd_vma val)
{
free (s);
if (! stab_write_symbol (info, stab_type, 0, val, buf))
- return FALSE;
+ return false;
free (buf);
- return TRUE;
+ return true;
}
/* Start outputting a function. */
-static bfd_boolean
-stab_start_function (void *p, const char *name, bfd_boolean globalp)
+static bool
+stab_start_function (void *p, const char *name, bool globalp)
{
struct stab_write_handle *info = (struct stab_write_handle *) p;
char *rettype, *buf;
if (info->nesting != 0 || info->fun_offset != -1)
- return FALSE;
+ return false;
rettype = stab_pop_type (info);
info->fun_offset = info->symbols_size;
if (! stab_write_symbol (info, N_FUN, 0, 0, buf))
- return FALSE;
+ return false;
free (buf);
- return TRUE;
+ return true;
}
/* Output a function parameter. */
-static bfd_boolean
+static bool
stab_function_parameter (void *p, const char *name, enum debug_parm_kind kind, bfd_vma val)
{
struct stab_write_handle *info = (struct stab_write_handle *) p;
free (s);
if (! stab_write_symbol (info, stab_type, 0, val, buf))
- return FALSE;
+ return false;
free (buf);
- return TRUE;
+ return true;
}
/* Start a block. */
-static bfd_boolean
+static bool
stab_start_block (void *p, bfd_vma addr)
{
struct stab_write_handle *info = (struct stab_write_handle *) p;
if (info->nesting == 1)
{
info->fnaddr = addr;
- return TRUE;
+ return true;
}
/* We have to output the LBRAC symbol after any variables which are
{
if (! stab_write_symbol (info, N_LBRAC, 0, info->pending_lbrac,
(const char *) NULL))
- return FALSE;
+ return false;
}
/* Remember the address and output it later. */
info->pending_lbrac = addr - info->fnaddr;
- return TRUE;
+ return true;
}
/* End a block. */
-static bfd_boolean
+static bool
stab_end_block (void *p, bfd_vma addr)
{
struct stab_write_handle *info = (struct stab_write_handle *) p;
{
if (! stab_write_symbol (info, N_LBRAC, 0, info->pending_lbrac,
(const char *) NULL))
- return FALSE;
+ return false;
info->pending_lbrac = (bfd_vma) -1;
}
if (info->nesting < 1)
- return FALSE;
+ return false;
--info->nesting;
/* We ignore the outermost block. */
if (info->nesting == 0)
- return TRUE;
+ return true;
return stab_write_symbol (info, N_RBRAC, 0, addr - info->fnaddr,
(const char *) NULL);
/* End a function. */
-static bfd_boolean
+static bool
stab_end_function (void *p ATTRIBUTE_UNUSED)
{
- return TRUE;
+ return true;
}
/* Output a line number. */
-static bfd_boolean
+static bool
stab_lineno (void *p, const char *file, unsigned long lineno, bfd_vma addr)
{
struct stab_write_handle *info = (struct stab_write_handle *) p;
if (info->lineno_filename == NULL)
- return FALSE;
+ return false;
if (addr > info->last_text_address)
info->last_text_address = addr;
if (filename_cmp (file, info->lineno_filename) != 0)
{
if (! stab_write_symbol (info, N_SOL, 0, addr, file))
- return FALSE;
+ return false;
info->lineno_filename = file;
}
projects / deliverable / binutils-gdb.git / commitdiff
