X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=binutils%2Fobjdump.c;h=4609858f9e38f19db0a812f529edf629496b8ed0;hb=65b48a81404cb058c75c562f7dfdeb74f07eba72;hp=758b0be4a68764d18d804413c527f94da05c9e74;hpb=d2fcac5caac9875cf9a8039b2061bf0b3895b9bc;p=deliverable%2Fbinutils-gdb.git diff --git a/binutils/objdump.c b/binutils/objdump.c index 758b0be4a6..4609858f9e 100644 --- a/binutils/objdump.c +++ b/binutils/objdump.c @@ -1,7 +1,5 @@ /* 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. @@ -29,14 +27,14 @@ 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. @@ -53,8 +51,10 @@ #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" @@ -64,13 +64,12 @@ #include "filenames.h" #include "debug.h" #include "budbg.h" +#include "objdump.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" @@ -92,6 +91,7 @@ static int dump_reloc_info; /* -r */ 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 */ @@ -109,6 +109,7 @@ static bfd_vma start_address = (bfd_vma) -1; /* --start-address */ 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 */ @@ -117,13 +118,16 @@ static const char *prefix; /* --prefix */ 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; @@ -180,7 +184,15 @@ static char *strtab; 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 + }; +static void usage (FILE *, int) ATTRIBUTE_NORETURN; static void usage (FILE *stream, int status) { @@ -191,6 +203,7 @@ 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\ @@ -200,8 +213,11 @@ usage (FILE *stream, int status) -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\ @@ -214,6 +230,8 @@ usage (FILE *stream, int status) ")); 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\ @@ -236,16 +254,29 @@ usage (FILE *stream, int status) --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); @@ -262,7 +293,10 @@ enum option_values 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[]= @@ -270,6 +304,7 @@ 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'}, @@ -310,6 +345,9 @@ static struct option long_options[]= {"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} }; @@ -325,24 +363,86 @@ nonfatal (const char *msg) 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); + } +} + 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. */ @@ -353,7 +453,7 @@ dump_section_header (bfd *abfd, asection *section, 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)); @@ -388,9 +488,18 @@ dump_section_header (bfd *abfd, asection *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) { @@ -427,28 +536,64 @@ dump_section_header (bfd *abfd, asection *section, #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); } static asymbol ** @@ -465,9 +610,12 @@ slurp_symtab (bfd *abfd) 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) @@ -489,6 +637,7 @@ slurp_dynamic_symtab (bfd *abfd) 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; } @@ -496,7 +645,7 @@ slurp_dynamic_symtab (bfd *abfd) 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) @@ -504,6 +653,18 @@ slurp_dynamic_symtab (bfd *abfd) 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. */ @@ -519,7 +680,8 @@ remove_useless_symbols (asymbol **symbols, long count) 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)) @@ -627,6 +789,21 @@ compare_symbols (const void *ap, const void *bp) 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] != '.') @@ -666,14 +843,14 @@ compare_relocs (const void *ap, const void *bp) 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; @@ -684,17 +861,18 @@ objdump_print_value (bfd_vma vma, struct disassemble_info *info, 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); @@ -706,10 +884,25 @@ objdump_print_symname (bfd *abfd, struct disassemble_info *info, 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); @@ -723,7 +916,7 @@ objdump_print_symname (bfd *abfd, struct disassemble_info *info, 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, @@ -733,7 +926,7 @@ find_symbol_for_address (bfd_vma vma, /* 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; @@ -744,22 +937,22 @@ find_symbol_for_address (bfd_vma vma, 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 @@ -771,23 +964,26 @@ find_symbol_for_address (bfd_vma vma, /* 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; @@ -807,7 +1003,7 @@ find_symbol_for_address (bfd_vma vma, 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 @@ -815,7 +1011,7 @@ find_symbol_for_address (bfd_vma vma, && 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; @@ -823,7 +1019,7 @@ find_symbol_for_address (bfd_vma vma, 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; @@ -847,7 +1043,7 @@ find_symbol_for_address (bfd_vma vma, 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; @@ -856,11 +1052,46 @@ find_symbol_for_address (bfd_vma vma, } 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; @@ -871,49 +1102,63 @@ find_symbol_for_address (bfd_vma vma, 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))); } @@ -922,23 +1167,23 @@ objdump_print_addr_with_sym (bfd *abfd, asection *sec, asymbol *sym, 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; } @@ -956,9 +1201,9 @@ objdump_print_addr (bfd_vma vma, } 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); } @@ -966,19 +1211,19 @@ objdump_print_addr (bfd_vma vma, 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)); } @@ -988,6 +1233,7 @@ objdump_symbol_at_address (bfd_vma vma, struct disassemble_info * info) 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 @@ -998,11 +1244,12 @@ struct print_file_list 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; }; @@ -1029,63 +1276,66 @@ slurp_file (const char *fn, size_t *size) 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; @@ -1095,14 +1345,14 @@ index_file (const char *map, size_t size, unsigned int *maxline) 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; } @@ -1114,7 +1364,7 @@ try_print_file_open (const char *origname, const char *modname) { 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) @@ -1122,9 +1372,10 @@ try_print_file_open (const char *origname, const char *modname) 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; @@ -1133,7 +1384,7 @@ try_print_file_open (const char *origname, const char *modname) 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. */ @@ -1144,9 +1395,6 @@ update_source_path (const char *filename) const char *fname; int i; - if (filename == NULL) - return NULL; - p = try_print_file_open (filename, filename); if (p != NULL) return p; @@ -1155,21 +1403,7 @@ update_source_path (const char *filename) 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. */ @@ -1189,16 +1423,16 @@ update_source_path (const char *filename) /* 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) @@ -1212,7 +1446,7 @@ dump_lines (struct print_file_list *p, unsigned int start, unsigned int end) { if (p->map == NULL) return; - while (start <= end) + while (start <= end) { print_line (p, start); start++; @@ -1227,14 +1461,17 @@ show_line (bfd *abfd, asection *section, bfd_vma addr_offset) { 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') @@ -1248,20 +1485,21 @@ show_line (bfd *abfd, asection *section, bfd_vma addr_offset) { 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)) { @@ -1270,7 +1508,7 @@ show_line (bfd *abfd, asection *section, bfd_vma addr_offset) } } - /* Update complete filename. */ + /* Update complete filename. */ strncpy (path_up, fname, PATH_MAX); path_up[PATH_MAX] = '\0'; @@ -1286,19 +1524,26 @@ show_line (bfd *abfd, asection *section, bfd_vma addr_offset) && (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; @@ -1309,20 +1554,27 @@ show_line (bfd *abfd, asection *section, bfd_vma addr_offset) 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; } } @@ -1333,12 +1585,18 @@ show_line (bfd *abfd, asection *section, bfd_vma addr_offset) { 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. */ @@ -1360,19 +1618,19 @@ objdump_sprintf (SFILE *f, const char *format, ...) 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; } @@ -1393,7 +1651,7 @@ objdump_sprintf (SFILE *f, const char *format, ...) /* 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, @@ -1406,22 +1664,21 @@ disassemble_bytes (struct disassemble_info * info, 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) @@ -1451,9 +1708,8 @@ disassemble_bytes (struct disassemble_info * info, 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) { @@ -1465,14 +1721,17 @@ disassemble_bytes (struct disassemble_info * info, 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))) @@ -1503,8 +1762,6 @@ disassemble_bytes (struct disassemble_info * info, int bpc = 0; int pb = 0; - done_dot = FALSE; - if (with_line_numbers || with_source_code) show_line (aux->abfd, section, addr_offset); @@ -1522,7 +1779,7 @@ disassemble_bytes (struct disassemble_info * info, 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 (' '); } @@ -1530,15 +1787,15 @@ disassemble_bytes (struct disassemble_info * info, 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) @@ -1565,22 +1822,37 @@ disassemble_bytes (struct disassemble_info * info, || (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; } } @@ -1614,8 +1886,8 @@ disassemble_bytes (struct disassemble_info * info, 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; @@ -1623,7 +1895,7 @@ disassemble_bytes (struct disassemble_info * info, { 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]); @@ -1684,7 +1956,7 @@ disassemble_bytes (struct disassemble_info * info, { 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]); @@ -1721,7 +1993,7 @@ disassemble_bytes (struct disassemble_info * info, printf ("\t\t\t"); objdump_print_value (section->vma - rel_offset + q->address, - info, TRUE); + inf, TRUE); if (q->howto == NULL) printf (": *unknown*\t"); @@ -1738,7 +2010,7 @@ disassemble_bytes (struct disassemble_info * info, 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; @@ -1753,8 +2025,15 @@ disassemble_bytes (struct disassemble_info * info, 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"); @@ -1773,11 +2052,11 @@ disassemble_bytes (struct disassemble_info * info, } 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; @@ -1785,7 +2064,7 @@ disassemble_section (bfd *abfd, asection *section, void *info) 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; @@ -1795,7 +2074,7 @@ disassemble_section (bfd *abfd, asection *section, void *info) /* 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; @@ -1807,9 +2086,30 @@ disassemble_section (bfd *abfd, asection *section, void *info) 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; @@ -1835,7 +2135,7 @@ disassemble_section (bfd *abfd, asection *section, void *info) 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)); @@ -1847,7 +2147,7 @@ disassemble_section (bfd *abfd, asection *section, void *info) } rel_ppend = rel_pp + rel_count; - data = xmalloc (datasize); + data = (bfd_byte *) xmalloc (datasize); bfd_get_section_contents (abfd, section, data, 0, datasize); @@ -1857,45 +2157,28 @@ disassemble_section (bfd *abfd, asection *section, void *info) 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 @@ -1905,7 +2188,7 @@ disassemble_section (bfd *abfd, asection *section, void *info) { bfd_vma addr; asymbol *nextsym; - unsigned long nextstop_offset; + bfd_vma nextstop_offset; bfd_boolean insns; addr = section->vma + addr_offset; @@ -1950,7 +2233,7 @@ disassemble_section (bfd *abfd, asection *section, void *info) ((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 @@ -1996,7 +2279,7 @@ disassemble_section (bfd *abfd, asection *section, void *info) disassemble_bytes (pinfo, paux->disassemble_fn, insns, data, addr_offset, nextstop_offset, rel_offset, &rel_pp, rel_ppend); - + addr_offset = nextstop_offset; sym = nextsym; } @@ -2019,11 +2302,13 @@ disassemble_data (bfd *abfd) 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 *)); @@ -2052,19 +2337,19 @@ disassemble_data (bfd *abfd) 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; @@ -2074,7 +2359,7 @@ disassemble_data (bfd *abfd) 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; @@ -2101,18 +2386,16 @@ disassemble_data (bfd *abfd) /* 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); @@ -2139,28 +2422,20 @@ load_specific_debug_section (enum dwarf_section_display_enum debug, 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) { @@ -2170,26 +2445,70 @@ load_specific_debug_section (enum dwarf_section_display_enum debug, 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. */ @@ -2220,6 +2539,23 @@ free_debug_section (enum dwarf_section_display_enum debug) 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; @@ -2232,7 +2568,7 @@ dump_dwarf_section (bfd *abfd, asection *section, { 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"; @@ -2251,12 +2587,13 @@ dump_dwarf_section (bfd *abfd, asection *section, 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; } @@ -2269,21 +2606,54 @@ dump_dwarf (bfd *abfd) { 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); @@ -2309,15 +2679,15 @@ read_section_stabs (bfd *abfd, const char *sect_name, bfd_size_type *size_ptr) } 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; } @@ -2364,7 +2734,7 @@ print_section_stabs (bfd *abfd, 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; @@ -2402,10 +2772,13 @@ print_section_stabs (bfd *abfd, } 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 (" *"); } @@ -2442,7 +2815,7 @@ find_stabs_section (bfd *abfd, asection *section, void *names) 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, @@ -2491,7 +2864,7 @@ dump_bfd_header (bfd *abfd) 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"); @@ -2504,7 +2877,6 @@ dump_bfd_header (bfd *abfd) 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"); @@ -2517,6 +2889,57 @@ dump_bfd_private_header (bfd *abfd) 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); +} /* Display a section in hexadecimal format with associated characters. Each line prefixed by the zero padded address. */ @@ -2526,9 +2949,9 @@ dump_section (bfd *abfd, asection *section, void *dummy ATTRIBUTE_UNUSED) { 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; @@ -2541,7 +2964,7 @@ dump_section (bfd *abfd, asection *section, void *dummy ATTRIBUTE_UNUSED) if (! process_section_p (section)) return; - + if ((datasize = bfd_section_size (abfd, section)) == 0) return; @@ -2567,16 +2990,19 @@ dump_section (bfd *abfd, asection *section, void *dummy ATTRIBUTE_UNUSED) 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; @@ -2660,26 +3086,26 @@ static void 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; @@ -2731,6 +3157,7 @@ dump_reloc_set (bfd *abfd, asection *sec, arelent **relpp, long relcount) arelent **p; char *last_filename, *last_functionname; unsigned int last_line; + unsigned int last_discriminator; /* Get column headers lined up reasonably. */ { @@ -2749,14 +3176,17 @@ dump_reloc_set (bfd *abfd, asection *sec, arelent **relpp, long relcount) 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) @@ -2767,8 +3197,9 @@ dump_reloc_set (bfd *abfd, asection *sec, arelent **relpp, long relcount) 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 @@ -2780,14 +3211,20 @@ dump_reloc_set (bfd *abfd, asection *sec, arelent **relpp, long relcount) 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) @@ -2812,7 +3249,37 @@ dump_reloc_set (bfd *abfd, asection *sec, arelent **relpp, long relcount) 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); @@ -2828,13 +3295,30 @@ dump_reloc_set (bfd *abfd, asection *sec, arelent **relpp, long relcount) } 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 @@ -2865,11 +3349,15 @@ dump_relocs_in_section (bfd *abfd, 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 @@ -2904,7 +3392,7 @@ dump_dynamic_relocs (bfd *abfd) printf (" (none)\n\n"); else { - relpp = xmalloc (relsize); + relpp = (arelent **) xmalloc (relsize); relcount = bfd_canonicalize_dynamic_reloc (abfd, relpp, dynsyms); if (relcount < 0) @@ -2929,8 +3417,8 @@ add_include_path (const char *path) 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); @@ -2966,7 +3454,7 @@ dump_bfd (bfd *abfd) 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) @@ -2975,10 +3463,10 @@ dump_bfd (bfd *abfd) 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 @@ -2986,6 +3474,10 @@ dump_bfd (bfd *abfd) || 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); @@ -3034,6 +3526,7 @@ dump_bfd (bfd *abfd) info in the file, try DWARF instead. */ else if (! dump_dwarf_section_info) { + dwarf_select_sections_all (); dump_dwarf (abfd); } } @@ -3062,7 +3555,7 @@ dump_bfd (bfd *abfd) } static void -display_bfd (bfd *abfd) +display_object_bfd (bfd *abfd) { char **matching; @@ -3102,30 +3595,30 @@ display_bfd (bfd *abfd) } 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); @@ -3138,10 +3631,18 @@ display_file (char *filename, char *target) 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; } @@ -3149,9 +3650,41 @@ display_file (char *filename, char *target) 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); } int @@ -3173,6 +3706,7 @@ main (int argc, char **argv) program_name = *argv; xmalloc_set_program_name (program_name); + bfd_set_error_program_name (program_name); START_PROGRESS (program_name, 0); @@ -3182,7 +3716,7 @@ main (int argc, char **argv) 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) { @@ -3194,20 +3728,19 @@ main (int argc, char **argv) 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; @@ -3272,7 +3805,7 @@ main (int argc, char **argv) endian = BFD_ENDIAN_LITTLE; else { - non_fatal (_("unrecognized -E option")); + nonfatal (_("unrecognized -E option")); usage (stderr, 1); } break; @@ -3284,6 +3817,7 @@ main (int argc, char **argv) else { non_fatal (_("unrecognized --endian type `%s'"), optarg); + exit_status = 1; usage (stderr, 1); } break; @@ -3303,6 +3837,10 @@ main (int argc, char **argv) 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; @@ -3363,6 +3901,22 @@ main (int argc, char **argv) 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; @@ -3387,15 +3941,15 @@ main (int argc, char **argv) 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); } @@ -3412,12 +3966,17 @@ main (int argc, char **argv) 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;