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