binutils/objdump.c

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