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