binutils/objdump.c

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