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