binutils/objdump.c

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