X-Git-Url: http://drtracing.org/?a=blobdiff_plain;f=binutils%2Fobjdump.c;h=b348025024ded88178ab5cc2a24d1f5a42391686;hb=a8da6403829d6f87867da6a737dfdaa736a37dfa;hp=809457ec10305e81f6fe24d22d120ee346090b62;hpb=0112cd268b205d8176b8b4d00988a334822956cf;p=deliverable%2Fbinutils-gdb.git diff --git a/binutils/objdump.c b/binutils/objdump.c index 809457ec10..b348025024 100644 --- a/binutils/objdump.c +++ b/binutils/objdump.c @@ -1,13 +1,13 @@ /* 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 + 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008 Free Software Foundation, Inc. This file is part of GNU Binutils. This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by - the Free Software Foundation; either version 2, or (at your option) + the Free Software Foundation; either version 3, or (at your option) any later version. This program is distributed in the hope that it will be useful, @@ -17,7 +17,9 @@ You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software - Foundation, 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA. */ + Foundation, 51 Franklin Street - Fifth Floor, Boston, + MA 02110-1301, USA. */ + /* Objdump overview. @@ -48,12 +50,12 @@ 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 "elf-bfd.h" #include "progress.h" #include "bucomm.h" #include "dwarf.h" -#include "budemang.h" #include "getopt.h" #include "safe-ctype.h" #include "dis-asm.h" @@ -62,6 +64,12 @@ #include "debug.h" #include "budbg.h" +#ifdef HAVE_MMAP +#include +#endif + +#include + /* Internal headers for the ELF .stab-dump code - sorry. */ #define BYTES_IN_WORD 32 #include "aout/aout64.h" @@ -102,6 +110,7 @@ static int dump_debugging_tags; /* --debugging-tags */ static int dump_special_syms = 0; /* --special-syms */ static bfd_vma adjust_section_vma = 0; /* --adjust-vma */ static int file_start_context = 0; /* --file-start-context */ +static bfd_boolean display_file_offsets;/* -F */ /* Pointer to an array of section names provided by one or more "-j secname" command line options. */ @@ -164,6 +173,8 @@ static bfd_size_type stab_size; static char *strtab; static bfd_size_type stabstr_size; + +static bfd_boolean is_relocatable = FALSE; static void usage (FILE *stream, int status) @@ -207,6 +218,7 @@ usage (FILE *stream, int status) --file-start-context Include context from start of file (with -S)\n\ -I, --include=DIR Add DIR to search list for source files\n\ -l, --line-numbers Include line numbers and filenames in output\n\ + -F, --file-offsets Include file offsets when displaying information\n\ -C, --demangle[=STYLE] Decode mangled/processed symbol names\n\ The STYLE, if specified, can be `auto', `gnu',\n\ `lucid', `arm', `hp', `edg', `gnu-v3', `java'\n\ @@ -225,7 +237,7 @@ usage (FILE *stream, int status) 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); } @@ -257,6 +269,7 @@ static struct option long_options[]= {"dynamic-syms", no_argument, NULL, 'T'}, {"endian", required_argument, NULL, OPTION_ENDIAN}, {"file-headers", no_argument, NULL, 'f'}, + {"file-offsets", no_argument, NULL, 'F'}, {"file-start-context", no_argument, &file_start_context, 1}, {"full-contents", no_argument, NULL, 's'}, {"headers", no_argument, NULL, 'h'}, @@ -650,8 +663,9 @@ objdump_print_symname (bfd *abfd, struct disassemble_info *info, 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) @@ -687,6 +701,7 @@ find_symbol_for_address (bfd_vma vma, bfd *abfd; asection *sec; unsigned int opb; + bfd_boolean want_section; if (sorted_symcount < 1) return NULL; @@ -732,15 +747,19 @@ find_symbol_for_address (bfd_vma vma, 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++) { @@ -750,27 +769,36 @@ find_symbol_for_address (bfd_vma vma, } --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; @@ -778,25 +806,12 @@ find_symbol_for_address (bfd_vma vma, } } - 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; @@ -847,6 +862,10 @@ objdump_print_addr_with_sym (bfd *abfd, asection *sec, asymbol *sym, } (*info->fprintf_func) (info->stream, ">"); } + + if (display_file_offsets) + info->fprintf_func (info->stream, _(" (File Offset: 0x%lx)"), + (long int)(sec->filepos + (vma - sec->vma))); } /* Print an address (VMA), symbolically if possible. @@ -858,18 +877,22 @@ objdump_print_addr (bfd_vma vma, bfd_boolean skip_zeroes) { struct objdump_disasm_info *aux; - asymbol *sym = NULL; /* Initialize to avoid compiler warning. */ + asymbol *sym = NULL; bfd_boolean skip_find = FALSE; + aux = (struct objdump_disasm_info *) info->application_data; + if (sorted_symcount < 1) { (*info->fprintf_func) (info->stream, "0x"); objdump_print_value (vma, info, skip_zeroes); + + if (display_file_offsets) + info->fprintf_func (info->stream, _(" (File Offset: 0x%lx)"), + (long int)(aux->sec->filepos + (vma - aux->sec->vma))); return; } - aux = (struct objdump_disasm_info *) info->application_data; - if (aux->reloc != NULL && aux->reloc->sym_ptr_ptr != NULL && * aux->reloc->sym_ptr_ptr != NULL) @@ -926,8 +949,12 @@ struct print_file_list 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; @@ -937,6 +964,99 @@ 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. */ @@ -944,24 +1064,22 @@ static struct print_file_list * 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; } @@ -1020,29 +1138,35 @@ update_source_path (const char *filename) 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; + size_t len; + + --line; + if (line >= p->maxline) + return; + l = p->linemap [line]; + /* Test fwrite return value to quiet glibc warning. */ + len = strcspn (l, "\n\r"); + if (len == 0 || fwrite (l, len, 1, stdout) == 1) + 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++; } } @@ -1083,79 +1207,31 @@ show_line (bfd *abfd, asection *section, bfd_vma addr_offset) && 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; } } @@ -1326,8 +1402,6 @@ disassemble_bytes (struct disassemble_info * info, || (z == stop_offset * opb && z - addr_offset * opb < skip_zeroes_at_end))) { - printf ("\t...\n"); - /* If there are more nonzero octets to follow, we only skip zeroes in multiples of 4, to try to avoid running over the start of an instruction which happens to start with @@ -1336,6 +1410,16 @@ disassemble_bytes (struct disassemble_info * info, z = addr_offset * opb + ((z - addr_offset * opb) &~ 3); octets = z - addr_offset * opb; + + /* If we are going to display more data, and we are displaying + file offsets, then tell the user how many zeroes we skip + and the file offset from where we resume dumping. */ + if (display_file_offsets && ((addr_offset + (octets / opb)) < stop_offset)) + printf ("\t... (skipping %d zeroes, resuming at file offset: 0x%lx)\n", + octets / opb, + (long int)(section->filepos + (addr_offset + (octets / opb)))); + else + printf ("\t...\n"); } else { @@ -1377,6 +1461,8 @@ disassemble_bytes (struct disassemble_info * info, info->flags = 0; 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; @@ -1716,7 +1802,8 @@ disassemble_section (bfd *abfd, asection *section, void *info) && (*rel_pp)->address < rel_offset + addr_offset) ++rel_pp; - printf (_("Disassembly of section %s:\n"), section->name); + if (addr_offset < stop_offset) + printf (_("\nDisassembly of section %s:\n"), section->name); /* Find the nearest symbol forwards from our current position. */ paux->require_sec = TRUE; @@ -1748,11 +1835,13 @@ disassemble_section (bfd *abfd, asection *section, void *info) 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) @@ -1945,6 +2034,8 @@ disassemble_data (bfd *abfd) compare_relocs); } } + disasm_info.symtab = sorted_syms; + disasm_info.symtab_size = sorted_symcount; bfd_map_over_sections (abfd, disassemble_section, & disasm_info); @@ -1970,7 +2061,19 @@ load_debug_section (enum dwarf_section_display_enum debug, void *file) if (sec == NULL) return 0; - section->address = bfd_get_section_vma (abfd, sec); + /* 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); @@ -2089,8 +2192,7 @@ check_mach_o_dwarf (bfd *abfd) static void dump_dwarf (bfd *abfd) { - is_relocatable = ((abfd->flags & (HAS_RELOC | EXEC_P | DYNAMIC)) - == HAS_RELOC); + is_relocatable = (abfd->flags & (EXEC_P | DYNAMIC)) == 0; /* FIXME: bfd_get_arch_size may return -1. We assume that 64bit targets will return 64. */ @@ -2105,6 +2207,12 @@ dump_dwarf (bfd *abfd) check_mach_o_dwarf (abfd); + if (bfd_get_flavour (abfd) == bfd_target_elf_flavour) + { + const struct elf_backend_data *bed = get_elf_backend_data (abfd); + init_dwarf_regnames (bed->elf_machine_code); + } + bfd_map_over_sections (abfd, dump_dwarf_section, NULL); free_debug_memory (); @@ -2360,12 +2468,6 @@ dump_section (bfd *abfd, asection *section, void *dummy ATTRIBUTE_UNUSED) if ((datasize = bfd_section_size (abfd, section)) == 0) return; - printf (_("Contents of section %s:\n"), section->name); - - data = xmalloc (datasize); - - bfd_get_section_contents (abfd, section, data, 0, datasize); - /* Compute the address range to display. */ if (start_address == (bfd_vma) -1 || start_address < section->vma) @@ -2386,6 +2488,18 @@ dump_section (bfd *abfd, asection *section, void *dummy ATTRIBUTE_UNUSED) stop_offset = datasize / opb; } + if (start_offset >= stop_offset) + return; + + printf (_("Contents of section %s:"), section->name); + if (display_file_offsets) + printf (_(" (Starting at file offset: 0x%lx)"), (long int)(section->filepos + start_offset)); + printf ("\n"); + + data = xmalloc (datasize); + + bfd_get_section_contents (abfd, section, data, 0, datasize); + width = 4; bfd_sprintf_vma (abfd, buf, start_offset + section->vma); @@ -2511,12 +2625,16 @@ dump_symbols (bfd *abfd ATTRIBUTE_UNUSED, bfd_boolean dynamic) /* 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, @@ -2822,8 +2940,9 @@ dump_bfd (bfd *abfd) 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)); @@ -2975,7 +3094,7 @@ main (int argc, char **argv) bfd_init (); set_default_bfd_target (); - while ((c = getopt_long (argc, argv, "pib:m:M:VvCdDlfaHhrRtTxsSI:j:wE:zgeGW", + while ((c = getopt_long (argc, argv, "pib:m:M:VvCdDlfFaHhrRtTxsSI:j:wE:zgeGW", long_options, (int *) 0)) != EOF) { @@ -2990,7 +3109,7 @@ main (int argc, char **argv) if (disassembler_options) /* Ignore potential memory leak for now. */ disassembler_options = concat (disassembler_options, ",", - optarg, NULL); + optarg, (const char *) NULL); else disassembler_options = optarg; break; @@ -3002,6 +3121,9 @@ main (int argc, char **argv) } only [only_used++] = optarg; break; + case 'F': + display_file_offsets = TRUE; + break; case 'l': with_line_numbers = TRUE; break; @@ -3030,9 +3152,13 @@ main (int argc, char **argv) break; case OPTION_START_ADDRESS: start_address = parse_vma (optarg, "--start-address"); + if ((stop_address != (bfd_vma) -1) && stop_address <= start_address) + fatal (_("error: the start address should be before the end address")); break; case OPTION_STOP_ADDRESS: stop_address = parse_vma (optarg, "--stop-address"); + if ((start_address != (bfd_vma) -1) && stop_address <= start_address) + fatal (_("error: the stop address should be after the start address")); break; case 'E': if (strcmp (optarg, "B") == 0)