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
1530               if (info->disassembler_needs_relocs
1531                   && (bfd_get_file_flags (aux->abfd) & EXEC_P) == 0
1532                   && (bfd_get_file_flags (aux->abfd) & DYNAMIC) == 0
1533                   && *relppp < relppend)
1534                 {
1535                   bfd_signed_vma distance_to_rel;
1536
1537                   distance_to_rel = (**relppp)->address
1538                     - (rel_offset + addr_offset);
1539
1540                   /* Check to see if the current reloc is associated with
1541                      the instruction that we are about to disassemble.  */
1542                   if (distance_to_rel == 0
1543                       /* FIXME: This is wrong.  We are trying to catch
1544                          relocs that are addressed part way through the
1545                          current instruction, as might happen with a packed
1546                          VLIW instruction.  Unfortunately we do not know the
1547                          length of the current instruction since we have not
1548                          disassembled it yet.  Instead we take a guess based
1549                          upon the length of the previous instruction.  The
1550                          proper solution is to have a new target-specific
1551                          disassembler function which just returns the length
1552                          of an instruction at a given address without trying
1553                          to display its disassembly. */
1554                       || (distance_to_rel > 0
1555                           && distance_to_rel < (bfd_signed_vma) (previous_octets/ opb)))
1556                     {
1557                       info->flags |= INSN_HAS_RELOC;
1558                       aux->reloc = **relppp;
1559                     }
1560                   else
1561                     aux->reloc = NULL;
1562                 }
1563
1564               octets = (*disassemble_fn) (section->vma + addr_offset, info);
1565               info->fprintf_func = (fprintf_ftype) fprintf;
1566               info->stream = stdout;
1567               if (info->bytes_per_line != 0)
1568                 octets_per_line = info->bytes_per_line;
1569               if (octets < 0)
1570                 {
1571                   if (sfile.pos)
1572                     printf ("%s\n", sfile.buffer);
1573                   break;
1574                 }
1575             }
1576           else
1577             {
1578               bfd_vma j;
1579
1580               octets = octets_per_line;
1581               if (addr_offset + octets / opb > stop_offset)
1582                 octets = (stop_offset - addr_offset) * opb;
1583
1584               for (j = addr_offset * opb; j < addr_offset * opb + octets; ++j)
1585                 {
1586                   if (ISPRINT (data[j]))
1587                     buf[j - addr_offset * opb] = data[j];
1588                   else
1589                     buf[j - addr_offset * opb] = '.';
1590                 }
1591               buf[j - addr_offset * opb] = '\0';
1592             }
1593
1594           if (prefix_addresses
1595               ? show_raw_insn > 0
1596               : show_raw_insn >= 0)
1597             {
1598               bfd_vma j;
1599
1600               /* If ! prefix_addresses and ! wide_output, we print
1601                  octets_per_line octets per line.  */
1602               pb = octets;
1603               if (pb > octets_per_line && ! prefix_addresses && ! wide_output)
1604                 pb = octets_per_line;
1605
1606               if (info->bytes_per_chunk)
1607                 bpc = info->bytes_per_chunk;
1608               else
1609                 bpc = 1;
1610
1611               for (j = addr_offset * opb; j < addr_offset * opb + pb; j += bpc)
1612                 {
1613                   int k;
1614
1615                   if (bpc > 1 && info->display_endian == BFD_ENDIAN_LITTLE)
1616                     {
1617                       for (k = bpc - 1; k >= 0; k--)
1618                         printf ("%02x", (unsigned) data[j + k]);
1619                       putchar (' ');
1620                     }
1621                   else
1622                     {
1623                       for (k = 0; k < bpc; k++)
1624                         printf ("%02x", (unsigned) data[j + k]);
1625                       putchar (' ');
1626                     }
1627                 }
1628
1629               for (; pb < octets_per_line; pb += bpc)
1630                 {
1631                   int k;
1632
1633                   for (k = 0; k < bpc; k++)
1634                     printf ("  ");
1635                   putchar (' ');
1636                 }
1637
1638               /* Separate raw data from instruction by extra space.  */
1639               if (insns)
1640                 putchar ('\t');
1641               else
1642                 printf ("    ");
1643             }
1644
1645           if (! insns)
1646             printf ("%s", buf);
1647           else if (sfile.pos)
1648             printf ("%s", sfile.buffer);
1649
1650           if (prefix_addresses
1651               ? show_raw_insn > 0
1652               : show_raw_insn >= 0)
1653             {
1654               while (pb < octets)
1655                 {
1656                   bfd_vma j;
1657                   char *s;
1658
1659                   putchar ('\n');
1660                   j = addr_offset * opb + pb;
1661
1662                   bfd_sprintf_vma (aux->abfd, buf, section->vma + j / opb);
1663                   for (s = buf + skip_addr_chars; *s == '0'; s++)
1664                     *s = ' ';
1665                   if (*s == '\0')
1666                     *--s = '0';
1667                   printf ("%s:\t", buf + skip_addr_chars);
1668
1669                   pb += octets_per_line;
1670                   if (pb > octets)
1671                     pb = octets;
1672                   for (; j < addr_offset * opb + pb; j += bpc)
1673                     {
1674                       int k;
1675
1676                       if (bpc > 1 && info->display_endian == BFD_ENDIAN_LITTLE)
1677                         {
1678                           for (k = bpc - 1; k >= 0; k--)
1679                             printf ("%02x", (unsigned) data[j + k]);
1680                           putchar (' ');
1681                         }
1682                       else
1683                         {
1684                           for (k = 0; k < bpc; k++)
1685                             printf ("%02x", (unsigned) data[j + k]);
1686                           putchar (' ');
1687                         }
1688                     }
1689                 }
1690             }
1691
1692           if (!wide_output)
1693             putchar ('\n');
1694           else
1695             need_nl = TRUE;
1696         }
1697
1698       while ((*relppp) < relppend
1699              && (**relppp)->address < rel_offset + addr_offset + octets / opb)
1700         {
1701           if (dump_reloc_info || dump_dynamic_reloc_info)
1702             {
1703               arelent *q;
1704
1705               q = **relppp;
1706
1707               if (wide_output)
1708                 putchar ('\t');
1709               else
1710                 printf ("\t\t\t");
1711
1712               objdump_print_value (section->vma - rel_offset + q->address,
1713                                    info, TRUE);
1714
1715               if (q->howto == NULL)
1716                 printf (": *unknown*\t");
1717               else if (q->howto->name)
1718                 printf (": %s\t", q->howto->name);
1719               else
1720                 printf (": %d\t", q->howto->type);
1721
1722               if (q->sym_ptr_ptr == NULL || *q->sym_ptr_ptr == NULL)
1723                 printf ("*unknown*");
1724               else
1725                 {
1726                   const char *sym_name;
1727
1728                   sym_name = bfd_asymbol_name (*q->sym_ptr_ptr);
1729                   if (sym_name != NULL && *sym_name != '\0')
1730                     objdump_print_symname (aux->abfd, info, *q->sym_ptr_ptr);
1731                   else
1732                     {
1733                       asection *sym_sec;
1734
1735                       sym_sec = bfd_get_section (*q->sym_ptr_ptr);
1736                       sym_name = bfd_get_section_name (aux->abfd, sym_sec);
1737                       if (sym_name == NULL || *sym_name == '\0')
1738                         sym_name = "*unknown*";
1739                       printf ("%s", sym_name);
1740                     }
1741                 }
1742
1743               if (q->addend)
1744                 {
1745                   printf ("+0x");
1746                   objdump_print_value (q->addend, info, TRUE);
1747                 }
1748
1749               printf ("\n");
1750               need_nl = FALSE;
1751             }
1752           ++(*relppp);
1753         }
1754
1755       if (need_nl)
1756         printf ("\n");
1757
1758       addr_offset += octets / opb;
1759     }
1760
1761   free (sfile.buffer);
1762 }
1763
1764 static void
1765 disassemble_section (bfd *abfd, asection *section, void *info)
1766 {
1767   const struct elf_backend_data * bed;
1768   bfd_vma                      sign_adjust = 0;
1769   struct disassemble_info *    pinfo = (struct disassemble_info *) info;
1770   struct objdump_disasm_info * paux;
1771   unsigned int                 opb = pinfo->octets_per_byte;
1772   bfd_byte *                   data = NULL;
1773   bfd_size_type                datasize = 0;
1774   arelent **                   rel_pp = NULL;
1775   arelent **                   rel_ppstart = NULL;
1776   arelent **                   rel_ppend;
1777   unsigned long                stop_offset;
1778   asymbol *                    sym = NULL;
1779   long                         place = 0;
1780   long                         rel_count;
1781   bfd_vma                      rel_offset;
1782   unsigned long                addr_offset;
1783
1784   /* Sections that do not contain machine
1785      code are not normally disassembled.  */
1786   if (! disassemble_all
1787       && only == NULL
1788       && ((section->flags & (SEC_CODE | SEC_HAS_CONTENTS))
1789           != (SEC_CODE | SEC_HAS_CONTENTS)))
1790     return;
1791
1792   if (! process_section_p (section))
1793     return;
1794
1795   datasize = bfd_get_section_size (section);
1796   if (datasize == 0)
1797     return;
1798
1799   /* Decide which set of relocs to use.  Load them if necessary.  */
1800   paux = (struct objdump_disasm_info *) pinfo->application_data;
1801   if (paux->dynrelbuf)
1802     {
1803       rel_pp = paux->dynrelbuf;
1804       rel_count = paux->dynrelcount;
1805       /* Dynamic reloc addresses are absolute, non-dynamic are section
1806          relative.  REL_OFFSET specifies the reloc address corresponding
1807          to the start of this section.  */
1808       rel_offset = section->vma;
1809     }
1810   else
1811     {
1812       rel_count = 0;
1813       rel_pp = NULL;
1814       rel_offset = 0;
1815
1816       if ((section->flags & SEC_RELOC) != 0
1817           && (dump_reloc_info || pinfo->disassembler_needs_relocs))
1818         {
1819           long relsize;
1820
1821           relsize = bfd_get_reloc_upper_bound (abfd, section);
1822           if (relsize < 0)
1823             bfd_fatal (bfd_get_filename (abfd));
1824
1825           if (relsize > 0)
1826             {
1827               rel_ppstart = rel_pp = xmalloc (relsize);
1828               rel_count = bfd_canonicalize_reloc (abfd, section, rel_pp, syms);
1829               if (rel_count < 0)
1830                 bfd_fatal (bfd_get_filename (abfd));
1831
1832               /* Sort the relocs by address.  */
1833               qsort (rel_pp, rel_count, sizeof (arelent *), compare_relocs);
1834             }
1835         }
1836     }
1837   rel_ppend = rel_pp + rel_count;
1838
1839   data = xmalloc (datasize);
1840
1841   bfd_get_section_contents (abfd, section, data, 0, datasize);
1842
1843   paux->sec = section;
1844   pinfo->buffer = data;
1845   pinfo->buffer_vma = section->vma;
1846   pinfo->buffer_length = datasize;
1847   pinfo->section = section;
1848
1849   if (start_address == (bfd_vma) -1
1850       || start_address < pinfo->buffer_vma)
1851     addr_offset = 0;
1852   else
1853     addr_offset = start_address - pinfo->buffer_vma;
1854
1855   if (stop_address == (bfd_vma) -1)
1856     stop_offset = datasize / opb;
1857   else
1858     {
1859       if (stop_address < pinfo->buffer_vma)
1860         stop_offset = 0;
1861       else
1862         stop_offset = stop_address - pinfo->buffer_vma;
1863       if (stop_offset > pinfo->buffer_length / opb)
1864         stop_offset = pinfo->buffer_length / opb;
1865     }
1866
1867   /* Skip over the relocs belonging to addresses below the
1868      start address.  */
1869   while (rel_pp < rel_ppend
1870          && (*rel_pp)->address < rel_offset + addr_offset)
1871     ++rel_pp;
1872
1873   if (addr_offset < stop_offset)
1874     printf (_("\nDisassembly of section %s:\n"), section->name);
1875
1876   /* Find the nearest symbol forwards from our current position.  */
1877   paux->require_sec = TRUE;
1878   sym = find_symbol_for_address (section->vma + addr_offset, info, &place);
1879   paux->require_sec = FALSE;
1880
1881   /* PR 9774: If the target used signed 32-bit addresses then we must make
1882      sure that we sign extend the value that we calculate for 'addr' in the
1883      loop below.  */
1884   if (bfd_get_flavour (abfd) == bfd_target_elf_flavour
1885       && (bed = get_elf_backend_data (abfd)) != NULL
1886       && bed->sign_extend_vma)
1887     sign_adjust = 0x80000000;
1888
1889   /* Disassemble a block of instructions up to the address associated with
1890      the symbol we have just found.  Then print the symbol and find the
1891      next symbol on.  Repeat until we have disassembled the entire section
1892      or we have reached the end of the address range we are interested in.  */
1893   while (addr_offset < stop_offset)
1894     {
1895       bfd_vma addr;
1896       asymbol *nextsym;
1897       unsigned long nextstop_offset;
1898       bfd_boolean insns;
1899
1900       addr = section->vma + addr_offset;
1901       addr = ((addr & ((sign_adjust << 1) - 1)) ^ sign_adjust) - sign_adjust;
1902
1903       if (sym != NULL && bfd_asymbol_value (sym) <= addr)
1904         {
1905           int x;
1906
1907           for (x = place;
1908                (x < sorted_symcount
1909                 && (bfd_asymbol_value (sorted_syms[x]) <= addr));
1910                ++x)
1911             continue;
1912
1913           pinfo->symbols = sorted_syms + place;
1914           pinfo->num_symbols = x - place;
1915           pinfo->symtab_pos = place;
1916         }
1917       else
1918         {
1919           pinfo->symbols = NULL;
1920           pinfo->num_symbols = 0;
1921           pinfo->symtab_pos = -1;
1922         }
1923
1924       if (! prefix_addresses)
1925         {
1926           pinfo->fprintf_func (pinfo->stream, "\n");
1927           objdump_print_addr_with_sym (abfd, section, sym, addr,
1928                                        pinfo, FALSE);
1929           pinfo->fprintf_func (pinfo->stream, ":\n");
1930         }
1931
1932       if (sym != NULL && bfd_asymbol_value (sym) > addr)
1933         nextsym = sym;
1934       else if (sym == NULL)
1935         nextsym = NULL;
1936       else
1937         {
1938 #define is_valid_next_sym(SYM) \
1939   ((SYM)->section == section \
1940    && (bfd_asymbol_value (SYM) > bfd_asymbol_value (sym)) \
1941    && pinfo->symbol_is_valid (SYM, pinfo))
1942
1943           /* Search forward for the next appropriate symbol in
1944              SECTION.  Note that all the symbols are sorted
1945              together into one big array, and that some sections
1946              may have overlapping addresses.  */
1947           while (place < sorted_symcount
1948                  && ! is_valid_next_sym (sorted_syms [place]))
1949             ++place;
1950
1951           if (place >= sorted_symcount)
1952             nextsym = NULL;
1953           else
1954             nextsym = sorted_syms[place];
1955         }
1956
1957       if (sym != NULL && bfd_asymbol_value (sym) > addr)
1958         nextstop_offset = bfd_asymbol_value (sym) - section->vma;
1959       else if (nextsym == NULL)
1960         nextstop_offset = stop_offset;
1961       else
1962         nextstop_offset = bfd_asymbol_value (nextsym) - section->vma;
1963
1964       if (nextstop_offset > stop_offset
1965           || nextstop_offset <= addr_offset)
1966         nextstop_offset = stop_offset;
1967
1968       /* If a symbol is explicitly marked as being an object
1969          rather than a function, just dump the bytes without
1970          disassembling them.  */
1971       if (disassemble_all
1972           || sym == NULL
1973           || sym->section != section
1974           || bfd_asymbol_value (sym) > addr
1975           || ((sym->flags & BSF_OBJECT) == 0
1976               && (strstr (bfd_asymbol_name (sym), "gnu_compiled")
1977                   == NULL)
1978               && (strstr (bfd_asymbol_name (sym), "gcc2_compiled")
1979                   == NULL))
1980           || (sym->flags & BSF_FUNCTION) != 0)
1981         insns = TRUE;
1982       else
1983         insns = FALSE;
1984
1985       disassemble_bytes (pinfo, paux->disassemble_fn, insns, data,
1986                          addr_offset, nextstop_offset,
1987                          rel_offset, &rel_pp, rel_ppend);
1988
1989       addr_offset = nextstop_offset;
1990       sym = nextsym;
1991     }
1992
1993   free (data);
1994
1995   if (rel_ppstart != NULL)
1996     free (rel_ppstart);
1997 }
1998
1999 /* Disassemble the contents of an object file.  */
2000
2001 static void
2002 disassemble_data (bfd *abfd)
2003 {
2004   struct disassemble_info disasm_info;
2005   struct objdump_disasm_info aux;
2006   long i;
2007
2008   print_files = NULL;
2009   prev_functionname = NULL;
2010   prev_line = -1;
2011
2012   /* We make a copy of syms to sort.  We don't want to sort syms
2013      because that will screw up the relocs.  */
2014   sorted_symcount = symcount ? symcount : dynsymcount;
2015   sorted_syms = xmalloc ((sorted_symcount + synthcount) * sizeof (asymbol *));
2016   memcpy (sorted_syms, symcount ? syms : dynsyms,
2017           sorted_symcount * sizeof (asymbol *));
2018
2019   sorted_symcount = remove_useless_symbols (sorted_syms, sorted_symcount);
2020
2021   for (i = 0; i < synthcount; ++i)
2022     {
2023       sorted_syms[sorted_symcount] = synthsyms + i;
2024       ++sorted_symcount;
2025     }
2026
2027   /* Sort the symbols into section and symbol order.  */
2028   qsort (sorted_syms, sorted_symcount, sizeof (asymbol *), compare_symbols);
2029
2030   init_disassemble_info (&disasm_info, stdout, (fprintf_ftype) fprintf);
2031
2032   disasm_info.application_data = (void *) &aux;
2033   aux.abfd = abfd;
2034   aux.require_sec = FALSE;
2035   aux.dynrelbuf = NULL;
2036   aux.dynrelcount = 0;
2037   aux.reloc = NULL;
2038
2039   disasm_info.print_address_func = objdump_print_address;
2040   disasm_info.symbol_at_address_func = objdump_symbol_at_address;
2041
2042   if (machine != NULL)
2043     {
2044       const bfd_arch_info_type *info = bfd_scan_arch (machine);
2045
2046       if (info == NULL)
2047         fatal (_("Can't use supplied machine %s"), machine);
2048
2049       abfd->arch_info = info;
2050     }
2051
2052   if (endian != BFD_ENDIAN_UNKNOWN)
2053     {
2054       struct bfd_target *xvec;
2055
2056       xvec = xmalloc (sizeof (struct bfd_target));
2057       memcpy (xvec, abfd->xvec, sizeof (struct bfd_target));
2058       xvec->byteorder = endian;
2059       abfd->xvec = xvec;
2060     }
2061
2062   /* Use libopcodes to locate a suitable disassembler.  */
2063   aux.disassemble_fn = disassembler (abfd);
2064   if (!aux.disassemble_fn)
2065     {
2066       non_fatal (_("Can't disassemble for architecture %s\n"),
2067                  bfd_printable_arch_mach (bfd_get_arch (abfd), 0));
2068       exit_status = 1;
2069       return;
2070     }
2071
2072   disasm_info.flavour = bfd_get_flavour (abfd);
2073   disasm_info.arch = bfd_get_arch (abfd);
2074   disasm_info.mach = bfd_get_mach (abfd);
2075   disasm_info.disassembler_options = disassembler_options;
2076   disasm_info.octets_per_byte = bfd_octets_per_byte (abfd);
2077   disasm_info.skip_zeroes = DEFAULT_SKIP_ZEROES;
2078   disasm_info.skip_zeroes_at_end = DEFAULT_SKIP_ZEROES_AT_END;
2079   disasm_info.disassembler_needs_relocs = FALSE;
2080
2081   if (bfd_big_endian (abfd))
2082     disasm_info.display_endian = disasm_info.endian = BFD_ENDIAN_BIG;
2083   else if (bfd_little_endian (abfd))
2084     disasm_info.display_endian = disasm_info.endian = BFD_ENDIAN_LITTLE;
2085   else
2086     /* ??? Aborting here seems too drastic.  We could default to big or little
2087        instead.  */
2088     disasm_info.endian = BFD_ENDIAN_UNKNOWN;
2089
2090   /* Allow the target to customize the info structure.  */
2091   disassemble_init_for_target (& disasm_info);
2092
2093   /* Pre-load the dynamic relocs if we are going
2094      to be dumping them along with the disassembly.  */
2095   if (dump_dynamic_reloc_info)
2096     {
2097       long relsize = bfd_get_dynamic_reloc_upper_bound (abfd);
2098
2099       if (relsize < 0)
2100         bfd_fatal (bfd_get_filename (abfd));
2101
2102       if (relsize > 0)
2103         {
2104           aux.dynrelbuf = xmalloc (relsize);
2105           aux.dynrelcount = bfd_canonicalize_dynamic_reloc (abfd,
2106                                                             aux.dynrelbuf,
2107                                                             dynsyms);
2108           if (aux.dynrelcount < 0)
2109             bfd_fatal (bfd_get_filename (abfd));
2110
2111           /* Sort the relocs by address.  */
2112           qsort (aux.dynrelbuf, aux.dynrelcount, sizeof (arelent *),
2113                  compare_relocs);
2114         }
2115     }
2116   disasm_info.symtab = sorted_syms;
2117   disasm_info.symtab_size = sorted_symcount;
2118
2119   bfd_map_over_sections (abfd, disassemble_section, & disasm_info);
2120
2121   if (aux.dynrelbuf != NULL)
2122     free (aux.dynrelbuf);
2123   free (sorted_syms);
2124 }
2125 \f
2126 static int
2127 load_specific_debug_section (enum dwarf_section_display_enum debug,
2128                              asection *sec, void *file)
2129 {
2130   struct dwarf_section *section = &debug_displays [debug].section;
2131   bfd *abfd = file;
2132   bfd_boolean ret;
2133   int section_is_compressed;
2134
2135   /* If it is already loaded, do nothing.  */
2136   if (section->start != NULL)
2137     return 1;
2138
2139   section_is_compressed = section->name == section->compressed_name;
2140
2141   section->address = 0;
2142   section->size = bfd_get_section_size (sec);
2143   section->start = xmalloc (section->size);
2144
2145   if (is_relocatable && debug_displays [debug].relocate)
2146     ret = bfd_simple_get_relocated_section_contents (abfd,
2147                                                      sec,
2148                                                      section->start,
2149                                                      syms) != NULL;
2150   else
2151     ret = bfd_get_section_contents (abfd, sec, section->start, 0,
2152                                     section->size);
2153
2154   if (! ret)
2155     {
2156       free_debug_section (debug);
2157       printf (_("\nCan't get contents for section '%s'.\n"),
2158               section->name);
2159       return 0;
2160     }
2161
2162   if (section_is_compressed)
2163     {
2164       bfd_size_type size = section->size;
2165       if (! bfd_uncompress_section_contents (&section->start, &size))
2166         {
2167           free_debug_section (debug);
2168           printf (_("\nCan't uncompress section '%s'.\n"), section->name);
2169           return 0;
2170         }
2171       section->size = size;
2172     }
2173
2174   return 1;
2175 }
2176
2177 int
2178 load_debug_section (enum dwarf_section_display_enum debug, void *file)
2179 {
2180   struct dwarf_section *section = &debug_displays [debug].section;
2181   bfd *abfd = file;
2182   asection *sec;
2183
2184   /* If it is already loaded, do nothing.  */
2185   if (section->start != NULL)
2186     return 1;
2187
2188   /* Locate the debug section.  */
2189   sec = bfd_get_section_by_name (abfd, section->uncompressed_name);
2190   if (sec != NULL)
2191     section->name = section->uncompressed_name;
2192   else
2193     {
2194       sec = bfd_get_section_by_name (abfd, section->compressed_name);
2195       if (sec != NULL)
2196         section->name = section->compressed_name;
2197     }
2198   if (sec == NULL)
2199     return 0;
2200
2201   return load_specific_debug_section (debug, sec, file);
2202 }
2203
2204 void
2205 free_debug_section (enum dwarf_section_display_enum debug)
2206 {
2207   struct dwarf_section *section = &debug_displays [debug].section;
2208
2209   if (section->start == NULL)
2210     return;
2211
2212   free ((char *) section->start);
2213   section->start = NULL;
2214   section->address = 0;
2215   section->size = 0;
2216 }
2217
2218 static void
2219 dump_dwarf_section (bfd *abfd, asection *section,
2220                     void *arg ATTRIBUTE_UNUSED)
2221 {
2222   const char *name = bfd_get_section_name (abfd, section);
2223   const char *match;
2224   enum dwarf_section_display_enum i;
2225
2226   if (CONST_STRNEQ (name, ".gnu.linkonce.wi."))
2227     match = ".debug_info";
2228   else
2229     match = name;
2230
2231   for (i = 0; i < max; i++)
2232     if ((strcmp (debug_displays [i].section.uncompressed_name, match) == 0
2233          || strcmp (debug_displays [i].section.compressed_name, match) == 0)
2234         && debug_displays [i].enabled != NULL
2235         && *debug_displays [i].enabled)
2236       {
2237         if (!debug_displays [i].eh_frame)
2238           {
2239             struct dwarf_section *sec = &debug_displays [i].section;
2240
2241             if (strcmp (sec->uncompressed_name, match) == 0)
2242               sec->name = sec->uncompressed_name;
2243             else
2244               sec->name = sec->compressed_name;
2245             if (load_specific_debug_section (i, section, abfd))
2246               {
2247                 debug_displays [i].display (sec, abfd);
2248
2249                 if (i != info && i != abbrev)
2250                   free_debug_section (i);
2251               }
2252           }
2253         break;
2254       }
2255 }
2256
2257 /* Dump the dwarf debugging information.  */
2258
2259 static void
2260 dump_dwarf (bfd *abfd)
2261 {
2262   is_relocatable = (abfd->flags & (EXEC_P | DYNAMIC)) == 0;
2263
2264   /* FIXME: bfd_get_arch_size may return -1.  We assume that 64bit
2265      targets will return 64.  */
2266   eh_addr_size = bfd_get_arch_size (abfd) == 64 ? 8 : 4;
2267
2268   if (bfd_big_endian (abfd))
2269     byte_get = byte_get_big_endian;
2270   else if (bfd_little_endian (abfd))
2271     byte_get = byte_get_little_endian;
2272   else
2273     abort ();
2274
2275   if (bfd_get_flavour (abfd) == bfd_target_elf_flavour)
2276     {
2277       const struct elf_backend_data *bed = get_elf_backend_data (abfd);
2278       init_dwarf_regnames (bed->elf_machine_code);
2279     }
2280
2281   bfd_map_over_sections (abfd, dump_dwarf_section, NULL);
2282
2283   free_debug_memory ();
2284 }
2285 \f
2286 /* Read ABFD's stabs section STABSECT_NAME, and return a pointer to
2287    it.  Return NULL on failure.   */
2288
2289 static char *
2290 read_section_stabs (bfd *abfd, const char *sect_name, bfd_size_type *size_ptr)
2291 {
2292   asection *stabsect;
2293   bfd_size_type size;
2294   char *contents;
2295
2296   stabsect = bfd_get_section_by_name (abfd, sect_name);
2297   if (stabsect == NULL)
2298     {
2299       printf (_("No %s section present\n\n"), sect_name);
2300       return FALSE;
2301     }
2302
2303   size = bfd_section_size (abfd, stabsect);
2304   contents  = xmalloc (size);
2305
2306   if (! bfd_get_section_contents (abfd, stabsect, contents, 0, size))
2307     {
2308       non_fatal (_("Reading %s section of %s failed: %s"),
2309                  sect_name, bfd_get_filename (abfd),
2310                  bfd_errmsg (bfd_get_error ()));
2311       free (contents);
2312       exit_status = 1;
2313       return NULL;
2314     }
2315
2316   *size_ptr = size;
2317
2318   return contents;
2319 }
2320
2321 /* Stabs entries use a 12 byte format:
2322      4 byte string table index
2323      1 byte stab type
2324      1 byte stab other field
2325      2 byte stab desc field
2326      4 byte stab value
2327    FIXME: This will have to change for a 64 bit object format.  */
2328
2329 #define STRDXOFF  (0)
2330 #define TYPEOFF   (4)
2331 #define OTHEROFF  (5)
2332 #define DESCOFF   (6)
2333 #define VALOFF    (8)
2334 #define STABSIZE (12)
2335
2336 /* Print ABFD's stabs section STABSECT_NAME (in `stabs'),
2337    using string table section STRSECT_NAME (in `strtab').  */
2338
2339 static void
2340 print_section_stabs (bfd *abfd,
2341                      const char *stabsect_name,
2342                      unsigned *string_offset_ptr)
2343 {
2344   int i;
2345   unsigned file_string_table_offset = 0;
2346   unsigned next_file_string_table_offset = *string_offset_ptr;
2347   bfd_byte *stabp, *stabs_end;
2348
2349   stabp = stabs;
2350   stabs_end = stabp + stab_size;
2351
2352   printf (_("Contents of %s section:\n\n"), stabsect_name);
2353   printf ("Symnum n_type n_othr n_desc n_value  n_strx String\n");
2354
2355   /* Loop through all symbols and print them.
2356
2357      We start the index at -1 because there is a dummy symbol on
2358      the front of stabs-in-{coff,elf} sections that supplies sizes.  */
2359   for (i = -1; stabp < stabs_end; stabp += STABSIZE, i++)
2360     {
2361       const char *name;
2362       unsigned long strx;
2363       unsigned char type, other;
2364       unsigned short desc;
2365       bfd_vma value;
2366
2367       strx = bfd_h_get_32 (abfd, stabp + STRDXOFF);
2368       type = bfd_h_get_8 (abfd, stabp + TYPEOFF);
2369       other = bfd_h_get_8 (abfd, stabp + OTHEROFF);
2370       desc = bfd_h_get_16 (abfd, stabp + DESCOFF);
2371       value = bfd_h_get_32 (abfd, stabp + VALOFF);
2372
2373       printf ("\n%-6d ", i);
2374       /* Either print the stab name, or, if unnamed, print its number
2375          again (makes consistent formatting for tools like awk).  */
2376       name = bfd_get_stab_name (type);
2377       if (name != NULL)
2378         printf ("%-6s", name);
2379       else if (type == N_UNDF)
2380         printf ("HdrSym");
2381       else
2382         printf ("%-6d", type);
2383       printf (" %-6d %-6d ", other, desc);
2384       bfd_printf_vma (abfd, value);
2385       printf (" %-6lu", strx);
2386
2387       /* Symbols with type == 0 (N_UNDF) specify the length of the
2388          string table associated with this file.  We use that info
2389          to know how to relocate the *next* file's string table indices.  */
2390       if (type == N_UNDF)
2391         {
2392           file_string_table_offset = next_file_string_table_offset;
2393           next_file_string_table_offset += value;
2394         }
2395       else
2396         {
2397           /* Using the (possibly updated) string table offset, print the
2398              string (if any) associated with this symbol.  */
2399           if ((strx + file_string_table_offset) < stabstr_size)
2400             printf (" %s", &strtab[strx + file_string_table_offset]);
2401           else
2402             printf (" *");
2403         }
2404     }
2405   printf ("\n\n");
2406   *string_offset_ptr = next_file_string_table_offset;
2407 }
2408
2409 typedef struct
2410 {
2411   const char * section_name;
2412   const char * string_section_name;
2413   unsigned string_offset;
2414 }
2415 stab_section_names;
2416
2417 static void
2418 find_stabs_section (bfd *abfd, asection *section, void *names)
2419 {
2420   int len;
2421   stab_section_names * sought = (stab_section_names *) names;
2422
2423   /* Check for section names for which stabsect_name is a prefix, to
2424      handle .stab.N, etc.  */
2425   len = strlen (sought->section_name);
2426
2427   /* If the prefix matches, and the files section name ends with a
2428      nul or a digit, then we match.  I.e., we want either an exact
2429      match or a section followed by a number.  */
2430   if (strncmp (sought->section_name, section->name, len) == 0
2431       && (section->name[len] == 0
2432           || (section->name[len] == '.' && ISDIGIT (section->name[len + 1]))))
2433     {
2434       if (strtab == NULL)
2435         strtab = read_section_stabs (abfd, sought->string_section_name,
2436                                      &stabstr_size);
2437
2438       if (strtab)
2439         {
2440           stabs = (bfd_byte *) read_section_stabs (abfd, section->name,
2441                                                    &stab_size);
2442           if (stabs)
2443             print_section_stabs (abfd, section->name, &sought->string_offset);
2444         }
2445     }
2446 }
2447
2448 static void
2449 dump_stabs_section (bfd *abfd, char *stabsect_name, char *strsect_name)
2450 {
2451   stab_section_names s;
2452
2453   s.section_name = stabsect_name;
2454   s.string_section_name = strsect_name;
2455   s.string_offset = 0;
2456
2457   bfd_map_over_sections (abfd, find_stabs_section, & s);
2458
2459   free (strtab);
2460   strtab = NULL;
2461 }
2462
2463 /* Dump the any sections containing stabs debugging information.  */
2464
2465 static void
2466 dump_stabs (bfd *abfd)
2467 {
2468   dump_stabs_section (abfd, ".stab", ".stabstr");
2469   dump_stabs_section (abfd, ".stab.excl", ".stab.exclstr");
2470   dump_stabs_section (abfd, ".stab.index", ".stab.indexstr");
2471
2472   /* For Darwin.  */
2473   dump_stabs_section (abfd, "LC_SYMTAB.stabs", "LC_SYMTAB.stabstr");
2474
2475   dump_stabs_section (abfd, "$GDB_SYMBOLS$", "$GDB_STRINGS$");
2476 }
2477 \f
2478 static void
2479 dump_bfd_header (bfd *abfd)
2480 {
2481   char *comma = "";
2482
2483   printf (_("architecture: %s, "),
2484           bfd_printable_arch_mach (bfd_get_arch (abfd),
2485                                    bfd_get_mach (abfd)));
2486   printf (_("flags 0x%08x:\n"), abfd->flags);
2487
2488 #define PF(x, y)    if (abfd->flags & x) {printf("%s%s", comma, y); comma=", ";}
2489   PF (HAS_RELOC, "HAS_RELOC");
2490   PF (EXEC_P, "EXEC_P");
2491   PF (HAS_LINENO, "HAS_LINENO");
2492   PF (HAS_DEBUG, "HAS_DEBUG");
2493   PF (HAS_SYMS, "HAS_SYMS");
2494   PF (HAS_LOCALS, "HAS_LOCALS");
2495   PF (DYNAMIC, "DYNAMIC");
2496   PF (WP_TEXT, "WP_TEXT");
2497   PF (D_PAGED, "D_PAGED");
2498   PF (BFD_IS_RELAXABLE, "BFD_IS_RELAXABLE");
2499   PF (HAS_LOAD_PAGE, "HAS_LOAD_PAGE");
2500   printf (_("\nstart address 0x"));
2501   bfd_printf_vma (abfd, abfd->start_address);
2502   printf ("\n");
2503 }
2504
2505 \f
2506 static void
2507 dump_bfd_private_header (bfd *abfd)
2508 {
2509   bfd_print_private_bfd_data (abfd, stdout);
2510 }
2511
2512 \f
2513 /* Display a section in hexadecimal format with associated characters.
2514    Each line prefixed by the zero padded address.  */
2515
2516 static void
2517 dump_section (bfd *abfd, asection *section, void *dummy ATTRIBUTE_UNUSED)
2518 {
2519   bfd_byte *data = 0;
2520   bfd_size_type datasize;
2521   bfd_size_type addr_offset;
2522   bfd_size_type start_offset;
2523   bfd_size_type stop_offset;
2524   unsigned int opb = bfd_octets_per_byte (abfd);
2525   /* Bytes per line.  */
2526   const int onaline = 16;
2527   char buf[64];
2528   int count;
2529   int width;
2530
2531   if ((section->flags & SEC_HAS_CONTENTS) == 0)
2532     return;
2533
2534   if (! process_section_p (section))
2535     return;
2536
2537   if ((datasize = bfd_section_size (abfd, section)) == 0)
2538     return;
2539
2540   /* Compute the address range to display.  */
2541   if (start_address == (bfd_vma) -1
2542       || start_address < section->vma)
2543     start_offset = 0;
2544   else
2545     start_offset = start_address - section->vma;
2546
2547   if (stop_address == (bfd_vma) -1)
2548     stop_offset = datasize / opb;
2549   else
2550     {
2551       if (stop_address < section->vma)
2552         stop_offset = 0;
2553       else
2554         stop_offset = stop_address - section->vma;
2555
2556       if (stop_offset > datasize / opb)
2557         stop_offset = datasize / opb;
2558     }
2559
2560   if (start_offset >= stop_offset)
2561     return;
2562
2563   printf (_("Contents of section %s:"), section->name);
2564   if (display_file_offsets)
2565     printf (_("  (Starting at file offset: 0x%lx)"),
2566             (unsigned long) (section->filepos + start_offset));
2567   printf ("\n");
2568
2569   data = xmalloc (datasize);
2570
2571   bfd_get_section_contents (abfd, section, data, 0, datasize);
2572
2573   width = 4;
2574
2575   bfd_sprintf_vma (abfd, buf, start_offset + section->vma);
2576   if (strlen (buf) >= sizeof (buf))
2577     abort ();
2578
2579   count = 0;
2580   while (buf[count] == '0' && buf[count+1] != '\0')
2581     count++;
2582   count = strlen (buf) - count;
2583   if (count > width)
2584     width = count;
2585
2586   bfd_sprintf_vma (abfd, buf, stop_offset + section->vma - 1);
2587   if (strlen (buf) >= sizeof (buf))
2588     abort ();
2589
2590   count = 0;
2591   while (buf[count] == '0' && buf[count+1] != '\0')
2592     count++;
2593   count = strlen (buf) - count;
2594   if (count > width)
2595     width = count;
2596
2597   for (addr_offset = start_offset;
2598        addr_offset < stop_offset; addr_offset += onaline / opb)
2599     {
2600       bfd_size_type j;
2601
2602       bfd_sprintf_vma (abfd, buf, (addr_offset + section->vma));
2603       count = strlen (buf);
2604       if ((size_t) count >= sizeof (buf))
2605         abort ();
2606
2607       putchar (' ');
2608       while (count < width)
2609         {
2610           putchar ('0');
2611           count++;
2612         }
2613       fputs (buf + count - width, stdout);
2614       putchar (' ');
2615
2616       for (j = addr_offset * opb;
2617            j < addr_offset * opb + onaline; j++)
2618         {
2619           if (j < stop_offset * opb)
2620             printf ("%02x", (unsigned) (data[j]));
2621           else
2622             printf ("  ");
2623           if ((j & 3) == 3)
2624             printf (" ");
2625         }
2626
2627       printf (" ");
2628       for (j = addr_offset * opb;
2629            j < addr_offset * opb + onaline; j++)
2630         {
2631           if (j >= stop_offset * opb)
2632             printf (" ");
2633           else
2634             printf ("%c", ISPRINT (data[j]) ? data[j] : '.');
2635         }
2636       putchar ('\n');
2637     }
2638   free (data);
2639 }
2640
2641 /* Actually display the various requested regions.  */
2642
2643 static void
2644 dump_data (bfd *abfd)
2645 {
2646   bfd_map_over_sections (abfd, dump_section, NULL);
2647 }
2648
2649 /* Should perhaps share code and display with nm?  */
2650
2651 static void
2652 dump_symbols (bfd *abfd ATTRIBUTE_UNUSED, bfd_boolean dynamic)
2653 {
2654   asymbol **current;
2655   long max;
2656   long count;
2657
2658   if (dynamic)
2659     {
2660       current = dynsyms;
2661       max = dynsymcount;
2662       printf ("DYNAMIC SYMBOL TABLE:\n");
2663     }
2664   else
2665     {
2666       current = syms;
2667       max = symcount;
2668       printf ("SYMBOL TABLE:\n");
2669     }
2670
2671   if (max == 0)
2672     printf (_("no symbols\n"));
2673
2674   for (count = 0; count < max; count++)
2675     {
2676       bfd *cur_bfd;
2677
2678       if (*current == NULL)
2679         printf (_("no information for symbol number %ld\n"), count);
2680
2681       else if ((cur_bfd = bfd_asymbol_bfd (*current)) == NULL)
2682         printf (_("could not determine the type of symbol number %ld\n"),
2683                 count);
2684
2685       else if (process_section_p ((* current)->section)
2686                && (dump_special_syms
2687                    || !bfd_is_target_special_symbol (cur_bfd, *current)))
2688         {
2689           const char *name = (*current)->name;
2690
2691           if (do_demangle && name != NULL && *name != '\0')
2692             {
2693               char *alloc;
2694
2695               /* If we want to demangle the name, we demangle it
2696                  here, and temporarily clobber it while calling
2697                  bfd_print_symbol.  FIXME: This is a gross hack.  */
2698               alloc = bfd_demangle (cur_bfd, name, DMGL_ANSI | DMGL_PARAMS);
2699               if (alloc != NULL)
2700                 (*current)->name = alloc;
2701               bfd_print_symbol (cur_bfd, stdout, *current,
2702                                 bfd_print_symbol_all);
2703               if (alloc != NULL)
2704                 {
2705                   (*current)->name = name;
2706                   free (alloc);
2707                 }
2708             }
2709           else
2710             bfd_print_symbol (cur_bfd, stdout, *current,
2711                               bfd_print_symbol_all);
2712           printf ("\n");
2713         }
2714
2715       current++;
2716     }
2717   printf ("\n\n");
2718 }
2719 \f
2720 static void
2721 dump_reloc_set (bfd *abfd, asection *sec, arelent **relpp, long relcount)
2722 {
2723   arelent **p;
2724   char *last_filename, *last_functionname;
2725   unsigned int last_line;
2726
2727   /* Get column headers lined up reasonably.  */
2728   {
2729     static int width;
2730
2731     if (width == 0)
2732       {
2733         char buf[30];
2734
2735         bfd_sprintf_vma (abfd, buf, (bfd_vma) -1);
2736         width = strlen (buf) - 7;
2737       }
2738     printf ("OFFSET %*s TYPE %*s VALUE \n", width, "", 12, "");
2739   }
2740
2741   last_filename = NULL;
2742   last_functionname = NULL;
2743   last_line = 0;
2744
2745   for (p = relpp; relcount && *p != NULL; p++, relcount--)
2746     {
2747       arelent *q = *p;
2748       const char *filename, *functionname;
2749       unsigned int line;
2750       const char *sym_name;
2751       const char *section_name;
2752
2753       if (start_address != (bfd_vma) -1
2754           && q->address < start_address)
2755         continue;
2756       if (stop_address != (bfd_vma) -1
2757           && q->address > stop_address)
2758         continue;
2759
2760       if (with_line_numbers
2761           && sec != NULL
2762           && bfd_find_nearest_line (abfd, sec, syms, q->address,
2763                                     &filename, &functionname, &line))
2764         {
2765           if (functionname != NULL
2766               && (last_functionname == NULL
2767                   || strcmp (functionname, last_functionname) != 0))
2768             {
2769               printf ("%s():\n", functionname);
2770               if (last_functionname != NULL)
2771                 free (last_functionname);
2772               last_functionname = xstrdup (functionname);
2773             }
2774
2775           if (line > 0
2776               && (line != last_line
2777                   || (filename != NULL
2778                       && last_filename != NULL
2779                       && strcmp (filename, last_filename) != 0)))
2780             {
2781               printf ("%s:%u\n", filename == NULL ? "???" : filename, line);
2782               last_line = line;
2783               if (last_filename != NULL)
2784                 free (last_filename);
2785               if (filename == NULL)
2786                 last_filename = NULL;
2787               else
2788                 last_filename = xstrdup (filename);
2789             }
2790         }
2791
2792       if (q->sym_ptr_ptr && *q->sym_ptr_ptr)
2793         {
2794           sym_name = (*(q->sym_ptr_ptr))->name;
2795           section_name = (*(q->sym_ptr_ptr))->section->name;
2796         }
2797       else
2798         {
2799           sym_name = NULL;
2800           section_name = NULL;
2801         }
2802
2803       bfd_printf_vma (abfd, q->address);
2804       if (q->howto == NULL)
2805         printf (" *unknown*         ");
2806       else if (q->howto->name)
2807         printf (" %-16s  ", q->howto->name);
2808       else
2809         printf (" %-16d  ", q->howto->type);
2810
2811       if (sym_name)
2812         {
2813           objdump_print_symname (abfd, NULL, *q->sym_ptr_ptr);
2814         }
2815       else
2816         {
2817           if (section_name == NULL)
2818             section_name = "*unknown*";
2819           printf ("[%s]", section_name);
2820         }
2821
2822       if (q->addend)
2823         {
2824           printf ("+0x");
2825           bfd_printf_vma (abfd, q->addend);
2826         }
2827
2828       printf ("\n");
2829     }
2830 }
2831
2832 static void
2833 dump_relocs_in_section (bfd *abfd,
2834                         asection *section,
2835                         void *dummy ATTRIBUTE_UNUSED)
2836 {
2837   arelent **relpp;
2838   long relcount;
2839   long relsize;
2840
2841   if (   bfd_is_abs_section (section)
2842       || bfd_is_und_section (section)
2843       || bfd_is_com_section (section)
2844       || (! process_section_p (section))
2845       || ((section->flags & SEC_RELOC) == 0))
2846     return;
2847
2848   relsize = bfd_get_reloc_upper_bound (abfd, section);
2849   if (relsize < 0)
2850     bfd_fatal (bfd_get_filename (abfd));
2851
2852   printf ("RELOCATION RECORDS FOR [%s]:", section->name);
2853
2854   if (relsize == 0)
2855     {
2856       printf (" (none)\n\n");
2857       return;
2858     }
2859
2860   relpp = xmalloc (relsize);
2861   relcount = bfd_canonicalize_reloc (abfd, section, relpp, syms);
2862
2863   if (relcount < 0)
2864     bfd_fatal (bfd_get_filename (abfd));
2865   else if (relcount == 0)
2866     printf (" (none)\n\n");
2867   else
2868     {
2869       printf ("\n");
2870       dump_reloc_set (abfd, section, relpp, relcount);
2871       printf ("\n\n");
2872     }
2873   free (relpp);
2874 }
2875
2876 static void
2877 dump_relocs (bfd *abfd)
2878 {
2879   bfd_map_over_sections (abfd, dump_relocs_in_section, NULL);
2880 }
2881
2882 static void
2883 dump_dynamic_relocs (bfd *abfd)
2884 {
2885   long relsize;
2886   arelent **relpp;
2887   long relcount;
2888
2889   relsize = bfd_get_dynamic_reloc_upper_bound (abfd);
2890   if (relsize < 0)
2891     bfd_fatal (bfd_get_filename (abfd));
2892
2893   printf ("DYNAMIC RELOCATION RECORDS");
2894
2895   if (relsize == 0)
2896     printf (" (none)\n\n");
2897   else
2898     {
2899       relpp = xmalloc (relsize);
2900       relcount = bfd_canonicalize_dynamic_reloc (abfd, relpp, dynsyms);
2901
2902       if (relcount < 0)
2903         bfd_fatal (bfd_get_filename (abfd));
2904       else if (relcount == 0)
2905         printf (" (none)\n\n");
2906       else
2907         {
2908           printf ("\n");
2909           dump_reloc_set (abfd, NULL, relpp, relcount);
2910           printf ("\n\n");
2911         }
2912       free (relpp);
2913     }
2914 }
2915
2916 /* Creates a table of paths, to search for source files.  */
2917
2918 static void
2919 add_include_path (const char *path)
2920 {
2921   if (path[0] == 0)
2922     return;
2923   include_path_count++;
2924   include_paths = xrealloc (include_paths,
2925                             include_path_count * sizeof (*include_paths));
2926 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
2927   if (path[1] == ':' && path[2] == 0)
2928     path = concat (path, ".", (const char *) 0);
2929 #endif
2930   include_paths[include_path_count - 1] = path;
2931 }
2932
2933 static void
2934 adjust_addresses (bfd *abfd ATTRIBUTE_UNUSED,
2935                   asection *section,
2936                   void *arg)
2937 {
2938   if ((section->flags & SEC_DEBUGGING) == 0)
2939     {
2940       bfd_boolean *has_reloc_p = (bfd_boolean *) arg;
2941       section->vma += adjust_section_vma;
2942       if (*has_reloc_p)
2943         section->lma += adjust_section_vma;
2944     }
2945 }
2946
2947 /* Dump selected contents of ABFD.  */
2948
2949 static void
2950 dump_bfd (bfd *abfd)
2951 {
2952   /* If we are adjusting section VMA's, change them all now.  Changing
2953      the BFD information is a hack.  However, we must do it, or
2954      bfd_find_nearest_line will not do the right thing.  */
2955   if (adjust_section_vma != 0)
2956     {
2957       bfd_boolean has_reloc = (abfd->flags & HAS_RELOC);
2958       bfd_map_over_sections (abfd, adjust_addresses, &has_reloc);
2959     }
2960
2961   if (! dump_debugging_tags)
2962     printf (_("\n%s:     file format %s\n"), bfd_get_filename (abfd),
2963             abfd->xvec->name);
2964   if (dump_ar_hdrs)
2965     print_arelt_descr (stdout, abfd, TRUE);
2966   if (dump_file_header)
2967     dump_bfd_header (abfd);
2968   if (dump_private_headers)
2969     dump_bfd_private_header (abfd);
2970   if (! dump_debugging_tags)
2971     putchar ('\n');
2972   if (dump_section_headers)
2973     dump_headers (abfd);
2974
2975   if (dump_symtab
2976       || dump_reloc_info
2977       || disassemble
2978       || dump_debugging
2979       || dump_dwarf_section_info)
2980     syms = slurp_symtab (abfd);
2981   if (dump_dynamic_symtab || dump_dynamic_reloc_info
2982       || (disassemble && bfd_get_dynamic_symtab_upper_bound (abfd) > 0))
2983     dynsyms = slurp_dynamic_symtab (abfd);
2984   if (disassemble)
2985     {
2986       synthcount = bfd_get_synthetic_symtab (abfd, symcount, syms,
2987                                              dynsymcount, dynsyms, &synthsyms);
2988       if (synthcount < 0)
2989         synthcount = 0;
2990     }
2991
2992   if (dump_symtab)
2993     dump_symbols (abfd, FALSE);
2994   if (dump_dynamic_symtab)
2995     dump_symbols (abfd, TRUE);
2996   if (dump_dwarf_section_info)
2997     dump_dwarf (abfd);
2998   if (dump_stab_section_info)
2999     dump_stabs (abfd);
3000   if (dump_reloc_info && ! disassemble)
3001     dump_relocs (abfd);
3002   if (dump_dynamic_reloc_info && ! disassemble)
3003     dump_dynamic_relocs (abfd);
3004   if (dump_section_contents)
3005     dump_data (abfd);
3006   if (disassemble)
3007     disassemble_data (abfd);
3008
3009   if (dump_debugging)
3010     {
3011       void *dhandle;
3012
3013       dhandle = read_debugging_info (abfd, syms, symcount, TRUE);
3014       if (dhandle != NULL)
3015         {
3016           if (!print_debugging_info (stdout, dhandle, abfd, syms,
3017                                      bfd_demangle,
3018                                      dump_debugging_tags ? TRUE : FALSE))
3019             {
3020               non_fatal (_("%s: printing debugging information failed"),
3021                          bfd_get_filename (abfd));
3022               exit_status = 1;
3023             }
3024         }
3025       /* PR 6483: If there was no STABS or IEEE debug
3026          info in the file, try DWARF instead.  */
3027       else if (! dump_dwarf_section_info)
3028         {
3029           dump_dwarf (abfd);
3030         }
3031     }
3032
3033   if (syms)
3034     {
3035       free (syms);
3036       syms = NULL;
3037     }
3038
3039   if (dynsyms)
3040     {
3041       free (dynsyms);
3042       dynsyms = NULL;
3043     }
3044
3045   if (synthsyms)
3046     {
3047       free (synthsyms);
3048       synthsyms = NULL;
3049     }
3050
3051   symcount = 0;
3052   dynsymcount = 0;
3053   synthcount = 0;
3054 }
3055
3056 static void
3057 display_bfd (bfd *abfd)
3058 {
3059   char **matching;
3060
3061   if (bfd_check_format_matches (abfd, bfd_object, &matching))
3062     {
3063       dump_bfd (abfd);
3064       return;
3065     }
3066
3067   if (bfd_get_error () == bfd_error_file_ambiguously_recognized)
3068     {
3069       nonfatal (bfd_get_filename (abfd));
3070       list_matching_formats (matching);
3071       free (matching);
3072       return;
3073     }
3074
3075   if (bfd_get_error () != bfd_error_file_not_recognized)
3076     {
3077       nonfatal (bfd_get_filename (abfd));
3078       return;
3079     }
3080
3081   if (bfd_check_format_matches (abfd, bfd_core, &matching))
3082     {
3083       dump_bfd (abfd);
3084       return;
3085     }
3086
3087   nonfatal (bfd_get_filename (abfd));
3088
3089   if (bfd_get_error () == bfd_error_file_ambiguously_recognized)
3090     {
3091       list_matching_formats (matching);
3092       free (matching);
3093     }
3094 }
3095
3096 static void
3097 display_file (char *filename, char *target)
3098 {
3099   bfd *file;
3100   bfd *arfile = NULL;
3101
3102   if (get_file_size (filename) < 1)
3103     {
3104       exit_status = 1;
3105       return;
3106     }
3107
3108   file = bfd_openr (filename, target);
3109   if (file == NULL)
3110     {
3111       nonfatal (filename);
3112       return;
3113     }
3114
3115   /* If the file is an archive, process all of its elements.  */
3116   if (bfd_check_format (file, bfd_archive))
3117     {
3118       bfd *last_arfile = NULL;
3119
3120       printf (_("In archive %s:\n"), bfd_get_filename (file));
3121       for (;;)
3122         {
3123           bfd_set_error (bfd_error_no_error);
3124
3125           arfile = bfd_openr_next_archived_file (file, arfile);
3126           if (arfile == NULL)
3127             {
3128               if (bfd_get_error () != bfd_error_no_more_archived_files)
3129                 nonfatal (bfd_get_filename (file));
3130               break;
3131             }
3132
3133           display_bfd (arfile);
3134
3135           if (last_arfile != NULL)
3136             bfd_close (last_arfile);
3137           last_arfile = arfile;
3138         }
3139
3140       if (last_arfile != NULL)
3141         bfd_close (last_arfile);
3142     }
3143   else
3144     display_bfd (file);
3145
3146   bfd_close (file);
3147 }
3148 \f
3149 int
3150 main (int argc, char **argv)
3151 {
3152   int c;
3153   char *target = default_target;
3154   bfd_boolean seenflag = FALSE;
3155
3156 #if defined (HAVE_SETLOCALE)
3157 #if defined (HAVE_LC_MESSAGES)
3158   setlocale (LC_MESSAGES, "");
3159 #endif
3160   setlocale (LC_CTYPE, "");
3161 #endif
3162
3163   bindtextdomain (PACKAGE, LOCALEDIR);
3164   textdomain (PACKAGE);
3165
3166   program_name = *argv;
3167   xmalloc_set_program_name (program_name);
3168
3169   START_PROGRESS (program_name, 0);
3170
3171   expandargv (&argc, &argv);
3172
3173   bfd_init ();
3174   set_default_bfd_target ();
3175
3176   while ((c = getopt_long (argc, argv,
3177                            "pib:m:M:VvCdDlfFaHhrRtTxsSI:j:wE:zgeGW::",
3178                            long_options, (int *) 0))
3179          != EOF)
3180     {
3181       switch (c)
3182         {
3183         case 0:
3184           break;                /* We've been given a long option.  */
3185         case 'm':
3186           machine = optarg;
3187           break;
3188         case 'M':
3189           if (disassembler_options)
3190             /* Ignore potential memory leak for now.  */
3191             disassembler_options = concat (disassembler_options, ",",
3192                                            optarg, (const char *) NULL);
3193           else
3194             disassembler_options = optarg;
3195           break;
3196         case 'j':
3197           if (only_used == only_size)
3198             {
3199               only_size += 8;
3200               only = xrealloc (only, only_size * sizeof (char *));
3201             }
3202           only [only_used++] = optarg;
3203           break;
3204         case 'F':
3205           display_file_offsets = TRUE;
3206           break;
3207         case 'l':
3208           with_line_numbers = TRUE;
3209           break;
3210         case 'b':
3211           target = optarg;
3212           break;
3213         case 'C':
3214           do_demangle = TRUE;
3215           if (optarg != NULL)
3216             {
3217               enum demangling_styles style;
3218
3219               style = cplus_demangle_name_to_style (optarg);
3220               if (style == unknown_demangling)
3221                 fatal (_("unknown demangling style `%s'"),
3222                        optarg);
3223
3224               cplus_demangle_set_style (style);
3225             }
3226           break;
3227         case 'w':
3228           wide_output = TRUE;
3229           break;
3230         case OPTION_ADJUST_VMA:
3231           adjust_section_vma = parse_vma (optarg, "--adjust-vma");
3232           break;
3233         case OPTION_START_ADDRESS:
3234           start_address = parse_vma (optarg, "--start-address");
3235           if ((stop_address != (bfd_vma) -1) && stop_address <= start_address)
3236             fatal (_("error: the start address should be before the end address"));
3237           break;
3238         case OPTION_STOP_ADDRESS:
3239           stop_address = parse_vma (optarg, "--stop-address");
3240           if ((start_address != (bfd_vma) -1) && stop_address <= start_address)
3241             fatal (_("error: the stop address should be after the start address"));
3242           break;
3243         case OPTION_PREFIX:
3244           prefix = optarg;
3245           prefix_length = strlen (prefix);
3246           /* Remove an unnecessary trailing '/' */
3247           while (IS_DIR_SEPARATOR (prefix[prefix_length - 1]))
3248             prefix_length--;
3249           break;
3250         case OPTION_PREFIX_STRIP:
3251           prefix_strip = atoi (optarg);
3252           if (prefix_strip < 0)
3253             fatal (_("error: prefix strip must be non-negative"));
3254           break;
3255         case 'E':
3256           if (strcmp (optarg, "B") == 0)
3257             endian = BFD_ENDIAN_BIG;
3258           else if (strcmp (optarg, "L") == 0)
3259             endian = BFD_ENDIAN_LITTLE;
3260           else
3261             {
3262               non_fatal (_("unrecognized -E option"));
3263               usage (stderr, 1);
3264             }
3265           break;
3266         case OPTION_ENDIAN:
3267           if (strncmp (optarg, "big", strlen (optarg)) == 0)
3268             endian = BFD_ENDIAN_BIG;
3269           else if (strncmp (optarg, "little", strlen (optarg)) == 0)
3270             endian = BFD_ENDIAN_LITTLE;
3271           else
3272             {
3273               non_fatal (_("unrecognized --endian type `%s'"), optarg);
3274               usage (stderr, 1);
3275             }
3276           break;
3277
3278         case 'f':
3279           dump_file_header = TRUE;
3280           seenflag = TRUE;
3281           break;
3282         case 'i':
3283           formats_info = TRUE;
3284           seenflag = TRUE;
3285           break;
3286         case 'I':
3287           add_include_path (optarg);
3288           break;
3289         case 'p':
3290           dump_private_headers = TRUE;
3291           seenflag = TRUE;
3292           break;
3293         case 'x':
3294           dump_private_headers = TRUE;
3295           dump_symtab = TRUE;
3296           dump_reloc_info = TRUE;
3297           dump_file_header = TRUE;
3298           dump_ar_hdrs = TRUE;
3299           dump_section_headers = TRUE;
3300           seenflag = TRUE;
3301           break;
3302         case 't':
3303           dump_symtab = TRUE;
3304           seenflag = TRUE;
3305           break;
3306         case 'T':
3307           dump_dynamic_symtab = TRUE;
3308           seenflag = TRUE;
3309           break;
3310         case 'd':
3311           disassemble = TRUE;
3312           seenflag = TRUE;
3313           break;
3314         case 'z':
3315           disassemble_zeroes = TRUE;
3316           break;
3317         case 'D':
3318           disassemble = TRUE;
3319           disassemble_all = TRUE;
3320           seenflag = TRUE;
3321           break;
3322         case 'S':
3323           disassemble = TRUE;
3324           with_source_code = TRUE;
3325           seenflag = TRUE;
3326           break;
3327         case 'g':
3328           dump_debugging = 1;
3329           seenflag = TRUE;
3330           break;
3331         case 'e':
3332           dump_debugging = 1;
3333           dump_debugging_tags = 1;
3334           do_demangle = TRUE;
3335           seenflag = TRUE;
3336           break;
3337         case 'W':
3338           dump_dwarf_section_info = TRUE;
3339           seenflag = TRUE;
3340           if (optarg)
3341             dwarf_select_sections_by_letters (optarg);
3342           else
3343             dwarf_select_sections_all ();
3344           break;
3345         case OPTION_DWARF:
3346           dump_dwarf_section_info = TRUE;
3347           seenflag = TRUE;
3348           if (optarg)
3349             dwarf_select_sections_by_names (optarg);
3350           else
3351             dwarf_select_sections_all ();
3352           break;
3353         case 'G':
3354           dump_stab_section_info = TRUE;
3355           seenflag = TRUE;
3356           break;
3357         case 's':
3358           dump_section_contents = TRUE;
3359           seenflag = TRUE;
3360           break;
3361         case 'r':
3362           dump_reloc_info = TRUE;
3363           seenflag = TRUE;
3364           break;
3365         case 'R':
3366           dump_dynamic_reloc_info = TRUE;
3367           seenflag = TRUE;
3368           break;
3369         case 'a':
3370           dump_ar_hdrs = TRUE;
3371           seenflag = TRUE;
3372           break;
3373         case 'h':
3374           dump_section_headers = TRUE;
3375           seenflag = TRUE;
3376           break;
3377         case 'H':
3378           usage (stdout, 0);
3379           seenflag = TRUE;
3380         case 'v':
3381         case 'V':
3382           show_version = TRUE;
3383           seenflag = TRUE;
3384           break;
3385
3386         default:
3387           usage (stderr, 1);
3388         }
3389     }
3390
3391   if (show_version)
3392     print_version ("objdump");
3393
3394   if (!seenflag)
3395     usage (stderr, 2);
3396
3397   if (formats_info)
3398     exit_status = display_info ();
3399   else
3400     {
3401       if (optind == argc)
3402         display_file ("a.out", target);
3403       else
3404         for (; optind < argc;)
3405           display_file (argv[optind++], target);
3406     }
3407
3408   END_PROGRESS (program_name);
3409
3410   return exit_status;
3411 }