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