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