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