/* objdump.c -- dump information about an object file.
- Copyright (C) 1990-2020 Free Software Foundation, Inc.
+ Copyright (C) 1990-2021 Free Software Foundation, Inc.
This file is part of GNU Binutils.
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 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;
disassembler_ftype disassemble_fn;
- arelent * reloc;
- const char * symbol;
+ arelent *reloc;
+ const char *symbol;
};
/* Architecture to disassemble for, or default if NULL. */
fprintf (stream, _(" Display information from object <file(s)>.\n"));
fprintf (stream, _(" At least one of the following switches must be given:\n"));
fprintf (stream, _("\
- -a, --archive-headers Display archive header information\n\
- -f, --file-headers Display the contents of the overall file header\n\
- -p, --private-headers Display object format specific file header contents\n\
- -P, --private=OPT,OPT... Display object format specific contents\n\
- -h, --[section-]headers Display the contents of the section headers\n\
- -x, --all-headers Display the contents of all headers\n\
- -d, --disassemble Display assembler contents of executable sections\n\
- -D, --disassemble-all Display assembler contents of all sections\n\
- --disassemble=<sym> Display assembler contents from <sym>\n\
- -S, --source Intermix source code with disassembly\n\
- --source-comment[=<txt>] Prefix lines of source code with <txt>\n\
- -s, --full-contents Display the full contents of all sections requested\n\
- -g, --debugging Display debug information in object file\n\
- -e, --debugging-tags Display debug information using ctags style\n\
- -G, --stabs Display (in raw form) any STABS info in the file\n\
- -W[lLiaprmfFsoORtUuTgAckK] or\n\
- --dwarf[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
- =frames-interp,=str,=str-offsets,=loc,=Ranges,=pubtypes,\n\
- =gdb_index,=trace_info,=trace_abbrev,=trace_aranges,\n\
- =addr,=cu_index,=links,=follow-links]\n\
- Display DWARF info in the file\n\
-"));
+ -a, --archive-headers Display archive header information\n"));
+ fprintf (stream, _("\
+ -f, --file-headers Display the contents of the overall file header\n"));
+ fprintf (stream, _("\
+ -p, --private-headers Display object format specific file header contents\n"));
+ fprintf (stream, _("\
+ -P, --private=OPT,OPT... Display object format specific contents\n"));
+ fprintf (stream, _("\
+ -h, --[section-]headers Display the contents of the section headers\n"));
+ fprintf (stream, _("\
+ -x, --all-headers Display the contents of all headers\n"));
+ fprintf (stream, _("\
+ -d, --disassemble Display assembler contents of executable sections\n"));
+ fprintf (stream, _("\
+ -D, --disassemble-all Display assembler contents of all sections\n"));
+ fprintf (stream, _("\
+ --disassemble=<sym> Display assembler contents from <sym>\n"));
+ fprintf (stream, _("\
+ -S, --source Intermix source code with disassembly\n"));
+ fprintf (stream, _("\
+ --source-comment[=<txt>] Prefix lines of source code with <txt>\n"));
+ fprintf (stream, _("\
+ -s, --full-contents Display the full contents of all sections requested\n"));
+ fprintf (stream, _("\
+ -g, --debugging Display debug information in object file\n"));
+ fprintf (stream, _("\
+ -e, --debugging-tags Display debug information using ctags style\n"));
+ fprintf (stream, _("\
+ -G, --stabs Display (in raw form) any STABS info in the file\n"));
+ fprintf (stream, _("\
+ -W, --dwarf[a/=abbrev, A/=addr, r/=aranges, c/=cu_index, L/=decodedline,\n\
+ f/=frames, F/=frames-interp, g/=gdb_index, i/=info, o/=loc,\n\
+ m/=macro, p/=pubnames, t/=pubtypes, R/=Ranges, l/=rawline,\n\
+ s/=str, O/=str-offsets, u/=trace_abbrev, T/=trace_aranges,\n\
+ U/=trace_info]\n\
+ Display the contents of DWARF debug sections\n"));
+ fprintf (stream, _("\
+ -Wk,--dwarf=links Display the contents of sections that link to\n\
+ separate debuginfo files\n"));
+#if DEFAULT_FOR_FOLLOW_LINKS
+ fprintf (stream, _("\
+ -WK,--dwarf=follow-links\n\
+ Follow links to separate debug info files (default)\n"));
+ fprintf (stream, _("\
+ -WN,--dwarf=no-follow-links\n\
+ Do not follow links to separate debug info files\n"));
+#else
+ fprintf (stream, _("\
+ -WK,--dwarf=follow-links\n\
+ Follow links to separate debug info files\n"));
+ fprintf (stream, _("\
+ -WN,--dwarf=no-follow-links\n\
+ Do not follow links to separate debug info files\n\
+ (default)\n"));
+#endif
+ fprintf (stream, _("\
+ -L, --process-links Display the contents of non-debug sections in\n\
+ separate debuginfo files. (Implies -WK)\n"));
#ifdef ENABLE_LIBCTF
fprintf (stream, _("\
- --ctf=SECTION Display CTF info from SECTION\n\
-"));
+ --ctf=SECTION Display CTF info from SECTION\n"));
#endif
fprintf (stream, _("\
- -t, --syms Display the contents of the symbol table(s)\n\
- -T, --dynamic-syms Display the contents of the dynamic symbol table\n\
- -r, --reloc Display the relocation entries in the file\n\
- -R, --dynamic-reloc Display the dynamic relocation entries in the file\n\
- @<file> Read options from <file>\n\
- -v, --version Display this program's version number\n\
- -i, --info List object formats and architectures supported\n\
- -H, --help Display this information\n\
-"));
+ -t, --syms Display the contents of the symbol table(s)\n"));
+ fprintf (stream, _("\
+ -T, --dynamic-syms Display the contents of the dynamic symbol table\n"));
+ fprintf (stream, _("\
+ -r, --reloc Display the relocation entries in the file\n"));
+ fprintf (stream, _("\
+ -R, --dynamic-reloc Display the dynamic relocation entries in the file\n"));
+ fprintf (stream, _("\
+ @<file> Read options from <file>\n"));
+ fprintf (stream, _("\
+ -v, --version Display this program's version number\n"));
+ fprintf (stream, _("\
+ -i, --info List object formats and architectures supported\n"));
+ fprintf (stream, _("\
+ -H, --help Display this information\n"));
+
if (status != 2)
{
const struct objdump_private_desc * const *desc;
fprintf (stream, _("\n The following switches are optional:\n"));
fprintf (stream, _("\
- -b, --target=BFDNAME Specify the target object format as BFDNAME\n\
- -m, --architecture=MACHINE Specify the target architecture as MACHINE\n\
- -j, --section=NAME Only display information for section NAME\n\
- -M, --disassembler-options=OPT Pass text OPT on to the disassembler\n\
- -EB --endian=big Assume big endian format when disassembling\n\
- -EL --endian=little Assume little endian format when disassembling\n\
- --file-start-context Include context from start of file (with -S)\n\
- -I, --include=DIR Add DIR to search list for source files\n\
- -l, --line-numbers Include line numbers and filenames in output\n\
- -F, --file-offsets Include file offsets when displaying information\n\
+ -b, --target=BFDNAME Specify the target object format as BFDNAME\n"));
+ fprintf (stream, _("\
+ -m, --architecture=MACHINE Specify the target architecture as MACHINE\n"));
+ fprintf (stream, _("\
+ -j, --section=NAME Only display information for section NAME\n"));
+ fprintf (stream, _("\
+ -M, --disassembler-options=OPT Pass text OPT on to the disassembler\n"));
+ fprintf (stream, _("\
+ -EB --endian=big Assume big endian format when disassembling\n"));
+ fprintf (stream, _("\
+ -EL --endian=little Assume little endian format when disassembling\n"));
+ fprintf (stream, _("\
+ --file-start-context Include context from start of file (with -S)\n"));
+ fprintf (stream, _("\
+ -I, --include=DIR Add DIR to search list for source files\n"));
+ fprintf (stream, _("\
+ -l, --line-numbers Include line numbers and filenames in output\n"));
+ fprintf (stream, _("\
+ -F, --file-offsets Include file offsets when displaying information\n"));
+ fprintf (stream, _("\
-C, --demangle[=STYLE] Decode mangled/processed symbol names\n\
The STYLE, if specified, can be `auto', `gnu',\n\
`lucid', `arm', `hp', `edg', `gnu-v3', `java'\n\
- or `gnat'\n\
- --recurse-limit Enable a limit on recursion whilst demangling. [Default]\n\
- --no-recurse-limit Disable a limit on recursion whilst demangling\n\
- -w, --wide Format output for more than 80 columns\n\
- -z, --disassemble-zeroes Do not skip blocks of zeroes when disassembling\n\
- --start-address=ADDR Only process data whose address is >= ADDR\n\
- --stop-address=ADDR Only process data whose address is < ADDR\n\
- --no-addresses Do not print address alongside disassembly\n\
- --prefix-addresses Print complete address alongside disassembly\n\
- --[no-]show-raw-insn Display hex alongside symbolic disassembly\n\
- --insn-width=WIDTH Display WIDTH bytes on a single line for -d\n\
- --adjust-vma=OFFSET Add OFFSET to all displayed section addresses\n\
- --special-syms Include special symbols in symbol dumps\n\
- --inlines Print all inlines for source line (with -l)\n\
- --prefix=PREFIX Add PREFIX to absolute paths for -S\n\
+ or `gnat'\n"));
+ fprintf (stream, _("\
+ --recurse-limit Enable a limit on recursion whilst demangling\n\
+ (default)\n"));
+ fprintf (stream, _("\
+ --no-recurse-limit Disable a limit on recursion whilst demangling\n"));
+ fprintf (stream, _("\
+ -w, --wide Format output for more than 80 columns\n"));
+ fprintf (stream, _("\
+ -z, --disassemble-zeroes Do not skip blocks of zeroes when disassembling\n"));
+ fprintf (stream, _("\
+ --start-address=ADDR Only process data whose address is >= ADDR\n"));
+ fprintf (stream, _("\
+ --stop-address=ADDR Only process data whose address is < ADDR\n"));
+ fprintf (stream, _("\
+ --no-addresses Do not print address alongside disassembly\n"));
+ fprintf (stream, _("\
+ --prefix-addresses Print complete address alongside disassembly\n"));
+ fprintf (stream, _("\
+ --[no-]show-raw-insn Display hex alongside symbolic disassembly\n"));
+ fprintf (stream, _("\
+ --insn-width=WIDTH Display WIDTH bytes on a single line for -d\n"));
+ fprintf (stream, _("\
+ --adjust-vma=OFFSET Add OFFSET to all displayed section addresses\n"));
+ fprintf (stream, _("\
+ --special-syms Include special symbols in symbol dumps\n"));
+ fprintf (stream, _("\
+ --inlines Print all inlines for source line (with -l)\n"));
+ fprintf (stream, _("\
+ --prefix=PREFIX Add PREFIX to absolute paths for -S\n"));
+ fprintf (stream, _("\
--prefix-strip=LEVEL Strip initial directory names for -S\n"));
fprintf (stream, _("\
- --dwarf-depth=N Do not display DIEs at depth N or greater\n\
- --dwarf-start=N Display DIEs starting with N, at the same depth\n\
- or deeper\n\
- --dwarf-check Make additional dwarf internal consistency checks.\n"));
+ --dwarf-depth=N Do not display DIEs at depth N or greater\n"));
+ fprintf (stream, _("\
+ --dwarf-start=N Display DIEs starting at offset N\n"));
+ fprintf (stream, _("\
+ --dwarf-check Make additional dwarf consistency checks.\n"));
#ifdef ENABLE_LIBCTF
fprintf (stream, _("\
- --ctf-parent=SECTION Use SECTION as the CTF parent\n"));
+ --ctf-parent=SECTION Use SECTION as the CTF parent\n"));
#endif
fprintf (stream, _("\
- --visualize-jumps Visualize jumps by drawing ASCII art lines\n\
- --visualize-jumps=color Use colors in the ASCII art\n\
- --visualize-jumps=extended-color Use extended 8-bit color codes\n\
+ --visualize-jumps Visualize jumps by drawing ASCII art lines\n"));
+ fprintf (stream, _("\
+ --visualize-jumps=color Use colors in the ASCII art\n"));
+ fprintf (stream, _("\
+ --visualize-jumps=extended-color\n\
+ Use extended 8-bit color codes\n"));
+ fprintf (stream, _("\
--visualize-jumps=off Disable jump visualization\n\n"));
list_supported_targets (program_name, stream);
{"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},
{"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;
}
non_fatal (_("failed to read symbol table from: %s"), bfd_get_filename (abfd));
bfd_fatal (_("error message was"));
}
+
if (storage)
{
off_t filesize = bfd_get_file_size (abfd);
&& filesize < storage
/* The MMO file format supports its own special compression
technique, so its sections can be larger than the file size. */
- && bfd_get_flavour (abfd) != bfd_target_mmo_flavour)
+ && bfd_get_flavour (abfd) != bfd_target_mmo_flavour)
{
bfd_nonfatal_message (bfd_get_filename (abfd), abfd, NULL,
- _("error: symbol table size (%#lx) is larger than filesize (%#lx)"),
- storage, (long) filesize);
+ _("error: symbol table size (%#lx) "
+ "is larger than filesize (%#lx)"),
+ storage, (long) filesize);
exit_status = 1;
symcount = 0;
return NULL;
bfd_fatal (bfd_get_filename (abfd));
}
+
if (storage)
sy = (asymbol **) xmalloc (storage);
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;
+ return startswith (name, ".plt") || startswith (name, ".got");
}
/* Filter out (in place) symbols that are useless for disassembly.
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;
and we have dynamic relocations available, then we can produce
a better result by matching a relocation to the address and
using the symbol associated with that relocation. */
- rel_count = aux->dynrelcount;
+ rel_count = inf->dynrelcount;
if (!want_section
&& sorted_syms[thisplace]->value != vma
&& rel_count > 0
- && aux->dynrelbuf != NULL
- && aux->dynrelbuf[0]->address <= vma
- && aux->dynrelbuf[rel_count - 1]->address >= vma
+ && inf->dynrelbuf != NULL
+ && inf->dynrelbuf[0]->address <= vma
+ && inf->dynrelbuf[rel_count - 1]->address >= vma
/* If we have matched a synthetic symbol, then stick with that. */
&& (sorted_syms[thisplace]->flags & BSF_SYNTHETIC) == 0)
{
arelent ** rel_low;
arelent ** rel_high;
- rel_low = aux->dynrelbuf;
+ rel_low = inf->dynrelbuf;
rel_high = rel_low + rel_count - 1;
while (rel_low <= rel_high)
{
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)
/* Determine if the given address has a symbol associated with it. */
-static int
+static asymbol *
objdump_symbol_at_address (bfd_vma vma, struct disassemble_info * inf)
{
asymbol * sym;
sym = find_symbol_for_address (vma, inf, NULL);
+ if (sym != NULL && bfd_asymbol_value (sym) == vma)
+ return sym;
- return (sym != NULL && (bfd_asymbol_value (sym) == vma));
+ return NULL;
}
/* Hold the last function name and the last line number we displayed
const char *functionname;
unsigned int linenumber;
unsigned int discriminator;
- bfd_boolean reloc;
+ bool reloc;
char *path = NULL;
if (! with_line_numbers && ! with_source_code)
char *path_up;
const char *fname = filename;
- path = xmalloc (prefix_length + PATH_MAX + 1);
+ path = xmalloc (prefix_length + 1 + strlen (filename));
if (prefix_length)
memcpy (path, prefix, prefix_length);
}
/* Update complete filename. */
- strncpy (path_up, fname, PATH_MAX);
- path_up[PATH_MAX] = '\0';
+ strcpy (path_up, fname);
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 (": ");
}
if (q->addend)
{
- bfd_signed_vma addend = q->addend;
- if (addend < 0)
+ bfd_vma addend = q->addend;
+ if ((bfd_signed_vma) addend < 0)
{
printf ("-0x");
addend = -addend;
}
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,
/* Decide which set of relocs to use. Load them if necessary. */
paux = (struct objdump_disasm_info *) pinfo->application_data;
- if (paux->dynrelbuf && dump_dynamic_reloc_info)
+ if (pinfo->dynrelbuf && dump_dynamic_reloc_info)
{
- rel_pp = paux->dynrelbuf;
- rel_count = paux->dynrelcount;
+ rel_pp = pinfo->dynrelbuf;
+ rel_count = pinfo->dynrelcount;
/* Dynamic reloc addresses are absolute, non-dynamic are section
relative. REL_OFFSET specifies the reloc address corresponding
to the start of this section. */
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.dynrelbuf = NULL;
- aux.dynrelcount = 0;
+ aux.require_sec = false;
+ disasm_info.dynrelbuf = NULL;
+ disasm_info.dynrelcount = 0;
aux.reloc = NULL;
aux.symbol = disasm_sym;
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_init_for_target (& disasm_info);
/* Pre-load the dynamic relocs as we may need them during the disassembly. */
- {
- long relsize = bfd_get_dynamic_reloc_upper_bound (abfd);
+ long relsize = bfd_get_dynamic_reloc_upper_bound (abfd);
- if (relsize < 0 && dump_dynamic_reloc_info)
- bfd_fatal (bfd_get_filename (abfd));
+ if (relsize < 0 && dump_dynamic_reloc_info)
+ bfd_fatal (bfd_get_filename (abfd));
- if (relsize > 0)
- {
- aux.dynrelbuf = (arelent **) xmalloc (relsize);
- aux.dynrelcount = bfd_canonicalize_dynamic_reloc (abfd,
- aux.dynrelbuf,
- dynsyms);
- if (aux.dynrelcount < 0)
- bfd_fatal (bfd_get_filename (abfd));
+ if (relsize > 0)
+ {
+ disasm_info.dynrelbuf = (arelent **) xmalloc (relsize);
+ disasm_info.dynrelcount
+ = bfd_canonicalize_dynamic_reloc (abfd, disasm_info.dynrelbuf, dynsyms);
+ if (disasm_info.dynrelcount < 0)
+ bfd_fatal (bfd_get_filename (abfd));
- /* Sort the relocs by address. */
- qsort (aux.dynrelbuf, aux.dynrelcount, sizeof (arelent *),
- compare_relocs);
- }
+ /* Sort the relocs by address. */
+ qsort (disasm_info.dynrelbuf, disasm_info.dynrelcount, sizeof (arelent *),
+ compare_relocs);
}
+
disasm_info.symtab = sorted_syms;
disasm_info.symtab_size = sorted_symcount;
bfd_map_over_sections (abfd, disassemble_section, & disasm_info);
- if (aux.dynrelbuf != NULL)
- free (aux.dynrelbuf);
+ free (disasm_info.dynrelbuf);
+ disasm_info.dynrelbuf = NULL;
free (sorted_syms);
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;
+ 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);
- section->start = NULL;
}
section->filename = bfd_get_filename (abfd);
section->reloc_info = NULL;
section->num_relocs = 0;
section->address = bfd_section_vma (sec);
- section->user_data = sec;
section->size = bfd_section_size (sec);
/* PR 24360: On 32-bit hosts sizeof (size_t) < sizeof (bfd_size_type). */
alloced = amt = section->size + 1;
if (alloced != amt || alloced == 0)
{
+ section->start = NULL;
free_debug_section (debug);
printf (_("\nSection '%s' has an invalid size: %#llx.\n"),
sanitize_string (section->name),
(unsigned long long) section->size);
- return FALSE;
- }
- if (!bfd_malloc_and_get_section (abfd, sec, &contents))
- {
- free_debug_section (debug);
- printf (_("\nCan't get contents for section '%s'.\n"),
- sanitize_string (section->name));
- return FALSE;
+ return false;
}
- section->start = contents;
+
+ section->start = contents = xmalloc (alloced);
/* Ensure any string section has a terminating NUL. */
section->start[section->size] = 0;
if ((abfd->flags & (EXEC_P | DYNAMIC)) == 0
&& debug_displays [debug].relocate)
{
- long reloc_size;
- bfd_boolean ret;
-
- bfd_cache_section_contents (sec, section->start);
-
ret = bfd_simple_get_relocated_section_contents (abfd,
sec,
section->start,
syms) != NULL;
-
- if (! ret)
- {
- free_debug_section (debug);
- printf (_("\nCan't get contents for section '%s'.\n"),
- sanitize_string (section->name));
- return FALSE;
- }
-
- reloc_size = bfd_get_reloc_upper_bound (abfd, sec);
- if (reloc_size > 0)
+ if (ret)
{
- unsigned long reloc_count;
- arelent **relocs;
-
- relocs = (arelent **) xmalloc (reloc_size);
+ long reloc_size = bfd_get_reloc_upper_bound (abfd, sec);
- reloc_count = bfd_canonicalize_reloc (abfd, sec, relocs, NULL);
- if (reloc_count == 0)
- free (relocs);
- else
+ if (reloc_size > 0)
{
- section->reloc_info = relocs;
- section->num_relocs = reloc_count;
+ unsigned long reloc_count;
+ arelent **relocs;
+
+ relocs = (arelent **) xmalloc (reloc_size);
+
+ reloc_count = bfd_canonicalize_reloc (abfd, sec, relocs, NULL);
+ if (reloc_count == 0)
+ free (relocs);
+ else
+ {
+ section->reloc_info = relocs;
+ section->num_relocs = reloc_count;
+ }
}
}
}
+ else
+ ret = bfd_get_full_section_contents (abfd, sec, &contents);
- return TRUE;
+ if (!ret)
+ {
+ free_debug_section (debug);
+ printf (_("\nCan't get contents for section '%s'.\n"),
+ sanitize_string (section->name));
+ return false;
+ }
+
+ 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);
}
{
struct dwarf_section *section = &debug_displays [debug].section;
- if (section->start == NULL)
- return;
-
- /* PR 17512: file: 0f67f69d. */
- if (section->user_data != NULL)
- {
- asection * sec = (asection *) section->user_data;
-
- /* If we are freeing contents that are also pointed to by the BFD
- library's section structure then make sure to update those pointers
- too. Otherwise, the next time we try to load data for this section
- we can end up using a stale pointer. */
- if (section->start == sec->contents)
- {
- sec->contents = NULL;
- sec->flags &= ~ SEC_IN_MEMORY;
- sec->compress_status = COMPRESS_SECTION_NONE;
- }
- }
-
free ((char *) section->start);
section->start = NULL;
section->address = 0;
const char *match;
int i;
- if (CONST_STRNEQ (name, ".gnu.linkonce.wi."))
+ if (startswith (name, ".gnu.linkonce.wi."))
match = ".debug_info";
else
match = name;
{
printf (_("No %s section present\n\n"),
sanitize_string (sect_name));
- return FALSE;
+ return false;
}
if (!bfd_malloc_and_get_section (abfd, stabsect, &contents))
return ctfsect;
}
+/* Dump CTF errors/warnings. */
+static void
+dump_ctf_errs (ctf_dict_t *fp)
+{
+ ctf_next_t *it = NULL;
+ char *errtext;
+ int is_warning;
+ int err;
+
+ /* Dump accumulated errors and warnings. */
+ while ((errtext = ctf_errwarning_next (fp, &it, &is_warning, &err)) != NULL)
+ {
+ non_fatal (_("%s: %s"), is_warning ? _("warning"): _("error"),
+ errtext);
+ free (errtext);
+ }
+ if (err != ECTF_NEXT_END)
+ {
+ non_fatal (_("CTF error: cannot get CTF errors: `%s'"),
+ ctf_errmsg (err));
+ }
+}
+
/* Dump one CTF archive member. */
static int
-dump_ctf_archive_member (ctf_file_t *ctf, const char *name, void *arg)
+dump_ctf_archive_member (ctf_dict_t *ctf, const char *name, void *arg)
{
- ctf_file_t *parent = (ctf_file_t *) arg;
+ ctf_dict_t *parent = (ctf_dict_t *) arg;
const char *things[] = {"Header", "Labels", "Data objects",
"Function objects", "Variables", "Types", "Strings",
""};
const char **thing;
- ctf_next_t *it = NULL;
- char *errtext;
- int is_warning;
size_t i;
/* Only print out the name of non-default-named archive members.
}
}
- /* Dump accumulated errors and warnings. */
- while ((errtext = ctf_errwarning_next (ctf, &it, &is_warning)) != NULL)
- {
- non_fatal (_("%s: `%s'"), is_warning ? _("warning"): _("error"),
- errtext);
- free (errtext);
- }
- if (ctf_errno (ctf) != ECTF_NEXT_END)
- {
- non_fatal (_("CTF error: cannot get CTF errors: `%s'"),
- ctf_errmsg (ctf_errno (ctf)));
- }
+ dump_ctf_errs (ctf);
return 0;
}
bfd_byte *ctfdata, *parentdata = NULL;
bfd_size_type ctfsize, parentsize;
ctf_sect_t ctfsect;
- ctf_file_t *parent = NULL;
+ ctf_dict_t *parent = NULL;
int err;
if ((ctfdata = read_section_stabs (abfd, sect_name, &ctfsize, NULL)) == NULL)
ctfsect = make_ctfsect (sect_name, ctfdata, ctfsize);
if ((ctfa = ctf_bfdopen_ctfsect (abfd, &ctfsect, &err)) == NULL)
{
+ dump_ctf_errs (NULL);
non_fatal (_("CTF open failure: %s"), ctf_errmsg (err));
bfd_fatal (bfd_get_filename (abfd));
}
ctfsect = make_ctfsect (parent_name, parentdata, parentsize);
if ((parenta = ctf_bfdopen_ctfsect (abfd, &ctfsect, &err)) == NULL)
{
+ dump_ctf_errs (NULL);
non_fatal (_("CTF open failure: %s"), ctf_errmsg (err));
bfd_fatal (bfd_get_filename (abfd));
}
/* Assume that the applicable parent archive member is the default one.
(This is what all known implementations are expected to do, if they
put CTFs and their parents in archives together.) */
- if ((parent = ctf_arc_open_by_name (lookparent, NULL, &err)) == NULL)
+ if ((parent = ctf_dict_open (lookparent, NULL, &err)) == NULL)
{
+ dump_ctf_errs (NULL);
non_fatal (_("CTF open failure: %s"), ctf_errmsg (err));
bfd_fatal (bfd_get_filename (abfd));
}
printf (_("Contents of CTF section %s:\n"), sanitize_string (sect_name));
- ctf_archive_iter (ctfa, dump_ctf_archive_member, parent);
- ctf_file_close (parent);
+ if ((err = ctf_archive_iter (ctfa, dump_ctf_archive_member, parent)) != 0)
+ {
+ dump_ctf_errs (NULL);
+ non_fatal (_("CTF archive member open failure: %s"), ctf_errmsg (err));
+ bfd_fatal (bfd_get_filename (abfd));
+ }
+ ctf_dict_close (parent);
ctf_close (ctfa);
ctf_close (parenta);
free (parentdata);
/* 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);
}
+ if (! is_mainfile && ! process_links)
+ return;
+
if (! dump_debugging_tags && ! suppress_bfd_header)
printf (_("\n%s: file format %s\n"),
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)
}
else
{
- syms = xrealloc (syms, (symcount + old_symcount) * sizeof (asymbol *));
+ syms = xrealloc (syms, ((symcount + old_symcount + 1)
+ * sizeof (asymbol *)));
memcpy (syms + old_symcount,
extra_syms,
- symcount * sizeof (asymbol *));
+ (symcount + 1) * sizeof (asymbol *));
}
}
}
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,
bfd_demangle,
- dump_debugging_tags ? TRUE : FALSE))
+ dump_debugging_tags != 0))
{
non_fatal (_("%s: printing debugging information failed"),
bfd_get_filename (abfd));
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)
+#ifdef HAVE_LC_MESSAGES
setlocale (LC_MESSAGES, "");
#endif
setlocale (LC_CTYPE, "");
-#endif
bindtextdomain (PACKAGE, LOCALEDIR);
textdomain (PACKAGE);
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;
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;)
{
projects / deliverable / binutils-gdb.git / blobdiff