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