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