/* 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
+ 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007
Free Software Foundation, Inc.
This file is part of GNU Binutils.
disassembling is done by the libopcodes library, via a function pointer
supplied by the disassembler() function. */
+#include "sysdep.h"
#include "bfd.h"
-#include "bfdver.h"
#include "progress.h"
#include "bucomm.h"
-#include "budemang.h"
+#include "dwarf.h"
#include "getopt.h"
#include "safe-ctype.h"
#include "dis-asm.h"
#include "debug.h"
#include "budbg.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"
-#ifdef NEED_DECLARATION_FPRINTF
-/* This is needed by init_disassemble_info(). */
-extern int fprintf (FILE *, const char *, ...);
-#endif
-
/* Exit status. */
static int exit_status = 0;
static int with_line_numbers; /* -l */
static bfd_boolean with_source_code; /* -S */
static int show_raw_insn; /* --show-raw-insn */
+static int dump_dwarf_section_info; /* --dwarf */
static int dump_stab_section_info; /* --stabs */
static int do_demangle; /* -C, --demangle */
static bfd_boolean disassemble; /* -d */
arelent ** dynrelbuf;
long dynrelcount;
disassembler_ftype disassemble_fn;
-#ifdef DISASSEMBLER_NEEDS_RELOCS
arelent * reloc;
-#endif
};
/* Architecture to disassemble for, or default if NULL. */
-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, --dwarf 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\
-r, --reloc Display the relocation entries in the file\n\
-R, --dynamic-reloc Display the dynamic relocation entries in the file\n\
+ @<file> Read options from <file>\n\
-v, --version Display this program's version number\n\
-i, --info List object formats and architectures supported\n\
-H, --help Display this information\n\
disassembler_usage (stream);
}
- if (status == 0)
+ if (REPORT_BUGS_TO[0] && status == 0)
fprintf (stream, _("Report bugs to %s.\n"), REPORT_BUGS_TO);
exit (status);
}
{"source", no_argument, NULL, 'S'},
{"special-syms", no_argument, &dump_special_syms, 1},
{"include", required_argument, NULL, 'I'},
+ {"dwarf", no_argument, NULL, 'W'},
{"stabs", no_argument, NULL, 'G'},
{"start-address", required_argument, NULL, OPTION_START_ADDRESS},
{"stop-address", required_argument, NULL, OPTION_STOP_ADDRESS},
if (do_demangle && name[0] != '\0')
{
/* Demangle the name. */
- alloc = demangle (abfd, name);
- name = alloc;
+ alloc = bfd_demangle (abfd, name, DMGL_ANSI | DMGL_PARAMS);
+ if (alloc != NULL)
+ name = alloc;
}
if (info != NULL)
bfd *abfd;
asection *sec;
unsigned int opb;
+ bfd_boolean want_section;
if (sorted_symcount < 1)
return NULL;
Note that this may be wrong for some symbol references if the
sections have overlapping memory ranges, but in that case there's
no way to tell what's desired without looking at the relocation
- table. */
- if (sorted_syms[thisplace]->section != sec
- && (aux->require_sec
- || ((abfd->flags & HAS_RELOC) != 0
- && vma >= bfd_get_section_vma (abfd, sec)
- && vma < (bfd_get_section_vma (abfd, sec)
- + bfd_section_size (abfd, sec) / opb))))
+ 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)
+ && 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))
{
long i;
+ long newplace;
for (i = thisplace + 1; i < sorted_symcount; i++)
{
}
--i;
+ newplace = sorted_symcount;
for (; i >= 0; i--)
{
- if (sorted_syms[i]->section == sec
- && (i == 0
- || sorted_syms[i - 1]->section != sec
- || (bfd_asymbol_value (sorted_syms[i])
- != bfd_asymbol_value (sorted_syms[i - 1]))))
+ if ((sorted_syms[i]->section == sec || !want_section)
+ && info->symbol_is_valid (sorted_syms[i], info))
{
- thisplace = i;
- break;
+ if (newplace == sorted_symcount)
+ newplace = i;
+
+ if (bfd_asymbol_value (sorted_syms[i])
+ != bfd_asymbol_value (sorted_syms[newplace]))
+ break;
+
+ /* Remember this symbol and keep searching until we reach
+ an earlier address. */
+ newplace = i;
}
}
- if (sorted_syms[thisplace]->section != sec)
+ if (newplace != sorted_symcount)
+ thisplace = newplace;
+ else
{
/* We didn't find a good symbol with a smaller value.
Look for one with a larger value. */
for (i = thisplace + 1; i < sorted_symcount; i++)
{
- if (sorted_syms[i]->section == sec)
+ if ((sorted_syms[i]->section == sec || !want_section)
+ && info->symbol_is_valid (sorted_syms[i], info))
{
thisplace = i;
break;
}
}
- if (sorted_syms[thisplace]->section != sec
- && (aux->require_sec
- || ((abfd->flags & HAS_RELOC) != 0
- && vma >= bfd_get_section_vma (abfd, sec)
- && vma < (bfd_get_section_vma (abfd, sec)
- + bfd_section_size (abfd, sec)))))
+ if ((sorted_syms[thisplace]->section != sec && want_section)
+ || !info->symbol_is_valid (sorted_syms[thisplace], info))
/* There is no suitable symbol. */
return NULL;
}
- /* Give the target a chance to reject the symbol. */
- while (! info->symbol_is_valid (sorted_syms [thisplace], info))
- {
- ++ thisplace;
- if (thisplace >= sorted_symcount
- || bfd_asymbol_value (sorted_syms [thisplace]) > vma)
- return NULL;
- }
-
if (place != NULL)
*place = thisplace;
{
struct objdump_disasm_info *aux;
asymbol *sym = NULL; /* Initialize to avoid compiler warning. */
-#ifdef DISASSEMBLER_NEEDS_RELOCS
bfd_boolean skip_find = FALSE;
-#endif
if (sorted_symcount < 1)
{
aux = (struct objdump_disasm_info *) info->application_data;
-#ifdef DISASSEMBLER_NEEDS_RELOCS
if (aux->reloc != NULL
&& aux->reloc->sym_ptr_ptr != NULL
&& * aux->reloc->sym_ptr_ptr != NULL)
}
if (!skip_find)
-#endif
sym = find_symbol_for_address (vma, info, NULL);
objdump_print_addr_with_sym (aux->abfd, aux->sec, sym, vma, info,
objdump_print_addr (vma, info, ! prefix_addresses);
}
-/* Determine of the given address has a symbol associated with it. */
+/* Determine if the given address has a symbol associated with it. */
static int
objdump_symbol_at_address (bfd_vma vma, struct disassemble_info * info)
struct print_file_list *next;
const char *filename;
const char *modname;
- unsigned int line;
- FILE *f;
+ const char *map;
+ size_t mapsize;
+ const char **linemap;
+ unsigned maxline;
+ unsigned last_line;
+ int first;
};
static struct print_file_list *print_files;
#define SHOW_PRECEDING_CONTEXT_LINES (5)
+/* Read a complete file into memory. */
+
+static const char *
+slurp_file (const char *fn, size_t *size)
+{
+#ifdef HAVE_MMAP
+ int ps = getpagesize ();
+ size_t msize;
+#endif
+ const char *map;
+ struct stat st;
+ int fd = open (fn, O_RDONLY);
+
+ if (fd < 0)
+ return NULL;
+ if (fstat (fd, &st) < 0)
+ 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)
+ {
+ close(fd);
+ return map;
+ }
+#endif
+ map = malloc (*size);
+ if (!map || (size_t) read (fd, (char *)map, *size) != *size)
+ {
+ free ((void *)map);
+ map = NULL;
+ }
+ close (fd);
+ 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)
+{
+ const char *p, *lstart, *end;
+ int chars_per_line = 45; /* First iteration will use 40. */
+ unsigned int lineno;
+ 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')
+ {
+ if (p + 1 < end && p[1] == '\n')
+ p++;
+ }
+ else
+ continue;
+
+ /* End of line found. */
+
+ if (linemap == NULL || line_map_size < lineno + 1)
+ {
+ unsigned long newsize;
+
+ chars_per_line -= line_map_decrease;
+ if (chars_per_line <= 1)
+ chars_per_line = 1;
+ line_map_size = size / chars_per_line + 1;
+ if (line_map_size < lineno + 1)
+ line_map_size = lineno + 1;
+ newsize = line_map_size * sizeof (char *);
+ linemap = xrealloc (linemap, newsize);
+ }
+
+ linemap[lineno++] = lstart;
+ lstart = p + 1;
+ }
+
+ *maxline = lineno;
+ return linemap;
+}
+
/* Tries to open MODNAME, and if successful adds a node to print_files
linked list and returns that node. Returns NULL on failure. */
try_print_file_open (const char *origname, const char *modname)
{
struct print_file_list *p;
- FILE *f;
- f = fopen (modname, "r");
- if (f == NULL)
- return NULL;
+ p = xmalloc (sizeof (struct print_file_list));
- if (print_files != NULL && print_files->f != NULL)
+ p->map = slurp_file (modname, &p->mapsize);
+ if (p->map == NULL)
{
- fclose (print_files->f);
- print_files->f = NULL;
+ free (p);
+ return NULL;
}
-
- p = xmalloc (sizeof (struct print_file_list));
+
+ p->linemap = index_file (p->map, p->mapsize, &p->maxline);
+ p->last_line = 0;
p->filename = origname;
p->modname = modname;
- p->line = 0;
- p->f = f;
p->next = print_files;
+ p->first = 1;
print_files = p;
return p;
}
return NULL;
}
-/* Skip ahead to a given line in a file, optionally printing each
- line. */
+/* Print a source file line. */
-static void
-skip_to_line (struct print_file_list *p, unsigned int line,
- bfd_boolean show)
+static void
+print_line (struct print_file_list *p, unsigned int line)
{
- while (p->line < line)
- {
- char buf[100];
-
- if (fgets (buf, sizeof buf, p->f) == NULL)
- {
- fclose (p->f);
- p->f = NULL;
- break;
- }
+ const char *l;
+
+ --line;
+ if (line >= p->maxline)
+ return;
+ l = p->linemap [line];
+ fwrite (l, 1, strcspn (l, "\n\r"), stdout);
+ putchar ('\n');
+}
- if (show)
- printf ("%s", buf);
+/* Print a range of source code lines. */
- if (strchr (buf, '\n') != NULL)
- ++p->line;
+static void
+dump_lines (struct print_file_list *p, unsigned int start, unsigned int end)
+{
+ if (p->map == NULL)
+ return;
+ while (start <= end)
+ {
+ print_line (p, start);
+ start++;
}
}
&& line > 0)
{
struct print_file_list **pp, *p;
+ unsigned l;
for (pp = &print_files; *pp != NULL; pp = &(*pp)->next)
if (strcmp ((*pp)->filename, filename) == 0)
break;
p = *pp;
- if (p != NULL)
- {
- if (p != print_files)
- {
- int l;
-
- /* We have reencountered a file name which we saw
- earlier. This implies that either we are dumping out
- code from an included file, or the same file was
- linked in more than once. There are two common cases
- of an included file: inline functions in a header
- file, and a bison or flex skeleton file. In the
- former case we want to just start printing (but we
- back up a few lines to give context); in the latter
- case we want to continue from where we left off. I
- can't think of a good way to distinguish the cases,
- so I used a heuristic based on the file name. */
- if (strcmp (p->filename + strlen (p->filename) - 2, ".h") != 0)
- l = p->line;
- else
- {
- l = line - SHOW_PRECEDING_CONTEXT_LINES;
- if (l < 0)
- l = 0;
- }
-
- if (p->f == NULL)
- {
- p->f = fopen (p->modname, "r");
- p->line = 0;
- }
- if (p->f != NULL)
- skip_to_line (p, l, FALSE);
-
- if (print_files->f != NULL)
- {
- fclose (print_files->f);
- print_files->f = NULL;
- }
- }
-
- if (p->f != NULL)
- {
- skip_to_line (p, line, TRUE);
- *pp = p->next;
- p->next = print_files;
- print_files = p;
- }
- }
- else
- {
+ if (p == NULL)
p = update_source_path (filename);
- if (p != NULL)
+ if (p != NULL && line != p->last_line)
+ {
+ if (file_start_context && p->first)
+ l = 1;
+ else
{
- int l;
-
- if (file_start_context)
- l = 0;
- else
- l = line - SHOW_PRECEDING_CONTEXT_LINES;
- if (l < 0)
- l = 0;
- skip_to_line (p, l, FALSE);
- if (p->f != NULL)
- skip_to_line (p, line, TRUE);
+ l = line - SHOW_PRECEDING_CONTEXT_LINES;
+ if (l >= line)
+ l = 1;
+ if (p->last_line >= l && p->last_line <= line)
+ l = p->last_line + 1;
}
+ dump_lines (p, l, line);
+ p->last_line = line;
+ p->first = 0;
}
}
/* sprintf to a "stream". */
-static int
+static int ATTRIBUTE_PRINTF_2
objdump_sprintf (SFILE *f, const char *format, ...)
{
size_t n;
{
bfd_vma z;
bfd_boolean need_nl = FALSE;
-#ifdef DISASSEMBLER_NEEDS_RELOCS
int previous_octets;
/* Remember the length of the previous instruction. */
previous_octets = octets;
-#endif
octets = 0;
/* If we see more than SKIP_ZEROES octets of zeroes, we just
done_dot = FALSE;
if (with_line_numbers || with_source_code)
- /* The line number tables will refer to unadjusted
- section VMAs, so we must undo any VMA modifications
- when calling show_line. */
- show_line (aux->abfd, section, addr_offset - adjust_section_vma);
+ show_line (aux->abfd, section, addr_offset);
if (! prefix_addresses)
{
info->bytes_per_chunk = 0;
info->flags = 0;
-#ifdef DISASSEMBLER_NEEDS_RELOCS
- if (*relppp < relppend)
+ if (info->disassembler_needs_relocs
+ && (bfd_get_file_flags (aux->abfd) & EXEC_P) == 0
+ && (bfd_get_file_flags (aux->abfd) & DYNAMIC) == 0
+ && *relppp < relppend)
{
bfd_signed_vma distance_to_rel;
else
aux->reloc = NULL;
}
-#endif
+
octets = (*disassemble_fn) (section->vma + addr_offset, info);
info->fprintf_func = (fprintf_ftype) fprintf;
info->stream = stdout;
objdump_print_value (section->vma - rel_offset + q->address,
info, TRUE);
- printf (": %s\t", q->howto->name);
+ if (q->howto == NULL)
+ printf (": *unknown*\t");
+ else if (q->howto->name)
+ printf (": %s\t", q->howto->name);
+ else
+ printf (": %d\t", q->howto->type);
if (q->sym_ptr_ptr == NULL || *q->sym_ptr_ptr == NULL)
printf ("*unknown*");
rel_offset = 0;
if ((section->flags & SEC_RELOC) != 0
-#ifndef DISASSEMBLER_NEEDS_RELOCS
- && dump_reloc_info
-#endif
- )
+ && (dump_reloc_info || pinfo->disassembler_needs_relocs))
{
long relsize;
pinfo->symbols = sorted_syms + place;
pinfo->num_symbols = x - place;
+ pinfo->symtab_pos = place;
}
else
{
pinfo->symbols = NULL;
pinfo->num_symbols = 0;
+ pinfo->symtab_pos = -1;
}
if (! prefix_addresses)
aux.require_sec = FALSE;
aux.dynrelbuf = NULL;
aux.dynrelcount = 0;
-#ifdef DISASSEMBLER_NEEDS_RELOCS
aux.reloc = NULL;
-#endif
disasm_info.print_address_func = objdump_print_address;
disasm_info.symbol_at_address_func = objdump_symbol_at_address;
disasm_info.octets_per_byte = bfd_octets_per_byte (abfd);
disasm_info.skip_zeroes = DEFAULT_SKIP_ZEROES;
disasm_info.skip_zeroes_at_end = DEFAULT_SKIP_ZEROES_AT_END;
+ disasm_info.disassembler_needs_relocs = FALSE;
if (bfd_big_endian (abfd))
disasm_info.display_endian = disasm_info.endian = BFD_ENDIAN_BIG;
compare_relocs);
}
}
+ disasm_info.symtab = sorted_syms;
+ disasm_info.symtab_size = sorted_symcount;
bfd_map_over_sections (abfd, disassemble_section, & disasm_info);
free (sorted_syms);
}
\f
+int
+load_debug_section (enum dwarf_section_display_enum debug, void *file)
+{
+ struct dwarf_section *section = &debug_displays [debug].section;
+ bfd *abfd = file;
+ asection *sec;
+ bfd_boolean ret;
+
+ /* If it is already loaded, do nothing. */
+ if (section->start != NULL)
+ return 1;
+
+ /* Locate the debug section. */
+ sec = bfd_get_section_by_name (abfd, section->name);
+ if (sec == NULL)
+ return 0;
+
+ /* Compute a bias to be added to offsets found within the DWARF debug
+ information. These offsets are meant to be relative to the start of
+ the dwarf section, and hence the bias should be 0. For MACH-O however
+ a dwarf section is really just a region of a much larger section and so
+ the bias is the address of the start of that area within the larger
+ section. This test is important for PE and COFF based targets which
+ use DWARF debug information, since unlike ELF, they do not allow the
+ dwarf sections to be placed at address 0. */
+ if (bfd_get_flavour (abfd) == bfd_target_mach_o_flavour)
+ section->address = bfd_get_section_vma (abfd, sec);
+ else
+ section->address = 0;
+
+ 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);
+
+ if (!ret)
+ {
+ free_debug_section (debug);
+ printf (_("\nCan't get contents for section '%s'.\n"),
+ section->name);
+ }
+
+ return ret;
+}
+
+void
+free_debug_section (enum dwarf_section_display_enum debug)
+{
+ struct dwarf_section *section = &debug_displays [debug].section;
+
+ if (section->start == NULL)
+ return;
+
+ free ((char *) section->start);
+ section->start = NULL;
+ section->address = 0;
+ section->size = 0;
+}
+
+static void
+dump_dwarf_section (bfd *abfd, asection *section,
+ void *arg ATTRIBUTE_UNUSED)
+{
+ const char *name = bfd_get_section_name (abfd, section);
+ const char *match;
+ enum dwarf_section_display_enum i;
+
+ if (CONST_STRNEQ (name, ".gnu.linkonce.wi."))
+ match = ".debug_info";
+ else
+ match = name;
+
+ for (i = 0; i < max; i++)
+ if (strcmp (debug_displays[i].section.name, match) == 0)
+ {
+ if (!debug_displays[i].eh_frame)
+ {
+ struct dwarf_section *sec = &debug_displays [i].section;
+
+ if (load_debug_section (i, abfd))
+ {
+ debug_displays[i].display (sec, abfd);
+
+ if (i != info && i != abbrev)
+ free_debug_section (i);
+ }
+ }
+ break;
+ }
+}
+
+static const char *mach_o_dwarf_sections [] = {
+ "LC_SEGMENT.__DWARFA.__debug_abbrev", /* .debug_abbrev */
+ "LC_SEGMENT.__DWARFA.__debug_aranges", /* .debug_aranges */
+ "LC_SEGMENT.__DWARFA.__debug_frame", /* .debug_frame */
+ "LC_SEGMENT.__DWARFA.__debug_info", /* .debug_info */
+ "LC_SEGMENT.__DWARFA.__debug_line", /* .debug_line */
+ "LC_SEGMENT.__DWARFA.__debug_pubnames", /* .debug_pubnames */
+ ".eh_frame", /* .eh_frame */
+ "LC_SEGMENT.__DWARFA.__debug_macinfo", /* .debug_macinfo */
+ "LC_SEGMENT.__DWARFA.__debug_str", /* .debug_str */
+ "LC_SEGMENT.__DWARFA.__debug_loc", /* .debug_loc */
+ "LC_SEGMENT.__DWARFA.__debug_pubtypes", /* .debug_pubtypes */
+ "LC_SEGMENT.__DWARFA.__debug_ranges", /* .debug_ranges */
+ "LC_SEGMENT.__DWARFA.__debug_static_func", /* .debug_static_func */
+ "LC_SEGMENT.__DWARFA.__debug_static_vars", /* .debug_static_vars */
+ "LC_SEGMENT.__DWARFA.__debug_types", /* .debug_types */
+ "LC_SEGMENT.__DWARFA.__debug_weaknames" /* .debug_weaknames */
+};
+
+static const char *generic_dwarf_sections [max];
+
+static void
+check_mach_o_dwarf (bfd *abfd)
+{
+ static enum bfd_flavour old_flavour = bfd_target_unknown_flavour;
+ enum bfd_flavour current_flavour = bfd_get_flavour (abfd);
+ enum dwarf_section_display_enum i;
+
+ if (generic_dwarf_sections [0] == NULL)
+ for (i = 0; i < max; i++)
+ generic_dwarf_sections [i] = debug_displays[i].section.name;
+
+ if (old_flavour != current_flavour)
+ {
+ if (current_flavour == bfd_target_mach_o_flavour)
+ for (i = 0; i < max; i++)
+ debug_displays[i].section.name = mach_o_dwarf_sections [i];
+ else if (old_flavour == bfd_target_mach_o_flavour)
+ for (i = 0; i < max; i++)
+ debug_displays[i].section.name = generic_dwarf_sections [i];
+
+ old_flavour = current_flavour;
+ }
+}
+
+/* Dump the dwarf debugging information. */
+
+static void
+dump_dwarf (bfd *abfd)
+{
+ is_relocatable = ((abfd->flags & (HAS_RELOC | EXEC_P | DYNAMIC))
+ == HAS_RELOC);
+
+ /* 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;
+
+ 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 ();
+
+ check_mach_o_dwarf (abfd);
+
+ bfd_map_over_sections (abfd, dump_dwarf_section, NULL);
+
+ free_debug_memory ();
+}
+\f
/* Read ABFD's stabs section STABSECT_NAME, and return a pointer to
it. Return NULL on failure. */
/* If we want to demangle the name, we demangle it
here, and temporarily clobber it while calling
bfd_print_symbol. FIXME: This is a gross hack. */
- alloc = demangle (cur_bfd, name);
- (*current)->name = alloc;
+ alloc = bfd_demangle (cur_bfd, name, DMGL_ANSI | DMGL_PARAMS);
+ if (alloc != NULL)
+ (*current)->name = alloc;
bfd_print_symbol (cur_bfd, stdout, *current,
bfd_print_symbol_all);
- (*current)->name = name;
- free (alloc);
+ if (alloc != NULL)
+ {
+ (*current)->name = name;
+ free (alloc);
+ }
}
else
bfd_print_symbol (cur_bfd, stdout, *current,
section_name = NULL;
}
+ bfd_printf_vma (abfd, q->address);
+ if (q->howto == NULL)
+ printf (" *unknown* ");
+ else if (q->howto->name)
+ printf (" %-16s ", q->howto->name);
+ else
+ printf (" %-16d ", q->howto->type);
if (sym_name)
- {
- bfd_printf_vma (abfd, q->address);
- if (q->howto->name)
- printf (" %-16s ", q->howto->name);
- else
- printf (" %-16d ", q->howto->type);
- objdump_print_symname (abfd, NULL, *q->sym_ptr_ptr);
- }
+ objdump_print_symname (abfd, NULL, *q->sym_ptr_ptr);
else
{
if (section_name == NULL)
section_name = "*unknown*";
- bfd_printf_vma (abfd, q->address);
- printf (" %-16s [%s]",
- q->howto->name,
- section_name);
+ printf ("[%s]", section_name);
}
if (q->addend)
static void
adjust_addresses (bfd *abfd ATTRIBUTE_UNUSED,
asection *section,
- void *dummy ATTRIBUTE_UNUSED)
+ void *arg)
{
- section->vma += adjust_section_vma;
- section->lma += adjust_section_vma;
+ if ((section->flags & SEC_DEBUGGING) == 0)
+ {
+ bfd_boolean *has_reloc_p = (bfd_boolean *) arg;
+ section->vma += adjust_section_vma;
+ if (*has_reloc_p)
+ section->lma += adjust_section_vma;
+ }
}
/* Dump selected contents of ABFD. */
the BFD information is a hack. However, we must do it, or
bfd_find_nearest_line will not do the right thing. */
if (adjust_section_vma != 0)
- bfd_map_over_sections (abfd, adjust_addresses, NULL);
+ {
+ bfd_boolean has_reloc = (abfd->flags & HAS_RELOC);
+ bfd_map_over_sections (abfd, adjust_addresses, &has_reloc);
+ }
if (! dump_debugging_tags)
printf (_("\n%s: file format %s\n"), bfd_get_filename (abfd),
if (dump_section_headers)
dump_headers (abfd);
- if (dump_symtab || dump_reloc_info || disassemble || dump_debugging)
+ if (dump_symtab
+ || dump_reloc_info
+ || disassemble
+ || dump_debugging
+ || dump_dwarf_section_info)
syms = slurp_symtab (abfd);
if (dump_dynamic_symtab || dump_dynamic_reloc_info
|| (disassemble && bfd_get_dynamic_symtab_upper_bound (abfd) > 0))
dump_symbols (abfd, FALSE);
if (dump_dynamic_symtab)
dump_symbols (abfd, TRUE);
+ if (dump_dwarf_section_info)
+ dump_dwarf (abfd);
if (dump_stab_section_info)
dump_stabs (abfd);
if (dump_reloc_info && ! disassemble)
dhandle = read_debugging_info (abfd, syms, symcount);
if (dhandle != NULL)
{
- if (! print_debugging_info (stdout, dhandle, abfd, syms, demangle,
- dump_debugging_tags ? TRUE : FALSE))
+ if (!print_debugging_info (stdout, dhandle, abfd, syms,
+ bfd_demangle,
+ dump_debugging_tags ? TRUE : FALSE))
{
non_fatal (_("%s: printing debugging information failed"),
bfd_get_filename (abfd));
bfd *arfile = NULL;
if (get_file_size (filename) < 1)
- return;
+ {
+ exit_status = 1;
+ return;
+ }
file = bfd_openr (filename, target);
if (file == NULL)
START_PROGRESS (program_name, 0);
+ expandargv (&argc, &argv);
+
bfd_init ();
set_default_bfd_target ();
- while ((c = getopt_long (argc, argv, "pib:m:M:VvCdDlfaHhrRtTxsSI:j:wE:zgeG",
+ while ((c = getopt_long (argc, argv, "pib:m:M:VvCdDlfaHhrRtTxsSI:j:wE:zgeGW",
long_options, (int *) 0))
!= EOF)
{
do_demangle = TRUE;
seenflag = TRUE;
break;
+ case 'W':
+ dump_dwarf_section_info = TRUE;
+ seenflag = TRUE;
+ do_debug_info = 1;
+ do_debug_abbrevs = 1;
+ do_debug_lines = 1;
+ do_debug_pubnames = 1;
+ do_debug_aranges = 1;
+ do_debug_ranges = 1;
+ do_debug_frames = 1;
+ do_debug_macinfo = 1;
+ do_debug_str = 1;
+ do_debug_loc = 1;
+ break;
case 'G':
dump_stab_section_info = TRUE;
seenflag = TRUE;