binutils/objdump.c

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