/* objdump.c -- dump information about an object file.
- Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
- 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009
- Free Software Foundation, Inc.
+ Copyright (C) 1990-2017 Free Software Foundation, Inc.
This file is part of GNU Binutils.
relocations, debugging directives and more.
The flow of execution is as follows:
-
+
1. Command line arguments are checked for control switches and the
information to be displayed is selected.
-
+
2. Any remaining arguments are assumed to be object files, and they are
processed in order by display_bfd(). If the file is an archive each
of its elements is processed in turn.
-
+
3. The file's target architecture and binary file format are determined
by bfd_check_format(). If they are recognised, then dump_bfd() is
called.
#include "sysdep.h"
#include "bfd.h"
#include "elf-bfd.h"
+#include "coff-bfd.h"
#include "progress.h"
#include "bucomm.h"
+#include "elfcomm.h"
#include "dwarf.h"
#include "getopt.h"
#include "safe-ctype.h"
#include "filenames.h"
#include "debug.h"
#include "budbg.h"
+#include "objdump.h"
#ifdef HAVE_MMAP
#include <sys/mman.h>
#endif
-#include <sys/stat.h>
-
/* Internal headers for the ELF .stab-dump code - sorry. */
#define BYTES_IN_WORD 32
#include "aout/aout64.h"
static int dump_dynamic_reloc_info; /* -R */
static int dump_ar_hdrs; /* -a */
static int dump_private_headers; /* -p */
+static char *dump_private_options; /* -P */
static int prefix_addresses; /* --prefix-addresses */
static int with_line_numbers; /* -l */
static bfd_boolean with_source_code; /* -S */
static bfd_vma stop_address = (bfd_vma) -1; /* --stop-address */
static int dump_debugging; /* --debugging */
static int dump_debugging_tags; /* --debugging-tags */
+static int suppress_bfd_header;
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 int prefix_strip; /* --prefix-strip */
static size_t prefix_length;
-/* Pointer to an array of section names provided by
- one or more "-j secname" command line options. */
-static char **only;
-/* The total number of slots in the only[] array. */
-static size_t only_size = 0;
-/* The number of occupied slots in the only[] array. */
-static size_t only_used = 0;
+/* 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. */
+};
+/* Pointer to an array of 'only' structures.
+ This pointer is NULL if the -j switch has not been used. */
+static struct only * only_list = NULL;
/* Variables for handling include file path table. */
static const char **include_paths;
static bfd_size_type stabstr_size;
static bfd_boolean is_relocatable = FALSE;
+
+/* Handlers for -P/--private. */
+static const struct objdump_private_desc * const objdump_private_vectors[] =
+ {
+ OBJDUMP_PRIVATE_VECTORS
+ NULL
+ };
\f
+static void usage (FILE *, int) ATTRIBUTE_NORETURN;
static void
usage (FILE *stream, int status)
{
-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\
-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[lLiaprmfFsoR] or\n\
- --dwarf[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,=str,=loc,=Ranges]\n\
+ -W[lLiaprmfFsoRt] or\n\
+ --dwarf[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
+ =frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
+ =gdb_index,=trace_info,=trace_abbrev,=trace_aranges,\n\
+ =addr,=cu_index]\n\
Display DWARF info in the file\n\
-t, --syms Display the contents of the symbol table(s)\n\
-T, --dynamic-syms Display the contents of the dynamic symbol table\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\
--stop-address=ADDR Only process data whose address is <= ADDR\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 signle line for -d\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\
--prefix=PREFIX Add PREFIX to absolute paths for -S\n\
- --prefix-strip=LEVEL Strip initial directory names for -S\n\
-\n"));
+ --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\n"));
list_supported_targets (program_name, stream);
list_supported_architectures (program_name, stream);
disassembler_usage (stream);
+
+ if (objdump_private_vectors[0] != NULL)
+ {
+ fprintf (stream,
+ _("\nOptions supported for -P/--private switch:\n"));
+ for (desc = objdump_private_vectors; *desc != NULL; desc++)
+ (*desc)->help (stream);
+ }
}
if (REPORT_BUGS_TO[0] && status == 0)
fprintf (stream, _("Report bugs to %s.\n"), REPORT_BUGS_TO);
OPTION_PREFIX,
OPTION_PREFIX_STRIP,
OPTION_INSN_WIDTH,
- OPTION_ADJUST_VMA
+ OPTION_ADJUST_VMA,
+ OPTION_DWARF_DEPTH,
+ OPTION_DWARF_CHECK,
+ OPTION_DWARF_START
};
static struct option long_options[]=
{"adjust-vma", required_argument, NULL, OPTION_ADJUST_VMA},
{"all-headers", no_argument, NULL, 'x'},
{"private-headers", no_argument, NULL, 'p'},
+ {"private", required_argument, NULL, 'P'},
{"architecture", required_argument, NULL, 'm'},
{"archive-headers", no_argument, NULL, 'a'},
{"debugging", no_argument, NULL, 'g'},
{"prefix", required_argument, NULL, OPTION_PREFIX},
{"prefix-strip", required_argument, NULL, OPTION_PREFIX_STRIP},
{"insn-width", required_argument, NULL, OPTION_INSN_WIDTH},
+ {"dwarf-depth", required_argument, 0, OPTION_DWARF_DEPTH},
+ {"dwarf-start", required_argument, 0, OPTION_DWARF_START},
+ {"dwarf-check", no_argument, 0, OPTION_DWARF_CHECK},
{0, no_argument, 0, 0}
};
\f
static bfd_boolean
process_section_p (asection * section)
{
- size_t i;
+ struct only * only;
- if (only == NULL)
+ if (only_list == NULL)
return TRUE;
- for (i = 0; i < only_used; i++)
- if (strcmp (only [i], section->name) == 0)
- return TRUE;
+ for (only = only_list; only; only = only->next)
+ if (strcmp (only->name, section->name) == 0)
+ {
+ only->seen = TRUE;
+ return TRUE;
+ }
return FALSE;
}
+
+/* Add an entry to the 'only' list. */
+
+static void
+add_only (char * name)
+{
+ struct only * only;
+
+ /* First check to make sure that we do not
+ already have an entry for this name. */
+ for (only = only_list; only; only = only->next)
+ if (strcmp (only->name, name) == 0)
+ return;
+
+ only = xmalloc (sizeof * only);
+ only->name = name;
+ only->seen = FALSE;
+ only->next = only_list;
+ only_list = only;
+}
+
+/* Release the memory used by the 'only' list.
+ PR 11225: Issue a warning message for unseen sections.
+ Only do this if none of the sections were seen. This is mainly to support
+ tools like the GAS testsuite where an object file is dumped with a list of
+ generic section names known to be present in a range of different file
+ formats. */
+
+static void
+free_only_list (void)
+{
+ bfd_boolean at_least_one_seen = FALSE;
+ struct only * only;
+ struct only * next;
+
+ if (only_list == NULL)
+ return;
+
+ for (only = only_list; only; only = only->next)
+ if (only->seen)
+ {
+ at_least_one_seen = TRUE;
+ break;
+ }
+
+ for (only = only_list; only; only = next)
+ {
+ if (! at_least_one_seen)
+ {
+ non_fatal (_("section '%s' mentioned in a -j option, "
+ "but not found in any input file"),
+ only->name);
+ exit_status = 1;
+ }
+ next = only->next;
+ free (only);
+ }
+}
+
\f
static void
-dump_section_header (bfd *abfd, asection *section,
- void *ignored ATTRIBUTE_UNUSED)
+dump_section_header (bfd *abfd, asection *section, void *data)
{
char *comma = "";
unsigned int opb = bfd_octets_per_byte (abfd);
+ int longest_section_name = *((int *) data);
/* Ignore linker created section. See elfNN_ia64_object_p in
bfd/elfxx-ia64.c. */
if (! process_section_p (section))
return;
- printf ("%3d %-13s %08lx ", section->index,
+ printf ("%3d %-*s %08lx ", section->index, longest_section_name,
bfd_get_section_name (abfd, section),
(unsigned long) bfd_section_size (abfd, section) / opb);
bfd_printf_vma (abfd, bfd_get_section_vma (abfd, section));
}
PF (SEC_SMALL_DATA, "SMALL_DATA");
if (bfd_get_flavour (abfd) == bfd_target_coff_flavour)
- PF (SEC_COFF_SHARED, "SHARED");
+ {
+ PF (SEC_COFF_SHARED, "SHARED");
+ PF (SEC_COFF_NOREAD, "NOREAD");
+ }
+ else if (bfd_get_flavour (abfd) == bfd_target_elf_flavour)
+ PF (SEC_ELF_PURECODE, "PURECODE");
PF (SEC_THREAD_LOCAL, "THREAD_LOCAL");
PF (SEC_GROUP, "GROUP");
+ if (bfd_get_arch (abfd) == bfd_arch_mep)
+ {
+ PF (SEC_MEP_VLIW, "VLIW");
+ }
if ((section->flags & SEC_LINK_ONCE) != 0)
{
#undef PF
}
+/* Called on each SECTION in ABFD, update the int variable pointed to by
+ DATA which contains the string length of the longest section name. */
+
+static void
+find_longest_section_name (bfd *abfd, asection *section, void *data)
+{
+ int *longest_so_far = (int *) data;
+ const char *name;
+ int len;
+
+ /* Ignore linker created section. */
+ if (section->flags & SEC_LINKER_CREATED)
+ return;
+
+ /* Skip sections that we are ignoring. */
+ if (! process_section_p (section))
+ return;
+
+ name = bfd_get_section_name (abfd, section);
+ len = (int) strlen (name);
+ if (len > *longest_so_far)
+ *longest_so_far = len;
+}
+
static void
dump_headers (bfd *abfd)
{
- printf (_("Sections:\n"));
+ /* The default width of 13 is just an arbitrary choice. */
+ int max_section_name_length = 13;
+ int bfd_vma_width;
#ifndef BFD64
- printf (_("Idx Name Size VMA LMA File off Algn"));
+ bfd_vma_width = 10;
#else
/* With BFD64, non-ELF returns -1 and wants always 64 bit addresses. */
if (bfd_get_arch_size (abfd) == 32)
- printf (_("Idx Name Size VMA LMA File off Algn"));
+ bfd_vma_width = 10;
else
- printf (_("Idx Name Size VMA LMA File off Algn"));
+ bfd_vma_width = 18;
#endif
+ printf (_("Sections:\n"));
+
+ if (wide_output)
+ bfd_map_over_sections (abfd, find_longest_section_name,
+ &max_section_name_length);
+
+ printf (_("Idx %-*s Size %-*s%-*sFile off Algn"),
+ max_section_name_length, "Name",
+ bfd_vma_width, "VMA",
+ bfd_vma_width, "LMA");
+
if (wide_output)
printf (_(" Flags"));
- if (abfd->flags & HAS_LOAD_PAGE)
- printf (_(" Pg"));
printf ("\n");
- bfd_map_over_sections (abfd, dump_section_header, NULL);
+ bfd_map_over_sections (abfd, dump_section_header,
+ &max_section_name_length);
}
\f
static asymbol **
storage = bfd_get_symtab_upper_bound (abfd);
if (storage < 0)
- bfd_fatal (bfd_get_filename (abfd));
+ {
+ non_fatal (_("failed to read symbol table from: %s"), bfd_get_filename (abfd));
+ bfd_fatal (_("error message was"));
+ }
if (storage)
- sy = xmalloc (storage);
+ sy = (asymbol **) xmalloc (storage);
symcount = bfd_canonicalize_symtab (abfd, sy);
if (symcount < 0)
if (!(bfd_get_file_flags (abfd) & DYNAMIC))
{
non_fatal (_("%s: not a dynamic object"), bfd_get_filename (abfd));
+ exit_status = 1;
dynsymcount = 0;
return NULL;
}
bfd_fatal (bfd_get_filename (abfd));
}
if (storage)
- sy = xmalloc (storage);
+ sy = (asymbol **) xmalloc (storage);
dynsymcount = bfd_canonicalize_dynamic_symtab (abfd, sy);
if (dynsymcount < 0)
return sy;
}
+/* Some symbol names are significant and should be kept in the
+ table of sorted symbol names, even if they are marked as
+ debugging/section symbols. */
+
+static bfd_boolean
+is_significant_symbol_name (const char * name)
+{
+ return strcmp (name, ".plt") == 0
+ || strcmp (name, ".got") == 0
+ || strcmp (name, ".plt.got") == 0;
+}
+
/* Filter out (in place) symbols that are useless for disassembly.
COUNT is the number of elements in SYMBOLS.
Return the number of useful symbols. */
if (sym->name == NULL || sym->name[0] == '\0')
continue;
- if (sym->flags & (BSF_DEBUGGING | BSF_SECTION_SYM))
+ if ((sym->flags & (BSF_DEBUGGING | BSF_SECTION_SYM))
+ && ! is_significant_symbol_name (sym->name))
continue;
if (bfd_is_und_section (sym->section)
|| bfd_is_com_section (sym->section))
return 1;
}
+ if (bfd_get_flavour (bfd_asymbol_bfd (a)) == bfd_target_elf_flavour
+ && bfd_get_flavour (bfd_asymbol_bfd (b)) == bfd_target_elf_flavour)
+ {
+ bfd_vma asz, bsz;
+
+ asz = 0;
+ if ((a->flags & BSF_SYNTHETIC) == 0)
+ asz = ((elf_symbol_type *) a)->internal_elf_sym.st_size;
+ bsz = 0;
+ if ((b->flags & BSF_SYNTHETIC) == 0)
+ bsz = ((elf_symbol_type *) b)->internal_elf_sym.st_size;
+ if (asz != bsz)
+ return asz > bsz ? -1 : 1;
+ }
+
/* Symbols that start with '.' might be section names, so sort them
after symbols that don't start with '.'. */
if (an[0] == '.' && bn[0] != '.')
If SKIP_ZEROES is TRUE, omit leading zeroes. */
static void
-objdump_print_value (bfd_vma vma, struct disassemble_info *info,
+objdump_print_value (bfd_vma vma, struct disassemble_info *inf,
bfd_boolean skip_zeroes)
{
char buf[30];
char *p;
struct objdump_disasm_info *aux;
- aux = (struct objdump_disasm_info *) info->application_data;
+ aux = (struct objdump_disasm_info *) inf->application_data;
bfd_sprintf_vma (aux->abfd, buf, vma);
if (! skip_zeroes)
p = buf;
if (*p == '\0')
--p;
}
- (*info->fprintf_func) (info->stream, "%s", p);
+ (*inf->fprintf_func) (inf->stream, "%s", p);
}
/* Print the name of a symbol. */
static void
-objdump_print_symname (bfd *abfd, struct disassemble_info *info,
+objdump_print_symname (bfd *abfd, struct disassemble_info *inf,
asymbol *sym)
{
char *alloc;
- const char *name;
+ const char *name, *version_string = NULL;
+ bfd_boolean hidden = FALSE;
alloc = NULL;
name = bfd_asymbol_name (sym);
name = alloc;
}
- if (info != NULL)
- (*info->fprintf_func) (info->stream, "%s", name);
+ if ((sym->flags & BSF_SYNTHETIC) == 0)
+ version_string = bfd_get_symbol_version_string (abfd, sym, &hidden);
+
+ if (bfd_is_und_section (bfd_get_section (sym)))
+ hidden = TRUE;
+
+ if (inf != NULL)
+ {
+ (*inf->fprintf_func) (inf->stream, "%s", name);
+ if (version_string && *version_string != '\0')
+ (*inf->fprintf_func) (inf->stream, hidden ? "@%s" : "@@%s",
+ version_string);
+ }
else
- printf ("%s", name);
+ {
+ printf ("%s", name);
+ if (version_string && *version_string != '\0')
+ printf (hidden ? "@%s" : "@@%s", version_string);
+ }
if (alloc != NULL)
free (alloc);
static asymbol *
find_symbol_for_address (bfd_vma vma,
- struct disassemble_info *info,
+ struct disassemble_info *inf,
long *place)
{
/* @@ Would it speed things up to cache the last two symbols returned,
/* Indices in `sorted_syms'. */
long min = 0;
- long max = sorted_symcount;
+ long max_count = sorted_symcount;
long thisplace;
struct objdump_disasm_info *aux;
bfd *abfd;
if (sorted_symcount < 1)
return NULL;
- aux = (struct objdump_disasm_info *) info->application_data;
+ aux = (struct objdump_disasm_info *) inf->application_data;
abfd = aux->abfd;
sec = aux->sec;
- opb = bfd_octets_per_byte (abfd);
+ opb = inf->octets_per_byte;
/* Perform a binary search looking for the closest symbol to the
- required value. We are searching the range (min, max]. */
- while (min + 1 < max)
+ required value. We are searching the range (min, max_count]. */
+ while (min + 1 < max_count)
{
asymbol *sym;
- thisplace = (max + min) / 2;
+ thisplace = (max_count + min) / 2;
sym = sorted_syms[thisplace];
if (bfd_asymbol_value (sym) > vma)
- max = thisplace;
+ max_count = thisplace;
else if (bfd_asymbol_value (sym) < vma)
min = thisplace;
else
/* The symbol we want is now in min, the low end of the range we
were searching. If there are several symbols with the same
- value, we want the first one. */
+ value, we want the first (non-section/non-debugging) one. */
thisplace = min;
while (thisplace > 0
&& (bfd_asymbol_value (sorted_syms[thisplace])
- == bfd_asymbol_value (sorted_syms[thisplace - 1])))
+ == bfd_asymbol_value (sorted_syms[thisplace - 1]))
+ && ((sorted_syms[thisplace - 1]->flags
+ & (BSF_SECTION_SYM | BSF_DEBUGGING)) == 0)
+ )
--thisplace;
/* Prefer a symbol in the current section if we have multple symbols
with the same value, as can occur with overlays or zero size
sections. */
min = thisplace;
- while (min < max
+ while (min < max_count
&& (bfd_asymbol_value (sorted_syms[min])
== bfd_asymbol_value (sorted_syms[thisplace])))
{
if (sorted_syms[min]->section == sec
- && info->symbol_is_valid (sorted_syms[min], info))
+ && inf->symbol_is_valid (sorted_syms[min], inf))
{
thisplace = min;
sections have overlapping memory ranges, but in that case there's
no way to tell what's desired without looking at the relocation
table.
-
+
Also give the target a chance to reject symbols. */
want_section = (aux->require_sec
|| ((abfd->flags & HAS_RELOC) != 0
&& vma < (bfd_get_section_vma (abfd, sec)
+ bfd_section_size (abfd, sec) / opb)));
if ((sorted_syms[thisplace]->section != sec && want_section)
- || !info->symbol_is_valid (sorted_syms[thisplace], info))
+ || ! inf->symbol_is_valid (sorted_syms[thisplace], inf))
{
long i;
long newplace = sorted_symcount;
for (i = min - 1; i >= 0; i--)
{
if ((sorted_syms[i]->section == sec || !want_section)
- && info->symbol_is_valid (sorted_syms[i], info))
+ && inf->symbol_is_valid (sorted_syms[i], inf))
{
if (newplace == sorted_symcount)
newplace = i;
for (i = thisplace + 1; i < sorted_symcount; i++)
{
if ((sorted_syms[i]->section == sec || !want_section)
- && info->symbol_is_valid (sorted_syms[i], info))
+ && inf->symbol_is_valid (sorted_syms[i], inf))
{
thisplace = i;
break;
}
if ((sorted_syms[thisplace]->section != sec && want_section)
- || !info->symbol_is_valid (sorted_syms[thisplace], info))
+ || ! inf->symbol_is_valid (sorted_syms[thisplace], inf))
/* There is no suitable symbol. */
return NULL;
}
+ /* If we have not found an exact match for the specified address
+ 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. */
+ if (!want_section
+ && aux->dynrelbuf != NULL
+ && sorted_syms[thisplace]->value != vma
+ /* If we have matched a synthetic symbol, then stick with that. */
+ && (sorted_syms[thisplace]->flags & BSF_SYNTHETIC) == 0)
+ {
+ long rel_count;
+ arelent ** rel_pp;
+
+ for (rel_count = aux->dynrelcount, rel_pp = aux->dynrelbuf;
+ rel_count--;)
+ {
+ arelent * rel = rel_pp[rel_count];
+
+ if (rel->address == vma
+ && rel->sym_ptr_ptr != NULL
+ /* Absolute relocations do not provide a more helpful symbolic address. */
+ && ! bfd_is_abs_section ((* rel->sym_ptr_ptr)->section))
+ {
+ if (place != NULL)
+ * place = thisplace;
+ return * rel->sym_ptr_ptr;
+ }
+
+ /* We are scanning backwards, so if we go below the target address
+ we have failed. */
+ if (rel_pp[rel_count]->address < vma)
+ break;
+ }
+ }
+
if (place != NULL)
*place = thisplace;
static void
objdump_print_addr_with_sym (bfd *abfd, asection *sec, asymbol *sym,
- bfd_vma vma, struct disassemble_info *info,
+ bfd_vma vma, struct disassemble_info *inf,
bfd_boolean skip_zeroes)
{
- objdump_print_value (vma, info, skip_zeroes);
+ objdump_print_value (vma, inf, skip_zeroes);
if (sym == NULL)
{
bfd_vma secaddr;
- (*info->fprintf_func) (info->stream, " <%s",
- bfd_get_section_name (abfd, sec));
+ (*inf->fprintf_func) (inf->stream, " <%s",
+ bfd_get_section_name (abfd, sec));
secaddr = bfd_get_section_vma (abfd, sec);
if (vma < secaddr)
{
- (*info->fprintf_func) (info->stream, "-0x");
- objdump_print_value (secaddr - vma, info, TRUE);
+ (*inf->fprintf_func) (inf->stream, "-0x");
+ objdump_print_value (secaddr - vma, inf, TRUE);
}
else if (vma > secaddr)
{
- (*info->fprintf_func) (info->stream, "+0x");
- objdump_print_value (vma - secaddr, info, TRUE);
+ (*inf->fprintf_func) (inf->stream, "+0x");
+ objdump_print_value (vma - secaddr, inf, TRUE);
}
- (*info->fprintf_func) (info->stream, ">");
+ (*inf->fprintf_func) (inf->stream, ">");
}
else
{
- (*info->fprintf_func) (info->stream, " <");
- objdump_print_symname (abfd, info, sym);
- if (bfd_asymbol_value (sym) > vma)
+ (*inf->fprintf_func) (inf->stream, " <");
+
+ objdump_print_symname (abfd, inf, sym);
+
+ if (bfd_asymbol_value (sym) == vma)
+ ;
+ /* Undefined symbols in an executables and dynamic objects do not have
+ a value associated with them, so it does not make sense to display
+ an offset relative to them. Normally we would not be provided with
+ this kind of symbol, but the target backend might choose to do so,
+ and the code in find_symbol_for_address might return an as yet
+ unresolved symbol associated with a dynamic reloc. */
+ else if ((bfd_get_file_flags (abfd) & (EXEC_P | DYNAMIC))
+ && bfd_is_und_section (sym->section))
+ ;
+ else if (bfd_asymbol_value (sym) > vma)
{
- (*info->fprintf_func) (info->stream, "-0x");
- objdump_print_value (bfd_asymbol_value (sym) - vma, info, TRUE);
+ (*inf->fprintf_func) (inf->stream, "-0x");
+ objdump_print_value (bfd_asymbol_value (sym) - vma, inf, TRUE);
}
else if (vma > bfd_asymbol_value (sym))
{
- (*info->fprintf_func) (info->stream, "+0x");
- objdump_print_value (vma - bfd_asymbol_value (sym), info, TRUE);
+ (*inf->fprintf_func) (inf->stream, "+0x");
+ objdump_print_value (vma - bfd_asymbol_value (sym), inf, TRUE);
}
- (*info->fprintf_func) (info->stream, ">");
+
+ (*inf->fprintf_func) (inf->stream, ">");
}
if (display_file_offsets)
- info->fprintf_func (info->stream, _(" (File Offset: 0x%lx)"),
+ inf->fprintf_func (inf->stream, _(" (File Offset: 0x%lx)"),
(long int)(sec->filepos + (vma - sec->vma)));
}
static void
objdump_print_addr (bfd_vma vma,
- struct disassemble_info *info,
+ struct disassemble_info *inf,
bfd_boolean skip_zeroes)
{
struct objdump_disasm_info *aux;
asymbol *sym = NULL;
bfd_boolean skip_find = FALSE;
- aux = (struct objdump_disasm_info *) info->application_data;
+ aux = (struct objdump_disasm_info *) inf->application_data;
if (sorted_symcount < 1)
{
- (*info->fprintf_func) (info->stream, "0x");
- objdump_print_value (vma, info, skip_zeroes);
+ (*inf->fprintf_func) (inf->stream, "0x");
+ objdump_print_value (vma, inf, skip_zeroes);
if (display_file_offsets)
- info->fprintf_func (info->stream, _(" (File Offset: 0x%lx)"),
- (long int)(aux->sec->filepos + (vma - aux->sec->vma)));
+ inf->fprintf_func (inf->stream, _(" (File Offset: 0x%lx)"),
+ (long int)(aux->sec->filepos + (vma - aux->sec->vma)));
return;
}
}
if (!skip_find)
- sym = find_symbol_for_address (vma, info, NULL);
+ sym = find_symbol_for_address (vma, inf, NULL);
- objdump_print_addr_with_sym (aux->abfd, aux->sec, sym, vma, info,
+ objdump_print_addr_with_sym (aux->abfd, aux->sec, sym, vma, inf,
skip_zeroes);
}
routine. */
static void
-objdump_print_address (bfd_vma vma, struct disassemble_info *info)
+objdump_print_address (bfd_vma vma, struct disassemble_info *inf)
{
- objdump_print_addr (vma, info, ! prefix_addresses);
+ objdump_print_addr (vma, inf, ! prefix_addresses);
}
/* Determine if the given address has a symbol associated with it. */
static int
-objdump_symbol_at_address (bfd_vma vma, struct disassemble_info * info)
+objdump_symbol_at_address (bfd_vma vma, struct disassemble_info * inf)
{
asymbol * sym;
- sym = find_symbol_for_address (vma, info, NULL);
+ sym = find_symbol_for_address (vma, inf, NULL);
return (sym != NULL && (bfd_asymbol_value (sym) == vma));
}
static char *prev_functionname;
static unsigned int prev_line;
+static unsigned int prev_discriminator;
/* We keep a list of all files that we have seen when doing a
disassembly with source, so that we know how much of the file to
struct print_file_list *next;
const char *filename;
const char *modname;
- const char *map;
+ const char *map;
size_t mapsize;
- const char **linemap;
+ const char **linemap;
unsigned maxline;
unsigned last_line;
+ unsigned max_printed;
int first;
};
if (fd < 0)
return NULL;
if (fstat (fd, &st) < 0)
- return NULL;
+ {
+ close (fd);
+ return NULL;
+ }
*size = st.st_size;
#ifdef HAVE_MMAP
msize = (*size + ps - 1) & ~(ps - 1);
map = mmap (NULL, msize, PROT_READ, MAP_SHARED, fd, 0);
- if (map != (char *)-1L)
+ if (map != (char *) -1L)
{
- close(fd);
- return map;
+ close (fd);
+ return map;
}
#endif
- map = malloc (*size);
- if (!map || (size_t) read (fd, (char *)map, *size) != *size)
- {
- free ((void *)map);
+ map = (const char *) malloc (*size);
+ if (!map || (size_t) read (fd, (char *) map, *size) != *size)
+ {
+ free ((void *) map);
map = NULL;
}
close (fd);
- return map;
+ return map;
}
#define line_map_decrease 5
/* Precompute array of lines for a mapped file. */
-static const char **
-index_file (const char *map, size_t size, unsigned int *maxline)
+static const char **
+index_file (const char *map, size_t size, unsigned int *maxline)
{
const char *p, *lstart, *end;
int chars_per_line = 45; /* First iteration will use 40. */
unsigned int lineno;
- const char **linemap = NULL;
+ const char **linemap = NULL;
unsigned long line_map_size = 0;
-
+
lineno = 0;
lstart = map;
end = map + size;
- for (p = map; p < end; p++)
- {
- if (*p == '\n')
- {
- if (p + 1 < end && p[1] == '\r')
- p++;
- }
- else if (*p == '\r')
- {
+ for (p = map; p < end; p++)
+ {
+ if (*p == '\n')
+ {
+ if (p + 1 < end && p[1] == '\r')
+ p++;
+ }
+ else if (*p == '\r')
+ {
if (p + 1 < end && p[1] == '\n')
p++;
}
else
continue;
-
+
/* End of line found. */
- if (linemap == NULL || line_map_size < lineno + 1)
- {
+ if (linemap == NULL || line_map_size < lineno + 1)
+ {
unsigned long newsize;
chars_per_line -= line_map_decrease;
if (line_map_size < lineno + 1)
line_map_size = lineno + 1;
newsize = line_map_size * sizeof (char *);
- linemap = xrealloc (linemap, newsize);
+ linemap = (const char **) xrealloc (linemap, newsize);
}
- linemap[lineno++] = lstart;
- lstart = p + 1;
+ linemap[lineno++] = lstart;
+ lstart = p + 1;
}
-
- *maxline = lineno;
+
+ *maxline = lineno;
return linemap;
}
{
struct print_file_list *p;
- p = xmalloc (sizeof (struct print_file_list));
+ p = (struct print_file_list *) xmalloc (sizeof (struct print_file_list));
p->map = slurp_file (modname, &p->mapsize);
if (p->map == NULL)
free (p);
return NULL;
}
-
+
p->linemap = index_file (p->map, p->mapsize, &p->maxline);
p->last_line = 0;
+ p->max_printed = 0;
p->filename = origname;
p->modname = modname;
p->next = print_files;
return p;
}
-/* If the the source file, as described in the symtab, is not found
+/* If the source file, as described in the symtab, is not found
try to locate it in one of the paths specified with -I
If found, add location to print_files linked list. */
const char *fname;
int i;
- if (filename == NULL)
- return NULL;
-
p = try_print_file_open (filename, filename);
if (p != NULL)
return p;
return NULL;
/* Get the name of the file. */
- fname = strrchr (filename, '/');
-#ifdef HAVE_DOS_BASED_FILE_SYSTEM
- {
- /* We could have a mixed forward/back slash case. */
- char *backslash = strrchr (filename, '\\');
- if (fname == NULL || (backslash != NULL && backslash > fname))
- fname = backslash;
- if (fname == NULL && filename[0] != '\0' && filename[1] == ':')
- fname = filename + 1;
- }
-#endif
- if (fname == NULL)
- fname = filename;
- else
- ++fname;
+ fname = lbasename (filename);
/* If file exists under a new path, we need to add it to the list
so that show_line knows about it. */
/* Print a source file line. */
-static void
-print_line (struct print_file_list *p, unsigned int line)
+static void
+print_line (struct print_file_list *p, unsigned int linenum)
{
const char *l;
size_t len;
-
- --line;
- if (line >= p->maxline)
+
+ --linenum;
+ if (linenum >= p->maxline)
return;
- l = p->linemap [line];
+ l = p->linemap [linenum];
/* Test fwrite return value to quiet glibc warning. */
len = strcspn (l, "\n\r");
if (len == 0 || fwrite (l, len, 1, stdout) == 1)
{
if (p->map == NULL)
return;
- while (start <= end)
+ while (start <= end)
{
print_line (p, start);
start++;
{
const char *filename;
const char *functionname;
- unsigned int line;
+ unsigned int linenumber;
+ unsigned int discriminator;
bfd_boolean reloc;
+ char *path = NULL;
if (! with_line_numbers && ! with_source_code)
return;
- if (! bfd_find_nearest_line (abfd, section, syms, addr_offset, &filename,
- &functionname, &line))
+ if (! bfd_find_nearest_line_discriminator (abfd, section, syms, addr_offset,
+ &filename, &functionname,
+ &linenumber, &discriminator))
return;
if (filename != NULL && *filename == '\0')
{
char *path_up;
const char *fname = filename;
- char *path = (char *) alloca (prefix_length + PATH_MAX + 1);
+
+ path = xmalloc (prefix_length + PATH_MAX + 1);
if (prefix_length)
memcpy (path, prefix, prefix_length);
path_up = path + prefix_length;
/* Build relocated filename, stripping off leading directories
- from the initial filename if requested. */
+ from the initial filename if requested. */
if (prefix_strip > 0)
{
int level = 0;
const char *s;
- /* Skip selected directory levels. */
+ /* Skip selected directory levels. */
for (s = fname + 1; *s != '\0' && level < prefix_strip; s++)
if (IS_DIR_SEPARATOR(*s))
{
}
}
- /* Update complete filename. */
+ /* Update complete filename. */
strncpy (path_up, fname, PATH_MAX);
path_up[PATH_MAX] = '\0';
&& (prev_functionname == NULL
|| strcmp (functionname, prev_functionname) != 0))
printf ("%s():\n", functionname);
- if (line > 0 && line != prev_line)
- printf ("%s:%u\n", filename == NULL ? "???" : filename, line);
+ if (linenumber > 0 && (linenumber != prev_line ||
+ (discriminator != prev_discriminator)))
+ {
+ if (discriminator > 0)
+ printf ("%s:%u (discriminator %u)\n", filename == NULL ? "???" : filename,
+ linenumber, discriminator);
+ else
+ printf ("%s:%u\n", filename == NULL ? "???" : filename, linenumber);
+ }
}
if (with_source_code
&& filename != NULL
- && line > 0)
+ && linenumber > 0)
{
struct print_file_list **pp, *p;
unsigned l;
for (pp = &print_files; *pp != NULL; pp = &(*pp)->next)
- if (strcmp ((*pp)->filename, filename) == 0)
+ if (filename_cmp ((*pp)->filename, filename) == 0)
break;
p = *pp;
p = update_source_path (filename);
}
- if (p != NULL && line != p->last_line)
+ if (p != NULL && linenumber != p->last_line)
{
- if (file_start_context && p->first)
+ if (file_start_context && p->first)
l = 1;
- else
+ else
{
- l = line - SHOW_PRECEDING_CONTEXT_LINES;
- if (l >= line)
+ l = linenumber - SHOW_PRECEDING_CONTEXT_LINES;
+ if (l >= linenumber)
l = 1;
- if (p->last_line >= l && p->last_line <= line)
- l = p->last_line + 1;
+ if (p->max_printed >= l)
+ {
+ if (p->max_printed < linenumber)
+ l = p->max_printed + 1;
+ else
+ l = linenumber;
+ }
}
- dump_lines (p, l, line);
- p->last_line = line;
+ dump_lines (p, l, linenumber);
+ if (p->max_printed < linenumber)
+ p->max_printed = linenumber;
+ p->last_line = linenumber;
p->first = 0;
}
}
{
if (prev_functionname != NULL)
free (prev_functionname);
- prev_functionname = xmalloc (strlen (functionname) + 1);
+ prev_functionname = (char *) xmalloc (strlen (functionname) + 1);
strcpy (prev_functionname, functionname);
}
- if (line > 0 && line != prev_line)
- prev_line = line;
+ if (linenumber > 0 && linenumber != prev_line)
+ prev_line = linenumber;
+
+ if (discriminator != prev_discriminator)
+ prev_discriminator = discriminator;
+
+ if (path)
+ free (path);
}
/* Pseudo FILE object for strings. */
while (1)
{
size_t space = f->alloc - f->pos;
-
+
va_start (args, format);
n = vsnprintf (f->buffer + f->pos, space, format, args);
va_end (args);
if (space > n)
break;
-
+
f->alloc = (f->alloc + n) * 2;
- f->buffer = xrealloc (f->buffer, f->alloc);
+ f->buffer = (char *) xrealloc (f->buffer, f->alloc);
}
f->pos += n;
-
+
return n;
}
/* Disassemble some data in memory between given values. */
static void
-disassemble_bytes (struct disassemble_info * info,
+disassemble_bytes (struct disassemble_info * inf,
disassembler_ftype disassemble_fn,
bfd_boolean insns,
bfd_byte * data,
struct objdump_disasm_info *aux;
asection *section;
int octets_per_line;
- bfd_boolean done_dot;
int skip_addr_chars;
bfd_vma addr_offset;
- unsigned int opb = info->octets_per_byte;
- unsigned int skip_zeroes = info->skip_zeroes;
- unsigned int skip_zeroes_at_end = info->skip_zeroes_at_end;
+ unsigned int opb = inf->octets_per_byte;
+ unsigned int skip_zeroes = inf->skip_zeroes;
+ unsigned int skip_zeroes_at_end = inf->skip_zeroes_at_end;
int octets = opb;
SFILE sfile;
- aux = (struct objdump_disasm_info *) info->application_data;
+ aux = (struct objdump_disasm_info *) inf->application_data;
section = aux->sec;
sfile.alloc = 120;
- sfile.buffer = xmalloc (sfile.alloc);
+ sfile.buffer = (char *) xmalloc (sfile.alloc);
sfile.pos = 0;
-
+
if (insn_width)
octets_per_line = insn_width;
else if (insns)
skip_addr_chars = (skip_addr_chars - 1) & -4;
}
- info->insn_info_valid = 0;
+ inf->insn_info_valid = 0;
- done_dot = FALSE;
addr_offset = start_offset;
while (addr_offset < stop_offset)
{
previous_octets = octets;
octets = 0;
+ /* Make sure we don't use relocs from previous instructions. */
+ aux->reloc = NULL;
+
/* If we see more than SKIP_ZEROES octets of zeroes, we just
print `...'. */
for (z = addr_offset * opb; z < stop_offset * opb; z++)
if (data[z] != 0)
break;
if (! disassemble_zeroes
- && (info->insn_info_valid == 0
- || info->branch_delay_insns == 0)
+ && (inf->insn_info_valid == 0
+ || inf->branch_delay_insns == 0)
&& (z - addr_offset * opb >= skip_zeroes
|| (z == stop_offset * opb &&
z - addr_offset * opb < skip_zeroes_at_end)))
int bpc = 0;
int pb = 0;
- done_dot = FALSE;
-
if (with_line_numbers || with_source_code)
show_line (aux->abfd, section, addr_offset);
else
{
aux->require_sec = TRUE;
- objdump_print_address (section->vma + addr_offset, info);
+ objdump_print_address (section->vma + addr_offset, inf);
aux->require_sec = FALSE;
putchar (' ');
}
if (insns)
{
sfile.pos = 0;
- info->fprintf_func = (fprintf_ftype) objdump_sprintf;
- info->stream = &sfile;
- info->bytes_per_line = 0;
- info->bytes_per_chunk = 0;
- info->flags = disassemble_all ? DISASSEMBLE_DATA : 0;
+ inf->fprintf_func = (fprintf_ftype) objdump_sprintf;
+ inf->stream = &sfile;
+ inf->bytes_per_line = 0;
+ inf->bytes_per_chunk = 0;
+ inf->flags = disassemble_all ? DISASSEMBLE_DATA : 0;
if (machine)
- info->flags |= USER_SPECIFIED_MACHINE_TYPE;
+ inf->flags |= USER_SPECIFIED_MACHINE_TYPE;
- if (info->disassembler_needs_relocs
+ if (inf->disassembler_needs_relocs
&& (bfd_get_file_flags (aux->abfd) & EXEC_P) == 0
&& (bfd_get_file_flags (aux->abfd) & DYNAMIC) == 0
&& *relppp < relppend)
|| (distance_to_rel > 0
&& distance_to_rel < (bfd_signed_vma) (previous_octets/ opb)))
{
- info->flags |= INSN_HAS_RELOC;
+ inf->flags |= INSN_HAS_RELOC;
aux->reloc = **relppp;
}
- else
- aux->reloc = NULL;
}
- octets = (*disassemble_fn) (section->vma + addr_offset, info);
- info->fprintf_func = (fprintf_ftype) fprintf;
- info->stream = stdout;
- if (insn_width == 0 && info->bytes_per_line != 0)
- octets_per_line = info->bytes_per_line;
- if (octets < 0)
+ if (! disassemble_all
+ && (section->flags & (SEC_CODE | SEC_HAS_CONTENTS))
+ == (SEC_CODE | SEC_HAS_CONTENTS))
+ /* Set a stop_vma so that the disassembler will not read
+ beyond the next symbol. We assume that symbols appear on
+ the boundaries between instructions. We only do this when
+ disassembling code of course, and when -D is in effect. */
+ inf->stop_vma = section->vma + stop_offset;
+
+ octets = (*disassemble_fn) (section->vma + addr_offset, inf);
+
+ inf->stop_vma = 0;
+ inf->fprintf_func = (fprintf_ftype) fprintf;
+ inf->stream = stdout;
+ if (insn_width == 0 && inf->bytes_per_line != 0)
+ octets_per_line = inf->bytes_per_line;
+ if (octets < (int) opb)
{
if (sfile.pos)
printf ("%s\n", sfile.buffer);
+ if (octets >= 0)
+ {
+ non_fatal (_("disassemble_fn returned length %d"),
+ octets);
+ exit_status = 1;
+ }
break;
}
}
if (pb > octets_per_line && ! prefix_addresses && ! wide_output)
pb = octets_per_line;
- if (info->bytes_per_chunk)
- bpc = info->bytes_per_chunk;
+ if (inf->bytes_per_chunk)
+ bpc = inf->bytes_per_chunk;
else
bpc = 1;
{
int k;
- if (bpc > 1 && info->display_endian == BFD_ENDIAN_LITTLE)
+ if (bpc > 1 && inf->display_endian == BFD_ENDIAN_LITTLE)
{
for (k = bpc - 1; k >= 0; k--)
printf ("%02x", (unsigned) data[j + k]);
{
int k;
- if (bpc > 1 && info->display_endian == BFD_ENDIAN_LITTLE)
+ if (bpc > 1 && inf->display_endian == BFD_ENDIAN_LITTLE)
{
for (k = bpc - 1; k >= 0; k--)
printf ("%02x", (unsigned) data[j + k]);
printf ("\t\t\t");
objdump_print_value (section->vma - rel_offset + q->address,
- info, TRUE);
+ inf, TRUE);
if (q->howto == NULL)
printf (": *unknown*\t");
sym_name = bfd_asymbol_name (*q->sym_ptr_ptr);
if (sym_name != NULL && *sym_name != '\0')
- objdump_print_symname (aux->abfd, info, *q->sym_ptr_ptr);
+ objdump_print_symname (aux->abfd, inf, *q->sym_ptr_ptr);
else
{
asection *sym_sec;
if (q->addend)
{
- printf ("+0x");
- objdump_print_value (q->addend, info, TRUE);
+ bfd_signed_vma addend = q->addend;
+ if (addend < 0)
+ {
+ printf ("-0x");
+ addend = -addend;
+ }
+ else
+ printf ("+0x");
+ objdump_print_value (addend, inf, TRUE);
}
printf ("\n");
}
static void
-disassemble_section (bfd *abfd, asection *section, void *info)
+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 *) info;
+ struct disassemble_info * pinfo = (struct disassemble_info *) inf;
struct objdump_disasm_info * paux;
unsigned int opb = pinfo->octets_per_byte;
bfd_byte * data = NULL;
arelent ** rel_pp = NULL;
arelent ** rel_ppstart = NULL;
arelent ** rel_ppend;
- unsigned long stop_offset;
+ bfd_vma stop_offset;
asymbol * sym = NULL;
long place = 0;
long rel_count;
/* Sections that do not contain machine
code are not normally disassembled. */
if (! disassemble_all
- && only == NULL
+ && only_list == NULL
&& ((section->flags & (SEC_CODE | SEC_HAS_CONTENTS))
!= (SEC_CODE | SEC_HAS_CONTENTS)))
return;
if (datasize == 0)
return;
+ if (start_address == (bfd_vma) -1
+ || start_address < section->vma)
+ addr_offset = 0;
+ else
+ addr_offset = start_address - section->vma;
+
+ if (stop_address == (bfd_vma) -1)
+ stop_offset = datasize / opb;
+ else
+ {
+ if (stop_address < section->vma)
+ stop_offset = 0;
+ else
+ stop_offset = stop_address - section->vma;
+ if (stop_offset > datasize / opb)
+ stop_offset = datasize / opb;
+ }
+
+ if (addr_offset >= stop_offset)
+ return;
+
/* Decide which set of relocs to use. Load them if necessary. */
paux = (struct objdump_disasm_info *) pinfo->application_data;
- if (paux->dynrelbuf)
+ if (paux->dynrelbuf && dump_dynamic_reloc_info)
{
rel_pp = paux->dynrelbuf;
rel_count = paux->dynrelcount;
if (relsize > 0)
{
- rel_ppstart = rel_pp = xmalloc (relsize);
+ rel_ppstart = rel_pp = (arelent **) xmalloc (relsize);
rel_count = bfd_canonicalize_reloc (abfd, section, rel_pp, syms);
if (rel_count < 0)
bfd_fatal (bfd_get_filename (abfd));
}
rel_ppend = rel_pp + rel_count;
- data = xmalloc (datasize);
+ data = (bfd_byte *) xmalloc (datasize);
bfd_get_section_contents (abfd, section, data, 0, datasize);
pinfo->buffer_length = datasize;
pinfo->section = section;
- if (start_address == (bfd_vma) -1
- || start_address < pinfo->buffer_vma)
- addr_offset = 0;
- else
- addr_offset = start_address - pinfo->buffer_vma;
-
- if (stop_address == (bfd_vma) -1)
- stop_offset = datasize / opb;
- else
- {
- if (stop_address < pinfo->buffer_vma)
- stop_offset = 0;
- else
- stop_offset = stop_address - pinfo->buffer_vma;
- if (stop_offset > pinfo->buffer_length / opb)
- stop_offset = pinfo->buffer_length / opb;
- }
-
/* Skip over the relocs belonging to addresses below the
start address. */
while (rel_pp < rel_ppend
&& (*rel_pp)->address < rel_offset + addr_offset)
++rel_pp;
- if (addr_offset < stop_offset)
- printf (_("\nDisassembly of section %s:\n"), section->name);
+ printf (_("\nDisassembly of section %s:\n"), section->name);
/* Find the nearest symbol forwards from our current position. */
paux->require_sec = TRUE;
- sym = find_symbol_for_address (section->vma + addr_offset, info, &place);
+ sym = (asymbol *) find_symbol_for_address (section->vma + addr_offset,
+ (struct disassemble_info *) inf,
+ &place);
paux->require_sec = FALSE;
- /* PR 9774: If the target used signed 32-bit addresses then we must make
- sure that we sign extend the value that we calculate for 'addr' in the
- loop below. */
+ /* PR 9774: If the target used signed addresses then we must make
+ sure that we sign extend the value that we calculate for 'addr'
+ in the loop below. */
if (bfd_get_flavour (abfd) == bfd_target_elf_flavour
&& (bed = get_elf_backend_data (abfd)) != NULL
&& bed->sign_extend_vma)
- sign_adjust = 0x80000000;
+ sign_adjust = (bfd_vma) 1 << (bed->s->arch_size - 1);
/* Disassemble a block of instructions up to the address associated with
the symbol we have just found. Then print the symbol and find the
{
bfd_vma addr;
asymbol *nextsym;
- unsigned long nextstop_offset;
+ bfd_vma nextstop_offset;
bfd_boolean insns;
addr = section->vma + addr_offset;
((SYM)->section == section \
&& (bfd_asymbol_value (SYM) > bfd_asymbol_value (sym)) \
&& pinfo->symbol_is_valid (SYM, pinfo))
-
+
/* Search forward for the next appropriate symbol in
SECTION. Note that all the symbols are sorted
together into one big array, and that some sections
disassemble_bytes (pinfo, paux->disassemble_fn, insns, data,
addr_offset, nextstop_offset,
rel_offset, &rel_pp, rel_ppend);
-
+
addr_offset = nextstop_offset;
sym = nextsym;
}
print_files = NULL;
prev_functionname = NULL;
prev_line = -1;
+ prev_discriminator = 0;
/* We make a copy of syms to sort. We don't want to sort syms
because that will screw up the relocs. */
sorted_symcount = symcount ? symcount : dynsymcount;
- sorted_syms = xmalloc ((sorted_symcount + synthcount) * sizeof (asymbol *));
+ sorted_syms = (asymbol **) xmalloc ((sorted_symcount + synthcount)
+ * sizeof (asymbol *));
memcpy (sorted_syms, symcount ? syms : dynsyms,
sorted_symcount * sizeof (asymbol *));
if (machine != NULL)
{
- const bfd_arch_info_type *info = bfd_scan_arch (machine);
+ const bfd_arch_info_type *inf = bfd_scan_arch (machine);
- if (info == NULL)
- fatal (_("Can't use supplied machine %s"), machine);
+ if (inf == NULL)
+ fatal (_("can't use supplied machine %s"), machine);
- abfd->arch_info = info;
+ abfd->arch_info = inf;
}
if (endian != BFD_ENDIAN_UNKNOWN)
{
struct bfd_target *xvec;
- xvec = xmalloc (sizeof (struct bfd_target));
+ xvec = (struct bfd_target *) xmalloc (sizeof (struct bfd_target));
memcpy (xvec, abfd->xvec, sizeof (struct bfd_target));
xvec->byteorder = endian;
abfd->xvec = xvec;
aux.disassemble_fn = disassembler (abfd);
if (!aux.disassemble_fn)
{
- non_fatal (_("Can't disassemble for architecture %s\n"),
+ non_fatal (_("can't disassemble for architecture %s\n"),
bfd_printable_arch_mach (bfd_get_arch (abfd), 0));
exit_status = 1;
return;
/* Allow the target to customize the info structure. */
disassemble_init_for_target (& disasm_info);
- /* Pre-load the dynamic relocs if we are going
- to be dumping them along with the disassembly. */
- if (dump_dynamic_reloc_info)
+ /* Pre-load the dynamic relocs as we may need them during the disassembly. */
{
long relsize = bfd_get_dynamic_reloc_upper_bound (abfd);
-
- if (relsize < 0)
+
+ if (relsize < 0 && dump_dynamic_reloc_info)
bfd_fatal (bfd_get_filename (abfd));
if (relsize > 0)
{
- aux.dynrelbuf = xmalloc (relsize);
+ aux.dynrelbuf = (arelent **) xmalloc (relsize);
aux.dynrelcount = bfd_canonicalize_dynamic_reloc (abfd,
aux.dynrelbuf,
dynsyms);
asection *sec, void *file)
{
struct dwarf_section *section = &debug_displays [debug].section;
- bfd *abfd = file;
+ bfd *abfd = (bfd *) file;
bfd_boolean ret;
- int section_is_compressed;
/* If it is already loaded, do nothing. */
if (section->start != NULL)
return 1;
- section_is_compressed = section->name == section->compressed_name;
-
- section->address = 0;
+ section->reloc_info = NULL;
+ section->num_relocs = 0;
+ section->address = bfd_get_section_vma (abfd, sec);
section->size = bfd_get_section_size (sec);
- section->start = xmalloc (section->size);
-
- if (is_relocatable && debug_displays [debug].relocate)
- ret = bfd_simple_get_relocated_section_contents (abfd,
- sec,
- section->start,
- syms) != NULL;
- else
- ret = bfd_get_section_contents (abfd, sec, section->start, 0,
- section->size);
+ section->start = NULL;
+ section->user_data = sec;
+ ret = bfd_get_full_section_contents (abfd, sec, §ion->start);
if (! ret)
{
return 0;
}
- if (section_is_compressed)
+ if (is_relocatable && debug_displays [debug].relocate)
{
- bfd_size_type size = section->size;
- if (! bfd_uncompress_section_contents (§ion->start, &size))
+ 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 uncompress section '%s'.\n"), section->name);
+ printf (_("\nCan't get contents for section '%s'.\n"),
+ section->name);
return 0;
}
- section->size = size;
+
+ long reloc_size;
+
+ reloc_size = bfd_get_reloc_upper_bound (abfd, sec);
+ if (reloc_size > 0)
+ {
+ 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;
+ }
+ }
}
return 1;
}
+bfd_boolean
+reloc_at (struct dwarf_section * dsec, dwarf_vma offset)
+{
+ arelent ** relocs;
+ arelent * rp;
+
+ if (dsec == NULL || dsec->reloc_info == NULL)
+ return FALSE;
+
+ relocs = (arelent **) dsec->reloc_info;
+
+ for (; (rp = * relocs) != NULL; ++ relocs)
+ if (rp->address == offset)
+ return TRUE;
+
+ return FALSE;
+}
+
int
load_debug_section (enum dwarf_section_display_enum debug, void *file)
{
struct dwarf_section *section = &debug_displays [debug].section;
- bfd *abfd = file;
+ bfd *abfd = (bfd *) file;
asection *sec;
/* If it is already loaded, do nothing. */
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 *name = bfd_get_section_name (abfd, section);
const char *match;
- enum dwarf_section_display_enum i;
+ int i;
if (CONST_STRNEQ (name, ".gnu.linkonce.wi."))
match = ".debug_info";
sec->name = sec->uncompressed_name;
else
sec->name = sec->compressed_name;
- if (load_specific_debug_section (i, section, abfd))
+ if (load_specific_debug_section ((enum dwarf_section_display_enum) i,
+ section, abfd))
{
debug_displays [i].display (sec, abfd);
-
+
if (i != info && i != abbrev)
- free_debug_section (i);
+ free_debug_section ((enum dwarf_section_display_enum) i);
}
break;
}
{
is_relocatable = (abfd->flags & (EXEC_P | DYNAMIC)) == 0;
- /* FIXME: bfd_get_arch_size may return -1. We assume that 64bit
- targets will return 64. */
- eh_addr_size = bfd_get_arch_size (abfd) == 64 ? 8 : 4;
+ eh_addr_size = bfd_arch_bits_per_address (abfd) / 8;
if (bfd_big_endian (abfd))
byte_get = byte_get_big_endian;
else if (bfd_little_endian (abfd))
byte_get = byte_get_little_endian;
else
- abort ();
+ /* PR 17512: file: objdump-s-endless-loop.tekhex. */
+ {
+ warn (_("File %s does not contain any dwarf debug information\n"),
+ bfd_get_filename (abfd));
+ return;
+ }
- if (bfd_get_flavour (abfd) == bfd_target_elf_flavour)
+ switch (bfd_get_arch (abfd))
{
- const struct elf_backend_data *bed = get_elf_backend_data (abfd);
- init_dwarf_regnames (bed->elf_machine_code);
+ case bfd_arch_i386:
+ switch (bfd_get_mach (abfd))
+ {
+ case bfd_mach_x86_64:
+ case bfd_mach_x86_64_intel_syntax:
+ case bfd_mach_x86_64_nacl:
+ case bfd_mach_x64_32:
+ case bfd_mach_x64_32_intel_syntax:
+ case bfd_mach_x64_32_nacl:
+ init_dwarf_regnames_x86_64 ();
+ break;
+
+ default:
+ init_dwarf_regnames_i386 ();
+ break;
+ }
+ break;
+
+ case bfd_arch_iamcu:
+ init_dwarf_regnames_iamcu ();
+ break;
+
+ case bfd_arch_aarch64:
+ init_dwarf_regnames_aarch64();
+ break;
+
+ case bfd_arch_s390:
+ init_dwarf_regnames_s390 ();
+ break;
+
+ default:
+ break;
}
bfd_map_over_sections (abfd, dump_dwarf_section, NULL);
}
size = bfd_section_size (abfd, stabsect);
- contents = xmalloc (size);
+ contents = (char *) xmalloc (size);
if (! bfd_get_section_contents (abfd, stabsect, contents, 0, size))
{
- non_fatal (_("Reading %s section of %s failed: %s"),
+ non_fatal (_("reading %s section of %s failed: %s"),
sect_name, bfd_get_filename (abfd),
bfd_errmsg (bfd_get_error ()));
- free (contents);
exit_status = 1;
+ free (contents);
return NULL;
}
We start the index at -1 because there is a dummy symbol on
the front of stabs-in-{coff,elf} sections that supplies sizes. */
- for (i = -1; stabp < stabs_end; stabp += STABSIZE, i++)
+ for (i = -1; stabp <= stabs_end - STABSIZE; stabp += STABSIZE, i++)
{
const char *name;
unsigned long strx;
}
else
{
+ bfd_size_type amt = strx + file_string_table_offset;
+
/* Using the (possibly updated) string table offset, print the
string (if any) associated with this symbol. */
- if ((strx + file_string_table_offset) < stabstr_size)
- printf (" %s", &strtab[strx + file_string_table_offset]);
+ if (amt < stabstr_size)
+ /* PR 17512: file: 079-79389-0.001:0.1. */
+ printf (" %.*s", (int)(stabstr_size - amt), strtab + amt);
else
printf (" *");
}
if (strtab == NULL)
strtab = read_section_stabs (abfd, sought->string_section_name,
&stabstr_size);
-
+
if (strtab)
{
stabs = (bfd_byte *) read_section_stabs (abfd, section->name,
printf (_("architecture: %s, "),
bfd_printable_arch_mach (bfd_get_arch (abfd),
bfd_get_mach (abfd)));
- printf (_("flags 0x%08x:\n"), abfd->flags);
+ printf (_("flags 0x%08x:\n"), abfd->flags & ~BFD_FLAGS_FOR_BFD_USE_MASK);
#define PF(x, y) if (abfd->flags & x) {printf("%s%s", comma, y); comma=", ";}
PF (HAS_RELOC, "HAS_RELOC");
PF (WP_TEXT, "WP_TEXT");
PF (D_PAGED, "D_PAGED");
PF (BFD_IS_RELAXABLE, "BFD_IS_RELAXABLE");
- PF (HAS_LOAD_PAGE, "HAS_LOAD_PAGE");
printf (_("\nstart address 0x"));
bfd_printf_vma (abfd, abfd->start_address);
printf ("\n");
bfd_print_private_bfd_data (abfd, stdout);
}
+static void
+dump_target_specific (bfd *abfd)
+{
+ const struct objdump_private_desc * const *desc;
+ struct objdump_private_option *opt;
+ char *e, *b;
+
+ /* Find the desc. */
+ for (desc = objdump_private_vectors; *desc != NULL; desc++)
+ if ((*desc)->filter (abfd))
+ break;
+
+ if (*desc == NULL)
+ {
+ non_fatal (_("option -P/--private not supported by this file"));
+ return;
+ }
+
+ /* Clear all options. */
+ for (opt = (*desc)->options; opt->name; opt++)
+ opt->selected = FALSE;
+
+ /* Decode options. */
+ b = dump_private_options;
+ do
+ {
+ e = strchr (b, ',');
+
+ if (e)
+ *e = 0;
+
+ for (opt = (*desc)->options; opt->name; opt++)
+ if (strcmp (opt->name, b) == 0)
+ {
+ opt->selected = TRUE;
+ break;
+ }
+ if (opt->name == NULL)
+ non_fatal (_("target specific dump '%s' not supported"), b);
+
+ if (e)
+ {
+ *e = ',';
+ b = e + 1;
+ }
+ }
+ while (e != NULL);
+
+ /* Dump. */
+ (*desc)->dump (abfd);
+}
\f
/* Display a section in hexadecimal format with associated characters.
Each line prefixed by the zero padded address. */
{
bfd_byte *data = 0;
bfd_size_type datasize;
- bfd_size_type addr_offset;
- bfd_size_type start_offset;
- bfd_size_type stop_offset;
+ bfd_vma addr_offset;
+ bfd_vma start_offset;
+ bfd_vma stop_offset;
unsigned int opb = bfd_octets_per_byte (abfd);
/* Bytes per line. */
const int onaline = 16;
if (! process_section_p (section))
return;
-
+
if ((datasize = bfd_section_size (abfd, section)) == 0)
return;
if (start_offset >= stop_offset)
return;
-
+
printf (_("Contents of section %s:"), section->name);
if (display_file_offsets)
printf (_(" (Starting at file offset: 0x%lx)"),
(unsigned long) (section->filepos + start_offset));
printf ("\n");
- data = xmalloc (datasize);
-
- bfd_get_section_contents (abfd, section, data, 0, datasize);
+ if (!bfd_get_full_section_contents (abfd, section, &data))
+ {
+ non_fatal (_("Reading section %s failed because: %s"),
+ section->name, bfd_errmsg (bfd_get_error ()));
+ return;
+ }
width = 4;
dump_symbols (bfd *abfd ATTRIBUTE_UNUSED, bfd_boolean dynamic)
{
asymbol **current;
- long max;
+ long max_count;
long count;
if (dynamic)
{
current = dynsyms;
- max = dynsymcount;
+ max_count = dynsymcount;
printf ("DYNAMIC SYMBOL TABLE:\n");
}
else
{
current = syms;
- max = symcount;
+ max_count = symcount;
printf ("SYMBOL TABLE:\n");
}
- if (max == 0)
+ if (max_count == 0)
printf (_("no symbols\n"));
- for (count = 0; count < max; count++)
+ for (count = 0; count < max_count; count++)
{
bfd *cur_bfd;
arelent **p;
char *last_filename, *last_functionname;
unsigned int last_line;
+ unsigned int last_discriminator;
/* Get column headers lined up reasonably. */
{
last_filename = NULL;
last_functionname = NULL;
last_line = 0;
+ last_discriminator = 0;
for (p = relpp; relcount && *p != NULL; p++, relcount--)
{
arelent *q = *p;
const char *filename, *functionname;
- unsigned int line;
+ unsigned int linenumber;
+ unsigned int discriminator;
const char *sym_name;
const char *section_name;
+ bfd_vma addend2 = 0;
if (start_address != (bfd_vma) -1
&& q->address < start_address)
if (with_line_numbers
&& sec != NULL
- && bfd_find_nearest_line (abfd, sec, syms, q->address,
- &filename, &functionname, &line))
+ && bfd_find_nearest_line_discriminator (abfd, sec, syms, q->address,
+ &filename, &functionname,
+ &linenumber, &discriminator))
{
if (functionname != NULL
&& (last_functionname == NULL
last_functionname = xstrdup (functionname);
}
- if (line > 0
- && (line != last_line
+ if (linenumber > 0
+ && (linenumber != last_line
|| (filename != NULL
&& last_filename != NULL
- && strcmp (filename, last_filename) != 0)))
+ && filename_cmp (filename, last_filename) != 0)
+ || (discriminator != last_discriminator)))
{
- printf ("%s:%u\n", filename == NULL ? "???" : filename, line);
- last_line = line;
+ if (discriminator > 0)
+ printf ("%s:%u\n", filename == NULL ? "???" : filename, linenumber);
+ else
+ printf ("%s:%u (discriminator %u)\n", filename == NULL ? "???" : filename,
+ linenumber, discriminator);
+ last_line = linenumber;
+ last_discriminator = discriminator;
if (last_filename != NULL)
free (last_filename);
if (filename == NULL)
if (q->howto == NULL)
printf (" *unknown* ");
else if (q->howto->name)
- printf (" %-16s ", q->howto->name);
+ {
+ const char *name = q->howto->name;
+
+ /* R_SPARC_OLO10 relocations contain two addends.
+ But because 'arelent' lacks enough storage to
+ store them both, the 64-bit ELF Sparc backend
+ records this as two relocations. One R_SPARC_LO10
+ and one R_SPARC_13, both pointing to the same
+ address. This is merely so that we have some
+ place to store both addend fields.
+
+ Undo this transformation, otherwise the output
+ will be confusing. */
+ if (abfd->xvec->flavour == bfd_target_elf_flavour
+ && elf_tdata(abfd)->elf_header->e_machine == EM_SPARCV9
+ && relcount > 1
+ && !strcmp (q->howto->name, "R_SPARC_LO10"))
+ {
+ arelent *q2 = *(p + 1);
+ if (q2 != NULL
+ && q2->howto
+ && q->address == q2->address
+ && !strcmp (q2->howto->name, "R_SPARC_13"))
+ {
+ name = "R_SPARC_OLO10";
+ addend2 = q2->addend;
+ p++;
+ }
+ }
+ printf (" %-16s ", name);
+ }
else
printf (" %-16d ", q->howto->type);
}
if (q->addend)
+ {
+ bfd_signed_vma addend = q->addend;
+ if (addend < 0)
+ {
+ printf ("-0x");
+ addend = -addend;
+ }
+ else
+ printf ("+0x");
+ bfd_printf_vma (abfd, addend);
+ }
+ if (addend2)
{
printf ("+0x");
- bfd_printf_vma (abfd, q->addend);
+ bfd_printf_vma (abfd, addend2);
}
printf ("\n");
}
+
+ if (last_filename != NULL)
+ free (last_filename);
+ if (last_functionname != NULL)
+ free (last_functionname);
}
static void
return;
}
- relpp = xmalloc (relsize);
+ relpp = (arelent **) xmalloc (relsize);
relcount = bfd_canonicalize_reloc (abfd, section, relpp, syms);
if (relcount < 0)
- bfd_fatal (bfd_get_filename (abfd));
+ {
+ printf ("\n");
+ non_fatal (_("failed to read relocs in: %s"), bfd_get_filename (abfd));
+ bfd_fatal (_("error message was"));
+ }
else if (relcount == 0)
printf (" (none)\n\n");
else
printf (" (none)\n\n");
else
{
- relpp = xmalloc (relsize);
+ relpp = (arelent **) xmalloc (relsize);
relcount = bfd_canonicalize_dynamic_reloc (abfd, relpp, dynsyms);
if (relcount < 0)
if (path[0] == 0)
return;
include_path_count++;
- include_paths = xrealloc (include_paths,
- include_path_count * sizeof (*include_paths));
+ include_paths = (const char **)
+ xrealloc (include_paths, include_path_count * sizeof (*include_paths));
#ifdef HAVE_DOS_BASED_FILE_SYSTEM
if (path[1] == ':' && path[2] == 0)
path = concat (path, ".", (const char *) 0);
bfd_map_over_sections (abfd, adjust_addresses, &has_reloc);
}
- if (! dump_debugging_tags)
+ if (! dump_debugging_tags && ! suppress_bfd_header)
printf (_("\n%s: file format %s\n"), bfd_get_filename (abfd),
abfd->xvec->name);
if (dump_ar_hdrs)
dump_bfd_header (abfd);
if (dump_private_headers)
dump_bfd_private_header (abfd);
- if (! dump_debugging_tags)
+ if (dump_private_options != NULL)
+ dump_target_specific (abfd);
+ if (! dump_debugging_tags && ! suppress_bfd_header)
putchar ('\n');
- if (dump_section_headers)
- dump_headers (abfd);
if (dump_symtab
|| dump_reloc_info
|| dump_debugging
|| dump_dwarf_section_info)
syms = slurp_symtab (abfd);
+
+ if (dump_section_headers)
+ dump_headers (abfd);
+
if (dump_dynamic_symtab || dump_dynamic_reloc_info
|| (disassemble && bfd_get_dynamic_symtab_upper_bound (abfd) > 0))
dynsyms = slurp_dynamic_symtab (abfd);
info in the file, try DWARF instead. */
else if (! dump_dwarf_section_info)
{
+ dwarf_select_sections_all ();
dump_dwarf (abfd);
}
}
}
static void
-display_bfd (bfd *abfd)
+display_object_bfd (bfd *abfd)
{
char **matching;
}
static void
-display_file (char *filename, char *target)
+display_any_bfd (bfd *file, int level)
{
- bfd *file;
- bfd *arfile = NULL;
-
- if (get_file_size (filename) < 1)
- {
- exit_status = 1;
- return;
- }
-
- file = bfd_openr (filename, target);
- if (file == NULL)
- {
- nonfatal (filename);
- return;
- }
+ /* Decompress sections unless dumping the section contents. */
+ if (!dump_section_contents)
+ file->flags |= BFD_DECOMPRESS;
/* If the file is an archive, process all of its elements. */
if (bfd_check_format (file, bfd_archive))
{
+ bfd *arfile = NULL;
bfd *last_arfile = NULL;
- printf (_("In archive %s:\n"), bfd_get_filename (file));
+ if (level == 0)
+ printf (_("In archive %s:\n"), bfd_get_filename (file));
+ else if (level > 100)
+ {
+ /* Prevent corrupted files from spinning us into an
+ infinite loop. 100 is an arbitrary heuristic. */
+ fatal (_("Archive nesting is too deep"));
+ return;
+ }
+ else
+ printf (_("In nested archive %s:\n"), bfd_get_filename (file));
+
for (;;)
{
bfd_set_error (bfd_error_no_error);
break;
}
- display_bfd (arfile);
+ display_any_bfd (arfile, level + 1);
if (last_arfile != NULL)
- bfd_close (last_arfile);
+ {
+ bfd_close (last_arfile);
+ /* PR 17512: file: ac585d01. */
+ if (arfile == last_arfile)
+ {
+ last_arfile = NULL;
+ break;
+ }
+ }
last_arfile = arfile;
}
bfd_close (last_arfile);
}
else
- display_bfd (file);
+ display_object_bfd (file);
+}
+
+static void
+display_file (char *filename, char *target, bfd_boolean last_file)
+{
+ bfd *file;
+
+ if (get_file_size (filename) < 1)
+ {
+ exit_status = 1;
+ return;
+ }
- bfd_close (file);
+ file = bfd_openr (filename, target);
+ if (file == NULL)
+ {
+ nonfatal (filename);
+ return;
+ }
+
+ display_any_bfd (file, 0);
+
+ /* This is an optimization to improve the speed of objdump, especially when
+ dumping a file with lots of associated debug informatiom. Calling
+ bfd_close on such a file can take a non-trivial amount of time as there
+ are lots of lists to walk and buffers to free. This is only really
+ necessary however if we are about to load another file and we need the
+ memory back. Otherwise, if we are about to exit, then we can save (a lot
+ of) time by only doing a quick close, and allowing the OS to reclaim the
+ memory for us. */
+ if (! last_file)
+ bfd_close (file);
+ else
+ bfd_close_all_done (file);
}
\f
int
program_name = *argv;
xmalloc_set_program_name (program_name);
+ bfd_set_error_program_name (program_name);
START_PROGRESS (program_name, 0);
set_default_bfd_target ();
while ((c = getopt_long (argc, argv,
- "pib:m:M:VvCdDlfFaHhrRtTxsSI:j:wE:zgeGW::",
+ "pP:ib:m:M:VvCdDlfFaHhrRtTxsSI:j:wE:zgeGW::",
long_options, (int *) 0))
!= EOF)
{
machine = optarg;
break;
case 'M':
- if (disassembler_options)
- /* Ignore potential memory leak for now. */
- disassembler_options = concat (disassembler_options, ",",
- optarg, (const char *) NULL);
- else
- disassembler_options = optarg;
+ {
+ char *options;
+ if (disassembler_options)
+ /* Ignore potential memory leak for now. */
+ options = concat (disassembler_options, ",",
+ optarg, (const char *) NULL);
+ else
+ options = optarg;
+ disassembler_options = remove_whitespace_and_extra_commas (options);
+ }
break;
case 'j':
- if (only_used == only_size)
- {
- only_size += 8;
- only = xrealloc (only, only_size * sizeof (char *));
- }
- only [only_used++] = optarg;
+ add_only (optarg);
break;
case 'F':
display_file_offsets = TRUE;
endian = BFD_ENDIAN_LITTLE;
else
{
- non_fatal (_("unrecognized -E option"));
+ nonfatal (_("unrecognized -E option"));
usage (stderr, 1);
}
break;
else
{
non_fatal (_("unrecognized --endian type `%s'"), optarg);
+ exit_status = 1;
usage (stderr, 1);
}
break;
dump_private_headers = TRUE;
seenflag = TRUE;
break;
+ case 'P':
+ dump_private_options = optarg;
+ seenflag = TRUE;
+ break;
case 'x':
dump_private_headers = TRUE;
dump_symtab = TRUE;
else
dwarf_select_sections_all ();
break;
+ case OPTION_DWARF_DEPTH:
+ {
+ char *cp;
+ dwarf_cutoff_level = strtoul (optarg, & cp, 0);
+ }
+ break;
+ case OPTION_DWARF_START:
+ {
+ char *cp;
+ dwarf_start_die = strtoul (optarg, & cp, 0);
+ suppress_bfd_header = 1;
+ }
+ break;
+ case OPTION_DWARF_CHECK:
+ dwarf_check = TRUE;
+ break;
case 'G':
dump_stab_section_info = TRUE;
seenflag = TRUE;
dump_section_headers = TRUE;
seenflag = TRUE;
break;
- case 'H':
- usage (stdout, 0);
- seenflag = TRUE;
case 'v':
case 'V':
show_version = TRUE;
seenflag = TRUE;
break;
+ case 'H':
+ usage (stdout, 0);
+ /* No need to set seenflag or to break - usage() does not return. */
default:
usage (stderr, 1);
}
else
{
if (optind == argc)
- display_file ("a.out", target);
+ display_file ("a.out", target, TRUE);
else
for (; optind < argc;)
- display_file (argv[optind++], target);
+ {
+ display_file (argv[optind], target, optind == argc - 1);
+ optind++;
+ }
}
+ free_only_list ();
+
END_PROGRESS (program_name);
return exit_status;
projects / deliverable / binutils-gdb.git / blobdiff