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 & (HAS_RELOC | EXEC_P | DYNAMIC))
2170                     == HAS_RELOC);
2171
2172   /* FIXME: bfd_get_arch_size may return -1.  We assume that 64bit
2173      targets will return 64.  */
2174   eh_addr_size = bfd_get_arch_size (abfd) == 64 ? 8 : 4;
2175
2176   if (bfd_big_endian (abfd))
2177     byte_get = byte_get_big_endian;
2178   else if (bfd_little_endian (abfd))
2179     byte_get = byte_get_little_endian;
2180   else
2181     abort ();
2182
2183   check_mach_o_dwarf (abfd);
2184
2185   bfd_map_over_sections (abfd, dump_dwarf_section, NULL);
2186
2187   free_debug_memory ();
2188 }
2189 \f
2190 /* Read ABFD's stabs section STABSECT_NAME, and return a pointer to
2191    it.  Return NULL on failure.   */
2192
2193 static char *
2194 read_section_stabs (bfd *abfd, const char *sect_name, bfd_size_type *size_ptr)
2195 {
2196   asection *stabsect;
2197   bfd_size_type size;
2198   char *contents;
2199
2200   stabsect = bfd_get_section_by_name (abfd, sect_name);
2201   if (stabsect == NULL)
2202     {
2203       printf (_("No %s section present\n\n"), sect_name);
2204       return FALSE;
2205     }
2206
2207   size = bfd_section_size (abfd, stabsect);
2208   contents  = xmalloc (size);
2209
2210   if (! bfd_get_section_contents (abfd, stabsect, contents, 0, size))
2211     {
2212       non_fatal (_("Reading %s section of %s failed: %s"),
2213                  sect_name, bfd_get_filename (abfd),
2214                  bfd_errmsg (bfd_get_error ()));
2215       free (contents);
2216       exit_status = 1;
2217       return NULL;
2218     }
2219
2220   *size_ptr = size;
2221
2222   return contents;
2223 }
2224
2225 /* Stabs entries use a 12 byte format:
2226      4 byte string table index
2227      1 byte stab type
2228      1 byte stab other field
2229      2 byte stab desc field
2230      4 byte stab value
2231    FIXME: This will have to change for a 64 bit object format.  */
2232
2233 #define STRDXOFF  (0)
2234 #define TYPEOFF   (4)
2235 #define OTHEROFF  (5)
2236 #define DESCOFF   (6)
2237 #define VALOFF    (8)
2238 #define STABSIZE (12)
2239
2240 /* Print ABFD's stabs section STABSECT_NAME (in `stabs'),
2241    using string table section STRSECT_NAME (in `strtab').  */
2242
2243 static void
2244 print_section_stabs (bfd *abfd,
2245                      const char *stabsect_name,
2246                      unsigned *string_offset_ptr)
2247 {
2248   int i;
2249   unsigned file_string_table_offset = 0;
2250   unsigned next_file_string_table_offset = *string_offset_ptr;
2251   bfd_byte *stabp, *stabs_end;
2252
2253   stabp = stabs;
2254   stabs_end = stabp + stab_size;
2255
2256   printf (_("Contents of %s section:\n\n"), stabsect_name);
2257   printf ("Symnum n_type n_othr n_desc n_value  n_strx String\n");
2258
2259   /* Loop through all symbols and print them.
2260
2261      We start the index at -1 because there is a dummy symbol on
2262      the front of stabs-in-{coff,elf} sections that supplies sizes.  */
2263   for (i = -1; stabp < stabs_end; stabp += STABSIZE, i++)
2264     {
2265       const char *name;
2266       unsigned long strx;
2267       unsigned char type, other;
2268       unsigned short desc;
2269       bfd_vma value;
2270
2271       strx = bfd_h_get_32 (abfd, stabp + STRDXOFF);
2272       type = bfd_h_get_8 (abfd, stabp + TYPEOFF);
2273       other = bfd_h_get_8 (abfd, stabp + OTHEROFF);
2274       desc = bfd_h_get_16 (abfd, stabp + DESCOFF);
2275       value = bfd_h_get_32 (abfd, stabp + VALOFF);
2276
2277       printf ("\n%-6d ", i);
2278       /* Either print the stab name, or, if unnamed, print its number
2279          again (makes consistent formatting for tools like awk).  */
2280       name = bfd_get_stab_name (type);
2281       if (name != NULL)
2282         printf ("%-6s", name);
2283       else if (type == N_UNDF)
2284         printf ("HdrSym");
2285       else
2286         printf ("%-6d", type);
2287       printf (" %-6d %-6d ", other, desc);
2288       bfd_printf_vma (abfd, value);
2289       printf (" %-6lu", strx);
2290
2291       /* Symbols with type == 0 (N_UNDF) specify the length of the
2292          string table associated with this file.  We use that info
2293          to know how to relocate the *next* file's string table indices.  */
2294       if (type == N_UNDF)
2295         {
2296           file_string_table_offset = next_file_string_table_offset;
2297           next_file_string_table_offset += value;
2298         }
2299       else
2300         {
2301           /* Using the (possibly updated) string table offset, print the
2302              string (if any) associated with this symbol.  */
2303           if ((strx + file_string_table_offset) < stabstr_size)
2304             printf (" %s", &strtab[strx + file_string_table_offset]);
2305           else
2306             printf (" *");
2307         }
2308     }
2309   printf ("\n\n");
2310   *string_offset_ptr = next_file_string_table_offset;
2311 }
2312
2313 typedef struct
2314 {
2315   const char * section_name;
2316   const char * string_section_name;
2317   unsigned string_offset;
2318 }
2319 stab_section_names;
2320
2321 static void
2322 find_stabs_section (bfd *abfd, asection *section, void *names)
2323 {
2324   int len;
2325   stab_section_names * sought = (stab_section_names *) names;
2326
2327   /* Check for section names for which stabsect_name is a prefix, to
2328      handle .stab.N, etc.  */
2329   len = strlen (sought->section_name);
2330
2331   /* If the prefix matches, and the files section name ends with a
2332      nul or a digit, then we match.  I.e., we want either an exact
2333      match or a section followed by a number.  */
2334   if (strncmp (sought->section_name, section->name, len) == 0
2335       && (section->name[len] == 0
2336           || (section->name[len] == '.' && ISDIGIT (section->name[len + 1]))))
2337     {
2338       if (strtab == NULL)
2339         strtab = read_section_stabs (abfd, sought->string_section_name,
2340                                      &stabstr_size);
2341
2342       if (strtab)
2343         {
2344           stabs = (bfd_byte *) read_section_stabs (abfd, section->name,
2345                                                    &stab_size);
2346           if (stabs)
2347             print_section_stabs (abfd, section->name, &sought->string_offset);
2348         }
2349     }
2350 }
2351
2352 static void
2353 dump_stabs_section (bfd *abfd, char *stabsect_name, char *strsect_name)
2354 {
2355   stab_section_names s;
2356
2357   s.section_name = stabsect_name;
2358   s.string_section_name = strsect_name;
2359   s.string_offset = 0;
2360
2361   bfd_map_over_sections (abfd, find_stabs_section, & s);
2362
2363   free (strtab);
2364   strtab = NULL;
2365 }
2366
2367 /* Dump the any sections containing stabs debugging information.  */
2368
2369 static void
2370 dump_stabs (bfd *abfd)
2371 {
2372   dump_stabs_section (abfd, ".stab", ".stabstr");
2373   dump_stabs_section (abfd, ".stab.excl", ".stab.exclstr");
2374   dump_stabs_section (abfd, ".stab.index", ".stab.indexstr");
2375   dump_stabs_section (abfd, "$GDB_SYMBOLS$", "$GDB_STRINGS$");
2376 }
2377 \f
2378 static void
2379 dump_bfd_header (bfd *abfd)
2380 {
2381   char *comma = "";
2382
2383   printf (_("architecture: %s, "),
2384           bfd_printable_arch_mach (bfd_get_arch (abfd),
2385                                    bfd_get_mach (abfd)));
2386   printf (_("flags 0x%08x:\n"), abfd->flags);
2387
2388 #define PF(x, y)    if (abfd->flags & x) {printf("%s%s", comma, y); comma=", ";}
2389   PF (HAS_RELOC, "HAS_RELOC");
2390   PF (EXEC_P, "EXEC_P");
2391   PF (HAS_LINENO, "HAS_LINENO");
2392   PF (HAS_DEBUG, "HAS_DEBUG");
2393   PF (HAS_SYMS, "HAS_SYMS");
2394   PF (HAS_LOCALS, "HAS_LOCALS");
2395   PF (DYNAMIC, "DYNAMIC");
2396   PF (WP_TEXT, "WP_TEXT");
2397   PF (D_PAGED, "D_PAGED");
2398   PF (BFD_IS_RELAXABLE, "BFD_IS_RELAXABLE");
2399   PF (HAS_LOAD_PAGE, "HAS_LOAD_PAGE");
2400   printf (_("\nstart address 0x"));
2401   bfd_printf_vma (abfd, abfd->start_address);
2402   printf ("\n");
2403 }
2404
2405 \f
2406 static void
2407 dump_bfd_private_header (bfd *abfd)
2408 {
2409   bfd_print_private_bfd_data (abfd, stdout);
2410 }
2411
2412 \f
2413 /* Display a section in hexadecimal format with associated characters.
2414    Each line prefixed by the zero padded address.  */
2415
2416 static void
2417 dump_section (bfd *abfd, asection *section, void *dummy ATTRIBUTE_UNUSED)
2418 {
2419   bfd_byte *data = 0;
2420   bfd_size_type datasize;
2421   bfd_size_type addr_offset;
2422   bfd_size_type start_offset;
2423   bfd_size_type stop_offset;
2424   unsigned int opb = bfd_octets_per_byte (abfd);
2425   /* Bytes per line.  */
2426   const int onaline = 16;
2427   char buf[64];
2428   int count;
2429   int width;
2430
2431   if ((section->flags & SEC_HAS_CONTENTS) == 0)
2432     return;
2433
2434   if (! process_section_p (section))
2435     return;
2436
2437   if ((datasize = bfd_section_size (abfd, section)) == 0)
2438     return;
2439
2440   printf (_("Contents of section %s:\n"), section->name);
2441
2442   data = xmalloc (datasize);
2443
2444   bfd_get_section_contents (abfd, section, data, 0, datasize);
2445
2446   /* Compute the address range to display.  */
2447   if (start_address == (bfd_vma) -1
2448       || start_address < section->vma)
2449     start_offset = 0;
2450   else
2451     start_offset = start_address - section->vma;
2452
2453   if (stop_address == (bfd_vma) -1)
2454     stop_offset = datasize / opb;
2455   else
2456     {
2457       if (stop_address < section->vma)
2458         stop_offset = 0;
2459       else
2460         stop_offset = stop_address - section->vma;
2461
2462       if (stop_offset > datasize / opb)
2463         stop_offset = datasize / opb;
2464     }
2465
2466   width = 4;
2467
2468   bfd_sprintf_vma (abfd, buf, start_offset + section->vma);
2469   if (strlen (buf) >= sizeof (buf))
2470     abort ();
2471
2472   count = 0;
2473   while (buf[count] == '0' && buf[count+1] != '\0')
2474     count++;
2475   count = strlen (buf) - count;
2476   if (count > width)
2477     width = count;
2478
2479   bfd_sprintf_vma (abfd, buf, stop_offset + section->vma - 1);
2480   if (strlen (buf) >= sizeof (buf))
2481     abort ();
2482
2483   count = 0;
2484   while (buf[count] == '0' && buf[count+1] != '\0')
2485     count++;
2486   count = strlen (buf) - count;
2487   if (count > width)
2488     width = count;
2489
2490   for (addr_offset = start_offset;
2491        addr_offset < stop_offset; addr_offset += onaline / opb)
2492     {
2493       bfd_size_type j;
2494
2495       bfd_sprintf_vma (abfd, buf, (addr_offset + section->vma));
2496       count = strlen (buf);
2497       if ((size_t) count >= sizeof (buf))
2498         abort ();
2499
2500       putchar (' ');
2501       while (count < width)
2502         {
2503           putchar ('0');
2504           count++;
2505         }
2506       fputs (buf + count - width, stdout);
2507       putchar (' ');
2508
2509       for (j = addr_offset * opb;
2510            j < addr_offset * opb + onaline; j++)
2511         {
2512           if (j < stop_offset * opb)
2513             printf ("%02x", (unsigned) (data[j]));
2514           else
2515             printf ("  ");
2516           if ((j & 3) == 3)
2517             printf (" ");
2518         }
2519
2520       printf (" ");
2521       for (j = addr_offset * opb;
2522            j < addr_offset * opb + onaline; j++)
2523         {
2524           if (j >= stop_offset * opb)
2525             printf (" ");
2526           else
2527             printf ("%c", ISPRINT (data[j]) ? data[j] : '.');
2528         }
2529       putchar ('\n');
2530     }
2531   free (data);
2532 }
2533
2534 /* Actually display the various requested regions.  */
2535
2536 static void
2537 dump_data (bfd *abfd)
2538 {
2539   bfd_map_over_sections (abfd, dump_section, NULL);
2540 }
2541
2542 /* Should perhaps share code and display with nm?  */
2543
2544 static void
2545 dump_symbols (bfd *abfd ATTRIBUTE_UNUSED, bfd_boolean dynamic)
2546 {
2547   asymbol **current;
2548   long max;
2549   long count;
2550
2551   if (dynamic)
2552     {
2553       current = dynsyms;
2554       max = dynsymcount;
2555       printf ("DYNAMIC SYMBOL TABLE:\n");
2556     }
2557   else
2558     {
2559       current = syms;
2560       max = symcount;
2561       printf ("SYMBOL TABLE:\n");
2562     }
2563
2564   if (max == 0)
2565     printf (_("no symbols\n"));
2566
2567   for (count = 0; count < max; count++)
2568     {
2569       bfd *cur_bfd;
2570
2571       if (*current == NULL)
2572         printf (_("no information for symbol number %ld\n"), count);
2573
2574       else if ((cur_bfd = bfd_asymbol_bfd (*current)) == NULL)
2575         printf (_("could not determine the type of symbol number %ld\n"),
2576                 count);
2577
2578       else if (process_section_p ((* current)->section)
2579                && (dump_special_syms
2580                    || !bfd_is_target_special_symbol (cur_bfd, *current)))
2581         {
2582           const char *name = (*current)->name;
2583
2584           if (do_demangle && name != NULL && *name != '\0')
2585             {
2586               char *alloc;
2587
2588               /* If we want to demangle the name, we demangle it
2589                  here, and temporarily clobber it while calling
2590                  bfd_print_symbol.  FIXME: This is a gross hack.  */
2591               alloc = bfd_demangle (cur_bfd, name, DMGL_ANSI | DMGL_PARAMS);
2592               if (alloc != NULL)
2593                 (*current)->name = alloc;
2594               bfd_print_symbol (cur_bfd, stdout, *current,
2595                                 bfd_print_symbol_all);
2596               if (alloc != NULL)
2597                 {
2598                   (*current)->name = name;
2599                   free (alloc);
2600                 }
2601             }
2602           else
2603             bfd_print_symbol (cur_bfd, stdout, *current,
2604                               bfd_print_symbol_all);
2605           printf ("\n");
2606         }
2607
2608       current++;
2609     }
2610   printf ("\n\n");
2611 }
2612 \f
2613 static void
2614 dump_reloc_set (bfd *abfd, asection *sec, arelent **relpp, long relcount)
2615 {
2616   arelent **p;
2617   char *last_filename, *last_functionname;
2618   unsigned int last_line;
2619
2620   /* Get column headers lined up reasonably.  */
2621   {
2622     static int width;
2623
2624     if (width == 0)
2625       {
2626         char buf[30];
2627
2628         bfd_sprintf_vma (abfd, buf, (bfd_vma) -1);
2629         width = strlen (buf) - 7;
2630       }
2631     printf ("OFFSET %*s TYPE %*s VALUE \n", width, "", 12, "");
2632   }
2633
2634   last_filename = NULL;
2635   last_functionname = NULL;
2636   last_line = 0;
2637
2638   for (p = relpp; relcount && *p != NULL; p++, relcount--)
2639     {
2640       arelent *q = *p;
2641       const char *filename, *functionname;
2642       unsigned int line;
2643       const char *sym_name;
2644       const char *section_name;
2645
2646       if (start_address != (bfd_vma) -1
2647           && q->address < start_address)
2648         continue;
2649       if (stop_address != (bfd_vma) -1
2650           && q->address > stop_address)
2651         continue;
2652
2653       if (with_line_numbers
2654           && sec != NULL
2655           && bfd_find_nearest_line (abfd, sec, syms, q->address,
2656                                     &filename, &functionname, &line))
2657         {
2658           if (functionname != NULL
2659               && (last_functionname == NULL
2660                   || strcmp (functionname, last_functionname) != 0))
2661             {
2662               printf ("%s():\n", functionname);
2663               if (last_functionname != NULL)
2664                 free (last_functionname);
2665               last_functionname = xstrdup (functionname);
2666             }
2667
2668           if (line > 0
2669               && (line != last_line
2670                   || (filename != NULL
2671                       && last_filename != NULL
2672                       && strcmp (filename, last_filename) != 0)))
2673             {
2674               printf ("%s:%u\n", filename == NULL ? "???" : filename, line);
2675               last_line = line;
2676               if (last_filename != NULL)
2677                 free (last_filename);
2678               if (filename == NULL)
2679                 last_filename = NULL;
2680               else
2681                 last_filename = xstrdup (filename);
2682             }
2683         }
2684
2685       if (q->sym_ptr_ptr && *q->sym_ptr_ptr)
2686         {
2687           sym_name = (*(q->sym_ptr_ptr))->name;
2688           section_name = (*(q->sym_ptr_ptr))->section->name;
2689         }
2690       else
2691         {
2692           sym_name = NULL;
2693           section_name = NULL;
2694         }
2695
2696       bfd_printf_vma (abfd, q->address);
2697       if (q->howto == NULL)
2698         printf (" *unknown*         ");
2699       else if (q->howto->name)
2700         printf (" %-16s  ", q->howto->name);
2701       else
2702         printf (" %-16d  ", q->howto->type);
2703       if (sym_name)
2704         objdump_print_symname (abfd, NULL, *q->sym_ptr_ptr);
2705       else
2706         {
2707           if (section_name == NULL)
2708             section_name = "*unknown*";
2709           printf ("[%s]", section_name);
2710         }
2711
2712       if (q->addend)
2713         {
2714           printf ("+0x");
2715           bfd_printf_vma (abfd, q->addend);
2716         }
2717
2718       printf ("\n");
2719     }
2720 }
2721
2722 static void
2723 dump_relocs_in_section (bfd *abfd,
2724                         asection *section,
2725                         void *dummy ATTRIBUTE_UNUSED)
2726 {
2727   arelent **relpp;
2728   long relcount;
2729   long relsize;
2730
2731   if (   bfd_is_abs_section (section)
2732       || bfd_is_und_section (section)
2733       || bfd_is_com_section (section)
2734       || (! process_section_p (section))
2735       || ((section->flags & SEC_RELOC) == 0))
2736     return;
2737
2738   relsize = bfd_get_reloc_upper_bound (abfd, section);
2739   if (relsize < 0)
2740     bfd_fatal (bfd_get_filename (abfd));
2741
2742   printf ("RELOCATION RECORDS FOR [%s]:", section->name);
2743
2744   if (relsize == 0)
2745     {
2746       printf (" (none)\n\n");
2747       return;
2748     }
2749
2750   relpp = xmalloc (relsize);
2751   relcount = bfd_canonicalize_reloc (abfd, section, relpp, syms);
2752
2753   if (relcount < 0)
2754     bfd_fatal (bfd_get_filename (abfd));
2755   else if (relcount == 0)
2756     printf (" (none)\n\n");
2757   else
2758     {
2759       printf ("\n");
2760       dump_reloc_set (abfd, section, relpp, relcount);
2761       printf ("\n\n");
2762     }
2763   free (relpp);
2764 }
2765
2766 static void
2767 dump_relocs (bfd *abfd)
2768 {
2769   bfd_map_over_sections (abfd, dump_relocs_in_section, NULL);
2770 }
2771
2772 static void
2773 dump_dynamic_relocs (bfd *abfd)
2774 {
2775   long relsize;
2776   arelent **relpp;
2777   long relcount;
2778
2779   relsize = bfd_get_dynamic_reloc_upper_bound (abfd);
2780   if (relsize < 0)
2781     bfd_fatal (bfd_get_filename (abfd));
2782
2783   printf ("DYNAMIC RELOCATION RECORDS");
2784
2785   if (relsize == 0)
2786     printf (" (none)\n\n");
2787   else
2788     {
2789       relpp = xmalloc (relsize);
2790       relcount = bfd_canonicalize_dynamic_reloc (abfd, relpp, dynsyms);
2791
2792       if (relcount < 0)
2793         bfd_fatal (bfd_get_filename (abfd));
2794       else if (relcount == 0)
2795         printf (" (none)\n\n");
2796       else
2797         {
2798           printf ("\n");
2799           dump_reloc_set (abfd, NULL, relpp, relcount);
2800           printf ("\n\n");
2801         }
2802       free (relpp);
2803     }
2804 }
2805
2806 /* Creates a table of paths, to search for source files.  */
2807
2808 static void
2809 add_include_path (const char *path)
2810 {
2811   if (path[0] == 0)
2812     return;
2813   include_path_count++;
2814   include_paths = xrealloc (include_paths,
2815                             include_path_count * sizeof (*include_paths));
2816 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
2817   if (path[1] == ':' && path[2] == 0)
2818     path = concat (path, ".", (const char *) 0);
2819 #endif
2820   include_paths[include_path_count - 1] = path;
2821 }
2822
2823 static void
2824 adjust_addresses (bfd *abfd ATTRIBUTE_UNUSED,
2825                   asection *section,
2826                   void *arg)
2827 {
2828   if ((section->flags & SEC_DEBUGGING) == 0)
2829     {
2830       bfd_boolean *has_reloc_p = (bfd_boolean *) arg;
2831       section->vma += adjust_section_vma;
2832       if (*has_reloc_p)
2833         section->lma += adjust_section_vma;
2834     }
2835 }
2836
2837 /* Dump selected contents of ABFD.  */
2838
2839 static void
2840 dump_bfd (bfd *abfd)
2841 {
2842   /* If we are adjusting section VMA's, change them all now.  Changing
2843      the BFD information is a hack.  However, we must do it, or
2844      bfd_find_nearest_line will not do the right thing.  */
2845   if (adjust_section_vma != 0)
2846     {
2847       bfd_boolean has_reloc = (abfd->flags & HAS_RELOC);
2848       bfd_map_over_sections (abfd, adjust_addresses, &has_reloc);
2849     }
2850
2851   if (! dump_debugging_tags)
2852     printf (_("\n%s:     file format %s\n"), bfd_get_filename (abfd),
2853             abfd->xvec->name);
2854   if (dump_ar_hdrs)
2855     print_arelt_descr (stdout, abfd, TRUE);
2856   if (dump_file_header)
2857     dump_bfd_header (abfd);
2858   if (dump_private_headers)
2859     dump_bfd_private_header (abfd);
2860   if (! dump_debugging_tags)
2861     putchar ('\n');
2862   if (dump_section_headers)
2863     dump_headers (abfd);
2864
2865   if (dump_symtab
2866       || dump_reloc_info
2867       || disassemble
2868       || dump_debugging
2869       || dump_dwarf_section_info)
2870     syms = slurp_symtab (abfd);
2871   if (dump_dynamic_symtab || dump_dynamic_reloc_info
2872       || (disassemble && bfd_get_dynamic_symtab_upper_bound (abfd) > 0))
2873     dynsyms = slurp_dynamic_symtab (abfd);
2874   if (disassemble)
2875     {
2876       synthcount = bfd_get_synthetic_symtab (abfd, symcount, syms,
2877                                              dynsymcount, dynsyms, &synthsyms);
2878       if (synthcount < 0)
2879         synthcount = 0;
2880     }
2881
2882   if (dump_symtab)
2883     dump_symbols (abfd, FALSE);
2884   if (dump_dynamic_symtab)
2885     dump_symbols (abfd, TRUE);
2886   if (dump_dwarf_section_info)
2887     dump_dwarf (abfd);
2888   if (dump_stab_section_info)
2889     dump_stabs (abfd);
2890   if (dump_reloc_info && ! disassemble)
2891     dump_relocs (abfd);
2892   if (dump_dynamic_reloc_info && ! disassemble)
2893     dump_dynamic_relocs (abfd);
2894   if (dump_section_contents)
2895     dump_data (abfd);
2896   if (disassemble)
2897     disassemble_data (abfd);
2898
2899   if (dump_debugging)
2900     {
2901       void *dhandle;
2902
2903       dhandle = read_debugging_info (abfd, syms, symcount);
2904       if (dhandle != NULL)
2905         {
2906           if (!print_debugging_info (stdout, dhandle, abfd, syms,
2907                                      bfd_demangle,
2908                                      dump_debugging_tags ? TRUE : FALSE))
2909             {
2910               non_fatal (_("%s: printing debugging information failed"),
2911                          bfd_get_filename (abfd));
2912               exit_status = 1;
2913             }
2914         }
2915     }
2916
2917   if (syms)
2918     {
2919       free (syms);
2920       syms = NULL;
2921     }
2922
2923   if (dynsyms)
2924     {
2925       free (dynsyms);
2926       dynsyms = NULL;
2927     }
2928
2929   if (synthsyms)
2930     {
2931       free (synthsyms);
2932       synthsyms = NULL;
2933     }
2934
2935   symcount = 0;
2936   dynsymcount = 0;
2937   synthcount = 0;
2938 }
2939
2940 static void
2941 display_bfd (bfd *abfd)
2942 {
2943   char **matching;
2944
2945   if (bfd_check_format_matches (abfd, bfd_object, &matching))
2946     {
2947       dump_bfd (abfd);
2948       return;
2949     }
2950
2951   if (bfd_get_error () == bfd_error_file_ambiguously_recognized)
2952     {
2953       nonfatal (bfd_get_filename (abfd));
2954       list_matching_formats (matching);
2955       free (matching);
2956       return;
2957     }
2958
2959   if (bfd_get_error () != bfd_error_file_not_recognized)
2960     {
2961       nonfatal (bfd_get_filename (abfd));
2962       return;
2963     }
2964
2965   if (bfd_check_format_matches (abfd, bfd_core, &matching))
2966     {
2967       dump_bfd (abfd);
2968       return;
2969     }
2970
2971   nonfatal (bfd_get_filename (abfd));
2972
2973   if (bfd_get_error () == bfd_error_file_ambiguously_recognized)
2974     {
2975       list_matching_formats (matching);
2976       free (matching);
2977     }
2978 }
2979
2980 static void
2981 display_file (char *filename, char *target)
2982 {
2983   bfd *file;
2984   bfd *arfile = NULL;
2985
2986   if (get_file_size (filename) < 1)
2987     {
2988       exit_status = 1;
2989       return;
2990     }
2991
2992   file = bfd_openr (filename, target);
2993   if (file == NULL)
2994     {
2995       nonfatal (filename);
2996       return;
2997     }
2998
2999   /* If the file is an archive, process all of its elements.  */
3000   if (bfd_check_format (file, bfd_archive))
3001     {
3002       bfd *last_arfile = NULL;
3003
3004       printf (_("In archive %s:\n"), bfd_get_filename (file));
3005       for (;;)
3006         {
3007           bfd_set_error (bfd_error_no_error);
3008
3009           arfile = bfd_openr_next_archived_file (file, arfile);
3010           if (arfile == NULL)
3011             {
3012               if (bfd_get_error () != bfd_error_no_more_archived_files)
3013                 nonfatal (bfd_get_filename (file));
3014               break;
3015             }
3016
3017           display_bfd (arfile);
3018
3019           if (last_arfile != NULL)
3020             bfd_close (last_arfile);
3021           last_arfile = arfile;
3022         }
3023
3024       if (last_arfile != NULL)
3025         bfd_close (last_arfile);
3026     }
3027   else
3028     display_bfd (file);
3029
3030   bfd_close (file);
3031 }
3032 \f
3033 int
3034 main (int argc, char **argv)
3035 {
3036   int c;
3037   char *target = default_target;
3038   bfd_boolean seenflag = FALSE;
3039
3040 #if defined (HAVE_SETLOCALE)
3041 #if defined (HAVE_LC_MESSAGES)
3042   setlocale (LC_MESSAGES, "");
3043 #endif
3044   setlocale (LC_CTYPE, "");
3045 #endif
3046
3047   bindtextdomain (PACKAGE, LOCALEDIR);
3048   textdomain (PACKAGE);
3049
3050   program_name = *argv;
3051   xmalloc_set_program_name (program_name);
3052
3053   START_PROGRESS (program_name, 0);
3054
3055   expandargv (&argc, &argv);
3056
3057   bfd_init ();
3058   set_default_bfd_target ();
3059
3060   while ((c = getopt_long (argc, argv, "pib:m:M:VvCdDlfaHhrRtTxsSI:j:wE:zgeGW",
3061                            long_options, (int *) 0))
3062          != EOF)
3063     {
3064       switch (c)
3065         {
3066         case 0:
3067           break;                /* We've been given a long option.  */
3068         case 'm':
3069           machine = optarg;
3070           break;
3071         case 'M':
3072           if (disassembler_options)
3073             /* Ignore potential memory leak for now.  */
3074             disassembler_options = concat (disassembler_options, ",",
3075                                            optarg, NULL);
3076           else
3077             disassembler_options = optarg;
3078           break;
3079         case 'j':
3080           if (only_used == only_size)
3081             {
3082               only_size += 8;
3083               only = xrealloc (only, only_size * sizeof (char *));
3084             }
3085           only [only_used++] = optarg;
3086           break;
3087         case 'l':
3088           with_line_numbers = TRUE;
3089           break;
3090         case 'b':
3091           target = optarg;
3092           break;
3093         case 'C':
3094           do_demangle = TRUE;
3095           if (optarg != NULL)
3096             {
3097               enum demangling_styles style;
3098
3099               style = cplus_demangle_name_to_style (optarg);
3100               if (style == unknown_demangling)
3101                 fatal (_("unknown demangling style `%s'"),
3102                        optarg);
3103
3104               cplus_demangle_set_style (style);
3105             }
3106           break;
3107         case 'w':
3108           wide_output = TRUE;
3109           break;
3110         case OPTION_ADJUST_VMA:
3111           adjust_section_vma = parse_vma (optarg, "--adjust-vma");
3112           break;
3113         case OPTION_START_ADDRESS:
3114           start_address = parse_vma (optarg, "--start-address");
3115           break;
3116         case OPTION_STOP_ADDRESS:
3117           stop_address = parse_vma (optarg, "--stop-address");
3118           break;
3119         case 'E':
3120           if (strcmp (optarg, "B") == 0)
3121             endian = BFD_ENDIAN_BIG;
3122           else if (strcmp (optarg, "L") == 0)
3123             endian = BFD_ENDIAN_LITTLE;
3124           else
3125             {
3126               non_fatal (_("unrecognized -E option"));
3127               usage (stderr, 1);
3128             }
3129           break;
3130         case OPTION_ENDIAN:
3131           if (strncmp (optarg, "big", strlen (optarg)) == 0)
3132             endian = BFD_ENDIAN_BIG;
3133           else if (strncmp (optarg, "little", strlen (optarg)) == 0)
3134             endian = BFD_ENDIAN_LITTLE;
3135           else
3136             {
3137               non_fatal (_("unrecognized --endian type `%s'"), optarg);
3138               usage (stderr, 1);
3139             }
3140           break;
3141
3142         case 'f':
3143           dump_file_header = TRUE;
3144           seenflag = TRUE;
3145           break;
3146         case 'i':
3147           formats_info = TRUE;
3148           seenflag = TRUE;
3149           break;
3150         case 'I':
3151           add_include_path (optarg);
3152           break;
3153         case 'p':
3154           dump_private_headers = TRUE;
3155           seenflag = TRUE;
3156           break;
3157         case 'x':
3158           dump_private_headers = TRUE;
3159           dump_symtab = TRUE;
3160           dump_reloc_info = TRUE;
3161           dump_file_header = TRUE;
3162           dump_ar_hdrs = TRUE;
3163           dump_section_headers = TRUE;
3164           seenflag = TRUE;
3165           break;
3166         case 't':
3167           dump_symtab = TRUE;
3168           seenflag = TRUE;
3169           break;
3170         case 'T':
3171           dump_dynamic_symtab = TRUE;
3172           seenflag = TRUE;
3173           break;
3174         case 'd':
3175           disassemble = TRUE;
3176           seenflag = TRUE;
3177           break;
3178         case 'z':
3179           disassemble_zeroes = TRUE;
3180           break;
3181         case 'D':
3182           disassemble = TRUE;
3183           disassemble_all = TRUE;
3184           seenflag = TRUE;
3185           break;
3186         case 'S':
3187           disassemble = TRUE;
3188           with_source_code = TRUE;
3189           seenflag = TRUE;
3190           break;
3191         case 'g':
3192           dump_debugging = 1;
3193           seenflag = TRUE;
3194           break;
3195         case 'e':
3196           dump_debugging = 1;
3197           dump_debugging_tags = 1;
3198           do_demangle = TRUE;
3199           seenflag = TRUE;
3200           break;
3201         case 'W':
3202           dump_dwarf_section_info = TRUE;
3203           seenflag = TRUE;
3204           do_debug_info = 1;
3205           do_debug_abbrevs = 1;
3206           do_debug_lines = 1;
3207           do_debug_pubnames = 1;
3208           do_debug_aranges = 1;
3209           do_debug_ranges = 1;
3210           do_debug_frames = 1;
3211           do_debug_macinfo = 1;
3212           do_debug_str = 1;
3213           do_debug_loc = 1;
3214           break;
3215         case 'G':
3216           dump_stab_section_info = TRUE;
3217           seenflag = TRUE;
3218           break;
3219         case 's':
3220           dump_section_contents = TRUE;
3221           seenflag = TRUE;
3222           break;
3223         case 'r':
3224           dump_reloc_info = TRUE;
3225           seenflag = TRUE;
3226           break;
3227         case 'R':
3228           dump_dynamic_reloc_info = TRUE;
3229           seenflag = TRUE;
3230           break;
3231         case 'a':
3232           dump_ar_hdrs = TRUE;
3233           seenflag = TRUE;
3234           break;
3235         case 'h':
3236           dump_section_headers = TRUE;
3237           seenflag = TRUE;
3238           break;
3239         case 'H':
3240           usage (stdout, 0);
3241           seenflag = TRUE;
3242         case 'v':
3243         case 'V':
3244           show_version = TRUE;
3245           seenflag = TRUE;
3246           break;
3247
3248         default:
3249           usage (stderr, 1);
3250         }
3251     }
3252
3253   if (show_version)
3254     print_version ("objdump");
3255
3256   if (!seenflag)
3257     usage (stderr, 2);
3258
3259   if (formats_info)
3260     exit_status = display_info ();
3261   else
3262     {
3263       if (optind == argc)
3264         display_file ("a.out", target);
3265       else
3266         for (; optind < argc;)
3267           display_file (argv[optind++], target);
3268     }
3269
3270   END_PROGRESS (program_name);
3271
3272   return exit_status;
3273 }