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