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