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 "bfd.h"
  52 #include "progress.h"
  53 #include "bucomm.h"
  54 #include "dwarf.h"
  55 #include "budemang.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 = demangle (abfd, name);
 653       name = alloc;
 654     }
 655
 656   if (info != NULL)
 657     (*info->fprintf_func) (info->stream, "%s", name);
 658   else
 659     printf ("%s", name);
 660
 661   if (alloc != NULL)
 662     free (alloc);
 663 }
 664
 665 /* Locate a symbol given a bfd and a section (from INFO->application_data),
 666    and a VMA.  If INFO->application_data->require_sec is TRUE, then always
 667    require the symbol to be in the section.  Returns NULL if there is no
 668    suitable symbol.  If PLACE is not NULL, then *PLACE is set to the index
 669    of the symbol in sorted_syms.  */
 670
 671 static asymbol *
 672 find_symbol_for_address (bfd_vma vma,
 673                          struct disassemble_info *info,
 674                          long *place)
 675 {
 676   /* @@ Would it speed things up to cache the last two symbols returned,
 677      and maybe their address ranges?  For many processors, only one memory
 678      operand can be present at a time, so the 2-entry cache wouldn't be
 679      constantly churned by code doing heavy memory accesses.  */
 680
 681   /* Indices in `sorted_syms'.  */
 682   long min = 0;
 683   long max = sorted_symcount;
 684   long thisplace;
 685   struct objdump_disasm_info *aux;
 686   bfd *abfd;
 687   asection *sec;
 688   unsigned int opb;
 689
 690   if (sorted_symcount < 1)
 691     return NULL;
 692
 693   aux = (struct objdump_disasm_info *) info->application_data;
 694   abfd = aux->abfd;
 695   sec = aux->sec;
 696   opb = bfd_octets_per_byte (abfd);
 697
 698   /* Perform a binary search looking for the closest symbol to the
 699      required value.  We are searching the range (min, max].  */
 700   while (min + 1 < max)
 701     {
 702       asymbol *sym;
 703
 704       thisplace = (max + min) / 2;
 705       sym = sorted_syms[thisplace];
 706
 707       if (bfd_asymbol_value (sym) > vma)
 708         max = thisplace;
 709       else if (bfd_asymbol_value (sym) < vma)
 710         min = thisplace;
 711       else
 712         {
 713           min = thisplace;
 714           break;
 715         }
 716     }
 717
 718   /* The symbol we want is now in min, the low end of the range we
 719      were searching.  If there are several symbols with the same
 720      value, we want the first one.  */
 721   thisplace = min;
 722   while (thisplace > 0
 723          && (bfd_asymbol_value (sorted_syms[thisplace])
 724              == bfd_asymbol_value (sorted_syms[thisplace - 1])))
 725     --thisplace;
 726
 727   /* If the file is relocatable, and the symbol could be from this
 728      section, prefer a symbol from this section over symbols from
 729      others, even if the other symbol's value might be closer.
 730
 731      Note that this may be wrong for some symbol references if the
 732      sections have overlapping memory ranges, but in that case there's
 733      no way to tell what's desired without looking at the relocation
 734      table.  */
 735   if (sorted_syms[thisplace]->section != sec
 736       && (aux->require_sec
 737           || ((abfd->flags & HAS_RELOC) != 0
 738               && vma >= bfd_get_section_vma (abfd, sec)
 739               && vma < (bfd_get_section_vma (abfd, sec)
 740                         + bfd_section_size (abfd, sec) / opb))))
 741     {
 742       long i;
 743
 744       for (i = thisplace + 1; i < sorted_symcount; i++)
 745         {
 746           if (bfd_asymbol_value (sorted_syms[i])
 747               != bfd_asymbol_value (sorted_syms[thisplace]))
 748             break;
 749         }
 750
 751       --i;
 752
 753       for (; i >= 0; i--)
 754         {
 755           if (sorted_syms[i]->section == sec
 756               && (i == 0
 757                   || sorted_syms[i - 1]->section != sec
 758                   || (bfd_asymbol_value (sorted_syms[i])
 759                       != bfd_asymbol_value (sorted_syms[i - 1]))))
 760             {
 761               thisplace = i;
 762               break;
 763             }
 764         }
 765
 766       if (sorted_syms[thisplace]->section != sec)
 767         {
 768           /* We didn't find a good symbol with a smaller value.
 769              Look for one with a larger value.  */
 770           for (i = thisplace + 1; i < sorted_symcount; i++)
 771             {
 772               if (sorted_syms[i]->section == sec)
 773                 {
 774                   thisplace = i;
 775                   break;
 776                 }
 777             }
 778         }
 779
 780       if (sorted_syms[thisplace]->section != sec
 781           && (aux->require_sec
 782               || ((abfd->flags & HAS_RELOC) != 0
 783                   && vma >= bfd_get_section_vma (abfd, sec)
 784                   && vma < (bfd_get_section_vma (abfd, sec)
 785                             + bfd_section_size (abfd, sec)))))
 786         /* There is no suitable symbol.  */
 787         return NULL;
 788     }
 789
 790   /* Give the target a chance to reject the symbol.  */
 791   while (! info->symbol_is_valid (sorted_syms [thisplace], info))
 792     {
 793       ++ thisplace;
 794       if (thisplace >= sorted_symcount
 795           || bfd_asymbol_value (sorted_syms [thisplace]) > vma)
 796         return NULL;
 797     }
 798
 799   if (place != NULL)
 800     *place = thisplace;
 801
 802   return sorted_syms[thisplace];
 803 }
 804
 805 /* Print an address and the offset to the nearest symbol.  */
 806
 807 static void
 808 objdump_print_addr_with_sym (bfd *abfd, asection *sec, asymbol *sym,
 809                              bfd_vma vma, struct disassemble_info *info,
 810                              bfd_boolean skip_zeroes)
 811 {
 812   objdump_print_value (vma, info, skip_zeroes);
 813
 814   if (sym == NULL)
 815     {
 816       bfd_vma secaddr;
 817
 818       (*info->fprintf_func) (info->stream, " <%s",
 819                              bfd_get_section_name (abfd, sec));
 820       secaddr = bfd_get_section_vma (abfd, sec);
 821       if (vma < secaddr)
 822         {
 823           (*info->fprintf_func) (info->stream, "-0x");
 824           objdump_print_value (secaddr - vma, info, TRUE);
 825         }
 826       else if (vma > secaddr)
 827         {
 828           (*info->fprintf_func) (info->stream, "+0x");
 829           objdump_print_value (vma - secaddr, info, TRUE);
 830         }
 831       (*info->fprintf_func) (info->stream, ">");
 832     }
 833   else
 834     {
 835       (*info->fprintf_func) (info->stream, " <");
 836       objdump_print_symname (abfd, info, sym);
 837       if (bfd_asymbol_value (sym) > vma)
 838         {
 839           (*info->fprintf_func) (info->stream, "-0x");
 840           objdump_print_value (bfd_asymbol_value (sym) - vma, info, TRUE);
 841         }
 842       else if (vma > bfd_asymbol_value (sym))
 843         {
 844           (*info->fprintf_func) (info->stream, "+0x");
 845           objdump_print_value (vma - bfd_asymbol_value (sym), info, TRUE);
 846         }
 847       (*info->fprintf_func) (info->stream, ">");
 848     }
 849 }
 850
 851 /* Print an address (VMA), symbolically if possible.
 852    If SKIP_ZEROES is TRUE, don't output leading zeroes.  */
 853
 854 static void
 855 objdump_print_addr (bfd_vma vma,
 856                     struct disassemble_info *info,
 857                     bfd_boolean skip_zeroes)
 858 {
 859   struct objdump_disasm_info *aux;
 860   asymbol *sym = NULL; /* Initialize to avoid compiler warning.  */
 861   bfd_boolean skip_find = FALSE;
 862
 863   if (sorted_symcount < 1)
 864     {
 865       (*info->fprintf_func) (info->stream, "0x");
 866       objdump_print_value (vma, info, skip_zeroes);
 867       return;
 868     }
 869
 870   aux = (struct objdump_disasm_info *) info->application_data;
 871
 872   if (aux->reloc != NULL
 873       && aux->reloc->sym_ptr_ptr != NULL
 874       && * aux->reloc->sym_ptr_ptr != NULL)
 875     {
 876       sym = * aux->reloc->sym_ptr_ptr;
 877
 878       /* Adjust the vma to the reloc.  */
 879       vma += bfd_asymbol_value (sym);
 880
 881       if (bfd_is_und_section (bfd_get_section (sym)))
 882         skip_find = TRUE;
 883     }
 884
 885   if (!skip_find)
 886     sym = find_symbol_for_address (vma, info, NULL);
 887
 888   objdump_print_addr_with_sym (aux->abfd, aux->sec, sym, vma, info,
 889                                skip_zeroes);
 890 }
 891
 892 /* Print VMA to INFO.  This function is passed to the disassembler
 893    routine.  */
 894
 895 static void
 896 objdump_print_address (bfd_vma vma, struct disassemble_info *info)
 897 {
 898   objdump_print_addr (vma, info, ! prefix_addresses);
 899 }
 900
 901 /* Determine if the given address has a symbol associated with it.  */
 902
 903 static int
 904 objdump_symbol_at_address (bfd_vma vma, struct disassemble_info * info)
 905 {
 906   asymbol * sym;
 907
 908   sym = find_symbol_for_address (vma, info, NULL);
 909
 910   return (sym != NULL && (bfd_asymbol_value (sym) == vma));
 911 }
 912
 913 /* Hold the last function name and the last line number we displayed
 914    in a disassembly.  */
 915
 916 static char *prev_functionname;
 917 static unsigned int prev_line;
 918
 919 /* We keep a list of all files that we have seen when doing a
 920    disassembly with source, so that we know how much of the file to
 921    display.  This can be important for inlined functions.  */
 922
 923 struct print_file_list
 924 {
 925   struct print_file_list *next;
 926   const char *filename;
 927   const char *modname;
 928   unsigned int line;
 929   FILE *f;
 930 };
 931
 932 static struct print_file_list *print_files;
 933
 934 /* The number of preceding context lines to show when we start
 935    displaying a file for the first time.  */
 936
 937 #define SHOW_PRECEDING_CONTEXT_LINES (5)
 938
 939 /* Tries to open MODNAME, and if successful adds a node to print_files
 940    linked list and returns that node.  Returns NULL on failure.  */
 941
 942 static struct print_file_list *
 943 try_print_file_open (const char *origname, const char *modname)
 944 {
 945   struct print_file_list *p;
 946   FILE *f;
 947
 948   f = fopen (modname, "r");
 949   if (f == NULL)
 950     return NULL;
 951
 952   if (print_files != NULL && print_files->f != NULL)
 953     {
 954       fclose (print_files->f);
 955       print_files->f = NULL;
 956     }
 957
 958   p = xmalloc (sizeof (struct print_file_list));
 959   p->filename = origname;
 960   p->modname = modname;
 961   p->line = 0;
 962   p->f = f;
 963   p->next = print_files;
 964   print_files = p;
 965   return p;
 966 }
 967
 968 /* If the the source file, as described in the symtab, is not found
 969    try to locate it in one of the paths specified with -I
 970    If found, add location to print_files linked list.  */
 971
 972 static struct print_file_list *
 973 update_source_path (const char *filename)
 974 {
 975   struct print_file_list *p;
 976   const char *fname;
 977   int i;
 978
 979   if (filename == NULL)
 980     return NULL;
 981
 982   p = try_print_file_open (filename, filename);
 983   if (p != NULL)
 984     return p;
 985
 986   if (include_path_count == 0)
 987     return NULL;
 988
 989   /* Get the name of the file.  */
 990   fname = strrchr (filename, '/');
 991 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
 992   {
 993     /* We could have a mixed forward/back slash case.  */
 994     char *backslash = strrchr (filename, '\\');
 995     if (fname == NULL || (backslash != NULL && backslash > fname))
 996       fname = backslash;
 997     if (fname == NULL && filename[0] != '\0' && filename[1] == ':')
 998       fname = filename + 1;
 999   }
1000 #endif
1001   if (fname == NULL)
1002     fname = filename;
1003   else
1004     ++fname;
1005
1006   /* If file exists under a new path, we need to add it to the list
1007      so that show_line knows about it.  */
1008   for (i = 0; i < include_path_count; i++)
1009     {
1010       char *modname = concat (include_paths[i], "/", fname, (const char *) 0);
1011
1012       p = try_print_file_open (filename, modname);
1013       if (p)
1014         return p;
1015
1016       free (modname);
1017     }
1018
1019   return NULL;
1020 }
1021
1022 /* Skip ahead to a given line in a file, optionally printing each
1023    line.  */
1024
1025 static void
1026 skip_to_line (struct print_file_list *p, unsigned int line,
1027               bfd_boolean show)
1028 {
1029   while (p->line < line)
1030     {
1031       char buf[100];
1032
1033       if (fgets (buf, sizeof buf, p->f) == NULL)
1034         {
1035           fclose (p->f);
1036           p->f = NULL;
1037           break;
1038         }
1039
1040       if (show)
1041         printf ("%s", buf);
1042
1043       if (strchr (buf, '\n') != NULL)
1044         ++p->line;
1045     }
1046 }
1047
1048 /* Show the line number, or the source line, in a disassembly
1049    listing.  */
1050
1051 static void
1052 show_line (bfd *abfd, asection *section, bfd_vma addr_offset)
1053 {
1054   const char *filename;
1055   const char *functionname;
1056   unsigned int line;
1057
1058   if (! with_line_numbers && ! with_source_code)
1059     return;
1060
1061   if (! bfd_find_nearest_line (abfd, section, syms, addr_offset, &filename,
1062                                &functionname, &line))
1063     return;
1064
1065   if (filename != NULL && *filename == '\0')
1066     filename = NULL;
1067   if (functionname != NULL && *functionname == '\0')
1068     functionname = NULL;
1069
1070   if (with_line_numbers)
1071     {
1072       if (functionname != NULL
1073           && (prev_functionname == NULL
1074               || strcmp (functionname, prev_functionname) != 0))
1075         printf ("%s():\n", functionname);
1076       if (line > 0 && line != prev_line)
1077         printf ("%s:%u\n", filename == NULL ? "???" : filename, line);
1078     }
1079
1080   if (with_source_code
1081       && filename != NULL
1082       && line > 0)
1083     {
1084       struct print_file_list **pp, *p;
1085
1086       for (pp = &print_files; *pp != NULL; pp = &(*pp)->next)
1087         if (strcmp ((*pp)->filename, filename) == 0)
1088           break;
1089       p = *pp;
1090
1091       if (p != NULL)
1092         {
1093           if (p != print_files)
1094             {
1095               int l;
1096
1097               /* We have reencountered a file name which we saw
1098                  earlier.  This implies that either we are dumping out
1099                  code from an included file, or the same file was
1100                  linked in more than once.  There are two common cases
1101                  of an included file: inline functions in a header
1102                  file, and a bison or flex skeleton file.  In the
1103                  former case we want to just start printing (but we
1104                  back up a few lines to give context); in the latter
1105                  case we want to continue from where we left off.  I
1106                  can't think of a good way to distinguish the cases,
1107                  so I used a heuristic based on the file name.  */
1108               if (strcmp (p->filename + strlen (p->filename) - 2, ".h") != 0)
1109                 l = p->line;
1110               else
1111                 {
1112                   l = line - SHOW_PRECEDING_CONTEXT_LINES;
1113                   if (l < 0)
1114                     l = 0;
1115                 }
1116
1117               if (p->f == NULL)
1118                 {
1119                   p->f = fopen (p->modname, "r");
1120                   p->line = 0;
1121                 }
1122               if (p->f != NULL)
1123                 skip_to_line (p, l, FALSE);
1124
1125               if (print_files->f != NULL)
1126                 {
1127                   fclose (print_files->f);
1128                   print_files->f = NULL;
1129                 }
1130             }
1131
1132           if (p->f != NULL)
1133             {
1134               skip_to_line (p, line, TRUE);
1135               *pp = p->next;
1136               p->next = print_files;
1137               print_files = p;
1138             }
1139         }
1140       else
1141         {
1142           p = update_source_path (filename);
1143
1144           if (p != NULL)
1145             {
1146               int l;
1147
1148               if (file_start_context)
1149                 l = 0;
1150               else
1151                 l = line - SHOW_PRECEDING_CONTEXT_LINES;
1152               if (l < 0)
1153                 l = 0;
1154               skip_to_line (p, l, FALSE);
1155               if (p->f != NULL)
1156                 skip_to_line (p, line, TRUE);
1157             }
1158         }
1159     }
1160
1161   if (functionname != NULL
1162       && (prev_functionname == NULL
1163           || strcmp (functionname, prev_functionname) != 0))
1164     {
1165       if (prev_functionname != NULL)
1166         free (prev_functionname);
1167       prev_functionname = xmalloc (strlen (functionname) + 1);
1168       strcpy (prev_functionname, functionname);
1169     }
1170
1171   if (line > 0 && line != prev_line)
1172     prev_line = line;
1173 }
1174
1175 /* Pseudo FILE object for strings.  */
1176 typedef struct
1177 {
1178   char *buffer;
1179   size_t pos;
1180   size_t alloc;
1181 } SFILE;
1182
1183 /* sprintf to a "stream".  */
1184
1185 static int ATTRIBUTE_PRINTF_2
1186 objdump_sprintf (SFILE *f, const char *format, ...)
1187 {
1188   size_t n;
1189   va_list args;
1190
1191   while (1)
1192     {
1193       size_t space = f->alloc - f->pos;
1194
1195       va_start (args, format);
1196       n = vsnprintf (f->buffer + f->pos, space, format, args);
1197       va_end (args);
1198
1199       if (space > n)
1200         break;
1201
1202       f->alloc = (f->alloc + n) * 2;
1203       f->buffer = xrealloc (f->buffer, f->alloc);
1204     }
1205   f->pos += n;
1206
1207   return n;
1208 }
1209
1210 /* Returns TRUE if the specified section should be dumped.  */
1211
1212 static bfd_boolean
1213 process_section_p (asection * section)
1214 {
1215   size_t i;
1216
1217   if (only == NULL)
1218     return TRUE;
1219
1220   for (i = 0; i < only_used; i++)
1221     if (strcmp (only [i], section->name) == 0)
1222       return TRUE;
1223
1224   return FALSE;
1225 }
1226
1227
1228 /* The number of zeroes we want to see before we start skipping them.
1229    The number is arbitrarily chosen.  */
1230
1231 #define DEFAULT_SKIP_ZEROES 8
1232
1233 /* The number of zeroes to skip at the end of a section.  If the
1234    number of zeroes at the end is between SKIP_ZEROES_AT_END and
1235    SKIP_ZEROES, they will be disassembled.  If there are fewer than
1236    SKIP_ZEROES_AT_END, they will be skipped.  This is a heuristic
1237    attempt to avoid disassembling zeroes inserted by section
1238    alignment.  */
1239
1240 #define DEFAULT_SKIP_ZEROES_AT_END 3
1241
1242 /* Disassemble some data in memory between given values.  */
1243
1244 static void
1245 disassemble_bytes (struct disassemble_info * info,
1246                    disassembler_ftype        disassemble_fn,
1247                    bfd_boolean               insns,
1248                    bfd_byte *                data,
1249                    bfd_vma                   start_offset,
1250                    bfd_vma                   stop_offset,
1251                    bfd_vma                   rel_offset,
1252                    arelent ***               relppp,
1253                    arelent **                relppend)
1254 {
1255   struct objdump_disasm_info *aux;
1256   asection *section;
1257   int octets_per_line;
1258   bfd_boolean done_dot;
1259   int skip_addr_chars;
1260   bfd_vma addr_offset;
1261   unsigned int opb = info->octets_per_byte;
1262   unsigned int skip_zeroes = info->skip_zeroes;
1263   unsigned int skip_zeroes_at_end = info->skip_zeroes_at_end;
1264   int octets = opb;
1265   SFILE sfile;
1266
1267   aux = (struct objdump_disasm_info *) info->application_data;
1268   section = aux->sec;
1269
1270   sfile.alloc = 120;
1271   sfile.buffer = xmalloc (sfile.alloc);
1272   sfile.pos = 0;
1273
1274   if (insns)
1275     octets_per_line = 4;
1276   else
1277     octets_per_line = 16;
1278
1279   /* Figure out how many characters to skip at the start of an
1280      address, to make the disassembly look nicer.  We discard leading
1281      zeroes in chunks of 4, ensuring that there is always a leading
1282      zero remaining.  */
1283   skip_addr_chars = 0;
1284   if (! prefix_addresses)
1285     {
1286       char buf[30];
1287       char *s;
1288
1289       bfd_sprintf_vma
1290         (aux->abfd, buf,
1291          (section->vma
1292           + bfd_section_size (section->owner, section) / opb));
1293       s = buf;
1294       while (s[0] == '0' && s[1] == '0' && s[2] == '0' && s[3] == '0'
1295              && s[4] == '0')
1296         {
1297           skip_addr_chars += 4;
1298           s += 4;
1299         }
1300     }
1301
1302   info->insn_info_valid = 0;
1303
1304   done_dot = FALSE;
1305   addr_offset = start_offset;
1306   while (addr_offset < stop_offset)
1307     {
1308       bfd_vma z;
1309       bfd_boolean need_nl = FALSE;
1310       int previous_octets;
1311
1312       /* Remember the length of the previous instruction.  */
1313       previous_octets = octets;
1314       octets = 0;
1315
1316       /* If we see more than SKIP_ZEROES octets of zeroes, we just
1317          print `...'.  */
1318       for (z = addr_offset * opb; z < stop_offset * opb; z++)
1319         if (data[z] != 0)
1320           break;
1321       if (! disassemble_zeroes
1322           && (info->insn_info_valid == 0
1323               || info->branch_delay_insns == 0)
1324           && (z - addr_offset * opb >= skip_zeroes
1325               || (z == stop_offset * opb &&
1326                   z - addr_offset * opb < skip_zeroes_at_end)))
1327         {
1328           printf ("\t...\n");
1329
1330           /* If there are more nonzero octets to follow, we only skip
1331              zeroes in multiples of 4, to try to avoid running over
1332              the start of an instruction which happens to start with
1333              zero.  */
1334           if (z != stop_offset * opb)
1335             z = addr_offset * opb + ((z - addr_offset * opb) &~ 3);
1336
1337           octets = z - addr_offset * opb;
1338         }
1339       else
1340         {
1341           char buf[50];
1342           int bpc = 0;
1343           int pb = 0;
1344
1345           done_dot = FALSE;
1346
1347           if (with_line_numbers || with_source_code)
1348             show_line (aux->abfd, section, addr_offset);
1349
1350           if (! prefix_addresses)
1351             {
1352               char *s;
1353
1354               bfd_sprintf_vma (aux->abfd, buf, section->vma + addr_offset);
1355               for (s = buf + skip_addr_chars; *s == '0'; s++)
1356                 *s = ' ';
1357               if (*s == '\0')
1358                 *--s = '0';
1359               printf ("%s:\t", buf + skip_addr_chars);
1360             }
1361           else
1362             {
1363               aux->require_sec = TRUE;
1364               objdump_print_address (section->vma + addr_offset, info);
1365               aux->require_sec = FALSE;
1366               putchar (' ');
1367             }
1368
1369           if (insns)
1370             {
1371               sfile.pos = 0;
1372               info->fprintf_func = (fprintf_ftype) objdump_sprintf;
1373               info->stream = &sfile;
1374               info->bytes_per_line = 0;
1375               info->bytes_per_chunk = 0;
1376               info->flags = 0;
1377
1378               if (info->disassembler_needs_relocs
1379                   && *relppp < relppend)
1380                 {
1381                   bfd_signed_vma distance_to_rel;
1382
1383                   distance_to_rel = (**relppp)->address
1384                     - (rel_offset + addr_offset);
1385
1386                   /* Check to see if the current reloc is associated with
1387                      the instruction that we are about to disassemble.  */
1388                   if (distance_to_rel == 0
1389                       /* FIXME: This is wrong.  We are trying to catch
1390                          relocs that are addressed part way through the
1391                          current instruction, as might happen with a packed
1392                          VLIW instruction.  Unfortunately we do not know the
1393                          length of the current instruction since we have not
1394                          disassembled it yet.  Instead we take a guess based
1395                          upon the length of the previous instruction.  The
1396                          proper solution is to have a new target-specific
1397                          disassembler function which just returns the length
1398                          of an instruction at a given address without trying
1399                          to display its disassembly. */
1400                       || (distance_to_rel > 0
1401                           && distance_to_rel < (bfd_signed_vma) (previous_octets/ opb)))
1402                     {
1403                       info->flags = INSN_HAS_RELOC;
1404                       aux->reloc = **relppp;
1405                     }
1406                   else
1407                     aux->reloc = NULL;
1408                 }
1409
1410               octets = (*disassemble_fn) (section->vma + addr_offset, info);
1411               info->fprintf_func = (fprintf_ftype) fprintf;
1412               info->stream = stdout;
1413               if (info->bytes_per_line != 0)
1414                 octets_per_line = info->bytes_per_line;
1415               if (octets < 0)
1416                 {
1417                   if (sfile.pos)
1418                     printf ("%s\n", sfile.buffer);
1419                   break;
1420                 }
1421             }
1422           else
1423             {
1424               bfd_vma j;
1425
1426               octets = octets_per_line;
1427               if (addr_offset + octets / opb > stop_offset)
1428                 octets = (stop_offset - addr_offset) * opb;
1429
1430               for (j = addr_offset * opb; j < addr_offset * opb + octets; ++j)
1431                 {
1432                   if (ISPRINT (data[j]))
1433                     buf[j - addr_offset * opb] = data[j];
1434                   else
1435                     buf[j - addr_offset * opb] = '.';
1436                 }
1437               buf[j - addr_offset * opb] = '\0';
1438             }
1439
1440           if (prefix_addresses
1441               ? show_raw_insn > 0
1442               : show_raw_insn >= 0)
1443             {
1444               bfd_vma j;
1445
1446               /* If ! prefix_addresses and ! wide_output, we print
1447                  octets_per_line octets per line.  */
1448               pb = octets;
1449               if (pb > octets_per_line && ! prefix_addresses && ! wide_output)
1450                 pb = octets_per_line;
1451
1452               if (info->bytes_per_chunk)
1453                 bpc = info->bytes_per_chunk;
1454               else
1455                 bpc = 1;
1456
1457               for (j = addr_offset * opb; j < addr_offset * opb + pb; j += bpc)
1458                 {
1459                   int k;
1460
1461                   if (bpc > 1 && info->display_endian == BFD_ENDIAN_LITTLE)
1462                     {
1463                       for (k = bpc - 1; k >= 0; k--)
1464                         printf ("%02x", (unsigned) data[j + k]);
1465                       putchar (' ');
1466                     }
1467                   else
1468                     {
1469                       for (k = 0; k < bpc; k++)
1470                         printf ("%02x", (unsigned) data[j + k]);
1471                       putchar (' ');
1472                     }
1473                 }
1474
1475               for (; pb < octets_per_line; pb += bpc)
1476                 {
1477                   int k;
1478
1479                   for (k = 0; k < bpc; k++)
1480                     printf ("  ");
1481                   putchar (' ');
1482                 }
1483
1484               /* Separate raw data from instruction by extra space.  */
1485               if (insns)
1486                 putchar ('\t');
1487               else
1488                 printf ("    ");
1489             }
1490
1491           if (! insns)
1492             printf ("%s", buf);
1493           else if (sfile.pos)
1494             printf ("%s", sfile.buffer);
1495
1496           if (prefix_addresses
1497               ? show_raw_insn > 0
1498               : show_raw_insn >= 0)
1499             {
1500               while (pb < octets)
1501                 {
1502                   bfd_vma j;
1503                   char *s;
1504
1505                   putchar ('\n');
1506                   j = addr_offset * opb + pb;
1507
1508                   bfd_sprintf_vma (aux->abfd, buf, section->vma + j / opb);
1509                   for (s = buf + skip_addr_chars; *s == '0'; s++)
1510                     *s = ' ';
1511                   if (*s == '\0')
1512                     *--s = '0';
1513                   printf ("%s:\t", buf + skip_addr_chars);
1514
1515                   pb += octets_per_line;
1516                   if (pb > octets)
1517                     pb = octets;
1518                   for (; j < addr_offset * opb + pb; j += bpc)
1519                     {
1520                       int k;
1521
1522                       if (bpc > 1 && info->display_endian == BFD_ENDIAN_LITTLE)
1523                         {
1524                           for (k = bpc - 1; k >= 0; k--)
1525                             printf ("%02x", (unsigned) data[j + k]);
1526                           putchar (' ');
1527                         }
1528                       else
1529                         {
1530                           for (k = 0; k < bpc; k++)
1531                             printf ("%02x", (unsigned) data[j + k]);
1532                           putchar (' ');
1533                         }
1534                     }
1535                 }
1536             }
1537
1538           if (!wide_output)
1539             putchar ('\n');
1540           else
1541             need_nl = TRUE;
1542         }
1543
1544       while ((*relppp) < relppend
1545              && (**relppp)->address < rel_offset + addr_offset + octets / opb)
1546         {
1547           if (dump_reloc_info || dump_dynamic_reloc_info)
1548             {
1549               arelent *q;
1550
1551               q = **relppp;
1552
1553               if (wide_output)
1554                 putchar ('\t');
1555               else
1556                 printf ("\t\t\t");
1557
1558               objdump_print_value (section->vma - rel_offset + q->address,
1559                                    info, TRUE);
1560
1561               if (q->howto == NULL)
1562                 printf (": *unknown*\t");
1563               else if (q->howto->name)
1564                 printf (": %s\t", q->howto->name);
1565               else
1566                 printf (": %d\t", q->howto->type);
1567
1568               if (q->sym_ptr_ptr == NULL || *q->sym_ptr_ptr == NULL)
1569                 printf ("*unknown*");
1570               else
1571                 {
1572                   const char *sym_name;
1573
1574                   sym_name = bfd_asymbol_name (*q->sym_ptr_ptr);
1575                   if (sym_name != NULL && *sym_name != '\0')
1576                     objdump_print_symname (aux->abfd, info, *q->sym_ptr_ptr);
1577                   else
1578                     {
1579                       asection *sym_sec;
1580
1581                       sym_sec = bfd_get_section (*q->sym_ptr_ptr);
1582                       sym_name = bfd_get_section_name (aux->abfd, sym_sec);
1583                       if (sym_name == NULL || *sym_name == '\0')
1584                         sym_name = "*unknown*";
1585                       printf ("%s", sym_name);
1586                     }
1587                 }
1588
1589               if (q->addend)
1590                 {
1591                   printf ("+0x");
1592                   objdump_print_value (q->addend, info, TRUE);
1593                 }
1594
1595               printf ("\n");
1596               need_nl = FALSE;
1597             }
1598           ++(*relppp);
1599         }
1600
1601       if (need_nl)
1602         printf ("\n");
1603
1604       addr_offset += octets / opb;
1605     }
1606
1607   free (sfile.buffer);
1608 }
1609
1610 static void
1611 disassemble_section (bfd *abfd, asection *section, void *info)
1612 {
1613   struct disassemble_info *    pinfo = (struct disassemble_info *) info;
1614   struct objdump_disasm_info * paux;
1615   unsigned int                 opb = pinfo->octets_per_byte;
1616   bfd_byte *                   data = NULL;
1617   bfd_size_type                datasize = 0;
1618   arelent **                   rel_pp = NULL;
1619   arelent **                   rel_ppstart = NULL;
1620   arelent **                   rel_ppend;
1621   unsigned long                stop_offset;
1622   asymbol *                    sym = NULL;
1623   long                         place = 0;
1624   long                         rel_count;
1625   bfd_vma                      rel_offset;
1626   unsigned long                addr_offset;
1627
1628   /* Sections that do not contain machine
1629      code are not normally disassembled.  */
1630   if (! disassemble_all
1631       && only == NULL
1632       && ((section->flags & (SEC_CODE | SEC_HAS_CONTENTS))
1633           != (SEC_CODE | SEC_HAS_CONTENTS)))
1634     return;
1635
1636   if (! process_section_p (section))
1637     return;
1638
1639   datasize = bfd_get_section_size (section);
1640   if (datasize == 0)
1641     return;
1642
1643   /* Decide which set of relocs to use.  Load them if necessary.  */
1644   paux = (struct objdump_disasm_info *) pinfo->application_data;
1645   if (paux->dynrelbuf)
1646     {
1647       rel_pp = paux->dynrelbuf;
1648       rel_count = paux->dynrelcount;
1649       /* Dynamic reloc addresses are absolute, non-dynamic are section
1650          relative.  REL_OFFSET specifies the reloc address corresponding
1651          to the start of this section.  */
1652       rel_offset = section->vma;
1653     }
1654   else
1655     {
1656       rel_count = 0;
1657       rel_pp = NULL;
1658       rel_offset = 0;
1659
1660       if ((section->flags & SEC_RELOC) != 0
1661           && (dump_reloc_info || pinfo->disassembler_needs_relocs))
1662         {
1663           long relsize;
1664
1665           relsize = bfd_get_reloc_upper_bound (abfd, section);
1666           if (relsize < 0)
1667             bfd_fatal (bfd_get_filename (abfd));
1668
1669           if (relsize > 0)
1670             {
1671               rel_ppstart = rel_pp = xmalloc (relsize);
1672               rel_count = bfd_canonicalize_reloc (abfd, section, rel_pp, syms);
1673               if (rel_count < 0)
1674                 bfd_fatal (bfd_get_filename (abfd));
1675
1676               /* Sort the relocs by address.  */
1677               qsort (rel_pp, rel_count, sizeof (arelent *), compare_relocs);
1678             }
1679         }
1680
1681     }
1682   rel_ppend = rel_pp + rel_count;
1683
1684   data = xmalloc (datasize);
1685
1686   bfd_get_section_contents (abfd, section, data, 0, datasize);
1687
1688   paux->sec = section;
1689   pinfo->buffer = data;
1690   pinfo->buffer_vma = section->vma;
1691   pinfo->buffer_length = datasize;
1692   pinfo->section = section;
1693
1694   if (start_address == (bfd_vma) -1
1695       || start_address < pinfo->buffer_vma)
1696     addr_offset = 0;
1697   else
1698     addr_offset = start_address - pinfo->buffer_vma;
1699
1700   if (stop_address == (bfd_vma) -1)
1701     stop_offset = datasize / opb;
1702   else
1703     {
1704       if (stop_address < pinfo->buffer_vma)
1705         stop_offset = 0;
1706       else
1707         stop_offset = stop_address - pinfo->buffer_vma;
1708       if (stop_offset > pinfo->buffer_length / opb)
1709         stop_offset = pinfo->buffer_length / opb;
1710     }
1711
1712   /* Skip over the relocs belonging to addresses below the
1713      start address.  */
1714   while (rel_pp < rel_ppend
1715          && (*rel_pp)->address < rel_offset + addr_offset)
1716     ++rel_pp;
1717
1718   printf (_("Disassembly of section %s:\n"), section->name);
1719
1720   /* Find the nearest symbol forwards from our current position.  */
1721   paux->require_sec = TRUE;
1722   sym = find_symbol_for_address (section->vma + addr_offset, info, &place);
1723   paux->require_sec = FALSE;
1724
1725   /* Disassemble a block of instructions up to the address associated with
1726      the symbol we have just found.  Then print the symbol and find the
1727      next symbol on.  Repeat until we have disassembled the entire section
1728      or we have reached the end of the address range we are interested in.  */
1729   while (addr_offset < stop_offset)
1730     {
1731       bfd_vma addr;
1732       asymbol *nextsym;
1733       unsigned long nextstop_offset;
1734       bfd_boolean insns;
1735
1736       addr = section->vma + addr_offset;
1737
1738       if (sym != NULL && bfd_asymbol_value (sym) <= addr)
1739         {
1740           int x;
1741
1742           for (x = place;
1743                (x < sorted_symcount
1744                 && (bfd_asymbol_value (sorted_syms[x]) <= addr));
1745                ++x)
1746             continue;
1747
1748           pinfo->symbols = sorted_syms + place;
1749           pinfo->num_symbols = x - place;
1750           pinfo->symtab_pos = place;
1751         }
1752       else
1753         {
1754           pinfo->symbols = NULL;
1755           pinfo->num_symbols = 0;
1756           pinfo->symtab_pos = -1;
1757         }
1758
1759       if (! prefix_addresses)
1760         {
1761           pinfo->fprintf_func (pinfo->stream, "\n");
1762           objdump_print_addr_with_sym (abfd, section, sym, addr,
1763                                        pinfo, FALSE);
1764           pinfo->fprintf_func (pinfo->stream, ":\n");
1765         }
1766
1767       if (sym != NULL && bfd_asymbol_value (sym) > addr)
1768         nextsym = sym;
1769       else if (sym == NULL)
1770         nextsym = NULL;
1771       else
1772         {
1773 #define is_valid_next_sym(SYM) \
1774   ((SYM)->section == section \
1775    && (bfd_asymbol_value (SYM) > bfd_asymbol_value (sym)) \
1776    && pinfo->symbol_is_valid (SYM, pinfo))
1777
1778           /* Search forward for the next appropriate symbol in
1779              SECTION.  Note that all the symbols are sorted
1780              together into one big array, and that some sections
1781              may have overlapping addresses.  */
1782           while (place < sorted_symcount
1783                  && ! is_valid_next_sym (sorted_syms [place]))
1784             ++place;
1785
1786           if (place >= sorted_symcount)
1787             nextsym = NULL;
1788           else
1789             nextsym = sorted_syms[place];
1790         }
1791
1792       if (sym != NULL && bfd_asymbol_value (sym) > addr)
1793         nextstop_offset = bfd_asymbol_value (sym) - section->vma;
1794       else if (nextsym == NULL)
1795         nextstop_offset = stop_offset;
1796       else
1797         nextstop_offset = bfd_asymbol_value (nextsym) - section->vma;
1798
1799       if (nextstop_offset > stop_offset)
1800         nextstop_offset = stop_offset;
1801
1802       /* If a symbol is explicitly marked as being an object
1803          rather than a function, just dump the bytes without
1804          disassembling them.  */
1805       if (disassemble_all
1806           || sym == NULL
1807           || bfd_asymbol_value (sym) > addr
1808           || ((sym->flags & BSF_OBJECT) == 0
1809               && (strstr (bfd_asymbol_name (sym), "gnu_compiled")
1810                   == NULL)
1811               && (strstr (bfd_asymbol_name (sym), "gcc2_compiled")
1812                   == NULL))
1813           || (sym->flags & BSF_FUNCTION) != 0)
1814         insns = TRUE;
1815       else
1816         insns = FALSE;
1817
1818       disassemble_bytes (pinfo, paux->disassemble_fn, insns, data,
1819                          addr_offset, nextstop_offset,
1820                          rel_offset, &rel_pp, rel_ppend);
1821
1822       addr_offset = nextstop_offset;
1823       sym = nextsym;
1824     }
1825
1826   free (data);
1827
1828   if (rel_ppstart != NULL)
1829     free (rel_ppstart);
1830 }
1831
1832 /* Disassemble the contents of an object file.  */
1833
1834 static void
1835 disassemble_data (bfd *abfd)
1836 {
1837   struct disassemble_info disasm_info;
1838   struct objdump_disasm_info aux;
1839   long i;
1840
1841   print_files = NULL;
1842   prev_functionname = NULL;
1843   prev_line = -1;
1844
1845   /* We make a copy of syms to sort.  We don't want to sort syms
1846      because that will screw up the relocs.  */
1847   sorted_symcount = symcount ? symcount : dynsymcount;
1848   sorted_syms = xmalloc ((sorted_symcount + synthcount) * sizeof (asymbol *));
1849   memcpy (sorted_syms, symcount ? syms : dynsyms,
1850           sorted_symcount * sizeof (asymbol *));
1851
1852   sorted_symcount = remove_useless_symbols (sorted_syms, sorted_symcount);
1853
1854   for (i = 0; i < synthcount; ++i)
1855     {
1856       sorted_syms[sorted_symcount] = synthsyms + i;
1857       ++sorted_symcount;
1858     }
1859
1860   /* Sort the symbols into section and symbol order.  */
1861   qsort (sorted_syms, sorted_symcount, sizeof (asymbol *), compare_symbols);
1862
1863   init_disassemble_info (&disasm_info, stdout, (fprintf_ftype) fprintf);
1864
1865   disasm_info.application_data = (void *) &aux;
1866   aux.abfd = abfd;
1867   aux.require_sec = FALSE;
1868   aux.dynrelbuf = NULL;
1869   aux.dynrelcount = 0;
1870   aux.reloc = NULL;
1871
1872   disasm_info.print_address_func = objdump_print_address;
1873   disasm_info.symbol_at_address_func = objdump_symbol_at_address;
1874
1875   if (machine != NULL)
1876     {
1877       const bfd_arch_info_type *info = bfd_scan_arch (machine);
1878
1879       if (info == NULL)
1880         fatal (_("Can't use supplied machine %s"), machine);
1881
1882       abfd->arch_info = info;
1883     }
1884
1885   if (endian != BFD_ENDIAN_UNKNOWN)
1886     {
1887       struct bfd_target *xvec;
1888
1889       xvec = xmalloc (sizeof (struct bfd_target));
1890       memcpy (xvec, abfd->xvec, sizeof (struct bfd_target));
1891       xvec->byteorder = endian;
1892       abfd->xvec = xvec;
1893     }
1894
1895   /* Use libopcodes to locate a suitable disassembler.  */
1896   aux.disassemble_fn = disassembler (abfd);
1897   if (!aux.disassemble_fn)
1898     {
1899       non_fatal (_("Can't disassemble for architecture %s\n"),
1900                  bfd_printable_arch_mach (bfd_get_arch (abfd), 0));
1901       exit_status = 1;
1902       return;
1903     }
1904
1905   disasm_info.flavour = bfd_get_flavour (abfd);
1906   disasm_info.arch = bfd_get_arch (abfd);
1907   disasm_info.mach = bfd_get_mach (abfd);
1908   disasm_info.disassembler_options = disassembler_options;
1909   disasm_info.octets_per_byte = bfd_octets_per_byte (abfd);
1910   disasm_info.skip_zeroes = DEFAULT_SKIP_ZEROES;
1911   disasm_info.skip_zeroes_at_end = DEFAULT_SKIP_ZEROES_AT_END;
1912   disasm_info.disassembler_needs_relocs = FALSE;
1913
1914   if (bfd_big_endian (abfd))
1915     disasm_info.display_endian = disasm_info.endian = BFD_ENDIAN_BIG;
1916   else if (bfd_little_endian (abfd))
1917     disasm_info.display_endian = disasm_info.endian = BFD_ENDIAN_LITTLE;
1918   else
1919     /* ??? Aborting here seems too drastic.  We could default to big or little
1920        instead.  */
1921     disasm_info.endian = BFD_ENDIAN_UNKNOWN;
1922
1923   /* Allow the target to customize the info structure.  */
1924   disassemble_init_for_target (& disasm_info);
1925
1926   /* Pre-load the dynamic relocs if we are going
1927      to be dumping them along with the disassembly.  */
1928   if (dump_dynamic_reloc_info)
1929     {
1930       long relsize = bfd_get_dynamic_reloc_upper_bound (abfd);
1931
1932       if (relsize < 0)
1933         bfd_fatal (bfd_get_filename (abfd));
1934
1935       if (relsize > 0)
1936         {
1937           aux.dynrelbuf = xmalloc (relsize);
1938           aux.dynrelcount = bfd_canonicalize_dynamic_reloc (abfd,
1939                                                             aux.dynrelbuf,
1940                                                             dynsyms);
1941           if (aux.dynrelcount < 0)
1942             bfd_fatal (bfd_get_filename (abfd));
1943
1944           /* Sort the relocs by address.  */
1945           qsort (aux.dynrelbuf, aux.dynrelcount, sizeof (arelent *),
1946                  compare_relocs);
1947         }
1948     }
1949   disasm_info.symtab = sorted_syms;
1950   disasm_info.symtab_size = sorted_symcount;
1951
1952   bfd_map_over_sections (abfd, disassemble_section, & disasm_info);
1953
1954   if (aux.dynrelbuf != NULL)
1955     free (aux.dynrelbuf);
1956   free (sorted_syms);
1957 }
1958 \f
1959 int
1960 load_debug_section (enum dwarf_section_display_enum debug, void *file)
1961 {
1962   struct dwarf_section *section = &debug_displays [debug].section;
1963   bfd *abfd = file;
1964   asection *sec;
1965   bfd_boolean ret;
1966
1967   /* If it is already loaded, do nothing.  */
1968   if (section->start != NULL)
1969     return 1;
1970
1971   /* Locate the debug section.  */
1972   sec = bfd_get_section_by_name (abfd, section->name);
1973   if (sec == NULL)
1974     return 0;
1975
1976   section->address = bfd_get_section_vma (abfd, sec);
1977   section->size = bfd_get_section_size (sec);
1978   section->start = xmalloc (section->size);
1979
1980   if (is_relocatable && debug_displays [debug].relocate)
1981     ret = bfd_simple_get_relocated_section_contents (abfd,
1982                                                      sec,
1983                                                      section->start,
1984                                                      syms) != NULL;
1985   else
1986     ret = bfd_get_section_contents (abfd, sec, section->start, 0,
1987                                     section->size);
1988
1989   if (!ret)
1990     {
1991       free_debug_section (debug);
1992       printf (_("\nCan't get contents for section '%s'.\n"),
1993               section->name);
1994     }
1995
1996   return ret;
1997 }
1998
1999 void
2000 free_debug_section (enum dwarf_section_display_enum debug)
2001 {
2002   struct dwarf_section *section = &debug_displays [debug].section;
2003
2004   if (section->start == NULL)
2005     return;
2006
2007   free ((char *) section->start);
2008   section->start = NULL;
2009   section->address = 0;
2010   section->size = 0;
2011 }
2012
2013 static void
2014 dump_dwarf_section (bfd *abfd, asection *section,
2015                     void *arg ATTRIBUTE_UNUSED)
2016 {
2017   const char *name = bfd_get_section_name (abfd, section);
2018   const char *match;
2019   enum dwarf_section_display_enum i;
2020
2021   if (CONST_STRNEQ (name, ".gnu.linkonce.wi."))
2022     match = ".debug_info";
2023   else
2024     match = name;
2025
2026   for (i = 0; i < max; i++)
2027     if (strcmp (debug_displays[i].section.name, match) == 0)
2028       {
2029         if (!debug_displays[i].eh_frame)
2030           {
2031             struct dwarf_section *sec = &debug_displays [i].section;
2032
2033             if (load_debug_section (i, abfd))
2034               {
2035                 debug_displays[i].display (sec, abfd);
2036
2037                 if (i != info && i != abbrev)
2038                   free_debug_section (i);
2039               }
2040           }
2041         break;
2042       }
2043 }
2044
2045 static const char *mach_o_dwarf_sections [] = {
2046   "LC_SEGMENT.__DWARFA.__debug_abbrev",         /* .debug_abbrev */
2047   "LC_SEGMENT.__DWARFA.__debug_aranges",        /* .debug_aranges */
2048   "LC_SEGMENT.__DWARFA.__debug_frame",          /* .debug_frame */
2049   "LC_SEGMENT.__DWARFA.__debug_info",           /* .debug_info */
2050   "LC_SEGMENT.__DWARFA.__debug_line",           /* .debug_line */
2051   "LC_SEGMENT.__DWARFA.__debug_pubnames",       /* .debug_pubnames */
2052   ".eh_frame",                                  /* .eh_frame */
2053   "LC_SEGMENT.__DWARFA.__debug_macinfo",        /* .debug_macinfo */
2054   "LC_SEGMENT.__DWARFA.__debug_str",            /* .debug_str */
2055   "LC_SEGMENT.__DWARFA.__debug_loc",            /* .debug_loc */
2056   "LC_SEGMENT.__DWARFA.__debug_pubtypes",       /* .debug_pubtypes */
2057   "LC_SEGMENT.__DWARFA.__debug_ranges",         /* .debug_ranges */
2058   "LC_SEGMENT.__DWARFA.__debug_static_func",    /* .debug_static_func */
2059   "LC_SEGMENT.__DWARFA.__debug_static_vars",    /* .debug_static_vars */
2060   "LC_SEGMENT.__DWARFA.__debug_types",          /* .debug_types */
2061   "LC_SEGMENT.__DWARFA.__debug_weaknames"       /* .debug_weaknames */
2062 };
2063
2064 static const char *generic_dwarf_sections [max];
2065
2066 static void
2067 check_mach_o_dwarf (bfd *abfd)
2068 {
2069   static enum bfd_flavour old_flavour = bfd_target_unknown_flavour;
2070   enum bfd_flavour current_flavour = bfd_get_flavour (abfd);
2071   enum dwarf_section_display_enum i;
2072
2073   if (generic_dwarf_sections [0] == NULL)
2074     for (i = 0; i < max; i++)
2075       generic_dwarf_sections [i] = debug_displays[i].section.name;
2076
2077   if (old_flavour != current_flavour)
2078     {
2079       if (current_flavour == bfd_target_mach_o_flavour)
2080         for (i = 0; i < max; i++)
2081           debug_displays[i].section.name = mach_o_dwarf_sections [i];
2082       else if (old_flavour == bfd_target_mach_o_flavour)
2083         for (i = 0; i < max; i++)
2084           debug_displays[i].section.name = generic_dwarf_sections [i];
2085
2086       old_flavour = current_flavour;
2087     }
2088 }
2089
2090 /* Dump the dwarf debugging information.  */
2091
2092 static void
2093 dump_dwarf (bfd *abfd)
2094 {
2095   is_relocatable = ((abfd->flags & (HAS_RELOC | EXEC_P | DYNAMIC))
2096                     == HAS_RELOC);
2097
2098   /* FIXME: bfd_get_arch_size may return -1.  We assume that 64bit
2099      targets will return 64.  */
2100   eh_addr_size = bfd_get_arch_size (abfd) == 64 ? 8 : 4;
2101
2102   if (bfd_big_endian (abfd))
2103     byte_get = byte_get_big_endian;
2104   else if (bfd_little_endian (abfd))
2105     byte_get = byte_get_little_endian;
2106   else
2107     abort ();
2108
2109   check_mach_o_dwarf (abfd);
2110
2111   bfd_map_over_sections (abfd, dump_dwarf_section, NULL);
2112
2113   free_debug_memory ();
2114 }
2115 \f
2116 /* Read ABFD's stabs section STABSECT_NAME, and return a pointer to
2117    it.  Return NULL on failure.   */
2118
2119 static char *
2120 read_section_stabs (bfd *abfd, const char *sect_name, bfd_size_type *size_ptr)
2121 {
2122   asection *stabsect;
2123   bfd_size_type size;
2124   char *contents;
2125
2126   stabsect = bfd_get_section_by_name (abfd, sect_name);
2127   if (stabsect == NULL)
2128     {
2129       printf (_("No %s section present\n\n"), sect_name);
2130       return FALSE;
2131     }
2132
2133   size = bfd_section_size (abfd, stabsect);
2134   contents  = xmalloc (size);
2135
2136   if (! bfd_get_section_contents (abfd, stabsect, contents, 0, size))
2137     {
2138       non_fatal (_("Reading %s section of %s failed: %s"),
2139                  sect_name, bfd_get_filename (abfd),
2140                  bfd_errmsg (bfd_get_error ()));
2141       free (contents);
2142       exit_status = 1;
2143       return NULL;
2144     }
2145
2146   *size_ptr = size;
2147
2148   return contents;
2149 }
2150
2151 /* Stabs entries use a 12 byte format:
2152      4 byte string table index
2153      1 byte stab type
2154      1 byte stab other field
2155      2 byte stab desc field
2156      4 byte stab value
2157    FIXME: This will have to change for a 64 bit object format.  */
2158
2159 #define STRDXOFF  (0)
2160 #define TYPEOFF   (4)
2161 #define OTHEROFF  (5)
2162 #define DESCOFF   (6)
2163 #define VALOFF    (8)
2164 #define STABSIZE (12)
2165
2166 /* Print ABFD's stabs section STABSECT_NAME (in `stabs'),
2167    using string table section STRSECT_NAME (in `strtab').  */
2168
2169 static void
2170 print_section_stabs (bfd *abfd,
2171                      const char *stabsect_name,
2172                      unsigned *string_offset_ptr)
2173 {
2174   int i;
2175   unsigned file_string_table_offset = 0;
2176   unsigned next_file_string_table_offset = *string_offset_ptr;
2177   bfd_byte *stabp, *stabs_end;
2178
2179   stabp = stabs;
2180   stabs_end = stabp + stab_size;
2181
2182   printf (_("Contents of %s section:\n\n"), stabsect_name);
2183   printf ("Symnum n_type n_othr n_desc n_value  n_strx String\n");
2184
2185   /* Loop through all symbols and print them.
2186
2187      We start the index at -1 because there is a dummy symbol on
2188      the front of stabs-in-{coff,elf} sections that supplies sizes.  */
2189   for (i = -1; stabp < stabs_end; stabp += STABSIZE, i++)
2190     {
2191       const char *name;
2192       unsigned long strx;
2193       unsigned char type, other;
2194       unsigned short desc;
2195       bfd_vma value;
2196
2197       strx = bfd_h_get_32 (abfd, stabp + STRDXOFF);
2198       type = bfd_h_get_8 (abfd, stabp + TYPEOFF);
2199       other = bfd_h_get_8 (abfd, stabp + OTHEROFF);
2200       desc = bfd_h_get_16 (abfd, stabp + DESCOFF);
2201       value = bfd_h_get_32 (abfd, stabp + VALOFF);
2202
2203       printf ("\n%-6d ", i);
2204       /* Either print the stab name, or, if unnamed, print its number
2205          again (makes consistent formatting for tools like awk).  */
2206       name = bfd_get_stab_name (type);
2207       if (name != NULL)
2208         printf ("%-6s", name);
2209       else if (type == N_UNDF)
2210         printf ("HdrSym");
2211       else
2212         printf ("%-6d", type);
2213       printf (" %-6d %-6d ", other, desc);
2214       bfd_printf_vma (abfd, value);
2215       printf (" %-6lu", strx);
2216
2217       /* Symbols with type == 0 (N_UNDF) specify the length of the
2218          string table associated with this file.  We use that info
2219          to know how to relocate the *next* file's string table indices.  */
2220       if (type == N_UNDF)
2221         {
2222           file_string_table_offset = next_file_string_table_offset;
2223           next_file_string_table_offset += value;
2224         }
2225       else
2226         {
2227           /* Using the (possibly updated) string table offset, print the
2228              string (if any) associated with this symbol.  */
2229           if ((strx + file_string_table_offset) < stabstr_size)
2230             printf (" %s", &strtab[strx + file_string_table_offset]);
2231           else
2232             printf (" *");
2233         }
2234     }
2235   printf ("\n\n");
2236   *string_offset_ptr = next_file_string_table_offset;
2237 }
2238
2239 typedef struct
2240 {
2241   const char * section_name;
2242   const char * string_section_name;
2243   unsigned string_offset;
2244 }
2245 stab_section_names;
2246
2247 static void
2248 find_stabs_section (bfd *abfd, asection *section, void *names)
2249 {
2250   int len;
2251   stab_section_names * sought = (stab_section_names *) names;
2252
2253   /* Check for section names for which stabsect_name is a prefix, to
2254      handle .stab.N, etc.  */
2255   len = strlen (sought->section_name);
2256
2257   /* If the prefix matches, and the files section name ends with a
2258      nul or a digit, then we match.  I.e., we want either an exact
2259      match or a section followed by a number.  */
2260   if (strncmp (sought->section_name, section->name, len) == 0
2261       && (section->name[len] == 0
2262           || (section->name[len] == '.' && ISDIGIT (section->name[len + 1]))))
2263     {
2264       if (strtab == NULL)
2265         strtab = read_section_stabs (abfd, sought->string_section_name,
2266                                      &stabstr_size);
2267
2268       if (strtab)
2269         {
2270           stabs = (bfd_byte *) read_section_stabs (abfd, section->name,
2271                                                    &stab_size);
2272           if (stabs)
2273             print_section_stabs (abfd, section->name, &sought->string_offset);
2274         }
2275     }
2276 }
2277
2278 static void
2279 dump_stabs_section (bfd *abfd, char *stabsect_name, char *strsect_name)
2280 {
2281   stab_section_names s;
2282
2283   s.section_name = stabsect_name;
2284   s.string_section_name = strsect_name;
2285   s.string_offset = 0;
2286
2287   bfd_map_over_sections (abfd, find_stabs_section, & s);
2288
2289   free (strtab);
2290   strtab = NULL;
2291 }
2292
2293 /* Dump the any sections containing stabs debugging information.  */
2294
2295 static void
2296 dump_stabs (bfd *abfd)
2297 {
2298   dump_stabs_section (abfd, ".stab", ".stabstr");
2299   dump_stabs_section (abfd, ".stab.excl", ".stab.exclstr");
2300   dump_stabs_section (abfd, ".stab.index", ".stab.indexstr");
2301   dump_stabs_section (abfd, "$GDB_SYMBOLS$", "$GDB_STRINGS$");
2302 }
2303 \f
2304 static void
2305 dump_bfd_header (bfd *abfd)
2306 {
2307   char *comma = "";
2308
2309   printf (_("architecture: %s, "),
2310           bfd_printable_arch_mach (bfd_get_arch (abfd),
2311                                    bfd_get_mach (abfd)));
2312   printf (_("flags 0x%08x:\n"), abfd->flags);
2313
2314 #define PF(x, y)    if (abfd->flags & x) {printf("%s%s", comma, y); comma=", ";}
2315   PF (HAS_RELOC, "HAS_RELOC");
2316   PF (EXEC_P, "EXEC_P");
2317   PF (HAS_LINENO, "HAS_LINENO");
2318   PF (HAS_DEBUG, "HAS_DEBUG");
2319   PF (HAS_SYMS, "HAS_SYMS");
2320   PF (HAS_LOCALS, "HAS_LOCALS");
2321   PF (DYNAMIC, "DYNAMIC");
2322   PF (WP_TEXT, "WP_TEXT");
2323   PF (D_PAGED, "D_PAGED");
2324   PF (BFD_IS_RELAXABLE, "BFD_IS_RELAXABLE");
2325   PF (HAS_LOAD_PAGE, "HAS_LOAD_PAGE");
2326   printf (_("\nstart address 0x"));
2327   bfd_printf_vma (abfd, abfd->start_address);
2328   printf ("\n");
2329 }
2330
2331 \f
2332 static void
2333 dump_bfd_private_header (bfd *abfd)
2334 {
2335   bfd_print_private_bfd_data (abfd, stdout);
2336 }
2337
2338 \f
2339 /* Display a section in hexadecimal format with associated characters.
2340    Each line prefixed by the zero padded address.  */
2341
2342 static void
2343 dump_section (bfd *abfd, asection *section, void *dummy ATTRIBUTE_UNUSED)
2344 {
2345   bfd_byte *data = 0;
2346   bfd_size_type datasize;
2347   bfd_size_type addr_offset;
2348   bfd_size_type start_offset;
2349   bfd_size_type stop_offset;
2350   unsigned int opb = bfd_octets_per_byte (abfd);
2351   /* Bytes per line.  */
2352   const int onaline = 16;
2353   char buf[64];
2354   int count;
2355   int width;
2356
2357   if ((section->flags & SEC_HAS_CONTENTS) == 0)
2358     return;
2359
2360   if (! process_section_p (section))
2361     return;
2362
2363   if ((datasize = bfd_section_size (abfd, section)) == 0)
2364     return;
2365
2366   printf (_("Contents of section %s:\n"), section->name);
2367
2368   data = xmalloc (datasize);
2369
2370   bfd_get_section_contents (abfd, section, data, 0, datasize);
2371
2372   /* Compute the address range to display.  */
2373   if (start_address == (bfd_vma) -1
2374       || start_address < section->vma)
2375     start_offset = 0;
2376   else
2377     start_offset = start_address - section->vma;
2378
2379   if (stop_address == (bfd_vma) -1)
2380     stop_offset = datasize / opb;
2381   else
2382     {
2383       if (stop_address < section->vma)
2384         stop_offset = 0;
2385       else
2386         stop_offset = stop_address - section->vma;
2387
2388       if (stop_offset > datasize / opb)
2389         stop_offset = datasize / opb;
2390     }
2391
2392   width = 4;
2393
2394   bfd_sprintf_vma (abfd, buf, start_offset + section->vma);
2395   if (strlen (buf) >= sizeof (buf))
2396     abort ();
2397
2398   count = 0;
2399   while (buf[count] == '0' && buf[count+1] != '\0')
2400     count++;
2401   count = strlen (buf) - count;
2402   if (count > width)
2403     width = count;
2404
2405   bfd_sprintf_vma (abfd, buf, stop_offset + section->vma - 1);
2406   if (strlen (buf) >= sizeof (buf))
2407     abort ();
2408
2409   count = 0;
2410   while (buf[count] == '0' && buf[count+1] != '\0')
2411     count++;
2412   count = strlen (buf) - count;
2413   if (count > width)
2414     width = count;
2415
2416   for (addr_offset = start_offset;
2417        addr_offset < stop_offset; addr_offset += onaline / opb)
2418     {
2419       bfd_size_type j;
2420
2421       bfd_sprintf_vma (abfd, buf, (addr_offset + section->vma));
2422       count = strlen (buf);
2423       if ((size_t) count >= sizeof (buf))
2424         abort ();
2425
2426       putchar (' ');
2427       while (count < width)
2428         {
2429           putchar ('0');
2430           count++;
2431         }
2432       fputs (buf + count - width, stdout);
2433       putchar (' ');
2434
2435       for (j = addr_offset * opb;
2436            j < addr_offset * opb + onaline; j++)
2437         {
2438           if (j < stop_offset * opb)
2439             printf ("%02x", (unsigned) (data[j]));
2440           else
2441             printf ("  ");
2442           if ((j & 3) == 3)
2443             printf (" ");
2444         }
2445
2446       printf (" ");
2447       for (j = addr_offset * opb;
2448            j < addr_offset * opb + onaline; j++)
2449         {
2450           if (j >= stop_offset * opb)
2451             printf (" ");
2452           else
2453             printf ("%c", ISPRINT (data[j]) ? data[j] : '.');
2454         }
2455       putchar ('\n');
2456     }
2457   free (data);
2458 }
2459
2460 /* Actually display the various requested regions.  */
2461
2462 static void
2463 dump_data (bfd *abfd)
2464 {
2465   bfd_map_over_sections (abfd, dump_section, NULL);
2466 }
2467
2468 /* Should perhaps share code and display with nm?  */
2469
2470 static void
2471 dump_symbols (bfd *abfd ATTRIBUTE_UNUSED, bfd_boolean dynamic)
2472 {
2473   asymbol **current;
2474   long max;
2475   long count;
2476
2477   if (dynamic)
2478     {
2479       current = dynsyms;
2480       max = dynsymcount;
2481       printf ("DYNAMIC SYMBOL TABLE:\n");
2482     }
2483   else
2484     {
2485       current = syms;
2486       max = symcount;
2487       printf ("SYMBOL TABLE:\n");
2488     }
2489
2490   if (max == 0)
2491     printf (_("no symbols\n"));
2492
2493   for (count = 0; count < max; count++)
2494     {
2495       bfd *cur_bfd;
2496
2497       if (*current == NULL)
2498         printf (_("no information for symbol number %ld\n"), count);
2499
2500       else if ((cur_bfd = bfd_asymbol_bfd (*current)) == NULL)
2501         printf (_("could not determine the type of symbol number %ld\n"),
2502                 count);
2503
2504       else if (process_section_p ((* current)->section)
2505                && (dump_special_syms
2506                    || !bfd_is_target_special_symbol (cur_bfd, *current)))
2507         {
2508           const char *name = (*current)->name;
2509
2510           if (do_demangle && name != NULL && *name != '\0')
2511             {
2512               char *alloc;
2513
2514               /* If we want to demangle the name, we demangle it
2515                  here, and temporarily clobber it while calling
2516                  bfd_print_symbol.  FIXME: This is a gross hack.  */
2517               alloc = demangle (cur_bfd, name);
2518               (*current)->name = alloc;
2519               bfd_print_symbol (cur_bfd, stdout, *current,
2520                                 bfd_print_symbol_all);
2521               (*current)->name = name;
2522               free (alloc);
2523             }
2524           else
2525             bfd_print_symbol (cur_bfd, stdout, *current,
2526                               bfd_print_symbol_all);
2527           printf ("\n");
2528         }
2529
2530       current++;
2531     }
2532   printf ("\n\n");
2533 }
2534 \f
2535 static void
2536 dump_reloc_set (bfd *abfd, asection *sec, arelent **relpp, long relcount)
2537 {
2538   arelent **p;
2539   char *last_filename, *last_functionname;
2540   unsigned int last_line;
2541
2542   /* Get column headers lined up reasonably.  */
2543   {
2544     static int width;
2545
2546     if (width == 0)
2547       {
2548         char buf[30];
2549
2550         bfd_sprintf_vma (abfd, buf, (bfd_vma) -1);
2551         width = strlen (buf) - 7;
2552       }
2553     printf ("OFFSET %*s TYPE %*s VALUE \n", width, "", 12, "");
2554   }
2555
2556   last_filename = NULL;
2557   last_functionname = NULL;
2558   last_line = 0;
2559
2560   for (p = relpp; relcount && *p != NULL; p++, relcount--)
2561     {
2562       arelent *q = *p;
2563       const char *filename, *functionname;
2564       unsigned int line;
2565       const char *sym_name;
2566       const char *section_name;
2567
2568       if (start_address != (bfd_vma) -1
2569           && q->address < start_address)
2570         continue;
2571       if (stop_address != (bfd_vma) -1
2572           && q->address > stop_address)
2573         continue;
2574
2575       if (with_line_numbers
2576           && sec != NULL
2577           && bfd_find_nearest_line (abfd, sec, syms, q->address,
2578                                     &filename, &functionname, &line))
2579         {
2580           if (functionname != NULL
2581               && (last_functionname == NULL
2582                   || strcmp (functionname, last_functionname) != 0))
2583             {
2584               printf ("%s():\n", functionname);
2585               if (last_functionname != NULL)
2586                 free (last_functionname);
2587               last_functionname = xstrdup (functionname);
2588             }
2589
2590           if (line > 0
2591               && (line != last_line
2592                   || (filename != NULL
2593                       && last_filename != NULL
2594                       && strcmp (filename, last_filename) != 0)))
2595             {
2596               printf ("%s:%u\n", filename == NULL ? "???" : filename, line);
2597               last_line = line;
2598               if (last_filename != NULL)
2599                 free (last_filename);
2600               if (filename == NULL)
2601                 last_filename = NULL;
2602               else
2603                 last_filename = xstrdup (filename);
2604             }
2605         }
2606
2607       if (q->sym_ptr_ptr && *q->sym_ptr_ptr)
2608         {
2609           sym_name = (*(q->sym_ptr_ptr))->name;
2610           section_name = (*(q->sym_ptr_ptr))->section->name;
2611         }
2612       else
2613         {
2614           sym_name = NULL;
2615           section_name = NULL;
2616         }
2617
2618       bfd_printf_vma (abfd, q->address);
2619       if (q->howto == NULL)
2620         printf (" *unknown*         ");
2621       else if (q->howto->name)
2622         printf (" %-16s  ", q->howto->name);
2623       else
2624         printf (" %-16d  ", q->howto->type);
2625       if (sym_name)
2626         objdump_print_symname (abfd, NULL, *q->sym_ptr_ptr);
2627       else
2628         {
2629           if (section_name == NULL)
2630             section_name = "*unknown*";
2631           printf ("[%s]", section_name);
2632         }
2633
2634       if (q->addend)
2635         {
2636           printf ("+0x");
2637           bfd_printf_vma (abfd, q->addend);
2638         }
2639
2640       printf ("\n");
2641     }
2642 }
2643
2644 static void
2645 dump_relocs_in_section (bfd *abfd,
2646                         asection *section,
2647                         void *dummy ATTRIBUTE_UNUSED)
2648 {
2649   arelent **relpp;
2650   long relcount;
2651   long relsize;
2652
2653   if (   bfd_is_abs_section (section)
2654       || bfd_is_und_section (section)
2655       || bfd_is_com_section (section)
2656       || (! process_section_p (section))
2657       || ((section->flags & SEC_RELOC) == 0))
2658     return;
2659
2660   relsize = bfd_get_reloc_upper_bound (abfd, section);
2661   if (relsize < 0)
2662     bfd_fatal (bfd_get_filename (abfd));
2663
2664   printf ("RELOCATION RECORDS FOR [%s]:", section->name);
2665
2666   if (relsize == 0)
2667     {
2668       printf (" (none)\n\n");
2669       return;
2670     }
2671
2672   relpp = xmalloc (relsize);
2673   relcount = bfd_canonicalize_reloc (abfd, section, relpp, syms);
2674
2675   if (relcount < 0)
2676     bfd_fatal (bfd_get_filename (abfd));
2677   else if (relcount == 0)
2678     printf (" (none)\n\n");
2679   else
2680     {
2681       printf ("\n");
2682       dump_reloc_set (abfd, section, relpp, relcount);
2683       printf ("\n\n");
2684     }
2685   free (relpp);
2686 }
2687
2688 static void
2689 dump_relocs (bfd *abfd)
2690 {
2691   bfd_map_over_sections (abfd, dump_relocs_in_section, NULL);
2692 }
2693
2694 static void
2695 dump_dynamic_relocs (bfd *abfd)
2696 {
2697   long relsize;
2698   arelent **relpp;
2699   long relcount;
2700
2701   relsize = bfd_get_dynamic_reloc_upper_bound (abfd);
2702   if (relsize < 0)
2703     bfd_fatal (bfd_get_filename (abfd));
2704
2705   printf ("DYNAMIC RELOCATION RECORDS");
2706
2707   if (relsize == 0)
2708     printf (" (none)\n\n");
2709   else
2710     {
2711       relpp = xmalloc (relsize);
2712       relcount = bfd_canonicalize_dynamic_reloc (abfd, relpp, dynsyms);
2713
2714       if (relcount < 0)
2715         bfd_fatal (bfd_get_filename (abfd));
2716       else if (relcount == 0)
2717         printf (" (none)\n\n");
2718       else
2719         {
2720           printf ("\n");
2721           dump_reloc_set (abfd, NULL, relpp, relcount);
2722           printf ("\n\n");
2723         }
2724       free (relpp);
2725     }
2726 }
2727
2728 /* Creates a table of paths, to search for source files.  */
2729
2730 static void
2731 add_include_path (const char *path)
2732 {
2733   if (path[0] == 0)
2734     return;
2735   include_path_count++;
2736   include_paths = xrealloc (include_paths,
2737                             include_path_count * sizeof (*include_paths));
2738 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
2739   if (path[1] == ':' && path[2] == 0)
2740     path = concat (path, ".", (const char *) 0);
2741 #endif
2742   include_paths[include_path_count - 1] = path;
2743 }
2744
2745 static void
2746 adjust_addresses (bfd *abfd ATTRIBUTE_UNUSED,
2747                   asection *section,
2748                   void *arg)
2749 {
2750   if ((section->flags & SEC_DEBUGGING) == 0)
2751     {
2752       bfd_boolean *has_reloc_p = (bfd_boolean *) arg;
2753       section->vma += adjust_section_vma;
2754       if (*has_reloc_p)
2755         section->lma += adjust_section_vma;
2756     }
2757 }
2758
2759 /* Dump selected contents of ABFD.  */
2760
2761 static void
2762 dump_bfd (bfd *abfd)
2763 {
2764   /* If we are adjusting section VMA's, change them all now.  Changing
2765      the BFD information is a hack.  However, we must do it, or
2766      bfd_find_nearest_line will not do the right thing.  */
2767   if (adjust_section_vma != 0)
2768     {
2769       bfd_boolean has_reloc = (abfd->flags & HAS_RELOC);
2770       bfd_map_over_sections (abfd, adjust_addresses, &has_reloc);
2771     }
2772
2773   if (! dump_debugging_tags)
2774     printf (_("\n%s:     file format %s\n"), bfd_get_filename (abfd),
2775             abfd->xvec->name);
2776   if (dump_ar_hdrs)
2777     print_arelt_descr (stdout, abfd, TRUE);
2778   if (dump_file_header)
2779     dump_bfd_header (abfd);
2780   if (dump_private_headers)
2781     dump_bfd_private_header (abfd);
2782   if (! dump_debugging_tags)
2783     putchar ('\n');
2784   if (dump_section_headers)
2785     dump_headers (abfd);
2786
2787   if (dump_symtab
2788       || dump_reloc_info
2789       || disassemble
2790       || dump_debugging
2791       || dump_dwarf_section_info)
2792     syms = slurp_symtab (abfd);
2793   if (dump_dynamic_symtab || dump_dynamic_reloc_info
2794       || (disassemble && bfd_get_dynamic_symtab_upper_bound (abfd) > 0))
2795     dynsyms = slurp_dynamic_symtab (abfd);
2796   if (disassemble)
2797     {
2798       synthcount = bfd_get_synthetic_symtab (abfd, symcount, syms,
2799                                              dynsymcount, dynsyms, &synthsyms);
2800       if (synthcount < 0)
2801         synthcount = 0;
2802     }
2803
2804   if (dump_symtab)
2805     dump_symbols (abfd, FALSE);
2806   if (dump_dynamic_symtab)
2807     dump_symbols (abfd, TRUE);
2808   if (dump_dwarf_section_info)
2809     dump_dwarf (abfd);
2810   if (dump_stab_section_info)
2811     dump_stabs (abfd);
2812   if (dump_reloc_info && ! disassemble)
2813     dump_relocs (abfd);
2814   if (dump_dynamic_reloc_info && ! disassemble)
2815     dump_dynamic_relocs (abfd);
2816   if (dump_section_contents)
2817     dump_data (abfd);
2818   if (disassemble)
2819     disassemble_data (abfd);
2820
2821   if (dump_debugging)
2822     {
2823       void *dhandle;
2824
2825       dhandle = read_debugging_info (abfd, syms, symcount);
2826       if (dhandle != NULL)
2827         {
2828           if (! print_debugging_info (stdout, dhandle, abfd, syms, demangle,
2829               dump_debugging_tags ? TRUE : FALSE))
2830             {
2831               non_fatal (_("%s: printing debugging information failed"),
2832                          bfd_get_filename (abfd));
2833               exit_status = 1;
2834             }
2835         }
2836     }
2837
2838   if (syms)
2839     {
2840       free (syms);
2841       syms = NULL;
2842     }
2843
2844   if (dynsyms)
2845     {
2846       free (dynsyms);
2847       dynsyms = NULL;
2848     }
2849
2850   if (synthsyms)
2851     {
2852       free (synthsyms);
2853       synthsyms = NULL;
2854     }
2855
2856   symcount = 0;
2857   dynsymcount = 0;
2858   synthcount = 0;
2859 }
2860
2861 static void
2862 display_bfd (bfd *abfd)
2863 {
2864   char **matching;
2865
2866   if (bfd_check_format_matches (abfd, bfd_object, &matching))
2867     {
2868       dump_bfd (abfd);
2869       return;
2870     }
2871
2872   if (bfd_get_error () == bfd_error_file_ambiguously_recognized)
2873     {
2874       nonfatal (bfd_get_filename (abfd));
2875       list_matching_formats (matching);
2876       free (matching);
2877       return;
2878     }
2879
2880   if (bfd_get_error () != bfd_error_file_not_recognized)
2881     {
2882       nonfatal (bfd_get_filename (abfd));
2883       return;
2884     }
2885
2886   if (bfd_check_format_matches (abfd, bfd_core, &matching))
2887     {
2888       dump_bfd (abfd);
2889       return;
2890     }
2891
2892   nonfatal (bfd_get_filename (abfd));
2893
2894   if (bfd_get_error () == bfd_error_file_ambiguously_recognized)
2895     {
2896       list_matching_formats (matching);
2897       free (matching);
2898     }
2899 }
2900
2901 static void
2902 display_file (char *filename, char *target)
2903 {
2904   bfd *file;
2905   bfd *arfile = NULL;
2906
2907   if (get_file_size (filename) < 1)
2908     {
2909       exit_status = 1;
2910       return;
2911     }
2912
2913   file = bfd_openr (filename, target);
2914   if (file == NULL)
2915     {
2916       nonfatal (filename);
2917       return;
2918     }
2919
2920   /* If the file is an archive, process all of its elements.  */
2921   if (bfd_check_format (file, bfd_archive))
2922     {
2923       bfd *last_arfile = NULL;
2924
2925       printf (_("In archive %s:\n"), bfd_get_filename (file));
2926       for (;;)
2927         {
2928           bfd_set_error (bfd_error_no_error);
2929
2930           arfile = bfd_openr_next_archived_file (file, arfile);
2931           if (arfile == NULL)
2932             {
2933               if (bfd_get_error () != bfd_error_no_more_archived_files)
2934                 nonfatal (bfd_get_filename (file));
2935               break;
2936             }
2937
2938           display_bfd (arfile);
2939
2940           if (last_arfile != NULL)
2941             bfd_close (last_arfile);
2942           last_arfile = arfile;
2943         }
2944
2945       if (last_arfile != NULL)
2946         bfd_close (last_arfile);
2947     }
2948   else
2949     display_bfd (file);
2950
2951   bfd_close (file);
2952 }
2953 \f
2954 int
2955 main (int argc, char **argv)
2956 {
2957   int c;
2958   char *target = default_target;
2959   bfd_boolean seenflag = FALSE;
2960
2961 #if defined (HAVE_SETLOCALE)
2962 #if defined (HAVE_LC_MESSAGES)
2963   setlocale (LC_MESSAGES, "");
2964 #endif
2965   setlocale (LC_CTYPE, "");
2966 #endif
2967
2968   bindtextdomain (PACKAGE, LOCALEDIR);
2969   textdomain (PACKAGE);
2970
2971   program_name = *argv;
2972   xmalloc_set_program_name (program_name);
2973
2974   START_PROGRESS (program_name, 0);
2975
2976   expandargv (&argc, &argv);
2977
2978   bfd_init ();
2979   set_default_bfd_target ();
2980
2981   while ((c = getopt_long (argc, argv, "pib:m:M:VvCdDlfaHhrRtTxsSI:j:wE:zgeGW",
2982                            long_options, (int *) 0))
2983          != EOF)
2984     {
2985       switch (c)
2986         {
2987         case 0:
2988           break;                /* We've been given a long option.  */
2989         case 'm':
2990           machine = optarg;
2991           break;
2992         case 'M':
2993           if (disassembler_options)
2994             /* Ignore potential memory leak for now.  */
2995             disassembler_options = concat (disassembler_options, ",",
2996                                            optarg, NULL);
2997           else
2998             disassembler_options = optarg;
2999           break;
3000         case 'j':
3001           if (only_used == only_size)
3002             {
3003               only_size += 8;
3004               only = xrealloc (only, only_size * sizeof (char *));
3005             }
3006           only [only_used++] = optarg;
3007           break;
3008         case 'l':
3009           with_line_numbers = TRUE;
3010           break;
3011         case 'b':
3012           target = optarg;
3013           break;
3014         case 'C':
3015           do_demangle = TRUE;
3016           if (optarg != NULL)
3017             {
3018               enum demangling_styles style;
3019
3020               style = cplus_demangle_name_to_style (optarg);
3021               if (style == unknown_demangling)
3022                 fatal (_("unknown demangling style `%s'"),
3023                        optarg);
3024
3025               cplus_demangle_set_style (style);
3026             }
3027           break;
3028         case 'w':
3029           wide_output = TRUE;
3030           break;
3031         case OPTION_ADJUST_VMA:
3032           adjust_section_vma = parse_vma (optarg, "--adjust-vma");
3033           break;
3034         case OPTION_START_ADDRESS:
3035           start_address = parse_vma (optarg, "--start-address");
3036           break;
3037         case OPTION_STOP_ADDRESS:
3038           stop_address = parse_vma (optarg, "--stop-address");
3039           break;
3040         case 'E':
3041           if (strcmp (optarg, "B") == 0)
3042             endian = BFD_ENDIAN_BIG;
3043           else if (strcmp (optarg, "L") == 0)
3044             endian = BFD_ENDIAN_LITTLE;
3045           else
3046             {
3047               non_fatal (_("unrecognized -E option"));
3048               usage (stderr, 1);
3049             }
3050           break;
3051         case OPTION_ENDIAN:
3052           if (strncmp (optarg, "big", strlen (optarg)) == 0)
3053             endian = BFD_ENDIAN_BIG;
3054           else if (strncmp (optarg, "little", strlen (optarg)) == 0)
3055             endian = BFD_ENDIAN_LITTLE;
3056           else
3057             {
3058               non_fatal (_("unrecognized --endian type `%s'"), optarg);
3059               usage (stderr, 1);
3060             }
3061           break;
3062
3063         case 'f':
3064           dump_file_header = TRUE;
3065           seenflag = TRUE;
3066           break;
3067         case 'i':
3068           formats_info = TRUE;
3069           seenflag = TRUE;
3070           break;
3071         case 'I':
3072           add_include_path (optarg);
3073           break;
3074         case 'p':
3075           dump_private_headers = TRUE;
3076           seenflag = TRUE;
3077           break;
3078         case 'x':
3079           dump_private_headers = TRUE;
3080           dump_symtab = TRUE;
3081           dump_reloc_info = TRUE;
3082           dump_file_header = TRUE;
3083           dump_ar_hdrs = TRUE;
3084           dump_section_headers = TRUE;
3085           seenflag = TRUE;
3086           break;
3087         case 't':
3088           dump_symtab = TRUE;
3089           seenflag = TRUE;
3090           break;
3091         case 'T':
3092           dump_dynamic_symtab = TRUE;
3093           seenflag = TRUE;
3094           break;
3095         case 'd':
3096           disassemble = TRUE;
3097           seenflag = TRUE;
3098           break;
3099         case 'z':
3100           disassemble_zeroes = TRUE;
3101           break;
3102         case 'D':
3103           disassemble = TRUE;
3104           disassemble_all = TRUE;
3105           seenflag = TRUE;
3106           break;
3107         case 'S':
3108           disassemble = TRUE;
3109           with_source_code = TRUE;
3110           seenflag = TRUE;
3111           break;
3112         case 'g':
3113           dump_debugging = 1;
3114           seenflag = TRUE;
3115           break;
3116         case 'e':
3117           dump_debugging = 1;
3118           dump_debugging_tags = 1;
3119           do_demangle = TRUE;
3120           seenflag = TRUE;
3121           break;
3122         case 'W':
3123           dump_dwarf_section_info = TRUE;
3124           seenflag = TRUE;
3125           do_debug_info = 1;
3126           do_debug_abbrevs = 1;
3127           do_debug_lines = 1;
3128           do_debug_pubnames = 1;
3129           do_debug_aranges = 1;
3130           do_debug_ranges = 1;
3131           do_debug_frames = 1;
3132           do_debug_macinfo = 1;
3133           do_debug_str = 1;
3134           do_debug_loc = 1;
3135           break;
3136         case 'G':
3137           dump_stab_section_info = TRUE;
3138           seenflag = TRUE;
3139           break;
3140         case 's':
3141           dump_section_contents = TRUE;
3142           seenflag = TRUE;
3143           break;
3144         case 'r':
3145           dump_reloc_info = TRUE;
3146           seenflag = TRUE;
3147           break;
3148         case 'R':
3149           dump_dynamic_reloc_info = TRUE;
3150           seenflag = TRUE;
3151           break;
3152         case 'a':
3153           dump_ar_hdrs = TRUE;
3154           seenflag = TRUE;
3155           break;
3156         case 'h':
3157           dump_section_headers = TRUE;
3158           seenflag = TRUE;
3159           break;
3160         case 'H':
3161           usage (stdout, 0);
3162           seenflag = TRUE;
3163         case 'v':
3164         case 'V':
3165           show_version = TRUE;
3166           seenflag = TRUE;
3167           break;
3168
3169         default:
3170           usage (stderr, 1);
3171         }
3172     }
3173
3174   if (show_version)
3175     print_version ("objdump");
3176
3177   if (!seenflag)
3178     usage (stderr, 2);
3179
3180   if (formats_info)
3181     exit_status = display_info ();
3182   else
3183     {
3184       if (optind == argc)
3185         display_file ("a.out", target);
3186       else
3187         for (; optind < argc;)
3188           display_file (argv[optind++], target);
3189     }
3190
3191   END_PROGRESS (program_name);
3192
3193   return exit_status;
3194 }