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