binutils/objdump.c

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