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