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       if (start_address == (bfd_vma) -1
1740           || start_address < disasm_info.buffer_vma)
1741         addr_offset = 0;
1742       else
1743         addr_offset = start_address - disasm_info.buffer_vma;
1744       if (stop_address == (bfd_vma) -1)
1745         stop_offset = datasize / opb;
1746       else
1747         {
1748           if (stop_address < disasm_info.buffer_vma)
1749             stop_offset = 0;
1750           else
1751             stop_offset = stop_address - disasm_info.buffer_vma;
1752           if (stop_offset > disasm_info.buffer_length / opb)
1753             stop_offset = disasm_info.buffer_length / opb;
1754         }
1755
1756       sym = find_symbol_for_address (abfd, section, section->vma + addr_offset,
1757                                      true, &place);
1758
1759       while (addr_offset < stop_offset)
1760         {
1761           asymbol *nextsym;
1762           unsigned long nextstop_offset;
1763           boolean insns;
1764
1765           if (sym != NULL && bfd_asymbol_value (sym) <= section->vma + addr_offset)
1766             {
1767               int x;
1768
1769               for (x = place;
1770                    (x < sorted_symcount
1771                     && bfd_asymbol_value (sorted_syms[x]) <= section->vma + addr_offset);
1772                    ++x)
1773                 continue;
1774               disasm_info.symbols = & sorted_syms[place];
1775               disasm_info.num_symbols = x - place;
1776             }
1777           else
1778             disasm_info.symbols = NULL;
1779
1780           if (! prefix_addresses)
1781             {
1782               printf ("\n");
1783               objdump_print_addr_with_sym (abfd, section, sym,
1784                                            section->vma + addr_offset,
1785                                            &disasm_info,
1786                                            false);
1787               printf (":\n");
1788             }
1789
1790           if (sym != NULL && bfd_asymbol_value (sym) > section->vma + addr_offset)
1791             nextsym = sym;
1792           else if (sym == NULL)
1793             nextsym = NULL;
1794           else
1795             {
1796               /* Search forward for the next appropriate symbol in
1797                  SECTION.  Note that all the symbols are sorted
1798                  together into one big array, and that some sections
1799                  may have overlapping addresses.  */
1800               while (place < sorted_symcount
1801                      && (sorted_syms[place]->section != section
1802                          || (bfd_asymbol_value (sorted_syms[place])
1803                              <= bfd_asymbol_value (sym))))
1804                 ++place;
1805               if (place >= sorted_symcount)
1806                 nextsym = NULL;
1807               else
1808                 nextsym = sorted_syms[place];
1809             }
1810
1811           if (sym != NULL && bfd_asymbol_value (sym) > section->vma + addr_offset)
1812             {
1813               nextstop_offset = bfd_asymbol_value (sym) - section->vma;
1814               if (nextstop_offset > stop_offset)
1815                 nextstop_offset = stop_offset;
1816             }
1817           else if (nextsym == NULL)
1818             nextstop_offset = stop_offset;
1819           else
1820             {
1821               nextstop_offset = bfd_asymbol_value (nextsym) - section->vma;
1822               if (nextstop_offset > stop_offset)
1823                 nextstop_offset = stop_offset;
1824             }
1825
1826           /* If a symbol is explicitly marked as being an object
1827              rather than a function, just dump the bytes without
1828              disassembling them.  */
1829           if (disassemble_all
1830               || sym == NULL
1831               || bfd_asymbol_value (sym) > section->vma + addr_offset
1832               || ((sym->flags & BSF_OBJECT) == 0
1833                   && (strstr (bfd_asymbol_name (sym), "gnu_compiled")
1834                       == NULL)
1835                   && (strstr (bfd_asymbol_name (sym), "gcc2_compiled")
1836                       == NULL))
1837               || (sym->flags & BSF_FUNCTION) != 0)
1838             insns = true;
1839           else
1840             insns = false;
1841
1842           disassemble_bytes (&disasm_info, disassemble_fn, insns, data,
1843                              addr_offset, nextstop_offset, &relpp, relppend);
1844
1845           addr_offset = nextstop_offset;
1846           sym = nextsym;
1847         }
1848
1849       free (data);
1850       if (relbuf != NULL)
1851         free (relbuf);
1852     }
1853   free (sorted_syms);
1854 }
1855 \f
1856
1857 /* Define a table of stab values and print-strings.  We wish the initializer
1858    could be a direct-mapped table, but instead we build one the first
1859    time we need it.  */
1860
1861 static void dump_section_stabs PARAMS ((bfd *abfd, char *stabsect_name,
1862                                         char *strsect_name));
1863
1864 /* Dump the stabs sections from an object file that has a section that
1865    uses Sun stabs encoding.  */
1866
1867 static void
1868 dump_stabs (abfd)
1869      bfd *abfd;
1870 {
1871   dump_section_stabs (abfd, ".stab", ".stabstr");
1872   dump_section_stabs (abfd, ".stab.excl", ".stab.exclstr");
1873   dump_section_stabs (abfd, ".stab.index", ".stab.indexstr");
1874   dump_section_stabs (abfd, "$GDB_SYMBOLS$", "$GDB_STRINGS$");
1875 }
1876
1877 static bfd_byte *stabs;
1878 static bfd_size_type stab_size;
1879
1880 static char *strtab;
1881 static bfd_size_type stabstr_size;
1882
1883 /* Read ABFD's stabs section STABSECT_NAME into `stabs'
1884    and string table section STRSECT_NAME into `strtab'.
1885    If the section exists and was read, allocate the space and return true.
1886    Otherwise return false.  */
1887
1888 static boolean
1889 read_section_stabs (abfd, stabsect_name, strsect_name)
1890      bfd *abfd;
1891      const char *stabsect_name;
1892      const char *strsect_name;
1893 {
1894   asection *stabsect, *stabstrsect;
1895
1896   stabsect = bfd_get_section_by_name (abfd, stabsect_name);
1897   if (0 == stabsect)
1898     {
1899       printf (_("No %s section present\n\n"), stabsect_name);
1900       return false;
1901     }
1902
1903   stabstrsect = bfd_get_section_by_name (abfd, strsect_name);
1904   if (0 == stabstrsect)
1905     {
1906       non_fatal (_("%s has no %s section"),
1907                  bfd_get_filename (abfd), strsect_name);
1908       exit_status = 1;
1909       return false;
1910     }
1911
1912   stab_size    = bfd_section_size (abfd, stabsect);
1913   stabstr_size = bfd_section_size (abfd, stabstrsect);
1914
1915   stabs  = (bfd_byte *) xmalloc (stab_size);
1916   strtab = (char *) xmalloc (stabstr_size);
1917
1918   if (! bfd_get_section_contents (abfd, stabsect, (PTR) stabs, 0, stab_size))
1919     {
1920       non_fatal (_("Reading %s section of %s failed: %s"),
1921                  stabsect_name, bfd_get_filename (abfd),
1922                  bfd_errmsg (bfd_get_error ()));
1923       free (stabs);
1924       free (strtab);
1925       exit_status = 1;
1926       return false;
1927     }
1928
1929   if (! bfd_get_section_contents (abfd, stabstrsect, (PTR) strtab, 0,
1930                                   stabstr_size))
1931     {
1932       non_fatal (_("Reading %s section of %s failed: %s\n"),
1933                  strsect_name, bfd_get_filename (abfd),
1934                  bfd_errmsg (bfd_get_error ()));
1935       free (stabs);
1936       free (strtab);
1937       exit_status = 1;
1938       return false;
1939     }
1940
1941   return true;
1942 }
1943
1944 /* Stabs entries use a 12 byte format:
1945      4 byte string table index
1946      1 byte stab type
1947      1 byte stab other field
1948      2 byte stab desc field
1949      4 byte stab value
1950    FIXME: This will have to change for a 64 bit object format.  */
1951
1952 #define STRDXOFF (0)
1953 #define TYPEOFF (4)
1954 #define OTHEROFF (5)
1955 #define DESCOFF (6)
1956 #define VALOFF (8)
1957 #define STABSIZE (12)
1958
1959 /* Print ABFD's stabs section STABSECT_NAME (in `stabs'),
1960    using string table section STRSECT_NAME (in `strtab').  */
1961
1962 static void
1963 print_section_stabs (abfd, stabsect_name, strsect_name)
1964      bfd *abfd;
1965      const char *stabsect_name;
1966      const char *strsect_name ATTRIBUTE_UNUSED;
1967 {
1968   int i;
1969   unsigned file_string_table_offset = 0, next_file_string_table_offset = 0;
1970   bfd_byte *stabp, *stabs_end;
1971
1972   stabp = stabs;
1973   stabs_end = stabp + stab_size;
1974
1975   printf (_("Contents of %s section:\n\n"), stabsect_name);
1976   printf ("Symnum n_type n_othr n_desc n_value  n_strx String\n");
1977
1978   /* Loop through all symbols and print them.
1979
1980      We start the index at -1 because there is a dummy symbol on
1981      the front of stabs-in-{coff,elf} sections that supplies sizes.  */
1982
1983   for (i = -1; stabp < stabs_end; stabp += STABSIZE, i++)
1984     {
1985       const char *name;
1986       unsigned long strx;
1987       unsigned char type, other;
1988       unsigned short desc;
1989       bfd_vma value;
1990
1991       strx = bfd_h_get_32 (abfd, stabp + STRDXOFF);
1992       type = bfd_h_get_8 (abfd, stabp + TYPEOFF);
1993       other = bfd_h_get_8 (abfd, stabp + OTHEROFF);
1994       desc = bfd_h_get_16 (abfd, stabp + DESCOFF);
1995       value = bfd_h_get_32 (abfd, stabp + VALOFF);
1996
1997       printf ("\n%-6d ", i);
1998       /* Either print the stab name, or, if unnamed, print its number
1999          again (makes consistent formatting for tools like awk). */
2000       name = bfd_get_stab_name (type);
2001       if (name != NULL)
2002         printf ("%-6s", name);
2003       else if (type == N_UNDF)
2004         printf ("HdrSym");
2005       else
2006         printf ("%-6d", type);
2007       printf (" %-6d %-6d ", other, desc);
2008       printf_vma (value);
2009       printf (" %-6lu", strx);
2010
2011       /* Symbols with type == 0 (N_UNDF) specify the length of the
2012          string table associated with this file.  We use that info
2013          to know how to relocate the *next* file's string table indices.  */
2014
2015       if (type == N_UNDF)
2016         {
2017           file_string_table_offset = next_file_string_table_offset;
2018           next_file_string_table_offset += value;
2019         }
2020       else
2021         {
2022           /* Using the (possibly updated) string table offset, print the
2023              string (if any) associated with this symbol.  */
2024
2025           if ((strx + file_string_table_offset) < stabstr_size)
2026             printf (" %s", &strtab[strx + file_string_table_offset]);
2027           else
2028             printf (" *");
2029         }
2030     }
2031   printf ("\n\n");
2032 }
2033
2034 static void
2035 dump_section_stabs (abfd, stabsect_name, strsect_name)
2036      bfd *abfd;
2037      char *stabsect_name;
2038      char *strsect_name;
2039 {
2040   asection *s;
2041
2042   /* Check for section names for which stabsect_name is a prefix, to
2043      handle .stab0, etc.  */
2044   for (s = abfd->sections;
2045        s != NULL;
2046        s = s->next)
2047     {
2048       int len;
2049
2050       len = strlen (stabsect_name);
2051
2052       /* If the prefix matches, and the files section name ends with a
2053          nul or a digit, then we match.  I.e., we want either an exact
2054          match or a section followed by a number.  */
2055       if (strncmp (stabsect_name, s->name, len) == 0
2056           && (s->name[len] == '\000'
2057               || isdigit ((unsigned char) s->name[len])))
2058         {
2059           if (read_section_stabs (abfd, s->name, strsect_name))
2060             {
2061               print_section_stabs (abfd, s->name, strsect_name);
2062               free (stabs);
2063               free (strtab);
2064             }
2065         }
2066     }
2067 }
2068 \f
2069 static void
2070 dump_bfd_header (abfd)
2071      bfd *abfd;
2072 {
2073   char *comma = "";
2074
2075   printf (_("architecture: %s, "),
2076           bfd_printable_arch_mach (bfd_get_arch (abfd),
2077                                    bfd_get_mach (abfd)));
2078   printf (_("flags 0x%08x:\n"), abfd->flags);
2079
2080 #define PF(x, y)    if (abfd->flags & x) {printf("%s%s", comma, y); comma=", ";}
2081   PF (HAS_RELOC, "HAS_RELOC");
2082   PF (EXEC_P, "EXEC_P");
2083   PF (HAS_LINENO, "HAS_LINENO");
2084   PF (HAS_DEBUG, "HAS_DEBUG");
2085   PF (HAS_SYMS, "HAS_SYMS");
2086   PF (HAS_LOCALS, "HAS_LOCALS");
2087   PF (DYNAMIC, "DYNAMIC");
2088   PF (WP_TEXT, "WP_TEXT");
2089   PF (D_PAGED, "D_PAGED");
2090   PF (BFD_IS_RELAXABLE, "BFD_IS_RELAXABLE");
2091   printf (_("\nstart address 0x"));
2092   printf_vma (abfd->start_address);
2093   printf ("\n");
2094 }
2095 \f
2096 static void
2097 dump_bfd_private_header (abfd)
2098 bfd *abfd;
2099 {
2100   bfd_print_private_bfd_data (abfd, stdout);
2101 }
2102
2103 /* Dump selected contents of ABFD */
2104
2105 static void
2106 dump_bfd (abfd)
2107      bfd *abfd;
2108 {
2109   /* If we are adjusting section VMA's, change them all now.  Changing
2110      the BFD information is a hack.  However, we must do it, or
2111      bfd_find_nearest_line will not do the right thing.  */
2112   if (adjust_section_vma != 0)
2113     {
2114       asection *s;
2115
2116       for (s = abfd->sections; s != NULL; s = s->next)
2117         {
2118           s->vma += adjust_section_vma;
2119           s->lma += adjust_section_vma;
2120         }
2121     }
2122
2123   printf (_("\n%s:     file format %s\n"), bfd_get_filename (abfd),
2124           abfd->xvec->name);
2125   if (dump_ar_hdrs)
2126     print_arelt_descr (stdout, abfd, true);
2127   if (dump_file_header)
2128     dump_bfd_header (abfd);
2129   if (dump_private_headers)
2130     dump_bfd_private_header (abfd);
2131   putchar ('\n');
2132   if (dump_section_headers)
2133     dump_headers (abfd);
2134   if (dump_symtab || dump_reloc_info || disassemble || dump_debugging)
2135     {
2136       syms = slurp_symtab (abfd);
2137     }
2138   if (dump_dynamic_symtab || dump_dynamic_reloc_info)
2139     {
2140       dynsyms = slurp_dynamic_symtab (abfd);
2141     }
2142   if (dump_symtab)
2143     dump_symbols (abfd, false);
2144   if (dump_dynamic_symtab)
2145     dump_symbols (abfd, true);
2146   if (dump_stab_section_info)
2147     dump_stabs (abfd);
2148   if (dump_reloc_info && ! disassemble)
2149     dump_relocs (abfd);
2150   if (dump_dynamic_reloc_info)
2151     dump_dynamic_relocs (abfd);
2152   if (dump_section_contents)
2153     dump_data (abfd);
2154   if (disassemble)
2155     disassemble_data (abfd);
2156   if (dump_debugging)
2157     {
2158       PTR dhandle;
2159
2160       dhandle = read_debugging_info (abfd, syms, symcount);
2161       if (dhandle != NULL)
2162         {
2163           if (! print_debugging_info (stdout, dhandle))
2164             {
2165               non_fatal (_("%s: printing debugging information failed"),
2166                          bfd_get_filename (abfd));
2167               exit_status = 1;
2168             }
2169         }
2170     }
2171   if (syms)
2172     {
2173       free (syms);
2174       syms = NULL;
2175     }
2176   if (dynsyms)
2177     {
2178       free (dynsyms);
2179       dynsyms = NULL;
2180     }
2181 }
2182
2183 static void
2184 display_bfd (abfd)
2185      bfd *abfd;
2186 {
2187   char **matching;
2188
2189   if (bfd_check_format_matches (abfd, bfd_object, &matching))
2190     {
2191       dump_bfd (abfd);
2192       return;
2193     }
2194
2195   if (bfd_get_error () == bfd_error_file_ambiguously_recognized)
2196     {
2197       nonfatal (bfd_get_filename (abfd));
2198       list_matching_formats (matching);
2199       free (matching);
2200       return;
2201     }
2202
2203   if (bfd_get_error () != bfd_error_file_not_recognized)
2204     {
2205       nonfatal (bfd_get_filename (abfd));
2206       return;
2207     }
2208
2209   if (bfd_check_format_matches (abfd, bfd_core, &matching))
2210     {
2211       dump_bfd (abfd);
2212       return;
2213     }
2214
2215   nonfatal (bfd_get_filename (abfd));
2216
2217   if (bfd_get_error () == bfd_error_file_ambiguously_recognized)
2218     {
2219       list_matching_formats (matching);
2220       free (matching);
2221     }
2222 }
2223
2224 static void
2225 display_file (filename, target)
2226      char *filename;
2227      char *target;
2228 {
2229   bfd *file, *arfile = (bfd *) NULL;
2230
2231   file = bfd_openr (filename, target);
2232   if (file == NULL)
2233     {
2234       nonfatal (filename);
2235       return;
2236     }
2237
2238   if (bfd_check_format (file, bfd_archive) == true)
2239     {
2240       bfd *last_arfile = NULL;
2241
2242       printf (_("In archive %s:\n"), bfd_get_filename (file));
2243       for (;;)
2244         {
2245           bfd_set_error (bfd_error_no_error);
2246
2247           arfile = bfd_openr_next_archived_file (file, arfile);
2248           if (arfile == NULL)
2249             {
2250               if (bfd_get_error () != bfd_error_no_more_archived_files)
2251                 nonfatal (bfd_get_filename (file));
2252               break;
2253             }
2254
2255           display_bfd (arfile);
2256
2257           if (last_arfile != NULL)
2258             bfd_close (last_arfile);
2259           last_arfile = arfile;
2260         }
2261
2262       if (last_arfile != NULL)
2263         bfd_close (last_arfile);
2264     }
2265   else
2266     display_bfd (file);
2267
2268   bfd_close (file);
2269 }
2270 \f
2271 /* Actually display the various requested regions */
2272
2273 static void
2274 dump_data (abfd)
2275      bfd *abfd;
2276 {
2277   asection *section;
2278   bfd_byte *data = 0;
2279   bfd_size_type datasize = 0;
2280   bfd_size_type addr_offset;
2281   bfd_size_type start_offset, stop_offset;
2282   unsigned int opb = bfd_octets_per_byte (abfd);
2283
2284   for (section = abfd->sections; section != NULL; section =
2285        section->next)
2286     {
2287       int onaline = 16;
2288
2289       if (only == (char *) NULL ||
2290           strcmp (only, section->name) == 0)
2291         {
2292           if (section->flags & SEC_HAS_CONTENTS)
2293             {
2294               printf (_("Contents of section %s:\n"), section->name);
2295
2296               if (bfd_section_size (abfd, section) == 0)
2297                 continue;
2298               data = (bfd_byte *) xmalloc ((size_t) bfd_section_size (abfd, section));
2299               datasize = bfd_section_size (abfd, section);
2300
2301
2302               bfd_get_section_contents (abfd, section, (PTR) data, 0, bfd_section_size (abfd, section));
2303
2304               if (start_address == (bfd_vma) -1
2305                   || start_address < section->vma)
2306                 start_offset = 0;
2307               else
2308                 start_offset = start_address - section->vma;
2309               if (stop_address == (bfd_vma) -1)
2310                 stop_offset = bfd_section_size (abfd, section) / opb;
2311               else
2312                 {
2313                   if (stop_address < section->vma)
2314                     stop_offset = 0;
2315                   else
2316                     stop_offset = stop_address - section->vma;
2317                   if (stop_offset > bfd_section_size (abfd, section) / opb)
2318                     stop_offset = bfd_section_size (abfd, section) / opb;
2319                 }
2320               for (addr_offset = start_offset;
2321                    addr_offset < stop_offset; addr_offset += onaline)
2322                 {
2323                   bfd_size_type j;
2324
2325                   printf (" %04lx ", (unsigned long int)
2326                           (addr_offset + section->vma));
2327                   for (j = addr_offset * opb;
2328                        j < addr_offset * opb + onaline; j++)
2329                     {
2330                       if (j < stop_offset * opb)
2331                         printf ("%02x", (unsigned) (data[j]));
2332                       else
2333                         printf ("  ");
2334                       if ((j & 3) == 3)
2335                         printf (" ");
2336                     }
2337
2338                   printf (" ");
2339                   for (j = addr_offset; j < addr_offset * opb + onaline; j++)
2340                     {
2341                       if (j >= stop_offset * opb)
2342                         printf (" ");
2343                       else
2344                         printf ("%c", isprint (data[j]) ? data[j] : '.');
2345                     }
2346                   putchar ('\n');
2347                 }
2348               free (data);
2349             }
2350         }
2351     }
2352 }
2353
2354 /* Should perhaps share code and display with nm? */
2355 static void
2356 dump_symbols (abfd, dynamic)
2357      bfd *abfd ATTRIBUTE_UNUSED;
2358      boolean dynamic;
2359 {
2360   asymbol **current;
2361   long max;
2362   long count;
2363
2364   if (dynamic)
2365     {
2366       current = dynsyms;
2367       max = dynsymcount;
2368       if (max == 0)
2369         return;
2370       printf ("DYNAMIC SYMBOL TABLE:\n");
2371     }
2372   else
2373     {
2374       current = syms;
2375       max = symcount;
2376       if (max == 0)
2377         return;
2378       printf ("SYMBOL TABLE:\n");
2379     }
2380
2381   for (count = 0; count < max; count++)
2382     {
2383       if (*current)
2384         {
2385           bfd *cur_bfd = bfd_asymbol_bfd (*current);
2386
2387           if (cur_bfd != NULL)
2388             {
2389               const char *name;
2390               char *alloc;
2391
2392               name = bfd_asymbol_name (*current);
2393               alloc = NULL;
2394               if (do_demangle && name != NULL && *name != '\0')
2395                 {
2396                   const char *n;
2397
2398                   /* If we want to demangle the name, we demangle it
2399                      here, and temporarily clobber it while calling
2400                      bfd_print_symbol.  FIXME: This is a gross hack.  */
2401
2402                   n = name;
2403                   if (bfd_get_symbol_leading_char (cur_bfd) == *n)
2404                     ++n;
2405                   alloc = cplus_demangle (n, DMGL_ANSI | DMGL_PARAMS);
2406                   if (alloc != NULL)
2407                     (*current)->name = alloc;
2408                   else
2409                     (*current)->name = n;
2410                 }
2411
2412               bfd_print_symbol (cur_bfd, stdout, *current,
2413                                 bfd_print_symbol_all);
2414
2415               (*current)->name = name;
2416               if (alloc != NULL)
2417                 free (alloc);
2418
2419               printf ("\n");
2420             }
2421         }
2422       current++;
2423     }
2424   printf ("\n");
2425   printf ("\n");
2426 }
2427
2428 static void
2429 dump_relocs (abfd)
2430      bfd *abfd;
2431 {
2432   arelent **relpp;
2433   long relcount;
2434   asection *a;
2435
2436   for (a = abfd->sections; a != (asection *) NULL; a = a->next)
2437     {
2438       long relsize;
2439
2440       if (bfd_is_abs_section (a))
2441         continue;
2442       if (bfd_is_und_section (a))
2443         continue;
2444       if (bfd_is_com_section (a))
2445         continue;
2446
2447       if (only)
2448         {
2449           if (strcmp (only, a->name))
2450             continue;
2451         }
2452       else if ((a->flags & SEC_RELOC) == 0)
2453         continue;
2454
2455       relsize = bfd_get_reloc_upper_bound (abfd, a);
2456       if (relsize < 0)
2457         bfd_fatal (bfd_get_filename (abfd));
2458
2459       printf ("RELOCATION RECORDS FOR [%s]:", a->name);
2460
2461       if (relsize == 0)
2462         {
2463           printf (" (none)\n\n");
2464         }
2465       else
2466         {
2467           relpp = (arelent **) xmalloc (relsize);
2468           relcount = bfd_canonicalize_reloc (abfd, a, relpp, syms);
2469           if (relcount < 0)
2470             bfd_fatal (bfd_get_filename (abfd));
2471           else if (relcount == 0)
2472             {
2473               printf (" (none)\n\n");
2474             }
2475           else
2476             {
2477               printf ("\n");
2478               dump_reloc_set (abfd, a, relpp, relcount);
2479               printf ("\n\n");
2480             }
2481           free (relpp);
2482         }
2483     }
2484 }
2485
2486 static void
2487 dump_dynamic_relocs (abfd)
2488      bfd *abfd;
2489 {
2490   long relsize;
2491   arelent **relpp;
2492   long relcount;
2493
2494   relsize = bfd_get_dynamic_reloc_upper_bound (abfd);
2495   if (relsize < 0)
2496     bfd_fatal (bfd_get_filename (abfd));
2497
2498   printf ("DYNAMIC RELOCATION RECORDS");
2499
2500   if (relsize == 0)
2501     {
2502       printf (" (none)\n\n");
2503     }
2504   else
2505     {
2506       relpp = (arelent **) xmalloc (relsize);
2507       relcount = bfd_canonicalize_dynamic_reloc (abfd, relpp, dynsyms);
2508       if (relcount < 0)
2509         bfd_fatal (bfd_get_filename (abfd));
2510       else if (relcount == 0)
2511         {
2512           printf (" (none)\n\n");
2513         }
2514       else
2515         {
2516           printf ("\n");
2517           dump_reloc_set (abfd, (asection *) NULL, relpp, relcount);
2518           printf ("\n\n");
2519         }
2520       free (relpp);
2521     }
2522 }
2523
2524 static void
2525 dump_reloc_set (abfd, sec, relpp, relcount)
2526      bfd *abfd;
2527      asection *sec;
2528      arelent **relpp;
2529      long relcount;
2530 {
2531   arelent **p;
2532   char *last_filename, *last_functionname;
2533   unsigned int last_line;
2534
2535   /* Get column headers lined up reasonably.  */
2536   {
2537     static int width;
2538     if (width == 0)
2539       {
2540         char buf[30];
2541         sprintf_vma (buf, (bfd_vma) -1);
2542         width = strlen (buf) - 7;
2543       }
2544     printf ("OFFSET %*s TYPE %*s VALUE \n", width, "", 12, "");
2545   }
2546
2547   last_filename = NULL;
2548   last_functionname = NULL;
2549   last_line = 0;
2550
2551   for (p = relpp; relcount && *p != (arelent *) NULL; p++, relcount--)
2552     {
2553       arelent *q = *p;
2554       const char *filename, *functionname;
2555       unsigned int line;
2556       const char *sym_name;
2557       const char *section_name;
2558
2559       if (start_address != (bfd_vma) -1
2560           && q->address < start_address)
2561         continue;
2562       if (stop_address != (bfd_vma) -1
2563           && q->address > stop_address)
2564         continue;
2565
2566       if (with_line_numbers
2567           && sec != NULL
2568           && bfd_find_nearest_line (abfd, sec, syms, q->address,
2569                                     &filename, &functionname, &line))
2570         {
2571           if (functionname != NULL
2572               && (last_functionname == NULL
2573                   || strcmp (functionname, last_functionname) != 0))
2574             {
2575               printf ("%s():\n", functionname);
2576               if (last_functionname != NULL)
2577                 free (last_functionname);
2578               last_functionname = xstrdup (functionname);
2579             }
2580           if (line > 0
2581               && (line != last_line
2582                   || (filename != NULL
2583                       && last_filename != NULL
2584                       && strcmp (filename, last_filename) != 0)))
2585             {
2586               printf ("%s:%u\n", filename == NULL ? "???" : filename, line);
2587               last_line = line;
2588               if (last_filename != NULL)
2589                 free (last_filename);
2590               if (filename == NULL)
2591                 last_filename = NULL;
2592               else
2593                 last_filename = xstrdup (filename);
2594             }
2595         }
2596
2597       if (q->sym_ptr_ptr && *q->sym_ptr_ptr)
2598         {
2599           sym_name = (*(q->sym_ptr_ptr))->name;
2600           section_name = (*(q->sym_ptr_ptr))->section->name;
2601         }
2602       else
2603         {
2604           sym_name = NULL;
2605           section_name = NULL;
2606         }
2607       if (sym_name)
2608         {
2609           printf_vma (q->address);
2610           if (q->howto->name)
2611             printf (" %-16s  ", q->howto->name);
2612           else
2613             printf (" %-16d  ", q->howto->type);
2614           objdump_print_symname (abfd, (struct disassemble_info *) NULL,
2615                                  *q->sym_ptr_ptr);
2616         }
2617       else
2618         {
2619           if (section_name == (CONST char *) NULL)
2620             section_name = "*unknown*";
2621           printf_vma (q->address);
2622           printf (" %-16s  [%s]",
2623                   q->howto->name,
2624                   section_name);
2625         }
2626       if (q->addend)
2627         {
2628           printf ("+0x");
2629           printf_vma (q->addend);
2630         }
2631       printf ("\n");
2632     }
2633 }
2634 \f
2635 /* The length of the longest architecture name + 1.  */
2636 #define LONGEST_ARCH sizeof("powerpc:common")
2637
2638 static const char *
2639 endian_string (endian)
2640      enum bfd_endian endian;
2641 {
2642   if (endian == BFD_ENDIAN_BIG)
2643     return "big endian";
2644   else if (endian == BFD_ENDIAN_LITTLE)
2645     return "little endian";
2646   else
2647     return "endianness unknown";
2648 }
2649
2650 /* List the targets that BFD is configured to support, each followed
2651    by its endianness and the architectures it supports.  */
2652
2653 static void
2654 display_target_list ()
2655 {
2656   extern const bfd_target *const *bfd_target_vector;
2657   char *dummy_name;
2658   int t;
2659
2660   dummy_name = make_temp_file (NULL);
2661   for (t = 0; bfd_target_vector[t]; t++)
2662     {
2663       const bfd_target *p = bfd_target_vector[t];
2664       bfd *abfd = bfd_openw (dummy_name, p->name);
2665       int a;
2666
2667       printf ("%s\n (header %s, data %s)\n", p->name,
2668               endian_string (p->header_byteorder),
2669               endian_string (p->byteorder));
2670
2671       if (abfd == NULL)
2672         {
2673           nonfatal (dummy_name);
2674           continue;
2675         }
2676
2677       if (! bfd_set_format (abfd, bfd_object))
2678         {
2679           if (bfd_get_error () != bfd_error_invalid_operation)
2680             nonfatal (p->name);
2681           bfd_close_all_done (abfd);
2682           continue;
2683         }
2684
2685       for (a = (int) bfd_arch_obscure + 1; a < (int) bfd_arch_last; a++)
2686         if (bfd_set_arch_mach (abfd, (enum bfd_architecture) a, 0))
2687           printf ("  %s\n",
2688                   bfd_printable_arch_mach ((enum bfd_architecture) a, 0));
2689       bfd_close_all_done (abfd);
2690     }
2691   unlink (dummy_name);
2692   free (dummy_name);
2693 }
2694
2695 /* Print a table showing which architectures are supported for entries
2696    FIRST through LAST-1 of bfd_target_vector (targets across,
2697    architectures down).  */
2698
2699 static void
2700 display_info_table (first, last)
2701      int first;
2702      int last;
2703 {
2704   extern const bfd_target *const *bfd_target_vector;
2705   int t, a;
2706   char *dummy_name;
2707
2708   /* Print heading of target names.  */
2709   printf ("\n%*s", (int) LONGEST_ARCH, " ");
2710   for (t = first; t < last && bfd_target_vector[t]; t++)
2711     printf ("%s ", bfd_target_vector[t]->name);
2712   putchar ('\n');
2713
2714   dummy_name = make_temp_file (NULL);
2715   for (a = (int) bfd_arch_obscure + 1; a < (int) bfd_arch_last; a++)
2716     if (strcmp (bfd_printable_arch_mach (a, 0), "UNKNOWN!") != 0)
2717       {
2718         printf ("%*s ", (int) LONGEST_ARCH - 1,
2719                 bfd_printable_arch_mach (a, 0));
2720         for (t = first; t < last && bfd_target_vector[t]; t++)
2721           {
2722             const bfd_target *p = bfd_target_vector[t];
2723             boolean ok = true;
2724             bfd *abfd = bfd_openw (dummy_name, p->name);
2725
2726             if (abfd == NULL)
2727               {
2728                 nonfatal (p->name);
2729                 ok = false;
2730               }
2731
2732             if (ok)
2733               {
2734                 if (! bfd_set_format (abfd, bfd_object))
2735                   {
2736                     if (bfd_get_error () != bfd_error_invalid_operation)
2737                       nonfatal (p->name);
2738                     ok = false;
2739                   }
2740               }
2741
2742             if (ok)
2743               {
2744                 if (! bfd_set_arch_mach (abfd, a, 0))
2745                   ok = false;
2746               }
2747
2748             if (ok)
2749               printf ("%s ", p->name);
2750             else
2751               {
2752                 int l = strlen (p->name);
2753                 while (l--)
2754                   putchar ('-');
2755                 putchar (' ');
2756               }
2757             if (abfd != NULL)
2758               bfd_close_all_done (abfd);
2759           }
2760         putchar ('\n');
2761       }
2762   unlink (dummy_name);
2763   free (dummy_name);
2764 }
2765
2766 /* Print tables of all the target-architecture combinations that
2767    BFD has been configured to support.  */
2768
2769 static void
2770 display_target_tables ()
2771 {
2772   int t, columns;
2773   extern const bfd_target *const *bfd_target_vector;
2774   char *colum;
2775
2776   columns = 0;
2777   colum = getenv ("COLUMNS");
2778   if (colum != NULL)
2779     columns = atoi (colum);
2780   if (columns == 0)
2781     columns = 80;
2782
2783   t = 0;
2784   while (bfd_target_vector[t] != NULL)
2785     {
2786       int oldt = t, wid;
2787
2788       wid = LONGEST_ARCH + strlen (bfd_target_vector[t]->name) + 1;
2789       ++t;
2790       while (wid < columns && bfd_target_vector[t] != NULL)
2791         {
2792           int newwid;
2793
2794           newwid = wid + strlen (bfd_target_vector[t]->name) + 1;
2795           if (newwid >= columns)
2796             break;
2797           wid = newwid;
2798           ++t;
2799         }
2800       display_info_table (oldt, t);
2801     }
2802 }
2803
2804 static void
2805 display_info ()
2806 {
2807   printf (_("BFD header file version %s\n"), BFD_VERSION);
2808   display_target_list ();
2809   display_target_tables ();
2810 }
2811
2812 int
2813 main (argc, argv)
2814      int argc;
2815      char **argv;
2816 {
2817   int c;
2818   char *target = default_target;
2819   boolean seenflag = false;
2820
2821 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
2822   setlocale (LC_MESSAGES, "");
2823 #endif
2824   bindtextdomain (PACKAGE, LOCALEDIR);
2825   textdomain (PACKAGE);
2826
2827   program_name = *argv;
2828   xmalloc_set_program_name (program_name);
2829
2830   START_PROGRESS (program_name, 0);
2831
2832   bfd_init ();
2833   set_default_bfd_target ();
2834
2835   while ((c = getopt_long (argc, argv, "pib:m:M:VCdDlfahHrRtTxsSj:wE:zgG",
2836                            long_options, (int *) 0))
2837          != EOF)
2838     {
2839       switch (c)
2840         {
2841         case 0:
2842           break;                /* we've been given a long option */
2843         case 'm':
2844           machine = optarg;
2845           break;
2846         case 'M':
2847           disassembler_options = optarg;
2848           break;
2849         case 'j':
2850           only = optarg;
2851           break;
2852         case 'l':
2853           with_line_numbers = true;
2854           break;
2855         case 'b':
2856           target = optarg;
2857           break;
2858         case 'C':
2859           do_demangle = true;
2860           if (optarg != NULL)
2861             {
2862               enum demangling_styles style;
2863
2864               style = cplus_demangle_name_to_style (optarg);
2865               if (style == unknown_demangling)
2866                 fatal (_("unknown demangling style `%s'"),
2867                        optarg);
2868
2869               cplus_demangle_set_style (style);
2870            }
2871           break;
2872         case 'w':
2873           wide_output = true;
2874           break;
2875         case OPTION_ADJUST_VMA:
2876           adjust_section_vma = parse_vma (optarg, "--adjust-vma");
2877           break;
2878         case OPTION_START_ADDRESS:
2879           start_address = parse_vma (optarg, "--start-address");
2880           break;
2881         case OPTION_STOP_ADDRESS:
2882           stop_address = parse_vma (optarg, "--stop-address");
2883           break;
2884         case 'E':
2885           if (strcmp (optarg, "B") == 0)
2886             endian = BFD_ENDIAN_BIG;
2887           else if (strcmp (optarg, "L") == 0)
2888             endian = BFD_ENDIAN_LITTLE;
2889           else
2890             {
2891               non_fatal (_("unrecognized -E option"));
2892               usage (stderr, 1);
2893             }
2894           break;
2895         case OPTION_ENDIAN:
2896           if (strncmp (optarg, "big", strlen (optarg)) == 0)
2897             endian = BFD_ENDIAN_BIG;
2898           else if (strncmp (optarg, "little", strlen (optarg)) == 0)
2899             endian = BFD_ENDIAN_LITTLE;
2900           else
2901             {
2902               non_fatal (_("unrecognized --endian type `%s'"), optarg);
2903               usage (stderr, 1);
2904             }
2905           break;
2906
2907         case 'f':
2908           dump_file_header = true;
2909           seenflag = true;
2910           break;
2911         case 'i':
2912           formats_info = true;
2913           seenflag = true;
2914           break;
2915         case 'p':
2916           dump_private_headers = true;
2917           seenflag = true;
2918           break;
2919         case 'x':
2920           dump_private_headers = true;
2921           dump_symtab = true;
2922           dump_reloc_info = true;
2923           dump_file_header = true;
2924           dump_ar_hdrs = true;
2925           dump_section_headers = true;
2926           seenflag = true;
2927           break;
2928         case 't':
2929           dump_symtab = true;
2930           seenflag = true;
2931           break;
2932         case 'T':
2933           dump_dynamic_symtab = true;
2934           seenflag = true;
2935           break;
2936         case 'd':
2937           disassemble = true;
2938           seenflag = true;
2939           break;
2940         case 'z':
2941           disassemble_zeroes = true;
2942           break;
2943         case 'D':
2944           disassemble = true;
2945           disassemble_all = true;
2946           seenflag = true;
2947           break;
2948         case 'S':
2949           disassemble = true;
2950           with_source_code = true;
2951           seenflag = true;
2952           break;
2953         case 'g':
2954           dump_debugging = 1;
2955           seenflag = true;
2956           break;
2957         case 'G':
2958           dump_stab_section_info = true;
2959           seenflag = true;
2960           break;
2961         case 's':
2962           dump_section_contents = true;
2963           seenflag = true;
2964           break;
2965         case 'r':
2966           dump_reloc_info = true;
2967           seenflag = true;
2968           break;
2969         case 'R':
2970           dump_dynamic_reloc_info = true;
2971           seenflag = true;
2972           break;
2973         case 'a':
2974           dump_ar_hdrs = true;
2975           seenflag = true;
2976           break;
2977         case 'h':
2978           dump_section_headers = true;
2979           seenflag = true;
2980           break;
2981         case 'H':
2982           usage (stdout, 0);
2983           seenflag = true;
2984         case 'V':
2985           show_version = true;
2986           seenflag = true;
2987           break;
2988
2989         default:
2990           usage (stderr, 1);
2991         }
2992     }
2993
2994   if (show_version)
2995     print_version ("objdump");
2996
2997   if (seenflag == false)
2998     usage (stderr, 2);
2999
3000   if (formats_info)
3001     display_info ();
3002   else
3003     {
3004       if (optind == argc)
3005         display_file ("a.out", target);
3006       else
3007         for (; optind < argc;)
3008           display_file (argv[optind++], target);
3009     }
3010
3011   END_PROGRESS (program_name);
3012
3013   return exit_status;
3014 }