binutils/objdump.c

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