binutils/objdump.c

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