binutils/objdump.c

   1 /* objdump.c -- dump information about an object file.
   2    Copyright 1990, 91, 92, 93, 94, 95, 96, 97, 98, 1999
   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
  79 /* Extra info to pass to the disassembler address printing function.  */
  80 struct objdump_disasm_info {
  81   bfd *abfd;
  82   asection *sec;
  83   boolean require_sec;
  84 };
  85
  86 /* Architecture to disassemble for, or default if NULL.  */
  87 static char *machine = (char *) NULL;
  88
  89 /* Target specific options to the disassembler.  */
  90 static char *disassembler_options = (char *) NULL;
  91
  92 /* Endianness to disassemble for, or default if BFD_ENDIAN_UNKNOWN.  */
  93 static enum bfd_endian endian = BFD_ENDIAN_UNKNOWN;
  94
  95 /* The symbol table.  */
  96 static asymbol **syms;
  97
  98 /* Number of symbols in `syms'.  */
  99 static long symcount = 0;
 100
 101 /* The sorted symbol table.  */
 102 static asymbol **sorted_syms;
 103
 104 /* Number of symbols in `sorted_syms'.  */
 105 static long sorted_symcount = 0;
 106
 107 /* The dynamic symbol table.  */
 108 static asymbol **dynsyms;
 109
 110 /* Number of symbols in `dynsyms'.  */
 111 static long dynsymcount = 0;
 112
 113 /* Static declarations.  */
 114
 115 static void
 116 usage PARAMS ((FILE *, int));
 117
 118 static void
 119 nonfatal PARAMS ((const char *));
 120
 121 static void
 122 display_file PARAMS ((char *filename, char *target));
 123
 124 static void
 125 dump_section_header PARAMS ((bfd *, asection *, PTR));
 126
 127 static void
 128 dump_headers PARAMS ((bfd *));
 129
 130 static void
 131 dump_data PARAMS ((bfd *abfd));
 132
 133 static void
 134 dump_relocs PARAMS ((bfd *abfd));
 135
 136 static void
 137 dump_dynamic_relocs PARAMS ((bfd * abfd));
 138
 139 static void
 140 dump_reloc_set PARAMS ((bfd *, asection *, arelent **, long));
 141
 142 static void
 143 dump_symbols PARAMS ((bfd *abfd, boolean dynamic));
 144
 145 static void
 146 dump_bfd_header PARAMS ((bfd *));
 147
 148 static void
 149 dump_bfd_private_header PARAMS ((bfd *));
 150
 151 static void
 152 display_bfd PARAMS ((bfd *abfd));
 153
 154 static void
 155 display_target_list PARAMS ((void));
 156
 157 static void
 158 display_info_table PARAMS ((int, int));
 159
 160 static void
 161 display_target_tables PARAMS ((void));
 162
 163 static void
 164 display_info PARAMS ((void));
 165
 166 static void
 167 objdump_print_value PARAMS ((bfd_vma, struct disassemble_info *, boolean));
 168
 169 static void
 170 objdump_print_symname PARAMS ((bfd *, struct disassemble_info *, asymbol *));
 171
 172 static asymbol *
 173 find_symbol_for_address PARAMS ((bfd *, asection *, bfd_vma, boolean, long *));
 174
 175 static void
 176 objdump_print_addr_with_sym PARAMS ((bfd *, asection *, asymbol *, bfd_vma,
 177                                      struct disassemble_info *, boolean));
 178
 179 static void
 180 objdump_print_addr PARAMS ((bfd_vma, struct disassemble_info *, boolean));
 181
 182 static void
 183 objdump_print_address PARAMS ((bfd_vma, struct disassemble_info *));
 184
 185 static void
 186 show_line PARAMS ((bfd *, asection *, bfd_vma));
 187
 188 static void
 189 disassemble_bytes PARAMS ((struct disassemble_info *, disassembler_ftype,
 190                            boolean, bfd_byte *, bfd_vma, bfd_vma,
 191                            arelent ***, arelent **));
 192
 193 static void
 194 disassemble_data PARAMS ((bfd *));
 195
 196 static const char *
 197 endian_string PARAMS ((enum bfd_endian));
 198
 199 static asymbol **
 200 slurp_symtab PARAMS ((bfd *));
 201
 202 static asymbol **
 203 slurp_dynamic_symtab PARAMS ((bfd *));
 204
 205 static long
 206 remove_useless_symbols PARAMS ((asymbol **, long));
 207
 208 static int
 209 compare_symbols PARAMS ((const PTR, const PTR));
 210
 211 static int
 212 compare_relocs PARAMS ((const PTR, const PTR));
 213
 214 static void
 215 dump_stabs PARAMS ((bfd *));
 216
 217 static boolean
 218 read_section_stabs PARAMS ((bfd *, const char *, const char *));
 219
 220 static void
 221 print_section_stabs PARAMS ((bfd *, const char *, const char *));
 222 \f
 223 static void
 224 usage (stream, status)
 225      FILE *stream;
 226      int status;
 227 {
 228   fprintf (stream, _("Usage: %s <switches> file(s)\n"), program_name);
 229   fprintf (stream, _(" At least one of the following switches must be given:\n"));
 230   fprintf (stream, _("\
 231   -a  --archive-headers    Display archive header information\n\
 232   -f  --file-headers       Display the contents of the overall file header\n\
 233   -p  --private-headers    Display object format specific file header contents\n\
 234   -h  --[section-]headers  Display the contents of the section headers\n\
 235   -x  --all-headers        Display the contents of all headers\n\
 236   -d  --disassemble        Display assembler contents of executable sections\n\
 237   -D  --disassemble-all    Display assembler contents of all sections\n\
 238   -S  --source             Intermix source code with disassembly\n\
 239   -s  --full-contents      Display the full contents of all sections requested\n\
 240   -g  --debugging          Display debug information in object file\n\
 241   -G  --stabs              Display the STABS contents of an ELF format file\n\
 242   -t  --syms               Display the contents of the symbol table(s)\n\
 243   -T  --dynamic-syms       Display the contents of the dynamic symbol table\n\
 244   -r  --reloc              Display the relocation entries in the file\n\
 245   -R  --dynamic-reloc      Display the dynamic relocation entries in the file\n\
 246   -V  --version            Display this program's version number\n\
 247   -i  --info               List object formats and architectures supported\n\
 248   -H  --help               Display this information\n\
 249 "));
 250   if (status != 2)
 251     {
 252       fprintf (stream, _("\n The following switches are optional:\n"));
 253       fprintf (stream, _("\
 254   -b  --target <bfdname>         Specify the target object format as <bfdname>\n\
 255   -m  --architecture <machine>   Specify the target architecture as <machine>\n\
 256   -j  --section <name>           Only display information for section <name>\n\
 257   -M  --disassembler-options <o> Pass text <o> on to the disassembler\n\
 258   -EB --endian=big               Assume big endian format when disassembling\n\
 259   -EL --endian=little            Assume little endian format when disassembling\n\
 260   -l  --line-numbers             Include line numbers and filenames in output\n\
 261   -C  --demangle                 Decode mangled/processed symbol names\n\
 262   -w  --wide                     Format output for more than 80 columns\n\
 263   -z  --disassemble-zeroes       Do not skip blocks of zeroes when disassembling\n\
 264       --start-address <addr>     Only process data whoes address is >= <addr>\n\
 265       --stop-address <addr>      Only process data whoes address is <= <addr>\n\
 266       --prefix-addresses         Print complete address alongside disassembly\n\
 267       --[no-]show-raw-insn       Display hex alongside symbolic disassembly\n\
 268       --adjust-vma <offset>      Add <offset> to all displayed section addresses\n\
 269 \n"));
 270       list_supported_targets (program_name, stream);
 271
 272       disassembler_usage (stream);
 273     }
 274   if (status == 0)
 275     fprintf (stream, _("Report bugs to bug-gnu-utils@gnu.org\n"));
 276   exit (status);
 277 }
 278
 279 /* 150 isn't special; it's just an arbitrary non-ASCII char value.  */
 280
 281 #define OPTION_ENDIAN (150)
 282 #define OPTION_START_ADDRESS (OPTION_ENDIAN + 1)
 283 #define OPTION_STOP_ADDRESS (OPTION_START_ADDRESS + 1)
 284 #define OPTION_ADJUST_VMA (OPTION_STOP_ADDRESS + 1)
 285
 286 static struct option long_options[]=
 287 {
 288   {"adjust-vma", required_argument, NULL, OPTION_ADJUST_VMA},
 289   {"all-headers", no_argument, NULL, 'x'},
 290   {"private-headers", no_argument, NULL, 'p'},
 291   {"architecture", required_argument, NULL, 'm'},
 292   {"archive-headers", no_argument, NULL, 'a'},
 293   {"debugging", no_argument, NULL, 'g'},
 294   {"demangle", no_argument, NULL, 'C'},
 295   {"disassemble", no_argument, NULL, 'd'},
 296   {"disassemble-all", no_argument, NULL, 'D'},
 297   {"disassembler-options", required_argument, NULL, 'M'},
 298   {"disassemble-zeroes", no_argument, NULL, 'z'},
 299   {"dynamic-reloc", no_argument, NULL, 'R'},
 300   {"dynamic-syms", no_argument, NULL, 'T'},
 301   {"endian", required_argument, NULL, OPTION_ENDIAN},
 302   {"file-headers", no_argument, NULL, 'f'},
 303   {"full-contents", no_argument, NULL, 's'},
 304   {"headers", no_argument, NULL, 'h'},
 305   {"help", no_argument, NULL, 'H'},
 306   {"info", no_argument, NULL, 'i'},
 307   {"line-numbers", no_argument, NULL, 'l'},
 308   {"no-show-raw-insn", no_argument, &show_raw_insn, -1},
 309   {"prefix-addresses", no_argument, &prefix_addresses, 1},
 310   {"reloc", no_argument, NULL, 'r'},
 311   {"section", required_argument, NULL, 'j'},
 312   {"section-headers", no_argument, NULL, 'h'},
 313   {"show-raw-insn", no_argument, &show_raw_insn, 1},
 314   {"source", no_argument, NULL, 'S'},
 315   {"stabs", no_argument, NULL, 'G'},
 316   {"start-address", required_argument, NULL, OPTION_START_ADDRESS},
 317   {"stop-address", required_argument, NULL, OPTION_STOP_ADDRESS},
 318   {"syms", no_argument, NULL, 't'},
 319   {"target", required_argument, NULL, 'b'},
 320   {"version", no_argument, NULL, 'V'},
 321   {"wide", no_argument, NULL, 'w'},
 322   {0, no_argument, 0, 0}
 323 };
 324 \f
 325 static void
 326 nonfatal (msg)
 327      const char *msg;
 328 {
 329   bfd_nonfatal (msg);
 330   exit_status = 1;
 331 }
 332 \f
 333 static void
 334 dump_section_header (abfd, section, ignored)
 335      bfd *abfd ATTRIBUTE_UNUSED;
 336      asection *section;
 337      PTR ignored ATTRIBUTE_UNUSED;
 338 {
 339   char *comma = "";
 340   int opb = bfd_octets_per_byte (abfd);
 341
 342   printf ("%3d %-13s %08lx  ", section->index,
 343           bfd_get_section_name (abfd, section),
 344           (unsigned long) bfd_section_size (abfd, section) / opb);
 345   printf_vma (bfd_get_section_vma (abfd, section));
 346   printf ("  ");
 347   printf_vma (section->lma);
 348   printf ("  %08lx  2**%u", section->filepos,
 349           bfd_get_section_alignment (abfd, section));
 350   if (! wide_output)
 351     printf ("\n                ");
 352   printf ("  ");
 353
 354 #define PF(x, y) \
 355   if (section->flags & x) { printf ("%s%s", comma, y); comma = ", "; }
 356
 357   PF (SEC_HAS_CONTENTS, "CONTENTS");
 358   PF (SEC_ALLOC, "ALLOC");
 359   PF (SEC_CONSTRUCTOR, "CONSTRUCTOR");
 360   PF (SEC_CONSTRUCTOR_TEXT, "CONSTRUCTOR TEXT");
 361   PF (SEC_CONSTRUCTOR_DATA, "CONSTRUCTOR DATA");
 362   PF (SEC_CONSTRUCTOR_BSS, "CONSTRUCTOR BSS");
 363   PF (SEC_LOAD, "LOAD");
 364   PF (SEC_RELOC, "RELOC");
 365 #ifdef SEC_BALIGN
 366   PF (SEC_BALIGN, "BALIGN");
 367 #endif
 368   PF (SEC_READONLY, "READONLY");
 369   PF (SEC_CODE, "CODE");
 370   PF (SEC_DATA, "DATA");
 371   PF (SEC_ROM, "ROM");
 372   PF (SEC_DEBUGGING, "DEBUGGING");
 373   PF (SEC_NEVER_LOAD, "NEVER_LOAD");
 374   PF (SEC_EXCLUDE, "EXCLUDE");
 375   PF (SEC_SORT_ENTRIES, "SORT_ENTRIES");
 376   PF (SEC_SMALL_DATA, "SMALL_DATA");
 377   PF (SEC_SHARED, "SHARED");
 378
 379   if ((section->flags & SEC_LINK_ONCE) != 0)
 380     {
 381       const char *ls;
 382
 383       switch (section->flags & SEC_LINK_DUPLICATES)
 384         {
 385         default:
 386           abort ();
 387         case SEC_LINK_DUPLICATES_DISCARD:
 388           ls = "LINK_ONCE_DISCARD";
 389           break;
 390         case SEC_LINK_DUPLICATES_ONE_ONLY:
 391           ls = "LINK_ONCE_ONE_ONLY";
 392           break;
 393         case SEC_LINK_DUPLICATES_SAME_SIZE:
 394           ls = "LINK_ONCE_SAME_SIZE";
 395           break;
 396         case SEC_LINK_DUPLICATES_SAME_CONTENTS:
 397           ls = "LINK_ONCE_SAME_CONTENTS";
 398           break;
 399         }
 400       printf ("%s%s", comma, ls);
 401
 402       if (section->comdat != NULL)
 403         printf (" (COMDAT %s %ld)", section->comdat->name,
 404                 section->comdat->symbol);
 405
 406       comma = ", ";
 407     }
 408
 409   printf ("\n");
 410 #undef PF
 411 }
 412
 413 static void
 414 dump_headers (abfd)
 415      bfd *abfd;
 416 {
 417   printf (_("Sections:\n"));
 418
 419 #ifndef BFD64
 420   printf (_("Idx Name          Size      VMA       LMA       File off  Algn"));
 421 #else
 422   printf (_("Idx Name          Size      VMA               LMA               File off  Algn"));
 423 #endif
 424
 425   if (wide_output)
 426     printf (_("  Flags"));
 427   printf ("\n");
 428
 429   bfd_map_over_sections (abfd, dump_section_header, (PTR) NULL);
 430 }
 431 \f
 432 static asymbol **
 433 slurp_symtab (abfd)
 434      bfd *abfd;
 435 {
 436   asymbol **sy = (asymbol **) NULL;
 437   long storage;
 438
 439   if (!(bfd_get_file_flags (abfd) & HAS_SYMS))
 440     {
 441       fprintf (stderr, _("%s: no symbols\n"), bfd_get_filename (abfd));
 442       symcount = 0;
 443       return NULL;
 444     }
 445
 446   storage = bfd_get_symtab_upper_bound (abfd);
 447   if (storage < 0)
 448     bfd_fatal (bfd_get_filename (abfd));
 449
 450   if (storage)
 451     {
 452       sy = (asymbol **) xmalloc (storage);
 453     }
 454   symcount = bfd_canonicalize_symtab (abfd, sy);
 455   if (symcount < 0)
 456     bfd_fatal (bfd_get_filename (abfd));
 457   if (symcount == 0)
 458     fprintf (stderr, _("%s: no symbols\n"), bfd_get_filename (abfd));
 459   return sy;
 460 }
 461
 462 /* Read in the dynamic symbols.  */
 463
 464 static asymbol **
 465 slurp_dynamic_symtab (abfd)
 466      bfd *abfd;
 467 {
 468   asymbol **sy = (asymbol **) NULL;
 469   long storage;
 470
 471   storage = bfd_get_dynamic_symtab_upper_bound (abfd);
 472   if (storage < 0)
 473     {
 474       if (!(bfd_get_file_flags (abfd) & DYNAMIC))
 475         {
 476           fprintf (stderr, _("%s: %s: not a dynamic object\n"),
 477                    program_name, bfd_get_filename (abfd));
 478           dynsymcount = 0;
 479           return NULL;
 480         }
 481
 482       bfd_fatal (bfd_get_filename (abfd));
 483     }
 484
 485   if (storage)
 486     {
 487       sy = (asymbol **) xmalloc (storage);
 488     }
 489   dynsymcount = bfd_canonicalize_dynamic_symtab (abfd, sy);
 490   if (dynsymcount < 0)
 491     bfd_fatal (bfd_get_filename (abfd));
 492   if (dynsymcount == 0)
 493     fprintf (stderr, _("%s: %s: No dynamic symbols\n"),
 494              program_name, bfd_get_filename (abfd));
 495   return sy;
 496 }
 497
 498 /* Filter out (in place) symbols that are useless for disassembly.
 499    COUNT is the number of elements in SYMBOLS.
 500    Return the number of useful symbols. */
 501
 502 static long
 503 remove_useless_symbols (symbols, count)
 504      asymbol **symbols;
 505      long count;
 506 {
 507   register asymbol **in_ptr = symbols, **out_ptr = symbols;
 508
 509   while (--count >= 0)
 510     {
 511       asymbol *sym = *in_ptr++;
 512
 513       if (sym->name == NULL || sym->name[0] == '\0')
 514         continue;
 515       if (sym->flags & (BSF_DEBUGGING))
 516         continue;
 517       if (bfd_is_und_section (sym->section)
 518           || bfd_is_com_section (sym->section))
 519         continue;
 520
 521       *out_ptr++ = sym;
 522     }
 523   return out_ptr - symbols;
 524 }
 525
 526 /* Sort symbols into value order.  */
 527
 528 static int
 529 compare_symbols (ap, bp)
 530      const PTR ap;
 531      const PTR bp;
 532 {
 533   const asymbol *a = *(const asymbol **)ap;
 534   const asymbol *b = *(const asymbol **)bp;
 535   const char *an, *bn;
 536   size_t anl, bnl;
 537   boolean af, bf;
 538   flagword aflags, bflags;
 539
 540   if (bfd_asymbol_value (a) > bfd_asymbol_value (b))
 541     return 1;
 542   else if (bfd_asymbol_value (a) < bfd_asymbol_value (b))
 543     return -1;
 544
 545   if (a->section > b->section)
 546     return 1;
 547   else if (a->section < b->section)
 548     return -1;
 549
 550   an = bfd_asymbol_name (a);
 551   bn = bfd_asymbol_name (b);
 552   anl = strlen (an);
 553   bnl = strlen (bn);
 554
 555   /* The symbols gnu_compiled and gcc2_compiled convey no real
 556      information, so put them after other symbols with the same value.  */
 557
 558   af = (strstr (an, "gnu_compiled") != NULL
 559         || strstr (an, "gcc2_compiled") != NULL);
 560   bf = (strstr (bn, "gnu_compiled") != NULL
 561         || strstr (bn, "gcc2_compiled") != NULL);
 562
 563   if (af && ! bf)
 564     return 1;
 565   if (! af && bf)
 566     return -1;
 567
 568   /* We use a heuristic for the file name, to try to sort it after
 569      more useful symbols.  It may not work on non Unix systems, but it
 570      doesn't really matter; the only difference is precisely which
 571      symbol names get printed.  */
 572
 573 #define file_symbol(s, sn, snl)                 \
 574   (((s)->flags & BSF_FILE) != 0                 \
 575    || ((sn)[(snl) - 2] == '.'                   \
 576        && ((sn)[(snl) - 1] == 'o'               \
 577            || (sn)[(snl) - 1] == 'a')))
 578
 579   af = file_symbol (a, an, anl);
 580   bf = file_symbol (b, bn, bnl);
 581
 582   if (af && ! bf)
 583     return 1;
 584   if (! af && bf)
 585     return -1;
 586
 587   /* Try to sort global symbols before local symbols before function
 588      symbols before debugging symbols.  */
 589
 590   aflags = a->flags;
 591   bflags = b->flags;
 592
 593   if ((aflags & BSF_DEBUGGING) != (bflags & BSF_DEBUGGING))
 594     {
 595       if ((aflags & BSF_DEBUGGING) != 0)
 596         return 1;
 597       else
 598         return -1;
 599     }
 600   if ((aflags & BSF_FUNCTION) != (bflags & BSF_FUNCTION))
 601     {
 602       if ((aflags & BSF_FUNCTION) != 0)
 603         return -1;
 604       else
 605         return 1;
 606     }
 607   if ((aflags & BSF_LOCAL) != (bflags & BSF_LOCAL))
 608     {
 609       if ((aflags & BSF_LOCAL) != 0)
 610         return 1;
 611       else
 612         return -1;
 613     }
 614   if ((aflags & BSF_GLOBAL) != (bflags & BSF_GLOBAL))
 615     {
 616       if ((aflags & BSF_GLOBAL) != 0)
 617         return -1;
 618       else
 619         return 1;
 620     }
 621
 622   /* Symbols that start with '.' might be section names, so sort them
 623      after symbols that don't start with '.'.  */
 624   if (an[0] == '.' && bn[0] != '.')
 625     return 1;
 626   if (an[0] != '.' && bn[0] == '.')
 627     return -1;
 628
 629   /* Finally, if we can't distinguish them in any other way, try to
 630      get consistent results by sorting the symbols by name.  */
 631   return strcmp (an, bn);
 632 }
 633
 634 /* Sort relocs into address order.  */
 635
 636 static int
 637 compare_relocs (ap, bp)
 638      const PTR ap;
 639      const PTR bp;
 640 {
 641   const arelent *a = *(const arelent **)ap;
 642   const arelent *b = *(const arelent **)bp;
 643
 644   if (a->address > b->address)
 645     return 1;
 646   else if (a->address < b->address)
 647     return -1;
 648
 649   /* So that associated relocations tied to the same address show up
 650      in the correct order, we don't do any further sorting.  */
 651   if (a > b)
 652     return 1;
 653   else if (a < b)
 654     return -1;
 655   else
 656     return 0;
 657 }
 658
 659 /* Print VMA to STREAM.  If SKIP_ZEROES is true, omit leading zeroes.  */
 660
 661 static void
 662 objdump_print_value (vma, info, skip_zeroes)
 663      bfd_vma vma;
 664      struct disassemble_info *info;
 665      boolean skip_zeroes;
 666 {
 667   char buf[30];
 668   char *p;
 669
 670   sprintf_vma (buf, vma);
 671   if (! skip_zeroes)
 672     p = buf;
 673   else
 674     {
 675       for (p = buf; *p == '0'; ++p)
 676         ;
 677       if (*p == '\0')
 678         --p;
 679     }
 680   (*info->fprintf_func) (info->stream, "%s", p);
 681 }
 682
 683 /* Print the name of a symbol.  */
 684
 685 static void
 686 objdump_print_symname (abfd, info, sym)
 687      bfd *abfd;
 688      struct disassemble_info *info;
 689      asymbol *sym;
 690 {
 691   char *alloc;
 692   const char *name;
 693   const char *print;
 694
 695   alloc = NULL;
 696   name = bfd_asymbol_name (sym);
 697   if (! do_demangle || name[0] == '\0')
 698     print = name;
 699   else
 700     {
 701       /* Demangle the name.  */
 702       if (bfd_get_symbol_leading_char (abfd) == name[0])
 703         ++name;
 704
 705       alloc = cplus_demangle (name, DMGL_ANSI | DMGL_PARAMS);
 706       if (alloc == NULL)
 707         print = name;
 708       else
 709         print = alloc;
 710     }
 711
 712   if (info != NULL)
 713     (*info->fprintf_func) (info->stream, "%s", print);
 714   else
 715     printf ("%s", print);
 716
 717   if (alloc != NULL)
 718     free (alloc);
 719 }
 720
 721 /* Locate a symbol given a bfd, a section, and a VMA.  If REQUIRE_SEC
 722    is true, then always require the symbol to be in the section.  This
 723    returns NULL if there is no suitable symbol.  If PLACE is not NULL,
 724    then *PLACE is set to the index of the symbol in sorted_syms.  */
 725
 726 static asymbol *
 727 find_symbol_for_address (abfd, sec, vma, require_sec, place)
 728      bfd *abfd;
 729      asection *sec;
 730      bfd_vma vma;
 731      boolean require_sec;
 732      long *place;
 733 {
 734   /* @@ Would it speed things up to cache the last two symbols returned,
 735      and maybe their address ranges?  For many processors, only one memory
 736      operand can be present at a time, so the 2-entry cache wouldn't be
 737      constantly churned by code doing heavy memory accesses.  */
 738
 739   /* Indices in `sorted_syms'.  */
 740   long min = 0;
 741   long max = sorted_symcount;
 742   long thisplace;
 743   int opb = bfd_octets_per_byte (abfd);
 744
 745   if (sorted_symcount < 1)
 746     return NULL;
 747
 748   /* Perform a binary search looking for the closest symbol to the
 749      required value.  We are searching the range (min, max].  */
 750   while (min + 1 < max)
 751     {
 752       asymbol *sym;
 753
 754       thisplace = (max + min) / 2;
 755       sym = sorted_syms[thisplace];
 756
 757       if (bfd_asymbol_value (sym) > vma)
 758         max = thisplace;
 759       else if (bfd_asymbol_value (sym) < vma)
 760         min = thisplace;
 761       else
 762         {
 763           min = thisplace;
 764           break;
 765         }
 766     }
 767
 768   /* The symbol we want is now in min, the low end of the range we
 769      were searching.  If there are several symbols with the same
 770      value, we want the first one.  */
 771   thisplace = min;
 772   while (thisplace > 0
 773          && (bfd_asymbol_value (sorted_syms[thisplace])
 774              == bfd_asymbol_value (sorted_syms[thisplace - 1])))
 775     --thisplace;
 776
 777   /* If the file is relocateable, and the symbol could be from this
 778      section, prefer a symbol from this section over symbols from
 779      others, even if the other symbol's value might be closer.
 780
 781      Note that this may be wrong for some symbol references if the
 782      sections have overlapping memory ranges, but in that case there's
 783      no way to tell what's desired without looking at the relocation
 784      table.  */
 785
 786   if (sorted_syms[thisplace]->section != sec
 787       && (require_sec
 788           || ((abfd->flags & HAS_RELOC) != 0
 789               && vma >= bfd_get_section_vma (abfd, sec)
 790               && vma < (bfd_get_section_vma (abfd, sec)
 791                         + bfd_section_size (abfd, sec) / opb))))
 792     {
 793       long i;
 794
 795       for (i = thisplace + 1; i < sorted_symcount; i++)
 796         {
 797           if (bfd_asymbol_value (sorted_syms[i])
 798               != bfd_asymbol_value (sorted_syms[thisplace]))
 799             break;
 800         }
 801       --i;
 802       for (; i >= 0; i--)
 803         {
 804           if (sorted_syms[i]->section == sec
 805               && (i == 0
 806                   || sorted_syms[i - 1]->section != sec
 807                   || (bfd_asymbol_value (sorted_syms[i])
 808                       != bfd_asymbol_value (sorted_syms[i - 1]))))
 809             {
 810               thisplace = i;
 811               break;
 812             }
 813         }
 814
 815       if (sorted_syms[thisplace]->section != sec)
 816         {
 817           /* We didn't find a good symbol with a smaller value.
 818              Look for one with a larger value.  */
 819           for (i = thisplace + 1; i < sorted_symcount; i++)
 820             {
 821               if (sorted_syms[i]->section == sec)
 822                 {
 823                   thisplace = i;
 824                   break;
 825                 }
 826             }
 827         }
 828
 829       if (sorted_syms[thisplace]->section != sec
 830           && (require_sec
 831               || ((abfd->flags & HAS_RELOC) != 0
 832                   && vma >= bfd_get_section_vma (abfd, sec)
 833                   && vma < (bfd_get_section_vma (abfd, sec)
 834                             + bfd_section_size (abfd, sec)))))
 835         {
 836           /* There is no suitable symbol.  */
 837           return NULL;
 838         }
 839     }
 840
 841   if (place != NULL)
 842     *place = thisplace;
 843
 844   return sorted_syms[thisplace];
 845 }
 846
 847 /* Print an address to INFO symbolically.  */
 848
 849 static void
 850 objdump_print_addr_with_sym (abfd, sec, sym, vma, info, skip_zeroes)
 851      bfd *abfd;
 852      asection *sec;
 853      asymbol *sym;
 854      bfd_vma vma;
 855      struct disassemble_info *info;
 856      boolean skip_zeroes;
 857 {
 858   objdump_print_value (vma, info, skip_zeroes);
 859
 860   if (sym == NULL)
 861     {
 862       bfd_vma secaddr;
 863
 864       (*info->fprintf_func) (info->stream, " <%s",
 865                              bfd_get_section_name (abfd, sec));
 866       secaddr = bfd_get_section_vma (abfd, sec);
 867       if (vma < secaddr)
 868         {
 869           (*info->fprintf_func) (info->stream, "-0x");
 870           objdump_print_value (secaddr - vma, info, true);
 871         }
 872       else if (vma > secaddr)
 873         {
 874           (*info->fprintf_func) (info->stream, "+0x");
 875           objdump_print_value (vma - secaddr, info, true);
 876         }
 877       (*info->fprintf_func) (info->stream, ">");
 878     }
 879   else
 880     {
 881       (*info->fprintf_func) (info->stream, " <");
 882       objdump_print_symname (abfd, info, sym);
 883       if (bfd_asymbol_value (sym) > vma)
 884         {
 885           (*info->fprintf_func) (info->stream, "-0x");
 886           objdump_print_value (bfd_asymbol_value (sym) - vma, info, true);
 887         }
 888       else if (vma > bfd_asymbol_value (sym))
 889         {
 890           (*info->fprintf_func) (info->stream, "+0x");
 891           objdump_print_value (vma - bfd_asymbol_value (sym), info, true);
 892         }
 893       (*info->fprintf_func) (info->stream, ">");
 894     }
 895 }
 896
 897 /* Print VMA to INFO, symbolically if possible.  If SKIP_ZEROES is
 898    true, don't output leading zeroes.  */
 899
 900 static void
 901 objdump_print_addr (vma, info, skip_zeroes)
 902      bfd_vma vma;
 903      struct disassemble_info *info;
 904      boolean skip_zeroes;
 905 {
 906   struct objdump_disasm_info *aux;
 907   asymbol *sym;
 908
 909   if (sorted_symcount < 1)
 910     {
 911       (*info->fprintf_func) (info->stream, "0x");
 912       objdump_print_value (vma, info, skip_zeroes);
 913       return;
 914     }
 915
 916   aux = (struct objdump_disasm_info *) info->application_data;
 917   sym = find_symbol_for_address (aux->abfd, aux->sec, vma, aux->require_sec,
 918                                  (long *) NULL);
 919   objdump_print_addr_with_sym (aux->abfd, aux->sec, sym, vma, info,
 920                                skip_zeroes);
 921 }
 922
 923 /* Print VMA to INFO.  This function is passed to the disassembler
 924    routine.  */
 925
 926 static void
 927 objdump_print_address (vma, info)
 928      bfd_vma vma;
 929      struct disassemble_info *info;
 930 {
 931   objdump_print_addr (vma, info, ! prefix_addresses);
 932 }
 933
 934 /* Determine of the given address has a symbol associated with it.  */
 935
 936 static int
 937 objdump_symbol_at_address (vma, info)
 938      bfd_vma vma;
 939      struct disassemble_info * info;
 940 {
 941   struct objdump_disasm_info * aux;
 942   asymbol * sym;
 943
 944   /* No symbols - do not bother checking.  */
 945   if (sorted_symcount < 1)
 946     return 0;
 947
 948   aux = (struct objdump_disasm_info *) info->application_data;
 949   sym = find_symbol_for_address (aux->abfd, aux->sec, vma, aux->require_sec,
 950                                  (long *) NULL);
 951
 952   return (sym != NULL && (bfd_asymbol_value (sym) == vma));
 953 }
 954
 955 /* Hold the last function name and the last line number we displayed
 956    in a disassembly.  */
 957
 958 static char *prev_functionname;
 959 static unsigned int prev_line;
 960
 961 /* We keep a list of all files that we have seen when doing a
 962    dissassembly with source, so that we know how much of the file to
 963    display.  This can be important for inlined functions.  */
 964
 965 struct print_file_list
 966 {
 967   struct print_file_list *next;
 968   char *filename;
 969   unsigned int line;
 970   FILE *f;
 971 };
 972
 973 static struct print_file_list *print_files;
 974
 975 /* The number of preceding context lines to show when we start
 976    displaying a file for the first time.  */
 977
 978 #define SHOW_PRECEDING_CONTEXT_LINES (5)
 979
 980 /* Skip ahead to a given line in a file, optionally printing each
 981    line.  */
 982
 983 static void
 984 skip_to_line PARAMS ((struct print_file_list *, unsigned int, boolean));
 985
 986 static void
 987 skip_to_line (p, line, show)
 988      struct print_file_list *p;
 989      unsigned int line;
 990      boolean show;
 991 {
 992   while (p->line < line)
 993     {
 994       char buf[100];
 995
 996       if (fgets (buf, sizeof buf, p->f) == NULL)
 997         {
 998           fclose (p->f);
 999           p->f = NULL;
1000           break;
1001         }
1002
1003       if (show)
1004         printf ("%s", buf);
1005
1006       if (strchr (buf, '\n') != NULL)
1007         ++p->line;
1008     }
1009 }
1010
1011 /* Show the line number, or the source line, in a dissassembly
1012    listing.  */
1013
1014 static void
1015 show_line (abfd, section, addr_offset)
1016      bfd *abfd;
1017      asection *section;
1018      bfd_vma addr_offset;
1019 {
1020   CONST char *filename;
1021   CONST char *functionname;
1022   unsigned int line;
1023
1024   if (! with_line_numbers && ! with_source_code)
1025     return;
1026
1027   if (! bfd_find_nearest_line (abfd, section, syms, addr_offset, &filename,
1028                                &functionname, &line))
1029     return;
1030
1031   if (filename != NULL && *filename == '\0')
1032     filename = NULL;
1033   if (functionname != NULL && *functionname == '\0')
1034     functionname = NULL;
1035
1036   if (with_line_numbers)
1037     {
1038       if (functionname != NULL
1039           && (prev_functionname == NULL
1040               || strcmp (functionname, prev_functionname) != 0))
1041         printf ("%s():\n", functionname);
1042       if (line > 0 && line != prev_line)
1043         printf ("%s:%u\n", filename == NULL ? "???" : filename, line);
1044     }
1045
1046   if (with_source_code
1047       && filename != NULL
1048       && line > 0)
1049     {
1050       struct print_file_list **pp, *p;
1051
1052       for (pp = &print_files; *pp != NULL; pp = &(*pp)->next)
1053         if (strcmp ((*pp)->filename, filename) == 0)
1054           break;
1055       p = *pp;
1056
1057       if (p != NULL)
1058         {
1059           if (p != print_files)
1060             {
1061               int l;
1062
1063               /* We have reencountered a file name which we saw
1064                  earlier.  This implies that either we are dumping out
1065                  code from an included file, or the same file was
1066                  linked in more than once.  There are two common cases
1067                  of an included file: inline functions in a header
1068                  file, and a bison or flex skeleton file.  In the
1069                  former case we want to just start printing (but we
1070                  back up a few lines to give context); in the latter
1071                  case we want to continue from where we left off.  I
1072                  can't think of a good way to distinguish the cases,
1073                  so I used a heuristic based on the file name.  */
1074               if (strcmp (p->filename + strlen (p->filename) - 2, ".h") != 0)
1075                 l = p->line;
1076               else
1077                 {
1078                   l = line - SHOW_PRECEDING_CONTEXT_LINES;
1079                   if (l <= 0)
1080                     l = 1;
1081                 }
1082
1083               if (p->f == NULL)
1084                 {
1085                   p->f = fopen (p->filename, "r");
1086                   p->line = 0;
1087                 }
1088               if (p->f != NULL)
1089                 skip_to_line (p, l, false);
1090
1091               if (print_files->f != NULL)
1092                 {
1093                   fclose (print_files->f);
1094                   print_files->f = NULL;
1095                 }
1096             }
1097
1098           if (p->f != NULL)
1099             {
1100               skip_to_line (p, line, true);
1101               *pp = p->next;
1102               p->next = print_files;
1103               print_files = p;
1104             }
1105         }
1106       else
1107         {
1108           FILE *f;
1109
1110           f = fopen (filename, "r");
1111           if (f != NULL)
1112             {
1113               int l;
1114
1115               p = ((struct print_file_list *)
1116                    xmalloc (sizeof (struct print_file_list)));
1117               p->filename = xmalloc (strlen (filename) + 1);
1118               strcpy (p->filename, filename);
1119               p->line = 0;
1120               p->f = f;
1121
1122               if (print_files != NULL && print_files->f != NULL)
1123                 {
1124                   fclose (print_files->f);
1125                   print_files->f = NULL;
1126                 }
1127               p->next = print_files;
1128               print_files = p;
1129
1130               l = line - SHOW_PRECEDING_CONTEXT_LINES;
1131               if (l <= 0)
1132                 l = 1;
1133               skip_to_line (p, l, false);
1134               if (p->f != NULL)
1135                 skip_to_line (p, line, true);
1136             }
1137         }
1138     }
1139
1140   if (functionname != NULL
1141       && (prev_functionname == NULL
1142           || strcmp (functionname, prev_functionname) != 0))
1143     {
1144       if (prev_functionname != NULL)
1145         free (prev_functionname);
1146       prev_functionname = xmalloc (strlen (functionname) + 1);
1147       strcpy (prev_functionname, functionname);
1148     }
1149
1150   if (line > 0 && line != prev_line)
1151     prev_line = line;
1152 }
1153
1154 /* Pseudo FILE object for strings.  */
1155 typedef struct
1156 {
1157   char *buffer;
1158   size_t size;
1159   char *current;
1160 } SFILE;
1161
1162 /* sprintf to a "stream" */
1163
1164 static int
1165 #ifdef ANSI_PROTOTYPES
1166 objdump_sprintf (SFILE *f, const char *format, ...)
1167 #else
1168 objdump_sprintf (va_alist)
1169      va_dcl
1170 #endif
1171 {
1172 #ifndef ANSI_PROTOTYPES
1173   SFILE *f;
1174   const char *format;
1175 #endif
1176   char *buf;
1177   va_list args;
1178   size_t n;
1179
1180 #ifdef ANSI_PROTOTYPES
1181   va_start (args, format);
1182 #else
1183   va_start (args);
1184   f = va_arg (args, SFILE *);
1185   format = va_arg (args, const char *);
1186 #endif
1187
1188   vasprintf (&buf, format, args);
1189
1190   va_end (args);
1191
1192   if (buf == NULL)
1193     {
1194       fprintf (stderr, _("Out of virtual memory\n"));
1195       exit (1);
1196     }
1197
1198   n = strlen (buf);
1199
1200   while ((size_t) ((f->buffer + f->size) - f->current) < n + 1)
1201     {
1202       size_t curroff;
1203
1204       curroff = f->current - f->buffer;
1205       f->size *= 2;
1206       f->buffer = xrealloc (f->buffer, f->size);
1207       f->current = f->buffer + curroff;
1208     }
1209
1210   memcpy (f->current, buf, n);
1211   f->current += n;
1212   f->current[0] = '\0';
1213
1214   free (buf);
1215
1216   return n;
1217 }
1218
1219 /* The number of zeroes we want to see before we start skipping them.
1220    The number is arbitrarily chosen.  */
1221
1222 #define SKIP_ZEROES (8)
1223
1224 /* The number of zeroes to skip at the end of a section.  If the
1225    number of zeroes at the end is between SKIP_ZEROES_AT_END and
1226    SKIP_ZEROES, they will be disassembled.  If there are fewer than
1227    SKIP_ZEROES_AT_END, they will be skipped.  This is a heuristic
1228    attempt to avoid disassembling zeroes inserted by section
1229    alignment.  */
1230
1231 #define SKIP_ZEROES_AT_END (3)
1232
1233 /* Disassemble some data in memory between given values.  */
1234
1235 static void
1236 disassemble_bytes (info, disassemble_fn, insns, data,
1237                    start_offset, stop_offset, relppp,
1238                    relppend)
1239      struct disassemble_info *info;
1240      disassembler_ftype disassemble_fn;
1241      boolean insns;
1242      bfd_byte *data;
1243      bfd_vma start_offset;
1244      bfd_vma stop_offset;
1245      arelent ***relppp;
1246      arelent **relppend;
1247 {
1248   struct objdump_disasm_info *aux;
1249   asection *section;
1250   int octets_per_line;
1251   boolean done_dot;
1252   int skip_addr_chars;
1253   bfd_vma addr_offset;
1254   int opb = info->octets_per_byte;
1255
1256   aux = (struct objdump_disasm_info *) info->application_data;
1257   section = aux->sec;
1258
1259   if (insns)
1260     octets_per_line = 4;
1261   else
1262     octets_per_line = 16;
1263
1264   /* Figure out how many characters to skip at the start of an
1265      address, to make the disassembly look nicer.  We discard leading
1266      zeroes in chunks of 4, ensuring that there is always a leading
1267      zero remaining.  */
1268   skip_addr_chars = 0;
1269   if (! prefix_addresses)
1270     {
1271       char buf[30];
1272       char *s;
1273
1274       sprintf_vma (buf, section->vma +
1275                    bfd_section_size (section->owner, section) / opb);
1276       s = buf;
1277       while (s[0] == '0' && s[1] == '0' && s[2] == '0' && s[3] == '0'
1278              && s[4] == '0')
1279         {
1280           skip_addr_chars += 4;
1281           s += 4;
1282         }
1283     }
1284
1285   info->insn_info_valid = 0;
1286
1287   done_dot = false;
1288   addr_offset = start_offset;
1289   while (addr_offset < stop_offset)
1290     {
1291       bfd_vma z;
1292       int octets = 0;
1293       boolean need_nl = false;
1294
1295       /* If we see more than SKIP_ZEROES octets of zeroes, we just
1296          print `...'.  */
1297       for (z = addr_offset * opb; z < stop_offset * opb; z++)
1298         if (data[z] != 0)
1299           break;
1300       if (! disassemble_zeroes
1301           && (info->insn_info_valid == 0
1302               || info->branch_delay_insns == 0)
1303           && (z - addr_offset * opb >= SKIP_ZEROES
1304               || (z == stop_offset * opb &&
1305                   z - addr_offset * opb < SKIP_ZEROES_AT_END)))
1306         {
1307           printf ("\t...\n");
1308
1309           /* If there are more nonzero octets to follow, we only skip
1310              zeroes in multiples of 4, to try to avoid running over
1311              the start of an instruction which happens to start with
1312              zero.  */
1313           if (z != stop_offset * opb)
1314             z = addr_offset * opb + ((z - addr_offset * opb) &~ 3);
1315
1316           octets = z - addr_offset * opb;
1317         }
1318       else
1319         {
1320           char buf[50];
1321           SFILE sfile;
1322           int bpc = 0;
1323           int pb = 0;
1324
1325           done_dot = false;
1326
1327           if (with_line_numbers || with_source_code)
1328             show_line (aux->abfd, section, addr_offset);
1329
1330           if (! prefix_addresses)
1331             {
1332               char *s;
1333
1334               sprintf_vma (buf, section->vma + addr_offset);
1335               for (s = buf + skip_addr_chars; *s == '0'; s++)
1336                 *s = ' ';
1337               if (*s == '\0')
1338                 *--s = '0';
1339               printf ("%s:\t", buf + skip_addr_chars);
1340             }
1341           else
1342             {
1343               aux->require_sec = true;
1344               objdump_print_address (section->vma + addr_offset, info);
1345               aux->require_sec = false;
1346               putchar (' ');
1347             }
1348
1349           if (insns)
1350             {
1351               sfile.size = 120;
1352               sfile.buffer = xmalloc (sfile.size);
1353               sfile.current = sfile.buffer;
1354               info->fprintf_func = (fprintf_ftype) objdump_sprintf;
1355               info->stream = (FILE *) &sfile;
1356               info->bytes_per_line = 0;
1357               info->bytes_per_chunk = 0;
1358
1359               /* FIXME: This is wrong.  It tests the number of octets
1360                  in the last instruction, not the current one.  */
1361               if (*relppp < relppend
1362                   && (**relppp)->address >= addr_offset
1363                   && (**relppp)->address < addr_offset + octets / opb)
1364                 info->flags = INSN_HAS_RELOC;
1365               else
1366                 info->flags = 0;
1367
1368               octets = (*disassemble_fn) (section->vma + addr_offset, info);
1369               info->fprintf_func = (fprintf_ftype) fprintf;
1370               info->stream = stdout;
1371               if (info->bytes_per_line != 0)
1372                 octets_per_line = info->bytes_per_line;
1373               if (octets < 0)
1374                 {
1375                   if (sfile.current != sfile.buffer)
1376                     printf ("%s\n", sfile.buffer);
1377                   free (sfile.buffer);
1378                   break;
1379                 }
1380             }
1381           else
1382             {
1383               bfd_vma j;
1384
1385               octets = octets_per_line;
1386               if (addr_offset + octets / opb > stop_offset)
1387                 octets = (stop_offset - addr_offset) * opb;
1388
1389               for (j = addr_offset * opb; j < addr_offset * opb + octets; ++j)
1390                 {
1391                   if (isprint (data[j]))
1392                     buf[j - addr_offset * opb] = data[j];
1393                   else
1394                     buf[j - addr_offset * opb] = '.';
1395                 }
1396               buf[j - addr_offset * opb] = '\0';
1397             }
1398
1399           if (prefix_addresses
1400               ? show_raw_insn > 0
1401               : show_raw_insn >= 0)
1402             {
1403               bfd_vma j;
1404
1405               /* If ! prefix_addresses and ! wide_output, we print
1406                  octets_per_line octets per line.  */
1407               pb = octets;
1408               if (pb > octets_per_line && ! prefix_addresses && ! wide_output)
1409                 pb = octets_per_line;
1410
1411               if (info->bytes_per_chunk)
1412                 bpc = info->bytes_per_chunk;
1413               else
1414                 bpc = 1;
1415
1416               for (j = addr_offset * opb; j < addr_offset * opb + pb; j += bpc)
1417                 {
1418                   int k;
1419                   if (bpc > 1 && info->display_endian == BFD_ENDIAN_LITTLE)
1420                     {
1421                       for (k = bpc - 1; k >= 0; k--)
1422                         printf ("%02x", (unsigned) data[j + k]);
1423                       putchar (' ');
1424                     }
1425                   else
1426                     {
1427                       for (k = 0; k < bpc; k++)
1428                         printf ("%02x", (unsigned) data[j + k]);
1429                       putchar (' ');
1430                     }
1431                 }
1432
1433               for (; pb < octets_per_line; pb += bpc)
1434                 {
1435                   int k;
1436
1437                   for (k = 0; k < bpc; k++)
1438                     printf ("  ");
1439                   putchar (' ');
1440                 }
1441
1442               /* Separate raw data from instruction by extra space.  */
1443               if (insns)
1444                 putchar ('\t');
1445               else
1446                 printf ("    ");
1447             }
1448
1449           if (! insns)
1450             printf ("%s", buf);
1451           else
1452             {
1453               printf ("%s", sfile.buffer);
1454               free (sfile.buffer);
1455             }
1456
1457           if (prefix_addresses
1458               ? show_raw_insn > 0
1459               : show_raw_insn >= 0)
1460             {
1461               while (pb < octets)
1462                 {
1463                   bfd_vma j;
1464                   char *s;
1465
1466                   putchar ('\n');
1467                   j = addr_offset * opb + pb;
1468
1469                   sprintf_vma (buf, section->vma + j / opb);
1470                   for (s = buf + skip_addr_chars; *s == '0'; s++)
1471                     *s = ' ';
1472                   if (*s == '\0')
1473                     *--s = '0';
1474                   printf ("%s:\t", buf + skip_addr_chars);
1475
1476                   pb += octets_per_line;
1477                   if (pb > octets)
1478                     pb = octets;
1479                   for (; j < addr_offset * opb + pb; j += bpc)
1480                     {
1481                       int k;
1482
1483                       if (bpc > 1 && info->display_endian == BFD_ENDIAN_LITTLE)
1484                         {
1485                           for (k = bpc - 1; k >= 0; k--)
1486                             printf ("%02x", (unsigned) data[j + k]);
1487                           putchar (' ');
1488                         }
1489                       else
1490                         {
1491                           for (k = 0; k < bpc; k++)
1492                             printf ("%02x", (unsigned) data[j + k]);
1493                           putchar (' ');
1494                         }
1495                     }
1496                 }
1497             }
1498
1499           if (!wide_output)
1500             putchar ('\n');
1501           else
1502             need_nl = true;
1503         }
1504
1505       if (dump_reloc_info
1506           && (section->flags & SEC_RELOC) != 0)
1507         {
1508           while ((*relppp) < relppend
1509                  && ((**relppp)->address >= (bfd_vma) addr_offset
1510                      && (**relppp)->address < (bfd_vma) addr_offset + octets / opb))
1511             {
1512               arelent *q;
1513
1514               q = **relppp;
1515
1516               if (wide_output)
1517                 putchar ('\t');
1518               else
1519                 printf ("\t\t\t");
1520
1521               objdump_print_value (section->vma + q->address, info, true);
1522
1523               printf (": %s\t", q->howto->name);
1524
1525               if (q->sym_ptr_ptr == NULL || *q->sym_ptr_ptr == NULL)
1526                 printf ("*unknown*");
1527               else
1528                 {
1529                   const char *sym_name;
1530
1531                   sym_name = bfd_asymbol_name (*q->sym_ptr_ptr);
1532                   if (sym_name != NULL && *sym_name != '\0')
1533                     objdump_print_symname (aux->abfd, info, *q->sym_ptr_ptr);
1534                   else
1535                     {
1536                       asection *sym_sec;
1537
1538                       sym_sec = bfd_get_section (*q->sym_ptr_ptr);
1539                       sym_name = bfd_get_section_name (aux->abfd, sym_sec);
1540                       if (sym_name == NULL || *sym_name == '\0')
1541                         sym_name = "*unknown*";
1542                       printf ("%s", sym_name);
1543                     }
1544                 }
1545
1546               if (q->addend)
1547                 {
1548                   printf ("+0x");
1549                   objdump_print_value (q->addend, info, true);
1550                 }
1551
1552               printf ("\n");
1553               need_nl = false;
1554               ++(*relppp);
1555             }
1556         }
1557
1558       if (need_nl)
1559         printf ("\n");
1560
1561       addr_offset += octets / opb;
1562     }
1563 }
1564
1565 /* Disassemble the contents of an object file.  */
1566
1567 static void
1568 disassemble_data (abfd)
1569      bfd *abfd;
1570 {
1571   long addr_offset;
1572   disassembler_ftype disassemble_fn;
1573   struct disassemble_info disasm_info;
1574   struct objdump_disasm_info aux;
1575   asection *section;
1576   int opb = bfd_octets_per_byte (abfd);
1577
1578   print_files = NULL;
1579   prev_functionname = NULL;
1580   prev_line = -1;
1581
1582   /* We make a copy of syms to sort.  We don't want to sort syms
1583      because that will screw up the relocs.  */
1584   sorted_syms = (asymbol **) xmalloc (symcount * sizeof (asymbol *));
1585   memcpy (sorted_syms, syms, symcount * sizeof (asymbol *));
1586
1587   sorted_symcount = remove_useless_symbols (sorted_syms, symcount);
1588
1589   /* Sort the symbols into section and symbol order */
1590   qsort (sorted_syms, sorted_symcount, sizeof (asymbol *), compare_symbols);
1591
1592   INIT_DISASSEMBLE_INFO(disasm_info, stdout, fprintf);
1593   disasm_info.application_data = (PTR) &aux;
1594   aux.abfd = abfd;
1595   aux.require_sec = false;
1596   disasm_info.print_address_func = objdump_print_address;
1597   disasm_info.symbol_at_address_func = objdump_symbol_at_address;
1598   disasm_info.octets_per_byte = opb;
1599
1600   if (machine != (char *) NULL)
1601     {
1602       const bfd_arch_info_type *info = bfd_scan_arch (machine);
1603       if (info == NULL)
1604         {
1605           fprintf (stderr, _("%s: Can't use supplied machine %s\n"),
1606                    program_name,
1607                    machine);
1608           exit (1);
1609         }
1610       abfd->arch_info = info;
1611     }
1612
1613   if (endian != BFD_ENDIAN_UNKNOWN)
1614     {
1615       struct bfd_target *xvec;
1616
1617       xvec = (struct bfd_target *) xmalloc (sizeof (struct bfd_target));
1618       memcpy (xvec, abfd->xvec, sizeof (struct bfd_target));
1619       xvec->byteorder = endian;
1620       abfd->xvec = xvec;
1621     }
1622
1623   disassemble_fn = disassembler (abfd);
1624   if (!disassemble_fn)
1625     {
1626       fprintf (stderr, _("%s: Can't disassemble for architecture %s\n"),
1627                program_name,
1628                bfd_printable_arch_mach (bfd_get_arch (abfd), 0));
1629       exit_status = 1;
1630       return;
1631     }
1632
1633   disasm_info.flavour = bfd_get_flavour (abfd);
1634   disasm_info.arch = bfd_get_arch (abfd);
1635   disasm_info.mach = bfd_get_mach (abfd);
1636   disasm_info.disassembler_options = disassembler_options;
1637
1638   if (bfd_big_endian (abfd))
1639     disasm_info.display_endian = disasm_info.endian = BFD_ENDIAN_BIG;
1640   else if (bfd_little_endian (abfd))
1641     disasm_info.display_endian = disasm_info.endian = BFD_ENDIAN_LITTLE;
1642   else
1643     /* ??? Aborting here seems too drastic.  We could default to big or little
1644        instead.  */
1645     disasm_info.endian = BFD_ENDIAN_UNKNOWN;
1646
1647   for (section = abfd->sections;
1648        section != (asection *) NULL;
1649        section = section->next)
1650     {
1651       bfd_byte *data = NULL;
1652       bfd_size_type datasize = 0;
1653       arelent **relbuf = NULL;
1654       arelent **relpp = NULL;
1655       arelent **relppend = NULL;
1656       long stop_offset;
1657       asymbol *sym = NULL;
1658       long place = 0;
1659
1660       if ((section->flags & SEC_LOAD) == 0
1661           || (! disassemble_all
1662               && only == NULL
1663               && (section->flags & SEC_CODE) == 0))
1664         continue;
1665       if (only != (char *) NULL && strcmp (only, section->name) != 0)
1666         continue;
1667
1668       if (dump_reloc_info
1669           && (section->flags & SEC_RELOC) != 0)
1670         {
1671           long relsize;
1672
1673           relsize = bfd_get_reloc_upper_bound (abfd, section);
1674           if (relsize < 0)
1675             bfd_fatal (bfd_get_filename (abfd));
1676
1677           if (relsize > 0)
1678             {
1679               long relcount;
1680
1681               relbuf = (arelent **) xmalloc (relsize);
1682               relcount = bfd_canonicalize_reloc (abfd, section, relbuf, syms);
1683               if (relcount < 0)
1684                 bfd_fatal (bfd_get_filename (abfd));
1685
1686               /* Sort the relocs by address.  */
1687               qsort (relbuf, relcount, sizeof (arelent *), compare_relocs);
1688
1689               relpp = relbuf;
1690               relppend = relpp + relcount;
1691
1692               /* Skip over the relocs belonging to addresses below the
1693                  start address.  */
1694               if (start_address != (bfd_vma) -1)
1695                 {
1696                   while (relpp < relppend
1697                          && (*relpp)->address < start_address)
1698                     ++relpp;
1699                 }
1700             }
1701         }
1702
1703       printf (_("Disassembly of section %s:\n"), section->name);
1704
1705       datasize = bfd_get_section_size_before_reloc (section);
1706       if (datasize == 0)
1707         continue;
1708
1709       data = (bfd_byte *) xmalloc ((size_t) datasize);
1710
1711       bfd_get_section_contents (abfd, section, data, 0, datasize);
1712
1713       aux.sec = section;
1714       disasm_info.buffer = data;
1715       disasm_info.buffer_vma = section->vma;
1716       disasm_info.buffer_length = datasize;
1717       if (start_address == (bfd_vma) -1
1718           || start_address < disasm_info.buffer_vma)
1719         addr_offset = 0;
1720       else
1721         addr_offset = start_address - disasm_info.buffer_vma;
1722       if (stop_address == (bfd_vma) -1)
1723         stop_offset = datasize / opb;
1724       else
1725         {
1726           if (stop_address < disasm_info.buffer_vma)
1727             stop_offset = 0;
1728           else
1729             stop_offset = stop_address - disasm_info.buffer_vma;
1730           if (stop_offset > disasm_info.buffer_length / opb)
1731             stop_offset = disasm_info.buffer_length / opb;
1732         }
1733
1734       sym = find_symbol_for_address (abfd, section, section->vma + addr_offset,
1735                                      true, &place);
1736
1737       while (addr_offset < stop_offset)
1738         {
1739           asymbol *nextsym;
1740           long nextstop_offset;
1741           boolean insns;
1742
1743           if (sym != NULL && bfd_asymbol_value (sym) <= section->vma + addr_offset)
1744             {
1745               int x;
1746
1747               for (x = place;
1748                    (x < sorted_symcount
1749                     && bfd_asymbol_value (sorted_syms[x]) <= section->vma + addr_offset);
1750                    ++x)
1751                 continue;
1752               disasm_info.symbols = & sorted_syms[place];
1753               disasm_info.num_symbols = x - place;
1754             }
1755           else
1756             disasm_info.symbols = NULL;
1757
1758           if (! prefix_addresses)
1759             {
1760               printf ("\n");
1761               objdump_print_addr_with_sym (abfd, section, sym,
1762                                            section->vma + addr_offset,
1763                                            &disasm_info,
1764                                            false);
1765               printf (":\n");
1766             }
1767
1768           if (sym != NULL && bfd_asymbol_value (sym) > section->vma + addr_offset)
1769             nextsym = sym;
1770           else if (sym == NULL)
1771             nextsym = NULL;
1772           else
1773             {
1774               /* Search forward for the next appropriate symbol in
1775                  SECTION.  Note that all the symbols are sorted
1776                  together into one big array, and that some sections
1777                  may have overlapping addresses.  */
1778               while (place < sorted_symcount
1779                      && (sorted_syms[place]->section != section
1780                          || (bfd_asymbol_value (sorted_syms[place])
1781                              <= bfd_asymbol_value (sym))))
1782                 ++place;
1783               if (place >= sorted_symcount)
1784                 nextsym = NULL;
1785               else
1786                 nextsym = sorted_syms[place];
1787             }
1788
1789           if (sym != NULL && bfd_asymbol_value (sym) > section->vma + addr_offset)
1790             {
1791               nextstop_offset = bfd_asymbol_value (sym) - section->vma;
1792               if (nextstop_offset > stop_offset)
1793                 nextstop_offset = stop_offset;
1794             }
1795           else if (nextsym == NULL)
1796             nextstop_offset = stop_offset;
1797           else
1798             {
1799               nextstop_offset = bfd_asymbol_value (nextsym) - section->vma;
1800               if (nextstop_offset > stop_offset)
1801                 nextstop_offset = stop_offset;
1802             }
1803
1804           /* If a symbol is explicitly marked as being an object
1805              rather than a function, just dump the bytes without
1806              disassembling them.  */
1807           if (disassemble_all
1808               || sym == NULL
1809               || bfd_asymbol_value (sym) > section->vma + addr_offset
1810               || ((sym->flags & BSF_OBJECT) == 0
1811                   && (strstr (bfd_asymbol_name (sym), "gnu_compiled")
1812                       == NULL)
1813                   && (strstr (bfd_asymbol_name (sym), "gcc2_compiled")
1814                       == NULL))
1815               || (sym->flags & BSF_FUNCTION) != 0)
1816             insns = true;
1817           else
1818             insns = false;
1819
1820           disassemble_bytes (&disasm_info, disassemble_fn, insns, data,
1821                              addr_offset, nextstop_offset, &relpp, relppend);
1822
1823           addr_offset = nextstop_offset;
1824           sym = nextsym;
1825         }
1826
1827       free (data);
1828       if (relbuf != NULL)
1829         free (relbuf);
1830     }
1831   free (sorted_syms);
1832 }
1833 \f
1834
1835 /* Define a table of stab values and print-strings.  We wish the initializer
1836    could be a direct-mapped table, but instead we build one the first
1837    time we need it.  */
1838
1839 static void dump_section_stabs PARAMS ((bfd *abfd, char *stabsect_name,
1840                                         char *strsect_name));
1841
1842 /* Dump the stabs sections from an object file that has a section that
1843    uses Sun stabs encoding.  */
1844
1845 static void
1846 dump_stabs (abfd)
1847      bfd *abfd;
1848 {
1849   dump_section_stabs (abfd, ".stab", ".stabstr");
1850   dump_section_stabs (abfd, ".stab.excl", ".stab.exclstr");
1851   dump_section_stabs (abfd, ".stab.index", ".stab.indexstr");
1852   dump_section_stabs (abfd, "$GDB_SYMBOLS$", "$GDB_STRINGS$");
1853 }
1854
1855 static bfd_byte *stabs;
1856 static bfd_size_type stab_size;
1857
1858 static char *strtab;
1859 static bfd_size_type stabstr_size;
1860
1861 /* Read ABFD's stabs section STABSECT_NAME into `stabs'
1862    and string table section STRSECT_NAME into `strtab'.
1863    If the section exists and was read, allocate the space and return true.
1864    Otherwise return false.  */
1865
1866 static boolean
1867 read_section_stabs (abfd, stabsect_name, strsect_name)
1868      bfd *abfd;
1869      const char *stabsect_name;
1870      const char *strsect_name;
1871 {
1872   asection *stabsect, *stabstrsect;
1873
1874   stabsect = bfd_get_section_by_name (abfd, stabsect_name);
1875   if (0 == stabsect)
1876     {
1877       printf (_("No %s section present\n\n"), stabsect_name);
1878       return false;
1879     }
1880
1881   stabstrsect = bfd_get_section_by_name (abfd, strsect_name);
1882   if (0 == stabstrsect)
1883     {
1884       fprintf (stderr, _("%s: %s has no %s section\n"), program_name,
1885                bfd_get_filename (abfd), strsect_name);
1886       exit_status = 1;
1887       return false;
1888     }
1889
1890   stab_size    = bfd_section_size (abfd, stabsect);
1891   stabstr_size = bfd_section_size (abfd, stabstrsect);
1892
1893   stabs  = (bfd_byte *) xmalloc (stab_size);
1894   strtab = (char *) xmalloc (stabstr_size);
1895
1896   if (! bfd_get_section_contents (abfd, stabsect, (PTR) stabs, 0, stab_size))
1897     {
1898       fprintf (stderr, _("%s: Reading %s section of %s failed: %s\n"),
1899                program_name, stabsect_name, bfd_get_filename (abfd),
1900                bfd_errmsg (bfd_get_error ()));
1901       free (stabs);
1902       free (strtab);
1903       exit_status = 1;
1904       return false;
1905     }
1906
1907   if (! bfd_get_section_contents (abfd, stabstrsect, (PTR) strtab, 0,
1908                                   stabstr_size))
1909     {
1910       fprintf (stderr, _("%s: Reading %s section of %s failed: %s\n"),
1911                program_name, strsect_name, bfd_get_filename (abfd),
1912                bfd_errmsg (bfd_get_error ()));
1913       free (stabs);
1914       free (strtab);
1915       exit_status = 1;
1916       return false;
1917     }
1918
1919   return true;
1920 }
1921
1922 /* Stabs entries use a 12 byte format:
1923      4 byte string table index
1924      1 byte stab type
1925      1 byte stab other field
1926      2 byte stab desc field
1927      4 byte stab value
1928    FIXME: This will have to change for a 64 bit object format.  */
1929
1930 #define STRDXOFF (0)
1931 #define TYPEOFF (4)
1932 #define OTHEROFF (5)
1933 #define DESCOFF (6)
1934 #define VALOFF (8)
1935 #define STABSIZE (12)
1936
1937 /* Print ABFD's stabs section STABSECT_NAME (in `stabs'),
1938    using string table section STRSECT_NAME (in `strtab').  */
1939
1940 static void
1941 print_section_stabs (abfd, stabsect_name, strsect_name)
1942      bfd *abfd;
1943      const char *stabsect_name;
1944      const char *strsect_name ATTRIBUTE_UNUSED;
1945 {
1946   int i;
1947   unsigned file_string_table_offset = 0, next_file_string_table_offset = 0;
1948   bfd_byte *stabp, *stabs_end;
1949
1950   stabp = stabs;
1951   stabs_end = stabp + stab_size;
1952
1953   printf (_("Contents of %s section:\n\n"), stabsect_name);
1954   printf ("Symnum n_type n_othr n_desc n_value  n_strx String\n");
1955
1956   /* Loop through all symbols and print them.
1957
1958      We start the index at -1 because there is a dummy symbol on
1959      the front of stabs-in-{coff,elf} sections that supplies sizes.  */
1960
1961   for (i = -1; stabp < stabs_end; stabp += STABSIZE, i++)
1962     {
1963       const char *name;
1964       unsigned long strx;
1965       unsigned char type, other;
1966       unsigned short desc;
1967       bfd_vma value;
1968
1969       strx = bfd_h_get_32 (abfd, stabp + STRDXOFF);
1970       type = bfd_h_get_8 (abfd, stabp + TYPEOFF);
1971       other = bfd_h_get_8 (abfd, stabp + OTHEROFF);
1972       desc = bfd_h_get_16 (abfd, stabp + DESCOFF);
1973       value = bfd_h_get_32 (abfd, stabp + VALOFF);
1974
1975       printf ("\n%-6d ", i);
1976       /* Either print the stab name, or, if unnamed, print its number
1977          again (makes consistent formatting for tools like awk). */
1978       name = bfd_get_stab_name (type);
1979       if (name != NULL)
1980         printf ("%-6s", name);
1981       else if (type == N_UNDF)
1982         printf ("HdrSym");
1983       else
1984         printf ("%-6d", type);
1985       printf (" %-6d %-6d ", other, desc);
1986       printf_vma (value);
1987       printf (" %-6lu", strx);
1988
1989       /* Symbols with type == 0 (N_UNDF) specify the length of the
1990          string table associated with this file.  We use that info
1991          to know how to relocate the *next* file's string table indices.  */
1992
1993       if (type == N_UNDF)
1994         {
1995           file_string_table_offset = next_file_string_table_offset;
1996           next_file_string_table_offset += value;
1997         }
1998       else
1999         {
2000           /* Using the (possibly updated) string table offset, print the
2001              string (if any) associated with this symbol.  */
2002
2003           if ((strx + file_string_table_offset) < stabstr_size)
2004             printf (" %s", &strtab[strx + file_string_table_offset]);
2005           else
2006             printf (" *");
2007         }
2008     }
2009   printf ("\n\n");
2010 }
2011
2012 static void
2013 dump_section_stabs (abfd, stabsect_name, strsect_name)
2014      bfd *abfd;
2015      char *stabsect_name;
2016      char *strsect_name;
2017 {
2018   asection *s;
2019
2020   /* Check for section names for which stabsect_name is a prefix, to
2021      handle .stab0, etc.  */
2022   for (s = abfd->sections;
2023        s != NULL;
2024        s = s->next)
2025     {
2026       int len;
2027
2028       len = strlen (stabsect_name);
2029
2030       /* If the prefix matches, and the files section name ends with a
2031          nul or a digit, then we match.  I.e., we want either an exact
2032          match or a section followed by a number.  */
2033       if (strncmp (stabsect_name, s->name, len) == 0
2034           && (s->name[len] == '\000'
2035               || isdigit ((unsigned char) s->name[len])))
2036         {
2037           if (read_section_stabs (abfd, s->name, strsect_name))
2038             {
2039               print_section_stabs (abfd, s->name, strsect_name);
2040               free (stabs);
2041               free (strtab);
2042             }
2043         }
2044     }
2045 }
2046 \f
2047 static void
2048 dump_bfd_header (abfd)
2049      bfd *abfd;
2050 {
2051   char *comma = "";
2052
2053   printf (_("architecture: %s, "),
2054           bfd_printable_arch_mach (bfd_get_arch (abfd),
2055                                    bfd_get_mach (abfd)));
2056   printf (_("flags 0x%08x:\n"), abfd->flags);
2057
2058 #define PF(x, y)    if (abfd->flags & x) {printf("%s%s", comma, y); comma=", ";}
2059   PF (HAS_RELOC, "HAS_RELOC");
2060   PF (EXEC_P, "EXEC_P");
2061   PF (HAS_LINENO, "HAS_LINENO");
2062   PF (HAS_DEBUG, "HAS_DEBUG");
2063   PF (HAS_SYMS, "HAS_SYMS");
2064   PF (HAS_LOCALS, "HAS_LOCALS");
2065   PF (DYNAMIC, "DYNAMIC");
2066   PF (WP_TEXT, "WP_TEXT");
2067   PF (D_PAGED, "D_PAGED");
2068   PF (BFD_IS_RELAXABLE, "BFD_IS_RELAXABLE");
2069   printf (_("\nstart address 0x"));
2070   printf_vma (abfd->start_address);
2071   printf ("\n");
2072 }
2073 \f
2074 static void
2075 dump_bfd_private_header (abfd)
2076 bfd *abfd;
2077 {
2078   bfd_print_private_bfd_data (abfd, stdout);
2079 }
2080
2081 /* Dump selected contents of ABFD */
2082
2083 static void
2084 dump_bfd (abfd)
2085      bfd *abfd;
2086 {
2087   /* If we are adjusting section VMA's, change them all now.  Changing
2088      the BFD information is a hack.  However, we must do it, or
2089      bfd_find_nearest_line will not do the right thing.  */
2090   if (adjust_section_vma != 0)
2091     {
2092       asection *s;
2093
2094       for (s = abfd->sections; s != NULL; s = s->next)
2095         {
2096           s->vma += adjust_section_vma;
2097           s->lma += adjust_section_vma;
2098         }
2099     }
2100
2101   printf (_("\n%s:     file format %s\n"), bfd_get_filename (abfd),
2102           abfd->xvec->name);
2103   if (dump_ar_hdrs)
2104     print_arelt_descr (stdout, abfd, true);
2105   if (dump_file_header)
2106     dump_bfd_header (abfd);
2107   if (dump_private_headers)
2108     dump_bfd_private_header (abfd);
2109   putchar ('\n');
2110   if (dump_section_headers)
2111     dump_headers (abfd);
2112   if (dump_symtab || dump_reloc_info || disassemble || dump_debugging)
2113     {
2114       syms = slurp_symtab (abfd);
2115     }
2116   if (dump_dynamic_symtab || dump_dynamic_reloc_info)
2117     {
2118       dynsyms = slurp_dynamic_symtab (abfd);
2119     }
2120   if (dump_symtab)
2121     dump_symbols (abfd, false);
2122   if (dump_dynamic_symtab)
2123     dump_symbols (abfd, true);
2124   if (dump_stab_section_info)
2125     dump_stabs (abfd);
2126   if (dump_reloc_info && ! disassemble)
2127     dump_relocs (abfd);
2128   if (dump_dynamic_reloc_info)
2129     dump_dynamic_relocs (abfd);
2130   if (dump_section_contents)
2131     dump_data (abfd);
2132   if (disassemble)
2133     disassemble_data (abfd);
2134   if (dump_debugging)
2135     {
2136       PTR dhandle;
2137
2138       dhandle = read_debugging_info (abfd, syms, symcount);
2139       if (dhandle != NULL)
2140         {
2141           if (! print_debugging_info (stdout, dhandle))
2142             {
2143               fprintf (stderr,
2144                        _("%s: printing debugging information failed\n"),
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   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               fprintf (stderr, _("%s: unrecognized -E option\n"),
2856                        program_name);
2857               usage (stderr, 1);
2858             }
2859           break;
2860         case OPTION_ENDIAN:
2861           if (strncmp (optarg, "big", strlen (optarg)) == 0)
2862             endian = BFD_ENDIAN_BIG;
2863           else if (strncmp (optarg, "little", strlen (optarg)) == 0)
2864             endian = BFD_ENDIAN_LITTLE;
2865           else
2866             {
2867               fprintf (stderr, _("%s: unrecognized --endian type `%s'\n"),
2868                       program_name, optarg);
2869               usage (stderr, 1);
2870             }
2871           break;
2872
2873         case 'f':
2874           dump_file_header = true;
2875           seenflag = true;
2876           break;
2877         case 'i':
2878           formats_info = true;
2879           seenflag = true;
2880           break;
2881         case 'p':
2882           dump_private_headers = true;
2883           seenflag = true;
2884           break;
2885         case 'x':
2886           dump_private_headers = true;
2887           dump_symtab = true;
2888           dump_reloc_info = true;
2889           dump_file_header = true;
2890           dump_ar_hdrs = true;
2891           dump_section_headers = true;
2892           seenflag = true;
2893           break;
2894         case 't':
2895           dump_symtab = true;
2896           seenflag = true;
2897           break;
2898         case 'T':
2899           dump_dynamic_symtab = true;
2900           seenflag = true;
2901           break;
2902         case 'd':
2903           disassemble = true;
2904           seenflag = true;
2905           break;
2906         case 'z':
2907           disassemble_zeroes = true;
2908           break;
2909         case 'D':
2910           disassemble = true;
2911           disassemble_all = true;
2912           seenflag = true;
2913           break;
2914         case 'S':
2915           disassemble = true;
2916           with_source_code = true;
2917           seenflag = true;
2918           break;
2919         case 'g':
2920           dump_debugging = 1;
2921           seenflag = true;
2922           break;
2923         case 'G':
2924           dump_stab_section_info = true;
2925           seenflag = true;
2926           break;
2927         case 's':
2928           dump_section_contents = true;
2929           seenflag = true;
2930           break;
2931         case 'r':
2932           dump_reloc_info = true;
2933           seenflag = true;
2934           break;
2935         case 'R':
2936           dump_dynamic_reloc_info = true;
2937           seenflag = true;
2938           break;
2939         case 'a':
2940           dump_ar_hdrs = true;
2941           seenflag = true;
2942           break;
2943         case 'h':
2944           dump_section_headers = true;
2945           seenflag = true;
2946           break;
2947         case 'H':
2948           usage (stdout, 0);
2949           seenflag = true;
2950         case 'V':
2951           show_version = true;
2952           seenflag = true;
2953           break;
2954
2955         default:
2956           usage (stderr, 1);
2957         }
2958     }
2959
2960   if (show_version)
2961     print_version ("objdump");
2962
2963   if (seenflag == false)
2964     usage (stderr, 2);
2965
2966   if (formats_info)
2967     display_info ();
2968   else
2969     {
2970       if (optind == argc)
2971         display_file ("a.out", target);
2972       else
2973         for (; optind < argc;)
2974           display_file (argv[optind++], target);
2975     }
2976
2977   END_PROGRESS (program_name);
2978
2979   return exit_status;
2980 }