binutils/objdump.c

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