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               if (q->howto == NULL)
1574                 printf (": *unknown*\t");
1575               else if (q->howto->name)
1576                 printf (": %s\t", q->howto->name);
1577               else
1578                 printf (": %d\t", q->howto->type);
1579
1580               if (q->sym_ptr_ptr == NULL || *q->sym_ptr_ptr == NULL)
1581                 printf ("*unknown*");
1582               else
1583                 {
1584                   const char *sym_name;
1585
1586                   sym_name = bfd_asymbol_name (*q->sym_ptr_ptr);
1587                   if (sym_name != NULL && *sym_name != '\0')
1588                     objdump_print_symname (aux->abfd, info, *q->sym_ptr_ptr);
1589                   else
1590                     {
1591                       asection *sym_sec;
1592
1593                       sym_sec = bfd_get_section (*q->sym_ptr_ptr);
1594                       sym_name = bfd_get_section_name (aux->abfd, sym_sec);
1595                       if (sym_name == NULL || *sym_name == '\0')
1596                         sym_name = "*unknown*";
1597                       printf ("%s", sym_name);
1598                     }
1599                 }
1600
1601               if (q->addend)
1602                 {
1603                   printf ("+0x");
1604                   objdump_print_value (q->addend, info, TRUE);
1605                 }
1606
1607               printf ("\n");
1608               need_nl = FALSE;
1609             }
1610           ++(*relppp);
1611         }
1612
1613       if (need_nl)
1614         printf ("\n");
1615
1616       addr_offset += octets / opb;
1617     }
1618
1619   free (sfile.buffer);
1620 }
1621
1622 static void
1623 disassemble_section (bfd *abfd, asection *section, void *info)
1624 {
1625   struct disassemble_info *    pinfo = (struct disassemble_info *) info;
1626   struct objdump_disasm_info * paux;
1627   unsigned int                 opb = pinfo->octets_per_byte;
1628   bfd_byte *                   data = NULL;
1629   bfd_size_type                datasize = 0;
1630   arelent **                   rel_pp = NULL;
1631   arelent **                   rel_ppstart = NULL;
1632   arelent **                   rel_ppend;
1633   unsigned long                stop_offset;
1634   asymbol *                    sym = NULL;
1635   long                         place = 0;
1636   long                         rel_count;
1637   bfd_vma                      rel_offset;
1638   unsigned long                addr_offset;
1639
1640   /* Sections that do not contain machine
1641      code are not normally disassembled.  */
1642   if (! disassemble_all
1643       && only == NULL
1644       && ((section->flags & (SEC_CODE | SEC_HAS_CONTENTS))
1645           != (SEC_CODE | SEC_HAS_CONTENTS)))
1646     return;
1647
1648   if (! process_section_p (section))
1649     return;
1650
1651   datasize = bfd_get_section_size (section);
1652   if (datasize == 0)
1653     return;
1654
1655   /* Decide which set of relocs to use.  Load them if necessary.  */
1656   paux = (struct objdump_disasm_info *) pinfo->application_data;
1657   if (paux->dynrelbuf)
1658     {
1659       rel_pp = paux->dynrelbuf;
1660       rel_count = paux->dynrelcount;
1661       /* Dynamic reloc addresses are absolute, non-dynamic are section
1662          relative.  REL_OFFSET specifies the reloc address corresponding
1663          to the start of this section.  */
1664       rel_offset = section->vma;
1665     }
1666   else
1667     {
1668       rel_count = 0;
1669       rel_pp = NULL;
1670       rel_offset = 0;
1671
1672       if ((section->flags & SEC_RELOC) != 0
1673 #ifndef DISASSEMBLER_NEEDS_RELOCS
1674           && dump_reloc_info
1675 #endif
1676           )
1677         {
1678           long relsize;
1679
1680           relsize = bfd_get_reloc_upper_bound (abfd, section);
1681           if (relsize < 0)
1682             bfd_fatal (bfd_get_filename (abfd));
1683
1684           if (relsize > 0)
1685             {
1686               rel_ppstart = rel_pp = xmalloc (relsize);
1687               rel_count = bfd_canonicalize_reloc (abfd, section, rel_pp, syms);
1688               if (rel_count < 0)
1689                 bfd_fatal (bfd_get_filename (abfd));
1690
1691               /* Sort the relocs by address.  */
1692               qsort (rel_pp, rel_count, sizeof (arelent *), compare_relocs);
1693             }
1694         }
1695
1696     }
1697   rel_ppend = rel_pp + rel_count;
1698
1699   data = xmalloc (datasize);
1700
1701   bfd_get_section_contents (abfd, section, data, 0, datasize);
1702
1703   paux->sec = section;
1704   pinfo->buffer = data;
1705   pinfo->buffer_vma = section->vma;
1706   pinfo->buffer_length = datasize;
1707   pinfo->section = section;
1708
1709   if (start_address == (bfd_vma) -1
1710       || start_address < pinfo->buffer_vma)
1711     addr_offset = 0;
1712   else
1713     addr_offset = start_address - pinfo->buffer_vma;
1714
1715   if (stop_address == (bfd_vma) -1)
1716     stop_offset = datasize / opb;
1717   else
1718     {
1719       if (stop_address < pinfo->buffer_vma)
1720         stop_offset = 0;
1721       else
1722         stop_offset = stop_address - pinfo->buffer_vma;
1723       if (stop_offset > pinfo->buffer_length / opb)
1724         stop_offset = pinfo->buffer_length / opb;
1725     }
1726
1727   /* Skip over the relocs belonging to addresses below the
1728      start address.  */
1729   while (rel_pp < rel_ppend
1730          && (*rel_pp)->address < rel_offset + addr_offset)
1731     ++rel_pp;
1732
1733   printf (_("Disassembly of section %s:\n"), section->name);
1734
1735   /* Find the nearest symbol forwards from our current position.  */
1736   paux->require_sec = TRUE;
1737   sym = find_symbol_for_address (section->vma + addr_offset, info, &place);
1738   paux->require_sec = FALSE;
1739
1740   /* Disassemble a block of instructions up to the address associated with
1741      the symbol we have just found.  Then print the symbol and find the
1742      next symbol on.  Repeat until we have disassembled the entire section
1743      or we have reached the end of the address range we are interested in.  */
1744   while (addr_offset < stop_offset)
1745     {
1746       bfd_vma addr;
1747       asymbol *nextsym;
1748       unsigned long nextstop_offset;
1749       bfd_boolean insns;
1750
1751       addr = section->vma + addr_offset;
1752
1753       if (sym != NULL && bfd_asymbol_value (sym) <= addr)
1754         {
1755           int x;
1756
1757           for (x = place;
1758                (x < sorted_symcount
1759                 && (bfd_asymbol_value (sorted_syms[x]) <= addr));
1760                ++x)
1761             continue;
1762
1763           pinfo->symbols = sorted_syms + place;
1764           pinfo->num_symbols = x - place;
1765         }
1766       else
1767         {
1768           pinfo->symbols = NULL;
1769           pinfo->num_symbols = 0;
1770         }
1771
1772       if (! prefix_addresses)
1773         {
1774           pinfo->fprintf_func (pinfo->stream, "\n");
1775           objdump_print_addr_with_sym (abfd, section, sym, addr,
1776                                        pinfo, FALSE);
1777           pinfo->fprintf_func (pinfo->stream, ":\n");
1778         }
1779
1780       if (sym != NULL && bfd_asymbol_value (sym) > addr)
1781         nextsym = sym;
1782       else if (sym == NULL)
1783         nextsym = NULL;
1784       else
1785         {
1786 #define is_valid_next_sym(SYM) \
1787   ((SYM)->section == section \
1788    && (bfd_asymbol_value (SYM) > bfd_asymbol_value (sym)) \
1789    && pinfo->symbol_is_valid (SYM, pinfo))
1790
1791           /* Search forward for the next appropriate symbol in
1792              SECTION.  Note that all the symbols are sorted
1793              together into one big array, and that some sections
1794              may have overlapping addresses.  */
1795           while (place < sorted_symcount
1796                  && ! is_valid_next_sym (sorted_syms [place]))
1797             ++place;
1798
1799           if (place >= sorted_symcount)
1800             nextsym = NULL;
1801           else
1802             nextsym = sorted_syms[place];
1803         }
1804
1805       if (sym != NULL && bfd_asymbol_value (sym) > addr)
1806         nextstop_offset = bfd_asymbol_value (sym) - section->vma;
1807       else if (nextsym == NULL)
1808         nextstop_offset = stop_offset;
1809       else
1810         nextstop_offset = bfd_asymbol_value (nextsym) - section->vma;
1811
1812       if (nextstop_offset > stop_offset)
1813         nextstop_offset = stop_offset;
1814
1815       /* If a symbol is explicitly marked as being an object
1816          rather than a function, just dump the bytes without
1817          disassembling them.  */
1818       if (disassemble_all
1819           || sym == NULL
1820           || bfd_asymbol_value (sym) > addr
1821           || ((sym->flags & BSF_OBJECT) == 0
1822               && (strstr (bfd_asymbol_name (sym), "gnu_compiled")
1823                   == NULL)
1824               && (strstr (bfd_asymbol_name (sym), "gcc2_compiled")
1825                   == NULL))
1826           || (sym->flags & BSF_FUNCTION) != 0)
1827         insns = TRUE;
1828       else
1829         insns = FALSE;
1830
1831       disassemble_bytes (pinfo, paux->disassemble_fn, insns, data,
1832                          addr_offset, nextstop_offset,
1833                          rel_offset, &rel_pp, rel_ppend);
1834
1835       addr_offset = nextstop_offset;
1836       sym = nextsym;
1837     }
1838
1839   free (data);
1840
1841   if (rel_ppstart != NULL)
1842     free (rel_ppstart);
1843 }
1844
1845 /* Disassemble the contents of an object file.  */
1846
1847 static void
1848 disassemble_data (bfd *abfd)
1849 {
1850   struct disassemble_info disasm_info;
1851   struct objdump_disasm_info aux;
1852   long i;
1853
1854   print_files = NULL;
1855   prev_functionname = NULL;
1856   prev_line = -1;
1857
1858   /* We make a copy of syms to sort.  We don't want to sort syms
1859      because that will screw up the relocs.  */
1860   sorted_symcount = symcount ? symcount : dynsymcount;
1861   sorted_syms = xmalloc ((sorted_symcount + synthcount) * sizeof (asymbol *));
1862   memcpy (sorted_syms, symcount ? syms : dynsyms,
1863           sorted_symcount * sizeof (asymbol *));
1864
1865   sorted_symcount = remove_useless_symbols (sorted_syms, sorted_symcount);
1866
1867   for (i = 0; i < synthcount; ++i)
1868     {
1869       sorted_syms[sorted_symcount] = synthsyms + i;
1870       ++sorted_symcount;
1871     }
1872
1873   /* Sort the symbols into section and symbol order.  */
1874   qsort (sorted_syms, sorted_symcount, sizeof (asymbol *), compare_symbols);
1875
1876   init_disassemble_info (&disasm_info, stdout, (fprintf_ftype) fprintf);
1877
1878   disasm_info.application_data = (void *) &aux;
1879   aux.abfd = abfd;
1880   aux.require_sec = FALSE;
1881   aux.dynrelbuf = NULL;
1882   aux.dynrelcount = 0;
1883 #ifdef DISASSEMBLER_NEEDS_RELOCS
1884   aux.reloc = NULL;
1885 #endif
1886
1887   disasm_info.print_address_func = objdump_print_address;
1888   disasm_info.symbol_at_address_func = objdump_symbol_at_address;
1889
1890   if (machine != NULL)
1891     {
1892       const bfd_arch_info_type *info = bfd_scan_arch (machine);
1893
1894       if (info == NULL)
1895         fatal (_("Can't use supplied machine %s"), machine);
1896
1897       abfd->arch_info = info;
1898     }
1899
1900   if (endian != BFD_ENDIAN_UNKNOWN)
1901     {
1902       struct bfd_target *xvec;
1903
1904       xvec = xmalloc (sizeof (struct bfd_target));
1905       memcpy (xvec, abfd->xvec, sizeof (struct bfd_target));
1906       xvec->byteorder = endian;
1907       abfd->xvec = xvec;
1908     }
1909
1910   /* Use libopcodes to locate a suitable disassembler.  */
1911   aux.disassemble_fn = disassembler (abfd);
1912   if (!aux.disassemble_fn)
1913     {
1914       non_fatal (_("Can't disassemble for architecture %s\n"),
1915                  bfd_printable_arch_mach (bfd_get_arch (abfd), 0));
1916       exit_status = 1;
1917       return;
1918     }
1919
1920   disasm_info.flavour = bfd_get_flavour (abfd);
1921   disasm_info.arch = bfd_get_arch (abfd);
1922   disasm_info.mach = bfd_get_mach (abfd);
1923   disasm_info.disassembler_options = disassembler_options;
1924   disasm_info.octets_per_byte = bfd_octets_per_byte (abfd);
1925   disasm_info.skip_zeroes = DEFAULT_SKIP_ZEROES;
1926   disasm_info.skip_zeroes_at_end = DEFAULT_SKIP_ZEROES_AT_END;
1927
1928   if (bfd_big_endian (abfd))
1929     disasm_info.display_endian = disasm_info.endian = BFD_ENDIAN_BIG;
1930   else if (bfd_little_endian (abfd))
1931     disasm_info.display_endian = disasm_info.endian = BFD_ENDIAN_LITTLE;
1932   else
1933     /* ??? Aborting here seems too drastic.  We could default to big or little
1934        instead.  */
1935     disasm_info.endian = BFD_ENDIAN_UNKNOWN;
1936
1937   /* Allow the target to customize the info structure.  */
1938   disassemble_init_for_target (& disasm_info);
1939
1940   /* Pre-load the dynamic relocs if we are going
1941      to be dumping them along with the disassembly.  */
1942   if (dump_dynamic_reloc_info)
1943     {
1944       long relsize = bfd_get_dynamic_reloc_upper_bound (abfd);
1945
1946       if (relsize < 0)
1947         bfd_fatal (bfd_get_filename (abfd));
1948
1949       if (relsize > 0)
1950         {
1951           aux.dynrelbuf = xmalloc (relsize);
1952           aux.dynrelcount = bfd_canonicalize_dynamic_reloc (abfd,
1953                                                             aux.dynrelbuf,
1954                                                             dynsyms);
1955           if (aux.dynrelcount < 0)
1956             bfd_fatal (bfd_get_filename (abfd));
1957
1958           /* Sort the relocs by address.  */
1959           qsort (aux.dynrelbuf, aux.dynrelcount, sizeof (arelent *),
1960                  compare_relocs);
1961         }
1962     }
1963
1964   bfd_map_over_sections (abfd, disassemble_section, & disasm_info);
1965
1966   if (aux.dynrelbuf != NULL)
1967     free (aux.dynrelbuf);
1968   free (sorted_syms);
1969 }
1970 \f
1971 /* Read ABFD's stabs section STABSECT_NAME, and return a pointer to
1972    it.  Return NULL on failure.   */
1973
1974 static char *
1975 read_section_stabs (bfd *abfd, const char *sect_name, bfd_size_type *size_ptr)
1976 {
1977   asection *stabsect;
1978   bfd_size_type size;
1979   char *contents;
1980
1981   stabsect = bfd_get_section_by_name (abfd, sect_name);
1982   if (stabsect == NULL)
1983     {
1984       printf (_("No %s section present\n\n"), sect_name);
1985       return FALSE;
1986     }
1987
1988   size = bfd_section_size (abfd, stabsect);
1989   contents  = xmalloc (size);
1990
1991   if (! bfd_get_section_contents (abfd, stabsect, contents, 0, size))
1992     {
1993       non_fatal (_("Reading %s section of %s failed: %s"),
1994                  sect_name, bfd_get_filename (abfd),
1995                  bfd_errmsg (bfd_get_error ()));
1996       free (contents);
1997       exit_status = 1;
1998       return NULL;
1999     }
2000
2001   *size_ptr = size;
2002
2003   return contents;
2004 }
2005
2006 /* Stabs entries use a 12 byte format:
2007      4 byte string table index
2008      1 byte stab type
2009      1 byte stab other field
2010      2 byte stab desc field
2011      4 byte stab value
2012    FIXME: This will have to change for a 64 bit object format.  */
2013
2014 #define STRDXOFF  (0)
2015 #define TYPEOFF   (4)
2016 #define OTHEROFF  (5)
2017 #define DESCOFF   (6)
2018 #define VALOFF    (8)
2019 #define STABSIZE (12)
2020
2021 /* Print ABFD's stabs section STABSECT_NAME (in `stabs'),
2022    using string table section STRSECT_NAME (in `strtab').  */
2023
2024 static void
2025 print_section_stabs (bfd *abfd,
2026                      const char *stabsect_name,
2027                      unsigned *string_offset_ptr)
2028 {
2029   int i;
2030   unsigned file_string_table_offset = 0;
2031   unsigned next_file_string_table_offset = *string_offset_ptr;
2032   bfd_byte *stabp, *stabs_end;
2033
2034   stabp = stabs;
2035   stabs_end = stabp + stab_size;
2036
2037   printf (_("Contents of %s section:\n\n"), stabsect_name);
2038   printf ("Symnum n_type n_othr n_desc n_value  n_strx String\n");
2039
2040   /* Loop through all symbols and print them.
2041
2042      We start the index at -1 because there is a dummy symbol on
2043      the front of stabs-in-{coff,elf} sections that supplies sizes.  */
2044   for (i = -1; stabp < stabs_end; stabp += STABSIZE, i++)
2045     {
2046       const char *name;
2047       unsigned long strx;
2048       unsigned char type, other;
2049       unsigned short desc;
2050       bfd_vma value;
2051
2052       strx = bfd_h_get_32 (abfd, stabp + STRDXOFF);
2053       type = bfd_h_get_8 (abfd, stabp + TYPEOFF);
2054       other = bfd_h_get_8 (abfd, stabp + OTHEROFF);
2055       desc = bfd_h_get_16 (abfd, stabp + DESCOFF);
2056       value = bfd_h_get_32 (abfd, stabp + VALOFF);
2057
2058       printf ("\n%-6d ", i);
2059       /* Either print the stab name, or, if unnamed, print its number
2060          again (makes consistent formatting for tools like awk).  */
2061       name = bfd_get_stab_name (type);
2062       if (name != NULL)
2063         printf ("%-6s", name);
2064       else if (type == N_UNDF)
2065         printf ("HdrSym");
2066       else
2067         printf ("%-6d", type);
2068       printf (" %-6d %-6d ", other, desc);
2069       bfd_printf_vma (abfd, value);
2070       printf (" %-6lu", strx);
2071
2072       /* Symbols with type == 0 (N_UNDF) specify the length of the
2073          string table associated with this file.  We use that info
2074          to know how to relocate the *next* file's string table indices.  */
2075       if (type == N_UNDF)
2076         {
2077           file_string_table_offset = next_file_string_table_offset;
2078           next_file_string_table_offset += value;
2079         }
2080       else
2081         {
2082           /* Using the (possibly updated) string table offset, print the
2083              string (if any) associated with this symbol.  */
2084           if ((strx + file_string_table_offset) < stabstr_size)
2085             printf (" %s", &strtab[strx + file_string_table_offset]);
2086           else
2087             printf (" *");
2088         }
2089     }
2090   printf ("\n\n");
2091   *string_offset_ptr = next_file_string_table_offset;
2092 }
2093
2094 typedef struct
2095 {
2096   const char * section_name;
2097   const char * string_section_name;
2098   unsigned string_offset;
2099 }
2100 stab_section_names;
2101
2102 static void
2103 find_stabs_section (bfd *abfd, asection *section, void *names)
2104 {
2105   int len;
2106   stab_section_names * sought = (stab_section_names *) names;
2107
2108   /* Check for section names for which stabsect_name is a prefix, to
2109      handle .stab.N, etc.  */
2110   len = strlen (sought->section_name);
2111
2112   /* If the prefix matches, and the files section name ends with a
2113      nul or a digit, then we match.  I.e., we want either an exact
2114      match or a section followed by a number.  */
2115   if (strncmp (sought->section_name, section->name, len) == 0
2116       && (section->name[len] == 0
2117           || (section->name[len] == '.' && ISDIGIT (section->name[len + 1]))))
2118     {
2119       if (strtab == NULL)
2120         strtab = read_section_stabs (abfd, sought->string_section_name,
2121                                      &stabstr_size);
2122
2123       if (strtab)
2124         {
2125           stabs = (bfd_byte *) read_section_stabs (abfd, section->name,
2126                                                    &stab_size);
2127           if (stabs)
2128             print_section_stabs (abfd, section->name, &sought->string_offset);
2129         }
2130     }
2131 }
2132
2133 static void
2134 dump_stabs_section (bfd *abfd, char *stabsect_name, char *strsect_name)
2135 {
2136   stab_section_names s;
2137
2138   s.section_name = stabsect_name;
2139   s.string_section_name = strsect_name;
2140   s.string_offset = 0;
2141
2142   bfd_map_over_sections (abfd, find_stabs_section, & s);
2143
2144   free (strtab);
2145   strtab = NULL;
2146 }
2147
2148 /* Dump the any sections containing stabs debugging information.  */
2149
2150 static void
2151 dump_stabs (bfd *abfd)
2152 {
2153   dump_stabs_section (abfd, ".stab", ".stabstr");
2154   dump_stabs_section (abfd, ".stab.excl", ".stab.exclstr");
2155   dump_stabs_section (abfd, ".stab.index", ".stab.indexstr");
2156   dump_stabs_section (abfd, "$GDB_SYMBOLS$", "$GDB_STRINGS$");
2157 }
2158 \f
2159 static void
2160 dump_bfd_header (bfd *abfd)
2161 {
2162   char *comma = "";
2163
2164   printf (_("architecture: %s, "),
2165           bfd_printable_arch_mach (bfd_get_arch (abfd),
2166                                    bfd_get_mach (abfd)));
2167   printf (_("flags 0x%08x:\n"), abfd->flags);
2168
2169 #define PF(x, y)    if (abfd->flags & x) {printf("%s%s", comma, y); comma=", ";}
2170   PF (HAS_RELOC, "HAS_RELOC");
2171   PF (EXEC_P, "EXEC_P");
2172   PF (HAS_LINENO, "HAS_LINENO");
2173   PF (HAS_DEBUG, "HAS_DEBUG");
2174   PF (HAS_SYMS, "HAS_SYMS");
2175   PF (HAS_LOCALS, "HAS_LOCALS");
2176   PF (DYNAMIC, "DYNAMIC");
2177   PF (WP_TEXT, "WP_TEXT");
2178   PF (D_PAGED, "D_PAGED");
2179   PF (BFD_IS_RELAXABLE, "BFD_IS_RELAXABLE");
2180   PF (HAS_LOAD_PAGE, "HAS_LOAD_PAGE");
2181   printf (_("\nstart address 0x"));
2182   bfd_printf_vma (abfd, abfd->start_address);
2183   printf ("\n");
2184 }
2185
2186 \f
2187 static void
2188 dump_bfd_private_header (bfd *abfd)
2189 {
2190   bfd_print_private_bfd_data (abfd, stdout);
2191 }
2192
2193 \f
2194 /* Display a section in hexadecimal format with associated characters.
2195    Each line prefixed by the zero padded address.  */
2196
2197 static void
2198 dump_section (bfd *abfd, asection *section, void *dummy ATTRIBUTE_UNUSED)
2199 {
2200   bfd_byte *data = 0;
2201   bfd_size_type datasize;
2202   bfd_size_type addr_offset;
2203   bfd_size_type start_offset;
2204   bfd_size_type stop_offset;
2205   unsigned int opb = bfd_octets_per_byte (abfd);
2206   /* Bytes per line.  */
2207   const int onaline = 16;
2208   char buf[64];
2209   int count;
2210   int width;
2211
2212   if ((section->flags & SEC_HAS_CONTENTS) == 0)
2213     return;
2214
2215   if (! process_section_p (section))
2216     return;
2217
2218   if ((datasize = bfd_section_size (abfd, section)) == 0)
2219     return;
2220
2221   printf (_("Contents of section %s:\n"), section->name);
2222
2223   data = xmalloc (datasize);
2224
2225   bfd_get_section_contents (abfd, section, data, 0, datasize);
2226
2227   /* Compute the address range to display.  */
2228   if (start_address == (bfd_vma) -1
2229       || start_address < section->vma)
2230     start_offset = 0;
2231   else
2232     start_offset = start_address - section->vma;
2233
2234   if (stop_address == (bfd_vma) -1)
2235     stop_offset = datasize / opb;
2236   else
2237     {
2238       if (stop_address < section->vma)
2239         stop_offset = 0;
2240       else
2241         stop_offset = stop_address - section->vma;
2242
2243       if (stop_offset > datasize / opb)
2244         stop_offset = datasize / opb;
2245     }
2246
2247   width = 4;
2248
2249   bfd_sprintf_vma (abfd, buf, start_offset + section->vma);
2250   if (strlen (buf) >= sizeof (buf))
2251     abort ();
2252
2253   count = 0;
2254   while (buf[count] == '0' && buf[count+1] != '\0')
2255     count++;
2256   count = strlen (buf) - count;
2257   if (count > width)
2258     width = count;
2259
2260   bfd_sprintf_vma (abfd, buf, stop_offset + section->vma - 1);
2261   if (strlen (buf) >= sizeof (buf))
2262     abort ();
2263
2264   count = 0;
2265   while (buf[count] == '0' && buf[count+1] != '\0')
2266     count++;
2267   count = strlen (buf) - count;
2268   if (count > width)
2269     width = count;
2270
2271   for (addr_offset = start_offset;
2272        addr_offset < stop_offset; addr_offset += onaline / opb)
2273     {
2274       bfd_size_type j;
2275
2276       bfd_sprintf_vma (abfd, buf, (addr_offset + section->vma));
2277       count = strlen (buf);
2278       if ((size_t) count >= sizeof (buf))
2279         abort ();
2280
2281       putchar (' ');
2282       while (count < width)
2283         {
2284           putchar ('0');
2285           count++;
2286         }
2287       fputs (buf + count - width, stdout);
2288       putchar (' ');
2289
2290       for (j = addr_offset * opb;
2291            j < addr_offset * opb + onaline; j++)
2292         {
2293           if (j < stop_offset * opb)
2294             printf ("%02x", (unsigned) (data[j]));
2295           else
2296             printf ("  ");
2297           if ((j & 3) == 3)
2298             printf (" ");
2299         }
2300
2301       printf (" ");
2302       for (j = addr_offset * opb;
2303            j < addr_offset * opb + onaline; j++)
2304         {
2305           if (j >= stop_offset * opb)
2306             printf (" ");
2307           else
2308             printf ("%c", ISPRINT (data[j]) ? data[j] : '.');
2309         }
2310       putchar ('\n');
2311     }
2312   free (data);
2313 }
2314
2315 /* Actually display the various requested regions.  */
2316
2317 static void
2318 dump_data (bfd *abfd)
2319 {
2320   bfd_map_over_sections (abfd, dump_section, NULL);
2321 }
2322
2323 /* Should perhaps share code and display with nm?  */
2324
2325 static void
2326 dump_symbols (bfd *abfd ATTRIBUTE_UNUSED, bfd_boolean dynamic)
2327 {
2328   asymbol **current;
2329   long max;
2330   long count;
2331
2332   if (dynamic)
2333     {
2334       current = dynsyms;
2335       max = dynsymcount;
2336       printf ("DYNAMIC SYMBOL TABLE:\n");
2337     }
2338   else
2339     {
2340       current = syms;
2341       max = symcount;
2342       printf ("SYMBOL TABLE:\n");
2343     }
2344
2345   if (max == 0)
2346     printf (_("no symbols\n"));
2347
2348   for (count = 0; count < max; count++)
2349     {
2350       bfd *cur_bfd;
2351
2352       if (*current == NULL)
2353         printf (_("no information for symbol number %ld\n"), count);
2354
2355       else if ((cur_bfd = bfd_asymbol_bfd (*current)) == NULL)
2356         printf (_("could not determine the type of symbol number %ld\n"),
2357                 count);
2358
2359       else if (process_section_p ((* current)->section)
2360                && (dump_special_syms
2361                    || !bfd_is_target_special_symbol (cur_bfd, *current)))
2362         {
2363           const char *name = (*current)->name;
2364
2365           if (do_demangle && name != NULL && *name != '\0')
2366             {
2367               char *alloc;
2368
2369               /* If we want to demangle the name, we demangle it
2370                  here, and temporarily clobber it while calling
2371                  bfd_print_symbol.  FIXME: This is a gross hack.  */
2372               alloc = demangle (cur_bfd, name);
2373               (*current)->name = alloc;
2374               bfd_print_symbol (cur_bfd, stdout, *current,
2375                                 bfd_print_symbol_all);
2376               (*current)->name = name;
2377               free (alloc);
2378             }
2379           else
2380             bfd_print_symbol (cur_bfd, stdout, *current,
2381                               bfd_print_symbol_all);
2382           printf ("\n");
2383         }
2384
2385       current++;
2386     }
2387   printf ("\n\n");
2388 }
2389 \f
2390 static void
2391 dump_reloc_set (bfd *abfd, asection *sec, arelent **relpp, long relcount)
2392 {
2393   arelent **p;
2394   char *last_filename, *last_functionname;
2395   unsigned int last_line;
2396
2397   /* Get column headers lined up reasonably.  */
2398   {
2399     static int width;
2400
2401     if (width == 0)
2402       {
2403         char buf[30];
2404
2405         bfd_sprintf_vma (abfd, buf, (bfd_vma) -1);
2406         width = strlen (buf) - 7;
2407       }
2408     printf ("OFFSET %*s TYPE %*s VALUE \n", width, "", 12, "");
2409   }
2410
2411   last_filename = NULL;
2412   last_functionname = NULL;
2413   last_line = 0;
2414
2415   for (p = relpp; relcount && *p != NULL; p++, relcount--)
2416     {
2417       arelent *q = *p;
2418       const char *filename, *functionname;
2419       unsigned int line;
2420       const char *sym_name;
2421       const char *section_name;
2422
2423       if (start_address != (bfd_vma) -1
2424           && q->address < start_address)
2425         continue;
2426       if (stop_address != (bfd_vma) -1
2427           && q->address > stop_address)
2428         continue;
2429
2430       if (with_line_numbers
2431           && sec != NULL
2432           && bfd_find_nearest_line (abfd, sec, syms, q->address,
2433                                     &filename, &functionname, &line))
2434         {
2435           if (functionname != NULL
2436               && (last_functionname == NULL
2437                   || strcmp (functionname, last_functionname) != 0))
2438             {
2439               printf ("%s():\n", functionname);
2440               if (last_functionname != NULL)
2441                 free (last_functionname);
2442               last_functionname = xstrdup (functionname);
2443             }
2444
2445           if (line > 0
2446               && (line != last_line
2447                   || (filename != NULL
2448                       && last_filename != NULL
2449                       && strcmp (filename, last_filename) != 0)))
2450             {
2451               printf ("%s:%u\n", filename == NULL ? "???" : filename, line);
2452               last_line = line;
2453               if (last_filename != NULL)
2454                 free (last_filename);
2455               if (filename == NULL)
2456                 last_filename = NULL;
2457               else
2458                 last_filename = xstrdup (filename);
2459             }
2460         }
2461
2462       if (q->sym_ptr_ptr && *q->sym_ptr_ptr)
2463         {
2464           sym_name = (*(q->sym_ptr_ptr))->name;
2465           section_name = (*(q->sym_ptr_ptr))->section->name;
2466         }
2467       else
2468         {
2469           sym_name = NULL;
2470           section_name = NULL;
2471         }
2472
2473       bfd_printf_vma (abfd, q->address);
2474       if (q->howto == NULL)
2475         printf (" *unknown*         ");
2476       else if (q->howto->name)
2477         printf (" %-16s  ", q->howto->name);
2478       else
2479         printf (" %-16d  ", q->howto->type);
2480       if (sym_name)
2481         objdump_print_symname (abfd, NULL, *q->sym_ptr_ptr);
2482       else
2483         {
2484           if (section_name == NULL)
2485             section_name = "*unknown*";
2486           printf ("[%s]", section_name);
2487         }
2488
2489       if (q->addend)
2490         {
2491           printf ("+0x");
2492           bfd_printf_vma (abfd, q->addend);
2493         }
2494
2495       printf ("\n");
2496     }
2497 }
2498
2499 static void
2500 dump_relocs_in_section (bfd *abfd,
2501                         asection *section,
2502                         void *dummy ATTRIBUTE_UNUSED)
2503 {
2504   arelent **relpp;
2505   long relcount;
2506   long relsize;
2507
2508   if (   bfd_is_abs_section (section)
2509       || bfd_is_und_section (section)
2510       || bfd_is_com_section (section)
2511       || (! process_section_p (section))
2512       || ((section->flags & SEC_RELOC) == 0))
2513     return;
2514
2515   relsize = bfd_get_reloc_upper_bound (abfd, section);
2516   if (relsize < 0)
2517     bfd_fatal (bfd_get_filename (abfd));
2518
2519   printf ("RELOCATION RECORDS FOR [%s]:", section->name);
2520
2521   if (relsize == 0)
2522     {
2523       printf (" (none)\n\n");
2524       return;
2525     }
2526
2527   relpp = xmalloc (relsize);
2528   relcount = bfd_canonicalize_reloc (abfd, section, relpp, syms);
2529
2530   if (relcount < 0)
2531     bfd_fatal (bfd_get_filename (abfd));
2532   else if (relcount == 0)
2533     printf (" (none)\n\n");
2534   else
2535     {
2536       printf ("\n");
2537       dump_reloc_set (abfd, section, relpp, relcount);
2538       printf ("\n\n");
2539     }
2540   free (relpp);
2541 }
2542
2543 static void
2544 dump_relocs (bfd *abfd)
2545 {
2546   bfd_map_over_sections (abfd, dump_relocs_in_section, NULL);
2547 }
2548
2549 static void
2550 dump_dynamic_relocs (bfd *abfd)
2551 {
2552   long relsize;
2553   arelent **relpp;
2554   long relcount;
2555
2556   relsize = bfd_get_dynamic_reloc_upper_bound (abfd);
2557   if (relsize < 0)
2558     bfd_fatal (bfd_get_filename (abfd));
2559
2560   printf ("DYNAMIC RELOCATION RECORDS");
2561
2562   if (relsize == 0)
2563     printf (" (none)\n\n");
2564   else
2565     {
2566       relpp = xmalloc (relsize);
2567       relcount = bfd_canonicalize_dynamic_reloc (abfd, relpp, dynsyms);
2568
2569       if (relcount < 0)
2570         bfd_fatal (bfd_get_filename (abfd));
2571       else if (relcount == 0)
2572         printf (" (none)\n\n");
2573       else
2574         {
2575           printf ("\n");
2576           dump_reloc_set (abfd, NULL, relpp, relcount);
2577           printf ("\n\n");
2578         }
2579       free (relpp);
2580     }
2581 }
2582
2583 /* Creates a table of paths, to search for source files.  */
2584
2585 static void
2586 add_include_path (const char *path)
2587 {
2588   if (path[0] == 0)
2589     return;
2590   include_path_count++;
2591   include_paths = xrealloc (include_paths,
2592                             include_path_count * sizeof (*include_paths));
2593 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
2594   if (path[1] == ':' && path[2] == 0)
2595     path = concat (path, ".", (const char *) 0);
2596 #endif
2597   include_paths[include_path_count - 1] = path;
2598 }
2599
2600 static void
2601 adjust_addresses (bfd *abfd ATTRIBUTE_UNUSED,
2602                   asection *section,
2603                   void *dummy ATTRIBUTE_UNUSED)
2604 {
2605   section->vma += adjust_section_vma;
2606   section->lma += adjust_section_vma;
2607 }
2608
2609 /* Dump selected contents of ABFD.  */
2610
2611 static void
2612 dump_bfd (bfd *abfd)
2613 {
2614   /* If we are adjusting section VMA's, change them all now.  Changing
2615      the BFD information is a hack.  However, we must do it, or
2616      bfd_find_nearest_line will not do the right thing.  */
2617   if (adjust_section_vma != 0)
2618     bfd_map_over_sections (abfd, adjust_addresses, NULL);
2619
2620   if (! dump_debugging_tags)
2621     printf (_("\n%s:     file format %s\n"), bfd_get_filename (abfd),
2622             abfd->xvec->name);
2623   if (dump_ar_hdrs)
2624     print_arelt_descr (stdout, abfd, TRUE);
2625   if (dump_file_header)
2626     dump_bfd_header (abfd);
2627   if (dump_private_headers)
2628     dump_bfd_private_header (abfd);
2629   if (! dump_debugging_tags)
2630     putchar ('\n');
2631   if (dump_section_headers)
2632     dump_headers (abfd);
2633
2634   if (dump_symtab || dump_reloc_info || disassemble || dump_debugging)
2635     syms = slurp_symtab (abfd);
2636   if (dump_dynamic_symtab || dump_dynamic_reloc_info
2637       || (disassemble && bfd_get_dynamic_symtab_upper_bound (abfd) > 0))
2638     dynsyms = slurp_dynamic_symtab (abfd);
2639   if (disassemble)
2640     {
2641       synthcount = bfd_get_synthetic_symtab (abfd, symcount, syms,
2642                                              dynsymcount, dynsyms, &synthsyms);
2643       if (synthcount < 0)
2644         synthcount = 0;
2645     }
2646
2647   if (dump_symtab)
2648     dump_symbols (abfd, FALSE);
2649   if (dump_dynamic_symtab)
2650     dump_symbols (abfd, TRUE);
2651   if (dump_stab_section_info)
2652     dump_stabs (abfd);
2653   if (dump_reloc_info && ! disassemble)
2654     dump_relocs (abfd);
2655   if (dump_dynamic_reloc_info && ! disassemble)
2656     dump_dynamic_relocs (abfd);
2657   if (dump_section_contents)
2658     dump_data (abfd);
2659   if (disassemble)
2660     disassemble_data (abfd);
2661
2662   if (dump_debugging)
2663     {
2664       void *dhandle;
2665
2666       dhandle = read_debugging_info (abfd, syms, symcount);
2667       if (dhandle != NULL)
2668         {
2669           if (! print_debugging_info (stdout, dhandle, abfd, syms, demangle,
2670               dump_debugging_tags ? TRUE : FALSE))
2671             {
2672               non_fatal (_("%s: printing debugging information failed"),
2673                          bfd_get_filename (abfd));
2674               exit_status = 1;
2675             }
2676         }
2677     }
2678
2679   if (syms)
2680     {
2681       free (syms);
2682       syms = NULL;
2683     }
2684
2685   if (dynsyms)
2686     {
2687       free (dynsyms);
2688       dynsyms = NULL;
2689     }
2690
2691   if (synthsyms)
2692     {
2693       free (synthsyms);
2694       synthsyms = NULL;
2695     }
2696
2697   symcount = 0;
2698   dynsymcount = 0;
2699   synthcount = 0;
2700 }
2701
2702 static void
2703 display_bfd (bfd *abfd)
2704 {
2705   char **matching;
2706
2707   if (bfd_check_format_matches (abfd, bfd_object, &matching))
2708     {
2709       dump_bfd (abfd);
2710       return;
2711     }
2712
2713   if (bfd_get_error () == bfd_error_file_ambiguously_recognized)
2714     {
2715       nonfatal (bfd_get_filename (abfd));
2716       list_matching_formats (matching);
2717       free (matching);
2718       return;
2719     }
2720
2721   if (bfd_get_error () != bfd_error_file_not_recognized)
2722     {
2723       nonfatal (bfd_get_filename (abfd));
2724       return;
2725     }
2726
2727   if (bfd_check_format_matches (abfd, bfd_core, &matching))
2728     {
2729       dump_bfd (abfd);
2730       return;
2731     }
2732
2733   nonfatal (bfd_get_filename (abfd));
2734
2735   if (bfd_get_error () == bfd_error_file_ambiguously_recognized)
2736     {
2737       list_matching_formats (matching);
2738       free (matching);
2739     }
2740 }
2741
2742 static void
2743 display_file (char *filename, char *target)
2744 {
2745   bfd *file;
2746   bfd *arfile = NULL;
2747
2748   if (get_file_size (filename) < 1)
2749     return;
2750
2751   file = bfd_openr (filename, target);
2752   if (file == NULL)
2753     {
2754       nonfatal (filename);
2755       return;
2756     }
2757
2758   /* If the file is an archive, process all of its elements.  */
2759   if (bfd_check_format (file, bfd_archive))
2760     {
2761       bfd *last_arfile = NULL;
2762
2763       printf (_("In archive %s:\n"), bfd_get_filename (file));
2764       for (;;)
2765         {
2766           bfd_set_error (bfd_error_no_error);
2767
2768           arfile = bfd_openr_next_archived_file (file, arfile);
2769           if (arfile == NULL)
2770             {
2771               if (bfd_get_error () != bfd_error_no_more_archived_files)
2772                 nonfatal (bfd_get_filename (file));
2773               break;
2774             }
2775
2776           display_bfd (arfile);
2777
2778           if (last_arfile != NULL)
2779             bfd_close (last_arfile);
2780           last_arfile = arfile;
2781         }
2782
2783       if (last_arfile != NULL)
2784         bfd_close (last_arfile);
2785     }
2786   else
2787     display_bfd (file);
2788
2789   bfd_close (file);
2790 }
2791 \f
2792 int
2793 main (int argc, char **argv)
2794 {
2795   int c;
2796   char *target = default_target;
2797   bfd_boolean seenflag = FALSE;
2798
2799 #if defined (HAVE_SETLOCALE)
2800 #if defined (HAVE_LC_MESSAGES)
2801   setlocale (LC_MESSAGES, "");
2802 #endif
2803   setlocale (LC_CTYPE, "");
2804 #endif
2805
2806   bindtextdomain (PACKAGE, LOCALEDIR);
2807   textdomain (PACKAGE);
2808
2809   program_name = *argv;
2810   xmalloc_set_program_name (program_name);
2811
2812   START_PROGRESS (program_name, 0);
2813
2814   bfd_init ();
2815   set_default_bfd_target ();
2816
2817   while ((c = getopt_long (argc, argv, "pib:m:M:VvCdDlfaHhrRtTxsSI:j:wE:zgeG",
2818                            long_options, (int *) 0))
2819          != EOF)
2820     {
2821       switch (c)
2822         {
2823         case 0:
2824           break;                /* We've been given a long option.  */
2825         case 'm':
2826           machine = optarg;
2827           break;
2828         case 'M':
2829           if (disassembler_options)
2830             /* Ignore potential memory leak for now.  */
2831             disassembler_options = concat (disassembler_options, ",",
2832                                            optarg, NULL);
2833           else
2834             disassembler_options = optarg;
2835           break;
2836         case 'j':
2837           if (only_used == only_size)
2838             {
2839               only_size += 8;
2840               only = xrealloc (only, only_size * sizeof (char *));
2841             }
2842           only [only_used++] = optarg;
2843           break;
2844         case 'l':
2845           with_line_numbers = TRUE;
2846           break;
2847         case 'b':
2848           target = optarg;
2849           break;
2850         case 'C':
2851           do_demangle = TRUE;
2852           if (optarg != NULL)
2853             {
2854               enum demangling_styles style;
2855
2856               style = cplus_demangle_name_to_style (optarg);
2857               if (style == unknown_demangling)
2858                 fatal (_("unknown demangling style `%s'"),
2859                        optarg);
2860
2861               cplus_demangle_set_style (style);
2862             }
2863           break;
2864         case 'w':
2865           wide_output = TRUE;
2866           break;
2867         case OPTION_ADJUST_VMA:
2868           adjust_section_vma = parse_vma (optarg, "--adjust-vma");
2869           break;
2870         case OPTION_START_ADDRESS:
2871           start_address = parse_vma (optarg, "--start-address");
2872           break;
2873         case OPTION_STOP_ADDRESS:
2874           stop_address = parse_vma (optarg, "--stop-address");
2875           break;
2876         case 'E':
2877           if (strcmp (optarg, "B") == 0)
2878             endian = BFD_ENDIAN_BIG;
2879           else if (strcmp (optarg, "L") == 0)
2880             endian = BFD_ENDIAN_LITTLE;
2881           else
2882             {
2883               non_fatal (_("unrecognized -E option"));
2884               usage (stderr, 1);
2885             }
2886           break;
2887         case OPTION_ENDIAN:
2888           if (strncmp (optarg, "big", strlen (optarg)) == 0)
2889             endian = BFD_ENDIAN_BIG;
2890           else if (strncmp (optarg, "little", strlen (optarg)) == 0)
2891             endian = BFD_ENDIAN_LITTLE;
2892           else
2893             {
2894               non_fatal (_("unrecognized --endian type `%s'"), optarg);
2895               usage (stderr, 1);
2896             }
2897           break;
2898
2899         case 'f':
2900           dump_file_header = TRUE;
2901           seenflag = TRUE;
2902           break;
2903         case 'i':
2904           formats_info = TRUE;
2905           seenflag = TRUE;
2906           break;
2907         case 'I':
2908           add_include_path (optarg);
2909           break;
2910         case 'p':
2911           dump_private_headers = TRUE;
2912           seenflag = TRUE;
2913           break;
2914         case 'x':
2915           dump_private_headers = TRUE;
2916           dump_symtab = TRUE;
2917           dump_reloc_info = TRUE;
2918           dump_file_header = TRUE;
2919           dump_ar_hdrs = TRUE;
2920           dump_section_headers = TRUE;
2921           seenflag = TRUE;
2922           break;
2923         case 't':
2924           dump_symtab = TRUE;
2925           seenflag = TRUE;
2926           break;
2927         case 'T':
2928           dump_dynamic_symtab = TRUE;
2929           seenflag = TRUE;
2930           break;
2931         case 'd':
2932           disassemble = TRUE;
2933           seenflag = TRUE;
2934           break;
2935         case 'z':
2936           disassemble_zeroes = TRUE;
2937           break;
2938         case 'D':
2939           disassemble = TRUE;
2940           disassemble_all = TRUE;
2941           seenflag = TRUE;
2942           break;
2943         case 'S':
2944           disassemble = TRUE;
2945           with_source_code = TRUE;
2946           seenflag = TRUE;
2947           break;
2948         case 'g':
2949           dump_debugging = 1;
2950           seenflag = TRUE;
2951           break;
2952         case 'e':
2953           dump_debugging = 1;
2954           dump_debugging_tags = 1;
2955           do_demangle = TRUE;
2956           seenflag = TRUE;
2957           break;
2958         case 'G':
2959           dump_stab_section_info = TRUE;
2960           seenflag = TRUE;
2961           break;
2962         case 's':
2963           dump_section_contents = TRUE;
2964           seenflag = TRUE;
2965           break;
2966         case 'r':
2967           dump_reloc_info = TRUE;
2968           seenflag = TRUE;
2969           break;
2970         case 'R':
2971           dump_dynamic_reloc_info = TRUE;
2972           seenflag = TRUE;
2973           break;
2974         case 'a':
2975           dump_ar_hdrs = TRUE;
2976           seenflag = TRUE;
2977           break;
2978         case 'h':
2979           dump_section_headers = TRUE;
2980           seenflag = TRUE;
2981           break;
2982         case 'H':
2983           usage (stdout, 0);
2984           seenflag = TRUE;
2985         case 'v':
2986         case 'V':
2987           show_version = TRUE;
2988           seenflag = TRUE;
2989           break;
2990
2991         default:
2992           usage (stderr, 1);
2993         }
2994     }
2995
2996   if (show_version)
2997     print_version ("objdump");
2998
2999   if (!seenflag)
3000     usage (stderr, 2);
3001
3002   if (formats_info)
3003     exit_status = display_info ();
3004   else
3005     {
3006       if (optind == argc)
3007         display_file ("a.out", target);
3008       else
3009         for (; optind < argc;)
3010           display_file (argv[optind++], target);
3011     }
3012
3013   END_PROGRESS (program_name);
3014
3015   return exit_status;
3016 }