binutils/objdump.c

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