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