binutils/objdump.c

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