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 = 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) - 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 = stop_offset;
1966
1967       /* If a symbol is explicitly marked as being an object
1968          rather than a function, just dump the bytes without
1969          disassembling them.  */
1970       if (disassemble_all
1971           || sym == NULL
1972           || sym->section != section
1973           || bfd_asymbol_value (sym) > addr
1974           || ((sym->flags & BSF_OBJECT) == 0
1975               && (strstr (bfd_asymbol_name (sym), "gnu_compiled")
1976                   == NULL)
1977               && (strstr (bfd_asymbol_name (sym), "gcc2_compiled")
1978                   == NULL))
1979           || (sym->flags & BSF_FUNCTION) != 0)
1980         insns = TRUE;
1981       else
1982         insns = FALSE;
1983
1984       disassemble_bytes (pinfo, paux->disassemble_fn, insns, data,
1985                          addr_offset, nextstop_offset,
1986                          rel_offset, &rel_pp, rel_ppend);
1987
1988       addr_offset = nextstop_offset;
1989       sym = nextsym;
1990     }
1991
1992   free (data);
1993
1994   if (rel_ppstart != NULL)
1995     free (rel_ppstart);
1996 }
1997
1998 /* Disassemble the contents of an object file.  */
1999
2000 static void
2001 disassemble_data (bfd *abfd)
2002 {
2003   struct disassemble_info disasm_info;
2004   struct objdump_disasm_info aux;
2005   long i;
2006
2007   print_files = NULL;
2008   prev_functionname = NULL;
2009   prev_line = -1;
2010
2011   /* We make a copy of syms to sort.  We don't want to sort syms
2012      because that will screw up the relocs.  */
2013   sorted_symcount = symcount ? symcount : dynsymcount;
2014   sorted_syms = xmalloc ((sorted_symcount + synthcount) * sizeof (asymbol *));
2015   memcpy (sorted_syms, symcount ? syms : dynsyms,
2016           sorted_symcount * sizeof (asymbol *));
2017
2018   sorted_symcount = remove_useless_symbols (sorted_syms, sorted_symcount);
2019
2020   for (i = 0; i < synthcount; ++i)
2021     {
2022       sorted_syms[sorted_symcount] = synthsyms + i;
2023       ++sorted_symcount;
2024     }
2025
2026   /* Sort the symbols into section and symbol order.  */
2027   qsort (sorted_syms, sorted_symcount, sizeof (asymbol *), compare_symbols);
2028
2029   init_disassemble_info (&disasm_info, stdout, (fprintf_ftype) fprintf);
2030
2031   disasm_info.application_data = (void *) &aux;
2032   aux.abfd = abfd;
2033   aux.require_sec = FALSE;
2034   aux.dynrelbuf = NULL;
2035   aux.dynrelcount = 0;
2036   aux.reloc = NULL;
2037
2038   disasm_info.print_address_func = objdump_print_address;
2039   disasm_info.symbol_at_address_func = objdump_symbol_at_address;
2040
2041   if (machine != NULL)
2042     {
2043       const bfd_arch_info_type *info = bfd_scan_arch (machine);
2044
2045       if (info == NULL)
2046         fatal (_("Can't use supplied machine %s"), machine);
2047
2048       abfd->arch_info = info;
2049     }
2050
2051   if (endian != BFD_ENDIAN_UNKNOWN)
2052     {
2053       struct bfd_target *xvec;
2054
2055       xvec = xmalloc (sizeof (struct bfd_target));
2056       memcpy (xvec, abfd->xvec, sizeof (struct bfd_target));
2057       xvec->byteorder = endian;
2058       abfd->xvec = xvec;
2059     }
2060
2061   /* Use libopcodes to locate a suitable disassembler.  */
2062   aux.disassemble_fn = disassembler (abfd);
2063   if (!aux.disassemble_fn)
2064     {
2065       non_fatal (_("Can't disassemble for architecture %s\n"),
2066                  bfd_printable_arch_mach (bfd_get_arch (abfd), 0));
2067       exit_status = 1;
2068       return;
2069     }
2070
2071   disasm_info.flavour = bfd_get_flavour (abfd);
2072   disasm_info.arch = bfd_get_arch (abfd);
2073   disasm_info.mach = bfd_get_mach (abfd);
2074   disasm_info.disassembler_options = disassembler_options;
2075   disasm_info.octets_per_byte = bfd_octets_per_byte (abfd);
2076   disasm_info.skip_zeroes = DEFAULT_SKIP_ZEROES;
2077   disasm_info.skip_zeroes_at_end = DEFAULT_SKIP_ZEROES_AT_END;
2078   disasm_info.disassembler_needs_relocs = FALSE;
2079
2080   if (bfd_big_endian (abfd))
2081     disasm_info.display_endian = disasm_info.endian = BFD_ENDIAN_BIG;
2082   else if (bfd_little_endian (abfd))
2083     disasm_info.display_endian = disasm_info.endian = BFD_ENDIAN_LITTLE;
2084   else
2085     /* ??? Aborting here seems too drastic.  We could default to big or little
2086        instead.  */
2087     disasm_info.endian = BFD_ENDIAN_UNKNOWN;
2088
2089   /* Allow the target to customize the info structure.  */
2090   disassemble_init_for_target (& disasm_info);
2091
2092   /* Pre-load the dynamic relocs if we are going
2093      to be dumping them along with the disassembly.  */
2094   if (dump_dynamic_reloc_info)
2095     {
2096       long relsize = bfd_get_dynamic_reloc_upper_bound (abfd);
2097
2098       if (relsize < 0)
2099         bfd_fatal (bfd_get_filename (abfd));
2100
2101       if (relsize > 0)
2102         {
2103           aux.dynrelbuf = xmalloc (relsize);
2104           aux.dynrelcount = bfd_canonicalize_dynamic_reloc (abfd,
2105                                                             aux.dynrelbuf,
2106                                                             dynsyms);
2107           if (aux.dynrelcount < 0)
2108             bfd_fatal (bfd_get_filename (abfd));
2109
2110           /* Sort the relocs by address.  */
2111           qsort (aux.dynrelbuf, aux.dynrelcount, sizeof (arelent *),
2112                  compare_relocs);
2113         }
2114     }
2115   disasm_info.symtab = sorted_syms;
2116   disasm_info.symtab_size = sorted_symcount;
2117
2118   bfd_map_over_sections (abfd, disassemble_section, & disasm_info);
2119
2120   if (aux.dynrelbuf != NULL)
2121     free (aux.dynrelbuf);
2122   free (sorted_syms);
2123 }
2124 \f
2125 int
2126 load_debug_section (enum dwarf_section_display_enum debug, void *file)
2127 {
2128   struct dwarf_section *section = &debug_displays [debug].section;
2129   bfd *abfd = file;
2130   asection *sec;
2131   bfd_boolean ret;
2132   int section_is_compressed;
2133
2134   /* If it is already loaded, do nothing.  */
2135   if (section->start != NULL)
2136     return 1;
2137
2138   /* Locate the debug section.  */
2139   sec = bfd_get_section_by_name (abfd, section->uncompressed_name);
2140   if (sec != NULL)
2141     section->name = section->uncompressed_name;
2142   else
2143     {
2144       sec = bfd_get_section_by_name (abfd, section->compressed_name);
2145       if (sec != NULL)
2146         section->name = section->compressed_name;
2147     }
2148   if (sec == NULL)
2149     return 0;
2150   section_is_compressed = section->name == section->compressed_name;
2151
2152   section->address = 0;
2153   section->size = bfd_get_section_size (sec);
2154   section->start = xmalloc (section->size);
2155
2156   if (is_relocatable && debug_displays [debug].relocate)
2157     ret = bfd_simple_get_relocated_section_contents (abfd,
2158                                                      sec,
2159                                                      section->start,
2160                                                      syms) != NULL;
2161   else
2162     ret = bfd_get_section_contents (abfd, sec, section->start, 0,
2163                                     section->size);
2164
2165   if (! ret)
2166     {
2167       free_debug_section (debug);
2168       printf (_("\nCan't get contents for section '%s'.\n"),
2169               section->name);
2170       return 0;
2171     }
2172
2173   if (section_is_compressed)
2174     {
2175       bfd_size_type size = section->size;
2176       if (! bfd_uncompress_section_contents (&section->start, &size))
2177         {
2178           free_debug_section (debug);
2179           printf (_("\nCan't uncompress section '%s'.\n"), section->name);
2180           return 0;
2181         }
2182       section->size = size;
2183     }
2184
2185   return ret;
2186 }
2187
2188 void
2189 free_debug_section (enum dwarf_section_display_enum debug)
2190 {
2191   struct dwarf_section *section = &debug_displays [debug].section;
2192
2193   if (section->start == NULL)
2194     return;
2195
2196   free ((char *) section->start);
2197   section->start = NULL;
2198   section->address = 0;
2199   section->size = 0;
2200 }
2201
2202 static void
2203 dump_dwarf_section (bfd *abfd, asection *section,
2204                     void *arg ATTRIBUTE_UNUSED)
2205 {
2206   const char *name = bfd_get_section_name (abfd, section);
2207   const char *match;
2208   enum dwarf_section_display_enum i;
2209
2210   if (CONST_STRNEQ (name, ".gnu.linkonce.wi."))
2211     match = ".debug_info";
2212   else
2213     match = name;
2214
2215   for (i = 0; i < max; i++)
2216     if ((strcmp (debug_displays [i].section.uncompressed_name, match) == 0
2217          || strcmp (debug_displays [i].section.compressed_name, match) == 0)
2218         && debug_displays [i].enabled != NULL
2219         && *debug_displays [i].enabled)
2220       {
2221         if (!debug_displays [i].eh_frame)
2222           {
2223             struct dwarf_section *sec = &debug_displays [i].section;
2224
2225             if (load_debug_section (i, abfd))
2226               {
2227                 debug_displays [i].display (sec, abfd);
2228
2229                 if (i != info && i != abbrev)
2230                   free_debug_section (i);
2231               }
2232           }
2233         break;
2234       }
2235 }
2236
2237 /* Dump the dwarf debugging information.  */
2238
2239 static void
2240 dump_dwarf (bfd *abfd)
2241 {
2242   is_relocatable = (abfd->flags & (EXEC_P | DYNAMIC)) == 0;
2243
2244   /* FIXME: bfd_get_arch_size may return -1.  We assume that 64bit
2245      targets will return 64.  */
2246   eh_addr_size = bfd_get_arch_size (abfd) == 64 ? 8 : 4;
2247
2248   if (bfd_big_endian (abfd))
2249     byte_get = byte_get_big_endian;
2250   else if (bfd_little_endian (abfd))
2251     byte_get = byte_get_little_endian;
2252   else
2253     abort ();
2254
2255   if (bfd_get_flavour (abfd) == bfd_target_elf_flavour)
2256     {
2257       const struct elf_backend_data *bed = get_elf_backend_data (abfd);
2258       init_dwarf_regnames (bed->elf_machine_code);
2259     }
2260
2261   bfd_map_over_sections (abfd, dump_dwarf_section, NULL);
2262
2263   free_debug_memory ();
2264 }
2265 \f
2266 /* Read ABFD's stabs section STABSECT_NAME, and return a pointer to
2267    it.  Return NULL on failure.   */
2268
2269 static char *
2270 read_section_stabs (bfd *abfd, const char *sect_name, bfd_size_type *size_ptr)
2271 {
2272   asection *stabsect;
2273   bfd_size_type size;
2274   char *contents;
2275
2276   stabsect = bfd_get_section_by_name (abfd, sect_name);
2277   if (stabsect == NULL)
2278     {
2279       printf (_("No %s section present\n\n"), sect_name);
2280       return FALSE;
2281     }
2282
2283   size = bfd_section_size (abfd, stabsect);
2284   contents  = xmalloc (size);
2285
2286   if (! bfd_get_section_contents (abfd, stabsect, contents, 0, size))
2287     {
2288       non_fatal (_("Reading %s section of %s failed: %s"),
2289                  sect_name, bfd_get_filename (abfd),
2290                  bfd_errmsg (bfd_get_error ()));
2291       free (contents);
2292       exit_status = 1;
2293       return NULL;
2294     }
2295
2296   *size_ptr = size;
2297
2298   return contents;
2299 }
2300
2301 /* Stabs entries use a 12 byte format:
2302      4 byte string table index
2303      1 byte stab type
2304      1 byte stab other field
2305      2 byte stab desc field
2306      4 byte stab value
2307    FIXME: This will have to change for a 64 bit object format.  */
2308
2309 #define STRDXOFF  (0)
2310 #define TYPEOFF   (4)
2311 #define OTHEROFF  (5)
2312 #define DESCOFF   (6)
2313 #define VALOFF    (8)
2314 #define STABSIZE (12)
2315
2316 /* Print ABFD's stabs section STABSECT_NAME (in `stabs'),
2317    using string table section STRSECT_NAME (in `strtab').  */
2318
2319 static void
2320 print_section_stabs (bfd *abfd,
2321                      const char *stabsect_name,
2322                      unsigned *string_offset_ptr)
2323 {
2324   int i;
2325   unsigned file_string_table_offset = 0;
2326   unsigned next_file_string_table_offset = *string_offset_ptr;
2327   bfd_byte *stabp, *stabs_end;
2328
2329   stabp = stabs;
2330   stabs_end = stabp + stab_size;
2331
2332   printf (_("Contents of %s section:\n\n"), stabsect_name);
2333   printf ("Symnum n_type n_othr n_desc n_value  n_strx String\n");
2334
2335   /* Loop through all symbols and print them.
2336
2337      We start the index at -1 because there is a dummy symbol on
2338      the front of stabs-in-{coff,elf} sections that supplies sizes.  */
2339   for (i = -1; stabp < stabs_end; stabp += STABSIZE, i++)
2340     {
2341       const char *name;
2342       unsigned long strx;
2343       unsigned char type, other;
2344       unsigned short desc;
2345       bfd_vma value;
2346
2347       strx = bfd_h_get_32 (abfd, stabp + STRDXOFF);
2348       type = bfd_h_get_8 (abfd, stabp + TYPEOFF);
2349       other = bfd_h_get_8 (abfd, stabp + OTHEROFF);
2350       desc = bfd_h_get_16 (abfd, stabp + DESCOFF);
2351       value = bfd_h_get_32 (abfd, stabp + VALOFF);
2352
2353       printf ("\n%-6d ", i);
2354       /* Either print the stab name, or, if unnamed, print its number
2355          again (makes consistent formatting for tools like awk).  */
2356       name = bfd_get_stab_name (type);
2357       if (name != NULL)
2358         printf ("%-6s", name);
2359       else if (type == N_UNDF)
2360         printf ("HdrSym");
2361       else
2362         printf ("%-6d", type);
2363       printf (" %-6d %-6d ", other, desc);
2364       bfd_printf_vma (abfd, value);
2365       printf (" %-6lu", strx);
2366
2367       /* Symbols with type == 0 (N_UNDF) specify the length of the
2368          string table associated with this file.  We use that info
2369          to know how to relocate the *next* file's string table indices.  */
2370       if (type == N_UNDF)
2371         {
2372           file_string_table_offset = next_file_string_table_offset;
2373           next_file_string_table_offset += value;
2374         }
2375       else
2376         {
2377           /* Using the (possibly updated) string table offset, print the
2378              string (if any) associated with this symbol.  */
2379           if ((strx + file_string_table_offset) < stabstr_size)
2380             printf (" %s", &strtab[strx + file_string_table_offset]);
2381           else
2382             printf (" *");
2383         }
2384     }
2385   printf ("\n\n");
2386   *string_offset_ptr = next_file_string_table_offset;
2387 }
2388
2389 typedef struct
2390 {
2391   const char * section_name;
2392   const char * string_section_name;
2393   unsigned string_offset;
2394 }
2395 stab_section_names;
2396
2397 static void
2398 find_stabs_section (bfd *abfd, asection *section, void *names)
2399 {
2400   int len;
2401   stab_section_names * sought = (stab_section_names *) names;
2402
2403   /* Check for section names for which stabsect_name is a prefix, to
2404      handle .stab.N, etc.  */
2405   len = strlen (sought->section_name);
2406
2407   /* If the prefix matches, and the files section name ends with a
2408      nul or a digit, then we match.  I.e., we want either an exact
2409      match or a section followed by a number.  */
2410   if (strncmp (sought->section_name, section->name, len) == 0
2411       && (section->name[len] == 0
2412           || (section->name[len] == '.' && ISDIGIT (section->name[len + 1]))))
2413     {
2414       if (strtab == NULL)
2415         strtab = read_section_stabs (abfd, sought->string_section_name,
2416                                      &stabstr_size);
2417
2418       if (strtab)
2419         {
2420           stabs = (bfd_byte *) read_section_stabs (abfd, section->name,
2421                                                    &stab_size);
2422           if (stabs)
2423             print_section_stabs (abfd, section->name, &sought->string_offset);
2424         }
2425     }
2426 }
2427
2428 static void
2429 dump_stabs_section (bfd *abfd, char *stabsect_name, char *strsect_name)
2430 {
2431   stab_section_names s;
2432
2433   s.section_name = stabsect_name;
2434   s.string_section_name = strsect_name;
2435   s.string_offset = 0;
2436
2437   bfd_map_over_sections (abfd, find_stabs_section, & s);
2438
2439   free (strtab);
2440   strtab = NULL;
2441 }
2442
2443 /* Dump the any sections containing stabs debugging information.  */
2444
2445 static void
2446 dump_stabs (bfd *abfd)
2447 {
2448   dump_stabs_section (abfd, ".stab", ".stabstr");
2449   dump_stabs_section (abfd, ".stab.excl", ".stab.exclstr");
2450   dump_stabs_section (abfd, ".stab.index", ".stab.indexstr");
2451
2452   /* For Darwin.  */
2453   dump_stabs_section (abfd, "LC_SYMTAB.stabs", "LC_SYMTAB.stabstr");
2454
2455   dump_stabs_section (abfd, "$GDB_SYMBOLS$", "$GDB_STRINGS$");
2456 }
2457 \f
2458 static void
2459 dump_bfd_header (bfd *abfd)
2460 {
2461   char *comma = "";
2462
2463   printf (_("architecture: %s, "),
2464           bfd_printable_arch_mach (bfd_get_arch (abfd),
2465                                    bfd_get_mach (abfd)));
2466   printf (_("flags 0x%08x:\n"), abfd->flags);
2467
2468 #define PF(x, y)    if (abfd->flags & x) {printf("%s%s", comma, y); comma=", ";}
2469   PF (HAS_RELOC, "HAS_RELOC");
2470   PF (EXEC_P, "EXEC_P");
2471   PF (HAS_LINENO, "HAS_LINENO");
2472   PF (HAS_DEBUG, "HAS_DEBUG");
2473   PF (HAS_SYMS, "HAS_SYMS");
2474   PF (HAS_LOCALS, "HAS_LOCALS");
2475   PF (DYNAMIC, "DYNAMIC");
2476   PF (WP_TEXT, "WP_TEXT");
2477   PF (D_PAGED, "D_PAGED");
2478   PF (BFD_IS_RELAXABLE, "BFD_IS_RELAXABLE");
2479   PF (HAS_LOAD_PAGE, "HAS_LOAD_PAGE");
2480   printf (_("\nstart address 0x"));
2481   bfd_printf_vma (abfd, abfd->start_address);
2482   printf ("\n");
2483 }
2484
2485 \f
2486 static void
2487 dump_bfd_private_header (bfd *abfd)
2488 {
2489   bfd_print_private_bfd_data (abfd, stdout);
2490 }
2491
2492 \f
2493 /* Display a section in hexadecimal format with associated characters.
2494    Each line prefixed by the zero padded address.  */
2495
2496 static void
2497 dump_section (bfd *abfd, asection *section, void *dummy ATTRIBUTE_UNUSED)
2498 {
2499   bfd_byte *data = 0;
2500   bfd_size_type datasize;
2501   bfd_size_type addr_offset;
2502   bfd_size_type start_offset;
2503   bfd_size_type stop_offset;
2504   unsigned int opb = bfd_octets_per_byte (abfd);
2505   /* Bytes per line.  */
2506   const int onaline = 16;
2507   char buf[64];
2508   int count;
2509   int width;
2510
2511   if ((section->flags & SEC_HAS_CONTENTS) == 0)
2512     return;
2513
2514   if (! process_section_p (section))
2515     return;
2516
2517   if ((datasize = bfd_section_size (abfd, section)) == 0)
2518     return;
2519
2520   /* Compute the address range to display.  */
2521   if (start_address == (bfd_vma) -1
2522       || start_address < section->vma)
2523     start_offset = 0;
2524   else
2525     start_offset = start_address - section->vma;
2526
2527   if (stop_address == (bfd_vma) -1)
2528     stop_offset = datasize / opb;
2529   else
2530     {
2531       if (stop_address < section->vma)
2532         stop_offset = 0;
2533       else
2534         stop_offset = stop_address - section->vma;
2535
2536       if (stop_offset > datasize / opb)
2537         stop_offset = datasize / opb;
2538     }
2539
2540   if (start_offset >= stop_offset)
2541     return;
2542
2543   printf (_("Contents of section %s:"), section->name);
2544   if (display_file_offsets)
2545     printf (_("  (Starting at file offset: 0x%lx)"),
2546             (unsigned long) (section->filepos + start_offset));
2547   printf ("\n");
2548
2549   data = xmalloc (datasize);
2550
2551   bfd_get_section_contents (abfd, section, data, 0, datasize);
2552
2553   width = 4;
2554
2555   bfd_sprintf_vma (abfd, buf, start_offset + section->vma);
2556   if (strlen (buf) >= sizeof (buf))
2557     abort ();
2558
2559   count = 0;
2560   while (buf[count] == '0' && buf[count+1] != '\0')
2561     count++;
2562   count = strlen (buf) - count;
2563   if (count > width)
2564     width = count;
2565
2566   bfd_sprintf_vma (abfd, buf, stop_offset + section->vma - 1);
2567   if (strlen (buf) >= sizeof (buf))
2568     abort ();
2569
2570   count = 0;
2571   while (buf[count] == '0' && buf[count+1] != '\0')
2572     count++;
2573   count = strlen (buf) - count;
2574   if (count > width)
2575     width = count;
2576
2577   for (addr_offset = start_offset;
2578        addr_offset < stop_offset; addr_offset += onaline / opb)
2579     {
2580       bfd_size_type j;
2581
2582       bfd_sprintf_vma (abfd, buf, (addr_offset + section->vma));
2583       count = strlen (buf);
2584       if ((size_t) count >= sizeof (buf))
2585         abort ();
2586
2587       putchar (' ');
2588       while (count < width)
2589         {
2590           putchar ('0');
2591           count++;
2592         }
2593       fputs (buf + count - width, stdout);
2594       putchar (' ');
2595
2596       for (j = addr_offset * opb;
2597            j < addr_offset * opb + onaline; j++)
2598         {
2599           if (j < stop_offset * opb)
2600             printf ("%02x", (unsigned) (data[j]));
2601           else
2602             printf ("  ");
2603           if ((j & 3) == 3)
2604             printf (" ");
2605         }
2606
2607       printf (" ");
2608       for (j = addr_offset * opb;
2609            j < addr_offset * opb + onaline; j++)
2610         {
2611           if (j >= stop_offset * opb)
2612             printf (" ");
2613           else
2614             printf ("%c", ISPRINT (data[j]) ? data[j] : '.');
2615         }
2616       putchar ('\n');
2617     }
2618   free (data);
2619 }
2620
2621 /* Actually display the various requested regions.  */
2622
2623 static void
2624 dump_data (bfd *abfd)
2625 {
2626   bfd_map_over_sections (abfd, dump_section, NULL);
2627 }
2628
2629 /* Should perhaps share code and display with nm?  */
2630
2631 static void
2632 dump_symbols (bfd *abfd ATTRIBUTE_UNUSED, bfd_boolean dynamic)
2633 {
2634   asymbol **current;
2635   long max;
2636   long count;
2637
2638   if (dynamic)
2639     {
2640       current = dynsyms;
2641       max = dynsymcount;
2642       printf ("DYNAMIC SYMBOL TABLE:\n");
2643     }
2644   else
2645     {
2646       current = syms;
2647       max = symcount;
2648       printf ("SYMBOL TABLE:\n");
2649     }
2650
2651   if (max == 0)
2652     printf (_("no symbols\n"));
2653
2654   for (count = 0; count < max; count++)
2655     {
2656       bfd *cur_bfd;
2657
2658       if (*current == NULL)
2659         printf (_("no information for symbol number %ld\n"), count);
2660
2661       else if ((cur_bfd = bfd_asymbol_bfd (*current)) == NULL)
2662         printf (_("could not determine the type of symbol number %ld\n"),
2663                 count);
2664
2665       else if (process_section_p ((* current)->section)
2666                && (dump_special_syms
2667                    || !bfd_is_target_special_symbol (cur_bfd, *current)))
2668         {
2669           const char *name = (*current)->name;
2670
2671           if (do_demangle && name != NULL && *name != '\0')
2672             {
2673               char *alloc;
2674
2675               /* If we want to demangle the name, we demangle it
2676                  here, and temporarily clobber it while calling
2677                  bfd_print_symbol.  FIXME: This is a gross hack.  */
2678               alloc = bfd_demangle (cur_bfd, name, DMGL_ANSI | DMGL_PARAMS);
2679               if (alloc != NULL)
2680                 (*current)->name = alloc;
2681               bfd_print_symbol (cur_bfd, stdout, *current,
2682                                 bfd_print_symbol_all);
2683               if (alloc != NULL)
2684                 {
2685                   (*current)->name = name;
2686                   free (alloc);
2687                 }
2688             }
2689           else
2690             bfd_print_symbol (cur_bfd, stdout, *current,
2691                               bfd_print_symbol_all);
2692           printf ("\n");
2693         }
2694
2695       current++;
2696     }
2697   printf ("\n\n");
2698 }
2699 \f
2700 static void
2701 dump_reloc_set (bfd *abfd, asection *sec, arelent **relpp, long relcount)
2702 {
2703   arelent **p;
2704   char *last_filename, *last_functionname;
2705   unsigned int last_line;
2706
2707   /* Get column headers lined up reasonably.  */
2708   {
2709     static int width;
2710
2711     if (width == 0)
2712       {
2713         char buf[30];
2714
2715         bfd_sprintf_vma (abfd, buf, (bfd_vma) -1);
2716         width = strlen (buf) - 7;
2717       }
2718     printf ("OFFSET %*s TYPE %*s VALUE \n", width, "", 12, "");
2719   }
2720
2721   last_filename = NULL;
2722   last_functionname = NULL;
2723   last_line = 0;
2724
2725   for (p = relpp; relcount && *p != NULL; p++, relcount--)
2726     {
2727       arelent *q = *p;
2728       const char *filename, *functionname;
2729       unsigned int line;
2730       const char *sym_name;
2731       const char *section_name;
2732
2733       if (start_address != (bfd_vma) -1
2734           && q->address < start_address)
2735         continue;
2736       if (stop_address != (bfd_vma) -1
2737           && q->address > stop_address)
2738         continue;
2739
2740       if (with_line_numbers
2741           && sec != NULL
2742           && bfd_find_nearest_line (abfd, sec, syms, q->address,
2743                                     &filename, &functionname, &line))
2744         {
2745           if (functionname != NULL
2746               && (last_functionname == NULL
2747                   || strcmp (functionname, last_functionname) != 0))
2748             {
2749               printf ("%s():\n", functionname);
2750               if (last_functionname != NULL)
2751                 free (last_functionname);
2752               last_functionname = xstrdup (functionname);
2753             }
2754
2755           if (line > 0
2756               && (line != last_line
2757                   || (filename != NULL
2758                       && last_filename != NULL
2759                       && strcmp (filename, last_filename) != 0)))
2760             {
2761               printf ("%s:%u\n", filename == NULL ? "???" : filename, line);
2762               last_line = line;
2763               if (last_filename != NULL)
2764                 free (last_filename);
2765               if (filename == NULL)
2766                 last_filename = NULL;
2767               else
2768                 last_filename = xstrdup (filename);
2769             }
2770         }
2771
2772       if (q->sym_ptr_ptr && *q->sym_ptr_ptr)
2773         {
2774           sym_name = (*(q->sym_ptr_ptr))->name;
2775           section_name = (*(q->sym_ptr_ptr))->section->name;
2776         }
2777       else
2778         {
2779           sym_name = NULL;
2780           section_name = NULL;
2781         }
2782
2783       bfd_printf_vma (abfd, q->address);
2784       if (q->howto == NULL)
2785         printf (" *unknown*         ");
2786       else if (q->howto->name)
2787         printf (" %-16s  ", q->howto->name);
2788       else
2789         printf (" %-16d  ", q->howto->type);
2790
2791       if (sym_name)
2792         {
2793           objdump_print_symname (abfd, NULL, *q->sym_ptr_ptr);
2794         }
2795       else
2796         {
2797           if (section_name == NULL)
2798             section_name = "*unknown*";
2799           printf ("[%s]", section_name);
2800         }
2801
2802       if (q->addend)
2803         {
2804           printf ("+0x");
2805           bfd_printf_vma (abfd, q->addend);
2806         }
2807
2808       printf ("\n");
2809     }
2810 }
2811
2812 static void
2813 dump_relocs_in_section (bfd *abfd,
2814                         asection *section,
2815                         void *dummy ATTRIBUTE_UNUSED)
2816 {
2817   arelent **relpp;
2818   long relcount;
2819   long relsize;
2820
2821   if (   bfd_is_abs_section (section)
2822       || bfd_is_und_section (section)
2823       || bfd_is_com_section (section)
2824       || (! process_section_p (section))
2825       || ((section->flags & SEC_RELOC) == 0))
2826     return;
2827
2828   relsize = bfd_get_reloc_upper_bound (abfd, section);
2829   if (relsize < 0)
2830     bfd_fatal (bfd_get_filename (abfd));
2831
2832   printf ("RELOCATION RECORDS FOR [%s]:", section->name);
2833
2834   if (relsize == 0)
2835     {
2836       printf (" (none)\n\n");
2837       return;
2838     }
2839
2840   relpp = xmalloc (relsize);
2841   relcount = bfd_canonicalize_reloc (abfd, section, relpp, syms);
2842
2843   if (relcount < 0)
2844     bfd_fatal (bfd_get_filename (abfd));
2845   else if (relcount == 0)
2846     printf (" (none)\n\n");
2847   else
2848     {
2849       printf ("\n");
2850       dump_reloc_set (abfd, section, relpp, relcount);
2851       printf ("\n\n");
2852     }
2853   free (relpp);
2854 }
2855
2856 static void
2857 dump_relocs (bfd *abfd)
2858 {
2859   bfd_map_over_sections (abfd, dump_relocs_in_section, NULL);
2860 }
2861
2862 static void
2863 dump_dynamic_relocs (bfd *abfd)
2864 {
2865   long relsize;
2866   arelent **relpp;
2867   long relcount;
2868
2869   relsize = bfd_get_dynamic_reloc_upper_bound (abfd);
2870   if (relsize < 0)
2871     bfd_fatal (bfd_get_filename (abfd));
2872
2873   printf ("DYNAMIC RELOCATION RECORDS");
2874
2875   if (relsize == 0)
2876     printf (" (none)\n\n");
2877   else
2878     {
2879       relpp = xmalloc (relsize);
2880       relcount = bfd_canonicalize_dynamic_reloc (abfd, relpp, dynsyms);
2881
2882       if (relcount < 0)
2883         bfd_fatal (bfd_get_filename (abfd));
2884       else if (relcount == 0)
2885         printf (" (none)\n\n");
2886       else
2887         {
2888           printf ("\n");
2889           dump_reloc_set (abfd, NULL, relpp, relcount);
2890           printf ("\n\n");
2891         }
2892       free (relpp);
2893     }
2894 }
2895
2896 /* Creates a table of paths, to search for source files.  */
2897
2898 static void
2899 add_include_path (const char *path)
2900 {
2901   if (path[0] == 0)
2902     return;
2903   include_path_count++;
2904   include_paths = xrealloc (include_paths,
2905                             include_path_count * sizeof (*include_paths));
2906 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
2907   if (path[1] == ':' && path[2] == 0)
2908     path = concat (path, ".", (const char *) 0);
2909 #endif
2910   include_paths[include_path_count - 1] = path;
2911 }
2912
2913 static void
2914 adjust_addresses (bfd *abfd ATTRIBUTE_UNUSED,
2915                   asection *section,
2916                   void *arg)
2917 {
2918   if ((section->flags & SEC_DEBUGGING) == 0)
2919     {
2920       bfd_boolean *has_reloc_p = (bfd_boolean *) arg;
2921       section->vma += adjust_section_vma;
2922       if (*has_reloc_p)
2923         section->lma += adjust_section_vma;
2924     }
2925 }
2926
2927 /* Dump selected contents of ABFD.  */
2928
2929 static void
2930 dump_bfd (bfd *abfd)
2931 {
2932   /* If we are adjusting section VMA's, change them all now.  Changing
2933      the BFD information is a hack.  However, we must do it, or
2934      bfd_find_nearest_line will not do the right thing.  */
2935   if (adjust_section_vma != 0)
2936     {
2937       bfd_boolean has_reloc = (abfd->flags & HAS_RELOC);
2938       bfd_map_over_sections (abfd, adjust_addresses, &has_reloc);
2939     }
2940
2941   if (! dump_debugging_tags)
2942     printf (_("\n%s:     file format %s\n"), bfd_get_filename (abfd),
2943             abfd->xvec->name);
2944   if (dump_ar_hdrs)
2945     print_arelt_descr (stdout, abfd, TRUE);
2946   if (dump_file_header)
2947     dump_bfd_header (abfd);
2948   if (dump_private_headers)
2949     dump_bfd_private_header (abfd);
2950   if (! dump_debugging_tags)
2951     putchar ('\n');
2952   if (dump_section_headers)
2953     dump_headers (abfd);
2954
2955   if (dump_symtab
2956       || dump_reloc_info
2957       || disassemble
2958       || dump_debugging
2959       || dump_dwarf_section_info)
2960     syms = slurp_symtab (abfd);
2961   if (dump_dynamic_symtab || dump_dynamic_reloc_info
2962       || (disassemble && bfd_get_dynamic_symtab_upper_bound (abfd) > 0))
2963     dynsyms = slurp_dynamic_symtab (abfd);
2964   if (disassemble)
2965     {
2966       synthcount = bfd_get_synthetic_symtab (abfd, symcount, syms,
2967                                              dynsymcount, dynsyms, &synthsyms);
2968       if (synthcount < 0)
2969         synthcount = 0;
2970     }
2971
2972   if (dump_symtab)
2973     dump_symbols (abfd, FALSE);
2974   if (dump_dynamic_symtab)
2975     dump_symbols (abfd, TRUE);
2976   if (dump_dwarf_section_info)
2977     dump_dwarf (abfd);
2978   if (dump_stab_section_info)
2979     dump_stabs (abfd);
2980   if (dump_reloc_info && ! disassemble)
2981     dump_relocs (abfd);
2982   if (dump_dynamic_reloc_info && ! disassemble)
2983     dump_dynamic_relocs (abfd);
2984   if (dump_section_contents)
2985     dump_data (abfd);
2986   if (disassemble)
2987     disassemble_data (abfd);
2988
2989   if (dump_debugging)
2990     {
2991       void *dhandle;
2992
2993       dhandle = read_debugging_info (abfd, syms, symcount, TRUE);
2994       if (dhandle != NULL)
2995         {
2996           if (!print_debugging_info (stdout, dhandle, abfd, syms,
2997                                      bfd_demangle,
2998                                      dump_debugging_tags ? TRUE : FALSE))
2999             {
3000               non_fatal (_("%s: printing debugging information failed"),
3001                          bfd_get_filename (abfd));
3002               exit_status = 1;
3003             }
3004         }
3005       /* PR 6483: If there was no STABS or IEEE debug
3006          info in the file, try DWARF instead.  */
3007       else if (! dump_dwarf_section_info)
3008         {
3009           dump_dwarf (abfd);
3010         }
3011     }
3012
3013   if (syms)
3014     {
3015       free (syms);
3016       syms = NULL;
3017     }
3018
3019   if (dynsyms)
3020     {
3021       free (dynsyms);
3022       dynsyms = NULL;
3023     }
3024
3025   if (synthsyms)
3026     {
3027       free (synthsyms);
3028       synthsyms = NULL;
3029     }
3030
3031   symcount = 0;
3032   dynsymcount = 0;
3033   synthcount = 0;
3034 }
3035
3036 static void
3037 display_bfd (bfd *abfd)
3038 {
3039   char **matching;
3040
3041   if (bfd_check_format_matches (abfd, bfd_object, &matching))
3042     {
3043       dump_bfd (abfd);
3044       return;
3045     }
3046
3047   if (bfd_get_error () == bfd_error_file_ambiguously_recognized)
3048     {
3049       nonfatal (bfd_get_filename (abfd));
3050       list_matching_formats (matching);
3051       free (matching);
3052       return;
3053     }
3054
3055   if (bfd_get_error () != bfd_error_file_not_recognized)
3056     {
3057       nonfatal (bfd_get_filename (abfd));
3058       return;
3059     }
3060
3061   if (bfd_check_format_matches (abfd, bfd_core, &matching))
3062     {
3063       dump_bfd (abfd);
3064       return;
3065     }
3066
3067   nonfatal (bfd_get_filename (abfd));
3068
3069   if (bfd_get_error () == bfd_error_file_ambiguously_recognized)
3070     {
3071       list_matching_formats (matching);
3072       free (matching);
3073     }
3074 }
3075
3076 static void
3077 display_file (char *filename, char *target)
3078 {
3079   bfd *file;
3080   bfd *arfile = NULL;
3081
3082   if (get_file_size (filename) < 1)
3083     {
3084       exit_status = 1;
3085       return;
3086     }
3087
3088   file = bfd_openr (filename, target);
3089   if (file == NULL)
3090     {
3091       nonfatal (filename);
3092       return;
3093     }
3094
3095   /* If the file is an archive, process all of its elements.  */
3096   if (bfd_check_format (file, bfd_archive))
3097     {
3098       bfd *last_arfile = NULL;
3099
3100       printf (_("In archive %s:\n"), bfd_get_filename (file));
3101       for (;;)
3102         {
3103           bfd_set_error (bfd_error_no_error);
3104
3105           arfile = bfd_openr_next_archived_file (file, arfile);
3106           if (arfile == NULL)
3107             {
3108               if (bfd_get_error () != bfd_error_no_more_archived_files)
3109                 nonfatal (bfd_get_filename (file));
3110               break;
3111             }
3112
3113           display_bfd (arfile);
3114
3115           if (last_arfile != NULL)
3116             bfd_close (last_arfile);
3117           last_arfile = arfile;
3118         }
3119
3120       if (last_arfile != NULL)
3121         bfd_close (last_arfile);
3122     }
3123   else
3124     display_bfd (file);
3125
3126   bfd_close (file);
3127 }
3128 \f
3129 int
3130 main (int argc, char **argv)
3131 {
3132   int c;
3133   char *target = default_target;
3134   bfd_boolean seenflag = FALSE;
3135
3136 #if defined (HAVE_SETLOCALE)
3137 #if defined (HAVE_LC_MESSAGES)
3138   setlocale (LC_MESSAGES, "");
3139 #endif
3140   setlocale (LC_CTYPE, "");
3141 #endif
3142
3143   bindtextdomain (PACKAGE, LOCALEDIR);
3144   textdomain (PACKAGE);
3145
3146   program_name = *argv;
3147   xmalloc_set_program_name (program_name);
3148
3149   START_PROGRESS (program_name, 0);
3150
3151   expandargv (&argc, &argv);
3152
3153   bfd_init ();
3154   set_default_bfd_target ();
3155
3156   while ((c = getopt_long (argc, argv,
3157                            "pib:m:M:VvCdDlfFaHhrRtTxsSI:j:wE:zgeGW::",
3158                            long_options, (int *) 0))
3159          != EOF)
3160     {
3161       switch (c)
3162         {
3163         case 0:
3164           break;                /* We've been given a long option.  */
3165         case 'm':
3166           machine = optarg;
3167           break;
3168         case 'M':
3169           if (disassembler_options)
3170             /* Ignore potential memory leak for now.  */
3171             disassembler_options = concat (disassembler_options, ",",
3172                                            optarg, (const char *) NULL);
3173           else
3174             disassembler_options = optarg;
3175           break;
3176         case 'j':
3177           if (only_used == only_size)
3178             {
3179               only_size += 8;
3180               only = xrealloc (only, only_size * sizeof (char *));
3181             }
3182           only [only_used++] = optarg;
3183           break;
3184         case 'F':
3185           display_file_offsets = TRUE;
3186           break;
3187         case 'l':
3188           with_line_numbers = TRUE;
3189           break;
3190         case 'b':
3191           target = optarg;
3192           break;
3193         case 'C':
3194           do_demangle = TRUE;
3195           if (optarg != NULL)
3196             {
3197               enum demangling_styles style;
3198
3199               style = cplus_demangle_name_to_style (optarg);
3200               if (style == unknown_demangling)
3201                 fatal (_("unknown demangling style `%s'"),
3202                        optarg);
3203
3204               cplus_demangle_set_style (style);
3205             }
3206           break;
3207         case 'w':
3208           wide_output = TRUE;
3209           break;
3210         case OPTION_ADJUST_VMA:
3211           adjust_section_vma = parse_vma (optarg, "--adjust-vma");
3212           break;
3213         case OPTION_START_ADDRESS:
3214           start_address = parse_vma (optarg, "--start-address");
3215           if ((stop_address != (bfd_vma) -1) && stop_address <= start_address)
3216             fatal (_("error: the start address should be before the end address"));
3217           break;
3218         case OPTION_STOP_ADDRESS:
3219           stop_address = parse_vma (optarg, "--stop-address");
3220           if ((start_address != (bfd_vma) -1) && stop_address <= start_address)
3221             fatal (_("error: the stop address should be after the start address"));
3222           break;
3223         case OPTION_PREFIX:
3224           prefix = optarg;
3225           prefix_length = strlen (prefix);
3226           /* Remove an unnecessary trailing '/' */
3227           while (IS_DIR_SEPARATOR (prefix[prefix_length - 1]))
3228             prefix_length--;
3229           break;
3230         case OPTION_PREFIX_STRIP:
3231           prefix_strip = atoi (optarg);
3232           if (prefix_strip < 0)
3233             fatal (_("error: prefix strip must be non-negative"));
3234           break;
3235         case 'E':
3236           if (strcmp (optarg, "B") == 0)
3237             endian = BFD_ENDIAN_BIG;
3238           else if (strcmp (optarg, "L") == 0)
3239             endian = BFD_ENDIAN_LITTLE;
3240           else
3241             {
3242               non_fatal (_("unrecognized -E option"));
3243               usage (stderr, 1);
3244             }
3245           break;
3246         case OPTION_ENDIAN:
3247           if (strncmp (optarg, "big", strlen (optarg)) == 0)
3248             endian = BFD_ENDIAN_BIG;
3249           else if (strncmp (optarg, "little", strlen (optarg)) == 0)
3250             endian = BFD_ENDIAN_LITTLE;
3251           else
3252             {
3253               non_fatal (_("unrecognized --endian type `%s'"), optarg);
3254               usage (stderr, 1);
3255             }
3256           break;
3257
3258         case 'f':
3259           dump_file_header = TRUE;
3260           seenflag = TRUE;
3261           break;
3262         case 'i':
3263           formats_info = TRUE;
3264           seenflag = TRUE;
3265           break;
3266         case 'I':
3267           add_include_path (optarg);
3268           break;
3269         case 'p':
3270           dump_private_headers = TRUE;
3271           seenflag = TRUE;
3272           break;
3273         case 'x':
3274           dump_private_headers = TRUE;
3275           dump_symtab = TRUE;
3276           dump_reloc_info = TRUE;
3277           dump_file_header = TRUE;
3278           dump_ar_hdrs = TRUE;
3279           dump_section_headers = TRUE;
3280           seenflag = TRUE;
3281           break;
3282         case 't':
3283           dump_symtab = TRUE;
3284           seenflag = TRUE;
3285           break;
3286         case 'T':
3287           dump_dynamic_symtab = TRUE;
3288           seenflag = TRUE;
3289           break;
3290         case 'd':
3291           disassemble = TRUE;
3292           seenflag = TRUE;
3293           break;
3294         case 'z':
3295           disassemble_zeroes = TRUE;
3296           break;
3297         case 'D':
3298           disassemble = TRUE;
3299           disassemble_all = TRUE;
3300           seenflag = TRUE;
3301           break;
3302         case 'S':
3303           disassemble = TRUE;
3304           with_source_code = TRUE;
3305           seenflag = TRUE;
3306           break;
3307         case 'g':
3308           dump_debugging = 1;
3309           seenflag = TRUE;
3310           break;
3311         case 'e':
3312           dump_debugging = 1;
3313           dump_debugging_tags = 1;
3314           do_demangle = TRUE;
3315           seenflag = TRUE;
3316           break;
3317         case 'W':
3318           dump_dwarf_section_info = TRUE;
3319           seenflag = TRUE;
3320           if (optarg)
3321             dwarf_select_sections_by_letters (optarg);
3322           else
3323             dwarf_select_sections_all ();
3324           break;
3325         case OPTION_DWARF:
3326           dump_dwarf_section_info = TRUE;
3327           seenflag = TRUE;
3328           if (optarg)
3329             dwarf_select_sections_by_names (optarg);
3330           else
3331             dwarf_select_sections_all ();
3332           break;
3333         case 'G':
3334           dump_stab_section_info = TRUE;
3335           seenflag = TRUE;
3336           break;
3337         case 's':
3338           dump_section_contents = TRUE;
3339           seenflag = TRUE;
3340           break;
3341         case 'r':
3342           dump_reloc_info = TRUE;
3343           seenflag = TRUE;
3344           break;
3345         case 'R':
3346           dump_dynamic_reloc_info = TRUE;
3347           seenflag = TRUE;
3348           break;
3349         case 'a':
3350           dump_ar_hdrs = TRUE;
3351           seenflag = TRUE;
3352           break;
3353         case 'h':
3354           dump_section_headers = TRUE;
3355           seenflag = TRUE;
3356           break;
3357         case 'H':
3358           usage (stdout, 0);
3359           seenflag = TRUE;
3360         case 'v':
3361         case 'V':
3362           show_version = TRUE;
3363           seenflag = TRUE;
3364           break;
3365
3366         default:
3367           usage (stderr, 1);
3368         }
3369     }
3370
3371   if (show_version)
3372     print_version ("objdump");
3373
3374   if (!seenflag)
3375     usage (stderr, 2);
3376
3377   if (formats_info)
3378     exit_status = display_info ();
3379   else
3380     {
3381       if (optind == argc)
3382         display_file ("a.out", target);
3383       else
3384         for (; optind < argc;)
3385           display_file (argv[optind++], target);
3386     }
3387
3388   END_PROGRESS (program_name);
3389
3390   return exit_status;
3391 }