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