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