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