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               while (place < sorted_symcount
1739                      /* ??? Why the test for != section?  */
1740                      && (sorted_syms[place]->section != section
1741                          || (bfd_asymbol_value (sorted_syms[place])
1742                              <= bfd_asymbol_value (sym))))
1743                 ++place;
1744               if (place >= sorted_symcount)
1745                 nextsym = NULL;
1746               else
1747                 nextsym = sorted_syms[place];
1748             }
1749
1750           if (sym != NULL && bfd_asymbol_value (sym) > section->vma + i)
1751             {
1752               nextstop = bfd_asymbol_value (sym) - section->vma;
1753               if (nextstop > stop)
1754                 nextstop = stop;
1755             }
1756           else if (nextsym == NULL)
1757             nextstop = stop;
1758           else
1759             {
1760               nextstop = bfd_asymbol_value (nextsym) - section->vma;
1761               if (nextstop > stop)
1762                 nextstop = stop;
1763             }
1764
1765           /* If a symbol is explicitly marked as being an object
1766              rather than a function, just dump the bytes without
1767              disassembling them.  */
1768           if (disassemble_all
1769               || sym == NULL
1770               || bfd_asymbol_value (sym) > section->vma + i
1771               || ((sym->flags & BSF_OBJECT) == 0
1772                   && (strstr (bfd_asymbol_name (sym), "gnu_compiled")
1773                       == NULL)
1774                   && (strstr (bfd_asymbol_name (sym), "gcc2_compiled")
1775                       == NULL))
1776               || (sym->flags & BSF_FUNCTION) != 0)
1777             insns = true;
1778           else
1779             insns = false;
1780
1781           disassemble_bytes (&disasm_info, disassemble_fn, insns, data, i,
1782                              nextstop, &relpp, relppend);
1783
1784           i = nextstop;
1785           sym = nextsym;
1786         }
1787
1788       free (data);
1789       if (relbuf != NULL)
1790         free (relbuf);
1791     }
1792   free (sorted_syms);
1793 }
1794 \f
1795
1796 /* Define a table of stab values and print-strings.  We wish the initializer
1797    could be a direct-mapped table, but instead we build one the first
1798    time we need it.  */
1799
1800 static void dump_section_stabs PARAMS ((bfd *abfd, char *stabsect_name,
1801                                         char *strsect_name));
1802
1803 /* Dump the stabs sections from an object file that has a section that
1804    uses Sun stabs encoding.  */
1805
1806 static void
1807 dump_stabs (abfd)
1808      bfd *abfd;
1809 {
1810   dump_section_stabs (abfd, ".stab", ".stabstr");
1811   dump_section_stabs (abfd, ".stab.excl", ".stab.exclstr");
1812   dump_section_stabs (abfd, ".stab.index", ".stab.indexstr");
1813   dump_section_stabs (abfd, "$GDB_SYMBOLS$", "$GDB_STRINGS$");
1814 }
1815
1816 static bfd_byte *stabs;
1817 static bfd_size_type stab_size;
1818
1819 static char *strtab;
1820 static bfd_size_type stabstr_size;
1821
1822 /* Read ABFD's stabs section STABSECT_NAME into `stabs'
1823    and string table section STRSECT_NAME into `strtab'.
1824    If the section exists and was read, allocate the space and return true.
1825    Otherwise return false.  */
1826
1827 static boolean
1828 read_section_stabs (abfd, stabsect_name, strsect_name)
1829      bfd *abfd;
1830      const char *stabsect_name;
1831      const char *strsect_name;
1832 {
1833   asection *stabsect, *stabstrsect;
1834
1835   stabsect = bfd_get_section_by_name (abfd, stabsect_name);
1836   if (0 == stabsect)
1837     {
1838       printf (_("No %s section present\n\n"), stabsect_name);
1839       return false;
1840     }
1841
1842   stabstrsect = bfd_get_section_by_name (abfd, strsect_name);
1843   if (0 == stabstrsect)
1844     {
1845       fprintf (stderr, _("%s: %s has no %s section\n"), program_name,
1846                bfd_get_filename (abfd), strsect_name);
1847       exit_status = 1;
1848       return false;
1849     }
1850
1851   stab_size    = bfd_section_size (abfd, stabsect);
1852   stabstr_size = bfd_section_size (abfd, stabstrsect);
1853
1854   stabs  = (bfd_byte *) xmalloc (stab_size);
1855   strtab = (char *) xmalloc (stabstr_size);
1856
1857   if (! bfd_get_section_contents (abfd, stabsect, (PTR) stabs, 0, stab_size))
1858     {
1859       fprintf (stderr, _("%s: Reading %s section of %s failed: %s\n"),
1860                program_name, stabsect_name, bfd_get_filename (abfd),
1861                bfd_errmsg (bfd_get_error ()));
1862       free (stabs);
1863       free (strtab);
1864       exit_status = 1;
1865       return false;
1866     }
1867
1868   if (! bfd_get_section_contents (abfd, stabstrsect, (PTR) strtab, 0,
1869                                   stabstr_size))
1870     {
1871       fprintf (stderr, _("%s: Reading %s section of %s failed: %s\n"),
1872                program_name, strsect_name, bfd_get_filename (abfd),
1873                bfd_errmsg (bfd_get_error ()));
1874       free (stabs);
1875       free (strtab);
1876       exit_status = 1;
1877       return false;
1878     }
1879
1880   return true;
1881 }
1882
1883 /* Stabs entries use a 12 byte format:
1884      4 byte string table index
1885      1 byte stab type
1886      1 byte stab other field
1887      2 byte stab desc field
1888      4 byte stab value
1889    FIXME: This will have to change for a 64 bit object format.  */
1890
1891 #define STRDXOFF (0)
1892 #define TYPEOFF (4)
1893 #define OTHEROFF (5)
1894 #define DESCOFF (6)
1895 #define VALOFF (8)
1896 #define STABSIZE (12)
1897
1898 /* Print ABFD's stabs section STABSECT_NAME (in `stabs'),
1899    using string table section STRSECT_NAME (in `strtab').  */
1900
1901 static void
1902 print_section_stabs (abfd, stabsect_name, strsect_name)
1903      bfd *abfd;
1904      const char *stabsect_name;
1905      const char *strsect_name ATTRIBUTE_UNUSED;
1906 {
1907   int i;
1908   unsigned file_string_table_offset = 0, next_file_string_table_offset = 0;
1909   bfd_byte *stabp, *stabs_end;
1910
1911   stabp = stabs;
1912   stabs_end = stabp + stab_size;
1913
1914   printf (_("Contents of %s section:\n\n"), stabsect_name);
1915   printf ("Symnum n_type n_othr n_desc n_value  n_strx String\n");
1916
1917   /* Loop through all symbols and print them.
1918
1919      We start the index at -1 because there is a dummy symbol on
1920      the front of stabs-in-{coff,elf} sections that supplies sizes.  */
1921
1922   for (i = -1; stabp < stabs_end; stabp += STABSIZE, i++)
1923     {
1924       const char *name;
1925       unsigned long strx;
1926       unsigned char type, other;
1927       unsigned short desc;
1928       bfd_vma value;
1929
1930       strx = bfd_h_get_32 (abfd, stabp + STRDXOFF);
1931       type = bfd_h_get_8 (abfd, stabp + TYPEOFF);
1932       other = bfd_h_get_8 (abfd, stabp + OTHEROFF);
1933       desc = bfd_h_get_16 (abfd, stabp + DESCOFF);
1934       value = bfd_h_get_32 (abfd, stabp + VALOFF);
1935
1936       printf ("\n%-6d ", i);
1937       /* Either print the stab name, or, if unnamed, print its number
1938          again (makes consistent formatting for tools like awk). */
1939       name = bfd_get_stab_name (type);
1940       if (name != NULL)
1941         printf ("%-6s", name);
1942       else if (type == N_UNDF)
1943         printf ("HdrSym");
1944       else
1945         printf ("%-6d", type);
1946       printf (" %-6d %-6d ", other, desc);
1947       printf_vma (value);
1948       printf (" %-6lu", strx);
1949
1950       /* Symbols with type == 0 (N_UNDF) specify the length of the
1951          string table associated with this file.  We use that info
1952          to know how to relocate the *next* file's string table indices.  */
1953
1954       if (type == N_UNDF)
1955         {
1956           file_string_table_offset = next_file_string_table_offset;
1957           next_file_string_table_offset += value;
1958         }
1959       else
1960         {
1961           /* Using the (possibly updated) string table offset, print the
1962              string (if any) associated with this symbol.  */
1963
1964           if ((strx + file_string_table_offset) < stabstr_size)
1965             printf (" %s", &strtab[strx + file_string_table_offset]);
1966           else
1967             printf (" *");
1968         }
1969     }
1970   printf ("\n\n");
1971 }
1972
1973 static void
1974 dump_section_stabs (abfd, stabsect_name, strsect_name)
1975      bfd *abfd;
1976      char *stabsect_name;
1977      char *strsect_name;
1978 {
1979   asection *s;
1980
1981   /* Check for section names for which stabsect_name is a prefix, to
1982      handle .stab0, etc.  */
1983   for (s = abfd->sections;
1984        s != NULL;
1985        s = s->next)
1986     {
1987       int len;
1988
1989       len = strlen (stabsect_name);
1990
1991       /* If the prefix matches, and the files section name ends with a
1992          nul or a digit, then we match.  I.e., we want either an exact
1993          match or a section followed by a number.  */
1994       if (strncmp (stabsect_name, s->name, len) == 0
1995           && (s->name[len] == '\000'
1996               || isdigit ((unsigned char) s->name[len])))
1997         {
1998           if (read_section_stabs (abfd, s->name, strsect_name))
1999             {
2000               print_section_stabs (abfd, s->name, strsect_name);
2001               free (stabs);
2002               free (strtab);
2003             }
2004         }
2005     }
2006 }
2007 \f
2008 static void
2009 dump_bfd_header (abfd)
2010      bfd *abfd;
2011 {
2012   char *comma = "";
2013
2014   printf (_("architecture: %s, "),
2015           bfd_printable_arch_mach (bfd_get_arch (abfd),
2016                                    bfd_get_mach (abfd)));
2017   printf (_("flags 0x%08x:\n"), abfd->flags);
2018
2019 #define PF(x, y)    if (abfd->flags & x) {printf("%s%s", comma, y); comma=", ";}
2020   PF (HAS_RELOC, "HAS_RELOC");
2021   PF (EXEC_P, "EXEC_P");
2022   PF (HAS_LINENO, "HAS_LINENO");
2023   PF (HAS_DEBUG, "HAS_DEBUG");
2024   PF (HAS_SYMS, "HAS_SYMS");
2025   PF (HAS_LOCALS, "HAS_LOCALS");
2026   PF (DYNAMIC, "DYNAMIC");
2027   PF (WP_TEXT, "WP_TEXT");
2028   PF (D_PAGED, "D_PAGED");
2029   PF (BFD_IS_RELAXABLE, "BFD_IS_RELAXABLE");
2030   printf (_("\nstart address 0x"));
2031   printf_vma (abfd->start_address);
2032   printf ("\n");
2033 }
2034 \f
2035 static void
2036 dump_bfd_private_header (abfd)
2037 bfd *abfd;
2038 {
2039   bfd_print_private_bfd_data (abfd, stdout);
2040 }
2041
2042 static void
2043 display_bfd (abfd)
2044      bfd *abfd;
2045 {
2046   char **matching;
2047
2048   if (!bfd_check_format_matches (abfd, bfd_object, &matching))
2049     {
2050       nonfatal (bfd_get_filename (abfd));
2051       if (bfd_get_error () == bfd_error_file_ambiguously_recognized)
2052         {
2053           list_matching_formats (matching);
2054           free (matching);
2055         }
2056       return;
2057     }
2058
2059   /* If we are adjusting section VMA's, change them all now.  Changing
2060      the BFD information is a hack.  However, we must do it, or
2061      bfd_find_nearest_line will not do the right thing.  */
2062   if (adjust_section_vma != 0)
2063     {
2064       asection *s;
2065
2066       for (s = abfd->sections; s != NULL; s = s->next)
2067         {
2068           s->vma += adjust_section_vma;
2069           s->lma += adjust_section_vma;
2070         }
2071     }
2072
2073   printf (_("\n%s:     file format %s\n"), bfd_get_filename (abfd),
2074           abfd->xvec->name);
2075   if (dump_ar_hdrs)
2076     print_arelt_descr (stdout, abfd, true);
2077   if (dump_file_header)
2078     dump_bfd_header (abfd);
2079   if (dump_private_headers)
2080     dump_bfd_private_header (abfd);
2081   putchar ('\n');
2082   if (dump_section_headers)
2083     dump_headers (abfd);
2084   if (dump_symtab || dump_reloc_info || disassemble || dump_debugging)
2085     {
2086       syms = slurp_symtab (abfd);
2087     }
2088   if (dump_dynamic_symtab || dump_dynamic_reloc_info)
2089     {
2090       dynsyms = slurp_dynamic_symtab (abfd);
2091     }
2092   if (dump_symtab)
2093     dump_symbols (abfd, false);
2094   if (dump_dynamic_symtab)
2095     dump_symbols (abfd, true);
2096   if (dump_stab_section_info)
2097     dump_stabs (abfd);
2098   if (dump_reloc_info && ! disassemble)
2099     dump_relocs (abfd);
2100   if (dump_dynamic_reloc_info)
2101     dump_dynamic_relocs (abfd);
2102   if (dump_section_contents)
2103     dump_data (abfd);
2104   if (disassemble)
2105     disassemble_data (abfd);
2106   if (dump_debugging)
2107     {
2108       PTR dhandle;
2109
2110       dhandle = read_debugging_info (abfd, syms, symcount);
2111       if (dhandle != NULL)
2112         {
2113           if (! print_debugging_info (stdout, dhandle))
2114             {
2115               fprintf (stderr,
2116                        _("%s: printing debugging information failed\n"),
2117                        bfd_get_filename (abfd));
2118               exit_status = 1;
2119             }
2120         }
2121     }
2122   if (syms)
2123     {
2124       free (syms);
2125       syms = NULL;
2126     }
2127   if (dynsyms)
2128     {
2129       free (dynsyms);
2130       dynsyms = NULL;
2131     }
2132 }
2133
2134 static void
2135 display_file (filename, target)
2136      char *filename;
2137      char *target;
2138 {
2139   bfd *file, *arfile = (bfd *) NULL;
2140
2141   file = bfd_openr (filename, target);
2142   if (file == NULL)
2143     {
2144       nonfatal (filename);
2145       return;
2146     }
2147
2148   if (bfd_check_format (file, bfd_archive) == true)
2149     {
2150       bfd *last_arfile = NULL;
2151
2152       printf (_("In archive %s:\n"), bfd_get_filename (file));
2153       for (;;)
2154         {
2155           bfd_set_error (bfd_error_no_error);
2156
2157           arfile = bfd_openr_next_archived_file (file, arfile);
2158           if (arfile == NULL)
2159             {
2160               if (bfd_get_error () != bfd_error_no_more_archived_files)
2161                 nonfatal (bfd_get_filename (file));
2162               break;
2163             }
2164
2165           display_bfd (arfile);
2166
2167           if (last_arfile != NULL)
2168             bfd_close (last_arfile);
2169           last_arfile = arfile;
2170         }
2171
2172       if (last_arfile != NULL)
2173         bfd_close (last_arfile);
2174     }
2175   else
2176     display_bfd (file);
2177
2178   bfd_close (file);
2179 }
2180 \f
2181 /* Actually display the various requested regions */
2182
2183 static void
2184 dump_data (abfd)
2185      bfd *abfd;
2186 {
2187   asection *section;
2188   bfd_byte *data = 0;
2189   bfd_size_type datasize = 0;
2190   bfd_size_type i;
2191   bfd_size_type start, stop;
2192
2193   for (section = abfd->sections; section != NULL; section =
2194        section->next)
2195     {
2196       int onaline = 16;
2197
2198       if (only == (char *) NULL ||
2199           strcmp (only, section->name) == 0)
2200         {
2201           if (section->flags & SEC_HAS_CONTENTS)
2202             {
2203               printf (_("Contents of section %s:\n"), section->name);
2204
2205               if (bfd_section_size (abfd, section) == 0)
2206                 continue;
2207               data = (bfd_byte *) xmalloc ((size_t) bfd_section_size (abfd, section));
2208               datasize = bfd_section_size (abfd, section);
2209
2210
2211               bfd_get_section_contents (abfd, section, (PTR) data, 0, bfd_section_size (abfd, section));
2212
2213               if (start_address == (bfd_vma) -1
2214                   || start_address < section->vma)
2215                 start = 0;
2216               else
2217                 start = start_address - section->vma;
2218               if (stop_address == (bfd_vma) -1)
2219                 stop = bfd_section_size (abfd, section);
2220               else
2221                 {
2222                   if (stop_address < section->vma)
2223                     stop = 0;
2224                   else
2225                     stop = stop_address - section->vma;
2226                   if (stop > bfd_section_size (abfd, section))
2227                     stop = bfd_section_size (abfd, section);
2228                 }
2229               for (i = start; i < stop; i += onaline)
2230                 {
2231                   bfd_size_type j;
2232
2233                   printf (" %04lx ", (unsigned long int) (i + section->vma));
2234                   for (j = i; j < i + onaline; j++)
2235                     {
2236                       if (j < stop)
2237                         printf ("%02x", (unsigned) (data[j]));
2238                       else
2239                         printf ("  ");
2240                       if ((j & 3) == 3)
2241                         printf (" ");
2242                     }
2243
2244                   printf (" ");
2245                   for (j = i; j < i + onaline; j++)
2246                     {
2247                       if (j >= stop)
2248                         printf (" ");
2249                       else
2250                         printf ("%c", isprint (data[j]) ? data[j] : '.');
2251                     }
2252                   putchar ('\n');
2253                 }
2254               free (data);
2255             }
2256         }
2257     }
2258 }
2259
2260 /* Should perhaps share code and display with nm? */
2261 static void
2262 dump_symbols (abfd, dynamic)
2263      bfd *abfd ATTRIBUTE_UNUSED;
2264      boolean dynamic;
2265 {
2266   asymbol **current;
2267   long max;
2268   long count;
2269
2270   if (dynamic)
2271     {
2272       current = dynsyms;
2273       max = dynsymcount;
2274       if (max == 0)
2275         return;
2276       printf ("DYNAMIC SYMBOL TABLE:\n");
2277     }
2278   else
2279     {
2280       current = syms;
2281       max = symcount;
2282       if (max == 0)
2283         return;
2284       printf ("SYMBOL TABLE:\n");
2285     }
2286
2287   for (count = 0; count < max; count++)
2288     {
2289       if (*current)
2290         {
2291           bfd *cur_bfd = bfd_asymbol_bfd (*current);
2292
2293           if (cur_bfd != NULL)
2294             {
2295               const char *name;
2296               char *alloc;
2297
2298               name = bfd_asymbol_name (*current);
2299               alloc = NULL;
2300               if (do_demangle && name != NULL && *name != '\0')
2301                 {
2302                   const char *n;
2303
2304                   /* If we want to demangle the name, we demangle it
2305                      here, and temporarily clobber it while calling
2306                      bfd_print_symbol.  FIXME: This is a gross hack.  */
2307
2308                   n = name;
2309                   if (bfd_get_symbol_leading_char (cur_bfd) == *n)
2310                     ++n;
2311                   alloc = cplus_demangle (n, DMGL_ANSI | DMGL_PARAMS);
2312                   if (alloc != NULL)
2313                     (*current)->name = alloc;
2314                   else
2315                     (*current)->name = n;
2316                 }
2317
2318               bfd_print_symbol (cur_bfd, stdout, *current,
2319                                 bfd_print_symbol_all);
2320
2321               (*current)->name = name;
2322               if (alloc != NULL)
2323                 free (alloc);
2324
2325               printf ("\n");
2326             }
2327         }
2328       current++;
2329     }
2330   printf ("\n");
2331   printf ("\n");
2332 }
2333
2334 static void
2335 dump_relocs (abfd)
2336      bfd *abfd;
2337 {
2338   arelent **relpp;
2339   long relcount;
2340   asection *a;
2341
2342   for (a = abfd->sections; a != (asection *) NULL; a = a->next)
2343     {
2344       long relsize;
2345
2346       if (bfd_is_abs_section (a))
2347         continue;
2348       if (bfd_is_und_section (a))
2349         continue;
2350       if (bfd_is_com_section (a))
2351         continue;
2352
2353       if (only)
2354         {
2355           if (strcmp (only, a->name))
2356             continue;
2357         }
2358       else if ((a->flags & SEC_RELOC) == 0)
2359         continue;
2360
2361       relsize = bfd_get_reloc_upper_bound (abfd, a);
2362       if (relsize < 0)
2363         bfd_fatal (bfd_get_filename (abfd));
2364
2365       printf ("RELOCATION RECORDS FOR [%s]:", a->name);
2366
2367       if (relsize == 0)
2368         {
2369           printf (" (none)\n\n");
2370         }
2371       else
2372         {
2373           relpp = (arelent **) xmalloc (relsize);
2374           relcount = bfd_canonicalize_reloc (abfd, a, relpp, syms);
2375           if (relcount < 0)
2376             bfd_fatal (bfd_get_filename (abfd));
2377           else if (relcount == 0)
2378             {
2379               printf (" (none)\n\n");
2380             }
2381           else
2382             {
2383               printf ("\n");
2384               dump_reloc_set (abfd, a, relpp, relcount);
2385               printf ("\n\n");
2386             }
2387           free (relpp);
2388         }
2389     }
2390 }
2391
2392 static void
2393 dump_dynamic_relocs (abfd)
2394      bfd *abfd;
2395 {
2396   long relsize;
2397   arelent **relpp;
2398   long relcount;
2399
2400   relsize = bfd_get_dynamic_reloc_upper_bound (abfd);
2401   if (relsize < 0)
2402     bfd_fatal (bfd_get_filename (abfd));
2403
2404   printf ("DYNAMIC RELOCATION RECORDS");
2405
2406   if (relsize == 0)
2407     {
2408       printf (" (none)\n\n");
2409     }
2410   else
2411     {
2412       relpp = (arelent **) xmalloc (relsize);
2413       relcount = bfd_canonicalize_dynamic_reloc (abfd, relpp, dynsyms);
2414       if (relcount < 0)
2415         bfd_fatal (bfd_get_filename (abfd));
2416       else if (relcount == 0)
2417         {
2418           printf (" (none)\n\n");
2419         }
2420       else
2421         {
2422           printf ("\n");
2423           dump_reloc_set (abfd, (asection *) NULL, relpp, relcount);
2424           printf ("\n\n");
2425         }
2426       free (relpp);
2427     }
2428 }
2429
2430 static void
2431 dump_reloc_set (abfd, sec, relpp, relcount)
2432      bfd *abfd;
2433      asection *sec;
2434      arelent **relpp;
2435      long relcount;
2436 {
2437   arelent **p;
2438   char *last_filename, *last_functionname;
2439   unsigned int last_line;
2440
2441   /* Get column headers lined up reasonably.  */
2442   {
2443     static int width;
2444     if (width == 0)
2445       {
2446         char buf[30];
2447         sprintf_vma (buf, (bfd_vma) -1);
2448         width = strlen (buf) - 7;
2449       }
2450     printf ("OFFSET %*s TYPE %*s VALUE \n", width, "", 12, "");
2451   }
2452
2453   last_filename = NULL;
2454   last_functionname = NULL;
2455   last_line = 0;
2456
2457   for (p = relpp; relcount && *p != (arelent *) NULL; p++, relcount--)
2458     {
2459       arelent *q = *p;
2460       const char *filename, *functionname;
2461       unsigned int line;
2462       const char *sym_name;
2463       const char *section_name;
2464
2465       if (start_address != (bfd_vma) -1
2466           && q->address < start_address)
2467         continue;
2468       if (stop_address != (bfd_vma) -1
2469           && q->address > stop_address)
2470         continue;
2471
2472       if (with_line_numbers
2473           && sec != NULL
2474           && bfd_find_nearest_line (abfd, sec, syms, q->address,
2475                                     &filename, &functionname, &line))
2476         {
2477           if (functionname != NULL
2478               && (last_functionname == NULL
2479                   || strcmp (functionname, last_functionname) != 0))
2480             {
2481               printf ("%s():\n", functionname);
2482               if (last_functionname != NULL)
2483                 free (last_functionname);
2484               last_functionname = xstrdup (functionname);
2485             }
2486           if (line > 0
2487               && (line != last_line
2488                   || (filename != NULL
2489                       && last_filename != NULL
2490                       && strcmp (filename, last_filename) != 0)))
2491             {
2492               printf ("%s:%u\n", filename == NULL ? "???" : filename, line);
2493               last_line = line;
2494               if (last_filename != NULL)
2495                 free (last_filename);
2496               if (filename == NULL)
2497                 last_filename = NULL;
2498               else
2499                 last_filename = xstrdup (filename);
2500             }
2501         }
2502
2503       if (q->sym_ptr_ptr && *q->sym_ptr_ptr)
2504         {
2505           sym_name = (*(q->sym_ptr_ptr))->name;
2506           section_name = (*(q->sym_ptr_ptr))->section->name;
2507         }
2508       else
2509         {
2510           sym_name = NULL;
2511           section_name = NULL;
2512         }
2513       if (sym_name)
2514         {
2515           printf_vma (q->address);
2516           if (q->howto->name)
2517             printf (" %-16s  ", q->howto->name);
2518           else
2519             printf (" %-16d  ", q->howto->type);
2520           objdump_print_symname (abfd, (struct disassemble_info *) NULL,
2521                                  *q->sym_ptr_ptr);
2522         }
2523       else
2524         {
2525           if (section_name == (CONST char *) NULL)
2526             section_name = "*unknown*";
2527           printf_vma (q->address);
2528           printf (" %-16s  [%s]",
2529                   q->howto->name,
2530                   section_name);
2531         }
2532       if (q->addend)
2533         {
2534           printf ("+0x");
2535           printf_vma (q->addend);
2536         }
2537       printf ("\n");
2538     }
2539 }
2540 \f
2541 /* The length of the longest architecture name + 1.  */
2542 #define LONGEST_ARCH sizeof("rs6000:6000")
2543
2544 static const char *
2545 endian_string (endian)
2546      enum bfd_endian endian;
2547 {
2548   if (endian == BFD_ENDIAN_BIG)
2549     return "big endian";
2550   else if (endian == BFD_ENDIAN_LITTLE)
2551     return "little endian";
2552   else
2553     return "endianness unknown";
2554 }
2555
2556 /* List the targets that BFD is configured to support, each followed
2557    by its endianness and the architectures it supports.  */
2558
2559 static void
2560 display_target_list ()
2561 {
2562   extern bfd_target *bfd_target_vector[];
2563   char *dummy_name;
2564   int t;
2565
2566   dummy_name = choose_temp_base ();
2567   for (t = 0; bfd_target_vector[t]; t++)
2568     {
2569       bfd_target *p = bfd_target_vector[t];
2570       bfd *abfd = bfd_openw (dummy_name, p->name);
2571       int a;
2572
2573       printf ("%s\n (header %s, data %s)\n", p->name,
2574               endian_string (p->header_byteorder),
2575               endian_string (p->byteorder));
2576
2577       if (abfd == NULL)
2578         {
2579           nonfatal (dummy_name);
2580           continue;
2581         }
2582
2583       if (! bfd_set_format (abfd, bfd_object))
2584         {
2585           if (bfd_get_error () != bfd_error_invalid_operation)
2586             nonfatal (p->name);
2587           continue;
2588         }
2589
2590       for (a = (int) bfd_arch_obscure + 1; a < (int) bfd_arch_last; a++)
2591         if (bfd_set_arch_mach (abfd, (enum bfd_architecture) a, 0))
2592           printf ("  %s\n",
2593                   bfd_printable_arch_mach ((enum bfd_architecture) a, 0));
2594     }
2595   unlink (dummy_name);
2596   free (dummy_name);
2597 }
2598
2599 /* Print a table showing which architectures are supported for entries
2600    FIRST through LAST-1 of bfd_target_vector (targets across,
2601    architectures down).  */
2602
2603 static void
2604 display_info_table (first, last)
2605      int first;
2606      int last;
2607 {
2608   extern bfd_target *bfd_target_vector[];
2609   int t, a;
2610   char *dummy_name;
2611
2612   /* Print heading of target names.  */
2613   printf ("\n%*s", (int) LONGEST_ARCH, " ");
2614   for (t = first; t < last && bfd_target_vector[t]; t++)
2615     printf ("%s ", bfd_target_vector[t]->name);
2616   putchar ('\n');
2617
2618   dummy_name = choose_temp_base ();
2619   for (a = (int) bfd_arch_obscure + 1; a < (int) bfd_arch_last; a++)
2620     if (strcmp (bfd_printable_arch_mach (a, 0), "UNKNOWN!") != 0)
2621       {
2622         printf ("%*s ", (int) LONGEST_ARCH - 1,
2623                 bfd_printable_arch_mach (a, 0));
2624         for (t = first; t < last && bfd_target_vector[t]; t++)
2625           {
2626             bfd_target *p = bfd_target_vector[t];
2627             boolean ok = true;
2628             bfd *abfd = bfd_openw (dummy_name, p->name);
2629
2630             if (abfd == NULL)
2631               {
2632                 nonfatal (p->name);
2633                 ok = false;
2634               }
2635
2636             if (ok)
2637               {
2638                 if (! bfd_set_format (abfd, bfd_object))
2639                   {
2640                     if (bfd_get_error () != bfd_error_invalid_operation)
2641                       nonfatal (p->name);
2642                     ok = false;
2643                   }
2644               }
2645
2646             if (ok)
2647               {
2648                 if (! bfd_set_arch_mach (abfd, a, 0))
2649                   ok = false;
2650               }
2651
2652             if (ok)
2653               printf ("%s ", p->name);
2654             else
2655               {
2656                 int l = strlen (p->name);
2657                 while (l--)
2658                   putchar ('-');
2659                 putchar (' ');
2660               }
2661           }
2662         putchar ('\n');
2663       }
2664   unlink (dummy_name);
2665   free (dummy_name);
2666 }
2667
2668 /* Print tables of all the target-architecture combinations that
2669    BFD has been configured to support.  */
2670
2671 static void
2672 display_target_tables ()
2673 {
2674   int t, columns;
2675   extern bfd_target *bfd_target_vector[];
2676   char *colum;
2677
2678   columns = 0;
2679   colum = getenv ("COLUMNS");
2680   if (colum != NULL)
2681     columns = atoi (colum);
2682   if (columns == 0)
2683     columns = 80;
2684
2685   t = 0;
2686   while (bfd_target_vector[t] != NULL)
2687     {
2688       int oldt = t, wid;
2689
2690       wid = LONGEST_ARCH + strlen (bfd_target_vector[t]->name) + 1;
2691       ++t;
2692       while (wid < columns && bfd_target_vector[t] != NULL)
2693         {
2694           int newwid;
2695
2696           newwid = wid + strlen (bfd_target_vector[t]->name) + 1;
2697           if (newwid >= columns)
2698             break;
2699           wid = newwid;
2700           ++t;
2701         }
2702       display_info_table (oldt, t);
2703     }
2704 }
2705
2706 static void
2707 display_info ()
2708 {
2709   printf (_("BFD header file version %s\n"), BFD_VERSION);
2710   display_target_list ();
2711   display_target_tables ();
2712 }
2713
2714 int
2715 main (argc, argv)
2716      int argc;
2717      char **argv;
2718 {
2719   int c;
2720   char *target = default_target;
2721   boolean seenflag = false;
2722
2723 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
2724   setlocale (LC_MESSAGES, "");
2725 #endif
2726   bindtextdomain (PACKAGE, LOCALEDIR);
2727   textdomain (PACKAGE);
2728
2729   program_name = *argv;
2730   xmalloc_set_program_name (program_name);
2731
2732   START_PROGRESS (program_name, 0);
2733
2734   bfd_init ();
2735   set_default_bfd_target ();
2736
2737   while ((c = getopt_long (argc, argv, "pib:m:M:VCdDlfahrRtTxsSj:wE:",
2738                            long_options, (int *) 0))
2739          != EOF)
2740     {
2741       if (c != 'l' && c != OPTION_START_ADDRESS && c != OPTION_STOP_ADDRESS)
2742         seenflag = true;
2743       switch (c)
2744         {
2745         case 0:
2746           break;                /* we've been given a long option */
2747         case 'm':
2748           machine = optarg;
2749           break;
2750         case 'M':
2751           disassembler_options = optarg;
2752           break;
2753         case 'j':
2754           only = optarg;
2755           break;
2756         case 'l':
2757           with_line_numbers = 1;
2758           break;
2759         case 'b':
2760           target = optarg;
2761           break;
2762         case 'f':
2763           dump_file_header = true;
2764           break;
2765         case 'i':
2766           formats_info = true;
2767           break;
2768         case 'p':
2769           dump_private_headers = 1;
2770           break;
2771         case 'x':
2772           dump_private_headers = 1;
2773           dump_symtab = 1;
2774           dump_reloc_info = 1;
2775           dump_file_header = true;
2776           dump_ar_hdrs = 1;
2777           dump_section_headers = 1;
2778           break;
2779         case 't':
2780           dump_symtab = 1;
2781           break;
2782         case 'T':
2783           dump_dynamic_symtab = 1;
2784           break;
2785         case 'C':
2786           do_demangle = 1;
2787           break;
2788         case 'd':
2789           disassemble = true;
2790           break;
2791         case 'D':
2792           disassemble = disassemble_all = true;
2793           break;
2794         case 'S':
2795           disassemble = true;
2796           with_source_code = true;
2797           break;
2798         case 's':
2799           dump_section_contents = 1;
2800           break;
2801         case 'r':
2802           dump_reloc_info = 1;
2803           break;
2804         case 'R':
2805           dump_dynamic_reloc_info = 1;
2806           break;
2807         case 'a':
2808           dump_ar_hdrs = 1;
2809           break;
2810         case 'h':
2811           dump_section_headers = 1;
2812           break;
2813         case 'H':
2814           usage (stdout, 0);
2815         case 'V':
2816           show_version = 1;
2817           break;
2818         case 'w':
2819           wide_output = 1;
2820           break;
2821         case OPTION_ADJUST_VMA:
2822           adjust_section_vma = parse_vma (optarg, "--adjust-vma");
2823           break;
2824         case OPTION_START_ADDRESS:
2825           start_address = parse_vma (optarg, "--start-address");
2826           break;
2827         case OPTION_STOP_ADDRESS:
2828           stop_address = parse_vma (optarg, "--stop-address");
2829           break;
2830         case 'E':
2831           if (strcmp (optarg, "B") == 0)
2832             endian = BFD_ENDIAN_BIG;
2833           else if (strcmp (optarg, "L") == 0)
2834             endian = BFD_ENDIAN_LITTLE;
2835           else
2836             {
2837               fprintf (stderr, _("%s: unrecognized -E option\n"),
2838                        program_name);
2839               usage (stderr, 1);
2840             }
2841           break;
2842         case OPTION_ENDIAN:
2843           if (strncmp (optarg, "big", strlen (optarg)) == 0)
2844             endian = BFD_ENDIAN_BIG;
2845           else if (strncmp (optarg, "little", strlen (optarg)) == 0)
2846             endian = BFD_ENDIAN_LITTLE;
2847           else
2848             {
2849               fprintf (stderr, _("%s: unrecognized --endian type `%s'\n"),
2850                       program_name, optarg);
2851               usage (stderr, 1);
2852             }
2853           break;
2854         default:
2855           usage (stderr, 1);
2856         }
2857     }
2858
2859   if (show_version)
2860     print_version ("objdump");
2861
2862   if (seenflag == false)
2863     usage (stderr, 1);
2864
2865   if (formats_info)
2866     {
2867       display_info ();
2868     }
2869   else
2870     {
2871       if (optind == argc)
2872         display_file ("a.out", target);
2873       else
2874         for (; optind < argc;)
2875           display_file (argv[optind++], target);
2876     }
2877
2878   END_PROGRESS (program_name);
2879
2880   return exit_status;
2881 }