binutils/objdump.c

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