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
   4    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 2, 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, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
  21
  22 /* Objdump overview.
  23
  24    Objdump displays information about one or more object files, either on
  25    their own, or inside libraries.  It is commonly used as a disassembler,
  26    but it can also display information about file headers, symbol tables,
  27    relocations, debugging directives and more.
  28
  29    The flow of execution is as follows:
  30
  31    1. Command line arguments are checked for control switches and the
  32       information to be displayed is selected.
  33
  34    2. Any remaining arguments are assumed to be object files, and they are
  35       processed in order by display_bfd().  If the file is an archive each
  36       of its elements is processed in turn.
  37
  38    3. The file's target architecture and binary file format are determined
  39       by bfd_check_format().  If they are recognised, then dump_bfd() is
  40       called.
  41
  42    4. dump_bfd() in turn calls separate functions to display the requested
  43       item(s) of information(s).  For example disassemble_data() is called if
  44       a disassembly has been requested.
  45
  46    When disassembling the code loops through blocks of instructions bounded
  47    by symbols, calling disassemble_bytes() on each block.  The actual
  48    disassembling is done by the libopcodes library, via a function pointer
  49    supplied by the disassembler() function.  */
  50
  51 #include "bfd.h"
  52 #include "bfdver.h"
  53 #include "progress.h"
  54 #include "bucomm.h"
  55 #include "budemang.h"
  56 #include "getopt.h"
  57 #include "safe-ctype.h"
  58 #include "dis-asm.h"
  59 #include "libiberty.h"
  60 #include "demangle.h"
  61 #include "debug.h"
  62 #include "budbg.h"
  63
  64 /* Internal headers for the ELF .stab-dump code - sorry.  */
  65 #define BYTES_IN_WORD   32
  66 #include "aout/aout64.h"
  67
  68 #ifdef NEED_DECLARATION_FPRINTF
  69 /* This is needed by init_disassemble_info().  */
  70 extern int fprintf (FILE *, const char *, ...);
  71 #endif
  72
  73 /* Exit status.  */
  74 static int exit_status = 0;
  75
  76 static char *default_target = NULL;     /* Default at runtime.  */
  77
  78 /* The following variables are set based on arguments passed on the
  79    command line.  */
  80 static int show_version = 0;            /* Show the version number.  */
  81 static int dump_section_contents;       /* -s */
  82 static int dump_section_headers;        /* -h */
  83 static bfd_boolean dump_file_header;    /* -f */
  84 static int dump_symtab;                 /* -t */
  85 static int dump_dynamic_symtab;         /* -T */
  86 static int dump_reloc_info;             /* -r */
  87 static int dump_dynamic_reloc_info;     /* -R */
  88 static int dump_ar_hdrs;                /* -a */
  89 static int dump_private_headers;        /* -p */
  90 static int prefix_addresses;            /* --prefix-addresses */
  91 static int with_line_numbers;           /* -l */
  92 static bfd_boolean with_source_code;    /* -S */
  93 static int show_raw_insn;               /* --show-raw-insn */
  94 static int dump_stab_section_info;      /* --stabs */
  95 static int do_demangle;                 /* -C, --demangle */
  96 static bfd_boolean disassemble;         /* -d */
  97 static bfd_boolean disassemble_all;     /* -D */
  98 static int disassemble_zeroes;          /* --disassemble-zeroes */
  99 static bfd_boolean formats_info;        /* -i */
 100 static int wide_output;                 /* -w */
 101 static bfd_vma start_address = (bfd_vma) -1; /* --start-address */
 102 static bfd_vma stop_address = (bfd_vma) -1;  /* --stop-address */
 103 static int dump_debugging;              /* --debugging */
 104 static int dump_debugging_tags;         /* --debugging-tags */
 105 static bfd_vma adjust_section_vma = 0;  /* --adjust-vma */
 106 static int file_start_context = 0;      /* --file-start-context */
 107
 108 /* Pointer to an array of section names provided by
 109    one or more "-j secname" command line options.  */
 110 static char **only;
 111 /* The total number of slots in the only[] array.  */
 112 static size_t only_size = 0;
 113 /* The number of occupied slots in the only[] array.  */
 114 static size_t only_used = 0;
 115
 116 /* Variables for handling include file path table.  */
 117 static const char **include_paths;
 118 static int include_path_count;
 119
 120 /* Extra info to pass to the section disassembler and address printing
 121    function.  */
 122 struct objdump_disasm_info
 123 {
 124   bfd *              abfd;
 125   asection *         sec;
 126   bfd_boolean        require_sec;
 127   arelent **         dynrelbuf;
 128   long               dynrelcount;
 129   disassembler_ftype disassemble_fn;
 130 };
 131
 132 /* Architecture to disassemble for, or default if NULL.  */
 133 static char *machine = NULL;
 134
 135 /* Target specific options to the disassembler.  */
 136 static char *disassembler_options = NULL;
 137
 138 /* Endianness to disassemble for, or default if BFD_ENDIAN_UNKNOWN.  */
 139 static enum bfd_endian endian = BFD_ENDIAN_UNKNOWN;
 140
 141 /* The symbol table.  */
 142 static asymbol **syms;
 143
 144 /* Number of symbols in `syms'.  */
 145 static long symcount = 0;
 146
 147 /* The sorted symbol table.  */
 148 static asymbol **sorted_syms;
 149
 150 /* Number of symbols in `sorted_syms'.  */
 151 static long sorted_symcount = 0;
 152
 153 /* The dynamic symbol table.  */
 154 static asymbol **dynsyms;
 155
 156 /* The synthetic symbol table.  */
 157 static asymbol *synthsyms;
 158 static long synthcount = 0;
 159
 160 /* Number of symbols in `dynsyms'.  */
 161 static long dynsymcount = 0;
 162
 163 static bfd_byte *stabs;
 164 static bfd_size_type stab_size;
 165
 166 static char *strtab;
 167 static bfd_size_type stabstr_size;
 168 \f
 169 static void
 170 usage (FILE *stream, int status)
 171 {
 172   fprintf (stream, _("Usage: %s <option(s)> <file(s)>\n"), program_name);
 173   fprintf (stream, _(" Display information from object <file(s)>.\n"));
 174   fprintf (stream, _(" At least one of the following switches must be given:\n"));
 175   fprintf (stream, _("\
 176   -a, --archive-headers    Display archive header information\n\
 177   -f, --file-headers       Display the contents of the overall file header\n\
 178   -p, --private-headers    Display object format specific file header contents\n\
 179   -h, --[section-]headers  Display the contents of the section headers\n\
 180   -x, --all-headers        Display the contents of all headers\n\
 181   -d, --disassemble        Display assembler contents of executable sections\n\
 182   -D, --disassemble-all    Display assembler contents of all sections\n\
 183   -S, --source             Intermix source code with disassembly\n\
 184   -s, --full-contents      Display the full contents of all sections requested\n\
 185   -g, --debugging          Display debug information in object file\n\
 186   -e, --debugging-tags     Display debug information using ctags style\n\
 187   -G, --stabs              Display (in raw form) any STABS info in the file\n\
 188   -t, --syms               Display the contents of the symbol table(s)\n\
 189   -T, --dynamic-syms       Display the contents of the dynamic symbol table\n\
 190   -r, --reloc              Display the relocation entries in the file\n\
 191   -R, --dynamic-reloc      Display the dynamic relocation entries in the file\n\
 192   -v, --version            Display this program's version number\n\
 193   -i, --info               List object formats and architectures supported\n\
 194   -H, --help               Display this information\n\
 195 "));
 196   if (status != 2)
 197     {
 198       fprintf (stream, _("\n The following switches are optional:\n"));
 199       fprintf (stream, _("\
 200   -b, --target=BFDNAME           Specify the target object format as BFDNAME\n\
 201   -m, --architecture=MACHINE     Specify the target architecture as MACHINE\n\
 202   -j, --section=NAME             Only display information for section NAME\n\
 203   -M, --disassembler-options=OPT Pass text OPT on to the disassembler\n\
 204   -EB --endian=big               Assume big endian format when disassembling\n\
 205   -EL --endian=little            Assume little endian format when disassembling\n\
 206       --file-start-context       Include context from start of file (with -S)\n\
 207   -I, --include=DIR              Add DIR to search list for source files\n\
 208   -l, --line-numbers             Include line numbers and filenames in output\n\
 209   -C, --demangle[=STYLE]         Decode mangled/processed symbol names\n\
 210                                   The STYLE, if specified, can be `auto', `gnu',\n\
 211                                   `lucid', `arm', `hp', `edg', `gnu-v3', `java'\n\
 212                                   or `gnat'\n\
 213   -w, --wide                     Format output for more than 80 columns\n\
 214   -z, --disassemble-zeroes       Do not skip blocks of zeroes when disassembling\n\
 215       --start-address=ADDR       Only process data whose address is >= ADDR\n\
 216       --stop-address=ADDR        Only process data whose address is <= ADDR\n\
 217       --prefix-addresses         Print complete address alongside disassembly\n\
 218       --[no-]show-raw-insn       Display hex alongside symbolic disassembly\n\
 219       --adjust-vma=OFFSET        Add OFFSET to all displayed section addresses\n\
 220 \n"));
 221       list_supported_targets (program_name, stream);
 222       list_supported_architectures (program_name, stream);
 223
 224       disassembler_usage (stream);
 225     }
 226   if (status == 0)
 227     fprintf (stream, _("Report bugs to %s.\n"), REPORT_BUGS_TO);
 228   exit (status);
 229 }
 230
 231 /* 150 isn't special; it's just an arbitrary non-ASCII char value.  */
 232 enum option_values
 233   {
 234     OPTION_ENDIAN=150,
 235     OPTION_START_ADDRESS,
 236     OPTION_STOP_ADDRESS,
 237     OPTION_ADJUST_VMA
 238   };
 239
 240 static struct option long_options[]=
 241 {
 242   {"adjust-vma", required_argument, NULL, OPTION_ADJUST_VMA},
 243   {"all-headers", no_argument, NULL, 'x'},
 244   {"private-headers", no_argument, NULL, 'p'},
 245   {"architecture", required_argument, NULL, 'm'},
 246   {"archive-headers", no_argument, NULL, 'a'},
 247   {"debugging", no_argument, NULL, 'g'},
 248   {"debugging-tags", no_argument, NULL, 'e'},
 249   {"demangle", optional_argument, NULL, 'C'},
 250   {"disassemble", no_argument, NULL, 'd'},
 251   {"disassemble-all", no_argument, NULL, 'D'},
 252   {"disassembler-options", required_argument, NULL, 'M'},
 253   {"disassemble-zeroes", no_argument, NULL, 'z'},
 254   {"dynamic-reloc", no_argument, NULL, 'R'},
 255   {"dynamic-syms", no_argument, NULL, 'T'},
 256   {"endian", required_argument, NULL, OPTION_ENDIAN},
 257   {"file-headers", no_argument, NULL, 'f'},
 258   {"file-start-context", no_argument, &file_start_context, 1},
 259   {"full-contents", no_argument, NULL, 's'},
 260   {"headers", no_argument, NULL, 'h'},
 261   {"help", no_argument, NULL, 'H'},
 262   {"info", no_argument, NULL, 'i'},
 263   {"line-numbers", no_argument, NULL, 'l'},
 264   {"no-show-raw-insn", no_argument, &show_raw_insn, -1},
 265   {"prefix-addresses", no_argument, &prefix_addresses, 1},
 266   {"reloc", no_argument, NULL, 'r'},
 267   {"section", required_argument, NULL, 'j'},
 268   {"section-headers", no_argument, NULL, 'h'},
 269   {"show-raw-insn", no_argument, &show_raw_insn, 1},
 270   {"source", no_argument, NULL, 'S'},
 271   {"include", required_argument, NULL, 'I'},
 272   {"stabs", no_argument, NULL, 'G'},
 273   {"start-address", required_argument, NULL, OPTION_START_ADDRESS},
 274   {"stop-address", required_argument, NULL, OPTION_STOP_ADDRESS},
 275   {"syms", no_argument, NULL, 't'},
 276   {"target", required_argument, NULL, 'b'},
 277   {"version", no_argument, NULL, 'V'},
 278   {"wide", no_argument, NULL, 'w'},
 279   {0, no_argument, 0, 0}
 280 };
 281 \f
 282 static void
 283 nonfatal (const char *msg)
 284 {
 285   bfd_nonfatal (msg);
 286   exit_status = 1;
 287 }
 288 \f
 289 static void
 290 dump_section_header (bfd *abfd ATTRIBUTE_UNUSED, asection *section,
 291                      void *ignored ATTRIBUTE_UNUSED)
 292 {
 293   char *comma = "";
 294   unsigned int opb = bfd_octets_per_byte (abfd);
 295
 296   printf ("%3d %-13s %08lx  ", section->index,
 297           bfd_get_section_name (abfd, section),
 298           (unsigned long) bfd_section_size (abfd, section) / opb);
 299   bfd_printf_vma (abfd, bfd_get_section_vma (abfd, section));
 300   printf ("  ");
 301   bfd_printf_vma (abfd, section->lma);
 302   printf ("  %08lx  2**%u", (unsigned long) section->filepos,
 303           bfd_get_section_alignment (abfd, section));
 304   if (! wide_output)
 305     printf ("\n                ");
 306   printf ("  ");
 307
 308 #define PF(x, y) \
 309   if (section->flags & x) { printf ("%s%s", comma, y); comma = ", "; }
 310
 311   PF (SEC_HAS_CONTENTS, "CONTENTS");
 312   PF (SEC_ALLOC, "ALLOC");
 313   PF (SEC_CONSTRUCTOR, "CONSTRUCTOR");
 314   PF (SEC_LOAD, "LOAD");
 315   PF (SEC_RELOC, "RELOC");
 316   PF (SEC_READONLY, "READONLY");
 317   PF (SEC_CODE, "CODE");
 318   PF (SEC_DATA, "DATA");
 319   PF (SEC_ROM, "ROM");
 320   PF (SEC_DEBUGGING, "DEBUGGING");
 321   PF (SEC_NEVER_LOAD, "NEVER_LOAD");
 322   PF (SEC_EXCLUDE, "EXCLUDE");
 323   PF (SEC_SORT_ENTRIES, "SORT_ENTRIES");
 324   PF (SEC_BLOCK, "BLOCK");
 325   PF (SEC_CLINK, "CLINK");
 326   PF (SEC_SMALL_DATA, "SMALL_DATA");
 327   PF (SEC_SHARED, "SHARED");
 328   PF (SEC_ARCH_BIT_0, "ARCH_BIT_0");
 329   PF (SEC_THREAD_LOCAL, "THREAD_LOCAL");
 330
 331   if ((section->flags & SEC_LINK_ONCE) != 0)
 332     {
 333       const char *ls;
 334       struct coff_comdat_info *comdat;
 335
 336       switch (section->flags & SEC_LINK_DUPLICATES)
 337         {
 338         default:
 339           abort ();
 340         case SEC_LINK_DUPLICATES_DISCARD:
 341           ls = "LINK_ONCE_DISCARD";
 342           break;
 343         case SEC_LINK_DUPLICATES_ONE_ONLY:
 344           ls = "LINK_ONCE_ONE_ONLY";
 345           break;
 346         case SEC_LINK_DUPLICATES_SAME_SIZE:
 347           ls = "LINK_ONCE_SAME_SIZE";
 348           break;
 349         case SEC_LINK_DUPLICATES_SAME_CONTENTS:
 350           ls = "LINK_ONCE_SAME_CONTENTS";
 351           break;
 352         }
 353       printf ("%s%s", comma, ls);
 354
 355       comdat = bfd_coff_get_comdat_section (abfd, section);
 356       if (comdat != NULL)
 357         printf (" (COMDAT %s %ld)", comdat->name, comdat->symbol);
 358
 359       comma = ", ";
 360     }
 361
 362   printf ("\n");
 363 #undef PF
 364 }
 365
 366 static void
 367 dump_headers (bfd *abfd)
 368 {
 369   printf (_("Sections:\n"));
 370
 371 #ifndef BFD64
 372   printf (_("Idx Name          Size      VMA       LMA       File off  Algn"));
 373 #else
 374   /* With BFD64, non-ELF returns -1 and wants always 64 bit addresses.  */
 375   if (bfd_get_arch_size (abfd) == 32)
 376     printf (_("Idx Name          Size      VMA       LMA       File off  Algn"));
 377   else
 378     printf (_("Idx Name          Size      VMA               LMA               File off  Algn"));
 379 #endif
 380
 381   if (wide_output)
 382     printf (_("  Flags"));
 383   if (abfd->flags & HAS_LOAD_PAGE)
 384     printf (_("  Pg"));
 385   printf ("\n");
 386
 387   bfd_map_over_sections (abfd, dump_section_header, NULL);
 388 }
 389 \f
 390 static asymbol **
 391 slurp_symtab (bfd *abfd)
 392 {
 393   asymbol **sy = NULL;
 394   long storage;
 395
 396   if (!(bfd_get_file_flags (abfd) & HAS_SYMS))
 397     {
 398       symcount = 0;
 399       return NULL;
 400     }
 401
 402   storage = bfd_get_symtab_upper_bound (abfd);
 403   if (storage < 0)
 404     bfd_fatal (bfd_get_filename (abfd));
 405   if (storage)
 406     sy = xmalloc (storage);
 407
 408   symcount = bfd_canonicalize_symtab (abfd, sy);
 409   if (symcount < 0)
 410     bfd_fatal (bfd_get_filename (abfd));
 411   return sy;
 412 }
 413
 414 /* Read in the dynamic symbols.  */
 415
 416 static asymbol **
 417 slurp_dynamic_symtab (bfd *abfd)
 418 {
 419   asymbol **sy = NULL;
 420   long storage;
 421
 422   storage = bfd_get_dynamic_symtab_upper_bound (abfd);
 423   if (storage < 0)
 424     {
 425       if (!(bfd_get_file_flags (abfd) & DYNAMIC))
 426         {
 427           non_fatal (_("%s: not a dynamic object"), bfd_get_filename (abfd));
 428           dynsymcount = 0;
 429           return NULL;
 430         }
 431
 432       bfd_fatal (bfd_get_filename (abfd));
 433     }
 434   if (storage)
 435     sy = xmalloc (storage);
 436
 437   dynsymcount = bfd_canonicalize_dynamic_symtab (abfd, sy);
 438   if (dynsymcount < 0)
 439     bfd_fatal (bfd_get_filename (abfd));
 440   return sy;
 441 }
 442
 443 /* Filter out (in place) symbols that are useless for disassembly.
 444    COUNT is the number of elements in SYMBOLS.
 445    Return the number of useful symbols.  */
 446
 447 static long
 448 remove_useless_symbols (asymbol **symbols, long count)
 449 {
 450   asymbol **in_ptr = symbols, **out_ptr = symbols;
 451
 452   while (--count >= 0)
 453     {
 454       asymbol *sym = *in_ptr++;
 455
 456       if (sym->name == NULL || sym->name[0] == '\0')
 457         continue;
 458       if (sym->flags & (BSF_DEBUGGING))
 459         continue;
 460       if (bfd_is_und_section (sym->section)
 461           || bfd_is_com_section (sym->section))
 462         continue;
 463
 464       *out_ptr++ = sym;
 465     }
 466   return out_ptr - symbols;
 467 }
 468
 469 /* Sort symbols into value order.  */
 470
 471 static int
 472 compare_symbols (const void *ap, const void *bp)
 473 {
 474   const asymbol *a = * (const asymbol **) ap;
 475   const asymbol *b = * (const asymbol **) bp;
 476   const char *an;
 477   const char *bn;
 478   size_t anl;
 479   size_t bnl;
 480   bfd_boolean af;
 481   bfd_boolean bf;
 482   flagword aflags;
 483   flagword bflags;
 484
 485   if (bfd_asymbol_value (a) > bfd_asymbol_value (b))
 486     return 1;
 487   else if (bfd_asymbol_value (a) < bfd_asymbol_value (b))
 488     return -1;
 489
 490   if (a->section > b->section)
 491     return 1;
 492   else if (a->section < b->section)
 493     return -1;
 494
 495   an = bfd_asymbol_name (a);
 496   bn = bfd_asymbol_name (b);
 497   anl = strlen (an);
 498   bnl = strlen (bn);
 499
 500   /* The symbols gnu_compiled and gcc2_compiled convey no real
 501      information, so put them after other symbols with the same value.  */
 502   af = (strstr (an, "gnu_compiled") != NULL
 503         || strstr (an, "gcc2_compiled") != NULL);
 504   bf = (strstr (bn, "gnu_compiled") != NULL
 505         || strstr (bn, "gcc2_compiled") != NULL);
 506
 507   if (af && ! bf)
 508     return 1;
 509   if (! af && bf)
 510     return -1;
 511
 512   /* We use a heuristic for the file name, to try to sort it after
 513      more useful symbols.  It may not work on non Unix systems, but it
 514      doesn't really matter; the only difference is precisely which
 515      symbol names get printed.  */
 516
 517 #define file_symbol(s, sn, snl)                 \
 518   (((s)->flags & BSF_FILE) != 0                 \
 519    || ((sn)[(snl) - 2] == '.'                   \
 520        && ((sn)[(snl) - 1] == 'o'               \
 521            || (sn)[(snl) - 1] == 'a')))
 522
 523   af = file_symbol (a, an, anl);
 524   bf = file_symbol (b, bn, bnl);
 525
 526   if (af && ! bf)
 527     return 1;
 528   if (! af && bf)
 529     return -1;
 530
 531   /* Try to sort global symbols before local symbols before function
 532      symbols before debugging symbols.  */
 533
 534   aflags = a->flags;
 535   bflags = b->flags;
 536
 537   if ((aflags & BSF_DEBUGGING) != (bflags & BSF_DEBUGGING))
 538     {
 539       if ((aflags & BSF_DEBUGGING) != 0)
 540         return 1;
 541       else
 542         return -1;
 543     }
 544   if ((aflags & BSF_FUNCTION) != (bflags & BSF_FUNCTION))
 545     {
 546       if ((aflags & BSF_FUNCTION) != 0)
 547         return -1;
 548       else
 549         return 1;
 550     }
 551   if ((aflags & BSF_LOCAL) != (bflags & BSF_LOCAL))
 552     {
 553       if ((aflags & BSF_LOCAL) != 0)
 554         return 1;
 555       else
 556         return -1;
 557     }
 558   if ((aflags & BSF_GLOBAL) != (bflags & BSF_GLOBAL))
 559     {
 560       if ((aflags & BSF_GLOBAL) != 0)
 561         return -1;
 562       else
 563         return 1;
 564     }
 565
 566   /* Symbols that start with '.' might be section names, so sort them
 567      after symbols that don't start with '.'.  */
 568   if (an[0] == '.' && bn[0] != '.')
 569     return 1;
 570   if (an[0] != '.' && bn[0] == '.')
 571     return -1;
 572
 573   /* Finally, if we can't distinguish them in any other way, try to
 574      get consistent results by sorting the symbols by name.  */
 575   return strcmp (an, bn);
 576 }
 577
 578 /* Sort relocs into address order.  */
 579
 580 static int
 581 compare_relocs (const void *ap, const void *bp)
 582 {
 583   const arelent *a = * (const arelent **) ap;
 584   const arelent *b = * (const arelent **) bp;
 585
 586   if (a->address > b->address)
 587     return 1;
 588   else if (a->address < b->address)
 589     return -1;
 590
 591   /* So that associated relocations tied to the same address show up
 592      in the correct order, we don't do any further sorting.  */
 593   if (a > b)
 594     return 1;
 595   else if (a < b)
 596     return -1;
 597   else
 598     return 0;
 599 }
 600
 601 /* Print an address (VMA) to the output stream in INFO.
 602    If SKIP_ZEROES is TRUE, omit leading zeroes.  */
 603
 604 static void
 605 objdump_print_value (bfd_vma vma, struct disassemble_info *info,
 606                      bfd_boolean skip_zeroes)
 607 {
 608   char buf[30];
 609   char *p;
 610   struct objdump_disasm_info *aux;
 611
 612   aux = (struct objdump_disasm_info *) info->application_data;
 613   bfd_sprintf_vma (aux->abfd, buf, vma);
 614   if (! skip_zeroes)
 615     p = buf;
 616   else
 617     {
 618       for (p = buf; *p == '0'; ++p)
 619         ;
 620       if (*p == '\0')
 621         --p;
 622     }
 623   (*info->fprintf_func) (info->stream, "%s", p);
 624 }
 625
 626 /* Print the name of a symbol.  */
 627
 628 static void
 629 objdump_print_symname (bfd *abfd, struct disassemble_info *info,
 630                        asymbol *sym)
 631 {
 632   char *alloc;
 633   const char *name;
 634
 635   alloc = NULL;
 636   name = bfd_asymbol_name (sym);
 637   if (do_demangle && name[0] != '\0')
 638     {
 639       /* Demangle the name.  */
 640       alloc = demangle (abfd, name);
 641       name = alloc;
 642     }
 643
 644   if (info != NULL)
 645     (*info->fprintf_func) (info->stream, "%s", name);
 646   else
 647     printf ("%s", name);
 648
 649   if (alloc != NULL)
 650     free (alloc);
 651 }
 652
 653 /* Locate a symbol given a bfd and a section (from INFO->application_data),
 654    and a VMA.  If INFO->application_data->require_sec is TRUE, then always
 655    require the symbol to be in the section.  Returns NULL if there is no
 656    suitable symbol.  If PLACE is not NULL, then *PLACE is set to the index
 657    of the symbol in sorted_syms.  */
 658
 659 static asymbol *
 660 find_symbol_for_address (bfd_vma vma,
 661                          struct disassemble_info *info,
 662                          long *place)
 663 {
 664   /* @@ Would it speed things up to cache the last two symbols returned,
 665      and maybe their address ranges?  For many processors, only one memory
 666      operand can be present at a time, so the 2-entry cache wouldn't be
 667      constantly churned by code doing heavy memory accesses.  */
 668
 669   /* Indices in `sorted_syms'.  */
 670   long min = 0;
 671   long max = sorted_symcount;
 672   long thisplace;
 673   struct objdump_disasm_info *aux;
 674   bfd *abfd;
 675   asection *sec;
 676   unsigned int opb;
 677
 678   if (sorted_symcount < 1)
 679     return NULL;
 680
 681   aux = (struct objdump_disasm_info *) info->application_data;
 682   abfd = aux->abfd;
 683   sec = aux->sec;
 684   opb = bfd_octets_per_byte (abfd);
 685
 686   /* Perform a binary search looking for the closest symbol to the
 687      required value.  We are searching the range (min, max].  */
 688   while (min + 1 < max)
 689     {
 690       asymbol *sym;
 691
 692       thisplace = (max + min) / 2;
 693       sym = sorted_syms[thisplace];
 694
 695       if (bfd_asymbol_value (sym) > vma)
 696         max = thisplace;
 697       else if (bfd_asymbol_value (sym) < vma)
 698         min = thisplace;
 699       else
 700         {
 701           min = thisplace;
 702           break;
 703         }
 704     }
 705
 706   /* The symbol we want is now in min, the low end of the range we
 707      were searching.  If there are several symbols with the same
 708      value, we want the first one.  */
 709   thisplace = min;
 710   while (thisplace > 0
 711          && (bfd_asymbol_value (sorted_syms[thisplace])
 712              == bfd_asymbol_value (sorted_syms[thisplace - 1])))
 713     --thisplace;
 714
 715   /* If the file is relocatable, and the symbol could be from this
 716      section, prefer a symbol from this section over symbols from
 717      others, even if the other symbol's value might be closer.
 718
 719      Note that this may be wrong for some symbol references if the
 720      sections have overlapping memory ranges, but in that case there's
 721      no way to tell what's desired without looking at the relocation
 722      table.  */
 723   if (sorted_syms[thisplace]->section != sec
 724       && (aux->require_sec
 725           || ((abfd->flags & HAS_RELOC) != 0
 726               && vma >= bfd_get_section_vma (abfd, sec)
 727               && vma < (bfd_get_section_vma (abfd, sec)
 728                         + bfd_section_size (abfd, sec) / opb))))
 729     {
 730       long i;
 731
 732       for (i = thisplace + 1; i < sorted_symcount; i++)
 733         {
 734           if (bfd_asymbol_value (sorted_syms[i])
 735               != bfd_asymbol_value (sorted_syms[thisplace]))
 736             break;
 737         }
 738
 739       --i;
 740
 741       for (; i >= 0; i--)
 742         {
 743           if (sorted_syms[i]->section == sec
 744               && (i == 0
 745                   || sorted_syms[i - 1]->section != sec
 746                   || (bfd_asymbol_value (sorted_syms[i])
 747                       != bfd_asymbol_value (sorted_syms[i - 1]))))
 748             {
 749               thisplace = i;
 750               break;
 751             }
 752         }
 753
 754       if (sorted_syms[thisplace]->section != sec)
 755         {
 756           /* We didn't find a good symbol with a smaller value.
 757              Look for one with a larger value.  */
 758           for (i = thisplace + 1; i < sorted_symcount; i++)
 759             {
 760               if (sorted_syms[i]->section == sec)
 761                 {
 762                   thisplace = i;
 763                   break;
 764                 }
 765             }
 766         }
 767
 768       if (sorted_syms[thisplace]->section != sec
 769           && (aux->require_sec
 770               || ((abfd->flags & HAS_RELOC) != 0
 771                   && vma >= bfd_get_section_vma (abfd, sec)
 772                   && vma < (bfd_get_section_vma (abfd, sec)
 773                             + bfd_section_size (abfd, sec)))))
 774         /* There is no suitable symbol.  */
 775         return NULL;
 776     }
 777
 778   /* Give the target a chance to reject the symbol.  */
 779   while (! info->symbol_is_valid (sorted_syms [thisplace], info))
 780     {
 781       ++ thisplace;
 782       if (thisplace >= sorted_symcount
 783           || bfd_asymbol_value (sorted_syms [thisplace]) > vma)
 784         return NULL;
 785     }
 786
 787   if (place != NULL)
 788     *place = thisplace;
 789
 790   return sorted_syms[thisplace];
 791 }
 792
 793 /* Print an address and the offset to the nearest symbol.  */
 794
 795 static void
 796 objdump_print_addr_with_sym (bfd *abfd, asection *sec, asymbol *sym,
 797                              bfd_vma vma, struct disassemble_info *info,
 798                              bfd_boolean skip_zeroes)
 799 {
 800   objdump_print_value (vma, info, skip_zeroes);
 801
 802   if (sym == NULL)
 803     {
 804       bfd_vma secaddr;
 805
 806       (*info->fprintf_func) (info->stream, " <%s",
 807                              bfd_get_section_name (abfd, sec));
 808       secaddr = bfd_get_section_vma (abfd, sec);
 809       if (vma < secaddr)
 810         {
 811           (*info->fprintf_func) (info->stream, "-0x");
 812           objdump_print_value (secaddr - vma, info, TRUE);
 813         }
 814       else if (vma > secaddr)
 815         {
 816           (*info->fprintf_func) (info->stream, "+0x");
 817           objdump_print_value (vma - secaddr, info, TRUE);
 818         }
 819       (*info->fprintf_func) (info->stream, ">");
 820     }
 821   else
 822     {
 823       (*info->fprintf_func) (info->stream, " <");
 824       objdump_print_symname (abfd, info, sym);
 825       if (bfd_asymbol_value (sym) > vma)
 826         {
 827           (*info->fprintf_func) (info->stream, "-0x");
 828           objdump_print_value (bfd_asymbol_value (sym) - vma, info, TRUE);
 829         }
 830       else if (vma > bfd_asymbol_value (sym))
 831         {
 832           (*info->fprintf_func) (info->stream, "+0x");
 833           objdump_print_value (vma - bfd_asymbol_value (sym), info, TRUE);
 834         }
 835       (*info->fprintf_func) (info->stream, ">");
 836     }
 837 }
 838
 839 /* Print an address (VMA), symbolically if possible.
 840    If SKIP_ZEROES is TRUE, don't output leading zeroes.  */
 841
 842 static void
 843 objdump_print_addr (bfd_vma vma,
 844                     struct disassemble_info *info,
 845                     bfd_boolean skip_zeroes)
 846 {
 847   struct objdump_disasm_info *aux;
 848   asymbol *sym;
 849
 850   if (sorted_symcount < 1)
 851     {
 852       (*info->fprintf_func) (info->stream, "0x");
 853       objdump_print_value (vma, info, skip_zeroes);
 854       return;
 855     }
 856
 857   aux = (struct objdump_disasm_info *) info->application_data;
 858   sym = find_symbol_for_address (vma, info, NULL);
 859   objdump_print_addr_with_sym (aux->abfd, aux->sec, sym, vma, info,
 860                                skip_zeroes);
 861 }
 862
 863 /* Print VMA to INFO.  This function is passed to the disassembler
 864    routine.  */
 865
 866 static void
 867 objdump_print_address (bfd_vma vma, struct disassemble_info *info)
 868 {
 869   objdump_print_addr (vma, info, ! prefix_addresses);
 870 }
 871
 872 /* Determine of the given address has a symbol associated with it.  */
 873
 874 static int
 875 objdump_symbol_at_address (bfd_vma vma, struct disassemble_info * info)
 876 {
 877   asymbol * sym;
 878
 879   sym = find_symbol_for_address (vma, info, NULL);
 880
 881   return (sym != NULL && (bfd_asymbol_value (sym) == vma));
 882 }
 883
 884 /* Hold the last function name and the last line number we displayed
 885    in a disassembly.  */
 886
 887 static char *prev_functionname;
 888 static unsigned int prev_line;
 889
 890 /* We keep a list of all files that we have seen when doing a
 891    disassembly with source, so that we know how much of the file to
 892    display.  This can be important for inlined functions.  */
 893
 894 struct print_file_list
 895 {
 896   struct print_file_list *next;
 897   const char *filename;
 898   const char *modname;
 899   unsigned int line;
 900   FILE *f;
 901 };
 902
 903 static struct print_file_list *print_files;
 904
 905 /* The number of preceding context lines to show when we start
 906    displaying a file for the first time.  */
 907
 908 #define SHOW_PRECEDING_CONTEXT_LINES (5)
 909
 910 /* Tries to open MODNAME, and if successful adds a node to print_files
 911    linked list and returns that node.  Returns NULL on failure.  */
 912
 913 static struct print_file_list *
 914 try_print_file_open (const char *origname, const char *modname)
 915 {
 916   struct print_file_list *p;
 917   FILE *f;
 918
 919   f = fopen (modname, "r");
 920   if (f == NULL)
 921     return NULL;
 922
 923   if (print_files != NULL && print_files->f != NULL)
 924     {
 925       fclose (print_files->f);
 926       print_files->f = NULL;
 927     }
 928
 929   p = xmalloc (sizeof (struct print_file_list));
 930   p->filename = origname;
 931   p->modname = modname;
 932   p->line = 0;
 933   p->f = f;
 934   p->next = print_files;
 935   print_files = p;
 936   return p;
 937 }
 938
 939 /* If the the source file, as described in the symtab, is not found
 940    try to locate it in one of the paths specified with -I
 941    If found, add location to print_files linked list.  */
 942
 943 static struct print_file_list *
 944 update_source_path (const char *filename)
 945 {
 946   struct print_file_list *p;
 947   const char *fname;
 948   int i;
 949
 950   if (filename == NULL)
 951     return NULL;
 952
 953   p = try_print_file_open (filename, filename);
 954   if (p != NULL)
 955     return p;
 956
 957   if (include_path_count == 0)
 958     return NULL;
 959
 960   /* Get the name of the file.  */
 961   fname = strrchr (filename, '/');
 962 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
 963   {
 964     /* We could have a mixed forward/back slash case.  */
 965     char *backslash = strrchr (filename, '\\');
 966     if (fname == NULL || (backslash != NULL && backslash > fname))
 967       fname = backslash;
 968     if (fname == NULL && filename[0] != '\0' && filename[1] == ':')
 969       fname = filename + 1;
 970   }
 971 #endif
 972   if (fname == NULL)
 973     fname = filename;
 974   else
 975     ++fname;
 976
 977   /* If file exists under a new path, we need to add it to the list
 978      so that show_line knows about it.  */
 979   for (i = 0; i < include_path_count; i++)
 980     {
 981       char *modname = concat (include_paths[i], "/", fname, (const char *) 0);
 982
 983       p = try_print_file_open (filename, modname);
 984       if (p)
 985         return p;
 986
 987       free (modname);
 988     }
 989
 990   return NULL;
 991 }
 992
 993 /* Skip ahead to a given line in a file, optionally printing each
 994    line.  */
 995
 996 static void
 997 skip_to_line (struct print_file_list *p, unsigned int line,
 998               bfd_boolean show)
 999 {
1000   while (p->line < line)
1001     {
1002       char buf[100];
1003
1004       if (fgets (buf, sizeof buf, p->f) == NULL)
1005         {
1006           fclose (p->f);
1007           p->f = NULL;
1008           break;
1009         }
1010
1011       if (show)
1012         printf ("%s", buf);
1013
1014       if (strchr (buf, '\n') != NULL)
1015         ++p->line;
1016     }
1017 }
1018
1019 /* Show the line number, or the source line, in a disassembly
1020    listing.  */
1021
1022 static void
1023 show_line (bfd *abfd, asection *section, bfd_vma addr_offset)
1024 {
1025   const char *filename;
1026   const char *functionname;
1027   unsigned int line;
1028
1029   if (! with_line_numbers && ! with_source_code)
1030     return;
1031
1032   if (! bfd_find_nearest_line (abfd, section, syms, addr_offset, &filename,
1033                                &functionname, &line))
1034     return;
1035
1036   if (filename != NULL && *filename == '\0')
1037     filename = NULL;
1038   if (functionname != NULL && *functionname == '\0')
1039     functionname = NULL;
1040
1041   if (with_line_numbers)
1042     {
1043       if (functionname != NULL
1044           && (prev_functionname == NULL
1045               || strcmp (functionname, prev_functionname) != 0))
1046         printf ("%s():\n", functionname);
1047       if (line > 0 && line != prev_line)
1048         printf ("%s:%u\n", filename == NULL ? "???" : filename, line);
1049     }
1050
1051   if (with_source_code
1052       && filename != NULL
1053       && line > 0)
1054     {
1055       struct print_file_list **pp, *p;
1056
1057       for (pp = &print_files; *pp != NULL; pp = &(*pp)->next)
1058         if (strcmp ((*pp)->filename, filename) == 0)
1059           break;
1060       p = *pp;
1061
1062       if (p != NULL)
1063         {
1064           if (p != print_files)
1065             {
1066               int l;
1067
1068               /* We have reencountered a file name which we saw
1069                  earlier.  This implies that either we are dumping out
1070                  code from an included file, or the same file was
1071                  linked in more than once.  There are two common cases
1072                  of an included file: inline functions in a header
1073                  file, and a bison or flex skeleton file.  In the
1074                  former case we want to just start printing (but we
1075                  back up a few lines to give context); in the latter
1076                  case we want to continue from where we left off.  I
1077                  can't think of a good way to distinguish the cases,
1078                  so I used a heuristic based on the file name.  */
1079               if (strcmp (p->filename + strlen (p->filename) - 2, ".h") != 0)
1080                 l = p->line;
1081               else
1082                 {
1083                   l = line - SHOW_PRECEDING_CONTEXT_LINES;
1084                   if (l < 0)
1085                     l = 0;
1086                 }
1087
1088               if (p->f == NULL)
1089                 {
1090                   p->f = fopen (p->modname, "r");
1091                   p->line = 0;
1092                 }
1093               if (p->f != NULL)
1094                 skip_to_line (p, l, FALSE);
1095
1096               if (print_files->f != NULL)
1097                 {
1098                   fclose (print_files->f);
1099                   print_files->f = NULL;
1100                 }
1101             }
1102
1103           if (p->f != NULL)
1104             {
1105               skip_to_line (p, line, TRUE);
1106               *pp = p->next;
1107               p->next = print_files;
1108               print_files = p;
1109             }
1110         }
1111       else
1112         {
1113           p = update_source_path (filename);
1114
1115           if (p != NULL)
1116             {
1117               int l;
1118
1119               if (file_start_context)
1120                 l = 0;
1121               else
1122                 l = line - SHOW_PRECEDING_CONTEXT_LINES;
1123               if (l < 0)
1124                 l = 0;
1125               skip_to_line (p, l, FALSE);
1126               if (p->f != NULL)
1127                 skip_to_line (p, line, TRUE);
1128             }
1129         }
1130     }
1131
1132   if (functionname != NULL
1133       && (prev_functionname == NULL
1134           || strcmp (functionname, prev_functionname) != 0))
1135     {
1136       if (prev_functionname != NULL)
1137         free (prev_functionname);
1138       prev_functionname = xmalloc (strlen (functionname) + 1);
1139       strcpy (prev_functionname, functionname);
1140     }
1141
1142   if (line > 0 && line != prev_line)
1143     prev_line = line;
1144 }
1145
1146 /* Pseudo FILE object for strings.  */
1147 typedef struct
1148 {
1149   char *buffer;
1150   size_t pos;
1151   size_t alloc;
1152 } SFILE;
1153
1154 /* sprintf to a "stream".  */
1155
1156 static int
1157 objdump_sprintf (SFILE *f, const char *format, ...)
1158 {
1159   size_t n;
1160   va_list args;
1161
1162   while (1)
1163     {
1164       size_t space = f->alloc - f->pos;
1165
1166       va_start (args, format);
1167       n = vsnprintf (f->buffer + f->pos, space, format, args);
1168       va_end (args);
1169
1170       if (space > n)
1171         break;
1172
1173       f->alloc = (f->alloc + n) * 2;
1174       f->buffer = xrealloc (f->buffer, f->alloc);
1175     }
1176   f->pos += n;
1177
1178   return n;
1179 }
1180
1181 /* Returns TRUE if the specified section should be dumped.  */
1182
1183 static bfd_boolean
1184 process_section_p (asection * section)
1185 {
1186   size_t i;
1187
1188   if (only == NULL)
1189     return TRUE;
1190
1191   for (i = 0; i < only_used; i++)
1192     if (strcmp (only [i], section->name) == 0)
1193       return TRUE;
1194
1195   return FALSE;
1196 }
1197
1198
1199 /* The number of zeroes we want to see before we start skipping them.
1200    The number is arbitrarily chosen.  */
1201
1202 #ifndef SKIP_ZEROES
1203 #define SKIP_ZEROES (8)
1204 #endif
1205
1206 /* The number of zeroes to skip at the end of a section.  If the
1207    number of zeroes at the end is between SKIP_ZEROES_AT_END and
1208    SKIP_ZEROES, they will be disassembled.  If there are fewer than
1209    SKIP_ZEROES_AT_END, they will be skipped.  This is a heuristic
1210    attempt to avoid disassembling zeroes inserted by section
1211    alignment.  */
1212
1213 #ifndef SKIP_ZEROES_AT_END
1214 #define SKIP_ZEROES_AT_END (3)
1215 #endif
1216
1217 /* Disassemble some data in memory between given values.  */
1218
1219 static void
1220 disassemble_bytes (struct disassemble_info * info,
1221                    disassembler_ftype        disassemble_fn,
1222                    bfd_boolean               insns,
1223                    bfd_byte *                data,
1224                    bfd_vma                   start_offset,
1225                    bfd_vma                   stop_offset,
1226                    bfd_vma                   rel_offset,
1227                    arelent ***               relppp,
1228                    arelent **                relppend)
1229 {
1230   struct objdump_disasm_info *aux;
1231   asection *section;
1232   int octets_per_line;
1233   bfd_boolean done_dot;
1234   int skip_addr_chars;
1235   bfd_vma addr_offset;
1236   int opb = info->octets_per_byte;
1237   SFILE sfile;
1238
1239   aux = (struct objdump_disasm_info *) info->application_data;
1240   section = aux->sec;
1241
1242   sfile.alloc = 120;
1243   sfile.buffer = xmalloc (sfile.alloc);
1244   sfile.pos = 0;
1245
1246   if (insns)
1247     octets_per_line = 4;
1248   else
1249     octets_per_line = 16;
1250
1251   /* Figure out how many characters to skip at the start of an
1252      address, to make the disassembly look nicer.  We discard leading
1253      zeroes in chunks of 4, ensuring that there is always a leading
1254      zero remaining.  */
1255   skip_addr_chars = 0;
1256   if (! prefix_addresses)
1257     {
1258       char buf[30];
1259       char *s;
1260
1261       bfd_sprintf_vma
1262         (aux->abfd, buf,
1263          (section->vma
1264           + bfd_section_size (section->owner, section) / opb));
1265       s = buf;
1266       while (s[0] == '0' && s[1] == '0' && s[2] == '0' && s[3] == '0'
1267              && s[4] == '0')
1268         {
1269           skip_addr_chars += 4;
1270           s += 4;
1271         }
1272     }
1273
1274   info->insn_info_valid = 0;
1275
1276   done_dot = FALSE;
1277   addr_offset = start_offset;
1278   while (addr_offset < stop_offset)
1279     {
1280       bfd_vma z;
1281       int octets = 0;
1282       bfd_boolean need_nl = FALSE;
1283
1284       /* If we see more than SKIP_ZEROES octets of zeroes, we just
1285          print `...'.  */
1286       for (z = addr_offset * opb; z < stop_offset * opb; z++)
1287         if (data[z] != 0)
1288           break;
1289       if (! disassemble_zeroes
1290           && (info->insn_info_valid == 0
1291               || info->branch_delay_insns == 0)
1292           && (z - addr_offset * opb >= SKIP_ZEROES
1293               || (z == stop_offset * opb &&
1294                   z - addr_offset * opb < SKIP_ZEROES_AT_END)))
1295         {
1296           printf ("\t...\n");
1297
1298           /* If there are more nonzero octets to follow, we only skip
1299              zeroes in multiples of 4, to try to avoid running over
1300              the start of an instruction which happens to start with
1301              zero.  */
1302           if (z != stop_offset * opb)
1303             z = addr_offset * opb + ((z - addr_offset * opb) &~ 3);
1304
1305           octets = z - addr_offset * opb;
1306         }
1307       else
1308         {
1309           char buf[50];
1310           int bpc = 0;
1311           int pb = 0;
1312
1313           done_dot = FALSE;
1314
1315           if (with_line_numbers || with_source_code)
1316             /* The line number tables will refer to unadjusted
1317                section VMAs, so we must undo any VMA modifications
1318                when calling show_line.  */
1319             show_line (aux->abfd, section, addr_offset - adjust_section_vma);
1320
1321           if (! prefix_addresses)
1322             {
1323               char *s;
1324
1325               bfd_sprintf_vma (aux->abfd, buf, section->vma + addr_offset);
1326               for (s = buf + skip_addr_chars; *s == '0'; s++)
1327                 *s = ' ';
1328               if (*s == '\0')
1329                 *--s = '0';
1330               printf ("%s:\t", buf + skip_addr_chars);
1331             }
1332           else
1333             {
1334               aux->require_sec = TRUE;
1335               objdump_print_address (section->vma + addr_offset, info);
1336               aux->require_sec = FALSE;
1337               putchar (' ');
1338             }
1339
1340           if (insns)
1341             {
1342               sfile.pos = 0;
1343               info->fprintf_func = (fprintf_ftype) objdump_sprintf;
1344               info->stream = (FILE *) &sfile;
1345               info->bytes_per_line = 0;
1346               info->bytes_per_chunk = 0;
1347
1348 #ifdef DISASSEMBLER_NEEDS_RELOCS
1349               /* FIXME: This is wrong.  It tests the number of octets
1350                  in the last instruction, not the current one.  */
1351               if (*relppp < relppend
1352                   && (**relppp)->address >= rel_offset + addr_offset
1353                   && ((**relppp)->address
1354                       < rel_offset + addr_offset + octets / opb))
1355                 info->flags = INSN_HAS_RELOC;
1356               else
1357 #endif
1358                 info->flags = 0;
1359
1360               octets = (*disassemble_fn) (section->vma + addr_offset, info);
1361               info->fprintf_func = (fprintf_ftype) fprintf;
1362               info->stream = stdout;
1363               if (info->bytes_per_line != 0)
1364                 octets_per_line = info->bytes_per_line;
1365               if (octets < 0)
1366                 {
1367                   if (sfile.pos)
1368                     printf ("%s\n", sfile.buffer);
1369                   break;
1370                 }
1371             }
1372           else
1373             {
1374               bfd_vma j;
1375
1376               octets = octets_per_line;
1377               if (addr_offset + octets / opb > stop_offset)
1378                 octets = (stop_offset - addr_offset) * opb;
1379
1380               for (j = addr_offset * opb; j < addr_offset * opb + octets; ++j)
1381                 {
1382                   if (ISPRINT (data[j]))
1383                     buf[j - addr_offset * opb] = data[j];
1384                   else
1385                     buf[j - addr_offset * opb] = '.';
1386                 }
1387               buf[j - addr_offset * opb] = '\0';
1388             }
1389
1390           if (prefix_addresses
1391               ? show_raw_insn > 0
1392               : show_raw_insn >= 0)
1393             {
1394               bfd_vma j;
1395
1396               /* If ! prefix_addresses and ! wide_output, we print
1397                  octets_per_line octets per line.  */
1398               pb = octets;
1399               if (pb > octets_per_line && ! prefix_addresses && ! wide_output)
1400                 pb = octets_per_line;
1401
1402               if (info->bytes_per_chunk)
1403                 bpc = info->bytes_per_chunk;
1404               else
1405                 bpc = 1;
1406
1407               for (j = addr_offset * opb; j < addr_offset * opb + pb; j += bpc)
1408                 {
1409                   int k;
1410
1411                   if (bpc > 1 && info->display_endian == BFD_ENDIAN_LITTLE)
1412                     {
1413                       for (k = bpc - 1; k >= 0; k--)
1414                         printf ("%02x", (unsigned) data[j + k]);
1415                       putchar (' ');
1416                     }
1417                   else
1418                     {
1419                       for (k = 0; k < bpc; k++)
1420                         printf ("%02x", (unsigned) data[j + k]);
1421                       putchar (' ');
1422                     }
1423                 }
1424
1425               for (; pb < octets_per_line; pb += bpc)
1426                 {
1427                   int k;
1428
1429                   for (k = 0; k < bpc; k++)
1430                     printf ("  ");
1431                   putchar (' ');
1432                 }
1433
1434               /* Separate raw data from instruction by extra space.  */
1435               if (insns)
1436                 putchar ('\t');
1437               else
1438                 printf ("    ");
1439             }
1440
1441           if (! insns)
1442             printf ("%s", buf);
1443           else if (sfile.pos)
1444             printf ("%s", sfile.buffer);
1445
1446           if (prefix_addresses
1447               ? show_raw_insn > 0
1448               : show_raw_insn >= 0)
1449             {
1450               while (pb < octets)
1451                 {
1452                   bfd_vma j;
1453                   char *s;
1454
1455                   putchar ('\n');
1456                   j = addr_offset * opb + pb;
1457
1458                   bfd_sprintf_vma (aux->abfd, buf, section->vma + j / opb);
1459                   for (s = buf + skip_addr_chars; *s == '0'; s++)
1460                     *s = ' ';
1461                   if (*s == '\0')
1462                     *--s = '0';
1463                   printf ("%s:\t", buf + skip_addr_chars);
1464
1465                   pb += octets_per_line;
1466                   if (pb > octets)
1467                     pb = octets;
1468                   for (; j < addr_offset * opb + pb; j += bpc)
1469                     {
1470                       int k;
1471
1472                       if (bpc > 1 && info->display_endian == BFD_ENDIAN_LITTLE)
1473                         {
1474                           for (k = bpc - 1; k >= 0; k--)
1475                             printf ("%02x", (unsigned) data[j + k]);
1476                           putchar (' ');
1477                         }
1478                       else
1479                         {
1480                           for (k = 0; k < bpc; k++)
1481                             printf ("%02x", (unsigned) data[j + k]);
1482                           putchar (' ');
1483                         }
1484                     }
1485                 }
1486             }
1487
1488           if (!wide_output)
1489             putchar ('\n');
1490           else
1491             need_nl = TRUE;
1492         }
1493
1494       while ((*relppp) < relppend
1495              && (**relppp)->address < rel_offset + addr_offset + octets / opb)
1496         {
1497           if (dump_reloc_info || dump_dynamic_reloc_info)
1498             {
1499               arelent *q;
1500
1501               q = **relppp;
1502
1503               if (wide_output)
1504                 putchar ('\t');
1505               else
1506                 printf ("\t\t\t");
1507
1508               objdump_print_value (section->vma - rel_offset + q->address,
1509                                    info, TRUE);
1510
1511               printf (": %s\t", q->howto->name);
1512
1513               if (q->sym_ptr_ptr == NULL || *q->sym_ptr_ptr == NULL)
1514                 printf ("*unknown*");
1515               else
1516                 {
1517                   const char *sym_name;
1518
1519                   sym_name = bfd_asymbol_name (*q->sym_ptr_ptr);
1520                   if (sym_name != NULL && *sym_name != '\0')
1521                     objdump_print_symname (aux->abfd, info, *q->sym_ptr_ptr);
1522                   else
1523                     {
1524                       asection *sym_sec;
1525
1526                       sym_sec = bfd_get_section (*q->sym_ptr_ptr);
1527                       sym_name = bfd_get_section_name (aux->abfd, sym_sec);
1528                       if (sym_name == NULL || *sym_name == '\0')
1529                         sym_name = "*unknown*";
1530                       printf ("%s", sym_name);
1531                     }
1532                 }
1533
1534               if (q->addend)
1535                 {
1536                   printf ("+0x");
1537                   objdump_print_value (q->addend, info, TRUE);
1538                 }
1539
1540               printf ("\n");
1541               need_nl = FALSE;
1542             }
1543           ++(*relppp);
1544         }
1545
1546       if (need_nl)
1547         printf ("\n");
1548
1549       addr_offset += octets / opb;
1550     }
1551
1552   free (sfile.buffer);
1553 }
1554
1555 static void
1556 disassemble_section (bfd *abfd, asection *section, void *info)
1557 {
1558   struct disassemble_info *    pinfo = (struct disassemble_info *) info;
1559   struct objdump_disasm_info * paux;
1560   unsigned int                 opb = pinfo->octets_per_byte;
1561   bfd_byte *                   data = NULL;
1562   bfd_size_type                datasize = 0;
1563   arelent **                   rel_pp = NULL;
1564   arelent **                   rel_ppstart = NULL;
1565   arelent **                   rel_ppend;
1566   unsigned long                stop_offset;
1567   asymbol *                    sym = NULL;
1568   long                         place = 0;
1569   long                         rel_count;
1570   bfd_vma                      rel_offset;
1571   unsigned long                addr_offset;
1572
1573   /* Sections that do not contain machine
1574      code are not normally disassembled.  */
1575   if (! disassemble_all
1576       && only == NULL
1577       && ((section->flags & (SEC_CODE | SEC_HAS_CONTENTS))
1578           != (SEC_CODE | SEC_HAS_CONTENTS)))
1579     return;
1580
1581   if (! process_section_p (section))
1582     return;
1583
1584   datasize = bfd_get_section_size (section);
1585   if (datasize == 0)
1586     return;
1587
1588   /* Decide which set of relocs to use.  Load them if necessary.  */
1589   paux = (struct objdump_disasm_info *) pinfo->application_data;
1590   if (paux->dynrelbuf)
1591     {
1592       rel_pp = paux->dynrelbuf;
1593       rel_count = paux->dynrelcount;
1594       /* Dynamic reloc addresses are absolute, non-dynamic are section
1595          relative.  REL_OFFSET specifies the reloc address corresponding
1596          to the start of this section.  */
1597       rel_offset = section->vma;
1598     }
1599   else
1600     {
1601       rel_count = 0;
1602       rel_pp = NULL;
1603       rel_offset = 0;
1604
1605       if ((section->flags & SEC_RELOC) != 0
1606 #ifndef DISASSEMBLER_NEEDS_RELOCS
1607           && dump_reloc_info
1608 #endif
1609           )
1610         {
1611           long relsize;
1612
1613           relsize = bfd_get_reloc_upper_bound (abfd, section);
1614           if (relsize < 0)
1615             bfd_fatal (bfd_get_filename (abfd));
1616
1617           if (relsize > 0)
1618             {
1619               rel_ppstart = rel_pp = xmalloc (relsize);
1620               rel_count = bfd_canonicalize_reloc (abfd, section, rel_pp, syms);
1621               if (rel_count < 0)
1622                 bfd_fatal (bfd_get_filename (abfd));
1623
1624               /* Sort the relocs by address.  */
1625               qsort (rel_pp, rel_count, sizeof (arelent *), compare_relocs);
1626             }
1627         }
1628
1629     }
1630   rel_ppend = rel_pp + rel_count;
1631
1632   data = xmalloc (datasize);
1633
1634   bfd_get_section_contents (abfd, section, data, 0, datasize);
1635
1636   paux->sec = section;
1637   pinfo->buffer = data;
1638   pinfo->buffer_vma = section->vma;
1639   pinfo->buffer_length = datasize;
1640   pinfo->section = section;
1641
1642   if (start_address == (bfd_vma) -1
1643       || start_address < pinfo->buffer_vma)
1644     addr_offset = 0;
1645   else
1646     addr_offset = start_address - pinfo->buffer_vma;
1647
1648   if (stop_address == (bfd_vma) -1)
1649     stop_offset = datasize / opb;
1650   else
1651     {
1652       if (stop_address < pinfo->buffer_vma)
1653         stop_offset = 0;
1654       else
1655         stop_offset = stop_address - pinfo->buffer_vma;
1656       if (stop_offset > pinfo->buffer_length / opb)
1657         stop_offset = pinfo->buffer_length / opb;
1658     }
1659
1660   /* Skip over the relocs belonging to addresses below the
1661      start address.  */
1662   while (rel_pp < rel_ppend
1663          && (*rel_pp)->address < rel_offset + addr_offset)
1664     ++rel_pp;
1665
1666   printf (_("Disassembly of section %s:\n"), section->name);
1667
1668   /* Find the nearest symbol forwards from our current position.  */
1669   paux->require_sec = TRUE;
1670   sym = find_symbol_for_address (section->vma + addr_offset, info, &place);
1671   paux->require_sec = FALSE;
1672
1673   /* Disassemble a block of instructions up to the address associated with
1674      the symbol we have just found.  Then print the symbol and find the
1675      next symbol on.  Repeat until we have disassembled the entire section
1676      or we have reached the end of the address range we are interested in.  */
1677   while (addr_offset < stop_offset)
1678     {
1679       bfd_vma addr;
1680       asymbol *nextsym;
1681       unsigned long nextstop_offset;
1682       bfd_boolean insns;
1683
1684       addr = section->vma + addr_offset;
1685
1686       if (sym != NULL && bfd_asymbol_value (sym) <= addr)
1687         {
1688           int x;
1689
1690           for (x = place;
1691                (x < sorted_symcount
1692                 && (bfd_asymbol_value (sorted_syms[x]) <= addr));
1693                ++x)
1694             continue;
1695
1696           pinfo->symbols = sorted_syms + place;
1697           pinfo->num_symbols = x - place;
1698         }
1699       else
1700         {
1701           pinfo->symbols = NULL;
1702           pinfo->num_symbols = 0;
1703         }
1704
1705       if (! prefix_addresses)
1706         {
1707           pinfo->fprintf_func (pinfo->stream, "\n");
1708           objdump_print_addr_with_sym (abfd, section, sym, addr,
1709                                        pinfo, FALSE);
1710           pinfo->fprintf_func (pinfo->stream, ":\n");
1711         }
1712
1713       if (sym != NULL && bfd_asymbol_value (sym) > addr)
1714         nextsym = sym;
1715       else if (sym == NULL)
1716         nextsym = NULL;
1717       else
1718         {
1719 #define is_valid_next_sym(SYM) \
1720   ((SYM)->section == section \
1721    && (bfd_asymbol_value (SYM) > bfd_asymbol_value (sym)) \
1722    && pinfo->symbol_is_valid (SYM, pinfo))
1723
1724           /* Search forward for the next appropriate symbol in
1725              SECTION.  Note that all the symbols are sorted
1726              together into one big array, and that some sections
1727              may have overlapping addresses.  */
1728           while (place < sorted_symcount
1729                  && ! is_valid_next_sym (sorted_syms [place]))
1730             ++place;
1731
1732           if (place >= sorted_symcount)
1733             nextsym = NULL;
1734           else
1735             nextsym = sorted_syms[place];
1736         }
1737
1738       if (sym != NULL && bfd_asymbol_value (sym) > addr)
1739         nextstop_offset = bfd_asymbol_value (sym) - section->vma;
1740       else if (nextsym == NULL)
1741         nextstop_offset = stop_offset;
1742       else
1743         nextstop_offset = bfd_asymbol_value (nextsym) - section->vma;
1744
1745       if (nextstop_offset > stop_offset)
1746         nextstop_offset = stop_offset;
1747
1748       /* If a symbol is explicitly marked as being an object
1749          rather than a function, just dump the bytes without
1750          disassembling them.  */
1751       if (disassemble_all
1752           || sym == NULL
1753           || bfd_asymbol_value (sym) > addr
1754           || ((sym->flags & BSF_OBJECT) == 0
1755               && (strstr (bfd_asymbol_name (sym), "gnu_compiled")
1756                   == NULL)
1757               && (strstr (bfd_asymbol_name (sym), "gcc2_compiled")
1758                   == NULL))
1759           || (sym->flags & BSF_FUNCTION) != 0)
1760         insns = TRUE;
1761       else
1762         insns = FALSE;
1763
1764       disassemble_bytes (pinfo, paux->disassemble_fn, insns, data,
1765                          addr_offset, nextstop_offset,
1766                          rel_offset, &rel_pp, rel_ppend);
1767
1768       addr_offset = nextstop_offset;
1769       sym = nextsym;
1770     }
1771
1772   free (data);
1773
1774   if (rel_ppstart != NULL)
1775     free (rel_ppstart);
1776 }
1777
1778 /* Disassemble the contents of an object file.  */
1779
1780 static void
1781 disassemble_data (bfd *abfd)
1782 {
1783   struct disassemble_info disasm_info;
1784   struct objdump_disasm_info aux;
1785   long i;
1786
1787   print_files = NULL;
1788   prev_functionname = NULL;
1789   prev_line = -1;
1790
1791   /* We make a copy of syms to sort.  We don't want to sort syms
1792      because that will screw up the relocs.  */
1793   sorted_symcount = symcount ? symcount : dynsymcount;
1794   sorted_syms = xmalloc ((sorted_symcount + synthcount) * sizeof (asymbol *));
1795   memcpy (sorted_syms, symcount ? syms : dynsyms,
1796           sorted_symcount * sizeof (asymbol *));
1797
1798   sorted_symcount = remove_useless_symbols (sorted_syms, sorted_symcount);
1799
1800   for (i = 0; i < synthcount; ++i)
1801     {
1802       sorted_syms[sorted_symcount] = synthsyms + i;
1803       ++sorted_symcount;
1804     }
1805
1806   /* Sort the symbols into section and symbol order.  */
1807   qsort (sorted_syms, sorted_symcount, sizeof (asymbol *), compare_symbols);
1808
1809   init_disassemble_info (&disasm_info, stdout, (fprintf_ftype) fprintf);
1810
1811   disasm_info.application_data = (void *) &aux;
1812   aux.abfd = abfd;
1813   aux.require_sec = FALSE;
1814   aux.dynrelbuf = NULL;
1815   aux.dynrelcount = 0;
1816
1817   disasm_info.print_address_func = objdump_print_address;
1818   disasm_info.symbol_at_address_func = objdump_symbol_at_address;
1819
1820   if (machine != NULL)
1821     {
1822       const bfd_arch_info_type *info = bfd_scan_arch (machine);
1823
1824       if (info == NULL)
1825         fatal (_("Can't use supplied machine %s"), machine);
1826
1827       abfd->arch_info = info;
1828     }
1829
1830   if (endian != BFD_ENDIAN_UNKNOWN)
1831     {
1832       struct bfd_target *xvec;
1833
1834       xvec = xmalloc (sizeof (struct bfd_target));
1835       memcpy (xvec, abfd->xvec, sizeof (struct bfd_target));
1836       xvec->byteorder = endian;
1837       abfd->xvec = xvec;
1838     }
1839
1840   /* Use libopcodes to locate a suitable disassembler.  */
1841   aux.disassemble_fn = disassembler (abfd);
1842   if (!aux.disassemble_fn)
1843     {
1844       non_fatal (_("Can't disassemble for architecture %s\n"),
1845                  bfd_printable_arch_mach (bfd_get_arch (abfd), 0));
1846       exit_status = 1;
1847       return;
1848     }
1849
1850   disasm_info.flavour = bfd_get_flavour (abfd);
1851   disasm_info.arch = bfd_get_arch (abfd);
1852   disasm_info.mach = bfd_get_mach (abfd);
1853   disasm_info.disassembler_options = disassembler_options;
1854   disasm_info.octets_per_byte = bfd_octets_per_byte (abfd);
1855
1856   if (bfd_big_endian (abfd))
1857     disasm_info.display_endian = disasm_info.endian = BFD_ENDIAN_BIG;
1858   else if (bfd_little_endian (abfd))
1859     disasm_info.display_endian = disasm_info.endian = BFD_ENDIAN_LITTLE;
1860   else
1861     /* ??? Aborting here seems too drastic.  We could default to big or little
1862        instead.  */
1863     disasm_info.endian = BFD_ENDIAN_UNKNOWN;
1864
1865   /* Allow the target to customize the info structure.  */
1866   disassemble_init_for_target (& disasm_info);
1867
1868   /* Pre-load the dynamic relocs if we are going
1869      to be dumping them along with the disassembly.  */
1870   if (dump_dynamic_reloc_info)
1871     {
1872       long relsize = bfd_get_dynamic_reloc_upper_bound (abfd);
1873
1874       if (relsize < 0)
1875         bfd_fatal (bfd_get_filename (abfd));
1876
1877       if (relsize > 0)
1878         {
1879           aux.dynrelbuf = xmalloc (relsize);
1880           aux.dynrelcount = bfd_canonicalize_dynamic_reloc (abfd,
1881                                                             aux.dynrelbuf,
1882                                                             dynsyms);
1883           if (aux.dynrelcount < 0)
1884             bfd_fatal (bfd_get_filename (abfd));
1885
1886           /* Sort the relocs by address.  */
1887           qsort (aux.dynrelbuf, aux.dynrelcount, sizeof (arelent *),
1888                  compare_relocs);
1889         }
1890     }
1891
1892   bfd_map_over_sections (abfd, disassemble_section, & disasm_info);
1893
1894   if (aux.dynrelbuf != NULL)
1895     free (aux.dynrelbuf);
1896   free (sorted_syms);
1897 }
1898 \f
1899 /* Read ABFD's stabs section STABSECT_NAME, and return a pointer to
1900    it.  Return NULL on failure.   */
1901
1902 static char *
1903 read_section_stabs (bfd *abfd, const char *sect_name, bfd_size_type *size_ptr)
1904 {
1905   asection *stabsect;
1906   bfd_size_type size;
1907   char *contents;
1908
1909   stabsect = bfd_get_section_by_name (abfd, sect_name);
1910   if (stabsect == NULL)
1911     {
1912       printf (_("No %s section present\n\n"), sect_name);
1913       return FALSE;
1914     }
1915
1916   size = bfd_section_size (abfd, stabsect);
1917   contents  = xmalloc (size);
1918
1919   if (! bfd_get_section_contents (abfd, stabsect, contents, 0, size))
1920     {
1921       non_fatal (_("Reading %s section of %s failed: %s"),
1922                  sect_name, bfd_get_filename (abfd),
1923                  bfd_errmsg (bfd_get_error ()));
1924       free (contents);
1925       exit_status = 1;
1926       return NULL;
1927     }
1928
1929   *size_ptr = size;
1930
1931   return contents;
1932 }
1933
1934 /* Stabs entries use a 12 byte format:
1935      4 byte string table index
1936      1 byte stab type
1937      1 byte stab other field
1938      2 byte stab desc field
1939      4 byte stab value
1940    FIXME: This will have to change for a 64 bit object format.  */
1941
1942 #define STRDXOFF  (0)
1943 #define TYPEOFF   (4)
1944 #define OTHEROFF  (5)
1945 #define DESCOFF   (6)
1946 #define VALOFF    (8)
1947 #define STABSIZE (12)
1948
1949 /* Print ABFD's stabs section STABSECT_NAME (in `stabs'),
1950    using string table section STRSECT_NAME (in `strtab').  */
1951
1952 static void
1953 print_section_stabs (bfd *abfd,
1954                      const char *stabsect_name,
1955                      unsigned *string_offset_ptr)
1956 {
1957   int i;
1958   unsigned file_string_table_offset = 0;
1959   unsigned next_file_string_table_offset = *string_offset_ptr;
1960   bfd_byte *stabp, *stabs_end;
1961
1962   stabp = stabs;
1963   stabs_end = stabp + stab_size;
1964
1965   printf (_("Contents of %s section:\n\n"), stabsect_name);
1966   printf ("Symnum n_type n_othr n_desc n_value  n_strx String\n");
1967
1968   /* Loop through all symbols and print them.
1969
1970      We start the index at -1 because there is a dummy symbol on
1971      the front of stabs-in-{coff,elf} sections that supplies sizes.  */
1972   for (i = -1; stabp < stabs_end; stabp += STABSIZE, i++)
1973     {
1974       const char *name;
1975       unsigned long strx;
1976       unsigned char type, other;
1977       unsigned short desc;
1978       bfd_vma value;
1979
1980       strx = bfd_h_get_32 (abfd, stabp + STRDXOFF);
1981       type = bfd_h_get_8 (abfd, stabp + TYPEOFF);
1982       other = bfd_h_get_8 (abfd, stabp + OTHEROFF);
1983       desc = bfd_h_get_16 (abfd, stabp + DESCOFF);
1984       value = bfd_h_get_32 (abfd, stabp + VALOFF);
1985
1986       printf ("\n%-6d ", i);
1987       /* Either print the stab name, or, if unnamed, print its number
1988          again (makes consistent formatting for tools like awk).  */
1989       name = bfd_get_stab_name (type);
1990       if (name != NULL)
1991         printf ("%-6s", name);
1992       else if (type == N_UNDF)
1993         printf ("HdrSym");
1994       else
1995         printf ("%-6d", type);
1996       printf (" %-6d %-6d ", other, desc);
1997       bfd_printf_vma (abfd, value);
1998       printf (" %-6lu", strx);
1999
2000       /* Symbols with type == 0 (N_UNDF) specify the length of the
2001          string table associated with this file.  We use that info
2002          to know how to relocate the *next* file's string table indices.  */
2003       if (type == N_UNDF)
2004         {
2005           file_string_table_offset = next_file_string_table_offset;
2006           next_file_string_table_offset += value;
2007         }
2008       else
2009         {
2010           /* Using the (possibly updated) string table offset, print the
2011              string (if any) associated with this symbol.  */
2012           if ((strx + file_string_table_offset) < stabstr_size)
2013             printf (" %s", &strtab[strx + file_string_table_offset]);
2014           else
2015             printf (" *");
2016         }
2017     }
2018   printf ("\n\n");
2019   *string_offset_ptr = next_file_string_table_offset;
2020 }
2021
2022 typedef struct
2023 {
2024   const char * section_name;
2025   const char * string_section_name;
2026   unsigned string_offset;
2027 }
2028 stab_section_names;
2029
2030 static void
2031 find_stabs_section (bfd *abfd, asection *section, void *names)
2032 {
2033   int len;
2034   stab_section_names * sought = (stab_section_names *) names;
2035
2036   /* Check for section names for which stabsect_name is a prefix, to
2037      handle .stab.N, etc.  */
2038   len = strlen (sought->section_name);
2039
2040   /* If the prefix matches, and the files section name ends with a
2041      nul or a digit, then we match.  I.e., we want either an exact
2042      match or a section followed by a number.  */
2043   if (strncmp (sought->section_name, section->name, len) == 0
2044       && (section->name[len] == 0
2045           || (section->name[len] == '.' && ISDIGIT (section->name[len + 1]))))
2046     {
2047       if (strtab == NULL)
2048         strtab = read_section_stabs (abfd, sought->string_section_name,
2049                                      &stabstr_size);
2050
2051       if (strtab)
2052         {
2053           stabs = read_section_stabs (abfd, section->name, &stab_size);
2054           if (stabs)
2055             print_section_stabs (abfd, section->name, &sought->string_offset);
2056         }
2057     }
2058 }
2059
2060 static void
2061 dump_stabs_section (bfd *abfd, char *stabsect_name, char *strsect_name)
2062 {
2063   stab_section_names s;
2064
2065   s.section_name = stabsect_name;
2066   s.string_section_name = strsect_name;
2067   s.string_offset = 0;
2068
2069   bfd_map_over_sections (abfd, find_stabs_section, & s);
2070
2071   free (strtab);
2072   strtab = NULL;
2073 }
2074
2075 /* Dump the any sections containing stabs debugging information.  */
2076
2077 static void
2078 dump_stabs (bfd *abfd)
2079 {
2080   dump_stabs_section (abfd, ".stab", ".stabstr");
2081   dump_stabs_section (abfd, ".stab.excl", ".stab.exclstr");
2082   dump_stabs_section (abfd, ".stab.index", ".stab.indexstr");
2083   dump_stabs_section (abfd, "$GDB_SYMBOLS$", "$GDB_STRINGS$");
2084 }
2085 \f
2086 static void
2087 dump_bfd_header (bfd *abfd)
2088 {
2089   char *comma = "";
2090
2091   printf (_("architecture: %s, "),
2092           bfd_printable_arch_mach (bfd_get_arch (abfd),
2093                                    bfd_get_mach (abfd)));
2094   printf (_("flags 0x%08x:\n"), abfd->flags);
2095
2096 #define PF(x, y)    if (abfd->flags & x) {printf("%s%s", comma, y); comma=", ";}
2097   PF (HAS_RELOC, "HAS_RELOC");
2098   PF (EXEC_P, "EXEC_P");
2099   PF (HAS_LINENO, "HAS_LINENO");
2100   PF (HAS_DEBUG, "HAS_DEBUG");
2101   PF (HAS_SYMS, "HAS_SYMS");
2102   PF (HAS_LOCALS, "HAS_LOCALS");
2103   PF (DYNAMIC, "DYNAMIC");
2104   PF (WP_TEXT, "WP_TEXT");
2105   PF (D_PAGED, "D_PAGED");
2106   PF (BFD_IS_RELAXABLE, "BFD_IS_RELAXABLE");
2107   PF (HAS_LOAD_PAGE, "HAS_LOAD_PAGE");
2108   printf (_("\nstart address 0x"));
2109   bfd_printf_vma (abfd, abfd->start_address);
2110   printf ("\n");
2111 }
2112
2113 \f
2114 static void
2115 dump_bfd_private_header (bfd *abfd)
2116 {
2117   bfd_print_private_bfd_data (abfd, stdout);
2118 }
2119
2120 \f
2121 /* Display a section in hexadecimal format with associated characters.
2122    Each line prefixed by the zero padded address.  */
2123
2124 static void
2125 dump_section (bfd *abfd, asection *section, void *dummy ATTRIBUTE_UNUSED)
2126 {
2127   bfd_byte *data = 0;
2128   bfd_size_type datasize;
2129   bfd_size_type addr_offset;
2130   bfd_size_type start_offset;
2131   bfd_size_type stop_offset;
2132   unsigned int opb = bfd_octets_per_byte (abfd);
2133   /* Bytes per line.  */
2134   const int onaline = 16;
2135   char buf[64];
2136   int count;
2137   int width;
2138
2139   if ((section->flags & SEC_HAS_CONTENTS) == 0)
2140     return;
2141
2142   if (! process_section_p (section))
2143     return;
2144
2145   if ((datasize = bfd_section_size (abfd, section)) == 0)
2146     return;
2147
2148   printf (_("Contents of section %s:\n"), section->name);
2149
2150   data = xmalloc (datasize);
2151
2152   bfd_get_section_contents (abfd, section, data, 0, datasize);
2153
2154   /* Compute the address range to display.  */
2155   if (start_address == (bfd_vma) -1
2156       || start_address < section->vma)
2157     start_offset = 0;
2158   else
2159     start_offset = start_address - section->vma;
2160
2161   if (stop_address == (bfd_vma) -1)
2162     stop_offset = datasize / opb;
2163   else
2164     {
2165       if (stop_address < section->vma)
2166         stop_offset = 0;
2167       else
2168         stop_offset = stop_address - section->vma;
2169
2170       if (stop_offset > datasize / opb)
2171         stop_offset = datasize / opb;
2172     }
2173
2174   width = 4;
2175
2176   bfd_sprintf_vma (abfd, buf, start_offset + section->vma);
2177   if (strlen (buf) >= sizeof (buf))
2178     abort ();
2179
2180   count = 0;
2181   while (buf[count] == '0' && buf[count+1] != '\0')
2182     count++;
2183   count = strlen (buf) - count;
2184   if (count > width)
2185     width = count;
2186
2187   bfd_sprintf_vma (abfd, buf, stop_offset + section->vma - 1);
2188   if (strlen (buf) >= sizeof (buf))
2189     abort ();
2190
2191   count = 0;
2192   while (buf[count] == '0' && buf[count+1] != '\0')
2193     count++;
2194   count = strlen (buf) - count;
2195   if (count > width)
2196     width = count;
2197
2198   for (addr_offset = start_offset;
2199        addr_offset < stop_offset; addr_offset += onaline / opb)
2200     {
2201       bfd_size_type j;
2202
2203       bfd_sprintf_vma (abfd, buf, (addr_offset + section->vma));
2204       count = strlen (buf);
2205       if ((size_t) count >= sizeof (buf))
2206         abort ();
2207
2208       putchar (' ');
2209       while (count < width)
2210         {
2211           putchar ('0');
2212           count++;
2213         }
2214       fputs (buf + count - width, stdout);
2215       putchar (' ');
2216
2217       for (j = addr_offset * opb;
2218            j < addr_offset * opb + onaline; j++)
2219         {
2220           if (j < stop_offset * opb)
2221             printf ("%02x", (unsigned) (data[j]));
2222           else
2223             printf ("  ");
2224           if ((j & 3) == 3)
2225             printf (" ");
2226         }
2227
2228       printf (" ");
2229       for (j = addr_offset * opb;
2230            j < addr_offset * opb + onaline; j++)
2231         {
2232           if (j >= stop_offset * opb)
2233             printf (" ");
2234           else
2235             printf ("%c", ISPRINT (data[j]) ? data[j] : '.');
2236         }
2237       putchar ('\n');
2238     }
2239   free (data);
2240 }
2241
2242 /* Actually display the various requested regions.  */
2243
2244 static void
2245 dump_data (bfd *abfd)
2246 {
2247   bfd_map_over_sections (abfd, dump_section, NULL);
2248 }
2249
2250 /* Should perhaps share code and display with nm?  */
2251
2252 static void
2253 dump_symbols (bfd *abfd ATTRIBUTE_UNUSED, bfd_boolean dynamic)
2254 {
2255   asymbol **current;
2256   long max;
2257   long count;
2258
2259   if (dynamic)
2260     {
2261       current = dynsyms;
2262       max = dynsymcount;
2263       printf ("DYNAMIC SYMBOL TABLE:\n");
2264     }
2265   else
2266     {
2267       current = syms;
2268       max = symcount;
2269       printf ("SYMBOL TABLE:\n");
2270     }
2271
2272   if (max == 0)
2273     printf (_("no symbols\n"));
2274
2275   for (count = 0; count < max; count++)
2276     {
2277       bfd *cur_bfd;
2278
2279       if (*current == NULL)
2280         printf (_("no information for the %ld'th symbol"), count);
2281
2282       else if ((cur_bfd = bfd_asymbol_bfd (*current)) == NULL)
2283         printf (_("could not determine the type of the %ld'th symbol"),
2284                 count);
2285
2286       else
2287         {
2288           const char *name = (*current)->name;
2289
2290           if (do_demangle && name != NULL && *name != '\0')
2291             {
2292               char *alloc;
2293
2294               /* If we want to demangle the name, we demangle it
2295                  here, and temporarily clobber it while calling
2296                  bfd_print_symbol.  FIXME: This is a gross hack.  */
2297               alloc = demangle (cur_bfd, name);
2298               (*current)->name = alloc;
2299               bfd_print_symbol (cur_bfd, stdout, *current,
2300                                 bfd_print_symbol_all);
2301               (*current)->name = name;
2302               free (alloc);
2303             }
2304           else
2305             bfd_print_symbol (cur_bfd, stdout, *current,
2306                               bfd_print_symbol_all);
2307         }
2308
2309       printf ("\n");
2310       current++;
2311     }
2312   printf ("\n\n");
2313 }
2314 \f
2315 static void
2316 dump_reloc_set (bfd *abfd, asection *sec, arelent **relpp, long relcount)
2317 {
2318   arelent **p;
2319   char *last_filename, *last_functionname;
2320   unsigned int last_line;
2321
2322   /* Get column headers lined up reasonably.  */
2323   {
2324     static int width;
2325
2326     if (width == 0)
2327       {
2328         char buf[30];
2329
2330         bfd_sprintf_vma (abfd, buf, (bfd_vma) -1);
2331         width = strlen (buf) - 7;
2332       }
2333     printf ("OFFSET %*s TYPE %*s VALUE \n", width, "", 12, "");
2334   }
2335
2336   last_filename = NULL;
2337   last_functionname = NULL;
2338   last_line = 0;
2339
2340   for (p = relpp; relcount && *p != NULL; p++, relcount--)
2341     {
2342       arelent *q = *p;
2343       const char *filename, *functionname;
2344       unsigned int line;
2345       const char *sym_name;
2346       const char *section_name;
2347
2348       if (start_address != (bfd_vma) -1
2349           && q->address < start_address)
2350         continue;
2351       if (stop_address != (bfd_vma) -1
2352           && q->address > stop_address)
2353         continue;
2354
2355       if (with_line_numbers
2356           && sec != NULL
2357           && bfd_find_nearest_line (abfd, sec, syms, q->address,
2358                                     &filename, &functionname, &line))
2359         {
2360           if (functionname != NULL
2361               && (last_functionname == NULL
2362                   || strcmp (functionname, last_functionname) != 0))
2363             {
2364               printf ("%s():\n", functionname);
2365               if (last_functionname != NULL)
2366                 free (last_functionname);
2367               last_functionname = xstrdup (functionname);
2368             }
2369
2370           if (line > 0
2371               && (line != last_line
2372                   || (filename != NULL
2373                       && last_filename != NULL
2374                       && strcmp (filename, last_filename) != 0)))
2375             {
2376               printf ("%s:%u\n", filename == NULL ? "???" : filename, line);
2377               last_line = line;
2378               if (last_filename != NULL)
2379                 free (last_filename);
2380               if (filename == NULL)
2381                 last_filename = NULL;
2382               else
2383                 last_filename = xstrdup (filename);
2384             }
2385         }
2386
2387       if (q->sym_ptr_ptr && *q->sym_ptr_ptr)
2388         {
2389           sym_name = (*(q->sym_ptr_ptr))->name;
2390           section_name = (*(q->sym_ptr_ptr))->section->name;
2391         }
2392       else
2393         {
2394           sym_name = NULL;
2395           section_name = NULL;
2396         }
2397
2398       if (sym_name)
2399         {
2400           bfd_printf_vma (abfd, q->address);
2401           if (q->howto->name)
2402             printf (" %-16s  ", q->howto->name);
2403           else
2404             printf (" %-16d  ", q->howto->type);
2405           objdump_print_symname (abfd, NULL, *q->sym_ptr_ptr);
2406         }
2407       else
2408         {
2409           if (section_name == NULL)
2410             section_name = "*unknown*";
2411           bfd_printf_vma (abfd, q->address);
2412           printf (" %-16s  [%s]",
2413                   q->howto->name,
2414                   section_name);
2415         }
2416
2417       if (q->addend)
2418         {
2419           printf ("+0x");
2420           bfd_printf_vma (abfd, q->addend);
2421         }
2422
2423       printf ("\n");
2424     }
2425 }
2426
2427 static void
2428 dump_relocs_in_section (bfd *abfd,
2429                         asection *section,
2430                         void *dummy ATTRIBUTE_UNUSED)
2431 {
2432   arelent **relpp;
2433   long relcount;
2434   long relsize;
2435
2436   if (   bfd_is_abs_section (section)
2437       || bfd_is_und_section (section)
2438       || bfd_is_com_section (section)
2439       || (! process_section_p (section))
2440       || ((section->flags & SEC_RELOC) == 0))
2441     return;
2442
2443   relsize = bfd_get_reloc_upper_bound (abfd, section);
2444   if (relsize < 0)
2445     bfd_fatal (bfd_get_filename (abfd));
2446
2447   printf ("RELOCATION RECORDS FOR [%s]:", section->name);
2448
2449   if (relsize == 0)
2450     {
2451       printf (" (none)\n\n");
2452       return;
2453     }
2454
2455   relpp = xmalloc (relsize);
2456   relcount = bfd_canonicalize_reloc (abfd, section, relpp, syms);
2457
2458   if (relcount < 0)
2459     bfd_fatal (bfd_get_filename (abfd));
2460   else if (relcount == 0)
2461     printf (" (none)\n\n");
2462   else
2463     {
2464       printf ("\n");
2465       dump_reloc_set (abfd, section, relpp, relcount);
2466       printf ("\n\n");
2467     }
2468   free (relpp);
2469 }
2470
2471 static void
2472 dump_relocs (bfd *abfd)
2473 {
2474   bfd_map_over_sections (abfd, dump_relocs_in_section, NULL);
2475 }
2476
2477 static void
2478 dump_dynamic_relocs (bfd *abfd)
2479 {
2480   long relsize;
2481   arelent **relpp;
2482   long relcount;
2483
2484   relsize = bfd_get_dynamic_reloc_upper_bound (abfd);
2485   if (relsize < 0)
2486     bfd_fatal (bfd_get_filename (abfd));
2487
2488   printf ("DYNAMIC RELOCATION RECORDS");
2489
2490   if (relsize == 0)
2491     printf (" (none)\n\n");
2492   else
2493     {
2494       relpp = xmalloc (relsize);
2495       relcount = bfd_canonicalize_dynamic_reloc (abfd, relpp, dynsyms);
2496
2497       if (relcount < 0)
2498         bfd_fatal (bfd_get_filename (abfd));
2499       else if (relcount == 0)
2500         printf (" (none)\n\n");
2501       else
2502         {
2503           printf ("\n");
2504           dump_reloc_set (abfd, NULL, relpp, relcount);
2505           printf ("\n\n");
2506         }
2507       free (relpp);
2508     }
2509 }
2510
2511 /* Creates a table of paths, to search for source files.  */
2512
2513 static void
2514 add_include_path (const char *path)
2515 {
2516   if (path[0] == 0)
2517     return;
2518   include_path_count++;
2519   include_paths = xrealloc (include_paths,
2520                             include_path_count * sizeof (*include_paths));
2521 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
2522   if (path[1] == ':' && path[2] == 0)
2523     path = concat (path, ".", (const char *) 0);
2524 #endif
2525   include_paths[include_path_count - 1] = path;
2526 }
2527
2528 static void
2529 adjust_addresses (bfd *abfd ATTRIBUTE_UNUSED,
2530                   asection *section,
2531                   void *dummy ATTRIBUTE_UNUSED)
2532 {
2533   section->vma += adjust_section_vma;
2534   section->lma += adjust_section_vma;
2535 }
2536
2537 /* Dump selected contents of ABFD.  */
2538
2539 static void
2540 dump_bfd (bfd *abfd)
2541 {
2542   /* If we are adjusting section VMA's, change them all now.  Changing
2543      the BFD information is a hack.  However, we must do it, or
2544      bfd_find_nearest_line will not do the right thing.  */
2545   if (adjust_section_vma != 0)
2546     bfd_map_over_sections (abfd, adjust_addresses, NULL);
2547
2548   if (! dump_debugging_tags)
2549     printf (_("\n%s:     file format %s\n"), bfd_get_filename (abfd),
2550             abfd->xvec->name);
2551   if (dump_ar_hdrs)
2552     print_arelt_descr (stdout, abfd, TRUE);
2553   if (dump_file_header)
2554     dump_bfd_header (abfd);
2555   if (dump_private_headers)
2556     dump_bfd_private_header (abfd);
2557   if (! dump_debugging_tags)
2558     putchar ('\n');
2559   if (dump_section_headers)
2560     dump_headers (abfd);
2561
2562   if (dump_symtab || dump_reloc_info || disassemble || dump_debugging)
2563     syms = slurp_symtab (abfd);
2564   if (dump_dynamic_symtab || dump_dynamic_reloc_info
2565       || (disassemble && bfd_get_dynamic_symtab_upper_bound (abfd) > 0))
2566     dynsyms = slurp_dynamic_symtab (abfd);
2567   if (disassemble)
2568     {
2569       synthcount = 0;
2570       if (bfd_get_file_flags (abfd) & (DYNAMIC | EXEC_P))
2571         {
2572           if (dynsymcount > 0)
2573             synthcount = bfd_get_synthetic_symtab (abfd, dynsyms, &synthsyms);
2574         }
2575       else
2576         {
2577           if (symcount > 0)
2578             synthcount = bfd_get_synthetic_symtab (abfd, syms, &synthsyms);
2579         }
2580       if (synthcount < 0) synthcount = 0;
2581     }
2582
2583   if (dump_symtab)
2584     dump_symbols (abfd, FALSE);
2585   if (dump_dynamic_symtab)
2586     dump_symbols (abfd, TRUE);
2587   if (dump_stab_section_info)
2588     dump_stabs (abfd);
2589   if (dump_reloc_info && ! disassemble)
2590     dump_relocs (abfd);
2591   if (dump_dynamic_reloc_info && ! disassemble)
2592     dump_dynamic_relocs (abfd);
2593   if (dump_section_contents)
2594     dump_data (abfd);
2595   if (disassemble)
2596     disassemble_data (abfd);
2597
2598   if (dump_debugging)
2599     {
2600       void *dhandle;
2601
2602       dhandle = read_debugging_info (abfd, syms, symcount);
2603       if (dhandle != NULL)
2604         {
2605           if (! print_debugging_info (stdout, dhandle, abfd, syms, demangle,
2606               dump_debugging_tags ? TRUE : FALSE))
2607             {
2608               non_fatal (_("%s: printing debugging information failed"),
2609                          bfd_get_filename (abfd));
2610               exit_status = 1;
2611             }
2612         }
2613     }
2614
2615   if (syms)
2616     {
2617       free (syms);
2618       syms = NULL;
2619     }
2620
2621   if (dynsyms)
2622     {
2623       free (dynsyms);
2624       dynsyms = NULL;
2625     }
2626
2627   if (synthsyms)
2628     {
2629       free (synthsyms);
2630       synthsyms = NULL;
2631     }
2632
2633   symcount = 0;
2634   dynsymcount = 0;
2635   synthcount = 0;
2636 }
2637
2638 static void
2639 display_bfd (bfd *abfd)
2640 {
2641   char **matching;
2642
2643   if (bfd_check_format_matches (abfd, bfd_object, &matching))
2644     {
2645       dump_bfd (abfd);
2646       return;
2647     }
2648
2649   if (bfd_get_error () == bfd_error_file_ambiguously_recognized)
2650     {
2651       nonfatal (bfd_get_filename (abfd));
2652       list_matching_formats (matching);
2653       free (matching);
2654       return;
2655     }
2656
2657   if (bfd_get_error () != bfd_error_file_not_recognized)
2658     {
2659       nonfatal (bfd_get_filename (abfd));
2660       return;
2661     }
2662
2663   if (bfd_check_format_matches (abfd, bfd_core, &matching))
2664     {
2665       dump_bfd (abfd);
2666       return;
2667     }
2668
2669   nonfatal (bfd_get_filename (abfd));
2670
2671   if (bfd_get_error () == bfd_error_file_ambiguously_recognized)
2672     {
2673       list_matching_formats (matching);
2674       free (matching);
2675     }
2676 }
2677
2678 static void
2679 display_file (char *filename, char *target)
2680 {
2681   bfd *file;
2682   bfd *arfile = NULL;
2683
2684   if (get_file_size (filename) < 1)
2685     return;
2686
2687   file = bfd_openr (filename, target);
2688   if (file == NULL)
2689     {
2690       nonfatal (filename);
2691       return;
2692     }
2693
2694   /* If the file is an archive, process all of its elements.  */
2695   if (bfd_check_format (file, bfd_archive))
2696     {
2697       bfd *last_arfile = NULL;
2698
2699       printf (_("In archive %s:\n"), bfd_get_filename (file));
2700       for (;;)
2701         {
2702           bfd_set_error (bfd_error_no_error);
2703
2704           arfile = bfd_openr_next_archived_file (file, arfile);
2705           if (arfile == NULL)
2706             {
2707               if (bfd_get_error () != bfd_error_no_more_archived_files)
2708                 nonfatal (bfd_get_filename (file));
2709               break;
2710             }
2711
2712           display_bfd (arfile);
2713
2714           if (last_arfile != NULL)
2715             bfd_close (last_arfile);
2716           last_arfile = arfile;
2717         }
2718
2719       if (last_arfile != NULL)
2720         bfd_close (last_arfile);
2721     }
2722   else
2723     display_bfd (file);
2724
2725   bfd_close (file);
2726 }
2727 \f
2728 int
2729 main (int argc, char **argv)
2730 {
2731   int c;
2732   char *target = default_target;
2733   bfd_boolean seenflag = FALSE;
2734
2735 #if defined (HAVE_SETLOCALE)
2736 #if defined (HAVE_LC_MESSAGES)
2737   setlocale (LC_MESSAGES, "");
2738 #endif
2739   setlocale (LC_CTYPE, "");
2740 #endif
2741
2742   bindtextdomain (PACKAGE, LOCALEDIR);
2743   textdomain (PACKAGE);
2744
2745   program_name = *argv;
2746   xmalloc_set_program_name (program_name);
2747
2748   START_PROGRESS (program_name, 0);
2749
2750   bfd_init ();
2751   set_default_bfd_target ();
2752
2753   while ((c = getopt_long (argc, argv, "pib:m:M:VvCdDlfaHhrRtTxsSI:j:wE:zgeG",
2754                            long_options, (int *) 0))
2755          != EOF)
2756     {
2757       switch (c)
2758         {
2759         case 0:
2760           break;                /* We've been given a long option.  */
2761         case 'm':
2762           machine = optarg;
2763           break;
2764         case 'M':
2765           if (disassembler_options)
2766             /* Ignore potential memory leak for now.  */
2767             disassembler_options = concat (disassembler_options, ",",
2768                                            optarg, NULL);
2769           else
2770             disassembler_options = optarg;
2771           break;
2772         case 'j':
2773           if (only_used == only_size)
2774             {
2775               only_size += 8;
2776               only = xrealloc (only, only_size * sizeof (char *));
2777             }
2778           only [only_used++] = optarg;
2779           break;
2780         case 'l':
2781           with_line_numbers = TRUE;
2782           break;
2783         case 'b':
2784           target = optarg;
2785           break;
2786         case 'C':
2787           do_demangle = TRUE;
2788           if (optarg != NULL)
2789             {
2790               enum demangling_styles style;
2791
2792               style = cplus_demangle_name_to_style (optarg);
2793               if (style == unknown_demangling)
2794                 fatal (_("unknown demangling style `%s'"),
2795                        optarg);
2796
2797               cplus_demangle_set_style (style);
2798             }
2799           break;
2800         case 'w':
2801           wide_output = TRUE;
2802           break;
2803         case OPTION_ADJUST_VMA:
2804           adjust_section_vma = parse_vma (optarg, "--adjust-vma");
2805           break;
2806         case OPTION_START_ADDRESS:
2807           start_address = parse_vma (optarg, "--start-address");
2808           break;
2809         case OPTION_STOP_ADDRESS:
2810           stop_address = parse_vma (optarg, "--stop-address");
2811           break;
2812         case 'E':
2813           if (strcmp (optarg, "B") == 0)
2814             endian = BFD_ENDIAN_BIG;
2815           else if (strcmp (optarg, "L") == 0)
2816             endian = BFD_ENDIAN_LITTLE;
2817           else
2818             {
2819               non_fatal (_("unrecognized -E option"));
2820               usage (stderr, 1);
2821             }
2822           break;
2823         case OPTION_ENDIAN:
2824           if (strncmp (optarg, "big", strlen (optarg)) == 0)
2825             endian = BFD_ENDIAN_BIG;
2826           else if (strncmp (optarg, "little", strlen (optarg)) == 0)
2827             endian = BFD_ENDIAN_LITTLE;
2828           else
2829             {
2830               non_fatal (_("unrecognized --endian type `%s'"), optarg);
2831               usage (stderr, 1);
2832             }
2833           break;
2834
2835         case 'f':
2836           dump_file_header = TRUE;
2837           seenflag = TRUE;
2838           break;
2839         case 'i':
2840           formats_info = TRUE;
2841           seenflag = TRUE;
2842           break;
2843         case 'I':
2844           add_include_path (optarg);
2845           break;
2846         case 'p':
2847           dump_private_headers = TRUE;
2848           seenflag = TRUE;
2849           break;
2850         case 'x':
2851           dump_private_headers = TRUE;
2852           dump_symtab = TRUE;
2853           dump_reloc_info = TRUE;
2854           dump_file_header = TRUE;
2855           dump_ar_hdrs = TRUE;
2856           dump_section_headers = TRUE;
2857           seenflag = TRUE;
2858           break;
2859         case 't':
2860           dump_symtab = TRUE;
2861           seenflag = TRUE;
2862           break;
2863         case 'T':
2864           dump_dynamic_symtab = TRUE;
2865           seenflag = TRUE;
2866           break;
2867         case 'd':
2868           disassemble = TRUE;
2869           seenflag = TRUE;
2870           break;
2871         case 'z':
2872           disassemble_zeroes = TRUE;
2873           break;
2874         case 'D':
2875           disassemble = TRUE;
2876           disassemble_all = TRUE;
2877           seenflag = TRUE;
2878           break;
2879         case 'S':
2880           disassemble = TRUE;
2881           with_source_code = TRUE;
2882           seenflag = TRUE;
2883           break;
2884         case 'g':
2885           dump_debugging = 1;
2886           seenflag = TRUE;
2887           break;
2888         case 'e':
2889           dump_debugging = 1;
2890           dump_debugging_tags = 1;
2891           do_demangle = TRUE;
2892           seenflag = TRUE;
2893           break;
2894         case 'G':
2895           dump_stab_section_info = TRUE;
2896           seenflag = TRUE;
2897           break;
2898         case 's':
2899           dump_section_contents = TRUE;
2900           seenflag = TRUE;
2901           break;
2902         case 'r':
2903           dump_reloc_info = TRUE;
2904           seenflag = TRUE;
2905           break;
2906         case 'R':
2907           dump_dynamic_reloc_info = TRUE;
2908           seenflag = TRUE;
2909           break;
2910         case 'a':
2911           dump_ar_hdrs = TRUE;
2912           seenflag = TRUE;
2913           break;
2914         case 'h':
2915           dump_section_headers = TRUE;
2916           seenflag = TRUE;
2917           break;
2918         case 'H':
2919           usage (stdout, 0);
2920           seenflag = TRUE;
2921         case 'v':
2922         case 'V':
2923           show_version = TRUE;
2924           seenflag = TRUE;
2925           break;
2926
2927         default:
2928           usage (stderr, 1);
2929         }
2930     }
2931
2932   if (show_version)
2933     print_version ("objdump");
2934
2935   if (!seenflag)
2936     usage (stderr, 2);
2937
2938   if (formats_info)
2939     exit_status = display_info ();
2940   else
2941     {
2942       if (optind == argc)
2943         display_file ("a.out", target);
2944       else
2945         for (; optind < argc;)
2946           display_file (argv[optind++], target);
2947     }
2948
2949   END_PROGRESS (program_name);
2950
2951   return exit_status;
2952 }