binutils/objdump.c

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