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