binutils/objdump.c

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