binutils/objdump.c

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