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