/* objdump.c -- dump information about an object file.
- Copyright (C) 1990-2015 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.
\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"));
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 **
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] != '.')
name = alloc;
}
- version_string = bfd_get_symbol_version_string (abfd, sym, &hidden);
+ 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;
/* 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
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
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;
else
{
(*inf->fprintf_func) (inf->stream, " <");
+
objdump_print_symname (abfd, inf, sym);
- if (bfd_asymbol_value (sym) > vma)
+
+ 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)
{
(*inf->fprintf_func) (inf->stream, "-0x");
objdump_print_value (bfd_asymbol_value (sym) - vma, inf, TRUE);
(*inf->fprintf_func) (inf->stream, "+0x");
objdump_print_value (vma - bfd_asymbol_value (sym), inf, TRUE);
}
+
(*inf->fprintf_func) (inf->stream, ">");
}
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;
};
/* 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;
linemap = (const char **) xrealloc (linemap, newsize);
}
- linemap[lineno++] = lstart;
- lstart = p + 1;
+ linemap[lineno++] = lstart;
+ lstart = p + 1;
}
-
- *maxline = lineno;
+
+ *maxline = lineno;
return linemap;
}
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;
/* Print a source file line. */
-static void
+static void
print_line (struct print_file_list *p, unsigned int linenum)
{
const char *l;
size_t len;
-
- --linenum;
+
+ --linenum;
if (linenum >= p->maxline)
return;
l = p->linemap [linenum];
{
if (p->map == NULL)
return;
- while (start <= end)
+ while (start <= end)
{
print_line (p, start);
start++;
unsigned int linenumber;
unsigned int discriminator;
bfd_boolean reloc;
+ char *path = NULL;
if (! with_line_numbers && ! with_source_code)
return;
{
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 (linenumber > 0 && (linenumber != prev_line ||
+ if (linenumber > 0 && (linenumber != prev_line ||
(discriminator != prev_discriminator)))
- {
+ {
if (discriminator > 0)
printf ("%s:%u (discriminator %u)\n", filename == NULL ? "???" : filename,
linenumber, discriminator);
if (p != NULL && linenumber != p->last_line)
{
- if (file_start_context && p->first)
+ if (file_start_context && p->first)
l = 1;
- else
+ else
{
l = linenumber - SHOW_PRECEDING_CONTEXT_LINES;
- if (l >= linenumber)
+ if (l >= linenumber)
l = 1;
- if (p->last_line >= l && p->last_line <= linenumber)
- 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, linenumber);
+ if (p->max_printed < linenumber)
+ p->max_printed = linenumber;
p->last_line = linenumber;
p->first = 0;
}
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 = (char *) xrealloc (f->buffer, f->alloc);
}
f->pos += n;
-
+
return n;
}
sfile.alloc = 120;
sfile.buffer = (char *) xmalloc (sfile.alloc);
sfile.pos = 0;
-
+
if (insn_width)
octets_per_line = insn_width;
else if (insns)
}
}
+ 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)
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;
/* 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;
{
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;
}
/* 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)
if (section->start != NULL)
return 1;
+ 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 = NULL;
section->name);
return 0;
}
+
+ 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)
{
section, abfd))
{
debug_displays [i].display (sec, abfd);
-
+
if (i != info && i != abbrev)
free_debug_section ((enum dwarf_section_display_enum) i);
}
}
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;
}
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,
{
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)"),
if (!bfd_get_full_section_contents (abfd, section, &data))
{
- non_fatal (_("Reading section failed"));
+ non_fatal (_("Reading section %s failed because: %s"),
+ section->name, bfd_errmsg (bfd_get_error ()));
return;
}
info in the file, try DWARF instead. */
else if (! dump_dwarf_section_info)
{
- dwarf_select_sections_all ();
+ dwarf_select_sections_all ();
dump_dwarf (abfd);
}
}
{
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. */
- non_fatal (_("Archive nesting is too deep"));
+ fatal (_("Archive nesting is too deep"));
return;
}
else
}
static void
-display_file (char *filename, char *target)
+display_file (char *filename, char *target, bfd_boolean last_file)
{
bfd *file;
display_any_bfd (file, 0);
- bfd_close (file);
+ /* 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
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':
add_only (optarg);
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 ();