binutils/objdump.c

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