contrib/binutils-2.17/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
   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 (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         }
1752       else
1753         {
1754           pinfo->symbols = NULL;
1755           pinfo->num_symbols = 0;
1756         }
1757
1758       if (! prefix_addresses)
1759         {
1760           pinfo->fprintf_func (pinfo->stream, "\n");
1761           objdump_print_addr_with_sym (abfd, section, sym, addr,
1762                                        pinfo, FALSE);
1763           pinfo->fprintf_func (pinfo->stream, ":\n");
1764         }
1765
1766       if (sym != NULL && bfd_asymbol_value (sym) > addr)
1767         nextsym = sym;
1768       else if (sym == NULL)
1769         nextsym = NULL;
1770       else
1771         {
1772 #define is_valid_next_sym(SYM) \
1773   ((SYM)->section == section \
1774    && (bfd_asymbol_value (SYM) > bfd_asymbol_value (sym)) \
1775    && pinfo->symbol_is_valid (SYM, pinfo))
1776
1777           /* Search forward for the next appropriate symbol in
1778              SECTION.  Note that all the symbols are sorted
1779              together into one big array, and that some sections
1780              may have overlapping addresses.  */
1781           while (place < sorted_symcount
1782                  && ! is_valid_next_sym (sorted_syms [place]))
1783             ++place;
1784
1785           if (place >= sorted_symcount)
1786             nextsym = NULL;
1787           else
1788             nextsym = sorted_syms[place];
1789         }
1790
1791       if (sym != NULL && bfd_asymbol_value (sym) > addr)
1792         nextstop_offset = bfd_asymbol_value (sym) - section->vma;
1793       else if (nextsym == NULL)
1794         nextstop_offset = stop_offset;
1795       else
1796         nextstop_offset = bfd_asymbol_value (nextsym) - section->vma;
1797
1798       if (nextstop_offset > stop_offset)
1799         nextstop_offset = stop_offset;
1800
1801       /* If a symbol is explicitly marked as being an object
1802          rather than a function, just dump the bytes without
1803          disassembling them.  */
1804       if (disassemble_all
1805           || sym == NULL
1806           || bfd_asymbol_value (sym) > addr
1807           || ((sym->flags & BSF_OBJECT) == 0
1808               && (strstr (bfd_asymbol_name (sym), "gnu_compiled")
1809                   == NULL)
1810               && (strstr (bfd_asymbol_name (sym), "gcc2_compiled")
1811                   == NULL))
1812           || (sym->flags & BSF_FUNCTION) != 0)
1813         insns = TRUE;
1814       else
1815         insns = FALSE;
1816
1817       disassemble_bytes (pinfo, paux->disassemble_fn, insns, data,
1818                          addr_offset, nextstop_offset,
1819                          rel_offset, &rel_pp, rel_ppend);
1820
1821       addr_offset = nextstop_offset;
1822       sym = nextsym;
1823     }
1824
1825   free (data);
1826
1827   if (rel_ppstart != NULL)
1828     free (rel_ppstart);
1829 }
1830
1831 /* Disassemble the contents of an object file.  */
1832
1833 static void
1834 disassemble_data (bfd *abfd)
1835 {
1836   struct disassemble_info disasm_info;
1837   struct objdump_disasm_info aux;
1838   long i;
1839
1840   print_files = NULL;
1841   prev_functionname = NULL;
1842   prev_line = -1;
1843
1844   /* We make a copy of syms to sort.  We don't want to sort syms
1845      because that will screw up the relocs.  */
1846   sorted_symcount = symcount ? symcount : dynsymcount;
1847   sorted_syms = xmalloc ((sorted_symcount + synthcount) * sizeof (asymbol *));
1848   memcpy (sorted_syms, symcount ? syms : dynsyms,
1849           sorted_symcount * sizeof (asymbol *));
1850
1851   sorted_symcount = remove_useless_symbols (sorted_syms, sorted_symcount);
1852
1853   for (i = 0; i < synthcount; ++i)
1854     {
1855       sorted_syms[sorted_symcount] = synthsyms + i;
1856       ++sorted_symcount;
1857     }
1858
1859   /* Sort the symbols into section and symbol order.  */
1860   qsort (sorted_syms, sorted_symcount, sizeof (asymbol *), compare_symbols);
1861
1862   init_disassemble_info (&disasm_info, stdout, (fprintf_ftype) fprintf);
1863
1864   disasm_info.application_data = (void *) &aux;
1865   aux.abfd = abfd;
1866   aux.require_sec = FALSE;
1867   aux.dynrelbuf = NULL;
1868   aux.dynrelcount = 0;
1869   aux.reloc = NULL;
1870
1871   disasm_info.print_address_func = objdump_print_address;
1872   disasm_info.symbol_at_address_func = objdump_symbol_at_address;
1873
1874   if (machine != NULL)
1875     {
1876       const bfd_arch_info_type *info = bfd_scan_arch (machine);
1877
1878       if (info == NULL)
1879         fatal (_("Can't use supplied machine %s"), machine);
1880
1881       abfd->arch_info = info;
1882     }
1883
1884   if (endian != BFD_ENDIAN_UNKNOWN)
1885     {
1886       struct bfd_target *xvec;
1887
1888       xvec = xmalloc (sizeof (struct bfd_target));
1889       memcpy (xvec, abfd->xvec, sizeof (struct bfd_target));
1890       xvec->byteorder = endian;
1891       abfd->xvec = xvec;
1892     }
1893
1894   /* Use libopcodes to locate a suitable disassembler.  */
1895   aux.disassemble_fn = disassembler (abfd);
1896   if (!aux.disassemble_fn)
1897     {
1898       non_fatal (_("Can't disassemble for architecture %s\n"),
1899                  bfd_printable_arch_mach (bfd_get_arch (abfd), 0));
1900       exit_status = 1;
1901       return;
1902     }
1903
1904   disasm_info.flavour = bfd_get_flavour (abfd);
1905   disasm_info.arch = bfd_get_arch (abfd);
1906   disasm_info.mach = bfd_get_mach (abfd);
1907   disasm_info.disassembler_options = disassembler_options;
1908   disasm_info.octets_per_byte = bfd_octets_per_byte (abfd);
1909   disasm_info.skip_zeroes = DEFAULT_SKIP_ZEROES;
1910   disasm_info.skip_zeroes_at_end = DEFAULT_SKIP_ZEROES_AT_END;
1911   disasm_info.disassembler_needs_relocs = FALSE;
1912
1913   if (bfd_big_endian (abfd))
1914     disasm_info.display_endian = disasm_info.endian = BFD_ENDIAN_BIG;
1915   else if (bfd_little_endian (abfd))
1916     disasm_info.display_endian = disasm_info.endian = BFD_ENDIAN_LITTLE;
1917   else
1918     /* ??? Aborting here seems too drastic.  We could default to big or little
1919        instead.  */
1920     disasm_info.endian = BFD_ENDIAN_UNKNOWN;
1921
1922   /* Allow the target to customize the info structure.  */
1923   disassemble_init_for_target (& disasm_info);
1924
1925   /* Pre-load the dynamic relocs if we are going
1926      to be dumping them along with the disassembly.  */
1927   if (dump_dynamic_reloc_info)
1928     {
1929       long relsize = bfd_get_dynamic_reloc_upper_bound (abfd);
1930
1931       if (relsize < 0)
1932         bfd_fatal (bfd_get_filename (abfd));
1933
1934       if (relsize > 0)
1935         {
1936           aux.dynrelbuf = xmalloc (relsize);
1937           aux.dynrelcount = bfd_canonicalize_dynamic_reloc (abfd,
1938                                                             aux.dynrelbuf,
1939                                                             dynsyms);
1940           if (aux.dynrelcount < 0)
1941             bfd_fatal (bfd_get_filename (abfd));
1942
1943           /* Sort the relocs by address.  */
1944           qsort (aux.dynrelbuf, aux.dynrelcount, sizeof (arelent *),
1945                  compare_relocs);
1946         }
1947     }
1948
1949   bfd_map_over_sections (abfd, disassemble_section, & disasm_info);
1950
1951   if (aux.dynrelbuf != NULL)
1952     free (aux.dynrelbuf);
1953   free (sorted_syms);
1954 }
1955 \f
1956 int
1957 load_debug_section (enum dwarf_section_display_enum debug, void *file)
1958 {
1959   struct dwarf_section *section = &debug_displays [debug].section;
1960   bfd *abfd = file;
1961   asection *sec;
1962   bfd_boolean ret;
1963
1964   /* If it is already loaded, do nothing.  */
1965   if (section->start != NULL)
1966     return 1;
1967
1968   /* Locate the debug section.  */
1969   sec = bfd_get_section_by_name (abfd, section->name);
1970   if (sec == NULL)
1971     return 0;
1972
1973   section->address = bfd_get_section_vma (abfd, sec);
1974   section->size = bfd_get_section_size (sec);
1975   section->start = xmalloc (section->size);
1976
1977   if (is_relocatable && debug_displays [debug].relocate)
1978     ret = bfd_simple_get_relocated_section_contents (abfd,
1979                                                      sec,
1980                                                      section->start,
1981                                                      syms) != NULL;
1982   else
1983     ret = bfd_get_section_contents (abfd, sec, section->start, 0,
1984                                     section->size);
1985
1986   if (!ret)
1987     {
1988       free_debug_section (debug);
1989       printf (_("\nCan't get contents for section '%s'.\n"),
1990               section->name);
1991     }
1992
1993   return ret;
1994 }
1995
1996 void
1997 free_debug_section (enum dwarf_section_display_enum debug)
1998 {
1999   struct dwarf_section *section = &debug_displays [debug].section;
2000
2001   if (section->start == NULL)
2002     return;
2003
2004   free ((char *) section->start);
2005   section->start = NULL;
2006   section->address = 0;
2007   section->size = 0;
2008 }
2009
2010 static void
2011 dump_dwarf_section (bfd *abfd, asection *section,
2012                     void *arg ATTRIBUTE_UNUSED)
2013 {
2014   const char *name = bfd_get_section_name (abfd, section);
2015   const char *match;
2016   enum dwarf_section_display_enum i;
2017
2018   if (strncmp (name, ".gnu.linkonce.wi.", 17) == 0)
2019     match = ".debug_info";
2020   else
2021     match = name;
2022
2023   for (i = 0; i < max; i++)
2024     if (strcmp (debug_displays[i].section.name, match) == 0)
2025       {
2026         if (!debug_displays[i].eh_frame)
2027           {
2028             struct dwarf_section *sec = &debug_displays [i].section;
2029
2030             if (load_debug_section (i, abfd))
2031               {
2032                 debug_displays[i].display (sec, abfd);
2033
2034                 if (i != info && i != abbrev)
2035                   free_debug_section (i);
2036               }
2037           }
2038         break;
2039       }
2040 }
2041
2042 static const char *mach_o_dwarf_sections [] = {
2043   "LC_SEGMENT.__DWARFA.__debug_abbrev",         /* .debug_abbrev */
2044   "LC_SEGMENT.__DWARFA.__debug_aranges",        /* .debug_aranges */
2045   "LC_SEGMENT.__DWARFA.__debug_frame",          /* .debug_frame */
2046   "LC_SEGMENT.__DWARFA.__debug_info",           /* .debug_info */
2047   "LC_SEGMENT.__DWARFA.__debug_line",           /* .debug_line */
2048   "LC_SEGMENT.__DWARFA.__debug_pubnames",       /* .debug_pubnames */
2049   ".eh_frame",                                  /* .eh_frame */
2050   "LC_SEGMENT.__DWARFA.__debug_macinfo",        /* .debug_macinfo */
2051   "LC_SEGMENT.__DWARFA.__debug_str",            /* .debug_str */
2052   "LC_SEGMENT.__DWARFA.__debug_loc",            /* .debug_loc */
2053   "LC_SEGMENT.__DWARFA.__debug_pubtypes",       /* .debug_pubtypes */
2054   "LC_SEGMENT.__DWARFA.__debug_ranges",         /* .debug_ranges */
2055   "LC_SEGMENT.__DWARFA.__debug_static_func",    /* .debug_static_func */
2056   "LC_SEGMENT.__DWARFA.__debug_static_vars",    /* .debug_static_vars */
2057   "LC_SEGMENT.__DWARFA.__debug_types",          /* .debug_types */
2058   "LC_SEGMENT.__DWARFA.__debug_weaknames"       /* .debug_weaknames */
2059 };
2060
2061 static const char *generic_dwarf_sections [max];
2062
2063 static void
2064 check_mach_o_dwarf (bfd *abfd)
2065 {
2066   static enum bfd_flavour old_flavour = bfd_target_unknown_flavour;
2067   enum bfd_flavour current_flavour = bfd_get_flavour (abfd);
2068   enum dwarf_section_display_enum i;
2069
2070   if (generic_dwarf_sections [0] == NULL)
2071     for (i = 0; i < max; i++)
2072       generic_dwarf_sections [i] = debug_displays[i].section.name;
2073
2074   if (old_flavour != current_flavour)
2075     {
2076       if (current_flavour == bfd_target_mach_o_flavour)
2077         for (i = 0; i < max; i++)
2078           debug_displays[i].section.name = mach_o_dwarf_sections [i];
2079       else if (old_flavour == bfd_target_mach_o_flavour)
2080         for (i = 0; i < max; i++)
2081           debug_displays[i].section.name = generic_dwarf_sections [i];
2082
2083       old_flavour = current_flavour;
2084     }
2085 }
2086
2087 /* Dump the dwarf debugging information.  */
2088
2089 static void
2090 dump_dwarf (bfd *abfd)
2091 {
2092   is_relocatable = ((abfd->flags & (HAS_RELOC | EXEC_P | DYNAMIC))
2093                     == HAS_RELOC);
2094
2095   /* FIXME: bfd_get_arch_size may return -1.  We assume that 64bit
2096      targets will return 64.  */
2097   eh_addr_size = bfd_get_arch_size (abfd) == 64 ? 8 : 4;
2098
2099   if (bfd_big_endian (abfd))
2100     byte_get = byte_get_big_endian;
2101   else if (bfd_little_endian (abfd))
2102     byte_get = byte_get_little_endian;
2103   else
2104     abort ();
2105
2106   check_mach_o_dwarf (abfd);
2107
2108   bfd_map_over_sections (abfd, dump_dwarf_section, NULL);
2109
2110   free_debug_memory ();
2111 }
2112 \f
2113 /* Read ABFD's stabs section STABSECT_NAME, and return a pointer to
2114    it.  Return NULL on failure.   */
2115
2116 static char *
2117 read_section_stabs (bfd *abfd, const char *sect_name, bfd_size_type *size_ptr)
2118 {
2119   asection *stabsect;
2120   bfd_size_type size;
2121   char *contents;
2122
2123   stabsect = bfd_get_section_by_name (abfd, sect_name);
2124   if (stabsect == NULL)
2125     {
2126       printf (_("No %s section present\n\n"), sect_name);
2127       return FALSE;
2128     }
2129
2130   size = bfd_section_size (abfd, stabsect);
2131   contents  = xmalloc (size);
2132
2133   if (! bfd_get_section_contents (abfd, stabsect, contents, 0, size))
2134     {
2135       non_fatal (_("Reading %s section of %s failed: %s"),
2136                  sect_name, bfd_get_filename (abfd),
2137                  bfd_errmsg (bfd_get_error ()));
2138       free (contents);
2139       exit_status = 1;
2140       return NULL;
2141     }
2142
2143   *size_ptr = size;
2144
2145   return contents;
2146 }
2147
2148 /* Stabs entries use a 12 byte format:
2149      4 byte string table index
2150      1 byte stab type
2151      1 byte stab other field
2152      2 byte stab desc field
2153      4 byte stab value
2154    FIXME: This will have to change for a 64 bit object format.  */
2155
2156 #define STRDXOFF  (0)
2157 #define TYPEOFF   (4)
2158 #define OTHEROFF  (5)
2159 #define DESCOFF   (6)
2160 #define VALOFF    (8)
2161 #define STABSIZE (12)
2162
2163 /* Print ABFD's stabs section STABSECT_NAME (in `stabs'),
2164    using string table section STRSECT_NAME (in `strtab').  */
2165
2166 static void
2167 print_section_stabs (bfd *abfd,
2168                      const char *stabsect_name,
2169                      unsigned *string_offset_ptr)
2170 {
2171   int i;
2172   unsigned file_string_table_offset = 0;
2173   unsigned next_file_string_table_offset = *string_offset_ptr;
2174   bfd_byte *stabp, *stabs_end;
2175
2176   stabp = stabs;
2177   stabs_end = stabp + stab_size;
2178
2179   printf (_("Contents of %s section:\n\n"), stabsect_name);
2180   printf ("Symnum n_type n_othr n_desc n_value  n_strx String\n");
2181
2182   /* Loop through all symbols and print them.
2183
2184      We start the index at -1 because there is a dummy symbol on
2185      the front of stabs-in-{coff,elf} sections that supplies sizes.  */
2186   for (i = -1; stabp < stabs_end; stabp += STABSIZE, i++)
2187     {
2188       const char *name;
2189       unsigned long strx;
2190       unsigned char type, other;
2191       unsigned short desc;
2192       bfd_vma value;
2193
2194       strx = bfd_h_get_32 (abfd, stabp + STRDXOFF);
2195       type = bfd_h_get_8 (abfd, stabp + TYPEOFF);
2196       other = bfd_h_get_8 (abfd, stabp + OTHEROFF);
2197       desc = bfd_h_get_16 (abfd, stabp + DESCOFF);
2198       value = bfd_h_get_32 (abfd, stabp + VALOFF);
2199
2200       printf ("\n%-6d ", i);
2201       /* Either print the stab name, or, if unnamed, print its number
2202          again (makes consistent formatting for tools like awk).  */
2203       name = bfd_get_stab_name (type);
2204       if (name != NULL)
2205         printf ("%-6s", name);
2206       else if (type == N_UNDF)
2207         printf ("HdrSym");
2208       else
2209         printf ("%-6d", type);
2210       printf (" %-6d %-6d ", other, desc);
2211       bfd_printf_vma (abfd, value);
2212       printf (" %-6lu", strx);
2213
2214       /* Symbols with type == 0 (N_UNDF) specify the length of the
2215          string table associated with this file.  We use that info
2216          to know how to relocate the *next* file's string table indices.  */
2217       if (type == N_UNDF)
2218         {
2219           file_string_table_offset = next_file_string_table_offset;
2220           next_file_string_table_offset += value;
2221         }
2222       else
2223         {
2224           /* Using the (possibly updated) string table offset, print the
2225              string (if any) associated with this symbol.  */
2226           if ((strx + file_string_table_offset) < stabstr_size)
2227             printf (" %s", &strtab[strx + file_string_table_offset]);
2228           else
2229             printf (" *");
2230         }
2231     }
2232   printf ("\n\n");
2233   *string_offset_ptr = next_file_string_table_offset;
2234 }
2235
2236 typedef struct
2237 {
2238   const char * section_name;
2239   const char * string_section_name;
2240   unsigned string_offset;
2241 }
2242 stab_section_names;
2243
2244 static void
2245 find_stabs_section (bfd *abfd, asection *section, void *names)
2246 {
2247   int len;
2248   stab_section_names * sought = (stab_section_names *) names;
2249
2250   /* Check for section names for which stabsect_name is a prefix, to
2251      handle .stab.N, etc.  */
2252   len = strlen (sought->section_name);
2253
2254   /* If the prefix matches, and the files section name ends with a
2255      nul or a digit, then we match.  I.e., we want either an exact
2256      match or a section followed by a number.  */
2257   if (strncmp (sought->section_name, section->name, len) == 0
2258       && (section->name[len] == 0
2259           || (section->name[len] == '.' && ISDIGIT (section->name[len + 1]))))
2260     {
2261       if (strtab == NULL)
2262         strtab = read_section_stabs (abfd, sought->string_section_name,
2263                                      &stabstr_size);
2264
2265       if (strtab)
2266         {
2267           stabs = (bfd_byte *) read_section_stabs (abfd, section->name,
2268                                                    &stab_size);
2269           if (stabs)
2270             print_section_stabs (abfd, section->name, &sought->string_offset);
2271         }
2272     }
2273 }
2274
2275 static void
2276 dump_stabs_section (bfd *abfd, char *stabsect_name, char *strsect_name)
2277 {
2278   stab_section_names s;
2279
2280   s.section_name = stabsect_name;
2281   s.string_section_name = strsect_name;
2282   s.string_offset = 0;
2283
2284   bfd_map_over_sections (abfd, find_stabs_section, & s);
2285
2286   free (strtab);
2287   strtab = NULL;
2288 }
2289
2290 /* Dump the any sections containing stabs debugging information.  */
2291
2292 static void
2293 dump_stabs (bfd *abfd)
2294 {
2295   dump_stabs_section (abfd, ".stab", ".stabstr");
2296   dump_stabs_section (abfd, ".stab.excl", ".stab.exclstr");
2297   dump_stabs_section (abfd, ".stab.index", ".stab.indexstr");
2298   dump_stabs_section (abfd, "$GDB_SYMBOLS$", "$GDB_STRINGS$");
2299 }
2300 \f
2301 static void
2302 dump_bfd_header (bfd *abfd)
2303 {
2304   char *comma = "";
2305
2306   printf (_("architecture: %s, "),
2307           bfd_printable_arch_mach (bfd_get_arch (abfd),
2308                                    bfd_get_mach (abfd)));
2309   printf (_("flags 0x%08x:\n"), abfd->flags);
2310
2311 #define PF(x, y)    if (abfd->flags & x) {printf("%s%s", comma, y); comma=", ";}
2312   PF (HAS_RELOC, "HAS_RELOC");
2313   PF (EXEC_P, "EXEC_P");
2314   PF (HAS_LINENO, "HAS_LINENO");
2315   PF (HAS_DEBUG, "HAS_DEBUG");
2316   PF (HAS_SYMS, "HAS_SYMS");
2317   PF (HAS_LOCALS, "HAS_LOCALS");
2318   PF (DYNAMIC, "DYNAMIC");
2319   PF (WP_TEXT, "WP_TEXT");
2320   PF (D_PAGED, "D_PAGED");
2321   PF (BFD_IS_RELAXABLE, "BFD_IS_RELAXABLE");
2322   PF (HAS_LOAD_PAGE, "HAS_LOAD_PAGE");
2323   printf (_("\nstart address 0x"));
2324   bfd_printf_vma (abfd, abfd->start_address);
2325   printf ("\n");
2326 }
2327
2328 \f
2329 static void
2330 dump_bfd_private_header (bfd *abfd)
2331 {
2332   bfd_print_private_bfd_data (abfd, stdout);
2333 }
2334
2335 \f
2336 /* Display a section in hexadecimal format with associated characters.
2337    Each line prefixed by the zero padded address.  */
2338
2339 static void
2340 dump_section (bfd *abfd, asection *section, void *dummy ATTRIBUTE_UNUSED)
2341 {
2342   bfd_byte *data = 0;
2343   bfd_size_type datasize;
2344   bfd_size_type addr_offset;
2345   bfd_size_type start_offset;
2346   bfd_size_type stop_offset;
2347   unsigned int opb = bfd_octets_per_byte (abfd);
2348   /* Bytes per line.  */
2349   const int onaline = 16;
2350   char buf[64];
2351   int count;
2352   int width;
2353
2354   if ((section->flags & SEC_HAS_CONTENTS) == 0)
2355     return;
2356
2357   if (! process_section_p (section))
2358     return;
2359
2360   if ((datasize = bfd_section_size (abfd, section)) == 0)
2361     return;
2362
2363   printf (_("Contents of section %s:\n"), section->name);
2364
2365   data = xmalloc (datasize);
2366
2367   bfd_get_section_contents (abfd, section, data, 0, datasize);
2368
2369   /* Compute the address range to display.  */
2370   if (start_address == (bfd_vma) -1
2371       || start_address < section->vma)
2372     start_offset = 0;
2373   else
2374     start_offset = start_address - section->vma;
2375
2376   if (stop_address == (bfd_vma) -1)
2377     stop_offset = datasize / opb;
2378   else
2379     {
2380       if (stop_address < section->vma)
2381         stop_offset = 0;
2382       else
2383         stop_offset = stop_address - section->vma;
2384
2385       if (stop_offset > datasize / opb)
2386         stop_offset = datasize / opb;
2387     }
2388
2389   width = 4;
2390
2391   bfd_sprintf_vma (abfd, buf, start_offset + section->vma);
2392   if (strlen (buf) >= sizeof (buf))
2393     abort ();
2394
2395   count = 0;
2396   while (buf[count] == '0' && buf[count+1] != '\0')
2397     count++;
2398   count = strlen (buf) - count;
2399   if (count > width)
2400     width = count;
2401
2402   bfd_sprintf_vma (abfd, buf, stop_offset + section->vma - 1);
2403   if (strlen (buf) >= sizeof (buf))
2404     abort ();
2405
2406   count = 0;
2407   while (buf[count] == '0' && buf[count+1] != '\0')
2408     count++;
2409   count = strlen (buf) - count;
2410   if (count > width)
2411     width = count;
2412
2413   for (addr_offset = start_offset;
2414        addr_offset < stop_offset; addr_offset += onaline / opb)
2415     {
2416       bfd_size_type j;
2417
2418       bfd_sprintf_vma (abfd, buf, (addr_offset + section->vma));
2419       count = strlen (buf);
2420       if ((size_t) count >= sizeof (buf))
2421         abort ();
2422
2423       putchar (' ');
2424       while (count < width)
2425         {
2426           putchar ('0');
2427           count++;
2428         }
2429       fputs (buf + count - width, stdout);
2430       putchar (' ');
2431
2432       for (j = addr_offset * opb;
2433            j < addr_offset * opb + onaline; j++)
2434         {
2435           if (j < stop_offset * opb)
2436             printf ("%02x", (unsigned) (data[j]));
2437           else
2438             printf ("  ");
2439           if ((j & 3) == 3)
2440             printf (" ");
2441         }
2442
2443       printf (" ");
2444       for (j = addr_offset * opb;
2445            j < addr_offset * opb + onaline; j++)
2446         {
2447           if (j >= stop_offset * opb)
2448             printf (" ");
2449           else
2450             printf ("%c", ISPRINT (data[j]) ? data[j] : '.');
2451         }
2452       putchar ('\n');
2453     }
2454   free (data);
2455 }
2456
2457 /* Actually display the various requested regions.  */
2458
2459 static void
2460 dump_data (bfd *abfd)
2461 {
2462   bfd_map_over_sections (abfd, dump_section, NULL);
2463 }
2464
2465 /* Should perhaps share code and display with nm?  */
2466
2467 static void
2468 dump_symbols (bfd *abfd ATTRIBUTE_UNUSED, bfd_boolean dynamic)
2469 {
2470   asymbol **current;
2471   long max;
2472   long count;
2473
2474   if (dynamic)
2475     {
2476       current = dynsyms;
2477       max = dynsymcount;
2478       printf ("DYNAMIC SYMBOL TABLE:\n");
2479     }
2480   else
2481     {
2482       current = syms;
2483       max = symcount;
2484       printf ("SYMBOL TABLE:\n");
2485     }
2486
2487   if (max == 0)
2488     printf (_("no symbols\n"));
2489
2490   for (count = 0; count < max; count++)
2491     {
2492       bfd *cur_bfd;
2493
2494       if (*current == NULL)
2495         printf (_("no information for symbol number %ld\n"), count);
2496
2497       else if ((cur_bfd = bfd_asymbol_bfd (*current)) == NULL)
2498         printf (_("could not determine the type of symbol number %ld\n"),
2499                 count);
2500
2501       else if (process_section_p ((* current)->section)
2502                && (dump_special_syms
2503                    || !bfd_is_target_special_symbol (cur_bfd, *current)))
2504         {
2505           const char *name = (*current)->name;
2506
2507           if (do_demangle && name != NULL && *name != '\0')
2508             {
2509               char *alloc;
2510
2511               /* If we want to demangle the name, we demangle it
2512                  here, and temporarily clobber it while calling
2513                  bfd_print_symbol.  FIXME: This is a gross hack.  */
2514               alloc = demangle (cur_bfd, name);
2515               (*current)->name = alloc;
2516               bfd_print_symbol (cur_bfd, stdout, *current,
2517                                 bfd_print_symbol_all);
2518               (*current)->name = name;
2519               free (alloc);
2520             }
2521           else
2522             bfd_print_symbol (cur_bfd, stdout, *current,
2523                               bfd_print_symbol_all);
2524           printf ("\n");
2525         }
2526
2527       current++;
2528     }
2529   printf ("\n\n");
2530 }
2531 \f
2532 static void
2533 dump_reloc_set (bfd *abfd, asection *sec, arelent **relpp, long relcount)
2534 {
2535   arelent **p;
2536   char *last_filename, *last_functionname;
2537   unsigned int last_line;
2538
2539   /* Get column headers lined up reasonably.  */
2540   {
2541     static int width;
2542
2543     if (width == 0)
2544       {
2545         char buf[30];
2546
2547         bfd_sprintf_vma (abfd, buf, (bfd_vma) -1);
2548         width = strlen (buf) - 7;
2549       }
2550     printf ("OFFSET %*s TYPE %*s VALUE \n", width, "", 12, "");
2551   }
2552
2553   last_filename = NULL;
2554   last_functionname = NULL;
2555   last_line = 0;
2556
2557   for (p = relpp; relcount && *p != NULL; p++, relcount--)
2558     {
2559       arelent *q = *p;
2560       const char *filename, *functionname;
2561       unsigned int line;
2562       const char *sym_name;
2563       const char *section_name;
2564
2565       if (start_address != (bfd_vma) -1
2566           && q->address < start_address)
2567         continue;
2568       if (stop_address != (bfd_vma) -1
2569           && q->address > stop_address)
2570         continue;
2571
2572       if (with_line_numbers
2573           && sec != NULL
2574           && bfd_find_nearest_line (abfd, sec, syms, q->address,
2575                                     &filename, &functionname, &line))
2576         {
2577           if (functionname != NULL
2578               && (last_functionname == NULL
2579                   || strcmp (functionname, last_functionname) != 0))
2580             {
2581               printf ("%s():\n", functionname);
2582               if (last_functionname != NULL)
2583                 free (last_functionname);
2584               last_functionname = xstrdup (functionname);
2585             }
2586
2587           if (line > 0
2588               && (line != last_line
2589                   || (filename != NULL
2590                       && last_filename != NULL
2591                       && strcmp (filename, last_filename) != 0)))
2592             {
2593               printf ("%s:%u\n", filename == NULL ? "???" : filename, line);
2594               last_line = line;
2595               if (last_filename != NULL)
2596                 free (last_filename);
2597               if (filename == NULL)
2598                 last_filename = NULL;
2599               else
2600                 last_filename = xstrdup (filename);
2601             }
2602         }
2603
2604       if (q->sym_ptr_ptr && *q->sym_ptr_ptr)
2605         {
2606           sym_name = (*(q->sym_ptr_ptr))->name;
2607           section_name = (*(q->sym_ptr_ptr))->section->name;
2608         }
2609       else
2610         {
2611           sym_name = NULL;
2612           section_name = NULL;
2613         }
2614
2615       bfd_printf_vma (abfd, q->address);
2616       if (q->howto == NULL)
2617         printf (" *unknown*         ");
2618       else if (q->howto->name)
2619         printf (" %-16s  ", q->howto->name);
2620       else
2621         printf (" %-16d  ", q->howto->type);
2622       if (sym_name)
2623         objdump_print_symname (abfd, NULL, *q->sym_ptr_ptr);
2624       else
2625         {
2626           if (section_name == NULL)
2627             section_name = "*unknown*";
2628           printf ("[%s]", section_name);
2629         }
2630
2631       if (q->addend)
2632         {
2633           printf ("+0x");
2634           bfd_printf_vma (abfd, q->addend);
2635         }
2636
2637       printf ("\n");
2638     }
2639 }
2640
2641 static void
2642 dump_relocs_in_section (bfd *abfd,
2643                         asection *section,
2644                         void *dummy ATTRIBUTE_UNUSED)
2645 {
2646   arelent **relpp;
2647   long relcount;
2648   long relsize;
2649
2650   if (   bfd_is_abs_section (section)
2651       || bfd_is_und_section (section)
2652       || bfd_is_com_section (section)
2653       || (! process_section_p (section))
2654       || ((section->flags & SEC_RELOC) == 0))
2655     return;
2656
2657   relsize = bfd_get_reloc_upper_bound (abfd, section);
2658   if (relsize < 0)
2659     bfd_fatal (bfd_get_filename (abfd));
2660
2661   printf ("RELOCATION RECORDS FOR [%s]:", section->name);
2662
2663   if (relsize == 0)
2664     {
2665       printf (" (none)\n\n");
2666       return;
2667     }
2668
2669   relpp = xmalloc (relsize);
2670   relcount = bfd_canonicalize_reloc (abfd, section, relpp, syms);
2671
2672   if (relcount < 0)
2673     bfd_fatal (bfd_get_filename (abfd));
2674   else if (relcount == 0)
2675     printf (" (none)\n\n");
2676   else
2677     {
2678       printf ("\n");
2679       dump_reloc_set (abfd, section, relpp, relcount);
2680       printf ("\n\n");
2681     }
2682   free (relpp);
2683 }
2684
2685 static void
2686 dump_relocs (bfd *abfd)
2687 {
2688   bfd_map_over_sections (abfd, dump_relocs_in_section, NULL);
2689 }
2690
2691 static void
2692 dump_dynamic_relocs (bfd *abfd)
2693 {
2694   long relsize;
2695   arelent **relpp;
2696   long relcount;
2697
2698   relsize = bfd_get_dynamic_reloc_upper_bound (abfd);
2699   if (relsize < 0)
2700     bfd_fatal (bfd_get_filename (abfd));
2701
2702   printf ("DYNAMIC RELOCATION RECORDS");
2703
2704   if (relsize == 0)
2705     printf (" (none)\n\n");
2706   else
2707     {
2708       relpp = xmalloc (relsize);
2709       relcount = bfd_canonicalize_dynamic_reloc (abfd, relpp, dynsyms);
2710
2711       if (relcount < 0)
2712         bfd_fatal (bfd_get_filename (abfd));
2713       else if (relcount == 0)
2714         printf (" (none)\n\n");
2715       else
2716         {
2717           printf ("\n");
2718           dump_reloc_set (abfd, NULL, relpp, relcount);
2719           printf ("\n\n");
2720         }
2721       free (relpp);
2722     }
2723 }
2724
2725 /* Creates a table of paths, to search for source files.  */
2726
2727 static void
2728 add_include_path (const char *path)
2729 {
2730   if (path[0] == 0)
2731     return;
2732   include_path_count++;
2733   include_paths = xrealloc (include_paths,
2734                             include_path_count * sizeof (*include_paths));
2735 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
2736   if (path[1] == ':' && path[2] == 0)
2737     path = concat (path, ".", (const char *) 0);
2738 #endif
2739   include_paths[include_path_count - 1] = path;
2740 }
2741
2742 static void
2743 adjust_addresses (bfd *abfd ATTRIBUTE_UNUSED,
2744                   asection *section,
2745                   void *arg)
2746 {
2747   if ((section->flags & SEC_DEBUGGING) == 0)
2748     {
2749       bfd_boolean *has_reloc_p = (bfd_boolean *) arg;
2750       section->vma += adjust_section_vma;
2751       if (*has_reloc_p)
2752         section->lma += adjust_section_vma;
2753     }
2754 }
2755
2756 /* Dump selected contents of ABFD.  */
2757
2758 static void
2759 dump_bfd (bfd *abfd)
2760 {
2761   /* If we are adjusting section VMA's, change them all now.  Changing
2762      the BFD information is a hack.  However, we must do it, or
2763      bfd_find_nearest_line will not do the right thing.  */
2764   if (adjust_section_vma != 0)
2765     {
2766       bfd_boolean has_reloc = (abfd->flags & HAS_RELOC);
2767       bfd_map_over_sections (abfd, adjust_addresses, &has_reloc);
2768     }
2769
2770   if (! dump_debugging_tags)
2771     printf (_("\n%s:     file format %s\n"), bfd_get_filename (abfd),
2772             abfd->xvec->name);
2773   if (dump_ar_hdrs)
2774     print_arelt_descr (stdout, abfd, TRUE);
2775   if (dump_file_header)
2776     dump_bfd_header (abfd);
2777   if (dump_private_headers)
2778     dump_bfd_private_header (abfd);
2779   if (! dump_debugging_tags)
2780     putchar ('\n');
2781   if (dump_section_headers)
2782     dump_headers (abfd);
2783
2784   if (dump_symtab
2785       || dump_reloc_info
2786       || disassemble
2787       || dump_debugging
2788       || dump_dwarf_section_info)
2789     syms = slurp_symtab (abfd);
2790   if (dump_dynamic_symtab || dump_dynamic_reloc_info
2791       || (disassemble && bfd_get_dynamic_symtab_upper_bound (abfd) > 0))
2792     dynsyms = slurp_dynamic_symtab (abfd);
2793   if (disassemble)
2794     {
2795       synthcount = bfd_get_synthetic_symtab (abfd, symcount, syms,
2796                                              dynsymcount, dynsyms, &synthsyms);
2797       if (synthcount < 0)
2798         synthcount = 0;
2799     }
2800
2801   if (dump_symtab)
2802     dump_symbols (abfd, FALSE);
2803   if (dump_dynamic_symtab)
2804     dump_symbols (abfd, TRUE);
2805   if (dump_dwarf_section_info)
2806     dump_dwarf (abfd);
2807   if (dump_stab_section_info)
2808     dump_stabs (abfd);
2809   if (dump_reloc_info && ! disassemble)
2810     dump_relocs (abfd);
2811   if (dump_dynamic_reloc_info && ! disassemble)
2812     dump_dynamic_relocs (abfd);
2813   if (dump_section_contents)
2814     dump_data (abfd);
2815   if (disassemble)
2816     disassemble_data (abfd);
2817
2818   if (dump_debugging)
2819     {
2820       void *dhandle;
2821
2822       dhandle = read_debugging_info (abfd, syms, symcount);
2823       if (dhandle != NULL)
2824         {
2825           if (! print_debugging_info (stdout, dhandle, abfd, syms, demangle,
2826               dump_debugging_tags ? TRUE : FALSE))
2827             {
2828               non_fatal (_("%s: printing debugging information failed"),
2829                          bfd_get_filename (abfd));
2830               exit_status = 1;
2831             }
2832         }
2833     }
2834
2835   if (syms)
2836     {
2837       free (syms);
2838       syms = NULL;
2839     }
2840
2841   if (dynsyms)
2842     {
2843       free (dynsyms);
2844       dynsyms = NULL;
2845     }
2846
2847   if (synthsyms)
2848     {
2849       free (synthsyms);
2850       synthsyms = NULL;
2851     }
2852
2853   symcount = 0;
2854   dynsymcount = 0;
2855   synthcount = 0;
2856 }
2857
2858 static void
2859 display_bfd (bfd *abfd)
2860 {
2861   char **matching;
2862
2863   if (bfd_check_format_matches (abfd, bfd_object, &matching))
2864     {
2865       dump_bfd (abfd);
2866       return;
2867     }
2868
2869   if (bfd_get_error () == bfd_error_file_ambiguously_recognized)
2870     {
2871       nonfatal (bfd_get_filename (abfd));
2872       list_matching_formats (matching);
2873       free (matching);
2874       return;
2875     }
2876
2877   if (bfd_get_error () != bfd_error_file_not_recognized)
2878     {
2879       nonfatal (bfd_get_filename (abfd));
2880       return;
2881     }
2882
2883   if (bfd_check_format_matches (abfd, bfd_core, &matching))
2884     {
2885       dump_bfd (abfd);
2886       return;
2887     }
2888
2889   nonfatal (bfd_get_filename (abfd));
2890
2891   if (bfd_get_error () == bfd_error_file_ambiguously_recognized)
2892     {
2893       list_matching_formats (matching);
2894       free (matching);
2895     }
2896 }
2897
2898 static void
2899 display_file (char *filename, char *target)
2900 {
2901   bfd *file;
2902   bfd *arfile = NULL;
2903
2904   if (get_file_size (filename) < 1)
2905     return;
2906
2907   file = bfd_openr (filename, target);
2908   if (file == NULL)
2909     {
2910       nonfatal (filename);
2911       return;
2912     }
2913
2914   /* If the file is an archive, process all of its elements.  */
2915   if (bfd_check_format (file, bfd_archive))
2916     {
2917       bfd *last_arfile = NULL;
2918
2919       printf (_("In archive %s:\n"), bfd_get_filename (file));
2920       for (;;)
2921         {
2922           bfd_set_error (bfd_error_no_error);
2923
2924           arfile = bfd_openr_next_archived_file (file, arfile);
2925           if (arfile == NULL)
2926             {
2927               if (bfd_get_error () != bfd_error_no_more_archived_files)
2928                 nonfatal (bfd_get_filename (file));
2929               break;
2930             }
2931
2932           display_bfd (arfile);
2933
2934           if (last_arfile != NULL)
2935             bfd_close (last_arfile);
2936           last_arfile = arfile;
2937         }
2938
2939       if (last_arfile != NULL)
2940         bfd_close (last_arfile);
2941     }
2942   else
2943     display_bfd (file);
2944
2945   bfd_close (file);
2946 }
2947 \f
2948 int
2949 main (int argc, char **argv)
2950 {
2951   int c;
2952   char *target = default_target;
2953   bfd_boolean seenflag = FALSE;
2954
2955 #if defined (HAVE_SETLOCALE)
2956 #if defined (HAVE_LC_MESSAGES)
2957   setlocale (LC_MESSAGES, "");
2958 #endif
2959   setlocale (LC_CTYPE, "");
2960 #endif
2961
2962   bindtextdomain (PACKAGE, LOCALEDIR);
2963   textdomain (PACKAGE);
2964
2965   program_name = *argv;
2966   xmalloc_set_program_name (program_name);
2967
2968   START_PROGRESS (program_name, 0);
2969
2970   expandargv (&argc, &argv);
2971
2972   bfd_init ();
2973   set_default_bfd_target ();
2974
2975   while ((c = getopt_long (argc, argv, "pib:m:M:VvCdDlfaHhrRtTxsSI:j:wE:zgeGW",
2976                            long_options, (int *) 0))
2977          != EOF)
2978     {
2979       switch (c)
2980         {
2981         case 0:
2982           break;                /* We've been given a long option.  */
2983         case 'm':
2984           machine = optarg;
2985           break;
2986         case 'M':
2987           if (disassembler_options)
2988             /* Ignore potential memory leak for now.  */
2989             disassembler_options = concat (disassembler_options, ",",
2990                                            optarg, NULL);
2991           else
2992             disassembler_options = optarg;
2993           break;
2994         case 'j':
2995           if (only_used == only_size)
2996             {
2997               only_size += 8;
2998               only = xrealloc (only, only_size * sizeof (char *));
2999             }
3000           only [only_used++] = optarg;
3001           break;
3002         case 'l':
3003           with_line_numbers = TRUE;
3004           break;
3005         case 'b':
3006           target = optarg;
3007           break;
3008         case 'C':
3009           do_demangle = TRUE;
3010           if (optarg != NULL)
3011             {
3012               enum demangling_styles style;
3013
3014               style = cplus_demangle_name_to_style (optarg);
3015               if (style == unknown_demangling)
3016                 fatal (_("unknown demangling style `%s'"),
3017                        optarg);
3018
3019               cplus_demangle_set_style (style);
3020             }
3021           break;
3022         case 'w':
3023           wide_output = TRUE;
3024           break;
3025         case OPTION_ADJUST_VMA:
3026           adjust_section_vma = parse_vma (optarg, "--adjust-vma");
3027           break;
3028         case OPTION_START_ADDRESS:
3029           start_address = parse_vma (optarg, "--start-address");
3030           break;
3031         case OPTION_STOP_ADDRESS:
3032           stop_address = parse_vma (optarg, "--stop-address");
3033           break;
3034         case 'E':
3035           if (strcmp (optarg, "B") == 0)
3036             endian = BFD_ENDIAN_BIG;
3037           else if (strcmp (optarg, "L") == 0)
3038             endian = BFD_ENDIAN_LITTLE;
3039           else
3040             {
3041               non_fatal (_("unrecognized -E option"));
3042               usage (stderr, 1);
3043             }
3044           break;
3045         case OPTION_ENDIAN:
3046           if (strncmp (optarg, "big", strlen (optarg)) == 0)
3047             endian = BFD_ENDIAN_BIG;
3048           else if (strncmp (optarg, "little", strlen (optarg)) == 0)
3049             endian = BFD_ENDIAN_LITTLE;
3050           else
3051             {
3052               non_fatal (_("unrecognized --endian type `%s'"), optarg);
3053               usage (stderr, 1);
3054             }
3055           break;
3056
3057         case 'f':
3058           dump_file_header = TRUE;
3059           seenflag = TRUE;
3060           break;
3061         case 'i':
3062           formats_info = TRUE;
3063           seenflag = TRUE;
3064           break;
3065         case 'I':
3066           add_include_path (optarg);
3067           break;
3068         case 'p':
3069           dump_private_headers = TRUE;
3070           seenflag = TRUE;
3071           break;
3072         case 'x':
3073           dump_private_headers = TRUE;
3074           dump_symtab = TRUE;
3075           dump_reloc_info = TRUE;
3076           dump_file_header = TRUE;
3077           dump_ar_hdrs = TRUE;
3078           dump_section_headers = TRUE;
3079           seenflag = TRUE;
3080           break;
3081         case 't':
3082           dump_symtab = TRUE;
3083           seenflag = TRUE;
3084           break;
3085         case 'T':
3086           dump_dynamic_symtab = TRUE;
3087           seenflag = TRUE;
3088           break;
3089         case 'd':
3090           disassemble = TRUE;
3091           seenflag = TRUE;
3092           break;
3093         case 'z':
3094           disassemble_zeroes = TRUE;
3095           break;
3096         case 'D':
3097           disassemble = TRUE;
3098           disassemble_all = TRUE;
3099           seenflag = TRUE;
3100           break;
3101         case 'S':
3102           disassemble = TRUE;
3103           with_source_code = TRUE;
3104           seenflag = TRUE;
3105           break;
3106         case 'g':
3107           dump_debugging = 1;
3108           seenflag = TRUE;
3109           break;
3110         case 'e':
3111           dump_debugging = 1;
3112           dump_debugging_tags = 1;
3113           do_demangle = TRUE;
3114           seenflag = TRUE;
3115           break;
3116         case 'W':
3117           dump_dwarf_section_info = TRUE;
3118           seenflag = TRUE;
3119           do_debug_info = 1;
3120           do_debug_abbrevs = 1;
3121           do_debug_lines = 1;
3122           do_debug_pubnames = 1;
3123           do_debug_aranges = 1;
3124           do_debug_ranges = 1;
3125           do_debug_frames = 1;
3126           do_debug_macinfo = 1;
3127           do_debug_str = 1;
3128           do_debug_loc = 1;
3129           break;
3130         case 'G':
3131           dump_stab_section_info = TRUE;
3132           seenflag = TRUE;
3133           break;
3134         case 's':
3135           dump_section_contents = TRUE;
3136           seenflag = TRUE;
3137           break;
3138         case 'r':
3139           dump_reloc_info = TRUE;
3140           seenflag = TRUE;
3141           break;
3142         case 'R':
3143           dump_dynamic_reloc_info = TRUE;
3144           seenflag = TRUE;
3145           break;
3146         case 'a':
3147           dump_ar_hdrs = TRUE;
3148           seenflag = TRUE;
3149           break;
3150         case 'h':
3151           dump_section_headers = TRUE;
3152           seenflag = TRUE;
3153           break;
3154         case 'H':
3155           usage (stdout, 0);
3156           seenflag = TRUE;
3157         case 'v':
3158         case 'V':
3159           show_version = TRUE;
3160           seenflag = TRUE;
3161           break;
3162
3163         default:
3164           usage (stderr, 1);
3165         }
3166     }
3167
3168   if (show_version)
3169     print_version ("objdump");
3170
3171   if (!seenflag)
3172     usage (stderr, 2);
3173
3174   if (formats_info)
3175     exit_status = display_info ();
3176   else
3177     {
3178       if (optind == argc)
3179         display_file ("a.out", target);
3180       else
3181         for (; optind < argc;)
3182           display_file (argv[optind++], target);
3183     }
3184
3185   END_PROGRESS (program_name);
3186
3187   return exit_status;
3188 }