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