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