binutils/objdump.c

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