binutils/objdump.c

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