/* 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, 2010, 2011
- Free Software Foundation, Inc.
+ Copyright (C) 1990-2015 Free Software Foundation, Inc.
This file is part of GNU Binutils.
#include "sysdep.h"
#include "bfd.h"
#include "elf-bfd.h"
+#include "coff-bfd.h"
#include "progress.h"
#include "bucomm.h"
#include "elfcomm.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 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\
-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\
+ =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\
--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
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 = (asymbol **) xmalloc (storage);
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;
}
+ 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);
+ {
+ (*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 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
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 = (const char *) malloc (*size);
- if (!map || (size_t) read (fd, (char *)map, *size) != *size)
- {
- free ((void *)map);
+ 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
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 *filename;
const char *functionname;
unsigned int linenumber;
+ unsigned int discriminator;
bfd_boolean reloc;
if (! with_line_numbers && ! with_source_code)
return;
- if (! bfd_find_nearest_line (abfd, section, syms, addr_offset, &filename,
- &functionname, &linenumber))
+ if (! bfd_find_nearest_line_discriminator (abfd, section, syms, addr_offset,
+ &filename, &functionname,
+ &linenumber, &discriminator))
return;
if (filename != NULL && *filename == '\0')
&& (prev_functionname == NULL
|| strcmp (functionname, prev_functionname) != 0))
printf ("%s():\n", functionname);
- if (linenumber > 0 && linenumber != prev_line)
- printf ("%s:%u\n", filename == NULL ? "???" : filename, linenumber);
+ 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
if (linenumber > 0 && linenumber != prev_line)
prev_line = linenumber;
+
+ if (discriminator != prev_discriminator)
+ prev_discriminator = discriminator;
}
/* Pseudo FILE object for strings. */
if (q->addend)
{
- printf ("+0x");
- objdump_print_value (q->addend, inf, 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");
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)
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;
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. */
if (section->start != NULL)
return 1;
- section->address = 0;
+ section->address = bfd_get_section_vma (abfd, sec);
section->size = bfd_get_section_size (sec);
section->start = NULL;
+ section->user_data = sec;
ret = bfd_get_full_section_contents (abfd, sec, §ion->start);
if (! ret)
if (is_relocatable && debug_displays [debug].relocate)
{
- /* We want to relocate the data we've already read (and
- decompressed), so we store a pointer to the data in
- the bfd_section, and tell it that the contents are
- already in memory. */
- sec->contents = section->start;
- sec->flags |= SEC_IN_MEMORY;
- sec->size = section->size;
+ bfd_cache_section_contents (sec, section->start);
ret = bfd_simple_get_relocated_section_contents (abfd,
sec,
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;
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;
+ }
switch (bfd_get_arch (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;
}
break;
+ case bfd_arch_aarch64:
+ init_dwarf_regnames_aarch64();
+ break;
+
default:
break;
}
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 (" *");
}
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. */
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 linenumber;
+ unsigned int discriminator;
const char *sym_name;
const char *section_name;
bfd_vma addend2 = 0;
if (with_line_numbers
&& sec != NULL
- && bfd_find_nearest_line (abfd, sec, syms, q->address,
- &filename, &functionname, &linenumber))
+ && bfd_find_nearest_line_discriminator (abfd, sec, syms, q->address,
+ &filename, &functionname,
+ &linenumber, &discriminator))
{
if (functionname != NULL
&& (last_functionname == NULL
&& (linenumber != last_line
|| (filename != NULL
&& last_filename != NULL
- && filename_cmp (filename, last_filename) != 0)))
+ && filename_cmp (filename, last_filename) != 0)
+ || (discriminator != last_discriminator)))
{
- printf ("%s:%u\n", filename == NULL ? "???" : filename, linenumber);
+ 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->addend)
{
- printf ("+0x");
- bfd_printf_vma (abfd, 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)
{
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
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;
+
+ 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));
- printf (_("In 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 *file;
+
+ if (get_file_size (filename) < 1)
+ {
+ exit_status = 1;
+ return;
+ }
+
+ file = bfd_openr (filename, target);
+ if (file == NULL)
+ {
+ nonfatal (filename);
+ return;
+ }
+
+ display_any_bfd (file, 0);
bfd_close (file);
}
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)
{
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);
}
projects / deliverable / binutils-gdb.git / blobdiff