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