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 #ifndef SKIP_ZEROES
1226 #define SKIP_ZEROES (8)
1227 #endif
1228
1229 /* The number of zeroes to skip at the end of a section.  If the
1230    number of zeroes at the end is between SKIP_ZEROES_AT_END and
1231    SKIP_ZEROES, they will be disassembled.  If there are fewer than
1232    SKIP_ZEROES_AT_END, they will be skipped.  This is a heuristic
1233    attempt to avoid disassembling zeroes inserted by section
1234    alignment.  */
1235
1236 #ifndef SKIP_ZEROES_AT_END
1237 #define SKIP_ZEROES_AT_END (3)
1238 #endif
1239
1240 /* Disassemble some data in memory between given values.  */
1241
1242 static void
1243 disassemble_bytes (info, disassemble_fn, insns, data,
1244                    start_offset, stop_offset, relppp,
1245                    relppend)
1246      struct disassemble_info *info;
1247      disassembler_ftype disassemble_fn;
1248      boolean insns;
1249      bfd_byte *data;
1250      bfd_vma start_offset;
1251      bfd_vma stop_offset;
1252      arelent ***relppp;
1253      arelent **relppend;
1254 {
1255   struct objdump_disasm_info *aux;
1256   asection *section;
1257   int octets_per_line;
1258   boolean done_dot;
1259   int skip_addr_chars;
1260   bfd_vma addr_offset;
1261   int opb = info->octets_per_byte;
1262
1263   aux = (struct objdump_disasm_info *) info->application_data;
1264   section = aux->sec;
1265
1266   if (insns)
1267     octets_per_line = 4;
1268   else
1269     octets_per_line = 16;
1270
1271   /* Figure out how many characters to skip at the start of an
1272      address, to make the disassembly look nicer.  We discard leading
1273      zeroes in chunks of 4, ensuring that there is always a leading
1274      zero remaining.  */
1275   skip_addr_chars = 0;
1276   if (! prefix_addresses)
1277     {
1278       char buf[30];
1279       char *s;
1280
1281       sprintf_vma (buf, section->vma +
1282                    bfd_section_size (section->owner, section) / opb);
1283       s = buf;
1284       while (s[0] == '0' && s[1] == '0' && s[2] == '0' && s[3] == '0'
1285              && s[4] == '0')
1286         {
1287           skip_addr_chars += 4;
1288           s += 4;
1289         }
1290     }
1291
1292   info->insn_info_valid = 0;
1293
1294   done_dot = false;
1295   addr_offset = start_offset;
1296   while (addr_offset < stop_offset)
1297     {
1298       bfd_vma z;
1299       int octets = 0;
1300       boolean need_nl = false;
1301
1302       /* If we see more than SKIP_ZEROES octets of zeroes, we just
1303          print `...'.  */
1304       for (z = addr_offset * opb; z < stop_offset * opb; z++)
1305         if (data[z] != 0)
1306           break;
1307       if (! disassemble_zeroes
1308           && (info->insn_info_valid == 0
1309               || info->branch_delay_insns == 0)
1310           && (z - addr_offset * opb >= SKIP_ZEROES
1311               || (z == stop_offset * opb &&
1312                   z - addr_offset * opb < SKIP_ZEROES_AT_END)))
1313         {
1314           printf ("\t...\n");
1315
1316           /* If there are more nonzero octets to follow, we only skip
1317              zeroes in multiples of 4, to try to avoid running over
1318              the start of an instruction which happens to start with
1319              zero.  */
1320           if (z != stop_offset * opb)
1321             z = addr_offset * opb + ((z - addr_offset * opb) &~ 3);
1322
1323           octets = z - addr_offset * opb;
1324         }
1325       else
1326         {
1327           char buf[50];
1328           SFILE sfile;
1329           int bpc = 0;
1330           int pb = 0;
1331
1332           done_dot = false;
1333
1334           if (with_line_numbers || with_source_code)
1335             /* The line number tables will refer to unadjusted
1336                section VMAs, so we must undo any VMA modifications
1337                when calling show_line.  */
1338             show_line (aux->abfd, section, addr_offset - adjust_section_vma);
1339
1340           if (! prefix_addresses)
1341             {
1342               char *s;
1343
1344               sprintf_vma (buf, section->vma + addr_offset);
1345               for (s = buf + skip_addr_chars; *s == '0'; s++)
1346                 *s = ' ';
1347               if (*s == '\0')
1348                 *--s = '0';
1349               printf ("%s:\t", buf + skip_addr_chars);
1350             }
1351           else
1352             {
1353               aux->require_sec = true;
1354               objdump_print_address (section->vma + addr_offset, info);
1355               aux->require_sec = false;
1356               putchar (' ');
1357             }
1358
1359           if (insns)
1360             {
1361               sfile.size = 120;
1362               sfile.buffer = xmalloc (sfile.size);
1363               sfile.current = sfile.buffer;
1364               info->fprintf_func = (fprintf_ftype) objdump_sprintf;
1365               info->stream = (FILE *) &sfile;
1366               info->bytes_per_line = 0;
1367               info->bytes_per_chunk = 0;
1368
1369 #ifdef DISASSEMBLER_NEEDS_RELOCS
1370               /* FIXME: This is wrong.  It tests the number of octets
1371                  in the last instruction, not the current one.  */
1372               if (*relppp < relppend
1373                   && (**relppp)->address >= addr_offset
1374                   && (**relppp)->address <= addr_offset + octets / opb)
1375                 info->flags = INSN_HAS_RELOC;
1376               else
1377 #endif
1378                 info->flags = 0;
1379
1380               octets = (*disassemble_fn) (section->vma + addr_offset, info);
1381               info->fprintf_func = (fprintf_ftype) fprintf;
1382               info->stream = stdout;
1383               if (info->bytes_per_line != 0)
1384                 octets_per_line = info->bytes_per_line;
1385               if (octets < 0)
1386                 {
1387                   if (sfile.current != sfile.buffer)
1388                     printf ("%s\n", sfile.buffer);
1389                   free (sfile.buffer);
1390                   break;
1391                 }
1392             }
1393           else
1394             {
1395               bfd_vma j;
1396
1397               octets = octets_per_line;
1398               if (addr_offset + octets / opb > stop_offset)
1399                 octets = (stop_offset - addr_offset) * opb;
1400
1401               for (j = addr_offset * opb; j < addr_offset * opb + octets; ++j)
1402                 {
1403                   if (isprint (data[j]))
1404                     buf[j - addr_offset * opb] = data[j];
1405                   else
1406                     buf[j - addr_offset * opb] = '.';
1407                 }
1408               buf[j - addr_offset * opb] = '\0';
1409             }
1410
1411           if (prefix_addresses
1412               ? show_raw_insn > 0
1413               : show_raw_insn >= 0)
1414             {
1415               bfd_vma j;
1416
1417               /* If ! prefix_addresses and ! wide_output, we print
1418                  octets_per_line octets per line.  */
1419               pb = octets;
1420               if (pb > octets_per_line && ! prefix_addresses && ! wide_output)
1421                 pb = octets_per_line;
1422
1423               if (info->bytes_per_chunk)
1424                 bpc = info->bytes_per_chunk;
1425               else
1426                 bpc = 1;
1427
1428               for (j = addr_offset * opb; j < addr_offset * opb + pb; j += bpc)
1429                 {
1430                   int k;
1431                   if (bpc > 1 && info->display_endian == BFD_ENDIAN_LITTLE)
1432                     {
1433                       for (k = bpc - 1; k >= 0; k--)
1434                         printf ("%02x", (unsigned) data[j + k]);
1435                       putchar (' ');
1436                     }
1437                   else
1438                     {
1439                       for (k = 0; k < bpc; k++)
1440                         printf ("%02x", (unsigned) data[j + k]);
1441                       putchar (' ');
1442                     }
1443                 }
1444
1445               for (; pb < octets_per_line; pb += bpc)
1446                 {
1447                   int k;
1448
1449                   for (k = 0; k < bpc; k++)
1450                     printf ("  ");
1451                   putchar (' ');
1452                 }
1453
1454               /* Separate raw data from instruction by extra space.  */
1455               if (insns)
1456                 putchar ('\t');
1457               else
1458                 printf ("    ");
1459             }
1460
1461           if (! insns)
1462             printf ("%s", buf);
1463           else
1464             {
1465               printf ("%s", sfile.buffer);
1466               free (sfile.buffer);
1467             }
1468
1469           if (prefix_addresses
1470               ? show_raw_insn > 0
1471               : show_raw_insn >= 0)
1472             {
1473               while (pb < octets)
1474                 {
1475                   bfd_vma j;
1476                   char *s;
1477
1478                   putchar ('\n');
1479                   j = addr_offset * opb + pb;
1480
1481                   sprintf_vma (buf, section->vma + j / opb);
1482                   for (s = buf + skip_addr_chars; *s == '0'; s++)
1483                     *s = ' ';
1484                   if (*s == '\0')
1485                     *--s = '0';
1486                   printf ("%s:\t", buf + skip_addr_chars);
1487
1488                   pb += octets_per_line;
1489                   if (pb > octets)
1490                     pb = octets;
1491                   for (; j < addr_offset * opb + pb; j += bpc)
1492                     {
1493                       int k;
1494
1495                       if (bpc > 1 && info->display_endian == BFD_ENDIAN_LITTLE)
1496                         {
1497                           for (k = bpc - 1; k >= 0; k--)
1498                             printf ("%02x", (unsigned) data[j + k]);
1499                           putchar (' ');
1500                         }
1501                       else
1502                         {
1503                           for (k = 0; k < bpc; k++)
1504                             printf ("%02x", (unsigned) data[j + k]);
1505                           putchar (' ');
1506                         }
1507                     }
1508                 }
1509             }
1510
1511           if (!wide_output)
1512             putchar ('\n');
1513           else
1514             need_nl = true;
1515         }
1516
1517       if ((section->flags & SEC_RELOC) != 0
1518 #ifndef DISASSEMBLER_NEEDS_RELOCS
1519           && dump_reloc_info
1520 #endif
1521           )
1522         {
1523           while ((*relppp) < relppend
1524                  && ((**relppp)->address >= (bfd_vma) addr_offset
1525                      && (**relppp)->address < (bfd_vma) addr_offset + octets / opb))
1526 #ifdef DISASSEMBLER_NEEDS_RELOCS
1527             if (! dump_reloc_info)
1528               ++(*relppp);
1529             else
1530 #endif
1531             {
1532               arelent *q;
1533
1534               q = **relppp;
1535
1536               if (wide_output)
1537                 putchar ('\t');
1538               else
1539                 printf ("\t\t\t");
1540
1541               objdump_print_value (section->vma + q->address, info, true);
1542
1543               printf (": %s\t", q->howto->name);
1544
1545               if (q->sym_ptr_ptr == NULL || *q->sym_ptr_ptr == NULL)
1546                 printf ("*unknown*");
1547               else
1548                 {
1549                   const char *sym_name;
1550
1551                   sym_name = bfd_asymbol_name (*q->sym_ptr_ptr);
1552                   if (sym_name != NULL && *sym_name != '\0')
1553                     objdump_print_symname (aux->abfd, info, *q->sym_ptr_ptr);
1554                   else
1555                     {
1556                       asection *sym_sec;
1557
1558                       sym_sec = bfd_get_section (*q->sym_ptr_ptr);
1559                       sym_name = bfd_get_section_name (aux->abfd, sym_sec);
1560                       if (sym_name == NULL || *sym_name == '\0')
1561                         sym_name = "*unknown*";
1562                       printf ("%s", sym_name);
1563                     }
1564                 }
1565
1566               if (q->addend)
1567                 {
1568                   printf ("+0x");
1569                   objdump_print_value (q->addend, info, true);
1570                 }
1571
1572               printf ("\n");
1573               need_nl = false;
1574               ++(*relppp);
1575             }
1576         }
1577
1578       if (need_nl)
1579         printf ("\n");
1580
1581       addr_offset += octets / opb;
1582     }
1583 }
1584
1585 /* Disassemble the contents of an object file.  */
1586
1587 static void
1588 disassemble_data (abfd)
1589      bfd *abfd;
1590 {
1591   unsigned long addr_offset;
1592   disassembler_ftype disassemble_fn;
1593   struct disassemble_info disasm_info;
1594   struct objdump_disasm_info aux;
1595   asection *section;
1596   unsigned int opb;
1597
1598   print_files = NULL;
1599   prev_functionname = NULL;
1600   prev_line = -1;
1601
1602   /* We make a copy of syms to sort.  We don't want to sort syms
1603      because that will screw up the relocs.  */
1604   sorted_syms = (asymbol **) xmalloc (symcount * sizeof (asymbol *));
1605   memcpy (sorted_syms, syms, symcount * sizeof (asymbol *));
1606
1607   sorted_symcount = remove_useless_symbols (sorted_syms, symcount);
1608
1609   /* Sort the symbols into section and symbol order */
1610   qsort (sorted_syms, sorted_symcount, sizeof (asymbol *), compare_symbols);
1611
1612   INIT_DISASSEMBLE_INFO(disasm_info, stdout, fprintf);
1613   disasm_info.application_data = (PTR) &aux;
1614   aux.abfd = abfd;
1615   aux.require_sec = false;
1616   disasm_info.print_address_func = objdump_print_address;
1617   disasm_info.symbol_at_address_func = objdump_symbol_at_address;
1618
1619   if (machine != (char *) NULL)
1620     {
1621       const bfd_arch_info_type *info = bfd_scan_arch (machine);
1622       if (info == NULL)
1623         {
1624           fatal (_("Can't use supplied machine %s"), machine);
1625         }
1626       abfd->arch_info = info;
1627     }
1628
1629   if (endian != BFD_ENDIAN_UNKNOWN)
1630     {
1631       struct bfd_target *xvec;
1632
1633       xvec = (struct bfd_target *) xmalloc (sizeof (struct bfd_target));
1634       memcpy (xvec, abfd->xvec, sizeof (struct bfd_target));
1635       xvec->byteorder = endian;
1636       abfd->xvec = xvec;
1637     }
1638
1639   disassemble_fn = disassembler (abfd);
1640   if (!disassemble_fn)
1641     {
1642       non_fatal (_("Can't disassemble for architecture %s\n"),
1643                  bfd_printable_arch_mach (bfd_get_arch (abfd), 0));
1644       exit_status = 1;
1645       return;
1646     }
1647
1648   opb = bfd_octets_per_byte (abfd);
1649
1650   disasm_info.flavour = bfd_get_flavour (abfd);
1651   disasm_info.arch = bfd_get_arch (abfd);
1652   disasm_info.mach = bfd_get_mach (abfd);
1653   disasm_info.disassembler_options = disassembler_options;
1654   disasm_info.octets_per_byte = opb;
1655
1656   if (bfd_big_endian (abfd))
1657     disasm_info.display_endian = disasm_info.endian = BFD_ENDIAN_BIG;
1658   else if (bfd_little_endian (abfd))
1659     disasm_info.display_endian = disasm_info.endian = BFD_ENDIAN_LITTLE;
1660   else
1661     /* ??? Aborting here seems too drastic.  We could default to big or little
1662        instead.  */
1663     disasm_info.endian = BFD_ENDIAN_UNKNOWN;
1664
1665   for (section = abfd->sections;
1666        section != (asection *) NULL;
1667        section = section->next)
1668     {
1669       bfd_byte *data = NULL;
1670       bfd_size_type datasize = 0;
1671       arelent **relbuf = NULL;
1672       arelent **relpp = NULL;
1673       arelent **relppend = NULL;
1674       unsigned long stop_offset;
1675       asymbol *sym = NULL;
1676       long place = 0;
1677
1678       if ((section->flags & SEC_LOAD) == 0
1679           || (! disassemble_all
1680               && only == NULL
1681               && (section->flags & SEC_CODE) == 0))
1682         continue;
1683       if (only != (char *) NULL && strcmp (only, section->name) != 0)
1684         continue;
1685
1686       if ((section->flags & SEC_RELOC) != 0
1687 #ifndef DISASSEMBLER_NEEDS_RELOCS
1688           && dump_reloc_info
1689 #endif
1690           )
1691         {
1692           long relsize;
1693
1694           relsize = bfd_get_reloc_upper_bound (abfd, section);
1695           if (relsize < 0)
1696             bfd_fatal (bfd_get_filename (abfd));
1697
1698           if (relsize > 0)
1699             {
1700               long relcount;
1701
1702               relbuf = (arelent **) xmalloc (relsize);
1703               relcount = bfd_canonicalize_reloc (abfd, section, relbuf, syms);
1704               if (relcount < 0)
1705                 bfd_fatal (bfd_get_filename (abfd));
1706
1707               /* Sort the relocs by address.  */
1708               qsort (relbuf, relcount, sizeof (arelent *), compare_relocs);
1709
1710               relpp = relbuf;
1711               relppend = relpp + relcount;
1712
1713               /* Skip over the relocs belonging to addresses below the
1714                  start address.  */
1715               if (start_address != (bfd_vma) -1)
1716                 {
1717                   while (relpp < relppend
1718                          && (*relpp)->address < start_address)
1719                     ++relpp;
1720                 }
1721             }
1722         }
1723
1724       printf (_("Disassembly of section %s:\n"), section->name);
1725
1726       datasize = bfd_get_section_size_before_reloc (section);
1727       if (datasize == 0)
1728         continue;
1729
1730       data = (bfd_byte *) xmalloc ((size_t) datasize);
1731
1732       bfd_get_section_contents (abfd, section, data, 0, datasize);
1733
1734       aux.sec = section;
1735       disasm_info.buffer = data;
1736       disasm_info.buffer_vma = section->vma;
1737       disasm_info.buffer_length = datasize;
1738       if (start_address == (bfd_vma) -1
1739           || start_address < disasm_info.buffer_vma)
1740         addr_offset = 0;
1741       else
1742         addr_offset = start_address - disasm_info.buffer_vma;
1743       if (stop_address == (bfd_vma) -1)
1744         stop_offset = datasize / opb;
1745       else
1746         {
1747           if (stop_address < disasm_info.buffer_vma)
1748             stop_offset = 0;
1749           else
1750             stop_offset = stop_address - disasm_info.buffer_vma;
1751           if (stop_offset > disasm_info.buffer_length / opb)
1752             stop_offset = disasm_info.buffer_length / opb;
1753         }
1754
1755       sym = find_symbol_for_address (abfd, section, section->vma + addr_offset,
1756                                      true, &place);
1757
1758       while (addr_offset < stop_offset)
1759         {
1760           asymbol *nextsym;
1761           unsigned long nextstop_offset;
1762           boolean insns;
1763
1764           if (sym != NULL && bfd_asymbol_value (sym) <= section->vma + addr_offset)
1765             {
1766               int x;
1767
1768               for (x = place;
1769                    (x < sorted_symcount
1770                     && bfd_asymbol_value (sorted_syms[x]) <= section->vma + addr_offset);
1771                    ++x)
1772                 continue;
1773               disasm_info.symbols = & sorted_syms[place];
1774               disasm_info.num_symbols = x - place;
1775             }
1776           else
1777             disasm_info.symbols = NULL;
1778
1779           if (! prefix_addresses)
1780             {
1781               printf ("\n");
1782               objdump_print_addr_with_sym (abfd, section, sym,
1783                                            section->vma + addr_offset,
1784                                            &disasm_info,
1785                                            false);
1786               printf (":\n");
1787             }
1788
1789           if (sym != NULL && bfd_asymbol_value (sym) > section->vma + addr_offset)
1790             nextsym = sym;
1791           else if (sym == NULL)
1792             nextsym = NULL;
1793           else
1794             {
1795               /* Search forward for the next appropriate symbol in
1796                  SECTION.  Note that all the symbols are sorted
1797                  together into one big array, and that some sections
1798                  may have overlapping addresses.  */
1799               while (place < sorted_symcount
1800                      && (sorted_syms[place]->section != section
1801                          || (bfd_asymbol_value (sorted_syms[place])
1802                              <= bfd_asymbol_value (sym))))
1803                 ++place;
1804               if (place >= sorted_symcount)
1805                 nextsym = NULL;
1806               else
1807                 nextsym = sorted_syms[place];
1808             }
1809
1810           if (sym != NULL && bfd_asymbol_value (sym) > section->vma + addr_offset)
1811             {
1812               nextstop_offset = bfd_asymbol_value (sym) - section->vma;
1813               if (nextstop_offset > stop_offset)
1814                 nextstop_offset = stop_offset;
1815             }
1816           else if (nextsym == NULL)
1817             nextstop_offset = stop_offset;
1818           else
1819             {
1820               nextstop_offset = bfd_asymbol_value (nextsym) - section->vma;
1821               if (nextstop_offset > stop_offset)
1822                 nextstop_offset = stop_offset;
1823             }
1824
1825           /* If a symbol is explicitly marked as being an object
1826              rather than a function, just dump the bytes without
1827              disassembling them.  */
1828           if (disassemble_all
1829               || sym == NULL
1830               || bfd_asymbol_value (sym) > section->vma + addr_offset
1831               || ((sym->flags & BSF_OBJECT) == 0
1832                   && (strstr (bfd_asymbol_name (sym), "gnu_compiled")
1833                       == NULL)
1834                   && (strstr (bfd_asymbol_name (sym), "gcc2_compiled")
1835                       == NULL))
1836               || (sym->flags & BSF_FUNCTION) != 0)
1837             insns = true;
1838           else
1839             insns = false;
1840
1841           disassemble_bytes (&disasm_info, disassemble_fn, insns, data,
1842                              addr_offset, nextstop_offset, &relpp, relppend);
1843
1844           addr_offset = nextstop_offset;
1845           sym = nextsym;
1846         }
1847
1848       free (data);
1849       if (relbuf != NULL)
1850         free (relbuf);
1851     }
1852   free (sorted_syms);
1853 }
1854 \f
1855
1856 /* Define a table of stab values and print-strings.  We wish the initializer
1857    could be a direct-mapped table, but instead we build one the first
1858    time we need it.  */
1859
1860 static void dump_section_stabs PARAMS ((bfd *abfd, char *stabsect_name,
1861                                         char *strsect_name));
1862
1863 /* Dump the stabs sections from an object file that has a section that
1864    uses Sun stabs encoding.  */
1865
1866 static void
1867 dump_stabs (abfd)
1868      bfd *abfd;
1869 {
1870   dump_section_stabs (abfd, ".stab", ".stabstr");
1871   dump_section_stabs (abfd, ".stab.excl", ".stab.exclstr");
1872   dump_section_stabs (abfd, ".stab.index", ".stab.indexstr");
1873   dump_section_stabs (abfd, "$GDB_SYMBOLS$", "$GDB_STRINGS$");
1874 }
1875
1876 static bfd_byte *stabs;
1877 static bfd_size_type stab_size;
1878
1879 static char *strtab;
1880 static bfd_size_type stabstr_size;
1881
1882 /* Read ABFD's stabs section STABSECT_NAME into `stabs'
1883    and string table section STRSECT_NAME into `strtab'.
1884    If the section exists and was read, allocate the space and return true.
1885    Otherwise return false.  */
1886
1887 static boolean
1888 read_section_stabs (abfd, stabsect_name, strsect_name)
1889      bfd *abfd;
1890      const char *stabsect_name;
1891      const char *strsect_name;
1892 {
1893   asection *stabsect, *stabstrsect;
1894
1895   stabsect = bfd_get_section_by_name (abfd, stabsect_name);
1896   if (0 == stabsect)
1897     {
1898       printf (_("No %s section present\n\n"), stabsect_name);
1899       return false;
1900     }
1901
1902   stabstrsect = bfd_get_section_by_name (abfd, strsect_name);
1903   if (0 == stabstrsect)
1904     {
1905       non_fatal (_("%s has no %s section"),
1906                  bfd_get_filename (abfd), strsect_name);
1907       exit_status = 1;
1908       return false;
1909     }
1910
1911   stab_size    = bfd_section_size (abfd, stabsect);
1912   stabstr_size = bfd_section_size (abfd, stabstrsect);
1913
1914   stabs  = (bfd_byte *) xmalloc (stab_size);
1915   strtab = (char *) xmalloc (stabstr_size);
1916
1917   if (! bfd_get_section_contents (abfd, stabsect, (PTR) stabs, 0, stab_size))
1918     {
1919       non_fatal (_("Reading %s section of %s failed: %s"),
1920                  stabsect_name, bfd_get_filename (abfd),
1921                  bfd_errmsg (bfd_get_error ()));
1922       free (stabs);
1923       free (strtab);
1924       exit_status = 1;
1925       return false;
1926     }
1927
1928   if (! bfd_get_section_contents (abfd, stabstrsect, (PTR) strtab, 0,
1929                                   stabstr_size))
1930     {
1931       non_fatal (_("Reading %s section of %s failed: %s\n"),
1932                  strsect_name, bfd_get_filename (abfd),
1933                  bfd_errmsg (bfd_get_error ()));
1934       free (stabs);
1935       free (strtab);
1936       exit_status = 1;
1937       return false;
1938     }
1939
1940   return true;
1941 }
1942
1943 /* Stabs entries use a 12 byte format:
1944      4 byte string table index
1945      1 byte stab type
1946      1 byte stab other field
1947      2 byte stab desc field
1948      4 byte stab value
1949    FIXME: This will have to change for a 64 bit object format.  */
1950
1951 #define STRDXOFF (0)
1952 #define TYPEOFF (4)
1953 #define OTHEROFF (5)
1954 #define DESCOFF (6)
1955 #define VALOFF (8)
1956 #define STABSIZE (12)
1957
1958 /* Print ABFD's stabs section STABSECT_NAME (in `stabs'),
1959    using string table section STRSECT_NAME (in `strtab').  */
1960
1961 static void
1962 print_section_stabs (abfd, stabsect_name, strsect_name)
1963      bfd *abfd;
1964      const char *stabsect_name;
1965      const char *strsect_name ATTRIBUTE_UNUSED;
1966 {
1967   int i;
1968   unsigned file_string_table_offset = 0, next_file_string_table_offset = 0;
1969   bfd_byte *stabp, *stabs_end;
1970
1971   stabp = stabs;
1972   stabs_end = stabp + stab_size;
1973
1974   printf (_("Contents of %s section:\n\n"), stabsect_name);
1975   printf ("Symnum n_type n_othr n_desc n_value  n_strx String\n");
1976
1977   /* Loop through all symbols and print them.
1978
1979      We start the index at -1 because there is a dummy symbol on
1980      the front of stabs-in-{coff,elf} sections that supplies sizes.  */
1981
1982   for (i = -1; stabp < stabs_end; stabp += STABSIZE, i++)
1983     {
1984       const char *name;
1985       unsigned long strx;
1986       unsigned char type, other;
1987       unsigned short desc;
1988       bfd_vma value;
1989
1990       strx = bfd_h_get_32 (abfd, stabp + STRDXOFF);
1991       type = bfd_h_get_8 (abfd, stabp + TYPEOFF);
1992       other = bfd_h_get_8 (abfd, stabp + OTHEROFF);
1993       desc = bfd_h_get_16 (abfd, stabp + DESCOFF);
1994       value = bfd_h_get_32 (abfd, stabp + VALOFF);
1995
1996       printf ("\n%-6d ", i);
1997       /* Either print the stab name, or, if unnamed, print its number
1998          again (makes consistent formatting for tools like awk). */
1999       name = bfd_get_stab_name (type);
2000       if (name != NULL)
2001         printf ("%-6s", name);
2002       else if (type == N_UNDF)
2003         printf ("HdrSym");
2004       else
2005         printf ("%-6d", type);
2006       printf (" %-6d %-6d ", other, desc);
2007       printf_vma (value);
2008       printf (" %-6lu", strx);
2009
2010       /* Symbols with type == 0 (N_UNDF) specify the length of the
2011          string table associated with this file.  We use that info
2012          to know how to relocate the *next* file's string table indices.  */
2013
2014       if (type == N_UNDF)
2015         {
2016           file_string_table_offset = next_file_string_table_offset;
2017           next_file_string_table_offset += value;
2018         }
2019       else
2020         {
2021           /* Using the (possibly updated) string table offset, print the
2022              string (if any) associated with this symbol.  */
2023
2024           if ((strx + file_string_table_offset) < stabstr_size)
2025             printf (" %s", &strtab[strx + file_string_table_offset]);
2026           else
2027             printf (" *");
2028         }
2029     }
2030   printf ("\n\n");
2031 }
2032
2033 static void
2034 dump_section_stabs (abfd, stabsect_name, strsect_name)
2035      bfd *abfd;
2036      char *stabsect_name;
2037      char *strsect_name;
2038 {
2039   asection *s;
2040
2041   /* Check for section names for which stabsect_name is a prefix, to
2042      handle .stab0, etc.  */
2043   for (s = abfd->sections;
2044        s != NULL;
2045        s = s->next)
2046     {
2047       int len;
2048
2049       len = strlen (stabsect_name);
2050
2051       /* If the prefix matches, and the files section name ends with a
2052          nul or a digit, then we match.  I.e., we want either an exact
2053          match or a section followed by a number.  */
2054       if (strncmp (stabsect_name, s->name, len) == 0
2055           && (s->name[len] == '\000'
2056               || isdigit ((unsigned char) s->name[len])))
2057         {
2058           if (read_section_stabs (abfd, s->name, strsect_name))
2059             {
2060               print_section_stabs (abfd, s->name, strsect_name);
2061               free (stabs);
2062               free (strtab);
2063             }
2064         }
2065     }
2066 }
2067 \f
2068 static void
2069 dump_bfd_header (abfd)
2070      bfd *abfd;
2071 {
2072   char *comma = "";
2073
2074   printf (_("architecture: %s, "),
2075           bfd_printable_arch_mach (bfd_get_arch (abfd),
2076                                    bfd_get_mach (abfd)));
2077   printf (_("flags 0x%08x:\n"), abfd->flags);
2078
2079 #define PF(x, y)    if (abfd->flags & x) {printf("%s%s", comma, y); comma=", ";}
2080   PF (HAS_RELOC, "HAS_RELOC");
2081   PF (EXEC_P, "EXEC_P");
2082   PF (HAS_LINENO, "HAS_LINENO");
2083   PF (HAS_DEBUG, "HAS_DEBUG");
2084   PF (HAS_SYMS, "HAS_SYMS");
2085   PF (HAS_LOCALS, "HAS_LOCALS");
2086   PF (DYNAMIC, "DYNAMIC");
2087   PF (WP_TEXT, "WP_TEXT");
2088   PF (D_PAGED, "D_PAGED");
2089   PF (BFD_IS_RELAXABLE, "BFD_IS_RELAXABLE");
2090   printf (_("\nstart address 0x"));
2091   printf_vma (abfd->start_address);
2092   printf ("\n");
2093 }
2094 \f
2095 static void
2096 dump_bfd_private_header (abfd)
2097 bfd *abfd;
2098 {
2099   bfd_print_private_bfd_data (abfd, stdout);
2100 }
2101
2102 /* Dump selected contents of ABFD */
2103
2104 static void
2105 dump_bfd (abfd)
2106      bfd *abfd;
2107 {
2108   /* If we are adjusting section VMA's, change them all now.  Changing
2109      the BFD information is a hack.  However, we must do it, or
2110      bfd_find_nearest_line will not do the right thing.  */
2111   if (adjust_section_vma != 0)
2112     {
2113       asection *s;
2114
2115       for (s = abfd->sections; s != NULL; s = s->next)
2116         {
2117           s->vma += adjust_section_vma;
2118           s->lma += adjust_section_vma;
2119         }
2120     }
2121
2122   printf (_("\n%s:     file format %s\n"), bfd_get_filename (abfd),
2123           abfd->xvec->name);
2124   if (dump_ar_hdrs)
2125     print_arelt_descr (stdout, abfd, true);
2126   if (dump_file_header)
2127     dump_bfd_header (abfd);
2128   if (dump_private_headers)
2129     dump_bfd_private_header (abfd);
2130   putchar ('\n');
2131   if (dump_section_headers)
2132     dump_headers (abfd);
2133   if (dump_symtab || dump_reloc_info || disassemble || dump_debugging)
2134     {
2135       syms = slurp_symtab (abfd);
2136     }
2137   if (dump_dynamic_symtab || dump_dynamic_reloc_info)
2138     {
2139       dynsyms = slurp_dynamic_symtab (abfd);
2140     }
2141   if (dump_symtab)
2142     dump_symbols (abfd, false);
2143   if (dump_dynamic_symtab)
2144     dump_symbols (abfd, true);
2145   if (dump_stab_section_info)
2146     dump_stabs (abfd);
2147   if (dump_reloc_info && ! disassemble)
2148     dump_relocs (abfd);
2149   if (dump_dynamic_reloc_info)
2150     dump_dynamic_relocs (abfd);
2151   if (dump_section_contents)
2152     dump_data (abfd);
2153   if (disassemble)
2154     disassemble_data (abfd);
2155   if (dump_debugging)
2156     {
2157       PTR dhandle;
2158
2159       dhandle = read_debugging_info (abfd, syms, symcount);
2160       if (dhandle != NULL)
2161         {
2162           if (! print_debugging_info (stdout, dhandle))
2163             {
2164               non_fatal (_("%s: printing debugging information failed"),
2165                          bfd_get_filename (abfd));
2166               exit_status = 1;
2167             }
2168         }
2169     }
2170   if (syms)
2171     {
2172       free (syms);
2173       syms = NULL;
2174     }
2175   if (dynsyms)
2176     {
2177       free (dynsyms);
2178       dynsyms = NULL;
2179     }
2180 }
2181
2182 static void
2183 display_bfd (abfd)
2184      bfd *abfd;
2185 {
2186   char **matching;
2187
2188   if (bfd_check_format_matches (abfd, bfd_object, &matching))
2189     {
2190       dump_bfd (abfd);
2191       return;
2192     }
2193
2194   if (bfd_get_error () == bfd_error_file_ambiguously_recognized)
2195     {
2196       nonfatal (bfd_get_filename (abfd));
2197       list_matching_formats (matching);
2198       free (matching);
2199       return;
2200     }
2201
2202   if (bfd_get_error () != bfd_error_file_not_recognized)
2203     {
2204       nonfatal (bfd_get_filename (abfd));
2205       return;
2206     }
2207
2208   if (bfd_check_format_matches (abfd, bfd_core, &matching))
2209     {
2210       dump_bfd (abfd);
2211       return;
2212     }
2213
2214   nonfatal (bfd_get_filename (abfd));
2215
2216   if (bfd_get_error () == bfd_error_file_ambiguously_recognized)
2217     {
2218       list_matching_formats (matching);
2219       free (matching);
2220     }
2221 }
2222
2223 static void
2224 display_file (filename, target)
2225      char *filename;
2226      char *target;
2227 {
2228   bfd *file, *arfile = (bfd *) NULL;
2229
2230   file = bfd_openr (filename, target);
2231   if (file == NULL)
2232     {
2233       nonfatal (filename);
2234       return;
2235     }
2236
2237   if (bfd_check_format (file, bfd_archive) == true)
2238     {
2239       bfd *last_arfile = NULL;
2240
2241       printf (_("In archive %s:\n"), bfd_get_filename (file));
2242       for (;;)
2243         {
2244           bfd_set_error (bfd_error_no_error);
2245
2246           arfile = bfd_openr_next_archived_file (file, arfile);
2247           if (arfile == NULL)
2248             {
2249               if (bfd_get_error () != bfd_error_no_more_archived_files)
2250                 nonfatal (bfd_get_filename (file));
2251               break;
2252             }
2253
2254           display_bfd (arfile);
2255
2256           if (last_arfile != NULL)
2257             bfd_close (last_arfile);
2258           last_arfile = arfile;
2259         }
2260
2261       if (last_arfile != NULL)
2262         bfd_close (last_arfile);
2263     }
2264   else
2265     display_bfd (file);
2266
2267   bfd_close (file);
2268 }
2269 \f
2270 /* Actually display the various requested regions */
2271
2272 static void
2273 dump_data (abfd)
2274      bfd *abfd;
2275 {
2276   asection *section;
2277   bfd_byte *data = 0;
2278   bfd_size_type datasize = 0;
2279   bfd_size_type addr_offset;
2280   bfd_size_type start_offset, stop_offset;
2281   unsigned int opb = bfd_octets_per_byte (abfd);
2282
2283   for (section = abfd->sections; section != NULL; section =
2284        section->next)
2285     {
2286       int onaline = 16;
2287
2288       if (only == (char *) NULL ||
2289           strcmp (only, section->name) == 0)
2290         {
2291           if (section->flags & SEC_HAS_CONTENTS)
2292             {
2293               printf (_("Contents of section %s:\n"), section->name);
2294
2295               if (bfd_section_size (abfd, section) == 0)
2296                 continue;
2297               data = (bfd_byte *) xmalloc ((size_t) bfd_section_size (abfd, section));
2298               datasize = bfd_section_size (abfd, section);
2299
2300
2301               bfd_get_section_contents (abfd, section, (PTR) data, 0, bfd_section_size (abfd, section));
2302
2303               if (start_address == (bfd_vma) -1
2304                   || start_address < section->vma)
2305                 start_offset = 0;
2306               else
2307                 start_offset = start_address - section->vma;
2308               if (stop_address == (bfd_vma) -1)
2309                 stop_offset = bfd_section_size (abfd, section) / opb;
2310               else
2311                 {
2312                   if (stop_address < section->vma)
2313                     stop_offset = 0;
2314                   else
2315                     stop_offset = stop_address - section->vma;
2316                   if (stop_offset > bfd_section_size (abfd, section) / opb)
2317                     stop_offset = bfd_section_size (abfd, section) / opb;
2318                 }
2319               for (addr_offset = start_offset;
2320                    addr_offset < stop_offset; addr_offset += onaline)
2321                 {
2322                   bfd_size_type j;
2323
2324                   printf (" %04lx ", (unsigned long int)
2325                           (addr_offset + section->vma));
2326                   for (j = addr_offset * opb;
2327                        j < addr_offset * opb + onaline; j++)
2328                     {
2329                       if (j < stop_offset * opb)
2330                         printf ("%02x", (unsigned) (data[j]));
2331                       else
2332                         printf ("  ");
2333                       if ((j & 3) == 3)
2334                         printf (" ");
2335                     }
2336
2337                   printf (" ");
2338                   for (j = addr_offset; j < addr_offset * opb + onaline; j++)
2339                     {
2340                       if (j >= stop_offset * opb)
2341                         printf (" ");
2342                       else
2343                         printf ("%c", isprint (data[j]) ? data[j] : '.');
2344                     }
2345                   putchar ('\n');
2346                 }
2347               free (data);
2348             }
2349         }
2350     }
2351 }
2352
2353 /* Should perhaps share code and display with nm? */
2354 static void
2355 dump_symbols (abfd, dynamic)
2356      bfd *abfd ATTRIBUTE_UNUSED;
2357      boolean dynamic;
2358 {
2359   asymbol **current;
2360   long max;
2361   long count;
2362
2363   if (dynamic)
2364     {
2365       current = dynsyms;
2366       max = dynsymcount;
2367       if (max == 0)
2368         return;
2369       printf ("DYNAMIC SYMBOL TABLE:\n");
2370     }
2371   else
2372     {
2373       current = syms;
2374       max = symcount;
2375       if (max == 0)
2376         return;
2377       printf ("SYMBOL TABLE:\n");
2378     }
2379
2380   for (count = 0; count < max; count++)
2381     {
2382       if (*current)
2383         {
2384           bfd *cur_bfd = bfd_asymbol_bfd (*current);
2385
2386           if (cur_bfd != NULL)
2387             {
2388               const char *name;
2389               char *alloc;
2390
2391               name = bfd_asymbol_name (*current);
2392               alloc = NULL;
2393               if (do_demangle && name != NULL && *name != '\0')
2394                 {
2395                   const char *n;
2396
2397                   /* If we want to demangle the name, we demangle it
2398                      here, and temporarily clobber it while calling
2399                      bfd_print_symbol.  FIXME: This is a gross hack.  */
2400
2401                   n = name;
2402                   if (bfd_get_symbol_leading_char (cur_bfd) == *n)
2403                     ++n;
2404                   alloc = cplus_demangle (n, DMGL_ANSI | DMGL_PARAMS);
2405                   if (alloc != NULL)
2406                     (*current)->name = alloc;
2407                   else
2408                     (*current)->name = n;
2409                 }
2410
2411               bfd_print_symbol (cur_bfd, stdout, *current,
2412                                 bfd_print_symbol_all);
2413
2414               (*current)->name = name;
2415               if (alloc != NULL)
2416                 free (alloc);
2417
2418               printf ("\n");
2419             }
2420         }
2421       current++;
2422     }
2423   printf ("\n");
2424   printf ("\n");
2425 }
2426
2427 static void
2428 dump_relocs (abfd)
2429      bfd *abfd;
2430 {
2431   arelent **relpp;
2432   long relcount;
2433   asection *a;
2434
2435   for (a = abfd->sections; a != (asection *) NULL; a = a->next)
2436     {
2437       long relsize;
2438
2439       if (bfd_is_abs_section (a))
2440         continue;
2441       if (bfd_is_und_section (a))
2442         continue;
2443       if (bfd_is_com_section (a))
2444         continue;
2445
2446       if (only)
2447         {
2448           if (strcmp (only, a->name))
2449             continue;
2450         }
2451       else if ((a->flags & SEC_RELOC) == 0)
2452         continue;
2453
2454       relsize = bfd_get_reloc_upper_bound (abfd, a);
2455       if (relsize < 0)
2456         bfd_fatal (bfd_get_filename (abfd));
2457
2458       printf ("RELOCATION RECORDS FOR [%s]:", a->name);
2459
2460       if (relsize == 0)
2461         {
2462           printf (" (none)\n\n");
2463         }
2464       else
2465         {
2466           relpp = (arelent **) xmalloc (relsize);
2467           relcount = bfd_canonicalize_reloc (abfd, a, relpp, syms);
2468           if (relcount < 0)
2469             bfd_fatal (bfd_get_filename (abfd));
2470           else if (relcount == 0)
2471             {
2472               printf (" (none)\n\n");
2473             }
2474           else
2475             {
2476               printf ("\n");
2477               dump_reloc_set (abfd, a, relpp, relcount);
2478               printf ("\n\n");
2479             }
2480           free (relpp);
2481         }
2482     }
2483 }
2484
2485 static void
2486 dump_dynamic_relocs (abfd)
2487      bfd *abfd;
2488 {
2489   long relsize;
2490   arelent **relpp;
2491   long relcount;
2492
2493   relsize = bfd_get_dynamic_reloc_upper_bound (abfd);
2494   if (relsize < 0)
2495     bfd_fatal (bfd_get_filename (abfd));
2496
2497   printf ("DYNAMIC RELOCATION RECORDS");
2498
2499   if (relsize == 0)
2500     {
2501       printf (" (none)\n\n");
2502     }
2503   else
2504     {
2505       relpp = (arelent **) xmalloc (relsize);
2506       relcount = bfd_canonicalize_dynamic_reloc (abfd, relpp, dynsyms);
2507       if (relcount < 0)
2508         bfd_fatal (bfd_get_filename (abfd));
2509       else if (relcount == 0)
2510         {
2511           printf (" (none)\n\n");
2512         }
2513       else
2514         {
2515           printf ("\n");
2516           dump_reloc_set (abfd, (asection *) NULL, relpp, relcount);
2517           printf ("\n\n");
2518         }
2519       free (relpp);
2520     }
2521 }
2522
2523 static void
2524 dump_reloc_set (abfd, sec, relpp, relcount)
2525      bfd *abfd;
2526      asection *sec;
2527      arelent **relpp;
2528      long relcount;
2529 {
2530   arelent **p;
2531   char *last_filename, *last_functionname;
2532   unsigned int last_line;
2533
2534   /* Get column headers lined up reasonably.  */
2535   {
2536     static int width;
2537     if (width == 0)
2538       {
2539         char buf[30];
2540         sprintf_vma (buf, (bfd_vma) -1);
2541         width = strlen (buf) - 7;
2542       }
2543     printf ("OFFSET %*s TYPE %*s VALUE \n", width, "", 12, "");
2544   }
2545
2546   last_filename = NULL;
2547   last_functionname = NULL;
2548   last_line = 0;
2549
2550   for (p = relpp; relcount && *p != (arelent *) NULL; p++, relcount--)
2551     {
2552       arelent *q = *p;
2553       const char *filename, *functionname;
2554       unsigned int line;
2555       const char *sym_name;
2556       const char *section_name;
2557
2558       if (start_address != (bfd_vma) -1
2559           && q->address < start_address)
2560         continue;
2561       if (stop_address != (bfd_vma) -1
2562           && q->address > stop_address)
2563         continue;
2564
2565       if (with_line_numbers
2566           && sec != NULL
2567           && bfd_find_nearest_line (abfd, sec, syms, q->address,
2568                                     &filename, &functionname, &line))
2569         {
2570           if (functionname != NULL
2571               && (last_functionname == NULL
2572                   || strcmp (functionname, last_functionname) != 0))
2573             {
2574               printf ("%s():\n", functionname);
2575               if (last_functionname != NULL)
2576                 free (last_functionname);
2577               last_functionname = xstrdup (functionname);
2578             }
2579           if (line > 0
2580               && (line != last_line
2581                   || (filename != NULL
2582                       && last_filename != NULL
2583                       && strcmp (filename, last_filename) != 0)))
2584             {
2585               printf ("%s:%u\n", filename == NULL ? "???" : filename, line);
2586               last_line = line;
2587               if (last_filename != NULL)
2588                 free (last_filename);
2589               if (filename == NULL)
2590                 last_filename = NULL;
2591               else
2592                 last_filename = xstrdup (filename);
2593             }
2594         }
2595
2596       if (q->sym_ptr_ptr && *q->sym_ptr_ptr)
2597         {
2598           sym_name = (*(q->sym_ptr_ptr))->name;
2599           section_name = (*(q->sym_ptr_ptr))->section->name;
2600         }
2601       else
2602         {
2603           sym_name = NULL;
2604           section_name = NULL;
2605         }
2606       if (sym_name)
2607         {
2608           printf_vma (q->address);
2609           if (q->howto->name)
2610             printf (" %-16s  ", q->howto->name);
2611           else
2612             printf (" %-16d  ", q->howto->type);
2613           objdump_print_symname (abfd, (struct disassemble_info *) NULL,
2614                                  *q->sym_ptr_ptr);
2615         }
2616       else
2617         {
2618           if (section_name == (CONST char *) NULL)
2619             section_name = "*unknown*";
2620           printf_vma (q->address);
2621           printf (" %-16s  [%s]",
2622                   q->howto->name,
2623                   section_name);
2624         }
2625       if (q->addend)
2626         {
2627           printf ("+0x");
2628           printf_vma (q->addend);
2629         }
2630       printf ("\n");
2631     }
2632 }
2633 \f
2634 /* The length of the longest architecture name + 1.  */
2635 #define LONGEST_ARCH sizeof("powerpc:common")
2636
2637 static const char *
2638 endian_string (endian)
2639      enum bfd_endian endian;
2640 {
2641   if (endian == BFD_ENDIAN_BIG)
2642     return "big endian";
2643   else if (endian == BFD_ENDIAN_LITTLE)
2644     return "little endian";
2645   else
2646     return "endianness unknown";
2647 }
2648
2649 /* List the targets that BFD is configured to support, each followed
2650    by its endianness and the architectures it supports.  */
2651
2652 static void
2653 display_target_list ()
2654 {
2655   extern const bfd_target *const *bfd_target_vector;
2656   char *dummy_name;
2657   int t;
2658
2659   dummy_name = make_temp_file (NULL);
2660   for (t = 0; bfd_target_vector[t]; t++)
2661     {
2662       const bfd_target *p = bfd_target_vector[t];
2663       bfd *abfd = bfd_openw (dummy_name, p->name);
2664       int a;
2665
2666       printf ("%s\n (header %s, data %s)\n", p->name,
2667               endian_string (p->header_byteorder),
2668               endian_string (p->byteorder));
2669
2670       if (abfd == NULL)
2671         {
2672           nonfatal (dummy_name);
2673           continue;
2674         }
2675
2676       if (! bfd_set_format (abfd, bfd_object))
2677         {
2678           if (bfd_get_error () != bfd_error_invalid_operation)
2679             nonfatal (p->name);
2680           bfd_close_all_done (abfd);
2681           continue;
2682         }
2683
2684       for (a = (int) bfd_arch_obscure + 1; a < (int) bfd_arch_last; a++)
2685         if (bfd_set_arch_mach (abfd, (enum bfd_architecture) a, 0))
2686           printf ("  %s\n",
2687                   bfd_printable_arch_mach ((enum bfd_architecture) a, 0));
2688       bfd_close_all_done (abfd);
2689     }
2690   unlink (dummy_name);
2691   free (dummy_name);
2692 }
2693
2694 /* Print a table showing which architectures are supported for entries
2695    FIRST through LAST-1 of bfd_target_vector (targets across,
2696    architectures down).  */
2697
2698 static void
2699 display_info_table (first, last)
2700      int first;
2701      int last;
2702 {
2703   extern const bfd_target *const *bfd_target_vector;
2704   int t, a;
2705   char *dummy_name;
2706
2707   /* Print heading of target names.  */
2708   printf ("\n%*s", (int) LONGEST_ARCH, " ");
2709   for (t = first; t < last && bfd_target_vector[t]; t++)
2710     printf ("%s ", bfd_target_vector[t]->name);
2711   putchar ('\n');
2712
2713   dummy_name = make_temp_file (NULL);
2714   for (a = (int) bfd_arch_obscure + 1; a < (int) bfd_arch_last; a++)
2715     if (strcmp (bfd_printable_arch_mach (a, 0), "UNKNOWN!") != 0)
2716       {
2717         printf ("%*s ", (int) LONGEST_ARCH - 1,
2718                 bfd_printable_arch_mach (a, 0));
2719         for (t = first; t < last && bfd_target_vector[t]; t++)
2720           {
2721             const bfd_target *p = bfd_target_vector[t];
2722             boolean ok = true;
2723             bfd *abfd = bfd_openw (dummy_name, p->name);
2724
2725             if (abfd == NULL)
2726               {
2727                 nonfatal (p->name);
2728                 ok = false;
2729               }
2730
2731             if (ok)
2732               {
2733                 if (! bfd_set_format (abfd, bfd_object))
2734                   {
2735                     if (bfd_get_error () != bfd_error_invalid_operation)
2736                       nonfatal (p->name);
2737                     ok = false;
2738                   }
2739               }
2740
2741             if (ok)
2742               {
2743                 if (! bfd_set_arch_mach (abfd, a, 0))
2744                   ok = false;
2745               }
2746
2747             if (ok)
2748               printf ("%s ", p->name);
2749             else
2750               {
2751                 int l = strlen (p->name);
2752                 while (l--)
2753                   putchar ('-');
2754                 putchar (' ');
2755               }
2756             if (abfd != NULL)
2757               bfd_close_all_done (abfd);
2758           }
2759         putchar ('\n');
2760       }
2761   unlink (dummy_name);
2762   free (dummy_name);
2763 }
2764
2765 /* Print tables of all the target-architecture combinations that
2766    BFD has been configured to support.  */
2767
2768 static void
2769 display_target_tables ()
2770 {
2771   int t, columns;
2772   extern const bfd_target *const *bfd_target_vector;
2773   char *colum;
2774
2775   columns = 0;
2776   colum = getenv ("COLUMNS");
2777   if (colum != NULL)
2778     columns = atoi (colum);
2779   if (columns == 0)
2780     columns = 80;
2781
2782   t = 0;
2783   while (bfd_target_vector[t] != NULL)
2784     {
2785       int oldt = t, wid;
2786
2787       wid = LONGEST_ARCH + strlen (bfd_target_vector[t]->name) + 1;
2788       ++t;
2789       while (wid < columns && bfd_target_vector[t] != NULL)
2790         {
2791           int newwid;
2792
2793           newwid = wid + strlen (bfd_target_vector[t]->name) + 1;
2794           if (newwid >= columns)
2795             break;
2796           wid = newwid;
2797           ++t;
2798         }
2799       display_info_table (oldt, t);
2800     }
2801 }
2802
2803 static void
2804 display_info ()
2805 {
2806   printf (_("BFD header file version %s\n"), BFD_VERSION);
2807   display_target_list ();
2808   display_target_tables ();
2809 }
2810
2811 int
2812 main (argc, argv)
2813      int argc;
2814      char **argv;
2815 {
2816   int c;
2817   char *target = default_target;
2818   boolean seenflag = false;
2819
2820 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
2821   setlocale (LC_MESSAGES, "");
2822 #endif
2823   bindtextdomain (PACKAGE, LOCALEDIR);
2824   textdomain (PACKAGE);
2825
2826   program_name = *argv;
2827   xmalloc_set_program_name (program_name);
2828
2829   START_PROGRESS (program_name, 0);
2830
2831   bfd_init ();
2832   set_default_bfd_target ();
2833
2834   while ((c = getopt_long (argc, argv, "pib:m:M:VCdDlfahHrRtTxsSj:wE:zgG",
2835                            long_options, (int *) 0))
2836          != EOF)
2837     {
2838       switch (c)
2839         {
2840         case 0:
2841           break;                /* we've been given a long option */
2842         case 'm':
2843           machine = optarg;
2844           break;
2845         case 'M':
2846           disassembler_options = optarg;
2847           break;
2848         case 'j':
2849           only = optarg;
2850           break;
2851         case 'l':
2852           with_line_numbers = true;
2853           break;
2854         case 'b':
2855           target = optarg;
2856           break;
2857         case 'C':
2858           do_demangle = true;
2859           if (optarg != NULL)
2860             {
2861               enum demangling_styles style;
2862
2863               style = cplus_demangle_name_to_style (optarg);
2864               if (style == unknown_demangling)
2865                 fatal (_("unknown demangling style `%s'"),
2866                        optarg);
2867
2868               cplus_demangle_set_style (style);
2869            }
2870           break;
2871         case 'w':
2872           wide_output = true;
2873           break;
2874         case OPTION_ADJUST_VMA:
2875           adjust_section_vma = parse_vma (optarg, "--adjust-vma");
2876           break;
2877         case OPTION_START_ADDRESS:
2878           start_address = parse_vma (optarg, "--start-address");
2879           break;
2880         case OPTION_STOP_ADDRESS:
2881           stop_address = parse_vma (optarg, "--stop-address");
2882           break;
2883         case 'E':
2884           if (strcmp (optarg, "B") == 0)
2885             endian = BFD_ENDIAN_BIG;
2886           else if (strcmp (optarg, "L") == 0)
2887             endian = BFD_ENDIAN_LITTLE;
2888           else
2889             {
2890               non_fatal (_("unrecognized -E option"));
2891               usage (stderr, 1);
2892             }
2893           break;
2894         case OPTION_ENDIAN:
2895           if (strncmp (optarg, "big", strlen (optarg)) == 0)
2896             endian = BFD_ENDIAN_BIG;
2897           else if (strncmp (optarg, "little", strlen (optarg)) == 0)
2898             endian = BFD_ENDIAN_LITTLE;
2899           else
2900             {
2901               non_fatal (_("unrecognized --endian type `%s'"), optarg);
2902               usage (stderr, 1);
2903             }
2904           break;
2905
2906         case 'f':
2907           dump_file_header = true;
2908           seenflag = true;
2909           break;
2910         case 'i':
2911           formats_info = true;
2912           seenflag = true;
2913           break;
2914         case 'p':
2915           dump_private_headers = true;
2916           seenflag = true;
2917           break;
2918         case 'x':
2919           dump_private_headers = true;
2920           dump_symtab = true;
2921           dump_reloc_info = true;
2922           dump_file_header = true;
2923           dump_ar_hdrs = true;
2924           dump_section_headers = true;
2925           seenflag = true;
2926           break;
2927         case 't':
2928           dump_symtab = true;
2929           seenflag = true;
2930           break;
2931         case 'T':
2932           dump_dynamic_symtab = true;
2933           seenflag = true;
2934           break;
2935         case 'd':
2936           disassemble = true;
2937           seenflag = true;
2938           break;
2939         case 'z':
2940           disassemble_zeroes = true;
2941           break;
2942         case 'D':
2943           disassemble = true;
2944           disassemble_all = true;
2945           seenflag = true;
2946           break;
2947         case 'S':
2948           disassemble = true;
2949           with_source_code = true;
2950           seenflag = true;
2951           break;
2952         case 'g':
2953           dump_debugging = 1;
2954           seenflag = true;
2955           break;
2956         case 'G':
2957           dump_stab_section_info = true;
2958           seenflag = true;
2959           break;
2960         case 's':
2961           dump_section_contents = true;
2962           seenflag = true;
2963           break;
2964         case 'r':
2965           dump_reloc_info = true;
2966           seenflag = true;
2967           break;
2968         case 'R':
2969           dump_dynamic_reloc_info = true;
2970           seenflag = true;
2971           break;
2972         case 'a':
2973           dump_ar_hdrs = true;
2974           seenflag = true;
2975           break;
2976         case 'h':
2977           dump_section_headers = true;
2978           seenflag = true;
2979           break;
2980         case 'H':
2981           usage (stdout, 0);
2982           seenflag = true;
2983         case 'V':
2984           show_version = true;
2985           seenflag = true;
2986           break;
2987
2988         default:
2989           usage (stderr, 1);
2990         }
2991     }
2992
2993   if (show_version)
2994     print_version ("objdump");
2995
2996   if (seenflag == false)
2997     usage (stderr, 2);
2998
2999   if (formats_info)
3000     display_info ();
3001   else
3002     {
3003       if (optind == argc)
3004         display_file ("a.out", target);
3005       else
3006         for (; optind < argc;)
3007           display_file (argv[optind++], target);
3008     }
3009
3010   END_PROGRESS (program_name);
3011
3012   return exit_status;
3013 }