binutils/objdump.c

   1 /* objdump.c -- dump information about an object file.
   2    Copyright (C) 1990-2014 Free Software Foundation, Inc.
   3
   4    This file is part of GNU Binutils.
   5
   6    This program is free software; you can redistribute it and/or modify
   7    it under the terms of the GNU General Public License as published by
   8    the Free Software Foundation; either version 3, or (at your option)
   9    any later version.
  10
  11    This program is distributed in the hope that it will be useful,
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14    GNU General Public License for more details.
  15
  16    You should have received a copy of the GNU General Public License
  17    along with this program; if not, write to the Free Software
  18    Foundation, 51 Franklin Street - Fifth Floor, Boston,
  19    MA 02110-1301, USA.  */
  20
  21
  22 /* Objdump overview.
  23
  24    Objdump displays information about one or more object files, either on
  25    their own, or inside libraries.  It is commonly used as a disassembler,
  26    but it can also display information about file headers, symbol tables,
  27    relocations, debugging directives and more.
  28
  29    The flow of execution is as follows:
  30
  31    1. Command line arguments are checked for control switches and the
  32       information to be displayed is selected.
  33
  34    2. Any remaining arguments are assumed to be object files, and they are
  35       processed in order by display_bfd().  If the file is an archive each
  36       of its elements is processed in turn.
  37
  38    3. The file's target architecture and binary file format are determined
  39       by bfd_check_format().  If they are recognised, then dump_bfd() is
  40       called.
  41
  42    4. dump_bfd() in turn calls separate functions to display the requested
  43       item(s) of information(s).  For example disassemble_data() is called if
  44       a disassembly has been requested.
  45
  46    When disassembling the code loops through blocks of instructions bounded
  47    by symbols, calling disassemble_bytes() on each block.  The actual
  48    disassembling is done by the libopcodes library, via a function pointer
  49    supplied by the disassembler() function.  */
  50
  51 #include "sysdep.h"
  52 #include "bfd.h"
  53 #include "elf-bfd.h"
  54 #include "progress.h"
  55 #include "bucomm.h"
  56 #include "elfcomm.h"
  57 #include "dwarf.h"
  58 #include "getopt.h"
  59 #include "safe-ctype.h"
  60 #include "dis-asm.h"
  61 #include "libiberty.h"
  62 #include "demangle.h"
  63 #include "filenames.h"
  64 #include "debug.h"
  65 #include "budbg.h"
  66 #include "objdump.h"
  67
  68 #ifdef HAVE_MMAP
  69 #include <sys/mman.h>
  70 #endif
  71
  72 /* Internal headers for the ELF .stab-dump code - sorry.  */
  73 #define BYTES_IN_WORD   32
  74 #include "aout/aout64.h"
  75
  76 /* Exit status.  */
  77 static int exit_status = 0;
  78
  79 static char *default_target = NULL;     /* Default at runtime.  */
  80
  81 /* The following variables are set based on arguments passed on the
  82    command line.  */
  83 static int show_version = 0;            /* Show the version number.  */
  84 static int dump_section_contents;       /* -s */
  85 static int dump_section_headers;        /* -h */
  86 static bfd_boolean dump_file_header;    /* -f */
  87 static int dump_symtab;                 /* -t */
  88 static int dump_dynamic_symtab;         /* -T */
  89 static int dump_reloc_info;             /* -r */
  90 static int dump_dynamic_reloc_info;     /* -R */
  91 static int dump_ar_hdrs;                /* -a */
  92 static int dump_private_headers;        /* -p */
  93 static char *dump_private_options;      /* -P */
  94 static int prefix_addresses;            /* --prefix-addresses */
  95 static int with_line_numbers;           /* -l */
  96 static bfd_boolean with_source_code;    /* -S */
  97 static int show_raw_insn;               /* --show-raw-insn */
  98 static int dump_dwarf_section_info;     /* --dwarf */
  99 static int dump_stab_section_info;      /* --stabs */
 100 static int do_demangle;                 /* -C, --demangle */
 101 static bfd_boolean disassemble;         /* -d */
 102 static bfd_boolean disassemble_all;     /* -D */
 103 static int disassemble_zeroes;          /* --disassemble-zeroes */
 104 static bfd_boolean formats_info;        /* -i */
 105 static int wide_output;                 /* -w */
 106 static int insn_width;                  /* --insn-width */
 107 static bfd_vma start_address = (bfd_vma) -1; /* --start-address */
 108 static bfd_vma stop_address = (bfd_vma) -1;  /* --stop-address */
 109 static int dump_debugging;              /* --debugging */
 110 static int dump_debugging_tags;         /* --debugging-tags */
 111 static int suppress_bfd_header;
 112 static int dump_special_syms = 0;       /* --special-syms */
 113 static bfd_vma adjust_section_vma = 0;  /* --adjust-vma */
 114 static int file_start_context = 0;      /* --file-start-context */
 115 static bfd_boolean display_file_offsets;/* -F */
 116 static const char *prefix;              /* --prefix */
 117 static int prefix_strip;                /* --prefix-strip */
 118 static size_t prefix_length;
 119
 120 /* A structure to record the sections mentioned in -j switches.  */
 121 struct only
 122 {
 123   const char * name; /* The name of the section.  */
 124   bfd_boolean  seen; /* A flag to indicate that the section has been found in one or more input files.  */
 125   struct only * next; /* Pointer to the next structure in the list.  */
 126 };
 127 /* Pointer to an array of 'only' structures.
 128    This pointer is NULL if the -j switch has not been used.  */
 129 static struct only * only_list = NULL;
 130
 131 /* Variables for handling include file path table.  */
 132 static const char **include_paths;
 133 static int include_path_count;
 134
 135 /* Extra info to pass to the section disassembler and address printing
 136    function.  */
 137 struct objdump_disasm_info
 138 {
 139   bfd *              abfd;
 140   asection *         sec;
 141   bfd_boolean        require_sec;
 142   arelent **         dynrelbuf;
 143   long               dynrelcount;
 144   disassembler_ftype disassemble_fn;
 145   arelent *          reloc;
 146 };
 147
 148 /* Architecture to disassemble for, or default if NULL.  */
 149 static char *machine = NULL;
 150
 151 /* Target specific options to the disassembler.  */
 152 static char *disassembler_options = NULL;
 153
 154 /* Endianness to disassemble for, or default if BFD_ENDIAN_UNKNOWN.  */
 155 static enum bfd_endian endian = BFD_ENDIAN_UNKNOWN;
 156
 157 /* The symbol table.  */
 158 static asymbol **syms;
 159
 160 /* Number of symbols in `syms'.  */
 161 static long symcount = 0;
 162
 163 /* The sorted symbol table.  */
 164 static asymbol **sorted_syms;
 165
 166 /* Number of symbols in `sorted_syms'.  */
 167 static long sorted_symcount = 0;
 168
 169 /* The dynamic symbol table.  */
 170 static asymbol **dynsyms;
 171
 172 /* The synthetic symbol table.  */
 173 static asymbol *synthsyms;
 174 static long synthcount = 0;
 175
 176 /* Number of symbols in `dynsyms'.  */
 177 static long dynsymcount = 0;
 178
 179 static bfd_byte *stabs;
 180 static bfd_size_type stab_size;
 181
 182 static char *strtab;
 183 static bfd_size_type stabstr_size;
 184
 185 static bfd_boolean is_relocatable = FALSE;
 186
 187 /* Handlers for -P/--private.  */
 188 static const struct objdump_private_desc * const objdump_private_vectors[] =
 189   {
 190     OBJDUMP_PRIVATE_VECTORS
 191     NULL
 192   };
 193 \f
 194 static void usage (FILE *, int) ATTRIBUTE_NORETURN;
 195 static void
 196 usage (FILE *stream, int status)
 197 {
 198   fprintf (stream, _("Usage: %s <option(s)> <file(s)>\n"), program_name);
 199   fprintf (stream, _(" Display information from object <file(s)>.\n"));
 200   fprintf (stream, _(" At least one of the following switches must be given:\n"));
 201   fprintf (stream, _("\
 202   -a, --archive-headers    Display archive header information\n\
 203   -f, --file-headers       Display the contents of the overall file header\n\
 204   -p, --private-headers    Display object format specific file header contents\n\
 205   -P, --private=OPT,OPT... Display object format specific contents\n\
 206   -h, --[section-]headers  Display the contents of the section headers\n\
 207   -x, --all-headers        Display the contents of all headers\n\
 208   -d, --disassemble        Display assembler contents of executable sections\n\
 209   -D, --disassemble-all    Display assembler contents of all sections\n\
 210   -S, --source             Intermix source code with disassembly\n\
 211   -s, --full-contents      Display the full contents of all sections requested\n\
 212   -g, --debugging          Display debug information in object file\n\
 213   -e, --debugging-tags     Display debug information using ctags style\n\
 214   -G, --stabs              Display (in raw form) any STABS info in the file\n\
 215   -W[lLiaprmfFsoRt] or\n\
 216   --dwarf[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
 217           =frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
 218           =gdb_index,=trace_info,=trace_abbrev,=trace_aranges,\n\
 219           =addr,=cu_index]\n\
 220                            Display DWARF info in the file\n\
 221   -t, --syms               Display the contents of the symbol table(s)\n\
 222   -T, --dynamic-syms       Display the contents of the dynamic symbol table\n\
 223   -r, --reloc              Display the relocation entries in the file\n\
 224   -R, --dynamic-reloc      Display the dynamic relocation entries in the file\n\
 225   @<file>                  Read options from <file>\n\
 226   -v, --version            Display this program's version number\n\
 227   -i, --info               List object formats and architectures supported\n\
 228   -H, --help               Display this information\n\
 229 "));
 230   if (status != 2)
 231     {
 232       const struct objdump_private_desc * const *desc;
 233
 234       fprintf (stream, _("\n The following switches are optional:\n"));
 235       fprintf (stream, _("\
 236   -b, --target=BFDNAME           Specify the target object format as BFDNAME\n\
 237   -m, --architecture=MACHINE     Specify the target architecture as MACHINE\n\
 238   -j, --section=NAME             Only display information for section NAME\n\
 239   -M, --disassembler-options=OPT Pass text OPT on to the disassembler\n\
 240   -EB --endian=big               Assume big endian format when disassembling\n\
 241   -EL --endian=little            Assume little endian format when disassembling\n\
 242       --file-start-context       Include context from start of file (with -S)\n\
 243   -I, --include=DIR              Add DIR to search list for source files\n\
 244   -l, --line-numbers             Include line numbers and filenames in output\n\
 245   -F, --file-offsets             Include file offsets when displaying information\n\
 246   -C, --demangle[=STYLE]         Decode mangled/processed symbol names\n\
 247                                   The STYLE, if specified, can be `auto', `gnu',\n\
 248                                   `lucid', `arm', `hp', `edg', `gnu-v3', `java'\n\
 249                                   or `gnat'\n\
 250   -w, --wide                     Format output for more than 80 columns\n\
 251   -z, --disassemble-zeroes       Do not skip blocks of zeroes when disassembling\n\
 252       --start-address=ADDR       Only process data whose address is >= ADDR\n\
 253       --stop-address=ADDR        Only process data whose address is <= ADDR\n\
 254       --prefix-addresses         Print complete address alongside disassembly\n\
 255       --[no-]show-raw-insn       Display hex alongside symbolic disassembly\n\
 256       --insn-width=WIDTH         Display WIDTH bytes on a single line for -d\n\
 257       --adjust-vma=OFFSET        Add OFFSET to all displayed section addresses\n\
 258       --special-syms             Include special symbols in symbol dumps\n\
 259       --prefix=PREFIX            Add PREFIX to absolute paths for -S\n\
 260       --prefix-strip=LEVEL       Strip initial directory names for -S\n"));
 261       fprintf (stream, _("\
 262       --dwarf-depth=N        Do not display DIEs at depth N or greater\n\
 263       --dwarf-start=N        Display DIEs starting with N, at the same depth\n\
 264                              or deeper\n\
 265       --dwarf-check          Make additional dwarf internal consistency checks.\
 266       \n\n"));
 267       list_supported_targets (program_name, stream);
 268       list_supported_architectures (program_name, stream);
 269
 270       disassembler_usage (stream);
 271
 272       if (objdump_private_vectors[0] != NULL)
 273         {
 274           fprintf (stream,
 275                    _("\nOptions supported for -P/--private switch:\n"));
 276           for (desc = objdump_private_vectors; *desc != NULL; desc++)
 277             (*desc)->help (stream);
 278         }
 279     }
 280   if (REPORT_BUGS_TO[0] && status == 0)
 281     fprintf (stream, _("Report bugs to %s.\n"), REPORT_BUGS_TO);
 282   exit (status);
 283 }
 284
 285 /* 150 isn't special; it's just an arbitrary non-ASCII char value.  */
 286 enum option_values
 287   {
 288     OPTION_ENDIAN=150,
 289     OPTION_START_ADDRESS,
 290     OPTION_STOP_ADDRESS,
 291     OPTION_DWARF,
 292     OPTION_PREFIX,
 293     OPTION_PREFIX_STRIP,
 294     OPTION_INSN_WIDTH,
 295     OPTION_ADJUST_VMA,
 296     OPTION_DWARF_DEPTH,
 297     OPTION_DWARF_CHECK,
 298     OPTION_DWARF_START
 299   };
 300
 301 static struct option long_options[]=
 302 {
 303   {"adjust-vma", required_argument, NULL, OPTION_ADJUST_VMA},
 304   {"all-headers", no_argument, NULL, 'x'},
 305   {"private-headers", no_argument, NULL, 'p'},
 306   {"private", required_argument, NULL, 'P'},
 307   {"architecture", required_argument, NULL, 'm'},
 308   {"archive-headers", no_argument, NULL, 'a'},
 309   {"debugging", no_argument, NULL, 'g'},
 310   {"debugging-tags", no_argument, NULL, 'e'},
 311   {"demangle", optional_argument, NULL, 'C'},
 312   {"disassemble", no_argument, NULL, 'd'},
 313   {"disassemble-all", no_argument, NULL, 'D'},
 314   {"disassembler-options", required_argument, NULL, 'M'},
 315   {"disassemble-zeroes", no_argument, NULL, 'z'},
 316   {"dynamic-reloc", no_argument, NULL, 'R'},
 317   {"dynamic-syms", no_argument, NULL, 'T'},
 318   {"endian", required_argument, NULL, OPTION_ENDIAN},
 319   {"file-headers", no_argument, NULL, 'f'},
 320   {"file-offsets", no_argument, NULL, 'F'},
 321   {"file-start-context", no_argument, &file_start_context, 1},
 322   {"full-contents", no_argument, NULL, 's'},
 323   {"headers", no_argument, NULL, 'h'},
 324   {"help", no_argument, NULL, 'H'},
 325   {"info", no_argument, NULL, 'i'},
 326   {"line-numbers", no_argument, NULL, 'l'},
 327   {"no-show-raw-insn", no_argument, &show_raw_insn, -1},
 328   {"prefix-addresses", no_argument, &prefix_addresses, 1},
 329   {"reloc", no_argument, NULL, 'r'},
 330   {"section", required_argument, NULL, 'j'},
 331   {"section-headers", no_argument, NULL, 'h'},
 332   {"show-raw-insn", no_argument, &show_raw_insn, 1},
 333   {"source", no_argument, NULL, 'S'},
 334   {"special-syms", no_argument, &dump_special_syms, 1},
 335   {"include", required_argument, NULL, 'I'},
 336   {"dwarf", optional_argument, NULL, OPTION_DWARF},
 337   {"stabs", no_argument, NULL, 'G'},
 338   {"start-address", required_argument, NULL, OPTION_START_ADDRESS},
 339   {"stop-address", required_argument, NULL, OPTION_STOP_ADDRESS},
 340   {"syms", no_argument, NULL, 't'},
 341   {"target", required_argument, NULL, 'b'},
 342   {"version", no_argument, NULL, 'V'},
 343   {"wide", no_argument, NULL, 'w'},
 344   {"prefix", required_argument, NULL, OPTION_PREFIX},
 345   {"prefix-strip", required_argument, NULL, OPTION_PREFIX_STRIP},
 346   {"insn-width", required_argument, NULL, OPTION_INSN_WIDTH},
 347   {"dwarf-depth",      required_argument, 0, OPTION_DWARF_DEPTH},
 348   {"dwarf-start",      required_argument, 0, OPTION_DWARF_START},
 349   {"dwarf-check",      no_argument, 0, OPTION_DWARF_CHECK},
 350   {0, no_argument, 0, 0}
 351 };
 352 \f
 353 static void
 354 nonfatal (const char *msg)
 355 {
 356   bfd_nonfatal (msg);
 357   exit_status = 1;
 358 }
 359 \f
 360 /* Returns TRUE if the specified section should be dumped.  */
 361
 362 static bfd_boolean
 363 process_section_p (asection * section)
 364 {
 365   struct only * only;
 366
 367   if (only_list == NULL)
 368     return TRUE;
 369
 370   for (only = only_list; only; only = only->next)
 371     if (strcmp (only->name, section->name) == 0)
 372       {
 373         only->seen = TRUE;
 374         return TRUE;
 375       }
 376
 377   return FALSE;
 378 }
 379
 380 /* Add an entry to the 'only' list.  */
 381
 382 static void
 383 add_only (char * name)
 384 {
 385   struct only * only;
 386
 387   /* First check to make sure that we do not
 388      already have an entry for this name.  */
 389   for (only = only_list; only; only = only->next)
 390     if (strcmp (only->name, name) == 0)
 391       return;
 392
 393   only = xmalloc (sizeof * only);
 394   only->name = name;
 395   only->seen = FALSE;
 396   only->next = only_list;
 397   only_list = only;
 398 }
 399
 400 /* Release the memory used by the 'only' list.
 401    PR 11225: Issue a warning message for unseen sections.
 402    Only do this if none of the sections were seen.  This is mainly to support
 403    tools like the GAS testsuite where an object file is dumped with a list of
 404    generic section names known to be present in a range of different file
 405    formats.  */
 406
 407 static void
 408 free_only_list (void)
 409 {
 410   bfd_boolean at_least_one_seen = FALSE;
 411   struct only * only;
 412   struct only * next;
 413
 414   if (only_list == NULL)
 415     return;
 416
 417   for (only = only_list; only; only = only->next)
 418     if (only->seen)
 419       {
 420         at_least_one_seen = TRUE;
 421         break;
 422       }
 423
 424   for (only = only_list; only; only = next)
 425     {
 426       if (! at_least_one_seen)
 427         {
 428           non_fatal (_("section '%s' mentioned in a -j option, "
 429                        "but not found in any input file"),
 430                      only->name);
 431           exit_status = 1;
 432         }
 433       next = only->next;
 434       free (only);
 435     }
 436 }
 437
 438 \f
 439 static void
 440 dump_section_header (bfd *abfd, asection *section,
 441                      void *ignored ATTRIBUTE_UNUSED)
 442 {
 443   char *comma = "";
 444   unsigned int opb = bfd_octets_per_byte (abfd);
 445
 446   /* Ignore linker created section.  See elfNN_ia64_object_p in
 447      bfd/elfxx-ia64.c.  */
 448   if (section->flags & SEC_LINKER_CREATED)
 449     return;
 450
 451   /* PR 10413: Skip sections that we are ignoring.  */
 452   if (! process_section_p (section))
 453     return;
 454
 455   printf ("%3d %-13s %08lx  ", section->index,
 456           bfd_get_section_name (abfd, section),
 457           (unsigned long) bfd_section_size (abfd, section) / opb);
 458   bfd_printf_vma (abfd, bfd_get_section_vma (abfd, section));
 459   printf ("  ");
 460   bfd_printf_vma (abfd, section->lma);
 461   printf ("  %08lx  2**%u", (unsigned long) section->filepos,
 462           bfd_get_section_alignment (abfd, section));
 463   if (! wide_output)
 464     printf ("\n                ");
 465   printf ("  ");
 466
 467 #define PF(x, y) \
 468   if (section->flags & x) { printf ("%s%s", comma, y); comma = ", "; }
 469
 470   PF (SEC_HAS_CONTENTS, "CONTENTS");
 471   PF (SEC_ALLOC, "ALLOC");
 472   PF (SEC_CONSTRUCTOR, "CONSTRUCTOR");
 473   PF (SEC_LOAD, "LOAD");
 474   PF (SEC_RELOC, "RELOC");
 475   PF (SEC_READONLY, "READONLY");
 476   PF (SEC_CODE, "CODE");
 477   PF (SEC_DATA, "DATA");
 478   PF (SEC_ROM, "ROM");
 479   PF (SEC_DEBUGGING, "DEBUGGING");
 480   PF (SEC_NEVER_LOAD, "NEVER_LOAD");
 481   PF (SEC_EXCLUDE, "EXCLUDE");
 482   PF (SEC_SORT_ENTRIES, "SORT_ENTRIES");
 483   if (bfd_get_arch (abfd) == bfd_arch_tic54x)
 484     {
 485       PF (SEC_TIC54X_BLOCK, "BLOCK");
 486       PF (SEC_TIC54X_CLINK, "CLINK");
 487     }
 488   PF (SEC_SMALL_DATA, "SMALL_DATA");
 489   if (bfd_get_flavour (abfd) == bfd_target_coff_flavour)
 490     PF (SEC_COFF_SHARED, "SHARED");
 491   PF (SEC_THREAD_LOCAL, "THREAD_LOCAL");
 492   PF (SEC_GROUP, "GROUP");
 493
 494   if ((section->flags & SEC_LINK_ONCE) != 0)
 495     {
 496       const char *ls;
 497       struct coff_comdat_info *comdat;
 498
 499       switch (section->flags & SEC_LINK_DUPLICATES)
 500         {
 501         default:
 502           abort ();
 503         case SEC_LINK_DUPLICATES_DISCARD:
 504           ls = "LINK_ONCE_DISCARD";
 505           break;
 506         case SEC_LINK_DUPLICATES_ONE_ONLY:
 507           ls = "LINK_ONCE_ONE_ONLY";
 508           break;
 509         case SEC_LINK_DUPLICATES_SAME_SIZE:
 510           ls = "LINK_ONCE_SAME_SIZE";
 511           break;
 512         case SEC_LINK_DUPLICATES_SAME_CONTENTS:
 513           ls = "LINK_ONCE_SAME_CONTENTS";
 514           break;
 515         }
 516       printf ("%s%s", comma, ls);
 517
 518       comdat = bfd_coff_get_comdat_section (abfd, section);
 519       if (comdat != NULL)
 520         printf (" (COMDAT %s %ld)", comdat->name, comdat->symbol);
 521
 522       comma = ", ";
 523     }
 524
 525   printf ("\n");
 526 #undef PF
 527 }
 528
 529 static void
 530 dump_headers (bfd *abfd)
 531 {
 532   printf (_("Sections:\n"));
 533
 534 #ifndef BFD64
 535   printf (_("Idx Name          Size      VMA       LMA       File off  Algn"));
 536 #else
 537   /* With BFD64, non-ELF returns -1 and wants always 64 bit addresses.  */
 538   if (bfd_get_arch_size (abfd) == 32)
 539     printf (_("Idx Name          Size      VMA       LMA       File off  Algn"));
 540   else
 541     printf (_("Idx Name          Size      VMA               LMA               File off  Algn"));
 542 #endif
 543
 544   if (wide_output)
 545     printf (_("  Flags"));
 546   printf ("\n");
 547
 548   bfd_map_over_sections (abfd, dump_section_header, NULL);
 549 }
 550 \f
 551 static asymbol **
 552 slurp_symtab (bfd *abfd)
 553 {
 554   asymbol **sy = NULL;
 555   long storage;
 556
 557   if (!(bfd_get_file_flags (abfd) & HAS_SYMS))
 558     {
 559       symcount = 0;
 560       return NULL;
 561     }
 562
 563   storage = bfd_get_symtab_upper_bound (abfd);
 564   if (storage < 0)
 565     {
 566       non_fatal (_("failed to read symbol table from: %s"), bfd_get_filename (abfd));
 567       bfd_fatal (_("error message was"));
 568     }
 569   if (storage)
 570     sy = (asymbol **) xmalloc (storage);
 571
 572   symcount = bfd_canonicalize_symtab (abfd, sy);
 573   if (symcount < 0)
 574     bfd_fatal (bfd_get_filename (abfd));
 575   return sy;
 576 }
 577
 578 /* Read in the dynamic symbols.  */
 579
 580 static asymbol **
 581 slurp_dynamic_symtab (bfd *abfd)
 582 {
 583   asymbol **sy = NULL;
 584   long storage;
 585
 586   storage = bfd_get_dynamic_symtab_upper_bound (abfd);
 587   if (storage < 0)
 588     {
 589       if (!(bfd_get_file_flags (abfd) & DYNAMIC))
 590         {
 591           non_fatal (_("%s: not a dynamic object"), bfd_get_filename (abfd));
 592           exit_status = 1;
 593           dynsymcount = 0;
 594           return NULL;
 595         }
 596
 597       bfd_fatal (bfd_get_filename (abfd));
 598     }
 599   if (storage)
 600     sy = (asymbol **) xmalloc (storage);
 601
 602   dynsymcount = bfd_canonicalize_dynamic_symtab (abfd, sy);
 603   if (dynsymcount < 0)
 604     bfd_fatal (bfd_get_filename (abfd));
 605   return sy;
 606 }
 607
 608 /* Filter out (in place) symbols that are useless for disassembly.
 609    COUNT is the number of elements in SYMBOLS.
 610    Return the number of useful symbols.  */
 611
 612 static long
 613 remove_useless_symbols (asymbol **symbols, long count)
 614 {
 615   asymbol **in_ptr = symbols, **out_ptr = symbols;
 616
 617   while (--count >= 0)
 618     {
 619       asymbol *sym = *in_ptr++;
 620
 621       if (sym->name == NULL || sym->name[0] == '\0')
 622         continue;
 623       if (sym->flags & (BSF_DEBUGGING | BSF_SECTION_SYM))
 624         continue;
 625       if (bfd_is_und_section (sym->section)
 626           || bfd_is_com_section (sym->section))
 627         continue;
 628
 629       *out_ptr++ = sym;
 630     }
 631   return out_ptr - symbols;
 632 }
 633
 634 /* Sort symbols into value order.  */
 635
 636 static int
 637 compare_symbols (const void *ap, const void *bp)
 638 {
 639   const asymbol *a = * (const asymbol **) ap;
 640   const asymbol *b = * (const asymbol **) bp;
 641   const char *an;
 642   const char *bn;
 643   size_t anl;
 644   size_t bnl;
 645   bfd_boolean af;
 646   bfd_boolean bf;
 647   flagword aflags;
 648   flagword bflags;
 649
 650   if (bfd_asymbol_value (a) > bfd_asymbol_value (b))
 651     return 1;
 652   else if (bfd_asymbol_value (a) < bfd_asymbol_value (b))
 653     return -1;
 654
 655   if (a->section > b->section)
 656     return 1;
 657   else if (a->section < b->section)
 658     return -1;
 659
 660   an = bfd_asymbol_name (a);
 661   bn = bfd_asymbol_name (b);
 662   anl = strlen (an);
 663   bnl = strlen (bn);
 664
 665   /* The symbols gnu_compiled and gcc2_compiled convey no real
 666      information, so put them after other symbols with the same value.  */
 667   af = (strstr (an, "gnu_compiled") != NULL
 668         || strstr (an, "gcc2_compiled") != NULL);
 669   bf = (strstr (bn, "gnu_compiled") != NULL
 670         || strstr (bn, "gcc2_compiled") != NULL);
 671
 672   if (af && ! bf)
 673     return 1;
 674   if (! af && bf)
 675     return -1;
 676
 677   /* We use a heuristic for the file name, to try to sort it after
 678      more useful symbols.  It may not work on non Unix systems, but it
 679      doesn't really matter; the only difference is precisely which
 680      symbol names get printed.  */
 681
 682 #define file_symbol(s, sn, snl)                 \
 683   (((s)->flags & BSF_FILE) != 0                 \
 684    || ((sn)[(snl) - 2] == '.'                   \
 685        && ((sn)[(snl) - 1] == 'o'               \
 686            || (sn)[(snl) - 1] == 'a')))
 687
 688   af = file_symbol (a, an, anl);
 689   bf = file_symbol (b, bn, bnl);
 690
 691   if (af && ! bf)
 692     return 1;
 693   if (! af && bf)
 694     return -1;
 695
 696   /* Try to sort global symbols before local symbols before function
 697      symbols before debugging symbols.  */
 698
 699   aflags = a->flags;
 700   bflags = b->flags;
 701
 702   if ((aflags & BSF_DEBUGGING) != (bflags & BSF_DEBUGGING))
 703     {
 704       if ((aflags & BSF_DEBUGGING) != 0)
 705         return 1;
 706       else
 707         return -1;
 708     }
 709   if ((aflags & BSF_FUNCTION) != (bflags & BSF_FUNCTION))
 710     {
 711       if ((aflags & BSF_FUNCTION) != 0)
 712         return -1;
 713       else
 714         return 1;
 715     }
 716   if ((aflags & BSF_LOCAL) != (bflags & BSF_LOCAL))
 717     {
 718       if ((aflags & BSF_LOCAL) != 0)
 719         return 1;
 720       else
 721         return -1;
 722     }
 723   if ((aflags & BSF_GLOBAL) != (bflags & BSF_GLOBAL))
 724     {
 725       if ((aflags & BSF_GLOBAL) != 0)
 726         return -1;
 727       else
 728         return 1;
 729     }
 730
 731   /* Symbols that start with '.' might be section names, so sort them
 732      after symbols that don't start with '.'.  */
 733   if (an[0] == '.' && bn[0] != '.')
 734     return 1;
 735   if (an[0] != '.' && bn[0] == '.')
 736     return -1;
 737
 738   /* Finally, if we can't distinguish them in any other way, try to
 739      get consistent results by sorting the symbols by name.  */
 740   return strcmp (an, bn);
 741 }
 742
 743 /* Sort relocs into address order.  */
 744
 745 static int
 746 compare_relocs (const void *ap, const void *bp)
 747 {
 748   const arelent *a = * (const arelent **) ap;
 749   const arelent *b = * (const arelent **) bp;
 750
 751   if (a->address > b->address)
 752     return 1;
 753   else if (a->address < b->address)
 754     return -1;
 755
 756   /* So that associated relocations tied to the same address show up
 757      in the correct order, we don't do any further sorting.  */
 758   if (a > b)
 759     return 1;
 760   else if (a < b)
 761     return -1;
 762   else
 763     return 0;
 764 }
 765
 766 /* Print an address (VMA) to the output stream in INFO.
 767    If SKIP_ZEROES is TRUE, omit leading zeroes.  */
 768
 769 static void
 770 objdump_print_value (bfd_vma vma, struct disassemble_info *inf,
 771                      bfd_boolean skip_zeroes)
 772 {
 773   char buf[30];
 774   char *p;
 775   struct objdump_disasm_info *aux;
 776
 777   aux = (struct objdump_disasm_info *) inf->application_data;
 778   bfd_sprintf_vma (aux->abfd, buf, vma);
 779   if (! skip_zeroes)
 780     p = buf;
 781   else
 782     {
 783       for (p = buf; *p == '0'; ++p)
 784         ;
 785       if (*p == '\0')
 786         --p;
 787     }
 788   (*inf->fprintf_func) (inf->stream, "%s", p);
 789 }
 790
 791 /* Print the name of a symbol.  */
 792
 793 static void
 794 objdump_print_symname (bfd *abfd, struct disassemble_info *inf,
 795                        asymbol *sym)
 796 {
 797   char *alloc;
 798   const char *name;
 799
 800   alloc = NULL;
 801   name = bfd_asymbol_name (sym);
 802   if (do_demangle && name[0] != '\0')
 803     {
 804       /* Demangle the name.  */
 805       alloc = bfd_demangle (abfd, name, DMGL_ANSI | DMGL_PARAMS);
 806       if (alloc != NULL)
 807         name = alloc;
 808     }
 809
 810   if (inf != NULL)
 811     (*inf->fprintf_func) (inf->stream, "%s", name);
 812   else
 813     printf ("%s", name);
 814
 815   if (alloc != NULL)
 816     free (alloc);
 817 }
 818
 819 /* Locate a symbol given a bfd and a section (from INFO->application_data),
 820    and a VMA.  If INFO->application_data->require_sec is TRUE, then always
 821    require the symbol to be in the section.  Returns NULL if there is no
 822    suitable symbol.  If PLACE is not NULL, then *PLACE is set to the index
 823    of the symbol in sorted_syms.  */
 824
 825 static asymbol *
 826 find_symbol_for_address (bfd_vma vma,
 827                          struct disassemble_info *inf,
 828                          long *place)
 829 {
 830   /* @@ Would it speed things up to cache the last two symbols returned,
 831      and maybe their address ranges?  For many processors, only one memory
 832      operand can be present at a time, so the 2-entry cache wouldn't be
 833      constantly churned by code doing heavy memory accesses.  */
 834
 835   /* Indices in `sorted_syms'.  */
 836   long min = 0;
 837   long max_count = sorted_symcount;
 838   long thisplace;
 839   struct objdump_disasm_info *aux;
 840   bfd *abfd;
 841   asection *sec;
 842   unsigned int opb;
 843   bfd_boolean want_section;
 844
 845   if (sorted_symcount < 1)
 846     return NULL;
 847
 848   aux = (struct objdump_disasm_info *) inf->application_data;
 849   abfd = aux->abfd;
 850   sec = aux->sec;
 851   opb = inf->octets_per_byte;
 852
 853   /* Perform a binary search looking for the closest symbol to the
 854      required value.  We are searching the range (min, max_count].  */
 855   while (min + 1 < max_count)
 856     {
 857       asymbol *sym;
 858
 859       thisplace = (max_count + min) / 2;
 860       sym = sorted_syms[thisplace];
 861
 862       if (bfd_asymbol_value (sym) > vma)
 863         max_count = thisplace;
 864       else if (bfd_asymbol_value (sym) < vma)
 865         min = thisplace;
 866       else
 867         {
 868           min = thisplace;
 869           break;
 870         }
 871     }
 872
 873   /* The symbol we want is now in min, the low end of the range we
 874      were searching.  If there are several symbols with the same
 875      value, we want the first one.  */
 876   thisplace = min;
 877   while (thisplace > 0
 878          && (bfd_asymbol_value (sorted_syms[thisplace])
 879              == bfd_asymbol_value (sorted_syms[thisplace - 1])))
 880     --thisplace;
 881
 882   /* Prefer a symbol in the current section if we have multple symbols
 883      with the same value, as can occur with overlays or zero size
 884      sections.  */
 885   min = thisplace;
 886   while (min < max_count
 887          && (bfd_asymbol_value (sorted_syms[min])
 888              == bfd_asymbol_value (sorted_syms[thisplace])))
 889     {
 890       if (sorted_syms[min]->section == sec
 891           && inf->symbol_is_valid (sorted_syms[min], inf))
 892         {
 893           thisplace = min;
 894
 895           if (place != NULL)
 896             *place = thisplace;
 897
 898           return sorted_syms[thisplace];
 899         }
 900       ++min;
 901     }
 902
 903   /* If the file is relocatable, and the symbol could be from this
 904      section, prefer a symbol from this section over symbols from
 905      others, even if the other symbol's value might be closer.
 906
 907      Note that this may be wrong for some symbol references if the
 908      sections have overlapping memory ranges, but in that case there's
 909      no way to tell what's desired without looking at the relocation
 910      table.
 911
 912      Also give the target a chance to reject symbols.  */
 913   want_section = (aux->require_sec
 914                   || ((abfd->flags & HAS_RELOC) != 0
 915                       && vma >= bfd_get_section_vma (abfd, sec)
 916                       && vma < (bfd_get_section_vma (abfd, sec)
 917                                 + bfd_section_size (abfd, sec) / opb)));
 918   if ((sorted_syms[thisplace]->section != sec && want_section)
 919       || ! inf->symbol_is_valid (sorted_syms[thisplace], inf))
 920     {
 921       long i;
 922       long newplace = sorted_symcount;
 923
 924       for (i = min - 1; i >= 0; i--)
 925         {
 926           if ((sorted_syms[i]->section == sec || !want_section)
 927               && inf->symbol_is_valid (sorted_syms[i], inf))
 928             {
 929               if (newplace == sorted_symcount)
 930                 newplace = i;
 931
 932               if (bfd_asymbol_value (sorted_syms[i])
 933                   != bfd_asymbol_value (sorted_syms[newplace]))
 934                 break;
 935
 936               /* Remember this symbol and keep searching until we reach
 937                  an earlier address.  */
 938               newplace = i;
 939             }
 940         }
 941
 942       if (newplace != sorted_symcount)
 943         thisplace = newplace;
 944       else
 945         {
 946           /* We didn't find a good symbol with a smaller value.
 947              Look for one with a larger value.  */
 948           for (i = thisplace + 1; i < sorted_symcount; i++)
 949             {
 950               if ((sorted_syms[i]->section == sec || !want_section)
 951                   && inf->symbol_is_valid (sorted_syms[i], inf))
 952                 {
 953                   thisplace = i;
 954                   break;
 955                 }
 956             }
 957         }
 958
 959       if ((sorted_syms[thisplace]->section != sec && want_section)
 960           || ! inf->symbol_is_valid (sorted_syms[thisplace], inf))
 961         /* There is no suitable symbol.  */
 962         return NULL;
 963     }
 964
 965   if (place != NULL)
 966     *place = thisplace;
 967
 968   return sorted_syms[thisplace];
 969 }
 970
 971 /* Print an address and the offset to the nearest symbol.  */
 972
 973 static void
 974 objdump_print_addr_with_sym (bfd *abfd, asection *sec, asymbol *sym,
 975                              bfd_vma vma, struct disassemble_info *inf,
 976                              bfd_boolean skip_zeroes)
 977 {
 978   objdump_print_value (vma, inf, skip_zeroes);
 979
 980   if (sym == NULL)
 981     {
 982       bfd_vma secaddr;
 983
 984       (*inf->fprintf_func) (inf->stream, " <%s",
 985                             bfd_get_section_name (abfd, sec));
 986       secaddr = bfd_get_section_vma (abfd, sec);
 987       if (vma < secaddr)
 988         {
 989           (*inf->fprintf_func) (inf->stream, "-0x");
 990           objdump_print_value (secaddr - vma, inf, TRUE);
 991         }
 992       else if (vma > secaddr)
 993         {
 994           (*inf->fprintf_func) (inf->stream, "+0x");
 995           objdump_print_value (vma - secaddr, inf, TRUE);
 996         }
 997       (*inf->fprintf_func) (inf->stream, ">");
 998     }
 999   else
1000     {
1001       (*inf->fprintf_func) (inf->stream, " <");
1002       objdump_print_symname (abfd, inf, sym);
1003       if (bfd_asymbol_value (sym) > vma)
1004         {
1005           (*inf->fprintf_func) (inf->stream, "-0x");
1006           objdump_print_value (bfd_asymbol_value (sym) - vma, inf, TRUE);
1007         }
1008       else if (vma > bfd_asymbol_value (sym))
1009         {
1010           (*inf->fprintf_func) (inf->stream, "+0x");
1011           objdump_print_value (vma - bfd_asymbol_value (sym), inf, TRUE);
1012         }
1013       (*inf->fprintf_func) (inf->stream, ">");
1014     }
1015
1016   if (display_file_offsets)
1017     inf->fprintf_func (inf->stream, _(" (File Offset: 0x%lx)"),
1018                         (long int)(sec->filepos + (vma - sec->vma)));
1019 }
1020
1021 /* Print an address (VMA), symbolically if possible.
1022    If SKIP_ZEROES is TRUE, don't output leading zeroes.  */
1023
1024 static void
1025 objdump_print_addr (bfd_vma vma,
1026                     struct disassemble_info *inf,
1027                     bfd_boolean skip_zeroes)
1028 {
1029   struct objdump_disasm_info *aux;
1030   asymbol *sym = NULL;
1031   bfd_boolean skip_find = FALSE;
1032
1033   aux = (struct objdump_disasm_info *) inf->application_data;
1034
1035   if (sorted_symcount < 1)
1036     {
1037       (*inf->fprintf_func) (inf->stream, "0x");
1038       objdump_print_value (vma, inf, skip_zeroes);
1039
1040       if (display_file_offsets)
1041         inf->fprintf_func (inf->stream, _(" (File Offset: 0x%lx)"),
1042                            (long int)(aux->sec->filepos + (vma - aux->sec->vma)));
1043       return;
1044     }
1045
1046   if (aux->reloc != NULL
1047       && aux->reloc->sym_ptr_ptr != NULL
1048       && * aux->reloc->sym_ptr_ptr != NULL)
1049     {
1050       sym = * aux->reloc->sym_ptr_ptr;
1051
1052       /* Adjust the vma to the reloc.  */
1053       vma += bfd_asymbol_value (sym);
1054
1055       if (bfd_is_und_section (bfd_get_section (sym)))
1056         skip_find = TRUE;
1057     }
1058
1059   if (!skip_find)
1060     sym = find_symbol_for_address (vma, inf, NULL);
1061
1062   objdump_print_addr_with_sym (aux->abfd, aux->sec, sym, vma, inf,
1063                                skip_zeroes);
1064 }
1065
1066 /* Print VMA to INFO.  This function is passed to the disassembler
1067    routine.  */
1068
1069 static void
1070 objdump_print_address (bfd_vma vma, struct disassemble_info *inf)
1071 {
1072   objdump_print_addr (vma, inf, ! prefix_addresses);
1073 }
1074
1075 /* Determine if the given address has a symbol associated with it.  */
1076
1077 static int
1078 objdump_symbol_at_address (bfd_vma vma, struct disassemble_info * inf)
1079 {
1080   asymbol * sym;
1081
1082   sym = find_symbol_for_address (vma, inf, NULL);
1083
1084   return (sym != NULL && (bfd_asymbol_value (sym) == vma));
1085 }
1086
1087 /* Hold the last function name and the last line number we displayed
1088    in a disassembly.  */
1089
1090 static char *prev_functionname;
1091 static unsigned int prev_line;
1092 static unsigned int prev_discriminator;
1093
1094 /* We keep a list of all files that we have seen when doing a
1095    disassembly with source, so that we know how much of the file to
1096    display.  This can be important for inlined functions.  */
1097
1098 struct print_file_list
1099 {
1100   struct print_file_list *next;
1101   const char *filename;
1102   const char *modname;
1103   const char *map;
1104   size_t mapsize;
1105   const char **linemap;
1106   unsigned maxline;
1107   unsigned last_line;
1108   int first;
1109 };
1110
1111 static struct print_file_list *print_files;
1112
1113 /* The number of preceding context lines to show when we start
1114    displaying a file for the first time.  */
1115
1116 #define SHOW_PRECEDING_CONTEXT_LINES (5)
1117
1118 /* Read a complete file into memory.  */
1119
1120 static const char *
1121 slurp_file (const char *fn, size_t *size)
1122 {
1123 #ifdef HAVE_MMAP
1124   int ps = getpagesize ();
1125   size_t msize;
1126 #endif
1127   const char *map;
1128   struct stat st;
1129   int fd = open (fn, O_RDONLY | O_BINARY);
1130
1131   if (fd < 0)
1132     return NULL;
1133   if (fstat (fd, &st) < 0)
1134     {
1135       close (fd);
1136       return NULL;
1137     }
1138   *size = st.st_size;
1139 #ifdef HAVE_MMAP
1140   msize = (*size + ps - 1) & ~(ps - 1);
1141   map = mmap (NULL, msize, PROT_READ, MAP_SHARED, fd, 0);
1142   if (map != (char *) -1L)
1143     {
1144       close (fd);
1145       return map;
1146     }
1147 #endif
1148   map = (const char *) malloc (*size);
1149   if (!map || (size_t) read (fd, (char *) map, *size) != *size)
1150     {
1151       free ((void *) map);
1152       map = NULL;
1153     }
1154   close (fd);
1155   return map;
1156 }
1157
1158 #define line_map_decrease 5
1159
1160 /* Precompute array of lines for a mapped file. */
1161
1162 static const char **
1163 index_file (const char *map, size_t size, unsigned int *maxline)
1164 {
1165   const char *p, *lstart, *end;
1166   int chars_per_line = 45; /* First iteration will use 40.  */
1167   unsigned int lineno;
1168   const char **linemap = NULL;
1169   unsigned long line_map_size = 0;
1170
1171   lineno = 0;
1172   lstart = map;
1173   end = map + size;
1174
1175   for (p = map; p < end; p++)
1176     {
1177       if (*p == '\n')
1178         {
1179           if (p + 1 < end && p[1] == '\r')
1180             p++;
1181         }
1182       else if (*p == '\r')
1183         {
1184           if (p + 1 < end && p[1] == '\n')
1185             p++;
1186         }
1187       else
1188         continue;
1189
1190       /* End of line found.  */
1191
1192       if (linemap == NULL || line_map_size < lineno + 1)
1193         {
1194           unsigned long newsize;
1195
1196           chars_per_line -= line_map_decrease;
1197           if (chars_per_line <= 1)
1198             chars_per_line = 1;
1199           line_map_size = size / chars_per_line + 1;
1200           if (line_map_size < lineno + 1)
1201             line_map_size = lineno + 1;
1202           newsize = line_map_size * sizeof (char *);
1203           linemap = (const char **) xrealloc (linemap, newsize);
1204         }
1205
1206       linemap[lineno++] = lstart;
1207       lstart = p + 1;
1208     }
1209
1210   *maxline = lineno;
1211   return linemap;
1212 }
1213
1214 /* Tries to open MODNAME, and if successful adds a node to print_files
1215    linked list and returns that node.  Returns NULL on failure.  */
1216
1217 static struct print_file_list *
1218 try_print_file_open (const char *origname, const char *modname)
1219 {
1220   struct print_file_list *p;
1221
1222   p = (struct print_file_list *) xmalloc (sizeof (struct print_file_list));
1223
1224   p->map = slurp_file (modname, &p->mapsize);
1225   if (p->map == NULL)
1226     {
1227       free (p);
1228       return NULL;
1229     }
1230
1231   p->linemap = index_file (p->map, p->mapsize, &p->maxline);
1232   p->last_line = 0;
1233   p->filename = origname;
1234   p->modname = modname;
1235   p->next = print_files;
1236   p->first = 1;
1237   print_files = p;
1238   return p;
1239 }
1240
1241 /* If the source file, as described in the symtab, is not found
1242    try to locate it in one of the paths specified with -I
1243    If found, add location to print_files linked list.  */
1244
1245 static struct print_file_list *
1246 update_source_path (const char *filename)
1247 {
1248   struct print_file_list *p;
1249   const char *fname;
1250   int i;
1251
1252   p = try_print_file_open (filename, filename);
1253   if (p != NULL)
1254     return p;
1255
1256   if (include_path_count == 0)
1257     return NULL;
1258
1259   /* Get the name of the file.  */
1260   fname = lbasename (filename);
1261
1262   /* If file exists under a new path, we need to add it to the list
1263      so that show_line knows about it.  */
1264   for (i = 0; i < include_path_count; i++)
1265     {
1266       char *modname = concat (include_paths[i], "/", fname, (const char *) 0);
1267
1268       p = try_print_file_open (filename, modname);
1269       if (p)
1270         return p;
1271
1272       free (modname);
1273     }
1274
1275   return NULL;
1276 }
1277
1278 /* Print a source file line.  */
1279
1280 static void
1281 print_line (struct print_file_list *p, unsigned int linenum)
1282 {
1283   const char *l;
1284   size_t len;
1285
1286   --linenum;
1287   if (linenum >= p->maxline)
1288     return;
1289   l = p->linemap [linenum];
1290   /* Test fwrite return value to quiet glibc warning.  */
1291   len = strcspn (l, "\n\r");
1292   if (len == 0 || fwrite (l, len, 1, stdout) == 1)
1293     putchar ('\n');
1294 }
1295
1296 /* Print a range of source code lines. */
1297
1298 static void
1299 dump_lines (struct print_file_list *p, unsigned int start, unsigned int end)
1300 {
1301   if (p->map == NULL)
1302     return;
1303   while (start <= end)
1304     {
1305       print_line (p, start);
1306       start++;
1307     }
1308 }
1309
1310 /* Show the line number, or the source line, in a disassembly
1311    listing.  */
1312
1313 static void
1314 show_line (bfd *abfd, asection *section, bfd_vma addr_offset)
1315 {
1316   const char *filename;
1317   const char *functionname;
1318   unsigned int linenumber;
1319   unsigned int discriminator;
1320   bfd_boolean reloc;
1321
1322   if (! with_line_numbers && ! with_source_code)
1323     return;
1324
1325   if (! bfd_find_nearest_line_discriminator (abfd, section, syms, addr_offset,
1326                                              &filename, &functionname,
1327                                              &linenumber, &discriminator))
1328     return;
1329
1330   if (filename != NULL && *filename == '\0')
1331     filename = NULL;
1332   if (functionname != NULL && *functionname == '\0')
1333     functionname = NULL;
1334
1335   if (filename
1336       && IS_ABSOLUTE_PATH (filename)
1337       && prefix)
1338     {
1339       char *path_up;
1340       const char *fname = filename;
1341       char *path = (char *) alloca (prefix_length + PATH_MAX + 1);
1342
1343       if (prefix_length)
1344         memcpy (path, prefix, prefix_length);
1345       path_up = path + prefix_length;
1346
1347       /* Build relocated filename, stripping off leading directories
1348          from the initial filename if requested. */
1349       if (prefix_strip > 0)
1350         {
1351           int level = 0;
1352           const char *s;
1353
1354           /* Skip selected directory levels. */
1355           for (s = fname + 1; *s != '\0' && level < prefix_strip; s++)
1356             if (IS_DIR_SEPARATOR(*s))
1357               {
1358                 fname = s;
1359                 level++;
1360               }
1361         }
1362
1363       /* Update complete filename. */
1364       strncpy (path_up, fname, PATH_MAX);
1365       path_up[PATH_MAX] = '\0';
1366
1367       filename = path;
1368       reloc = TRUE;
1369     }
1370   else
1371     reloc = FALSE;
1372
1373   if (with_line_numbers)
1374     {
1375       if (functionname != NULL
1376           && (prev_functionname == NULL
1377               || strcmp (functionname, prev_functionname) != 0))
1378         printf ("%s():\n", functionname);
1379       if (linenumber > 0 && (linenumber != prev_line ||
1380                              (discriminator != prev_discriminator)))
1381         {
1382           if (discriminator > 0)
1383             printf ("%s:%u (discriminator %u)\n", filename == NULL ? "???" : filename,
1384                     linenumber, discriminator);
1385           else
1386             printf ("%s:%u\n", filename == NULL ? "???" : filename, linenumber);
1387         }
1388     }
1389
1390   if (with_source_code
1391       && filename != NULL
1392       && linenumber > 0)
1393     {
1394       struct print_file_list **pp, *p;
1395       unsigned l;
1396
1397       for (pp = &print_files; *pp != NULL; pp = &(*pp)->next)
1398         if (filename_cmp ((*pp)->filename, filename) == 0)
1399           break;
1400       p = *pp;
1401
1402       if (p == NULL)
1403         {
1404           if (reloc)
1405             filename = xstrdup (filename);
1406           p = update_source_path (filename);
1407         }
1408
1409       if (p != NULL && linenumber != p->last_line)
1410         {
1411           if (file_start_context && p->first)
1412             l = 1;
1413           else
1414             {
1415               l = linenumber - SHOW_PRECEDING_CONTEXT_LINES;
1416               if (l >= linenumber)
1417                 l = 1;
1418               if (p->last_line >= l && p->last_line <= linenumber)
1419                 l = p->last_line + 1;
1420             }
1421           dump_lines (p, l, linenumber);
1422           p->last_line = linenumber;
1423           p->first = 0;
1424         }
1425     }
1426
1427   if (functionname != NULL
1428       && (prev_functionname == NULL
1429           || strcmp (functionname, prev_functionname) != 0))
1430     {
1431       if (prev_functionname != NULL)
1432         free (prev_functionname);
1433       prev_functionname = (char *) xmalloc (strlen (functionname) + 1);
1434       strcpy (prev_functionname, functionname);
1435     }
1436
1437   if (linenumber > 0 && linenumber != prev_line)
1438     prev_line = linenumber;
1439
1440   if (discriminator != prev_discriminator)
1441     prev_discriminator = discriminator;
1442 }
1443
1444 /* Pseudo FILE object for strings.  */
1445 typedef struct
1446 {
1447   char *buffer;
1448   size_t pos;
1449   size_t alloc;
1450 } SFILE;
1451
1452 /* sprintf to a "stream".  */
1453
1454 static int ATTRIBUTE_PRINTF_2
1455 objdump_sprintf (SFILE *f, const char *format, ...)
1456 {
1457   size_t n;
1458   va_list args;
1459
1460   while (1)
1461     {
1462       size_t space = f->alloc - f->pos;
1463
1464       va_start (args, format);
1465       n = vsnprintf (f->buffer + f->pos, space, format, args);
1466       va_end (args);
1467
1468       if (space > n)
1469         break;
1470
1471       f->alloc = (f->alloc + n) * 2;
1472       f->buffer = (char *) xrealloc (f->buffer, f->alloc);
1473     }
1474   f->pos += n;
1475
1476   return n;
1477 }
1478
1479 /* The number of zeroes we want to see before we start skipping them.
1480    The number is arbitrarily chosen.  */
1481
1482 #define DEFAULT_SKIP_ZEROES 8
1483
1484 /* The number of zeroes to skip at the end of a section.  If the
1485    number of zeroes at the end is between SKIP_ZEROES_AT_END and
1486    SKIP_ZEROES, they will be disassembled.  If there are fewer than
1487    SKIP_ZEROES_AT_END, they will be skipped.  This is a heuristic
1488    attempt to avoid disassembling zeroes inserted by section
1489    alignment.  */
1490
1491 #define DEFAULT_SKIP_ZEROES_AT_END 3
1492
1493 /* Disassemble some data in memory between given values.  */
1494
1495 static void
1496 disassemble_bytes (struct disassemble_info * inf,
1497                    disassembler_ftype        disassemble_fn,
1498                    bfd_boolean               insns,
1499                    bfd_byte *                data,
1500                    bfd_vma                   start_offset,
1501                    bfd_vma                   stop_offset,
1502                    bfd_vma                   rel_offset,
1503                    arelent ***               relppp,
1504                    arelent **                relppend)
1505 {
1506   struct objdump_disasm_info *aux;
1507   asection *section;
1508   int octets_per_line;
1509   int skip_addr_chars;
1510   bfd_vma addr_offset;
1511   unsigned int opb = inf->octets_per_byte;
1512   unsigned int skip_zeroes = inf->skip_zeroes;
1513   unsigned int skip_zeroes_at_end = inf->skip_zeroes_at_end;
1514   int octets = opb;
1515   SFILE sfile;
1516
1517   aux = (struct objdump_disasm_info *) inf->application_data;
1518   section = aux->sec;
1519
1520   sfile.alloc = 120;
1521   sfile.buffer = (char *) xmalloc (sfile.alloc);
1522   sfile.pos = 0;
1523
1524   if (insn_width)
1525     octets_per_line = insn_width;
1526   else if (insns)
1527     octets_per_line = 4;
1528   else
1529     octets_per_line = 16;
1530
1531   /* Figure out how many characters to skip at the start of an
1532      address, to make the disassembly look nicer.  We discard leading
1533      zeroes in chunks of 4, ensuring that there is always a leading
1534      zero remaining.  */
1535   skip_addr_chars = 0;
1536   if (! prefix_addresses)
1537     {
1538       char buf[30];
1539
1540       bfd_sprintf_vma (aux->abfd, buf, section->vma + section->size / opb);
1541
1542       while (buf[skip_addr_chars] == '0')
1543         ++skip_addr_chars;
1544
1545       /* Don't discard zeros on overflow.  */
1546       if (buf[skip_addr_chars] == '\0' && section->vma != 0)
1547         skip_addr_chars = 0;
1548
1549       if (skip_addr_chars != 0)
1550         skip_addr_chars = (skip_addr_chars - 1) & -4;
1551     }
1552
1553   inf->insn_info_valid = 0;
1554
1555   addr_offset = start_offset;
1556   while (addr_offset < stop_offset)
1557     {
1558       bfd_vma z;
1559       bfd_boolean need_nl = FALSE;
1560       int previous_octets;
1561
1562       /* Remember the length of the previous instruction.  */
1563       previous_octets = octets;
1564       octets = 0;
1565
1566       /* Make sure we don't use relocs from previous instructions.  */
1567       aux->reloc = NULL;
1568
1569       /* If we see more than SKIP_ZEROES octets of zeroes, we just
1570          print `...'.  */
1571       for (z = addr_offset * opb; z < stop_offset * opb; z++)
1572         if (data[z] != 0)
1573           break;
1574       if (! disassemble_zeroes
1575           && (inf->insn_info_valid == 0
1576               || inf->branch_delay_insns == 0)
1577           && (z - addr_offset * opb >= skip_zeroes
1578               || (z == stop_offset * opb &&
1579                   z - addr_offset * opb < skip_zeroes_at_end)))
1580         {
1581           /* If there are more nonzero octets to follow, we only skip
1582              zeroes in multiples of 4, to try to avoid running over
1583              the start of an instruction which happens to start with
1584              zero.  */
1585           if (z != stop_offset * opb)
1586             z = addr_offset * opb + ((z - addr_offset * opb) &~ 3);
1587
1588           octets = z - addr_offset * opb;
1589
1590           /* If we are going to display more data, and we are displaying
1591              file offsets, then tell the user how many zeroes we skip
1592              and the file offset from where we resume dumping.  */
1593           if (display_file_offsets && ((addr_offset + (octets / opb)) < stop_offset))
1594             printf ("\t... (skipping %d zeroes, resuming at file offset: 0x%lx)\n",
1595                     octets / opb,
1596                     (unsigned long) (section->filepos
1597                                      + (addr_offset + (octets / opb))));
1598           else
1599             printf ("\t...\n");
1600         }
1601       else
1602         {
1603           char buf[50];
1604           int bpc = 0;
1605           int pb = 0;
1606
1607           if (with_line_numbers || with_source_code)
1608             show_line (aux->abfd, section, addr_offset);
1609
1610           if (! prefix_addresses)
1611             {
1612               char *s;
1613
1614               bfd_sprintf_vma (aux->abfd, buf, section->vma + addr_offset);
1615               for (s = buf + skip_addr_chars; *s == '0'; s++)
1616                 *s = ' ';
1617               if (*s == '\0')
1618                 *--s = '0';
1619               printf ("%s:\t", buf + skip_addr_chars);
1620             }
1621           else
1622             {
1623               aux->require_sec = TRUE;
1624               objdump_print_address (section->vma + addr_offset, inf);
1625               aux->require_sec = FALSE;
1626               putchar (' ');
1627             }
1628
1629           if (insns)
1630             {
1631               sfile.pos = 0;
1632               inf->fprintf_func = (fprintf_ftype) objdump_sprintf;
1633               inf->stream = &sfile;
1634               inf->bytes_per_line = 0;
1635               inf->bytes_per_chunk = 0;
1636               inf->flags = disassemble_all ? DISASSEMBLE_DATA : 0;
1637               if (machine)
1638                 inf->flags |= USER_SPECIFIED_MACHINE_TYPE;
1639
1640               if (inf->disassembler_needs_relocs
1641                   && (bfd_get_file_flags (aux->abfd) & EXEC_P) == 0
1642                   && (bfd_get_file_flags (aux->abfd) & DYNAMIC) == 0
1643                   && *relppp < relppend)
1644                 {
1645                   bfd_signed_vma distance_to_rel;
1646
1647                   distance_to_rel = (**relppp)->address
1648                     - (rel_offset + addr_offset);
1649
1650                   /* Check to see if the current reloc is associated with
1651                      the instruction that we are about to disassemble.  */
1652                   if (distance_to_rel == 0
1653                       /* FIXME: This is wrong.  We are trying to catch
1654                          relocs that are addressed part way through the
1655                          current instruction, as might happen with a packed
1656                          VLIW instruction.  Unfortunately we do not know the
1657                          length of the current instruction since we have not
1658                          disassembled it yet.  Instead we take a guess based
1659                          upon the length of the previous instruction.  The
1660                          proper solution is to have a new target-specific
1661                          disassembler function which just returns the length
1662                          of an instruction at a given address without trying
1663                          to display its disassembly. */
1664                       || (distance_to_rel > 0
1665                           && distance_to_rel < (bfd_signed_vma) (previous_octets/ opb)))
1666                     {
1667                       inf->flags |= INSN_HAS_RELOC;
1668                       aux->reloc = **relppp;
1669                     }
1670                 }
1671
1672               octets = (*disassemble_fn) (section->vma + addr_offset, inf);
1673               inf->fprintf_func = (fprintf_ftype) fprintf;
1674               inf->stream = stdout;
1675               if (insn_width == 0 && inf->bytes_per_line != 0)
1676                 octets_per_line = inf->bytes_per_line;
1677               if (octets < (int) opb)
1678                 {
1679                   if (sfile.pos)
1680                     printf ("%s\n", sfile.buffer);
1681                   if (octets >= 0)
1682                     {
1683                       non_fatal (_("disassemble_fn returned length %d"),
1684                                  octets);
1685                       exit_status = 1;
1686                     }
1687                   break;
1688                 }
1689             }
1690           else
1691             {
1692               bfd_vma j;
1693
1694               octets = octets_per_line;
1695               if (addr_offset + octets / opb > stop_offset)
1696                 octets = (stop_offset - addr_offset) * opb;
1697
1698               for (j = addr_offset * opb; j < addr_offset * opb + octets; ++j)
1699                 {
1700                   if (ISPRINT (data[j]))
1701                     buf[j - addr_offset * opb] = data[j];
1702                   else
1703                     buf[j - addr_offset * opb] = '.';
1704                 }
1705               buf[j - addr_offset * opb] = '\0';
1706             }
1707
1708           if (prefix_addresses
1709               ? show_raw_insn > 0
1710               : show_raw_insn >= 0)
1711             {
1712               bfd_vma j;
1713
1714               /* If ! prefix_addresses and ! wide_output, we print
1715                  octets_per_line octets per line.  */
1716               pb = octets;
1717               if (pb > octets_per_line && ! prefix_addresses && ! wide_output)
1718                 pb = octets_per_line;
1719
1720               if (inf->bytes_per_chunk)
1721                 bpc = inf->bytes_per_chunk;
1722               else
1723                 bpc = 1;
1724
1725               for (j = addr_offset * opb; j < addr_offset * opb + pb; j += bpc)
1726                 {
1727                   int k;
1728
1729                   if (bpc > 1 && inf->display_endian == BFD_ENDIAN_LITTLE)
1730                     {
1731                       for (k = bpc - 1; k >= 0; k--)
1732                         printf ("%02x", (unsigned) data[j + k]);
1733                       putchar (' ');
1734                     }
1735                   else
1736                     {
1737                       for (k = 0; k < bpc; k++)
1738                         printf ("%02x", (unsigned) data[j + k]);
1739                       putchar (' ');
1740                     }
1741                 }
1742
1743               for (; pb < octets_per_line; pb += bpc)
1744                 {
1745                   int k;
1746
1747                   for (k = 0; k < bpc; k++)
1748                     printf ("  ");
1749                   putchar (' ');
1750                 }
1751
1752               /* Separate raw data from instruction by extra space.  */
1753               if (insns)
1754                 putchar ('\t');
1755               else
1756                 printf ("    ");
1757             }
1758
1759           if (! insns)
1760             printf ("%s", buf);
1761           else if (sfile.pos)
1762             printf ("%s", sfile.buffer);
1763
1764           if (prefix_addresses
1765               ? show_raw_insn > 0
1766               : show_raw_insn >= 0)
1767             {
1768               while (pb < octets)
1769                 {
1770                   bfd_vma j;
1771                   char *s;
1772
1773                   putchar ('\n');
1774                   j = addr_offset * opb + pb;
1775
1776                   bfd_sprintf_vma (aux->abfd, buf, section->vma + j / opb);
1777                   for (s = buf + skip_addr_chars; *s == '0'; s++)
1778                     *s = ' ';
1779                   if (*s == '\0')
1780                     *--s = '0';
1781                   printf ("%s:\t", buf + skip_addr_chars);
1782
1783                   pb += octets_per_line;
1784                   if (pb > octets)
1785                     pb = octets;
1786                   for (; j < addr_offset * opb + pb; j += bpc)
1787                     {
1788                       int k;
1789
1790                       if (bpc > 1 && inf->display_endian == BFD_ENDIAN_LITTLE)
1791                         {
1792                           for (k = bpc - 1; k >= 0; k--)
1793                             printf ("%02x", (unsigned) data[j + k]);
1794                           putchar (' ');
1795                         }
1796                       else
1797                         {
1798                           for (k = 0; k < bpc; k++)
1799                             printf ("%02x", (unsigned) data[j + k]);
1800                           putchar (' ');
1801                         }
1802                     }
1803                 }
1804             }
1805
1806           if (!wide_output)
1807             putchar ('\n');
1808           else
1809             need_nl = TRUE;
1810         }
1811
1812       while ((*relppp) < relppend
1813              && (**relppp)->address < rel_offset + addr_offset + octets / opb)
1814         {
1815           if (dump_reloc_info || dump_dynamic_reloc_info)
1816             {
1817               arelent *q;
1818
1819               q = **relppp;
1820
1821               if (wide_output)
1822                 putchar ('\t');
1823               else
1824                 printf ("\t\t\t");
1825
1826               objdump_print_value (section->vma - rel_offset + q->address,
1827                                    inf, TRUE);
1828
1829               if (q->howto == NULL)
1830                 printf (": *unknown*\t");
1831               else if (q->howto->name)
1832                 printf (": %s\t", q->howto->name);
1833               else
1834                 printf (": %d\t", q->howto->type);
1835
1836               if (q->sym_ptr_ptr == NULL || *q->sym_ptr_ptr == NULL)
1837                 printf ("*unknown*");
1838               else
1839                 {
1840                   const char *sym_name;
1841
1842                   sym_name = bfd_asymbol_name (*q->sym_ptr_ptr);
1843                   if (sym_name != NULL && *sym_name != '\0')
1844                     objdump_print_symname (aux->abfd, inf, *q->sym_ptr_ptr);
1845                   else
1846                     {
1847                       asection *sym_sec;
1848
1849                       sym_sec = bfd_get_section (*q->sym_ptr_ptr);
1850                       sym_name = bfd_get_section_name (aux->abfd, sym_sec);
1851                       if (sym_name == NULL || *sym_name == '\0')
1852                         sym_name = "*unknown*";
1853                       printf ("%s", sym_name);
1854                     }
1855                 }
1856
1857               if (q->addend)
1858                 {
1859                   bfd_signed_vma addend = q->addend;
1860                   if (addend < 0)
1861                     {
1862                       printf ("-0x");
1863                       addend = -addend;
1864                     }
1865                   else
1866                     printf ("+0x");
1867                   objdump_print_value (addend, inf, TRUE);
1868                 }
1869
1870               printf ("\n");
1871               need_nl = FALSE;
1872             }
1873           ++(*relppp);
1874         }
1875
1876       if (need_nl)
1877         printf ("\n");
1878
1879       addr_offset += octets / opb;
1880     }
1881
1882   free (sfile.buffer);
1883 }
1884
1885 static void
1886 disassemble_section (bfd *abfd, asection *section, void *inf)
1887 {
1888   const struct elf_backend_data * bed;
1889   bfd_vma                      sign_adjust = 0;
1890   struct disassemble_info *    pinfo = (struct disassemble_info *) inf;
1891   struct objdump_disasm_info * paux;
1892   unsigned int                 opb = pinfo->octets_per_byte;
1893   bfd_byte *                   data = NULL;
1894   bfd_size_type                datasize = 0;
1895   arelent **                   rel_pp = NULL;
1896   arelent **                   rel_ppstart = NULL;
1897   arelent **                   rel_ppend;
1898   unsigned long                stop_offset;
1899   asymbol *                    sym = NULL;
1900   long                         place = 0;
1901   long                         rel_count;
1902   bfd_vma                      rel_offset;
1903   unsigned long                addr_offset;
1904
1905   /* Sections that do not contain machine
1906      code are not normally disassembled.  */
1907   if (! disassemble_all
1908       && only_list == NULL
1909       && ((section->flags & (SEC_CODE | SEC_HAS_CONTENTS))
1910           != (SEC_CODE | SEC_HAS_CONTENTS)))
1911     return;
1912
1913   if (! process_section_p (section))
1914     return;
1915
1916   datasize = bfd_get_section_size (section);
1917   if (datasize == 0)
1918     return;
1919
1920   if (start_address == (bfd_vma) -1
1921       || start_address < section->vma)
1922     addr_offset = 0;
1923   else
1924     addr_offset = start_address - section->vma;
1925
1926   if (stop_address == (bfd_vma) -1)
1927     stop_offset = datasize / opb;
1928   else
1929     {
1930       if (stop_address < section->vma)
1931         stop_offset = 0;
1932       else
1933         stop_offset = stop_address - section->vma;
1934       if (stop_offset > datasize / opb)
1935         stop_offset = datasize / opb;
1936     }
1937
1938   if (addr_offset >= stop_offset)
1939     return;
1940
1941   /* Decide which set of relocs to use.  Load them if necessary.  */
1942   paux = (struct objdump_disasm_info *) pinfo->application_data;
1943   if (paux->dynrelbuf)
1944     {
1945       rel_pp = paux->dynrelbuf;
1946       rel_count = paux->dynrelcount;
1947       /* Dynamic reloc addresses are absolute, non-dynamic are section
1948          relative.  REL_OFFSET specifies the reloc address corresponding
1949          to the start of this section.  */
1950       rel_offset = section->vma;
1951     }
1952   else
1953     {
1954       rel_count = 0;
1955       rel_pp = NULL;
1956       rel_offset = 0;
1957
1958       if ((section->flags & SEC_RELOC) != 0
1959           && (dump_reloc_info || pinfo->disassembler_needs_relocs))
1960         {
1961           long relsize;
1962
1963           relsize = bfd_get_reloc_upper_bound (abfd, section);
1964           if (relsize < 0)
1965             bfd_fatal (bfd_get_filename (abfd));
1966
1967           if (relsize > 0)
1968             {
1969               rel_ppstart = rel_pp = (arelent **) xmalloc (relsize);
1970               rel_count = bfd_canonicalize_reloc (abfd, section, rel_pp, syms);
1971               if (rel_count < 0)
1972                 bfd_fatal (bfd_get_filename (abfd));
1973
1974               /* Sort the relocs by address.  */
1975               qsort (rel_pp, rel_count, sizeof (arelent *), compare_relocs);
1976             }
1977         }
1978     }
1979   rel_ppend = rel_pp + rel_count;
1980
1981   data = (bfd_byte *) xmalloc (datasize);
1982
1983   bfd_get_section_contents (abfd, section, data, 0, datasize);
1984
1985   paux->sec = section;
1986   pinfo->buffer = data;
1987   pinfo->buffer_vma = section->vma;
1988   pinfo->buffer_length = datasize;
1989   pinfo->section = section;
1990
1991   /* Skip over the relocs belonging to addresses below the
1992      start address.  */
1993   while (rel_pp < rel_ppend
1994          && (*rel_pp)->address < rel_offset + addr_offset)
1995     ++rel_pp;
1996
1997   printf (_("\nDisassembly of section %s:\n"), section->name);
1998
1999   /* Find the nearest symbol forwards from our current position.  */
2000   paux->require_sec = TRUE;
2001   sym = (asymbol *) find_symbol_for_address (section->vma + addr_offset,
2002                                              (struct disassemble_info *) inf,
2003                                              &place);
2004   paux->require_sec = FALSE;
2005
2006   /* PR 9774: If the target used signed addresses then we must make
2007      sure that we sign extend the value that we calculate for 'addr'
2008      in the loop below.  */
2009   if (bfd_get_flavour (abfd) == bfd_target_elf_flavour
2010       && (bed = get_elf_backend_data (abfd)) != NULL
2011       && bed->sign_extend_vma)
2012     sign_adjust = (bfd_vma) 1 << (bed->s->arch_size - 1);
2013
2014   /* Disassemble a block of instructions up to the address associated with
2015      the symbol we have just found.  Then print the symbol and find the
2016      next symbol on.  Repeat until we have disassembled the entire section
2017      or we have reached the end of the address range we are interested in.  */
2018   while (addr_offset < stop_offset)
2019     {
2020       bfd_vma addr;
2021       asymbol *nextsym;
2022       unsigned long nextstop_offset;
2023       bfd_boolean insns;
2024
2025       addr = section->vma + addr_offset;
2026       addr = ((addr & ((sign_adjust << 1) - 1)) ^ sign_adjust) - sign_adjust;
2027
2028       if (sym != NULL && bfd_asymbol_value (sym) <= addr)
2029         {
2030           int x;
2031
2032           for (x = place;
2033                (x < sorted_symcount
2034                 && (bfd_asymbol_value (sorted_syms[x]) <= addr));
2035                ++x)
2036             continue;
2037
2038           pinfo->symbols = sorted_syms + place;
2039           pinfo->num_symbols = x - place;
2040           pinfo->symtab_pos = place;
2041         }
2042       else
2043         {
2044           pinfo->symbols = NULL;
2045           pinfo->num_symbols = 0;
2046           pinfo->symtab_pos = -1;
2047         }
2048
2049       if (! prefix_addresses)
2050         {
2051           pinfo->fprintf_func (pinfo->stream, "\n");
2052           objdump_print_addr_with_sym (abfd, section, sym, addr,
2053                                        pinfo, FALSE);
2054           pinfo->fprintf_func (pinfo->stream, ":\n");
2055         }
2056
2057       if (sym != NULL && bfd_asymbol_value (sym) > addr)
2058         nextsym = sym;
2059       else if (sym == NULL)
2060         nextsym = NULL;
2061       else
2062         {
2063 #define is_valid_next_sym(SYM) \
2064   ((SYM)->section == section \
2065    && (bfd_asymbol_value (SYM) > bfd_asymbol_value (sym)) \
2066    && pinfo->symbol_is_valid (SYM, pinfo))
2067
2068           /* Search forward for the next appropriate symbol in
2069              SECTION.  Note that all the symbols are sorted
2070              together into one big array, and that some sections
2071              may have overlapping addresses.  */
2072           while (place < sorted_symcount
2073                  && ! is_valid_next_sym (sorted_syms [place]))
2074             ++place;
2075
2076           if (place >= sorted_symcount)
2077             nextsym = NULL;
2078           else
2079             nextsym = sorted_syms[place];
2080         }
2081
2082       if (sym != NULL && bfd_asymbol_value (sym) > addr)
2083         nextstop_offset = bfd_asymbol_value (sym) - section->vma;
2084       else if (nextsym == NULL)
2085         nextstop_offset = stop_offset;
2086       else
2087         nextstop_offset = bfd_asymbol_value (nextsym) - section->vma;
2088
2089       if (nextstop_offset > stop_offset
2090           || nextstop_offset <= addr_offset)
2091         nextstop_offset = stop_offset;
2092
2093       /* If a symbol is explicitly marked as being an object
2094          rather than a function, just dump the bytes without
2095          disassembling them.  */
2096       if (disassemble_all
2097           || sym == NULL
2098           || sym->section != section
2099           || bfd_asymbol_value (sym) > addr
2100           || ((sym->flags & BSF_OBJECT) == 0
2101               && (strstr (bfd_asymbol_name (sym), "gnu_compiled")
2102                   == NULL)
2103               && (strstr (bfd_asymbol_name (sym), "gcc2_compiled")
2104                   == NULL))
2105           || (sym->flags & BSF_FUNCTION) != 0)
2106         insns = TRUE;
2107       else
2108         insns = FALSE;
2109
2110       disassemble_bytes (pinfo, paux->disassemble_fn, insns, data,
2111                          addr_offset, nextstop_offset,
2112                          rel_offset, &rel_pp, rel_ppend);
2113
2114       addr_offset = nextstop_offset;
2115       sym = nextsym;
2116     }
2117
2118   free (data);
2119
2120   if (rel_ppstart != NULL)
2121     free (rel_ppstart);
2122 }
2123
2124 /* Disassemble the contents of an object file.  */
2125
2126 static void
2127 disassemble_data (bfd *abfd)
2128 {
2129   struct disassemble_info disasm_info;
2130   struct objdump_disasm_info aux;
2131   long i;
2132
2133   print_files = NULL;
2134   prev_functionname = NULL;
2135   prev_line = -1;
2136   prev_discriminator = 0;
2137
2138   /* We make a copy of syms to sort.  We don't want to sort syms
2139      because that will screw up the relocs.  */
2140   sorted_symcount = symcount ? symcount : dynsymcount;
2141   sorted_syms = (asymbol **) xmalloc ((sorted_symcount + synthcount)
2142                                       * sizeof (asymbol *));
2143   memcpy (sorted_syms, symcount ? syms : dynsyms,
2144           sorted_symcount * sizeof (asymbol *));
2145
2146   sorted_symcount = remove_useless_symbols (sorted_syms, sorted_symcount);
2147
2148   for (i = 0; i < synthcount; ++i)
2149     {
2150       sorted_syms[sorted_symcount] = synthsyms + i;
2151       ++sorted_symcount;
2152     }
2153
2154   /* Sort the symbols into section and symbol order.  */
2155   qsort (sorted_syms, sorted_symcount, sizeof (asymbol *), compare_symbols);
2156
2157   init_disassemble_info (&disasm_info, stdout, (fprintf_ftype) fprintf);
2158
2159   disasm_info.application_data = (void *) &aux;
2160   aux.abfd = abfd;
2161   aux.require_sec = FALSE;
2162   aux.dynrelbuf = NULL;
2163   aux.dynrelcount = 0;
2164   aux.reloc = NULL;
2165
2166   disasm_info.print_address_func = objdump_print_address;
2167   disasm_info.symbol_at_address_func = objdump_symbol_at_address;
2168
2169   if (machine != NULL)
2170     {
2171       const bfd_arch_info_type *inf = bfd_scan_arch (machine);
2172
2173       if (inf == NULL)
2174         fatal (_("can't use supplied machine %s"), machine);
2175
2176       abfd->arch_info = inf;
2177     }
2178
2179   if (endian != BFD_ENDIAN_UNKNOWN)
2180     {
2181       struct bfd_target *xvec;
2182
2183       xvec = (struct bfd_target *) xmalloc (sizeof (struct bfd_target));
2184       memcpy (xvec, abfd->xvec, sizeof (struct bfd_target));
2185       xvec->byteorder = endian;
2186       abfd->xvec = xvec;
2187     }
2188
2189   /* Use libopcodes to locate a suitable disassembler.  */
2190   aux.disassemble_fn = disassembler (abfd);
2191   if (!aux.disassemble_fn)
2192     {
2193       non_fatal (_("can't disassemble for architecture %s\n"),
2194                  bfd_printable_arch_mach (bfd_get_arch (abfd), 0));
2195       exit_status = 1;
2196       return;
2197     }
2198
2199   disasm_info.flavour = bfd_get_flavour (abfd);
2200   disasm_info.arch = bfd_get_arch (abfd);
2201   disasm_info.mach = bfd_get_mach (abfd);
2202   disasm_info.disassembler_options = disassembler_options;
2203   disasm_info.octets_per_byte = bfd_octets_per_byte (abfd);
2204   disasm_info.skip_zeroes = DEFAULT_SKIP_ZEROES;
2205   disasm_info.skip_zeroes_at_end = DEFAULT_SKIP_ZEROES_AT_END;
2206   disasm_info.disassembler_needs_relocs = FALSE;
2207
2208   if (bfd_big_endian (abfd))
2209     disasm_info.display_endian = disasm_info.endian = BFD_ENDIAN_BIG;
2210   else if (bfd_little_endian (abfd))
2211     disasm_info.display_endian = disasm_info.endian = BFD_ENDIAN_LITTLE;
2212   else
2213     /* ??? Aborting here seems too drastic.  We could default to big or little
2214        instead.  */
2215     disasm_info.endian = BFD_ENDIAN_UNKNOWN;
2216
2217   /* Allow the target to customize the info structure.  */
2218   disassemble_init_for_target (& disasm_info);
2219
2220   /* Pre-load the dynamic relocs if we are going
2221      to be dumping them along with the disassembly.  */
2222   if (dump_dynamic_reloc_info)
2223     {
2224       long relsize = bfd_get_dynamic_reloc_upper_bound (abfd);
2225
2226       if (relsize < 0)
2227         bfd_fatal (bfd_get_filename (abfd));
2228
2229       if (relsize > 0)
2230         {
2231           aux.dynrelbuf = (arelent **) xmalloc (relsize);
2232           aux.dynrelcount = bfd_canonicalize_dynamic_reloc (abfd,
2233                                                             aux.dynrelbuf,
2234                                                             dynsyms);
2235           if (aux.dynrelcount < 0)
2236             bfd_fatal (bfd_get_filename (abfd));
2237
2238           /* Sort the relocs by address.  */
2239           qsort (aux.dynrelbuf, aux.dynrelcount, sizeof (arelent *),
2240                  compare_relocs);
2241         }
2242     }
2243   disasm_info.symtab = sorted_syms;
2244   disasm_info.symtab_size = sorted_symcount;
2245
2246   bfd_map_over_sections (abfd, disassemble_section, & disasm_info);
2247
2248   if (aux.dynrelbuf != NULL)
2249     free (aux.dynrelbuf);
2250   free (sorted_syms);
2251 }
2252 \f
2253 static int
2254 load_specific_debug_section (enum dwarf_section_display_enum debug,
2255                              asection *sec, void *file)
2256 {
2257   struct dwarf_section *section = &debug_displays [debug].section;
2258   bfd *abfd = (bfd *) file;
2259   bfd_boolean ret;
2260
2261   /* If it is already loaded, do nothing.  */
2262   if (section->start != NULL)
2263     return 1;
2264
2265   section->address = bfd_get_section_vma (abfd, sec);
2266   section->size = bfd_get_section_size (sec);
2267   section->start = NULL;
2268   ret = bfd_get_full_section_contents (abfd, sec, &section->start);
2269
2270   if (! ret)
2271     {
2272       free_debug_section (debug);
2273       printf (_("\nCan't get contents for section '%s'.\n"),
2274               section->name);
2275       return 0;
2276     }
2277
2278   if (is_relocatable && debug_displays [debug].relocate)
2279     {
2280       bfd_cache_section_contents (sec, section->start);
2281
2282       ret = bfd_simple_get_relocated_section_contents (abfd,
2283                                                        sec,
2284                                                        section->start,
2285                                                        syms) != NULL;
2286
2287       if (! ret)
2288         {
2289           free_debug_section (debug);
2290           printf (_("\nCan't get contents for section '%s'.\n"),
2291                   section->name);
2292           return 0;
2293         }
2294     }
2295
2296   return 1;
2297 }
2298
2299 int
2300 load_debug_section (enum dwarf_section_display_enum debug, void *file)
2301 {
2302   struct dwarf_section *section = &debug_displays [debug].section;
2303   bfd *abfd = (bfd *) file;
2304   asection *sec;
2305
2306   /* If it is already loaded, do nothing.  */
2307   if (section->start != NULL)
2308     return 1;
2309
2310   /* Locate the debug section.  */
2311   sec = bfd_get_section_by_name (abfd, section->uncompressed_name);
2312   if (sec != NULL)
2313     section->name = section->uncompressed_name;
2314   else
2315     {
2316       sec = bfd_get_section_by_name (abfd, section->compressed_name);
2317       if (sec != NULL)
2318         section->name = section->compressed_name;
2319     }
2320   if (sec == NULL)
2321     return 0;
2322
2323   return load_specific_debug_section (debug, sec, file);
2324 }
2325
2326 void
2327 free_debug_section (enum dwarf_section_display_enum debug)
2328 {
2329   struct dwarf_section *section = &debug_displays [debug].section;
2330
2331   if (section->start == NULL)
2332     return;
2333
2334   free ((char *) section->start);
2335   section->start = NULL;
2336   section->address = 0;
2337   section->size = 0;
2338 }
2339
2340 static void
2341 dump_dwarf_section (bfd *abfd, asection *section,
2342                     void *arg ATTRIBUTE_UNUSED)
2343 {
2344   const char *name = bfd_get_section_name (abfd, section);
2345   const char *match;
2346   int i;
2347
2348   if (CONST_STRNEQ (name, ".gnu.linkonce.wi."))
2349     match = ".debug_info";
2350   else
2351     match = name;
2352
2353   for (i = 0; i < max; i++)
2354     if ((strcmp (debug_displays [i].section.uncompressed_name, match) == 0
2355          || strcmp (debug_displays [i].section.compressed_name, match) == 0)
2356         && debug_displays [i].enabled != NULL
2357         && *debug_displays [i].enabled)
2358       {
2359         struct dwarf_section *sec = &debug_displays [i].section;
2360
2361         if (strcmp (sec->uncompressed_name, match) == 0)
2362           sec->name = sec->uncompressed_name;
2363         else
2364           sec->name = sec->compressed_name;
2365         if (load_specific_debug_section ((enum dwarf_section_display_enum) i,
2366                                          section, abfd))
2367           {
2368             debug_displays [i].display (sec, abfd);
2369
2370             if (i != info && i != abbrev)
2371               free_debug_section ((enum dwarf_section_display_enum) i);
2372           }
2373         break;
2374       }
2375 }
2376
2377 /* Dump the dwarf debugging information.  */
2378
2379 static void
2380 dump_dwarf (bfd *abfd)
2381 {
2382   is_relocatable = (abfd->flags & (EXEC_P | DYNAMIC)) == 0;
2383
2384   eh_addr_size = bfd_arch_bits_per_address (abfd) / 8;
2385
2386   if (bfd_big_endian (abfd))
2387     byte_get = byte_get_big_endian;
2388   else if (bfd_little_endian (abfd))
2389     byte_get = byte_get_little_endian;
2390   else
2391     /* PR 17512: file: objdump-s-endless-loop.tekhex.  */
2392     {
2393       warn (_("File %s does not contain any dwarf debug information\n"),
2394             bfd_get_filename (abfd));
2395       return;
2396     }
2397
2398   switch (bfd_get_arch (abfd))
2399     {
2400     case bfd_arch_i386:
2401       switch (bfd_get_mach (abfd))
2402         {
2403         case bfd_mach_x86_64:
2404         case bfd_mach_x86_64_intel_syntax:
2405         case bfd_mach_x86_64_nacl:
2406         case bfd_mach_x64_32:
2407         case bfd_mach_x64_32_intel_syntax:
2408         case bfd_mach_x64_32_nacl:
2409           init_dwarf_regnames_x86_64 ();
2410           break;
2411
2412         default:
2413           init_dwarf_regnames_i386 ();
2414           break;
2415         }
2416       break;
2417
2418     case bfd_arch_aarch64:
2419       init_dwarf_regnames_aarch64();
2420       break;
2421
2422     default:
2423       break;
2424     }
2425
2426   bfd_map_over_sections (abfd, dump_dwarf_section, NULL);
2427
2428   free_debug_memory ();
2429 }
2430 \f
2431 /* Read ABFD's stabs section STABSECT_NAME, and return a pointer to
2432    it.  Return NULL on failure.   */
2433
2434 static char *
2435 read_section_stabs (bfd *abfd, const char *sect_name, bfd_size_type *size_ptr)
2436 {
2437   asection *stabsect;
2438   bfd_size_type size;
2439   char *contents;
2440
2441   stabsect = bfd_get_section_by_name (abfd, sect_name);
2442   if (stabsect == NULL)
2443     {
2444       printf (_("No %s section present\n\n"), sect_name);
2445       return FALSE;
2446     }
2447
2448   size = bfd_section_size (abfd, stabsect);
2449   contents  = (char *) xmalloc (size);
2450
2451   if (! bfd_get_section_contents (abfd, stabsect, contents, 0, size))
2452     {
2453       non_fatal (_("reading %s section of %s failed: %s"),
2454                  sect_name, bfd_get_filename (abfd),
2455                  bfd_errmsg (bfd_get_error ()));
2456       exit_status = 1;
2457       free (contents);
2458       return NULL;
2459     }
2460
2461   *size_ptr = size;
2462
2463   return contents;
2464 }
2465
2466 /* Stabs entries use a 12 byte format:
2467      4 byte string table index
2468      1 byte stab type
2469      1 byte stab other field
2470      2 byte stab desc field
2471      4 byte stab value
2472    FIXME: This will have to change for a 64 bit object format.  */
2473
2474 #define STRDXOFF  (0)
2475 #define TYPEOFF   (4)
2476 #define OTHEROFF  (5)
2477 #define DESCOFF   (6)
2478 #define VALOFF    (8)
2479 #define STABSIZE (12)
2480
2481 /* Print ABFD's stabs section STABSECT_NAME (in `stabs'),
2482    using string table section STRSECT_NAME (in `strtab').  */
2483
2484 static void
2485 print_section_stabs (bfd *abfd,
2486                      const char *stabsect_name,
2487                      unsigned *string_offset_ptr)
2488 {
2489   int i;
2490   unsigned file_string_table_offset = 0;
2491   unsigned next_file_string_table_offset = *string_offset_ptr;
2492   bfd_byte *stabp, *stabs_end;
2493
2494   stabp = stabs;
2495   stabs_end = stabp + stab_size;
2496
2497   printf (_("Contents of %s section:\n\n"), stabsect_name);
2498   printf ("Symnum n_type n_othr n_desc n_value  n_strx String\n");
2499
2500   /* Loop through all symbols and print them.
2501
2502      We start the index at -1 because there is a dummy symbol on
2503      the front of stabs-in-{coff,elf} sections that supplies sizes.  */
2504   for (i = -1; stabp <= stabs_end - STABSIZE; stabp += STABSIZE, i++)
2505     {
2506       const char *name;
2507       unsigned long strx;
2508       unsigned char type, other;
2509       unsigned short desc;
2510       bfd_vma value;
2511
2512       strx = bfd_h_get_32 (abfd, stabp + STRDXOFF);
2513       type = bfd_h_get_8 (abfd, stabp + TYPEOFF);
2514       other = bfd_h_get_8 (abfd, stabp + OTHEROFF);
2515       desc = bfd_h_get_16 (abfd, stabp + DESCOFF);
2516       value = bfd_h_get_32 (abfd, stabp + VALOFF);
2517
2518       printf ("\n%-6d ", i);
2519       /* Either print the stab name, or, if unnamed, print its number
2520          again (makes consistent formatting for tools like awk).  */
2521       name = bfd_get_stab_name (type);
2522       if (name != NULL)
2523         printf ("%-6s", name);
2524       else if (type == N_UNDF)
2525         printf ("HdrSym");
2526       else
2527         printf ("%-6d", type);
2528       printf (" %-6d %-6d ", other, desc);
2529       bfd_printf_vma (abfd, value);
2530       printf (" %-6lu", strx);
2531
2532       /* Symbols with type == 0 (N_UNDF) specify the length of the
2533          string table associated with this file.  We use that info
2534          to know how to relocate the *next* file's string table indices.  */
2535       if (type == N_UNDF)
2536         {
2537           file_string_table_offset = next_file_string_table_offset;
2538           next_file_string_table_offset += value;
2539         }
2540       else
2541         {
2542           bfd_size_type amt = strx + file_string_table_offset;
2543
2544           /* Using the (possibly updated) string table offset, print the
2545              string (if any) associated with this symbol.  */
2546           if (amt < stabstr_size)
2547             /* PR 17512: file: 079-79389-0.001:0.1.  */
2548             printf (" %.*s", (int)(stabstr_size - amt), strtab + amt);
2549           else
2550             printf (" *");
2551         }
2552     }
2553   printf ("\n\n");
2554   *string_offset_ptr = next_file_string_table_offset;
2555 }
2556
2557 typedef struct
2558 {
2559   const char * section_name;
2560   const char * string_section_name;
2561   unsigned string_offset;
2562 }
2563 stab_section_names;
2564
2565 static void
2566 find_stabs_section (bfd *abfd, asection *section, void *names)
2567 {
2568   int len;
2569   stab_section_names * sought = (stab_section_names *) names;
2570
2571   /* Check for section names for which stabsect_name is a prefix, to
2572      handle .stab.N, etc.  */
2573   len = strlen (sought->section_name);
2574
2575   /* If the prefix matches, and the files section name ends with a
2576      nul or a digit, then we match.  I.e., we want either an exact
2577      match or a section followed by a number.  */
2578   if (strncmp (sought->section_name, section->name, len) == 0
2579       && (section->name[len] == 0
2580           || (section->name[len] == '.' && ISDIGIT (section->name[len + 1]))))
2581     {
2582       if (strtab == NULL)
2583         strtab = read_section_stabs (abfd, sought->string_section_name,
2584                                      &stabstr_size);
2585
2586       if (strtab)
2587         {
2588           stabs = (bfd_byte *) read_section_stabs (abfd, section->name,
2589                                                    &stab_size);
2590           if (stabs)
2591             print_section_stabs (abfd, section->name, &sought->string_offset);
2592         }
2593     }
2594 }
2595
2596 static void
2597 dump_stabs_section (bfd *abfd, char *stabsect_name, char *strsect_name)
2598 {
2599   stab_section_names s;
2600
2601   s.section_name = stabsect_name;
2602   s.string_section_name = strsect_name;
2603   s.string_offset = 0;
2604
2605   bfd_map_over_sections (abfd, find_stabs_section, & s);
2606
2607   free (strtab);
2608   strtab = NULL;
2609 }
2610
2611 /* Dump the any sections containing stabs debugging information.  */
2612
2613 static void
2614 dump_stabs (bfd *abfd)
2615 {
2616   dump_stabs_section (abfd, ".stab", ".stabstr");
2617   dump_stabs_section (abfd, ".stab.excl", ".stab.exclstr");
2618   dump_stabs_section (abfd, ".stab.index", ".stab.indexstr");
2619
2620   /* For Darwin.  */
2621   dump_stabs_section (abfd, "LC_SYMTAB.stabs", "LC_SYMTAB.stabstr");
2622
2623   dump_stabs_section (abfd, "$GDB_SYMBOLS$", "$GDB_STRINGS$");
2624 }
2625 \f
2626 static void
2627 dump_bfd_header (bfd *abfd)
2628 {
2629   char *comma = "";
2630
2631   printf (_("architecture: %s, "),
2632           bfd_printable_arch_mach (bfd_get_arch (abfd),
2633                                    bfd_get_mach (abfd)));
2634   printf (_("flags 0x%08x:\n"), abfd->flags & ~BFD_FLAGS_FOR_BFD_USE_MASK);
2635
2636 #define PF(x, y)    if (abfd->flags & x) {printf("%s%s", comma, y); comma=", ";}
2637   PF (HAS_RELOC, "HAS_RELOC");
2638   PF (EXEC_P, "EXEC_P");
2639   PF (HAS_LINENO, "HAS_LINENO");
2640   PF (HAS_DEBUG, "HAS_DEBUG");
2641   PF (HAS_SYMS, "HAS_SYMS");
2642   PF (HAS_LOCALS, "HAS_LOCALS");
2643   PF (DYNAMIC, "DYNAMIC");
2644   PF (WP_TEXT, "WP_TEXT");
2645   PF (D_PAGED, "D_PAGED");
2646   PF (BFD_IS_RELAXABLE, "BFD_IS_RELAXABLE");
2647   printf (_("\nstart address 0x"));
2648   bfd_printf_vma (abfd, abfd->start_address);
2649   printf ("\n");
2650 }
2651
2652 \f
2653 static void
2654 dump_bfd_private_header (bfd *abfd)
2655 {
2656   bfd_print_private_bfd_data (abfd, stdout);
2657 }
2658
2659 static void
2660 dump_target_specific (bfd *abfd)
2661 {
2662   const struct objdump_private_desc * const *desc;
2663   struct objdump_private_option *opt;
2664   char *e, *b;
2665
2666   /* Find the desc.  */
2667   for (desc = objdump_private_vectors; *desc != NULL; desc++)
2668     if ((*desc)->filter (abfd))
2669       break;
2670
2671   if (*desc == NULL)
2672     {
2673       non_fatal (_("option -P/--private not supported by this file"));
2674       return;
2675     }
2676
2677   /* Clear all options.  */
2678   for (opt = (*desc)->options; opt->name; opt++)
2679     opt->selected = FALSE;
2680
2681   /* Decode options.  */
2682   b = dump_private_options;
2683   do
2684     {
2685       e = strchr (b, ',');
2686
2687       if (e)
2688         *e = 0;
2689
2690       for (opt = (*desc)->options; opt->name; opt++)
2691         if (strcmp (opt->name, b) == 0)
2692           {
2693             opt->selected = TRUE;
2694             break;
2695           }
2696       if (opt->name == NULL)
2697         non_fatal (_("target specific dump '%s' not supported"), b);
2698
2699       if (e)
2700         {
2701           *e = ',';
2702           b = e + 1;
2703         }
2704     }
2705   while (e != NULL);
2706
2707   /* Dump.  */
2708   (*desc)->dump (abfd);
2709 }
2710 \f
2711 /* Display a section in hexadecimal format with associated characters.
2712    Each line prefixed by the zero padded address.  */
2713
2714 static void
2715 dump_section (bfd *abfd, asection *section, void *dummy ATTRIBUTE_UNUSED)
2716 {
2717   bfd_byte *data = 0;
2718   bfd_size_type datasize;
2719   bfd_size_type addr_offset;
2720   bfd_size_type start_offset;
2721   bfd_size_type stop_offset;
2722   unsigned int opb = bfd_octets_per_byte (abfd);
2723   /* Bytes per line.  */
2724   const int onaline = 16;
2725   char buf[64];
2726   int count;
2727   int width;
2728
2729   if ((section->flags & SEC_HAS_CONTENTS) == 0)
2730     return;
2731
2732   if (! process_section_p (section))
2733     return;
2734
2735   if ((datasize = bfd_section_size (abfd, section)) == 0)
2736     return;
2737
2738   /* Compute the address range to display.  */
2739   if (start_address == (bfd_vma) -1
2740       || start_address < section->vma)
2741     start_offset = 0;
2742   else
2743     start_offset = start_address - section->vma;
2744
2745   if (stop_address == (bfd_vma) -1)
2746     stop_offset = datasize / opb;
2747   else
2748     {
2749       if (stop_address < section->vma)
2750         stop_offset = 0;
2751       else
2752         stop_offset = stop_address - section->vma;
2753
2754       if (stop_offset > datasize / opb)
2755         stop_offset = datasize / opb;
2756     }
2757
2758   if (start_offset >= stop_offset)
2759     return;
2760
2761   printf (_("Contents of section %s:"), section->name);
2762   if (display_file_offsets)
2763     printf (_("  (Starting at file offset: 0x%lx)"),
2764             (unsigned long) (section->filepos + start_offset));
2765   printf ("\n");
2766
2767   if (!bfd_get_full_section_contents (abfd, section, &data))
2768     {
2769       non_fatal (_("Reading section failed"));
2770       return;
2771     }
2772
2773   width = 4;
2774
2775   bfd_sprintf_vma (abfd, buf, start_offset + section->vma);
2776   if (strlen (buf) >= sizeof (buf))
2777     abort ();
2778
2779   count = 0;
2780   while (buf[count] == '0' && buf[count+1] != '\0')
2781     count++;
2782   count = strlen (buf) - count;
2783   if (count > width)
2784     width = count;
2785
2786   bfd_sprintf_vma (abfd, buf, stop_offset + section->vma - 1);
2787   if (strlen (buf) >= sizeof (buf))
2788     abort ();
2789
2790   count = 0;
2791   while (buf[count] == '0' && buf[count+1] != '\0')
2792     count++;
2793   count = strlen (buf) - count;
2794   if (count > width)
2795     width = count;
2796
2797   for (addr_offset = start_offset;
2798        addr_offset < stop_offset; addr_offset += onaline / opb)
2799     {
2800       bfd_size_type j;
2801
2802       bfd_sprintf_vma (abfd, buf, (addr_offset + section->vma));
2803       count = strlen (buf);
2804       if ((size_t) count >= sizeof (buf))
2805         abort ();
2806
2807       putchar (' ');
2808       while (count < width)
2809         {
2810           putchar ('0');
2811           count++;
2812         }
2813       fputs (buf + count - width, stdout);
2814       putchar (' ');
2815
2816       for (j = addr_offset * opb;
2817            j < addr_offset * opb + onaline; j++)
2818         {
2819           if (j < stop_offset * opb)
2820             printf ("%02x", (unsigned) (data[j]));
2821           else
2822             printf ("  ");
2823           if ((j & 3) == 3)
2824             printf (" ");
2825         }
2826
2827       printf (" ");
2828       for (j = addr_offset * opb;
2829            j < addr_offset * opb + onaline; j++)
2830         {
2831           if (j >= stop_offset * opb)
2832             printf (" ");
2833           else
2834             printf ("%c", ISPRINT (data[j]) ? data[j] : '.');
2835         }
2836       putchar ('\n');
2837     }
2838   free (data);
2839 }
2840
2841 /* Actually display the various requested regions.  */
2842
2843 static void
2844 dump_data (bfd *abfd)
2845 {
2846   bfd_map_over_sections (abfd, dump_section, NULL);
2847 }
2848
2849 /* Should perhaps share code and display with nm?  */
2850
2851 static void
2852 dump_symbols (bfd *abfd ATTRIBUTE_UNUSED, bfd_boolean dynamic)
2853 {
2854   asymbol **current;
2855   long max_count;
2856   long count;
2857
2858   if (dynamic)
2859     {
2860       current = dynsyms;
2861       max_count = dynsymcount;
2862       printf ("DYNAMIC SYMBOL TABLE:\n");
2863     }
2864   else
2865     {
2866       current = syms;
2867       max_count = symcount;
2868       printf ("SYMBOL TABLE:\n");
2869     }
2870
2871   if (max_count == 0)
2872     printf (_("no symbols\n"));
2873
2874   for (count = 0; count < max_count; count++)
2875     {
2876       bfd *cur_bfd;
2877
2878       if (*current == NULL)
2879         printf (_("no information for symbol number %ld\n"), count);
2880
2881       else if ((cur_bfd = bfd_asymbol_bfd (*current)) == NULL)
2882         printf (_("could not determine the type of symbol number %ld\n"),
2883                 count);
2884
2885       else if (process_section_p ((* current)->section)
2886                && (dump_special_syms
2887                    || !bfd_is_target_special_symbol (cur_bfd, *current)))
2888         {
2889           const char *name = (*current)->name;
2890
2891           if (do_demangle && name != NULL && *name != '\0')
2892             {
2893               char *alloc;
2894
2895               /* If we want to demangle the name, we demangle it
2896                  here, and temporarily clobber it while calling
2897                  bfd_print_symbol.  FIXME: This is a gross hack.  */
2898               alloc = bfd_demangle (cur_bfd, name, DMGL_ANSI | DMGL_PARAMS);
2899               if (alloc != NULL)
2900                 (*current)->name = alloc;
2901               bfd_print_symbol (cur_bfd, stdout, *current,
2902                                 bfd_print_symbol_all);
2903               if (alloc != NULL)
2904                 {
2905                   (*current)->name = name;
2906                   free (alloc);
2907                 }
2908             }
2909           else
2910             bfd_print_symbol (cur_bfd, stdout, *current,
2911                               bfd_print_symbol_all);
2912           printf ("\n");
2913         }
2914
2915       current++;
2916     }
2917   printf ("\n\n");
2918 }
2919 \f
2920 static void
2921 dump_reloc_set (bfd *abfd, asection *sec, arelent **relpp, long relcount)
2922 {
2923   arelent **p;
2924   char *last_filename, *last_functionname;
2925   unsigned int last_line;
2926   unsigned int last_discriminator;
2927
2928   /* Get column headers lined up reasonably.  */
2929   {
2930     static int width;
2931
2932     if (width == 0)
2933       {
2934         char buf[30];
2935
2936         bfd_sprintf_vma (abfd, buf, (bfd_vma) -1);
2937         width = strlen (buf) - 7;
2938       }
2939     printf ("OFFSET %*s TYPE %*s VALUE \n", width, "", 12, "");
2940   }
2941
2942   last_filename = NULL;
2943   last_functionname = NULL;
2944   last_line = 0;
2945   last_discriminator = 0;
2946
2947   for (p = relpp; relcount && *p != NULL; p++, relcount--)
2948     {
2949       arelent *q = *p;
2950       const char *filename, *functionname;
2951       unsigned int linenumber;
2952       unsigned int discriminator;
2953       const char *sym_name;
2954       const char *section_name;
2955       bfd_vma addend2 = 0;
2956
2957       if (start_address != (bfd_vma) -1
2958           && q->address < start_address)
2959         continue;
2960       if (stop_address != (bfd_vma) -1
2961           && q->address > stop_address)
2962         continue;
2963
2964       if (with_line_numbers
2965           && sec != NULL
2966           && bfd_find_nearest_line_discriminator (abfd, sec, syms, q->address,
2967                                                   &filename, &functionname,
2968                                                   &linenumber, &discriminator))
2969         {
2970           if (functionname != NULL
2971               && (last_functionname == NULL
2972                   || strcmp (functionname, last_functionname) != 0))
2973             {
2974               printf ("%s():\n", functionname);
2975               if (last_functionname != NULL)
2976                 free (last_functionname);
2977               last_functionname = xstrdup (functionname);
2978             }
2979
2980           if (linenumber > 0
2981               && (linenumber != last_line
2982                   || (filename != NULL
2983                       && last_filename != NULL
2984                       && filename_cmp (filename, last_filename) != 0)
2985                   || (discriminator != last_discriminator)))
2986             {
2987               if (discriminator > 0)
2988                 printf ("%s:%u\n", filename == NULL ? "???" : filename, linenumber);
2989               else
2990                 printf ("%s:%u (discriminator %u)\n", filename == NULL ? "???" : filename,
2991                         linenumber, discriminator);
2992               last_line = linenumber;
2993               last_discriminator = discriminator;
2994               if (last_filename != NULL)
2995                 free (last_filename);
2996               if (filename == NULL)
2997                 last_filename = NULL;
2998               else
2999                 last_filename = xstrdup (filename);
3000             }
3001         }
3002
3003       if (q->sym_ptr_ptr && *q->sym_ptr_ptr)
3004         {
3005           sym_name = (*(q->sym_ptr_ptr))->name;
3006           section_name = (*(q->sym_ptr_ptr))->section->name;
3007         }
3008       else
3009         {
3010           sym_name = NULL;
3011           section_name = NULL;
3012         }
3013
3014       bfd_printf_vma (abfd, q->address);
3015       if (q->howto == NULL)
3016         printf (" *unknown*         ");
3017       else if (q->howto->name)
3018         {
3019           const char *name = q->howto->name;
3020
3021           /* R_SPARC_OLO10 relocations contain two addends.
3022              But because 'arelent' lacks enough storage to
3023              store them both, the 64-bit ELF Sparc backend
3024              records this as two relocations.  One R_SPARC_LO10
3025              and one R_SPARC_13, both pointing to the same
3026              address.  This is merely so that we have some
3027              place to store both addend fields.
3028
3029              Undo this transformation, otherwise the output
3030              will be confusing.  */
3031           if (abfd->xvec->flavour == bfd_target_elf_flavour
3032               && elf_tdata(abfd)->elf_header->e_machine == EM_SPARCV9
3033               && relcount > 1
3034               && !strcmp (q->howto->name, "R_SPARC_LO10"))
3035             {
3036               arelent *q2 = *(p + 1);
3037               if (q2 != NULL
3038                   && q2->howto
3039                   && q->address == q2->address
3040                   && !strcmp (q2->howto->name, "R_SPARC_13"))
3041                 {
3042                   name = "R_SPARC_OLO10";
3043                   addend2 = q2->addend;
3044                   p++;
3045                 }
3046             }
3047           printf (" %-16s  ", name);
3048         }
3049       else
3050         printf (" %-16d  ", q->howto->type);
3051
3052       if (sym_name)
3053         {
3054           objdump_print_symname (abfd, NULL, *q->sym_ptr_ptr);
3055         }
3056       else
3057         {
3058           if (section_name == NULL)
3059             section_name = "*unknown*";
3060           printf ("[%s]", section_name);
3061         }
3062
3063       if (q->addend)
3064         {
3065           bfd_signed_vma addend = q->addend;
3066           if (addend < 0)
3067             {
3068               printf ("-0x");
3069               addend = -addend;
3070             }
3071           else
3072             printf ("+0x");
3073           bfd_printf_vma (abfd, addend);
3074         }
3075       if (addend2)
3076         {
3077           printf ("+0x");
3078           bfd_printf_vma (abfd, addend2);
3079         }
3080
3081       printf ("\n");
3082     }
3083
3084   if (last_filename != NULL)
3085     free (last_filename);
3086   if (last_functionname != NULL)
3087     free (last_functionname);
3088 }
3089
3090 static void
3091 dump_relocs_in_section (bfd *abfd,
3092                         asection *section,
3093                         void *dummy ATTRIBUTE_UNUSED)
3094 {
3095   arelent **relpp;
3096   long relcount;
3097   long relsize;
3098
3099   if (   bfd_is_abs_section (section)
3100       || bfd_is_und_section (section)
3101       || bfd_is_com_section (section)
3102       || (! process_section_p (section))
3103       || ((section->flags & SEC_RELOC) == 0))
3104     return;
3105
3106   relsize = bfd_get_reloc_upper_bound (abfd, section);
3107   if (relsize < 0)
3108     bfd_fatal (bfd_get_filename (abfd));
3109
3110   printf ("RELOCATION RECORDS FOR [%s]:", section->name);
3111
3112   if (relsize == 0)
3113     {
3114       printf (" (none)\n\n");
3115       return;
3116     }
3117
3118   relpp = (arelent **) xmalloc (relsize);
3119   relcount = bfd_canonicalize_reloc (abfd, section, relpp, syms);
3120
3121   if (relcount < 0)
3122     {
3123       printf ("\n");
3124       non_fatal (_("failed to read relocs in: %s"), bfd_get_filename (abfd));
3125       bfd_fatal (_("error message was"));
3126     }
3127   else if (relcount == 0)
3128     printf (" (none)\n\n");
3129   else
3130     {
3131       printf ("\n");
3132       dump_reloc_set (abfd, section, relpp, relcount);
3133       printf ("\n\n");
3134     }
3135   free (relpp);
3136 }
3137
3138 static void
3139 dump_relocs (bfd *abfd)
3140 {
3141   bfd_map_over_sections (abfd, dump_relocs_in_section, NULL);
3142 }
3143
3144 static void
3145 dump_dynamic_relocs (bfd *abfd)
3146 {
3147   long relsize;
3148   arelent **relpp;
3149   long relcount;
3150
3151   relsize = bfd_get_dynamic_reloc_upper_bound (abfd);
3152   if (relsize < 0)
3153     bfd_fatal (bfd_get_filename (abfd));
3154
3155   printf ("DYNAMIC RELOCATION RECORDS");
3156
3157   if (relsize == 0)
3158     printf (" (none)\n\n");
3159   else
3160     {
3161       relpp = (arelent **) xmalloc (relsize);
3162       relcount = bfd_canonicalize_dynamic_reloc (abfd, relpp, dynsyms);
3163
3164       if (relcount < 0)
3165         bfd_fatal (bfd_get_filename (abfd));
3166       else if (relcount == 0)
3167         printf (" (none)\n\n");
3168       else
3169         {
3170           printf ("\n");
3171           dump_reloc_set (abfd, NULL, relpp, relcount);
3172           printf ("\n\n");
3173         }
3174       free (relpp);
3175     }
3176 }
3177
3178 /* Creates a table of paths, to search for source files.  */
3179
3180 static void
3181 add_include_path (const char *path)
3182 {
3183   if (path[0] == 0)
3184     return;
3185   include_path_count++;
3186   include_paths = (const char **)
3187       xrealloc (include_paths, include_path_count * sizeof (*include_paths));
3188 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
3189   if (path[1] == ':' && path[2] == 0)
3190     path = concat (path, ".", (const char *) 0);
3191 #endif
3192   include_paths[include_path_count - 1] = path;
3193 }
3194
3195 static void
3196 adjust_addresses (bfd *abfd ATTRIBUTE_UNUSED,
3197                   asection *section,
3198                   void *arg)
3199 {
3200   if ((section->flags & SEC_DEBUGGING) == 0)
3201     {
3202       bfd_boolean *has_reloc_p = (bfd_boolean *) arg;
3203       section->vma += adjust_section_vma;
3204       if (*has_reloc_p)
3205         section->lma += adjust_section_vma;
3206     }
3207 }
3208
3209 /* Dump selected contents of ABFD.  */
3210
3211 static void
3212 dump_bfd (bfd *abfd)
3213 {
3214   /* If we are adjusting section VMA's, change them all now.  Changing
3215      the BFD information is a hack.  However, we must do it, or
3216      bfd_find_nearest_line will not do the right thing.  */
3217   if (adjust_section_vma != 0)
3218     {
3219       bfd_boolean has_reloc = (abfd->flags & HAS_RELOC);
3220       bfd_map_over_sections (abfd, adjust_addresses, &has_reloc);
3221     }
3222
3223   if (! dump_debugging_tags && ! suppress_bfd_header)
3224     printf (_("\n%s:     file format %s\n"), bfd_get_filename (abfd),
3225             abfd->xvec->name);
3226   if (dump_ar_hdrs)
3227     print_arelt_descr (stdout, abfd, TRUE);
3228   if (dump_file_header)
3229     dump_bfd_header (abfd);
3230   if (dump_private_headers)
3231     dump_bfd_private_header (abfd);
3232   if (dump_private_options != NULL)
3233     dump_target_specific (abfd);
3234   if (! dump_debugging_tags && ! suppress_bfd_header)
3235     putchar ('\n');
3236
3237   if (dump_symtab
3238       || dump_reloc_info
3239       || disassemble
3240       || dump_debugging
3241       || dump_dwarf_section_info)
3242     syms = slurp_symtab (abfd);
3243
3244   if (dump_section_headers)
3245     dump_headers (abfd);
3246
3247   if (dump_dynamic_symtab || dump_dynamic_reloc_info
3248       || (disassemble && bfd_get_dynamic_symtab_upper_bound (abfd) > 0))
3249     dynsyms = slurp_dynamic_symtab (abfd);
3250   if (disassemble)
3251     {
3252       synthcount = bfd_get_synthetic_symtab (abfd, symcount, syms,
3253                                              dynsymcount, dynsyms, &synthsyms);
3254       if (synthcount < 0)
3255         synthcount = 0;
3256     }
3257
3258   if (dump_symtab)
3259     dump_symbols (abfd, FALSE);
3260   if (dump_dynamic_symtab)
3261     dump_symbols (abfd, TRUE);
3262   if (dump_dwarf_section_info)
3263     dump_dwarf (abfd);
3264   if (dump_stab_section_info)
3265     dump_stabs (abfd);
3266   if (dump_reloc_info && ! disassemble)
3267     dump_relocs (abfd);
3268   if (dump_dynamic_reloc_info && ! disassemble)
3269     dump_dynamic_relocs (abfd);
3270   if (dump_section_contents)
3271     dump_data (abfd);
3272   if (disassemble)
3273     disassemble_data (abfd);
3274
3275   if (dump_debugging)
3276     {
3277       void *dhandle;
3278
3279       dhandle = read_debugging_info (abfd, syms, symcount, TRUE);
3280       if (dhandle != NULL)
3281         {
3282           if (!print_debugging_info (stdout, dhandle, abfd, syms,
3283                                      bfd_demangle,
3284                                      dump_debugging_tags ? TRUE : FALSE))
3285             {
3286               non_fatal (_("%s: printing debugging information failed"),
3287                          bfd_get_filename (abfd));
3288               exit_status = 1;
3289             }
3290         }
3291       /* PR 6483: If there was no STABS or IEEE debug
3292          info in the file, try DWARF instead.  */
3293       else if (! dump_dwarf_section_info)
3294         {
3295           dwarf_select_sections_all ();
3296           dump_dwarf (abfd);
3297         }
3298     }
3299
3300   if (syms)
3301     {
3302       free (syms);
3303       syms = NULL;
3304     }
3305
3306   if (dynsyms)
3307     {
3308       free (dynsyms);
3309       dynsyms = NULL;
3310     }
3311
3312   if (synthsyms)
3313     {
3314       free (synthsyms);
3315       synthsyms = NULL;
3316     }
3317
3318   symcount = 0;
3319   dynsymcount = 0;
3320   synthcount = 0;
3321 }
3322
3323 static void
3324 display_object_bfd (bfd *abfd)
3325 {
3326   char **matching;
3327
3328   if (bfd_check_format_matches (abfd, bfd_object, &matching))
3329     {
3330       dump_bfd (abfd);
3331       return;
3332     }
3333
3334   if (bfd_get_error () == bfd_error_file_ambiguously_recognized)
3335     {
3336       nonfatal (bfd_get_filename (abfd));
3337       list_matching_formats (matching);
3338       free (matching);
3339       return;
3340     }
3341
3342   if (bfd_get_error () != bfd_error_file_not_recognized)
3343     {
3344       nonfatal (bfd_get_filename (abfd));
3345       return;
3346     }
3347
3348   if (bfd_check_format_matches (abfd, bfd_core, &matching))
3349     {
3350       dump_bfd (abfd);
3351       return;
3352     }
3353
3354   nonfatal (bfd_get_filename (abfd));
3355
3356   if (bfd_get_error () == bfd_error_file_ambiguously_recognized)
3357     {
3358       list_matching_formats (matching);
3359       free (matching);
3360     }
3361 }
3362
3363 static void
3364 display_any_bfd (bfd *file, int level)
3365 {
3366   /* Decompress sections unless dumping the section contents.  */
3367   if (!dump_section_contents)
3368     file->flags |= BFD_DECOMPRESS;
3369
3370   /* If the file is an archive, process all of its elements.  */
3371   if (bfd_check_format (file, bfd_archive))
3372     {
3373       bfd *arfile = NULL;
3374       bfd *last_arfile = NULL;
3375
3376       if (level == 0)
3377         printf (_("In archive %s:\n"), bfd_get_filename (file));
3378       else
3379         printf (_("In nested archive %s:\n"), bfd_get_filename (file));
3380
3381       for (;;)
3382         {
3383           bfd_set_error (bfd_error_no_error);
3384
3385           arfile = bfd_openr_next_archived_file (file, arfile);
3386           if (arfile == NULL)
3387             {
3388               if (bfd_get_error () != bfd_error_no_more_archived_files)
3389                 nonfatal (bfd_get_filename (file));
3390               break;
3391             }
3392
3393           display_any_bfd (arfile, level + 1);
3394
3395           if (last_arfile != NULL)
3396             bfd_close (last_arfile);
3397           last_arfile = arfile;
3398         }
3399
3400       if (last_arfile != NULL)
3401         bfd_close (last_arfile);
3402     }
3403   else
3404     display_object_bfd (file);
3405 }
3406
3407 static void
3408 display_file (char *filename, char *target)
3409 {
3410   bfd *file;
3411
3412   if (get_file_size (filename) < 1)
3413     {
3414       exit_status = 1;
3415       return;
3416     }
3417
3418   file = bfd_openr (filename, target);
3419   if (file == NULL)
3420     {
3421       nonfatal (filename);
3422       return;
3423     }
3424
3425   display_any_bfd (file, 0);
3426
3427   bfd_close (file);
3428 }
3429 \f
3430 int
3431 main (int argc, char **argv)
3432 {
3433   int c;
3434   char *target = default_target;
3435   bfd_boolean seenflag = FALSE;
3436
3437 #if defined (HAVE_SETLOCALE)
3438 #if defined (HAVE_LC_MESSAGES)
3439   setlocale (LC_MESSAGES, "");
3440 #endif
3441   setlocale (LC_CTYPE, "");
3442 #endif
3443
3444   bindtextdomain (PACKAGE, LOCALEDIR);
3445   textdomain (PACKAGE);
3446
3447   program_name = *argv;
3448   xmalloc_set_program_name (program_name);
3449
3450   START_PROGRESS (program_name, 0);
3451
3452   expandargv (&argc, &argv);
3453
3454   bfd_init ();
3455   set_default_bfd_target ();
3456
3457   while ((c = getopt_long (argc, argv,
3458                            "pP:ib:m:M:VvCdDlfFaHhrRtTxsSI:j:wE:zgeGW::",
3459                            long_options, (int *) 0))
3460          != EOF)
3461     {
3462       switch (c)
3463         {
3464         case 0:
3465           break;                /* We've been given a long option.  */
3466         case 'm':
3467           machine = optarg;
3468           break;
3469         case 'M':
3470           if (disassembler_options)
3471             /* Ignore potential memory leak for now.  */
3472             disassembler_options = concat (disassembler_options, ",",
3473                                            optarg, (const char *) NULL);
3474           else
3475             disassembler_options = optarg;
3476           break;
3477         case 'j':
3478           add_only (optarg);
3479           break;
3480         case 'F':
3481           display_file_offsets = TRUE;
3482           break;
3483         case 'l':
3484           with_line_numbers = TRUE;
3485           break;
3486         case 'b':
3487           target = optarg;
3488           break;
3489         case 'C':
3490           do_demangle = TRUE;
3491           if (optarg != NULL)
3492             {
3493               enum demangling_styles style;
3494
3495               style = cplus_demangle_name_to_style (optarg);
3496               if (style == unknown_demangling)
3497                 fatal (_("unknown demangling style `%s'"),
3498                        optarg);
3499
3500               cplus_demangle_set_style (style);
3501             }
3502           break;
3503         case 'w':
3504           wide_output = TRUE;
3505           break;
3506         case OPTION_ADJUST_VMA:
3507           adjust_section_vma = parse_vma (optarg, "--adjust-vma");
3508           break;
3509         case OPTION_START_ADDRESS:
3510           start_address = parse_vma (optarg, "--start-address");
3511           if ((stop_address != (bfd_vma) -1) && stop_address <= start_address)
3512             fatal (_("error: the start address should be before the end address"));
3513           break;
3514         case OPTION_STOP_ADDRESS:
3515           stop_address = parse_vma (optarg, "--stop-address");
3516           if ((start_address != (bfd_vma) -1) && stop_address <= start_address)
3517             fatal (_("error: the stop address should be after the start address"));
3518           break;
3519         case OPTION_PREFIX:
3520           prefix = optarg;
3521           prefix_length = strlen (prefix);
3522           /* Remove an unnecessary trailing '/' */
3523           while (IS_DIR_SEPARATOR (prefix[prefix_length - 1]))
3524             prefix_length--;
3525           break;
3526         case OPTION_PREFIX_STRIP:
3527           prefix_strip = atoi (optarg);
3528           if (prefix_strip < 0)
3529             fatal (_("error: prefix strip must be non-negative"));
3530           break;
3531         case OPTION_INSN_WIDTH:
3532           insn_width = strtoul (optarg, NULL, 0);
3533           if (insn_width <= 0)
3534             fatal (_("error: instruction width must be positive"));
3535           break;
3536         case 'E':
3537           if (strcmp (optarg, "B") == 0)
3538             endian = BFD_ENDIAN_BIG;
3539           else if (strcmp (optarg, "L") == 0)
3540             endian = BFD_ENDIAN_LITTLE;
3541           else
3542             {
3543               nonfatal (_("unrecognized -E option"));
3544               usage (stderr, 1);
3545             }
3546           break;
3547         case OPTION_ENDIAN:
3548           if (strncmp (optarg, "big", strlen (optarg)) == 0)
3549             endian = BFD_ENDIAN_BIG;
3550           else if (strncmp (optarg, "little", strlen (optarg)) == 0)
3551             endian = BFD_ENDIAN_LITTLE;
3552           else
3553             {
3554               non_fatal (_("unrecognized --endian type `%s'"), optarg);
3555               exit_status = 1;
3556               usage (stderr, 1);
3557             }
3558           break;
3559
3560         case 'f':
3561           dump_file_header = TRUE;
3562           seenflag = TRUE;
3563           break;
3564         case 'i':
3565           formats_info = TRUE;
3566           seenflag = TRUE;
3567           break;
3568         case 'I':
3569           add_include_path (optarg);
3570           break;
3571         case 'p':
3572           dump_private_headers = TRUE;
3573           seenflag = TRUE;
3574           break;
3575         case 'P':
3576           dump_private_options = optarg;
3577           seenflag = TRUE;
3578           break;
3579         case 'x':
3580           dump_private_headers = TRUE;
3581           dump_symtab = TRUE;
3582           dump_reloc_info = TRUE;
3583           dump_file_header = TRUE;
3584           dump_ar_hdrs = TRUE;
3585           dump_section_headers = TRUE;
3586           seenflag = TRUE;
3587           break;
3588         case 't':
3589           dump_symtab = TRUE;
3590           seenflag = TRUE;
3591           break;
3592         case 'T':
3593           dump_dynamic_symtab = TRUE;
3594           seenflag = TRUE;
3595           break;
3596         case 'd':
3597           disassemble = TRUE;
3598           seenflag = TRUE;
3599           break;
3600         case 'z':
3601           disassemble_zeroes = TRUE;
3602           break;
3603         case 'D':
3604           disassemble = TRUE;
3605           disassemble_all = TRUE;
3606           seenflag = TRUE;
3607           break;
3608         case 'S':
3609           disassemble = TRUE;
3610           with_source_code = TRUE;
3611           seenflag = TRUE;
3612           break;
3613         case 'g':
3614           dump_debugging = 1;
3615           seenflag = TRUE;
3616           break;
3617         case 'e':
3618           dump_debugging = 1;
3619           dump_debugging_tags = 1;
3620           do_demangle = TRUE;
3621           seenflag = TRUE;
3622           break;
3623         case 'W':
3624           dump_dwarf_section_info = TRUE;
3625           seenflag = TRUE;
3626           if (optarg)
3627             dwarf_select_sections_by_letters (optarg);
3628           else
3629             dwarf_select_sections_all ();
3630           break;
3631         case OPTION_DWARF:
3632           dump_dwarf_section_info = TRUE;
3633           seenflag = TRUE;
3634           if (optarg)
3635             dwarf_select_sections_by_names (optarg);
3636           else
3637             dwarf_select_sections_all ();
3638           break;
3639         case OPTION_DWARF_DEPTH:
3640           {
3641             char *cp;
3642             dwarf_cutoff_level = strtoul (optarg, & cp, 0);
3643           }
3644           break;
3645         case OPTION_DWARF_START:
3646           {
3647             char *cp;
3648             dwarf_start_die = strtoul (optarg, & cp, 0);
3649             suppress_bfd_header = 1;
3650           }
3651           break;
3652         case OPTION_DWARF_CHECK:
3653           dwarf_check = TRUE;
3654           break;
3655         case 'G':
3656           dump_stab_section_info = TRUE;
3657           seenflag = TRUE;
3658           break;
3659         case 's':
3660           dump_section_contents = TRUE;
3661           seenflag = TRUE;
3662           break;
3663         case 'r':
3664           dump_reloc_info = TRUE;
3665           seenflag = TRUE;
3666           break;
3667         case 'R':
3668           dump_dynamic_reloc_info = TRUE;
3669           seenflag = TRUE;
3670           break;
3671         case 'a':
3672           dump_ar_hdrs = TRUE;
3673           seenflag = TRUE;
3674           break;
3675         case 'h':
3676           dump_section_headers = TRUE;
3677           seenflag = TRUE;
3678           break;
3679         case 'v':
3680         case 'V':
3681           show_version = TRUE;
3682           seenflag = TRUE;
3683           break;
3684
3685         case 'H':
3686           usage (stdout, 0);
3687           /* No need to set seenflag or to break - usage() does not return.  */
3688         default:
3689           usage (stderr, 1);
3690         }
3691     }
3692
3693   if (show_version)
3694     print_version ("objdump");
3695
3696   if (!seenflag)
3697     usage (stderr, 2);
3698
3699   if (formats_info)
3700     exit_status = display_info ();
3701   else
3702     {
3703       if (optind == argc)
3704         display_file ("a.out", target);
3705       else
3706         for (; optind < argc;)
3707           display_file (argv[optind++], target);
3708     }
3709
3710   free_only_list ();
3711
3712   END_PROGRESS (program_name);
3713
3714   return exit_status;
3715 }