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                     (long int)(section->filepos + (addr_offset + (octets / opb))));
1432           else
1433             printf ("\t...\n");
1434         }
1435       else
1436         {
1437           char buf[50];
1438           int bpc = 0;
1439           int pb = 0;
1440
1441           done_dot = FALSE;
1442
1443           if (with_line_numbers || with_source_code)
1444             show_line (aux->abfd, section, addr_offset);
1445
1446           if (! prefix_addresses)
1447             {
1448               char *s;
1449
1450               bfd_sprintf_vma (aux->abfd, buf, section->vma + addr_offset);
1451               for (s = buf + skip_addr_chars; *s == '0'; s++)
1452                 *s = ' ';
1453               if (*s == '\0')
1454                 *--s = '0';
1455               printf ("%s:\t", buf + skip_addr_chars);
1456             }
1457           else
1458             {
1459               aux->require_sec = TRUE;
1460               objdump_print_address (section->vma + addr_offset, info);
1461               aux->require_sec = FALSE;
1462               putchar (' ');
1463             }
1464
1465           if (insns)
1466             {
1467               sfile.pos = 0;
1468               info->fprintf_func = (fprintf_ftype) objdump_sprintf;
1469               info->stream = &sfile;
1470               info->bytes_per_line = 0;
1471               info->bytes_per_chunk = 0;
1472               info->flags = 0;
1473
1474               if (info->disassembler_needs_relocs
1475                   && (bfd_get_file_flags (aux->abfd) & EXEC_P) == 0
1476                   && (bfd_get_file_flags (aux->abfd) & DYNAMIC) == 0
1477                   && *relppp < relppend)
1478                 {
1479                   bfd_signed_vma distance_to_rel;
1480
1481                   distance_to_rel = (**relppp)->address
1482                     - (rel_offset + addr_offset);
1483
1484                   /* Check to see if the current reloc is associated with
1485                      the instruction that we are about to disassemble.  */
1486                   if (distance_to_rel == 0
1487                       /* FIXME: This is wrong.  We are trying to catch
1488                          relocs that are addressed part way through the
1489                          current instruction, as might happen with a packed
1490                          VLIW instruction.  Unfortunately we do not know the
1491                          length of the current instruction since we have not
1492                          disassembled it yet.  Instead we take a guess based
1493                          upon the length of the previous instruction.  The
1494                          proper solution is to have a new target-specific
1495                          disassembler function which just returns the length
1496                          of an instruction at a given address without trying
1497                          to display its disassembly. */
1498                       || (distance_to_rel > 0
1499                           && distance_to_rel < (bfd_signed_vma) (previous_octets/ opb)))
1500                     {
1501                       info->flags = INSN_HAS_RELOC;
1502                       aux->reloc = **relppp;
1503                     }
1504                   else
1505                     aux->reloc = NULL;
1506                 }
1507
1508               octets = (*disassemble_fn) (section->vma + addr_offset, info);
1509               info->fprintf_func = (fprintf_ftype) fprintf;
1510               info->stream = stdout;
1511               if (info->bytes_per_line != 0)
1512                 octets_per_line = info->bytes_per_line;
1513               if (octets < 0)
1514                 {
1515                   if (sfile.pos)
1516                     printf ("%s\n", sfile.buffer);
1517                   break;
1518                 }
1519             }
1520           else
1521             {
1522               bfd_vma j;
1523
1524               octets = octets_per_line;
1525               if (addr_offset + octets / opb > stop_offset)
1526                 octets = (stop_offset - addr_offset) * opb;
1527
1528               for (j = addr_offset * opb; j < addr_offset * opb + octets; ++j)
1529                 {
1530                   if (ISPRINT (data[j]))
1531                     buf[j - addr_offset * opb] = data[j];
1532                   else
1533                     buf[j - addr_offset * opb] = '.';
1534                 }
1535               buf[j - addr_offset * opb] = '\0';
1536             }
1537
1538           if (prefix_addresses
1539               ? show_raw_insn > 0
1540               : show_raw_insn >= 0)
1541             {
1542               bfd_vma j;
1543
1544               /* If ! prefix_addresses and ! wide_output, we print
1545                  octets_per_line octets per line.  */
1546               pb = octets;
1547               if (pb > octets_per_line && ! prefix_addresses && ! wide_output)
1548                 pb = octets_per_line;
1549
1550               if (info->bytes_per_chunk)
1551                 bpc = info->bytes_per_chunk;
1552               else
1553                 bpc = 1;
1554
1555               for (j = addr_offset * opb; j < addr_offset * opb + pb; j += bpc)
1556                 {
1557                   int k;
1558
1559                   if (bpc > 1 && info->display_endian == BFD_ENDIAN_LITTLE)
1560                     {
1561                       for (k = bpc - 1; k >= 0; k--)
1562                         printf ("%02x", (unsigned) data[j + k]);
1563                       putchar (' ');
1564                     }
1565                   else
1566                     {
1567                       for (k = 0; k < bpc; k++)
1568                         printf ("%02x", (unsigned) data[j + k]);
1569                       putchar (' ');
1570                     }
1571                 }
1572
1573               for (; pb < octets_per_line; pb += bpc)
1574                 {
1575                   int k;
1576
1577                   for (k = 0; k < bpc; k++)
1578                     printf ("  ");
1579                   putchar (' ');
1580                 }
1581
1582               /* Separate raw data from instruction by extra space.  */
1583               if (insns)
1584                 putchar ('\t');
1585               else
1586                 printf ("    ");
1587             }
1588
1589           if (! insns)
1590             printf ("%s", buf);
1591           else if (sfile.pos)
1592             printf ("%s", sfile.buffer);
1593
1594           if (prefix_addresses
1595               ? show_raw_insn > 0
1596               : show_raw_insn >= 0)
1597             {
1598               while (pb < octets)
1599                 {
1600                   bfd_vma j;
1601                   char *s;
1602
1603                   putchar ('\n');
1604                   j = addr_offset * opb + pb;
1605
1606                   bfd_sprintf_vma (aux->abfd, buf, section->vma + j / opb);
1607                   for (s = buf + skip_addr_chars; *s == '0'; s++)
1608                     *s = ' ';
1609                   if (*s == '\0')
1610                     *--s = '0';
1611                   printf ("%s:\t", buf + skip_addr_chars);
1612
1613                   pb += octets_per_line;
1614                   if (pb > octets)
1615                     pb = octets;
1616                   for (; j < addr_offset * opb + pb; j += bpc)
1617                     {
1618                       int k;
1619
1620                       if (bpc > 1 && info->display_endian == BFD_ENDIAN_LITTLE)
1621                         {
1622                           for (k = bpc - 1; k >= 0; k--)
1623                             printf ("%02x", (unsigned) data[j + k]);
1624                           putchar (' ');
1625                         }
1626                       else
1627                         {
1628                           for (k = 0; k < bpc; k++)
1629                             printf ("%02x", (unsigned) data[j + k]);
1630                           putchar (' ');
1631                         }
1632                     }
1633                 }
1634             }
1635
1636           if (!wide_output)
1637             putchar ('\n');
1638           else
1639             need_nl = TRUE;
1640         }
1641
1642       while ((*relppp) < relppend
1643              && (**relppp)->address < rel_offset + addr_offset + octets / opb)
1644         {
1645           if (dump_reloc_info || dump_dynamic_reloc_info)
1646             {
1647               arelent *q;
1648
1649               q = **relppp;
1650
1651               if (wide_output)
1652                 putchar ('\t');
1653               else
1654                 printf ("\t\t\t");
1655
1656               objdump_print_value (section->vma - rel_offset + q->address,
1657                                    info, TRUE);
1658
1659               if (q->howto == NULL)
1660                 printf (": *unknown*\t");
1661               else if (q->howto->name)
1662                 printf (": %s\t", q->howto->name);
1663               else
1664                 printf (": %d\t", q->howto->type);
1665
1666               if (q->sym_ptr_ptr == NULL || *q->sym_ptr_ptr == NULL)
1667                 printf ("*unknown*");
1668               else
1669                 {
1670                   const char *sym_name;
1671
1672                   sym_name = bfd_asymbol_name (*q->sym_ptr_ptr);
1673                   if (sym_name != NULL && *sym_name != '\0')
1674                     objdump_print_symname (aux->abfd, info, *q->sym_ptr_ptr);
1675                   else
1676                     {
1677                       asection *sym_sec;
1678
1679                       sym_sec = bfd_get_section (*q->sym_ptr_ptr);
1680                       sym_name = bfd_get_section_name (aux->abfd, sym_sec);
1681                       if (sym_name == NULL || *sym_name == '\0')
1682                         sym_name = "*unknown*";
1683                       printf ("%s", sym_name);
1684                     }
1685                 }
1686
1687               if (q->addend)
1688                 {
1689                   printf ("+0x");
1690                   objdump_print_value (q->addend, info, TRUE);
1691                 }
1692
1693               printf ("\n");
1694               need_nl = FALSE;
1695             }
1696           ++(*relppp);
1697         }
1698
1699       if (need_nl)
1700         printf ("\n");
1701
1702       addr_offset += octets / opb;
1703     }
1704
1705   free (sfile.buffer);
1706 }
1707
1708 static void
1709 disassemble_section (bfd *abfd, asection *section, void *info)
1710 {
1711   struct disassemble_info *    pinfo = (struct disassemble_info *) info;
1712   struct objdump_disasm_info * paux;
1713   unsigned int                 opb = pinfo->octets_per_byte;
1714   bfd_byte *                   data = NULL;
1715   bfd_size_type                datasize = 0;
1716   arelent **                   rel_pp = NULL;
1717   arelent **                   rel_ppstart = NULL;
1718   arelent **                   rel_ppend;
1719   unsigned long                stop_offset;
1720   asymbol *                    sym = NULL;
1721   long                         place = 0;
1722   long                         rel_count;
1723   bfd_vma                      rel_offset;
1724   unsigned long                addr_offset;
1725
1726   /* Sections that do not contain machine
1727      code are not normally disassembled.  */
1728   if (! disassemble_all
1729       && only == NULL
1730       && ((section->flags & (SEC_CODE | SEC_HAS_CONTENTS))
1731           != (SEC_CODE | SEC_HAS_CONTENTS)))
1732     return;
1733
1734   if (! process_section_p (section))
1735     return;
1736
1737   datasize = bfd_get_section_size (section);
1738   if (datasize == 0)
1739     return;
1740
1741   /* Decide which set of relocs to use.  Load them if necessary.  */
1742   paux = (struct objdump_disasm_info *) pinfo->application_data;
1743   if (paux->dynrelbuf)
1744     {
1745       rel_pp = paux->dynrelbuf;
1746       rel_count = paux->dynrelcount;
1747       /* Dynamic reloc addresses are absolute, non-dynamic are section
1748          relative.  REL_OFFSET specifies the reloc address corresponding
1749          to the start of this section.  */
1750       rel_offset = section->vma;
1751     }
1752   else
1753     {
1754       rel_count = 0;
1755       rel_pp = NULL;
1756       rel_offset = 0;
1757
1758       if ((section->flags & SEC_RELOC) != 0
1759           && (dump_reloc_info || pinfo->disassembler_needs_relocs))
1760         {
1761           long relsize;
1762
1763           relsize = bfd_get_reloc_upper_bound (abfd, section);
1764           if (relsize < 0)
1765             bfd_fatal (bfd_get_filename (abfd));
1766
1767           if (relsize > 0)
1768             {
1769               rel_ppstart = rel_pp = xmalloc (relsize);
1770               rel_count = bfd_canonicalize_reloc (abfd, section, rel_pp, syms);
1771               if (rel_count < 0)
1772                 bfd_fatal (bfd_get_filename (abfd));
1773
1774               /* Sort the relocs by address.  */
1775               qsort (rel_pp, rel_count, sizeof (arelent *), compare_relocs);
1776             }
1777         }
1778
1779     }
1780   rel_ppend = rel_pp + rel_count;
1781
1782   data = xmalloc (datasize);
1783
1784   bfd_get_section_contents (abfd, section, data, 0, datasize);
1785
1786   paux->sec = section;
1787   pinfo->buffer = data;
1788   pinfo->buffer_vma = section->vma;
1789   pinfo->buffer_length = datasize;
1790   pinfo->section = section;
1791
1792   if (start_address == (bfd_vma) -1
1793       || start_address < pinfo->buffer_vma)
1794     addr_offset = 0;
1795   else
1796     addr_offset = start_address - pinfo->buffer_vma;
1797
1798   if (stop_address == (bfd_vma) -1)
1799     stop_offset = datasize / opb;
1800   else
1801     {
1802       if (stop_address < pinfo->buffer_vma)
1803         stop_offset = 0;
1804       else
1805         stop_offset = stop_address - pinfo->buffer_vma;
1806       if (stop_offset > pinfo->buffer_length / opb)
1807         stop_offset = pinfo->buffer_length / opb;
1808     }
1809
1810   /* Skip over the relocs belonging to addresses below the
1811      start address.  */
1812   while (rel_pp < rel_ppend
1813          && (*rel_pp)->address < rel_offset + addr_offset)
1814     ++rel_pp;
1815
1816   if (addr_offset < stop_offset)
1817     printf (_("\nDisassembly of section %s:\n"), section->name);
1818
1819   /* Find the nearest symbol forwards from our current position.  */
1820   paux->require_sec = TRUE;
1821   sym = find_symbol_for_address (section->vma + addr_offset, info, &place);
1822   paux->require_sec = FALSE;
1823
1824   /* Disassemble a block of instructions up to the address associated with
1825      the symbol we have just found.  Then print the symbol and find the
1826      next symbol on.  Repeat until we have disassembled the entire section
1827      or we have reached the end of the address range we are interested in.  */
1828   while (addr_offset < stop_offset)
1829     {
1830       bfd_vma addr;
1831       asymbol *nextsym;
1832       unsigned long nextstop_offset;
1833       bfd_boolean insns;
1834
1835       addr = section->vma + addr_offset;
1836
1837       if (sym != NULL && bfd_asymbol_value (sym) <= addr)
1838         {
1839           int x;
1840
1841           for (x = place;
1842                (x < sorted_symcount
1843                 && (bfd_asymbol_value (sorted_syms[x]) <= addr));
1844                ++x)
1845             continue;
1846
1847           pinfo->symbols = sorted_syms + place;
1848           pinfo->num_symbols = x - place;
1849           pinfo->symtab_pos = place;
1850         }
1851       else
1852         {
1853           pinfo->symbols = NULL;
1854           pinfo->num_symbols = 0;
1855           pinfo->symtab_pos = -1;
1856         }
1857
1858       if (! prefix_addresses)
1859         {
1860           pinfo->fprintf_func (pinfo->stream, "\n");
1861           objdump_print_addr_with_sym (abfd, section, sym, addr,
1862                                        pinfo, FALSE);
1863           pinfo->fprintf_func (pinfo->stream, ":\n");
1864         }
1865
1866       if (sym != NULL && bfd_asymbol_value (sym) > addr)
1867         nextsym = sym;
1868       else if (sym == NULL)
1869         nextsym = NULL;
1870       else
1871         {
1872 #define is_valid_next_sym(SYM) \
1873   ((SYM)->section == section \
1874    && (bfd_asymbol_value (SYM) > bfd_asymbol_value (sym)) \
1875    && pinfo->symbol_is_valid (SYM, pinfo))
1876
1877           /* Search forward for the next appropriate symbol in
1878              SECTION.  Note that all the symbols are sorted
1879              together into one big array, and that some sections
1880              may have overlapping addresses.  */
1881           while (place < sorted_symcount
1882                  && ! is_valid_next_sym (sorted_syms [place]))
1883             ++place;
1884
1885           if (place >= sorted_symcount)
1886             nextsym = NULL;
1887           else
1888             nextsym = sorted_syms[place];
1889         }
1890
1891       if (sym != NULL && bfd_asymbol_value (sym) > addr)
1892         nextstop_offset = bfd_asymbol_value (sym) - section->vma;
1893       else if (nextsym == NULL)
1894         nextstop_offset = stop_offset;
1895       else
1896         nextstop_offset = bfd_asymbol_value (nextsym) - section->vma;
1897
1898       if (nextstop_offset > stop_offset)
1899         nextstop_offset = stop_offset;
1900
1901       /* If a symbol is explicitly marked as being an object
1902          rather than a function, just dump the bytes without
1903          disassembling them.  */
1904       if (disassemble_all
1905           || sym == NULL
1906           || bfd_asymbol_value (sym) > addr
1907           || ((sym->flags & BSF_OBJECT) == 0
1908               && (strstr (bfd_asymbol_name (sym), "gnu_compiled")
1909                   == NULL)
1910               && (strstr (bfd_asymbol_name (sym), "gcc2_compiled")
1911                   == NULL))
1912           || (sym->flags & BSF_FUNCTION) != 0)
1913         insns = TRUE;
1914       else
1915         insns = FALSE;
1916
1917       disassemble_bytes (pinfo, paux->disassemble_fn, insns, data,
1918                          addr_offset, nextstop_offset,
1919                          rel_offset, &rel_pp, rel_ppend);
1920
1921       addr_offset = nextstop_offset;
1922       sym = nextsym;
1923     }
1924
1925   free (data);
1926
1927   if (rel_ppstart != NULL)
1928     free (rel_ppstart);
1929 }
1930
1931 /* Disassemble the contents of an object file.  */
1932
1933 static void
1934 disassemble_data (bfd *abfd)
1935 {
1936   struct disassemble_info disasm_info;
1937   struct objdump_disasm_info aux;
1938   long i;
1939
1940   print_files = NULL;
1941   prev_functionname = NULL;
1942   prev_line = -1;
1943
1944   /* We make a copy of syms to sort.  We don't want to sort syms
1945      because that will screw up the relocs.  */
1946   sorted_symcount = symcount ? symcount : dynsymcount;
1947   sorted_syms = xmalloc ((sorted_symcount + synthcount) * sizeof (asymbol *));
1948   memcpy (sorted_syms, symcount ? syms : dynsyms,
1949           sorted_symcount * sizeof (asymbol *));
1950
1951   sorted_symcount = remove_useless_symbols (sorted_syms, sorted_symcount);
1952
1953   for (i = 0; i < synthcount; ++i)
1954     {
1955       sorted_syms[sorted_symcount] = synthsyms + i;
1956       ++sorted_symcount;
1957     }
1958
1959   /* Sort the symbols into section and symbol order.  */
1960   qsort (sorted_syms, sorted_symcount, sizeof (asymbol *), compare_symbols);
1961
1962   init_disassemble_info (&disasm_info, stdout, (fprintf_ftype) fprintf);
1963
1964   disasm_info.application_data = (void *) &aux;
1965   aux.abfd = abfd;
1966   aux.require_sec = FALSE;
1967   aux.dynrelbuf = NULL;
1968   aux.dynrelcount = 0;
1969   aux.reloc = NULL;
1970
1971   disasm_info.print_address_func = objdump_print_address;
1972   disasm_info.symbol_at_address_func = objdump_symbol_at_address;
1973
1974   if (machine != NULL)
1975     {
1976       const bfd_arch_info_type *info = bfd_scan_arch (machine);
1977
1978       if (info == NULL)
1979         fatal (_("Can't use supplied machine %s"), machine);
1980
1981       abfd->arch_info = info;
1982     }
1983
1984   if (endian != BFD_ENDIAN_UNKNOWN)
1985     {
1986       struct bfd_target *xvec;
1987
1988       xvec = xmalloc (sizeof (struct bfd_target));
1989       memcpy (xvec, abfd->xvec, sizeof (struct bfd_target));
1990       xvec->byteorder = endian;
1991       abfd->xvec = xvec;
1992     }
1993
1994   /* Use libopcodes to locate a suitable disassembler.  */
1995   aux.disassemble_fn = disassembler (abfd);
1996   if (!aux.disassemble_fn)
1997     {
1998       non_fatal (_("Can't disassemble for architecture %s\n"),
1999                  bfd_printable_arch_mach (bfd_get_arch (abfd), 0));
2000       exit_status = 1;
2001       return;
2002     }
2003
2004   disasm_info.flavour = bfd_get_flavour (abfd);
2005   disasm_info.arch = bfd_get_arch (abfd);
2006   disasm_info.mach = bfd_get_mach (abfd);
2007   disasm_info.disassembler_options = disassembler_options;
2008   disasm_info.octets_per_byte = bfd_octets_per_byte (abfd);
2009   disasm_info.skip_zeroes = DEFAULT_SKIP_ZEROES;
2010   disasm_info.skip_zeroes_at_end = DEFAULT_SKIP_ZEROES_AT_END;
2011   disasm_info.disassembler_needs_relocs = FALSE;
2012
2013   if (bfd_big_endian (abfd))
2014     disasm_info.display_endian = disasm_info.endian = BFD_ENDIAN_BIG;
2015   else if (bfd_little_endian (abfd))
2016     disasm_info.display_endian = disasm_info.endian = BFD_ENDIAN_LITTLE;
2017   else
2018     /* ??? Aborting here seems too drastic.  We could default to big or little
2019        instead.  */
2020     disasm_info.endian = BFD_ENDIAN_UNKNOWN;
2021
2022   /* Allow the target to customize the info structure.  */
2023   disassemble_init_for_target (& disasm_info);
2024
2025   /* Pre-load the dynamic relocs if we are going
2026      to be dumping them along with the disassembly.  */
2027   if (dump_dynamic_reloc_info)
2028     {
2029       long relsize = bfd_get_dynamic_reloc_upper_bound (abfd);
2030
2031       if (relsize < 0)
2032         bfd_fatal (bfd_get_filename (abfd));
2033
2034       if (relsize > 0)
2035         {
2036           aux.dynrelbuf = xmalloc (relsize);
2037           aux.dynrelcount = bfd_canonicalize_dynamic_reloc (abfd,
2038                                                             aux.dynrelbuf,
2039                                                             dynsyms);
2040           if (aux.dynrelcount < 0)
2041             bfd_fatal (bfd_get_filename (abfd));
2042
2043           /* Sort the relocs by address.  */
2044           qsort (aux.dynrelbuf, aux.dynrelcount, sizeof (arelent *),
2045                  compare_relocs);
2046         }
2047     }
2048   disasm_info.symtab = sorted_syms;
2049   disasm_info.symtab_size = sorted_symcount;
2050
2051   bfd_map_over_sections (abfd, disassemble_section, & disasm_info);
2052
2053   if (aux.dynrelbuf != NULL)
2054     free (aux.dynrelbuf);
2055   free (sorted_syms);
2056 }
2057 \f
2058 int
2059 load_debug_section (enum dwarf_section_display_enum debug, void *file)
2060 {
2061   struct dwarf_section *section = &debug_displays [debug].section;
2062   bfd *abfd = file;
2063   asection *sec;
2064   bfd_boolean ret;
2065   int section_is_compressed;
2066
2067   /* If it is already loaded, do nothing.  */
2068   if (section->start != NULL)
2069     return 1;
2070
2071   /* Locate the debug section.  */
2072   sec = bfd_get_section_by_name (abfd, section->uncompressed_name);
2073   if (sec != NULL)
2074     section->name = section->uncompressed_name;
2075   else
2076     {
2077       sec = bfd_get_section_by_name (abfd, section->compressed_name);
2078       if (sec != NULL)
2079         section->name = section->compressed_name;
2080     }
2081   if (sec == NULL)
2082     return 0;
2083   section_is_compressed = section->name == section->compressed_name;
2084
2085   /* Compute a bias to be added to offsets found within the DWARF debug
2086      information.  These offsets are meant to be relative to the start of
2087      the dwarf section, and hence the bias should be 0.  For MACH-O however
2088      a dwarf section is really just a region of a much larger section and so
2089      the bias is the address of the start of that area within the larger
2090      section.  This test is important for PE and COFF based targets which
2091      use DWARF debug information, since unlike ELF, they do not allow the
2092      dwarf sections to be placed at address 0.  */
2093   if (bfd_get_flavour (abfd) == bfd_target_mach_o_flavour)
2094     section->address = bfd_get_section_vma (abfd, sec);
2095   else
2096     section->address = 0;
2097
2098   section->size = bfd_get_section_size (sec);
2099   section->start = xmalloc (section->size);
2100
2101   if (is_relocatable && debug_displays [debug].relocate)
2102     ret = bfd_simple_get_relocated_section_contents (abfd,
2103                                                      sec,
2104                                                      section->start,
2105                                                      syms) != NULL;
2106   else
2107     ret = bfd_get_section_contents (abfd, sec, section->start, 0,
2108                                     section->size);
2109
2110   if (! ret)
2111     {
2112       free_debug_section (debug);
2113       printf (_("\nCan't get contents for section '%s'.\n"),
2114               section->name);
2115       return 0;
2116     }
2117
2118   if (section_is_compressed)
2119     {
2120       bfd_size_type size = section->size;
2121       if (! bfd_uncompress_section_contents (&section->start, &size))
2122         {
2123           free_debug_section (debug);
2124           printf (_("\nCan't uncompress section '%s'.\n"), section->name);
2125           return 0;
2126         }
2127       section->size = size;
2128     }
2129
2130   return ret;
2131 }
2132
2133 void
2134 free_debug_section (enum dwarf_section_display_enum debug)
2135 {
2136   struct dwarf_section *section = &debug_displays [debug].section;
2137
2138   if (section->start == NULL)
2139     return;
2140
2141   free ((char *) section->start);
2142   section->start = NULL;
2143   section->address = 0;
2144   section->size = 0;
2145 }
2146
2147 static void
2148 dump_dwarf_section (bfd *abfd, asection *section,
2149                     void *arg ATTRIBUTE_UNUSED)
2150 {
2151   const char *name = bfd_get_section_name (abfd, section);
2152   const char *match;
2153   enum dwarf_section_display_enum i;
2154
2155   if (CONST_STRNEQ (name, ".gnu.linkonce.wi."))
2156     match = ".debug_info";
2157   else
2158     match = name;
2159
2160   for (i = 0; i < max; i++)
2161     if (strcmp (debug_displays [i].section.uncompressed_name, match) == 0
2162         || strcmp (debug_displays [i].section.compressed_name, match) == 0)
2163       {
2164         if (!debug_displays [i].eh_frame)
2165           {
2166             struct dwarf_section *sec = &debug_displays [i].section;
2167
2168             if (load_debug_section (i, abfd))
2169               {
2170                 debug_displays [i].display (sec, abfd);
2171
2172                 if (i != info && i != abbrev)
2173                   free_debug_section (i);
2174               }
2175           }
2176         break;
2177       }
2178 }
2179
2180 static const char *mach_o_uncompressed_dwarf_sections [] = {
2181   "LC_SEGMENT.__DWARFA.__debug_abbrev",         /* .debug_abbrev */
2182   "LC_SEGMENT.__DWARFA.__debug_aranges",        /* .debug_aranges */
2183   "LC_SEGMENT.__DWARFA.__debug_frame",          /* .debug_frame */
2184   "LC_SEGMENT.__DWARFA.__debug_info",           /* .debug_info */
2185   "LC_SEGMENT.__DWARFA.__debug_line",           /* .debug_line */
2186   "LC_SEGMENT.__DWARFA.__debug_pubnames",       /* .debug_pubnames */
2187   ".eh_frame",                                  /* .eh_frame */
2188   "LC_SEGMENT.__DWARFA.__debug_macinfo",        /* .debug_macinfo */
2189   "LC_SEGMENT.__DWARFA.__debug_str",            /* .debug_str */
2190   "LC_SEGMENT.__DWARFA.__debug_loc",            /* .debug_loc */
2191   "LC_SEGMENT.__DWARFA.__debug_pubtypes",       /* .debug_pubtypes */
2192   "LC_SEGMENT.__DWARFA.__debug_ranges",         /* .debug_ranges */
2193   "LC_SEGMENT.__DWARFA.__debug_static_func",    /* .debug_static_func */
2194   "LC_SEGMENT.__DWARFA.__debug_static_vars",    /* .debug_static_vars */
2195   "LC_SEGMENT.__DWARFA.__debug_types",          /* .debug_types */
2196   "LC_SEGMENT.__DWARFA.__debug_weaknames"       /* .debug_weaknames */
2197 };
2198
2199 static const char *mach_o_compressed_dwarf_sections [] = {
2200   "LC_SEGMENT.__DWARFA.__zdebug_abbrev",        /* .zdebug_abbrev */
2201   "LC_SEGMENT.__DWARFA.__zdebug_aranges",       /* .zdebug_aranges */
2202   "LC_SEGMENT.__DWARFA.__zdebug_frame",         /* .zdebug_frame */
2203   "LC_SEGMENT.__DWARFA.__zdebug_info",          /* .zdebug_info */
2204   "LC_SEGMENT.__DWARFA.__zdebug_line",          /* .zdebug_line */
2205   "LC_SEGMENT.__DWARFA.__zdebug_pubnames",      /* .zdebug_pubnames */
2206   ".eh_frame",                                  /* .eh_frame */
2207   "LC_SEGMENT.__DWARFA.__zdebug_macinfo",       /* .zdebug_macinfo */
2208   "LC_SEGMENT.__DWARFA.__zdebug_str",           /* .zdebug_str */
2209   "LC_SEGMENT.__DWARFA.__zdebug_loc",           /* .zdebug_loc */
2210   "LC_SEGMENT.__DWARFA.__zdebug_pubtypes",      /* .zdebug_pubtypes */
2211   "LC_SEGMENT.__DWARFA.__zdebug_ranges",        /* .zdebug_ranges */
2212   "LC_SEGMENT.__DWARFA.__zdebug_static_func",   /* .zdebug_static_func */
2213   "LC_SEGMENT.__DWARFA.__zdebug_static_vars",   /* .zdebug_static_vars */
2214   "LC_SEGMENT.__DWARFA.__zdebug_types",         /* .zdebug_types */
2215   "LC_SEGMENT.__DWARFA.__zdebug_weaknames"      /* .zdebug_weaknames */
2216 };
2217
2218 static const char *generic_uncompressed_dwarf_sections [max];
2219 static const char *generic_compressed_dwarf_sections [max];
2220
2221 static void
2222 check_mach_o_dwarf (bfd *abfd)
2223 {
2224   static enum bfd_flavour old_flavour = bfd_target_unknown_flavour;
2225   enum bfd_flavour current_flavour = bfd_get_flavour (abfd);
2226   enum dwarf_section_display_enum i;
2227
2228   if (generic_uncompressed_dwarf_sections [0] == NULL)
2229     for (i = 0; i < max; i++)
2230       {
2231         generic_uncompressed_dwarf_sections [i]
2232             = debug_displays[i].section.uncompressed_name;
2233         generic_compressed_dwarf_sections [i]
2234             = debug_displays[i].section.compressed_name;
2235       }
2236
2237   if (old_flavour != current_flavour)
2238     {
2239       if (current_flavour == bfd_target_mach_o_flavour)
2240         for (i = 0; i < max; i++)
2241           {
2242             debug_displays[i].section.uncompressed_name
2243                 = mach_o_uncompressed_dwarf_sections [i];
2244             debug_displays[i].section.compressed_name
2245                 = mach_o_compressed_dwarf_sections [i];
2246           }
2247       else if (old_flavour == bfd_target_mach_o_flavour)
2248         for (i = 0; i < max; i++)
2249           {
2250             debug_displays[i].section.uncompressed_name
2251                 = generic_uncompressed_dwarf_sections [i];
2252             debug_displays[i].section.compressed_name
2253                 = generic_compressed_dwarf_sections [i];
2254           }
2255
2256       old_flavour = current_flavour;
2257     }
2258 }
2259
2260 /* Dump the dwarf debugging information.  */
2261
2262 static void
2263 dump_dwarf (bfd *abfd)
2264 {
2265   is_relocatable = (abfd->flags & (EXEC_P | DYNAMIC)) == 0;
2266
2267   /* FIXME: bfd_get_arch_size may return -1.  We assume that 64bit
2268      targets will return 64.  */
2269   eh_addr_size = bfd_get_arch_size (abfd) == 64 ? 8 : 4;
2270
2271   if (bfd_big_endian (abfd))
2272     byte_get = byte_get_big_endian;
2273   else if (bfd_little_endian (abfd))
2274     byte_get = byte_get_little_endian;
2275   else
2276     abort ();
2277
2278   check_mach_o_dwarf (abfd);
2279
2280   if (bfd_get_flavour (abfd) == bfd_target_elf_flavour)
2281     {
2282       const struct elf_backend_data *bed = get_elf_backend_data (abfd);
2283       init_dwarf_regnames (bed->elf_machine_code);
2284     }
2285
2286   bfd_map_over_sections (abfd, dump_dwarf_section, NULL);
2287
2288   free_debug_memory ();
2289 }
2290 \f
2291 /* Read ABFD's stabs section STABSECT_NAME, and return a pointer to
2292    it.  Return NULL on failure.   */
2293
2294 static char *
2295 read_section_stabs (bfd *abfd, const char *sect_name, bfd_size_type *size_ptr)
2296 {
2297   asection *stabsect;
2298   bfd_size_type size;
2299   char *contents;
2300
2301   stabsect = bfd_get_section_by_name (abfd, sect_name);
2302   if (stabsect == NULL)
2303     {
2304       printf (_("No %s section present\n\n"), sect_name);
2305       return FALSE;
2306     }
2307
2308   size = bfd_section_size (abfd, stabsect);
2309   contents  = xmalloc (size);
2310
2311   if (! bfd_get_section_contents (abfd, stabsect, contents, 0, size))
2312     {
2313       non_fatal (_("Reading %s section of %s failed: %s"),
2314                  sect_name, bfd_get_filename (abfd),
2315                  bfd_errmsg (bfd_get_error ()));
2316       free (contents);
2317       exit_status = 1;
2318       return NULL;
2319     }
2320
2321   *size_ptr = size;
2322
2323   return contents;
2324 }
2325
2326 /* Stabs entries use a 12 byte format:
2327      4 byte string table index
2328      1 byte stab type
2329      1 byte stab other field
2330      2 byte stab desc field
2331      4 byte stab value
2332    FIXME: This will have to change for a 64 bit object format.  */
2333
2334 #define STRDXOFF  (0)
2335 #define TYPEOFF   (4)
2336 #define OTHEROFF  (5)
2337 #define DESCOFF   (6)
2338 #define VALOFF    (8)
2339 #define STABSIZE (12)
2340
2341 /* Print ABFD's stabs section STABSECT_NAME (in `stabs'),
2342    using string table section STRSECT_NAME (in `strtab').  */
2343
2344 static void
2345 print_section_stabs (bfd *abfd,
2346                      const char *stabsect_name,
2347                      unsigned *string_offset_ptr)
2348 {
2349   int i;
2350   unsigned file_string_table_offset = 0;
2351   unsigned next_file_string_table_offset = *string_offset_ptr;
2352   bfd_byte *stabp, *stabs_end;
2353
2354   stabp = stabs;
2355   stabs_end = stabp + stab_size;
2356
2357   printf (_("Contents of %s section:\n\n"), stabsect_name);
2358   printf ("Symnum n_type n_othr n_desc n_value  n_strx String\n");
2359
2360   /* Loop through all symbols and print them.
2361
2362      We start the index at -1 because there is a dummy symbol on
2363      the front of stabs-in-{coff,elf} sections that supplies sizes.  */
2364   for (i = -1; stabp < stabs_end; stabp += STABSIZE, i++)
2365     {
2366       const char *name;
2367       unsigned long strx;
2368       unsigned char type, other;
2369       unsigned short desc;
2370       bfd_vma value;
2371
2372       strx = bfd_h_get_32 (abfd, stabp + STRDXOFF);
2373       type = bfd_h_get_8 (abfd, stabp + TYPEOFF);
2374       other = bfd_h_get_8 (abfd, stabp + OTHEROFF);
2375       desc = bfd_h_get_16 (abfd, stabp + DESCOFF);
2376       value = bfd_h_get_32 (abfd, stabp + VALOFF);
2377
2378       printf ("\n%-6d ", i);
2379       /* Either print the stab name, or, if unnamed, print its number
2380          again (makes consistent formatting for tools like awk).  */
2381       name = bfd_get_stab_name (type);
2382       if (name != NULL)
2383         printf ("%-6s", name);
2384       else if (type == N_UNDF)
2385         printf ("HdrSym");
2386       else
2387         printf ("%-6d", type);
2388       printf (" %-6d %-6d ", other, desc);
2389       bfd_printf_vma (abfd, value);
2390       printf (" %-6lu", strx);
2391
2392       /* Symbols with type == 0 (N_UNDF) specify the length of the
2393          string table associated with this file.  We use that info
2394          to know how to relocate the *next* file's string table indices.  */
2395       if (type == N_UNDF)
2396         {
2397           file_string_table_offset = next_file_string_table_offset;
2398           next_file_string_table_offset += value;
2399         }
2400       else
2401         {
2402           /* Using the (possibly updated) string table offset, print the
2403              string (if any) associated with this symbol.  */
2404           if ((strx + file_string_table_offset) < stabstr_size)
2405             printf (" %s", &strtab[strx + file_string_table_offset]);
2406           else
2407             printf (" *");
2408         }
2409     }
2410   printf ("\n\n");
2411   *string_offset_ptr = next_file_string_table_offset;
2412 }
2413
2414 typedef struct
2415 {
2416   const char * section_name;
2417   const char * string_section_name;
2418   unsigned string_offset;
2419 }
2420 stab_section_names;
2421
2422 static void
2423 find_stabs_section (bfd *abfd, asection *section, void *names)
2424 {
2425   int len;
2426   stab_section_names * sought = (stab_section_names *) names;
2427
2428   /* Check for section names for which stabsect_name is a prefix, to
2429      handle .stab.N, etc.  */
2430   len = strlen (sought->section_name);
2431
2432   /* If the prefix matches, and the files section name ends with a
2433      nul or a digit, then we match.  I.e., we want either an exact
2434      match or a section followed by a number.  */
2435   if (strncmp (sought->section_name, section->name, len) == 0
2436       && (section->name[len] == 0
2437           || (section->name[len] == '.' && ISDIGIT (section->name[len + 1]))))
2438     {
2439       if (strtab == NULL)
2440         strtab = read_section_stabs (abfd, sought->string_section_name,
2441                                      &stabstr_size);
2442
2443       if (strtab)
2444         {
2445           stabs = (bfd_byte *) read_section_stabs (abfd, section->name,
2446                                                    &stab_size);
2447           if (stabs)
2448             print_section_stabs (abfd, section->name, &sought->string_offset);
2449         }
2450     }
2451 }
2452
2453 static void
2454 dump_stabs_section (bfd *abfd, char *stabsect_name, char *strsect_name)
2455 {
2456   stab_section_names s;
2457
2458   s.section_name = stabsect_name;
2459   s.string_section_name = strsect_name;
2460   s.string_offset = 0;
2461
2462   bfd_map_over_sections (abfd, find_stabs_section, & s);
2463
2464   free (strtab);
2465   strtab = NULL;
2466 }
2467
2468 /* Dump the any sections containing stabs debugging information.  */
2469
2470 static void
2471 dump_stabs (bfd *abfd)
2472 {
2473   dump_stabs_section (abfd, ".stab", ".stabstr");
2474   dump_stabs_section (abfd, ".stab.excl", ".stab.exclstr");
2475   dump_stabs_section (abfd, ".stab.index", ".stab.indexstr");
2476   dump_stabs_section (abfd, "$GDB_SYMBOLS$", "$GDB_STRINGS$");
2477 }
2478 \f
2479 static void
2480 dump_bfd_header (bfd *abfd)
2481 {
2482   char *comma = "";
2483
2484   printf (_("architecture: %s, "),
2485           bfd_printable_arch_mach (bfd_get_arch (abfd),
2486                                    bfd_get_mach (abfd)));
2487   printf (_("flags 0x%08x:\n"), abfd->flags);
2488
2489 #define PF(x, y)    if (abfd->flags & x) {printf("%s%s", comma, y); comma=", ";}
2490   PF (HAS_RELOC, "HAS_RELOC");
2491   PF (EXEC_P, "EXEC_P");
2492   PF (HAS_LINENO, "HAS_LINENO");
2493   PF (HAS_DEBUG, "HAS_DEBUG");
2494   PF (HAS_SYMS, "HAS_SYMS");
2495   PF (HAS_LOCALS, "HAS_LOCALS");
2496   PF (DYNAMIC, "DYNAMIC");
2497   PF (WP_TEXT, "WP_TEXT");
2498   PF (D_PAGED, "D_PAGED");
2499   PF (BFD_IS_RELAXABLE, "BFD_IS_RELAXABLE");
2500   PF (HAS_LOAD_PAGE, "HAS_LOAD_PAGE");
2501   printf (_("\nstart address 0x"));
2502   bfd_printf_vma (abfd, abfd->start_address);
2503   printf ("\n");
2504 }
2505
2506 \f
2507 static void
2508 dump_bfd_private_header (bfd *abfd)
2509 {
2510   bfd_print_private_bfd_data (abfd, stdout);
2511 }
2512
2513 \f
2514 /* Display a section in hexadecimal format with associated characters.
2515    Each line prefixed by the zero padded address.  */
2516
2517 static void
2518 dump_section (bfd *abfd, asection *section, void *dummy ATTRIBUTE_UNUSED)
2519 {
2520   bfd_byte *data = 0;
2521   bfd_size_type datasize;
2522   bfd_size_type addr_offset;
2523   bfd_size_type start_offset;
2524   bfd_size_type stop_offset;
2525   unsigned int opb = bfd_octets_per_byte (abfd);
2526   /* Bytes per line.  */
2527   const int onaline = 16;
2528   char buf[64];
2529   int count;
2530   int width;
2531
2532   if ((section->flags & SEC_HAS_CONTENTS) == 0)
2533     return;
2534
2535   if (! process_section_p (section))
2536     return;
2537
2538   if ((datasize = bfd_section_size (abfd, section)) == 0)
2539     return;
2540
2541   /* Compute the address range to display.  */
2542   if (start_address == (bfd_vma) -1
2543       || start_address < section->vma)
2544     start_offset = 0;
2545   else
2546     start_offset = start_address - section->vma;
2547
2548   if (stop_address == (bfd_vma) -1)
2549     stop_offset = datasize / opb;
2550   else
2551     {
2552       if (stop_address < section->vma)
2553         stop_offset = 0;
2554       else
2555         stop_offset = stop_address - section->vma;
2556
2557       if (stop_offset > datasize / opb)
2558         stop_offset = datasize / opb;
2559     }
2560
2561   if (start_offset >= stop_offset)
2562     return;
2563
2564   printf (_("Contents of section %s:"), section->name);
2565   if (display_file_offsets)
2566     printf (_("  (Starting at file offset: 0x%lx)"), (long int)(section->filepos + start_offset));
2567   printf ("\n");
2568
2569   data = xmalloc (datasize);
2570
2571   bfd_get_section_contents (abfd, section, data, 0, datasize);
2572
2573   width = 4;
2574
2575   bfd_sprintf_vma (abfd, buf, start_offset + section->vma);
2576   if (strlen (buf) >= sizeof (buf))
2577     abort ();
2578
2579   count = 0;
2580   while (buf[count] == '0' && buf[count+1] != '\0')
2581     count++;
2582   count = strlen (buf) - count;
2583   if (count > width)
2584     width = count;
2585
2586   bfd_sprintf_vma (abfd, buf, stop_offset + section->vma - 1);
2587   if (strlen (buf) >= sizeof (buf))
2588     abort ();
2589
2590   count = 0;
2591   while (buf[count] == '0' && buf[count+1] != '\0')
2592     count++;
2593   count = strlen (buf) - count;
2594   if (count > width)
2595     width = count;
2596
2597   for (addr_offset = start_offset;
2598        addr_offset < stop_offset; addr_offset += onaline / opb)
2599     {
2600       bfd_size_type j;
2601
2602       bfd_sprintf_vma (abfd, buf, (addr_offset + section->vma));
2603       count = strlen (buf);
2604       if ((size_t) count >= sizeof (buf))
2605         abort ();
2606
2607       putchar (' ');
2608       while (count < width)
2609         {
2610           putchar ('0');
2611           count++;
2612         }
2613       fputs (buf + count - width, stdout);
2614       putchar (' ');
2615
2616       for (j = addr_offset * opb;
2617            j < addr_offset * opb + onaline; j++)
2618         {
2619           if (j < stop_offset * opb)
2620             printf ("%02x", (unsigned) (data[j]));
2621           else
2622             printf ("  ");
2623           if ((j & 3) == 3)
2624             printf (" ");
2625         }
2626
2627       printf (" ");
2628       for (j = addr_offset * opb;
2629            j < addr_offset * opb + onaline; j++)
2630         {
2631           if (j >= stop_offset * opb)
2632             printf (" ");
2633           else
2634             printf ("%c", ISPRINT (data[j]) ? data[j] : '.');
2635         }
2636       putchar ('\n');
2637     }
2638   free (data);
2639 }
2640
2641 /* Actually display the various requested regions.  */
2642
2643 static void
2644 dump_data (bfd *abfd)
2645 {
2646   bfd_map_over_sections (abfd, dump_section, NULL);
2647 }
2648
2649 /* Should perhaps share code and display with nm?  */
2650
2651 static void
2652 dump_symbols (bfd *abfd ATTRIBUTE_UNUSED, bfd_boolean dynamic)
2653 {
2654   asymbol **current;
2655   long max;
2656   long count;
2657
2658   if (dynamic)
2659     {
2660       current = dynsyms;
2661       max = dynsymcount;
2662       printf ("DYNAMIC SYMBOL TABLE:\n");
2663     }
2664   else
2665     {
2666       current = syms;
2667       max = symcount;
2668       printf ("SYMBOL TABLE:\n");
2669     }
2670
2671   if (max == 0)
2672     printf (_("no symbols\n"));
2673
2674   for (count = 0; count < max; count++)
2675     {
2676       bfd *cur_bfd;
2677
2678       if (*current == NULL)
2679         printf (_("no information for symbol number %ld\n"), count);
2680
2681       else if ((cur_bfd = bfd_asymbol_bfd (*current)) == NULL)
2682         printf (_("could not determine the type of symbol number %ld\n"),
2683                 count);
2684
2685       else if (process_section_p ((* current)->section)
2686                && (dump_special_syms
2687                    || !bfd_is_target_special_symbol (cur_bfd, *current)))
2688         {
2689           const char *name = (*current)->name;
2690
2691           if (do_demangle && name != NULL && *name != '\0')
2692             {
2693               char *alloc;
2694
2695               /* If we want to demangle the name, we demangle it
2696                  here, and temporarily clobber it while calling
2697                  bfd_print_symbol.  FIXME: This is a gross hack.  */
2698               alloc = bfd_demangle (cur_bfd, name, DMGL_ANSI | DMGL_PARAMS);
2699               if (alloc != NULL)
2700                 (*current)->name = alloc;
2701               bfd_print_symbol (cur_bfd, stdout, *current,
2702                                 bfd_print_symbol_all);
2703               if (alloc != NULL)
2704                 {
2705                   (*current)->name = name;
2706                   free (alloc);
2707                 }
2708             }
2709           else
2710             bfd_print_symbol (cur_bfd, stdout, *current,
2711                               bfd_print_symbol_all);
2712           printf ("\n");
2713         }
2714
2715       current++;
2716     }
2717   printf ("\n\n");
2718 }
2719 \f
2720 static void
2721 dump_reloc_set (bfd *abfd, asection *sec, arelent **relpp, long relcount)
2722 {
2723   arelent **p;
2724   char *last_filename, *last_functionname;
2725   unsigned int last_line;
2726
2727   /* Get column headers lined up reasonably.  */
2728   {
2729     static int width;
2730
2731     if (width == 0)
2732       {
2733         char buf[30];
2734
2735         bfd_sprintf_vma (abfd, buf, (bfd_vma) -1);
2736         width = strlen (buf) - 7;
2737       }
2738     printf ("OFFSET %*s TYPE %*s VALUE \n", width, "", 12, "");
2739   }
2740
2741   last_filename = NULL;
2742   last_functionname = NULL;
2743   last_line = 0;
2744
2745   for (p = relpp; relcount && *p != NULL; p++, relcount--)
2746     {
2747       arelent *q = *p;
2748       const char *filename, *functionname;
2749       unsigned int line;
2750       const char *sym_name;
2751       const char *section_name;
2752
2753       if (start_address != (bfd_vma) -1
2754           && q->address < start_address)
2755         continue;
2756       if (stop_address != (bfd_vma) -1
2757           && q->address > stop_address)
2758         continue;
2759
2760       if (with_line_numbers
2761           && sec != NULL
2762           && bfd_find_nearest_line (abfd, sec, syms, q->address,
2763                                     &filename, &functionname, &line))
2764         {
2765           if (functionname != NULL
2766               && (last_functionname == NULL
2767                   || strcmp (functionname, last_functionname) != 0))
2768             {
2769               printf ("%s():\n", functionname);
2770               if (last_functionname != NULL)
2771                 free (last_functionname);
2772               last_functionname = xstrdup (functionname);
2773             }
2774
2775           if (line > 0
2776               && (line != last_line
2777                   || (filename != NULL
2778                       && last_filename != NULL
2779                       && strcmp (filename, last_filename) != 0)))
2780             {
2781               printf ("%s:%u\n", filename == NULL ? "???" : filename, line);
2782               last_line = line;
2783               if (last_filename != NULL)
2784                 free (last_filename);
2785               if (filename == NULL)
2786                 last_filename = NULL;
2787               else
2788                 last_filename = xstrdup (filename);
2789             }
2790         }
2791
2792       if (q->sym_ptr_ptr && *q->sym_ptr_ptr)
2793         {
2794           sym_name = (*(q->sym_ptr_ptr))->name;
2795           section_name = (*(q->sym_ptr_ptr))->section->name;
2796         }
2797       else
2798         {
2799           sym_name = NULL;
2800           section_name = NULL;
2801         }
2802
2803       bfd_printf_vma (abfd, q->address);
2804       if (q->howto == NULL)
2805         printf (" *unknown*         ");
2806       else if (q->howto->name)
2807         printf (" %-16s  ", q->howto->name);
2808       else
2809         printf (" %-16d  ", q->howto->type);
2810       if (sym_name)
2811         objdump_print_symname (abfd, NULL, *q->sym_ptr_ptr);
2812       else
2813         {
2814           if (section_name == NULL)
2815             section_name = "*unknown*";
2816           printf ("[%s]", section_name);
2817         }
2818
2819       if (q->addend)
2820         {
2821           printf ("+0x");
2822           bfd_printf_vma (abfd, q->addend);
2823         }
2824
2825       printf ("\n");
2826     }
2827 }
2828
2829 static void
2830 dump_relocs_in_section (bfd *abfd,
2831                         asection *section,
2832                         void *dummy ATTRIBUTE_UNUSED)
2833 {
2834   arelent **relpp;
2835   long relcount;
2836   long relsize;
2837
2838   if (   bfd_is_abs_section (section)
2839       || bfd_is_und_section (section)
2840       || bfd_is_com_section (section)
2841       || (! process_section_p (section))
2842       || ((section->flags & SEC_RELOC) == 0))
2843     return;
2844
2845   relsize = bfd_get_reloc_upper_bound (abfd, section);
2846   if (relsize < 0)
2847     bfd_fatal (bfd_get_filename (abfd));
2848
2849   printf ("RELOCATION RECORDS FOR [%s]:", section->name);
2850
2851   if (relsize == 0)
2852     {
2853       printf (" (none)\n\n");
2854       return;
2855     }
2856
2857   relpp = xmalloc (relsize);
2858   relcount = bfd_canonicalize_reloc (abfd, section, relpp, syms);
2859
2860   if (relcount < 0)
2861     bfd_fatal (bfd_get_filename (abfd));
2862   else if (relcount == 0)
2863     printf (" (none)\n\n");
2864   else
2865     {
2866       printf ("\n");
2867       dump_reloc_set (abfd, section, relpp, relcount);
2868       printf ("\n\n");
2869     }
2870   free (relpp);
2871 }
2872
2873 static void
2874 dump_relocs (bfd *abfd)
2875 {
2876   bfd_map_over_sections (abfd, dump_relocs_in_section, NULL);
2877 }
2878
2879 static void
2880 dump_dynamic_relocs (bfd *abfd)
2881 {
2882   long relsize;
2883   arelent **relpp;
2884   long relcount;
2885
2886   relsize = bfd_get_dynamic_reloc_upper_bound (abfd);
2887   if (relsize < 0)
2888     bfd_fatal (bfd_get_filename (abfd));
2889
2890   printf ("DYNAMIC RELOCATION RECORDS");
2891
2892   if (relsize == 0)
2893     printf (" (none)\n\n");
2894   else
2895     {
2896       relpp = xmalloc (relsize);
2897       relcount = bfd_canonicalize_dynamic_reloc (abfd, relpp, dynsyms);
2898
2899       if (relcount < 0)
2900         bfd_fatal (bfd_get_filename (abfd));
2901       else if (relcount == 0)
2902         printf (" (none)\n\n");
2903       else
2904         {
2905           printf ("\n");
2906           dump_reloc_set (abfd, NULL, relpp, relcount);
2907           printf ("\n\n");
2908         }
2909       free (relpp);
2910     }
2911 }
2912
2913 /* Creates a table of paths, to search for source files.  */
2914
2915 static void
2916 add_include_path (const char *path)
2917 {
2918   if (path[0] == 0)
2919     return;
2920   include_path_count++;
2921   include_paths = xrealloc (include_paths,
2922                             include_path_count * sizeof (*include_paths));
2923 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
2924   if (path[1] == ':' && path[2] == 0)
2925     path = concat (path, ".", (const char *) 0);
2926 #endif
2927   include_paths[include_path_count - 1] = path;
2928 }
2929
2930 static void
2931 adjust_addresses (bfd *abfd ATTRIBUTE_UNUSED,
2932                   asection *section,
2933                   void *arg)
2934 {
2935   if ((section->flags & SEC_DEBUGGING) == 0)
2936     {
2937       bfd_boolean *has_reloc_p = (bfd_boolean *) arg;
2938       section->vma += adjust_section_vma;
2939       if (*has_reloc_p)
2940         section->lma += adjust_section_vma;
2941     }
2942 }
2943
2944 /* Dump selected contents of ABFD.  */
2945
2946 static void
2947 dump_bfd (bfd *abfd)
2948 {
2949   /* If we are adjusting section VMA's, change them all now.  Changing
2950      the BFD information is a hack.  However, we must do it, or
2951      bfd_find_nearest_line will not do the right thing.  */
2952   if (adjust_section_vma != 0)
2953     {
2954       bfd_boolean has_reloc = (abfd->flags & HAS_RELOC);
2955       bfd_map_over_sections (abfd, adjust_addresses, &has_reloc);
2956     }
2957
2958   if (! dump_debugging_tags)
2959     printf (_("\n%s:     file format %s\n"), bfd_get_filename (abfd),
2960             abfd->xvec->name);
2961   if (dump_ar_hdrs)
2962     print_arelt_descr (stdout, abfd, TRUE);
2963   if (dump_file_header)
2964     dump_bfd_header (abfd);
2965   if (dump_private_headers)
2966     dump_bfd_private_header (abfd);
2967   if (! dump_debugging_tags)
2968     putchar ('\n');
2969   if (dump_section_headers)
2970     dump_headers (abfd);
2971
2972   if (dump_symtab
2973       || dump_reloc_info
2974       || disassemble
2975       || dump_debugging
2976       || dump_dwarf_section_info)
2977     syms = slurp_symtab (abfd);
2978   if (dump_dynamic_symtab || dump_dynamic_reloc_info
2979       || (disassemble && bfd_get_dynamic_symtab_upper_bound (abfd) > 0))
2980     dynsyms = slurp_dynamic_symtab (abfd);
2981   if (disassemble)
2982     {
2983       synthcount = bfd_get_synthetic_symtab (abfd, symcount, syms,
2984                                              dynsymcount, dynsyms, &synthsyms);
2985       if (synthcount < 0)
2986         synthcount = 0;
2987     }
2988
2989   if (dump_symtab)
2990     dump_symbols (abfd, FALSE);
2991   if (dump_dynamic_symtab)
2992     dump_symbols (abfd, TRUE);
2993   if (dump_dwarf_section_info)
2994     dump_dwarf (abfd);
2995   if (dump_stab_section_info)
2996     dump_stabs (abfd);
2997   if (dump_reloc_info && ! disassemble)
2998     dump_relocs (abfd);
2999   if (dump_dynamic_reloc_info && ! disassemble)
3000     dump_dynamic_relocs (abfd);
3001   if (dump_section_contents)
3002     dump_data (abfd);
3003   if (disassemble)
3004     disassemble_data (abfd);
3005
3006   if (dump_debugging)
3007     {
3008       void *dhandle;
3009
3010       dhandle = read_debugging_info (abfd, syms, symcount, TRUE);
3011       if (dhandle != NULL)
3012         {
3013           if (!print_debugging_info (stdout, dhandle, abfd, syms,
3014                                      bfd_demangle,
3015                                      dump_debugging_tags ? TRUE : FALSE))
3016             {
3017               non_fatal (_("%s: printing debugging information failed"),
3018                          bfd_get_filename (abfd));
3019               exit_status = 1;
3020             }
3021         }
3022       /* PR 6483: If there was no STABS or IEEE debug
3023          info in the file, try DWARF instead.  */
3024       else if (! dump_dwarf_section_info)
3025         {
3026           dump_dwarf (abfd);
3027         }
3028     }
3029
3030   if (syms)
3031     {
3032       free (syms);
3033       syms = NULL;
3034     }
3035
3036   if (dynsyms)
3037     {
3038       free (dynsyms);
3039       dynsyms = NULL;
3040     }
3041
3042   if (synthsyms)
3043     {
3044       free (synthsyms);
3045       synthsyms = NULL;
3046     }
3047
3048   symcount = 0;
3049   dynsymcount = 0;
3050   synthcount = 0;
3051 }
3052
3053 static void
3054 display_bfd (bfd *abfd)
3055 {
3056   char **matching;
3057
3058   if (bfd_check_format_matches (abfd, bfd_object, &matching))
3059     {
3060       dump_bfd (abfd);
3061       return;
3062     }
3063
3064   if (bfd_get_error () == bfd_error_file_ambiguously_recognized)
3065     {
3066       nonfatal (bfd_get_filename (abfd));
3067       list_matching_formats (matching);
3068       free (matching);
3069       return;
3070     }
3071
3072   if (bfd_get_error () != bfd_error_file_not_recognized)
3073     {
3074       nonfatal (bfd_get_filename (abfd));
3075       return;
3076     }
3077
3078   if (bfd_check_format_matches (abfd, bfd_core, &matching))
3079     {
3080       dump_bfd (abfd);
3081       return;
3082     }
3083
3084   nonfatal (bfd_get_filename (abfd));
3085
3086   if (bfd_get_error () == bfd_error_file_ambiguously_recognized)
3087     {
3088       list_matching_formats (matching);
3089       free (matching);
3090     }
3091 }
3092
3093 static void
3094 display_file (char *filename, char *target)
3095 {
3096   bfd *file;
3097   bfd *arfile = NULL;
3098
3099   if (get_file_size (filename) < 1)
3100     {
3101       exit_status = 1;
3102       return;
3103     }
3104
3105   file = bfd_openr (filename, target);
3106   if (file == NULL)
3107     {
3108       nonfatal (filename);
3109       return;
3110     }
3111
3112   /* If the file is an archive, process all of its elements.  */
3113   if (bfd_check_format (file, bfd_archive))
3114     {
3115       bfd *last_arfile = NULL;
3116
3117       printf (_("In archive %s:\n"), bfd_get_filename (file));
3118       for (;;)
3119         {
3120           bfd_set_error (bfd_error_no_error);
3121
3122           arfile = bfd_openr_next_archived_file (file, arfile);
3123           if (arfile == NULL)
3124             {
3125               if (bfd_get_error () != bfd_error_no_more_archived_files)
3126                 nonfatal (bfd_get_filename (file));
3127               break;
3128             }
3129
3130           display_bfd (arfile);
3131
3132           if (last_arfile != NULL)
3133             bfd_close (last_arfile);
3134           last_arfile = arfile;
3135         }
3136
3137       if (last_arfile != NULL)
3138         bfd_close (last_arfile);
3139     }
3140   else
3141     display_bfd (file);
3142
3143   bfd_close (file);
3144 }
3145 \f
3146 int
3147 main (int argc, char **argv)
3148 {
3149   int c;
3150   char *target = default_target;
3151   bfd_boolean seenflag = FALSE;
3152
3153 #if defined (HAVE_SETLOCALE)
3154 #if defined (HAVE_LC_MESSAGES)
3155   setlocale (LC_MESSAGES, "");
3156 #endif
3157   setlocale (LC_CTYPE, "");
3158 #endif
3159
3160   bindtextdomain (PACKAGE, LOCALEDIR);
3161   textdomain (PACKAGE);
3162
3163   program_name = *argv;
3164   xmalloc_set_program_name (program_name);
3165
3166   START_PROGRESS (program_name, 0);
3167
3168   expandargv (&argc, &argv);
3169
3170   bfd_init ();
3171   set_default_bfd_target ();
3172
3173   while ((c = getopt_long (argc, argv, "pib:m:M:VvCdDlfFaHhrRtTxsSI:j:wE:zgeGW",
3174                            long_options, (int *) 0))
3175          != EOF)
3176     {
3177       switch (c)
3178         {
3179         case 0:
3180           break;                /* We've been given a long option.  */
3181         case 'm':
3182           machine = optarg;
3183           break;
3184         case 'M':
3185           if (disassembler_options)
3186             /* Ignore potential memory leak for now.  */
3187             disassembler_options = concat (disassembler_options, ",",
3188                                            optarg, (const char *) NULL);
3189           else
3190             disassembler_options = optarg;
3191           break;
3192         case 'j':
3193           if (only_used == only_size)
3194             {
3195               only_size += 8;
3196               only = xrealloc (only, only_size * sizeof (char *));
3197             }
3198           only [only_used++] = optarg;
3199           break;
3200         case 'F':
3201           display_file_offsets = TRUE;
3202           break;
3203         case 'l':
3204           with_line_numbers = TRUE;
3205           break;
3206         case 'b':
3207           target = optarg;
3208           break;
3209         case 'C':
3210           do_demangle = TRUE;
3211           if (optarg != NULL)
3212             {
3213               enum demangling_styles style;
3214
3215               style = cplus_demangle_name_to_style (optarg);
3216               if (style == unknown_demangling)
3217                 fatal (_("unknown demangling style `%s'"),
3218                        optarg);
3219
3220               cplus_demangle_set_style (style);
3221             }
3222           break;
3223         case 'w':
3224           wide_output = TRUE;
3225           break;
3226         case OPTION_ADJUST_VMA:
3227           adjust_section_vma = parse_vma (optarg, "--adjust-vma");
3228           break;
3229         case OPTION_START_ADDRESS:
3230           start_address = parse_vma (optarg, "--start-address");
3231           if ((stop_address != (bfd_vma) -1) && stop_address <= start_address)
3232             fatal (_("error: the start address should be before the end address"));
3233           break;
3234         case OPTION_STOP_ADDRESS:
3235           stop_address = parse_vma (optarg, "--stop-address");
3236           if ((start_address != (bfd_vma) -1) && stop_address <= start_address)
3237             fatal (_("error: the stop address should be after the start address"));
3238           break;
3239         case 'E':
3240           if (strcmp (optarg, "B") == 0)
3241             endian = BFD_ENDIAN_BIG;
3242           else if (strcmp (optarg, "L") == 0)
3243             endian = BFD_ENDIAN_LITTLE;
3244           else
3245             {
3246               non_fatal (_("unrecognized -E option"));
3247               usage (stderr, 1);
3248             }
3249           break;
3250         case OPTION_ENDIAN:
3251           if (strncmp (optarg, "big", strlen (optarg)) == 0)
3252             endian = BFD_ENDIAN_BIG;
3253           else if (strncmp (optarg, "little", strlen (optarg)) == 0)
3254             endian = BFD_ENDIAN_LITTLE;
3255           else
3256             {
3257               non_fatal (_("unrecognized --endian type `%s'"), optarg);
3258               usage (stderr, 1);
3259             }
3260           break;
3261
3262         case 'f':
3263           dump_file_header = TRUE;
3264           seenflag = TRUE;
3265           break;
3266         case 'i':
3267           formats_info = TRUE;
3268           seenflag = TRUE;
3269           break;
3270         case 'I':
3271           add_include_path (optarg);
3272           break;
3273         case 'p':
3274           dump_private_headers = TRUE;
3275           seenflag = TRUE;
3276           break;
3277         case 'x':
3278           dump_private_headers = TRUE;
3279           dump_symtab = TRUE;
3280           dump_reloc_info = TRUE;
3281           dump_file_header = TRUE;
3282           dump_ar_hdrs = TRUE;
3283           dump_section_headers = TRUE;
3284           seenflag = TRUE;
3285           break;
3286         case 't':
3287           dump_symtab = TRUE;
3288           seenflag = TRUE;
3289           break;
3290         case 'T':
3291           dump_dynamic_symtab = TRUE;
3292           seenflag = TRUE;
3293           break;
3294         case 'd':
3295           disassemble = TRUE;
3296           seenflag = TRUE;
3297           break;
3298         case 'z':
3299           disassemble_zeroes = TRUE;
3300           break;
3301         case 'D':
3302           disassemble = TRUE;
3303           disassemble_all = TRUE;
3304           seenflag = TRUE;
3305           break;
3306         case 'S':
3307           disassemble = TRUE;
3308           with_source_code = TRUE;
3309           seenflag = TRUE;
3310           break;
3311         case 'g':
3312           dump_debugging = 1;
3313           seenflag = TRUE;
3314           break;
3315         case 'e':
3316           dump_debugging = 1;
3317           dump_debugging_tags = 1;
3318           do_demangle = TRUE;
3319           seenflag = TRUE;
3320           break;
3321         case 'W':
3322           dump_dwarf_section_info = TRUE;
3323           seenflag = TRUE;
3324           do_debug_info = 1;
3325           do_debug_abbrevs = 1;
3326           do_debug_lines = 1;
3327           do_debug_pubnames = 1;
3328           do_debug_aranges = 1;
3329           do_debug_ranges = 1;
3330           do_debug_frames = 1;
3331           do_debug_macinfo = 1;
3332           do_debug_str = 1;
3333           do_debug_loc = 1;
3334           break;
3335         case 'G':
3336           dump_stab_section_info = TRUE;
3337           seenflag = TRUE;
3338           break;
3339         case 's':
3340           dump_section_contents = TRUE;
3341           seenflag = TRUE;
3342           break;
3343         case 'r':
3344           dump_reloc_info = TRUE;
3345           seenflag = TRUE;
3346           break;
3347         case 'R':
3348           dump_dynamic_reloc_info = TRUE;
3349           seenflag = TRUE;
3350           break;
3351         case 'a':
3352           dump_ar_hdrs = TRUE;
3353           seenflag = TRUE;
3354           break;
3355         case 'h':
3356           dump_section_headers = TRUE;
3357           seenflag = TRUE;
3358           break;
3359         case 'H':
3360           usage (stdout, 0);
3361           seenflag = TRUE;
3362         case 'v':
3363         case 'V':
3364           show_version = TRUE;
3365           seenflag = TRUE;
3366           break;
3367
3368         default:
3369           usage (stderr, 1);
3370         }
3371     }
3372
3373   if (show_version)
3374     print_version ("objdump");
3375
3376   if (!seenflag)
3377     usage (stderr, 2);
3378
3379   if (formats_info)
3380     exit_status = display_info ();
3381   else
3382     {
3383       if (optind == argc)
3384         display_file ("a.out", target);
3385       else
3386         for (; optind < argc;)
3387           display_file (argv[optind++], target);
3388     }
3389
3390   END_PROGRESS (program_name);
3391
3392   return exit_status;
3393 }