binutils/objdump.c

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