contrib/binutils/binutils/objdump.c

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