binutils/objdump.c

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