binutils/objdump.c

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