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   if (bfd_get_flavour (abfd) == bfd_target_elf_flavour)
2353     {
2354       const struct elf_backend_data *bed = get_elf_backend_data (abfd);
2355       init_dwarf_regnames (bed->elf_machine_code);
2356     }
2357
2358   bfd_map_over_sections (abfd, dump_dwarf_section, NULL);
2359
2360   free_debug_memory ();
2361 }
2362 \f
2363 /* Read ABFD's stabs section STABSECT_NAME, and return a pointer to
2364    it.  Return NULL on failure.   */
2365
2366 static char *
2367 read_section_stabs (bfd *abfd, const char *sect_name, bfd_size_type *size_ptr)
2368 {
2369   asection *stabsect;
2370   bfd_size_type size;
2371   char *contents;
2372
2373   stabsect = bfd_get_section_by_name (abfd, sect_name);
2374   if (stabsect == NULL)
2375     {
2376       printf (_("No %s section present\n\n"), sect_name);
2377       return FALSE;
2378     }
2379
2380   size = bfd_section_size (abfd, stabsect);
2381   contents  = (char *) xmalloc (size);
2382
2383   if (! bfd_get_section_contents (abfd, stabsect, contents, 0, size))
2384     {
2385       non_fatal (_("Reading %s section of %s failed: %s"),
2386                  sect_name, bfd_get_filename (abfd),
2387                  bfd_errmsg (bfd_get_error ()));
2388       free (contents);
2389       exit_status = 1;
2390       return NULL;
2391     }
2392
2393   *size_ptr = size;
2394
2395   return contents;
2396 }
2397
2398 /* Stabs entries use a 12 byte format:
2399      4 byte string table index
2400      1 byte stab type
2401      1 byte stab other field
2402      2 byte stab desc field
2403      4 byte stab value
2404    FIXME: This will have to change for a 64 bit object format.  */
2405
2406 #define STRDXOFF  (0)
2407 #define TYPEOFF   (4)
2408 #define OTHEROFF  (5)
2409 #define DESCOFF   (6)
2410 #define VALOFF    (8)
2411 #define STABSIZE (12)
2412
2413 /* Print ABFD's stabs section STABSECT_NAME (in `stabs'),
2414    using string table section STRSECT_NAME (in `strtab').  */
2415
2416 static void
2417 print_section_stabs (bfd *abfd,
2418                      const char *stabsect_name,
2419                      unsigned *string_offset_ptr)
2420 {
2421   int i;
2422   unsigned file_string_table_offset = 0;
2423   unsigned next_file_string_table_offset = *string_offset_ptr;
2424   bfd_byte *stabp, *stabs_end;
2425
2426   stabp = stabs;
2427   stabs_end = stabp + stab_size;
2428
2429   printf (_("Contents of %s section:\n\n"), stabsect_name);
2430   printf ("Symnum n_type n_othr n_desc n_value  n_strx String\n");
2431
2432   /* Loop through all symbols and print them.
2433
2434      We start the index at -1 because there is a dummy symbol on
2435      the front of stabs-in-{coff,elf} sections that supplies sizes.  */
2436   for (i = -1; stabp < stabs_end; stabp += STABSIZE, i++)
2437     {
2438       const char *name;
2439       unsigned long strx;
2440       unsigned char type, other;
2441       unsigned short desc;
2442       bfd_vma value;
2443
2444       strx = bfd_h_get_32 (abfd, stabp + STRDXOFF);
2445       type = bfd_h_get_8 (abfd, stabp + TYPEOFF);
2446       other = bfd_h_get_8 (abfd, stabp + OTHEROFF);
2447       desc = bfd_h_get_16 (abfd, stabp + DESCOFF);
2448       value = bfd_h_get_32 (abfd, stabp + VALOFF);
2449
2450       printf ("\n%-6d ", i);
2451       /* Either print the stab name, or, if unnamed, print its number
2452          again (makes consistent formatting for tools like awk).  */
2453       name = bfd_get_stab_name (type);
2454       if (name != NULL)
2455         printf ("%-6s", name);
2456       else if (type == N_UNDF)
2457         printf ("HdrSym");
2458       else
2459         printf ("%-6d", type);
2460       printf (" %-6d %-6d ", other, desc);
2461       bfd_printf_vma (abfd, value);
2462       printf (" %-6lu", strx);
2463
2464       /* Symbols with type == 0 (N_UNDF) specify the length of the
2465          string table associated with this file.  We use that info
2466          to know how to relocate the *next* file's string table indices.  */
2467       if (type == N_UNDF)
2468         {
2469           file_string_table_offset = next_file_string_table_offset;
2470           next_file_string_table_offset += value;
2471         }
2472       else
2473         {
2474           /* Using the (possibly updated) string table offset, print the
2475              string (if any) associated with this symbol.  */
2476           if ((strx + file_string_table_offset) < stabstr_size)
2477             printf (" %s", &strtab[strx + file_string_table_offset]);
2478           else
2479             printf (" *");
2480         }
2481     }
2482   printf ("\n\n");
2483   *string_offset_ptr = next_file_string_table_offset;
2484 }
2485
2486 typedef struct
2487 {
2488   const char * section_name;
2489   const char * string_section_name;
2490   unsigned string_offset;
2491 }
2492 stab_section_names;
2493
2494 static void
2495 find_stabs_section (bfd *abfd, asection *section, void *names)
2496 {
2497   int len;
2498   stab_section_names * sought = (stab_section_names *) names;
2499
2500   /* Check for section names for which stabsect_name is a prefix, to
2501      handle .stab.N, etc.  */
2502   len = strlen (sought->section_name);
2503
2504   /* If the prefix matches, and the files section name ends with a
2505      nul or a digit, then we match.  I.e., we want either an exact
2506      match or a section followed by a number.  */
2507   if (strncmp (sought->section_name, section->name, len) == 0
2508       && (section->name[len] == 0
2509           || (section->name[len] == '.' && ISDIGIT (section->name[len + 1]))))
2510     {
2511       if (strtab == NULL)
2512         strtab = read_section_stabs (abfd, sought->string_section_name,
2513                                      &stabstr_size);
2514
2515       if (strtab)
2516         {
2517           stabs = (bfd_byte *) read_section_stabs (abfd, section->name,
2518                                                    &stab_size);
2519           if (stabs)
2520             print_section_stabs (abfd, section->name, &sought->string_offset);
2521         }
2522     }
2523 }
2524
2525 static void
2526 dump_stabs_section (bfd *abfd, char *stabsect_name, char *strsect_name)
2527 {
2528   stab_section_names s;
2529
2530   s.section_name = stabsect_name;
2531   s.string_section_name = strsect_name;
2532   s.string_offset = 0;
2533
2534   bfd_map_over_sections (abfd, find_stabs_section, & s);
2535
2536   free (strtab);
2537   strtab = NULL;
2538 }
2539
2540 /* Dump the any sections containing stabs debugging information.  */
2541
2542 static void
2543 dump_stabs (bfd *abfd)
2544 {
2545   dump_stabs_section (abfd, ".stab", ".stabstr");
2546   dump_stabs_section (abfd, ".stab.excl", ".stab.exclstr");
2547   dump_stabs_section (abfd, ".stab.index", ".stab.indexstr");
2548
2549   /* For Darwin.  */
2550   dump_stabs_section (abfd, "LC_SYMTAB.stabs", "LC_SYMTAB.stabstr");
2551
2552   dump_stabs_section (abfd, "$GDB_SYMBOLS$", "$GDB_STRINGS$");
2553 }
2554 \f
2555 static void
2556 dump_bfd_header (bfd *abfd)
2557 {
2558   char *comma = "";
2559
2560   printf (_("architecture: %s, "),
2561           bfd_printable_arch_mach (bfd_get_arch (abfd),
2562                                    bfd_get_mach (abfd)));
2563   printf (_("flags 0x%08x:\n"), abfd->flags);
2564
2565 #define PF(x, y)    if (abfd->flags & x) {printf("%s%s", comma, y); comma=", ";}
2566   PF (HAS_RELOC, "HAS_RELOC");
2567   PF (EXEC_P, "EXEC_P");
2568   PF (HAS_LINENO, "HAS_LINENO");
2569   PF (HAS_DEBUG, "HAS_DEBUG");
2570   PF (HAS_SYMS, "HAS_SYMS");
2571   PF (HAS_LOCALS, "HAS_LOCALS");
2572   PF (DYNAMIC, "DYNAMIC");
2573   PF (WP_TEXT, "WP_TEXT");
2574   PF (D_PAGED, "D_PAGED");
2575   PF (BFD_IS_RELAXABLE, "BFD_IS_RELAXABLE");
2576   PF (HAS_LOAD_PAGE, "HAS_LOAD_PAGE");
2577   printf (_("\nstart address 0x"));
2578   bfd_printf_vma (abfd, abfd->start_address);
2579   printf ("\n");
2580 }
2581
2582 \f
2583 static void
2584 dump_bfd_private_header (bfd *abfd)
2585 {
2586   bfd_print_private_bfd_data (abfd, stdout);
2587 }
2588
2589 \f
2590 /* Display a section in hexadecimal format with associated characters.
2591    Each line prefixed by the zero padded address.  */
2592
2593 static void
2594 dump_section (bfd *abfd, asection *section, void *dummy ATTRIBUTE_UNUSED)
2595 {
2596   bfd_byte *data = 0;
2597   bfd_size_type datasize;
2598   bfd_size_type addr_offset;
2599   bfd_size_type start_offset;
2600   bfd_size_type stop_offset;
2601   unsigned int opb = bfd_octets_per_byte (abfd);
2602   /* Bytes per line.  */
2603   const int onaline = 16;
2604   char buf[64];
2605   int count;
2606   int width;
2607
2608   if ((section->flags & SEC_HAS_CONTENTS) == 0)
2609     return;
2610
2611   if (! process_section_p (section))
2612     return;
2613
2614   if ((datasize = bfd_section_size (abfd, section)) == 0)
2615     return;
2616
2617   /* Compute the address range to display.  */
2618   if (start_address == (bfd_vma) -1
2619       || start_address < section->vma)
2620     start_offset = 0;
2621   else
2622     start_offset = start_address - section->vma;
2623
2624   if (stop_address == (bfd_vma) -1)
2625     stop_offset = datasize / opb;
2626   else
2627     {
2628       if (stop_address < section->vma)
2629         stop_offset = 0;
2630       else
2631         stop_offset = stop_address - section->vma;
2632
2633       if (stop_offset > datasize / opb)
2634         stop_offset = datasize / opb;
2635     }
2636
2637   if (start_offset >= stop_offset)
2638     return;
2639
2640   printf (_("Contents of section %s:"), section->name);
2641   if (display_file_offsets)
2642     printf (_("  (Starting at file offset: 0x%lx)"),
2643             (unsigned long) (section->filepos + start_offset));
2644   printf ("\n");
2645
2646   data = (bfd_byte *) xmalloc (datasize);
2647
2648   bfd_get_section_contents (abfd, section, data, 0, datasize);
2649
2650   width = 4;
2651
2652   bfd_sprintf_vma (abfd, buf, start_offset + section->vma);
2653   if (strlen (buf) >= sizeof (buf))
2654     abort ();
2655
2656   count = 0;
2657   while (buf[count] == '0' && buf[count+1] != '\0')
2658     count++;
2659   count = strlen (buf) - count;
2660   if (count > width)
2661     width = count;
2662
2663   bfd_sprintf_vma (abfd, buf, stop_offset + section->vma - 1);
2664   if (strlen (buf) >= sizeof (buf))
2665     abort ();
2666
2667   count = 0;
2668   while (buf[count] == '0' && buf[count+1] != '\0')
2669     count++;
2670   count = strlen (buf) - count;
2671   if (count > width)
2672     width = count;
2673
2674   for (addr_offset = start_offset;
2675        addr_offset < stop_offset; addr_offset += onaline / opb)
2676     {
2677       bfd_size_type j;
2678
2679       bfd_sprintf_vma (abfd, buf, (addr_offset + section->vma));
2680       count = strlen (buf);
2681       if ((size_t) count >= sizeof (buf))
2682         abort ();
2683
2684       putchar (' ');
2685       while (count < width)
2686         {
2687           putchar ('0');
2688           count++;
2689         }
2690       fputs (buf + count - width, stdout);
2691       putchar (' ');
2692
2693       for (j = addr_offset * opb;
2694            j < addr_offset * opb + onaline; j++)
2695         {
2696           if (j < stop_offset * opb)
2697             printf ("%02x", (unsigned) (data[j]));
2698           else
2699             printf ("  ");
2700           if ((j & 3) == 3)
2701             printf (" ");
2702         }
2703
2704       printf (" ");
2705       for (j = addr_offset * opb;
2706            j < addr_offset * opb + onaline; j++)
2707         {
2708           if (j >= stop_offset * opb)
2709             printf (" ");
2710           else
2711             printf ("%c", ISPRINT (data[j]) ? data[j] : '.');
2712         }
2713       putchar ('\n');
2714     }
2715   free (data);
2716 }
2717
2718 /* Actually display the various requested regions.  */
2719
2720 static void
2721 dump_data (bfd *abfd)
2722 {
2723   bfd_map_over_sections (abfd, dump_section, NULL);
2724 }
2725
2726 /* Should perhaps share code and display with nm?  */
2727
2728 static void
2729 dump_symbols (bfd *abfd ATTRIBUTE_UNUSED, bfd_boolean dynamic)
2730 {
2731   asymbol **current;
2732   long max_count;
2733   long count;
2734
2735   if (dynamic)
2736     {
2737       current = dynsyms;
2738       max_count = dynsymcount;
2739       printf ("DYNAMIC SYMBOL TABLE:\n");
2740     }
2741   else
2742     {
2743       current = syms;
2744       max_count = symcount;
2745       printf ("SYMBOL TABLE:\n");
2746     }
2747
2748   if (max_count == 0)
2749     printf (_("no symbols\n"));
2750
2751   for (count = 0; count < max_count; count++)
2752     {
2753       bfd *cur_bfd;
2754
2755       if (*current == NULL)
2756         printf (_("no information for symbol number %ld\n"), count);
2757
2758       else if ((cur_bfd = bfd_asymbol_bfd (*current)) == NULL)
2759         printf (_("could not determine the type of symbol number %ld\n"),
2760                 count);
2761
2762       else if (process_section_p ((* current)->section)
2763                && (dump_special_syms
2764                    || !bfd_is_target_special_symbol (cur_bfd, *current)))
2765         {
2766           const char *name = (*current)->name;
2767
2768           if (do_demangle && name != NULL && *name != '\0')
2769             {
2770               char *alloc;
2771
2772               /* If we want to demangle the name, we demangle it
2773                  here, and temporarily clobber it while calling
2774                  bfd_print_symbol.  FIXME: This is a gross hack.  */
2775               alloc = bfd_demangle (cur_bfd, name, DMGL_ANSI | DMGL_PARAMS);
2776               if (alloc != NULL)
2777                 (*current)->name = alloc;
2778               bfd_print_symbol (cur_bfd, stdout, *current,
2779                                 bfd_print_symbol_all);
2780               if (alloc != NULL)
2781                 {
2782                   (*current)->name = name;
2783                   free (alloc);
2784                 }
2785             }
2786           else
2787             bfd_print_symbol (cur_bfd, stdout, *current,
2788                               bfd_print_symbol_all);
2789           printf ("\n");
2790         }
2791
2792       current++;
2793     }
2794   printf ("\n\n");
2795 }
2796 \f
2797 static void
2798 dump_reloc_set (bfd *abfd, asection *sec, arelent **relpp, long relcount)
2799 {
2800   arelent **p;
2801   char *last_filename, *last_functionname;
2802   unsigned int last_line;
2803
2804   /* Get column headers lined up reasonably.  */
2805   {
2806     static int width;
2807
2808     if (width == 0)
2809       {
2810         char buf[30];
2811
2812         bfd_sprintf_vma (abfd, buf, (bfd_vma) -1);
2813         width = strlen (buf) - 7;
2814       }
2815     printf ("OFFSET %*s TYPE %*s VALUE \n", width, "", 12, "");
2816   }
2817
2818   last_filename = NULL;
2819   last_functionname = NULL;
2820   last_line = 0;
2821
2822   for (p = relpp; relcount && *p != NULL; p++, relcount--)
2823     {
2824       arelent *q = *p;
2825       const char *filename, *functionname;
2826       unsigned int linenumber;
2827       const char *sym_name;
2828       const char *section_name;
2829
2830       if (start_address != (bfd_vma) -1
2831           && q->address < start_address)
2832         continue;
2833       if (stop_address != (bfd_vma) -1
2834           && q->address > stop_address)
2835         continue;
2836
2837       if (with_line_numbers
2838           && sec != NULL
2839           && bfd_find_nearest_line (abfd, sec, syms, q->address,
2840                                     &filename, &functionname, &linenumber))
2841         {
2842           if (functionname != NULL
2843               && (last_functionname == NULL
2844                   || strcmp (functionname, last_functionname) != 0))
2845             {
2846               printf ("%s():\n", functionname);
2847               if (last_functionname != NULL)
2848                 free (last_functionname);
2849               last_functionname = xstrdup (functionname);
2850             }
2851
2852           if (linenumber > 0
2853               && (linenumber != last_line
2854                   || (filename != NULL
2855                       && last_filename != NULL
2856                       && strcmp (filename, last_filename) != 0)))
2857             {
2858               printf ("%s:%u\n", filename == NULL ? "???" : filename, linenumber);
2859               last_line = linenumber;
2860               if (last_filename != NULL)
2861                 free (last_filename);
2862               if (filename == NULL)
2863                 last_filename = NULL;
2864               else
2865                 last_filename = xstrdup (filename);
2866             }
2867         }
2868
2869       if (q->sym_ptr_ptr && *q->sym_ptr_ptr)
2870         {
2871           sym_name = (*(q->sym_ptr_ptr))->name;
2872           section_name = (*(q->sym_ptr_ptr))->section->name;
2873         }
2874       else
2875         {
2876           sym_name = NULL;
2877           section_name = NULL;
2878         }
2879
2880       bfd_printf_vma (abfd, q->address);
2881       if (q->howto == NULL)
2882         printf (" *unknown*         ");
2883       else if (q->howto->name)
2884         printf (" %-16s  ", q->howto->name);
2885       else
2886         printf (" %-16d  ", q->howto->type);
2887
2888       if (sym_name)
2889         {
2890           objdump_print_symname (abfd, NULL, *q->sym_ptr_ptr);
2891         }
2892       else
2893         {
2894           if (section_name == NULL)
2895             section_name = "*unknown*";
2896           printf ("[%s]", section_name);
2897         }
2898
2899       if (q->addend)
2900         {
2901           printf ("+0x");
2902           bfd_printf_vma (abfd, q->addend);
2903         }
2904
2905       printf ("\n");
2906     }
2907 }
2908
2909 static void
2910 dump_relocs_in_section (bfd *abfd,
2911                         asection *section,
2912                         void *dummy ATTRIBUTE_UNUSED)
2913 {
2914   arelent **relpp;
2915   long relcount;
2916   long relsize;
2917
2918   if (   bfd_is_abs_section (section)
2919       || bfd_is_und_section (section)
2920       || bfd_is_com_section (section)
2921       || (! process_section_p (section))
2922       || ((section->flags & SEC_RELOC) == 0))
2923     return;
2924
2925   relsize = bfd_get_reloc_upper_bound (abfd, section);
2926   if (relsize < 0)
2927     bfd_fatal (bfd_get_filename (abfd));
2928
2929   printf ("RELOCATION RECORDS FOR [%s]:", section->name);
2930
2931   if (relsize == 0)
2932     {
2933       printf (" (none)\n\n");
2934       return;
2935     }
2936
2937   relpp = (arelent **) xmalloc (relsize);
2938   relcount = bfd_canonicalize_reloc (abfd, section, relpp, syms);
2939
2940   if (relcount < 0)
2941     bfd_fatal (bfd_get_filename (abfd));
2942   else if (relcount == 0)
2943     printf (" (none)\n\n");
2944   else
2945     {
2946       printf ("\n");
2947       dump_reloc_set (abfd, section, relpp, relcount);
2948       printf ("\n\n");
2949     }
2950   free (relpp);
2951 }
2952
2953 static void
2954 dump_relocs (bfd *abfd)
2955 {
2956   bfd_map_over_sections (abfd, dump_relocs_in_section, NULL);
2957 }
2958
2959 static void
2960 dump_dynamic_relocs (bfd *abfd)
2961 {
2962   long relsize;
2963   arelent **relpp;
2964   long relcount;
2965
2966   relsize = bfd_get_dynamic_reloc_upper_bound (abfd);
2967   if (relsize < 0)
2968     bfd_fatal (bfd_get_filename (abfd));
2969
2970   printf ("DYNAMIC RELOCATION RECORDS");
2971
2972   if (relsize == 0)
2973     printf (" (none)\n\n");
2974   else
2975     {
2976       relpp = (arelent **) xmalloc (relsize);
2977       relcount = bfd_canonicalize_dynamic_reloc (abfd, relpp, dynsyms);
2978
2979       if (relcount < 0)
2980         bfd_fatal (bfd_get_filename (abfd));
2981       else if (relcount == 0)
2982         printf (" (none)\n\n");
2983       else
2984         {
2985           printf ("\n");
2986           dump_reloc_set (abfd, NULL, relpp, relcount);
2987           printf ("\n\n");
2988         }
2989       free (relpp);
2990     }
2991 }
2992
2993 /* Creates a table of paths, to search for source files.  */
2994
2995 static void
2996 add_include_path (const char *path)
2997 {
2998   if (path[0] == 0)
2999     return;
3000   include_path_count++;
3001   include_paths = (const char **)
3002       xrealloc (include_paths, include_path_count * sizeof (*include_paths));
3003 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
3004   if (path[1] == ':' && path[2] == 0)
3005     path = concat (path, ".", (const char *) 0);
3006 #endif
3007   include_paths[include_path_count - 1] = path;
3008 }
3009
3010 static void
3011 adjust_addresses (bfd *abfd ATTRIBUTE_UNUSED,
3012                   asection *section,
3013                   void *arg)
3014 {
3015   if ((section->flags & SEC_DEBUGGING) == 0)
3016     {
3017       bfd_boolean *has_reloc_p = (bfd_boolean *) arg;
3018       section->vma += adjust_section_vma;
3019       if (*has_reloc_p)
3020         section->lma += adjust_section_vma;
3021     }
3022 }
3023
3024 /* Dump selected contents of ABFD.  */
3025
3026 static void
3027 dump_bfd (bfd *abfd)
3028 {
3029   /* If we are adjusting section VMA's, change them all now.  Changing
3030      the BFD information is a hack.  However, we must do it, or
3031      bfd_find_nearest_line will not do the right thing.  */
3032   if (adjust_section_vma != 0)
3033     {
3034       bfd_boolean has_reloc = (abfd->flags & HAS_RELOC);
3035       bfd_map_over_sections (abfd, adjust_addresses, &has_reloc);
3036     }
3037
3038   if (! dump_debugging_tags)
3039     printf (_("\n%s:     file format %s\n"), bfd_get_filename (abfd),
3040             abfd->xvec->name);
3041   if (dump_ar_hdrs)
3042     print_arelt_descr (stdout, abfd, TRUE);
3043   if (dump_file_header)
3044     dump_bfd_header (abfd);
3045   if (dump_private_headers)
3046     dump_bfd_private_header (abfd);
3047   if (! dump_debugging_tags)
3048     putchar ('\n');
3049   if (dump_section_headers)
3050     dump_headers (abfd);
3051
3052   if (dump_symtab
3053       || dump_reloc_info
3054       || disassemble
3055       || dump_debugging
3056       || dump_dwarf_section_info)
3057     syms = slurp_symtab (abfd);
3058   if (dump_dynamic_symtab || dump_dynamic_reloc_info
3059       || (disassemble && bfd_get_dynamic_symtab_upper_bound (abfd) > 0))
3060     dynsyms = slurp_dynamic_symtab (abfd);
3061   if (disassemble)
3062     {
3063       synthcount = bfd_get_synthetic_symtab (abfd, symcount, syms,
3064                                              dynsymcount, dynsyms, &synthsyms);
3065       if (synthcount < 0)
3066         synthcount = 0;
3067     }
3068
3069   if (dump_symtab)
3070     dump_symbols (abfd, FALSE);
3071   if (dump_dynamic_symtab)
3072     dump_symbols (abfd, TRUE);
3073   if (dump_dwarf_section_info)
3074     dump_dwarf (abfd);
3075   if (dump_stab_section_info)
3076     dump_stabs (abfd);
3077   if (dump_reloc_info && ! disassemble)
3078     dump_relocs (abfd);
3079   if (dump_dynamic_reloc_info && ! disassemble)
3080     dump_dynamic_relocs (abfd);
3081   if (dump_section_contents)
3082     dump_data (abfd);
3083   if (disassemble)
3084     disassemble_data (abfd);
3085
3086   if (dump_debugging)
3087     {
3088       void *dhandle;
3089
3090       dhandle = read_debugging_info (abfd, syms, symcount, TRUE);
3091       if (dhandle != NULL)
3092         {
3093           if (!print_debugging_info (stdout, dhandle, abfd, syms,
3094                                      bfd_demangle,
3095                                      dump_debugging_tags ? TRUE : FALSE))
3096             {
3097               non_fatal (_("%s: printing debugging information failed"),
3098                          bfd_get_filename (abfd));
3099               exit_status = 1;
3100             }
3101         }
3102       /* PR 6483: If there was no STABS or IEEE debug
3103          info in the file, try DWARF instead.  */
3104       else if (! dump_dwarf_section_info)
3105         {
3106           dump_dwarf (abfd);
3107         }
3108     }
3109
3110   if (syms)
3111     {
3112       free (syms);
3113       syms = NULL;
3114     }
3115
3116   if (dynsyms)
3117     {
3118       free (dynsyms);
3119       dynsyms = NULL;
3120     }
3121
3122   if (synthsyms)
3123     {
3124       free (synthsyms);
3125       synthsyms = NULL;
3126     }
3127
3128   symcount = 0;
3129   dynsymcount = 0;
3130   synthcount = 0;
3131 }
3132
3133 static void
3134 display_bfd (bfd *abfd)
3135 {
3136   char **matching;
3137
3138   if (bfd_check_format_matches (abfd, bfd_object, &matching))
3139     {
3140       dump_bfd (abfd);
3141       return;
3142     }
3143
3144   if (bfd_get_error () == bfd_error_file_ambiguously_recognized)
3145     {
3146       nonfatal (bfd_get_filename (abfd));
3147       list_matching_formats (matching);
3148       free (matching);
3149       return;
3150     }
3151
3152   if (bfd_get_error () != bfd_error_file_not_recognized)
3153     {
3154       nonfatal (bfd_get_filename (abfd));
3155       return;
3156     }
3157
3158   if (bfd_check_format_matches (abfd, bfd_core, &matching))
3159     {
3160       dump_bfd (abfd);
3161       return;
3162     }
3163
3164   nonfatal (bfd_get_filename (abfd));
3165
3166   if (bfd_get_error () == bfd_error_file_ambiguously_recognized)
3167     {
3168       list_matching_formats (matching);
3169       free (matching);
3170     }
3171 }
3172
3173 static void
3174 display_file (char *filename, char *target)
3175 {
3176   bfd *file;
3177   bfd *arfile = NULL;
3178
3179   if (get_file_size (filename) < 1)
3180     {
3181       exit_status = 1;
3182       return;
3183     }
3184
3185   file = bfd_openr (filename, target);
3186   if (file == NULL)
3187     {
3188       nonfatal (filename);
3189       return;
3190     }
3191
3192   /* If the file is an archive, process all of its elements.  */
3193   if (bfd_check_format (file, bfd_archive))
3194     {
3195       bfd *last_arfile = NULL;
3196
3197       printf (_("In archive %s:\n"), bfd_get_filename (file));
3198       for (;;)
3199         {
3200           bfd_set_error (bfd_error_no_error);
3201
3202           arfile = bfd_openr_next_archived_file (file, arfile);
3203           if (arfile == NULL)
3204             {
3205               if (bfd_get_error () != bfd_error_no_more_archived_files)
3206                 nonfatal (bfd_get_filename (file));
3207               break;
3208             }
3209
3210           display_bfd (arfile);
3211
3212           if (last_arfile != NULL)
3213             bfd_close (last_arfile);
3214           last_arfile = arfile;
3215         }
3216
3217       if (last_arfile != NULL)
3218         bfd_close (last_arfile);
3219     }
3220   else
3221     display_bfd (file);
3222
3223   bfd_close (file);
3224 }
3225 \f
3226 int
3227 main (int argc, char **argv)
3228 {
3229   int c;
3230   char *target = default_target;
3231   bfd_boolean seenflag = FALSE;
3232
3233 #if defined (HAVE_SETLOCALE)
3234 #if defined (HAVE_LC_MESSAGES)
3235   setlocale (LC_MESSAGES, "");
3236 #endif
3237   setlocale (LC_CTYPE, "");
3238 #endif
3239
3240   bindtextdomain (PACKAGE, LOCALEDIR);
3241   textdomain (PACKAGE);
3242
3243   program_name = *argv;
3244   xmalloc_set_program_name (program_name);
3245
3246   START_PROGRESS (program_name, 0);
3247
3248   expandargv (&argc, &argv);
3249
3250   bfd_init ();
3251   set_default_bfd_target ();
3252
3253   while ((c = getopt_long (argc, argv,
3254                            "pib:m:M:VvCdDlfFaHhrRtTxsSI:j:wE:zgeGW::",
3255                            long_options, (int *) 0))
3256          != EOF)
3257     {
3258       switch (c)
3259         {
3260         case 0:
3261           break;                /* We've been given a long option.  */
3262         case 'm':
3263           machine = optarg;
3264           break;
3265         case 'M':
3266           if (disassembler_options)
3267             /* Ignore potential memory leak for now.  */
3268             disassembler_options = concat (disassembler_options, ",",
3269                                            optarg, (const char *) NULL);
3270           else
3271             disassembler_options = optarg;
3272           break;
3273         case 'j':
3274           add_only (optarg);
3275           break;
3276         case 'F':
3277           display_file_offsets = TRUE;
3278           break;
3279         case 'l':
3280           with_line_numbers = TRUE;
3281           break;
3282         case 'b':
3283           target = optarg;
3284           break;
3285         case 'C':
3286           do_demangle = TRUE;
3287           if (optarg != NULL)
3288             {
3289               enum demangling_styles style;
3290
3291               style = cplus_demangle_name_to_style (optarg);
3292               if (style == unknown_demangling)
3293                 fatal (_("unknown demangling style `%s'"),
3294                        optarg);
3295
3296               cplus_demangle_set_style (style);
3297             }
3298           break;
3299         case 'w':
3300           wide_output = TRUE;
3301           break;
3302         case OPTION_ADJUST_VMA:
3303           adjust_section_vma = parse_vma (optarg, "--adjust-vma");
3304           break;
3305         case OPTION_START_ADDRESS:
3306           start_address = parse_vma (optarg, "--start-address");
3307           if ((stop_address != (bfd_vma) -1) && stop_address <= start_address)
3308             fatal (_("error: the start address should be before the end address"));
3309           break;
3310         case OPTION_STOP_ADDRESS:
3311           stop_address = parse_vma (optarg, "--stop-address");
3312           if ((start_address != (bfd_vma) -1) && stop_address <= start_address)
3313             fatal (_("error: the stop address should be after the start address"));
3314           break;
3315         case OPTION_PREFIX:
3316           prefix = optarg;
3317           prefix_length = strlen (prefix);
3318           /* Remove an unnecessary trailing '/' */
3319           while (IS_DIR_SEPARATOR (prefix[prefix_length - 1]))
3320             prefix_length--;
3321           break;
3322         case OPTION_PREFIX_STRIP:
3323           prefix_strip = atoi (optarg);
3324           if (prefix_strip < 0)
3325             fatal (_("error: prefix strip must be non-negative"));
3326           break;
3327         case OPTION_INSN_WIDTH:
3328           insn_width = strtoul (optarg, NULL, 0);
3329           if (insn_width <= 0)
3330             fatal (_("error: instruction width must be positive"));
3331           break;
3332         case 'E':
3333           if (strcmp (optarg, "B") == 0)
3334             endian = BFD_ENDIAN_BIG;
3335           else if (strcmp (optarg, "L") == 0)
3336             endian = BFD_ENDIAN_LITTLE;
3337           else
3338             {
3339               non_fatal (_("unrecognized -E option"));
3340               usage (stderr, 1);
3341             }
3342           break;
3343         case OPTION_ENDIAN:
3344           if (strncmp (optarg, "big", strlen (optarg)) == 0)
3345             endian = BFD_ENDIAN_BIG;
3346           else if (strncmp (optarg, "little", strlen (optarg)) == 0)
3347             endian = BFD_ENDIAN_LITTLE;
3348           else
3349             {
3350               non_fatal (_("unrecognized --endian type `%s'"), optarg);
3351               usage (stderr, 1);
3352             }
3353           break;
3354
3355         case 'f':
3356           dump_file_header = TRUE;
3357           seenflag = TRUE;
3358           break;
3359         case 'i':
3360           formats_info = TRUE;
3361           seenflag = TRUE;
3362           break;
3363         case 'I':
3364           add_include_path (optarg);
3365           break;
3366         case 'p':
3367           dump_private_headers = TRUE;
3368           seenflag = TRUE;
3369           break;
3370         case 'x':
3371           dump_private_headers = TRUE;
3372           dump_symtab = TRUE;
3373           dump_reloc_info = TRUE;
3374           dump_file_header = TRUE;
3375           dump_ar_hdrs = TRUE;
3376           dump_section_headers = TRUE;
3377           seenflag = TRUE;
3378           break;
3379         case 't':
3380           dump_symtab = TRUE;
3381           seenflag = TRUE;
3382           break;
3383         case 'T':
3384           dump_dynamic_symtab = TRUE;
3385           seenflag = TRUE;
3386           break;
3387         case 'd':
3388           disassemble = TRUE;
3389           seenflag = TRUE;
3390           break;
3391         case 'z':
3392           disassemble_zeroes = TRUE;
3393           break;
3394         case 'D':
3395           disassemble = TRUE;
3396           disassemble_all = TRUE;
3397           seenflag = TRUE;
3398           break;
3399         case 'S':
3400           disassemble = TRUE;
3401           with_source_code = TRUE;
3402           seenflag = TRUE;
3403           break;
3404         case 'g':
3405           dump_debugging = 1;
3406           seenflag = TRUE;
3407           break;
3408         case 'e':
3409           dump_debugging = 1;
3410           dump_debugging_tags = 1;
3411           do_demangle = TRUE;
3412           seenflag = TRUE;
3413           break;
3414         case 'W':
3415           dump_dwarf_section_info = TRUE;
3416           seenflag = TRUE;
3417           if (optarg)
3418             dwarf_select_sections_by_letters (optarg);
3419           else
3420             dwarf_select_sections_all ();
3421           break;
3422         case OPTION_DWARF:
3423           dump_dwarf_section_info = TRUE;
3424           seenflag = TRUE;
3425           if (optarg)
3426             dwarf_select_sections_by_names (optarg);
3427           else
3428             dwarf_select_sections_all ();
3429           break;
3430         case 'G':
3431           dump_stab_section_info = TRUE;
3432           seenflag = TRUE;
3433           break;
3434         case 's':
3435           dump_section_contents = TRUE;
3436           seenflag = TRUE;
3437           break;
3438         case 'r':
3439           dump_reloc_info = TRUE;
3440           seenflag = TRUE;
3441           break;
3442         case 'R':
3443           dump_dynamic_reloc_info = TRUE;
3444           seenflag = TRUE;
3445           break;
3446         case 'a':
3447           dump_ar_hdrs = TRUE;
3448           seenflag = TRUE;
3449           break;
3450         case 'h':
3451           dump_section_headers = TRUE;
3452           seenflag = TRUE;
3453           break;
3454         case 'H':
3455           usage (stdout, 0);
3456           seenflag = TRUE;
3457         case 'v':
3458         case 'V':
3459           show_version = TRUE;
3460           seenflag = TRUE;
3461           break;
3462
3463         default:
3464           usage (stderr, 1);
3465         }
3466     }
3467
3468   if (show_version)
3469     print_version ("objdump");
3470
3471   if (!seenflag)
3472     usage (stderr, 2);
3473
3474   if (formats_info)
3475     exit_status = display_info ();
3476   else
3477     {
3478       if (optind == argc)
3479         display_file ("a.out", target);
3480       else
3481         for (; optind < argc;)
3482           display_file (argv[optind++], target);
3483     }
3484
3485   free_only_list ();
3486
3487   END_PROGRESS (program_name);
3488
3489   return exit_status;
3490 }