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