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 bug-gnu-utils@prep.ai.mit.edu\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
1202                   putchar ('\n');
1203                   j = i + pb;
1204                   printf ("%6lx:\t", (unsigned long) (j - start));
1205                   pb += bytes_per_line;
1206                   if (pb > bytes)
1207                     pb = bytes;
1208                   for (; j < i + pb; ++j)
1209                     {
1210                       printf ("%02x", (unsigned) data[j]);
1211                       putchar (' ');
1212                     }
1213                 }
1214             }
1215
1216           if (!wide_output)
1217             putchar ('\n');
1218           else
1219             need_nl = true;
1220         }
1221
1222       if (dump_reloc_info
1223           && (section->flags & SEC_RELOC) != 0)
1224         {
1225           while ((*relppp) < relppend
1226                  && ((**relppp)->address >= (bfd_vma) i
1227                      && (**relppp)->address < (bfd_vma) i + bytes))
1228             {
1229               arelent *q;
1230               const char *sym_name;
1231
1232               q = **relppp;
1233
1234               if (wide_output)
1235                 putchar ('\t');
1236               else
1237                 printf ("\t\t\t");
1238
1239               objdump_print_value (section->vma + q->address, info, true);
1240
1241               printf (": %s\t", q->howto->name);
1242
1243               if (q->sym_ptr_ptr != NULL
1244                   && *q->sym_ptr_ptr != NULL)
1245                 {
1246                   sym_name = bfd_asymbol_name (*q->sym_ptr_ptr);
1247                   if (sym_name == NULL || *sym_name == '\0')
1248                     {
1249                       asection *sym_sec;
1250
1251                       sym_sec = bfd_get_section (*q->sym_ptr_ptr);
1252                       sym_name = bfd_get_section_name (abfd, sym_sec);
1253                       if (sym_name == NULL || *sym_name == '\0')
1254                         sym_name = "*unknown*";
1255                     }
1256                 }
1257               else
1258                 sym_name = "*unknown*";
1259
1260               printf ("%s", sym_name);
1261
1262               if (q->addend)
1263                 {
1264                   printf ("+0x");
1265                   objdump_print_value (q->addend, info, true);
1266                 }
1267
1268               printf ("\n");
1269               need_nl = false;
1270               ++(*relppp);
1271             }
1272         }
1273
1274       if (need_nl)
1275         printf ("\n");
1276
1277       i += bytes;
1278     }
1279 }
1280
1281 /* Disassemble the contents of an object file.  */
1282
1283 static void
1284 disassemble_data (abfd)
1285      bfd *abfd;
1286 {
1287   long i;
1288   disassembler_ftype disassemble_fn;
1289   struct disassemble_info disasm_info;
1290   struct objdump_disasm_info aux;
1291   asection *section;
1292
1293   print_files = NULL;
1294   prev_functionname = NULL;
1295   prev_line = -1;
1296
1297   /* We make a copy of syms to sort.  We don't want to sort syms
1298      because that will screw up the relocs.  */
1299   sorted_syms = (asymbol **) xmalloc (symcount * sizeof (asymbol *));
1300   memcpy (sorted_syms, syms, symcount * sizeof (asymbol *));
1301
1302   sorted_symcount = remove_useless_symbols (sorted_syms, symcount);
1303
1304   /* Sort the symbols into section and symbol order */
1305   qsort (sorted_syms, sorted_symcount, sizeof (asymbol *), compare_symbols);
1306
1307   INIT_DISASSEMBLE_INFO(disasm_info, stdout, fprintf);
1308   disasm_info.application_data = (PTR) &aux;
1309   aux.abfd = abfd;
1310   disasm_info.print_address_func = objdump_print_address;
1311
1312   if (machine != (char *) NULL)
1313     {
1314       const bfd_arch_info_type *info = bfd_scan_arch (machine);
1315       if (info == NULL)
1316         {
1317           fprintf (stderr, "%s: Can't use supplied machine %s\n",
1318                    program_name,
1319                    machine);
1320           exit (1);
1321         }
1322       abfd->arch_info = info;
1323     }
1324
1325   if (endian != BFD_ENDIAN_UNKNOWN)
1326     {
1327       struct bfd_target *xvec;
1328
1329       xvec = (struct bfd_target *) xmalloc (sizeof (struct bfd_target));
1330       memcpy (xvec, abfd->xvec, sizeof (struct bfd_target));
1331       xvec->byteorder = endian;
1332       abfd->xvec = xvec;
1333     }
1334
1335   disassemble_fn = disassembler (abfd);
1336   if (!disassemble_fn)
1337     {
1338       fprintf (stderr, "%s: Can't disassemble for architecture %s\n",
1339                program_name,
1340                bfd_printable_arch_mach (bfd_get_arch (abfd), 0));
1341       exit (1);
1342     }
1343
1344   disasm_info.flavour = bfd_get_flavour (abfd);
1345   disasm_info.arch = bfd_get_arch (abfd);
1346   disasm_info.mach = bfd_get_mach (abfd);
1347   if (bfd_big_endian (abfd))
1348     disasm_info.endian = BFD_ENDIAN_BIG;
1349   else if (bfd_little_endian (abfd))
1350     disasm_info.endian = BFD_ENDIAN_LITTLE;
1351   else
1352     /* ??? Aborting here seems too drastic.  We could default to big or little
1353        instead.  */
1354     disasm_info.endian = BFD_ENDIAN_UNKNOWN;
1355
1356   for (section = abfd->sections;
1357        section != (asection *) NULL;
1358        section = section->next)
1359     {
1360       bfd_byte *data = NULL;
1361       bfd_size_type datasize = 0;
1362       arelent **relbuf = NULL;
1363       arelent **relpp = NULL;
1364       arelent **relppend = NULL;
1365       long stop;
1366
1367       if ((section->flags & SEC_LOAD) == 0
1368           || (! disassemble_all
1369               && only == NULL
1370               && (section->flags & SEC_CODE) == 0))
1371         continue;
1372       if (only != (char *) NULL && strcmp (only, section->name) != 0)
1373         continue;
1374
1375       if (dump_reloc_info
1376           && (section->flags & SEC_RELOC) != 0)
1377         {
1378           long relsize;
1379
1380           relsize = bfd_get_reloc_upper_bound (abfd, section);
1381           if (relsize < 0)
1382             bfd_fatal (bfd_get_filename (abfd));
1383
1384           if (relsize > 0)
1385             {
1386               long relcount;
1387
1388               relbuf = (arelent **) xmalloc (relsize);
1389               relcount = bfd_canonicalize_reloc (abfd, section, relbuf, syms);
1390               if (relcount < 0)
1391                 bfd_fatal (bfd_get_filename (abfd));
1392
1393               /* Sort the relocs by address.  */
1394               qsort (relbuf, relcount, sizeof (arelent *), compare_relocs);
1395
1396               relpp = relbuf;
1397               relppend = relpp + relcount;
1398             }
1399         }
1400
1401       printf ("Disassembly of section %s:\n", section->name);
1402
1403       datasize = bfd_get_section_size_before_reloc (section);
1404       if (datasize == 0)
1405         continue;
1406
1407       data = (bfd_byte *) xmalloc ((size_t) datasize);
1408
1409       bfd_get_section_contents (abfd, section, data, 0, datasize);
1410
1411       aux.sec = section;
1412       disasm_info.buffer = data;
1413       disasm_info.buffer_vma = section->vma;
1414       disasm_info.buffer_length = datasize;
1415       if (start_address == (bfd_vma) -1
1416           || start_address < disasm_info.buffer_vma)
1417         i = 0;
1418       else
1419         i = start_address - disasm_info.buffer_vma;
1420       if (stop_address == (bfd_vma) -1)
1421         stop = datasize;
1422       else
1423         {
1424           if (stop_address < disasm_info.buffer_vma)
1425             stop = 0;
1426           else
1427             stop = stop_address - disasm_info.buffer_vma;
1428           if (stop > disasm_info.buffer_length)
1429             stop = disasm_info.buffer_length;
1430         }
1431
1432       if (prefix_addresses)
1433         disassemble_bytes (&disasm_info, disassemble_fn, true, data, i, stop,
1434                            &relpp, relppend);
1435       else
1436         {
1437           asymbol *sym;
1438           long place;
1439
1440           sym = find_symbol_for_address (abfd, section, i, true, &place);
1441           ++place;
1442           while (i < stop)
1443             {
1444               asymbol *nextsym;
1445               long nextstop;
1446               boolean insns;
1447
1448               disasm_info.symbol = sym;
1449
1450               printf ("\n");
1451               objdump_print_addr_with_sym (abfd, section, sym,
1452                                            section->vma + i,
1453                                            &disasm_info,
1454                                            false);
1455               printf (":\n");
1456
1457               if (sym == NULL)
1458                 nextsym = NULL;
1459               else
1460                 {
1461                   while (place < sorted_symcount
1462                          && (sorted_syms[place]->section != section
1463                              || (bfd_asymbol_value (sorted_syms[place])
1464                                  <= bfd_asymbol_value (sym))))
1465                     ++place;
1466                   if (place >= sorted_symcount)
1467                     nextsym = NULL;
1468                   else
1469                     nextsym = sorted_syms[place];
1470                 }
1471
1472               if (nextsym == NULL)
1473                 nextstop = stop;
1474               else
1475                 {
1476                   nextstop = bfd_asymbol_value (nextsym) - section->vma;
1477                   if (nextstop > stop)
1478                     nextstop = stop;
1479                 }
1480
1481               /* If a symbol is explicitly marked as being an object
1482                  rather than a function, just dump the bytes without
1483                  disassembling them.  */
1484               if (disassemble_all
1485                   || sym == NULL
1486                   || ((sym->flags & BSF_OBJECT) == 0
1487                       && (strstr (bfd_asymbol_name (sym), "gnu_compiled")
1488                           == NULL)
1489                       && (strstr (bfd_asymbol_name (sym), "gcc2_compiled")
1490                           == NULL))
1491                   || (sym->flags & BSF_FUNCTION) != 0)
1492                 insns = true;
1493               else
1494                 insns = false;
1495
1496               disassemble_bytes (&disasm_info, disassemble_fn, insns, data, i,
1497                                  nextstop, &relpp, relppend);
1498
1499               i = nextstop;
1500               sym = nextsym;
1501             }
1502         }
1503
1504       free (data);
1505       if (relbuf != NULL)
1506         free (relbuf);
1507     }
1508   free (sorted_syms);
1509 }
1510 \f
1511
1512 /* Define a table of stab values and print-strings.  We wish the initializer
1513    could be a direct-mapped table, but instead we build one the first
1514    time we need it.  */
1515
1516 static void dump_section_stabs PARAMS ((bfd *abfd, char *stabsect_name,
1517                                         char *strsect_name));
1518
1519 /* Dump the stabs sections from an object file that has a section that
1520    uses Sun stabs encoding.  */
1521
1522 static void
1523 dump_stabs (abfd)
1524      bfd *abfd;
1525 {
1526   dump_section_stabs (abfd, ".stab", ".stabstr");
1527   dump_section_stabs (abfd, ".stab.excl", ".stab.exclstr");
1528   dump_section_stabs (abfd, ".stab.index", ".stab.indexstr");
1529   dump_section_stabs (abfd, "$GDB_SYMBOLS$", "$GDB_STRINGS$");
1530 }
1531
1532 static bfd_byte *stabs;
1533 static bfd_size_type stab_size;
1534
1535 static char *strtab;
1536 static bfd_size_type stabstr_size;
1537
1538 /* Read ABFD's stabs section STABSECT_NAME into `stabs'
1539    and string table section STRSECT_NAME into `strtab'.
1540    If the section exists and was read, allocate the space and return true.
1541    Otherwise return false.  */
1542
1543 static boolean
1544 read_section_stabs (abfd, stabsect_name, strsect_name)
1545      bfd *abfd;
1546      char *stabsect_name;
1547      char *strsect_name;
1548 {
1549   asection *stabsect, *stabstrsect;
1550
1551   stabsect = bfd_get_section_by_name (abfd, stabsect_name);
1552   if (0 == stabsect)
1553     {
1554       printf ("No %s section present\n\n", stabsect_name);
1555       return false;
1556     }
1557
1558   stabstrsect = bfd_get_section_by_name (abfd, strsect_name);
1559   if (0 == stabstrsect)
1560     {
1561       fprintf (stderr, "%s: %s has no %s section\n", program_name,
1562                bfd_get_filename (abfd), strsect_name);
1563       return false;
1564     }
1565
1566   stab_size    = bfd_section_size (abfd, stabsect);
1567   stabstr_size = bfd_section_size (abfd, stabstrsect);
1568
1569   stabs  = (bfd_byte *) xmalloc (stab_size);
1570   strtab = (char *) xmalloc (stabstr_size);
1571
1572   if (! bfd_get_section_contents (abfd, stabsect, (PTR) stabs, 0, stab_size))
1573     {
1574       fprintf (stderr, "%s: Reading %s section of %s failed: %s\n",
1575                program_name, stabsect_name, bfd_get_filename (abfd),
1576                bfd_errmsg (bfd_get_error ()));
1577       free (stabs);
1578       free (strtab);
1579       return false;
1580     }
1581
1582   if (! bfd_get_section_contents (abfd, stabstrsect, (PTR) strtab, 0,
1583                                   stabstr_size))
1584     {
1585       fprintf (stderr, "%s: Reading %s section of %s failed: %s\n",
1586                program_name, strsect_name, bfd_get_filename (abfd),
1587                bfd_errmsg (bfd_get_error ()));
1588       free (stabs);
1589       free (strtab);
1590       return false;
1591     }
1592
1593   return true;
1594 }
1595
1596 /* Stabs entries use a 12 byte format:
1597      4 byte string table index
1598      1 byte stab type
1599      1 byte stab other field
1600      2 byte stab desc field
1601      4 byte stab value
1602    FIXME: This will have to change for a 64 bit object format.  */
1603
1604 #define STRDXOFF (0)
1605 #define TYPEOFF (4)
1606 #define OTHEROFF (5)
1607 #define DESCOFF (6)
1608 #define VALOFF (8)
1609 #define STABSIZE (12)
1610
1611 /* Print ABFD's stabs section STABSECT_NAME (in `stabs'),
1612    using string table section STRSECT_NAME (in `strtab').  */
1613
1614 static void
1615 print_section_stabs (abfd, stabsect_name, strsect_name)
1616      bfd *abfd;
1617      char *stabsect_name;
1618      char *strsect_name;
1619 {
1620   int i;
1621   unsigned file_string_table_offset = 0, next_file_string_table_offset = 0;
1622   bfd_byte *stabp, *stabs_end;
1623
1624   stabp = stabs;
1625   stabs_end = stabp + stab_size;
1626
1627   printf ("Contents of %s section:\n\n", stabsect_name);
1628   printf ("Symnum n_type n_othr n_desc n_value  n_strx String\n");
1629
1630   /* Loop through all symbols and print them.
1631
1632      We start the index at -1 because there is a dummy symbol on
1633      the front of stabs-in-{coff,elf} sections that supplies sizes.  */
1634
1635   for (i = -1; stabp < stabs_end; stabp += STABSIZE, i++)
1636     {
1637       const char *name;
1638       unsigned long strx;
1639       unsigned char type, other;
1640       unsigned short desc;
1641       bfd_vma value;
1642
1643       strx = bfd_h_get_32 (abfd, stabp + STRDXOFF);
1644       type = bfd_h_get_8 (abfd, stabp + TYPEOFF);
1645       other = bfd_h_get_8 (abfd, stabp + OTHEROFF);
1646       desc = bfd_h_get_16 (abfd, stabp + DESCOFF);
1647       value = bfd_h_get_32 (abfd, stabp + VALOFF);
1648
1649       printf ("\n%-6d ", i);
1650       /* Either print the stab name, or, if unnamed, print its number
1651          again (makes consistent formatting for tools like awk). */
1652       name = bfd_get_stab_name (type);
1653       if (name != NULL)
1654         printf ("%-6s", name);
1655       else if (type == N_UNDF)
1656         printf ("HdrSym");
1657       else
1658         printf ("%-6d", type);
1659       printf (" %-6d %-6d ", other, desc);
1660       printf_vma (value);
1661       printf (" %-6lu", strx);
1662
1663       /* Symbols with type == 0 (N_UNDF) specify the length of the
1664          string table associated with this file.  We use that info
1665          to know how to relocate the *next* file's string table indices.  */
1666
1667       if (type == N_UNDF)
1668         {
1669           file_string_table_offset = next_file_string_table_offset;
1670           next_file_string_table_offset += value;
1671         }
1672       else
1673         {
1674           /* Using the (possibly updated) string table offset, print the
1675              string (if any) associated with this symbol.  */
1676
1677           if ((strx + file_string_table_offset) < stabstr_size)
1678             printf (" %s", &strtab[strx + file_string_table_offset]);
1679           else
1680             printf (" *");
1681         }
1682     }
1683   printf ("\n\n");
1684 }
1685
1686 static void
1687 dump_section_stabs (abfd, stabsect_name, strsect_name)
1688      bfd *abfd;
1689      char *stabsect_name;
1690      char *strsect_name;
1691 {
1692   asection *s;
1693
1694   /* Check for section names for which stabsect_name is a prefix, to
1695      handle .stab0, etc.  */
1696   for (s = abfd->sections;
1697        s != NULL;
1698        s = s->next)
1699     {
1700       int len;
1701
1702       len = strlen (stabsect_name);
1703
1704 /* If the prefix matches, and the files section name ends with a nul or a digit,
1705    then we match.  Ie: we want either an exact match or a a section followed by
1706    a number.  */
1707       if (strncmp (stabsect_name, s->name, len) == 0
1708           && (s->name[len] == '\000' || isdigit (s->name[len])))
1709         {
1710           if (read_section_stabs (abfd, s->name, strsect_name))
1711             {
1712               print_section_stabs (abfd, s->name, strsect_name);
1713               free (stabs);
1714               free (strtab);
1715             }
1716         }
1717     }
1718 }
1719 \f
1720 static void
1721 dump_bfd_header (abfd)
1722      bfd *abfd;
1723 {
1724   char *comma = "";
1725
1726   printf ("architecture: %s, ",
1727           bfd_printable_arch_mach (bfd_get_arch (abfd),
1728                                    bfd_get_mach (abfd)));
1729   printf ("flags 0x%08x:\n", abfd->flags);
1730
1731 #define PF(x, y)    if (abfd->flags & x) {printf("%s%s", comma, y); comma=", ";}
1732   PF (HAS_RELOC, "HAS_RELOC");
1733   PF (EXEC_P, "EXEC_P");
1734   PF (HAS_LINENO, "HAS_LINENO");
1735   PF (HAS_DEBUG, "HAS_DEBUG");
1736   PF (HAS_SYMS, "HAS_SYMS");
1737   PF (HAS_LOCALS, "HAS_LOCALS");
1738   PF (DYNAMIC, "DYNAMIC");
1739   PF (WP_TEXT, "WP_TEXT");
1740   PF (D_PAGED, "D_PAGED");
1741   PF (BFD_IS_RELAXABLE, "BFD_IS_RELAXABLE");
1742   printf ("\nstart address 0x");
1743   printf_vma (abfd->start_address);
1744   printf ("\n");
1745 }
1746 \f
1747 static void
1748 dump_bfd_private_header (abfd)
1749 bfd *abfd;
1750 {
1751   bfd_print_private_bfd_data (abfd, stdout);
1752 }
1753
1754 static void
1755 display_bfd (abfd)
1756      bfd *abfd;
1757 {
1758   char **matching;
1759
1760   if (!bfd_check_format_matches (abfd, bfd_object, &matching))
1761     {
1762       bfd_nonfatal (bfd_get_filename (abfd));
1763       if (bfd_get_error () == bfd_error_file_ambiguously_recognized)
1764         {
1765           list_matching_formats (matching);
1766           free (matching);
1767         }
1768       return;
1769     }
1770
1771   printf ("\n%s:     file format %s\n", bfd_get_filename (abfd),
1772           abfd->xvec->name);
1773   if (dump_ar_hdrs)
1774     print_arelt_descr (stdout, abfd, true);
1775   if (dump_file_header)
1776     dump_bfd_header (abfd);
1777   if (dump_private_headers)
1778     dump_bfd_private_header (abfd);
1779   putchar ('\n');
1780   if (dump_section_headers)
1781     dump_headers (abfd);
1782   if (dump_symtab || dump_reloc_info || disassemble || dump_debugging)
1783     {
1784       syms = slurp_symtab (abfd);
1785     }
1786   if (dump_dynamic_symtab || dump_dynamic_reloc_info)
1787     {
1788       dynsyms = slurp_dynamic_symtab (abfd);
1789     }
1790   if (dump_symtab)
1791     dump_symbols (abfd, false);
1792   if (dump_dynamic_symtab)
1793     dump_symbols (abfd, true);
1794   if (dump_stab_section_info)
1795     dump_stabs (abfd);
1796   if (dump_reloc_info && ! disassemble)
1797     dump_relocs (abfd);
1798   if (dump_dynamic_reloc_info)
1799     dump_dynamic_relocs (abfd);
1800   if (dump_section_contents)
1801     dump_data (abfd);
1802   if (disassemble)
1803     disassemble_data (abfd);
1804   if (dump_debugging)
1805     {
1806       PTR dhandle;
1807
1808       dhandle = read_debugging_info (abfd, syms, symcount);
1809       if (dhandle != NULL)
1810         {
1811           if (! print_debugging_info (stdout, dhandle))
1812             fprintf (stderr, "%s: printing debugging information failed\n",
1813                      bfd_get_filename (abfd));
1814         }
1815     }
1816   if (syms)
1817     {
1818       free (syms);
1819       syms = NULL;
1820     }
1821   if (dynsyms)
1822     {
1823       free (dynsyms);
1824       dynsyms = NULL;
1825     }
1826 }
1827
1828 static void
1829 display_file (filename, target)
1830      char *filename;
1831      char *target;
1832 {
1833   bfd *file, *arfile = (bfd *) NULL;
1834
1835   file = bfd_openr (filename, target);
1836   if (file == NULL)
1837     {
1838       bfd_nonfatal (filename);
1839       return;
1840     }
1841
1842   if (bfd_check_format (file, bfd_archive) == true)
1843     {
1844       bfd *last_arfile = NULL;
1845
1846       printf ("In archive %s:\n", bfd_get_filename (file));
1847       for (;;)
1848         {
1849           bfd_set_error (bfd_error_no_error);
1850
1851           arfile = bfd_openr_next_archived_file (file, arfile);
1852           if (arfile == NULL)
1853             {
1854               if (bfd_get_error () != bfd_error_no_more_archived_files)
1855                 {
1856                   bfd_nonfatal (bfd_get_filename (file));
1857                 }
1858               break;
1859             }
1860
1861           display_bfd (arfile);
1862
1863           if (last_arfile != NULL)
1864             bfd_close (last_arfile);
1865           last_arfile = arfile;
1866         }
1867
1868       if (last_arfile != NULL)
1869         bfd_close (last_arfile);
1870     }
1871   else
1872     display_bfd (file);
1873
1874   bfd_close (file);
1875 }
1876 \f
1877 /* Actually display the various requested regions */
1878
1879 static void
1880 dump_data (abfd)
1881      bfd *abfd;
1882 {
1883   asection *section;
1884   bfd_byte *data = 0;
1885   bfd_size_type datasize = 0;
1886   bfd_size_type i;
1887   bfd_size_type start, stop;
1888
1889   for (section = abfd->sections; section != NULL; section =
1890        section->next)
1891     {
1892       int onaline = 16;
1893
1894       if (only == (char *) NULL ||
1895           strcmp (only, section->name) == 0)
1896         {
1897           if (section->flags & SEC_HAS_CONTENTS)
1898             {
1899               printf ("Contents of section %s:\n", section->name);
1900
1901               if (bfd_section_size (abfd, section) == 0)
1902                 continue;
1903               data = (bfd_byte *) xmalloc ((size_t) bfd_section_size (abfd, section));
1904               datasize = bfd_section_size (abfd, section);
1905
1906
1907               bfd_get_section_contents (abfd, section, (PTR) data, 0, bfd_section_size (abfd, section));
1908
1909               if (start_address == (bfd_vma) -1
1910                   || start_address < section->vma)
1911                 start = 0;
1912               else
1913                 start = start_address - section->vma;
1914               if (stop_address == (bfd_vma) -1)
1915                 stop = bfd_section_size (abfd, section);
1916               else
1917                 {
1918                   if (stop_address < section->vma)
1919                     stop = 0;
1920                   else
1921                     stop = stop_address - section->vma;
1922                   if (stop > bfd_section_size (abfd, section))
1923                     stop = bfd_section_size (abfd, section);
1924                 }
1925               for (i = start; i < stop; i += onaline)
1926                 {
1927                   bfd_size_type j;
1928
1929                   printf (" %04lx ", (unsigned long int) (i + section->vma));
1930                   for (j = i; j < i + onaline; j++)
1931                     {
1932                       if (j < stop)
1933                         printf ("%02x", (unsigned) (data[j]));
1934                       else
1935                         printf ("  ");
1936                       if ((j & 3) == 3)
1937                         printf (" ");
1938                     }
1939
1940                   printf (" ");
1941                   for (j = i; j < i + onaline; j++)
1942                     {
1943                       if (j >= stop)
1944                         printf (" ");
1945                       else
1946                         printf ("%c", isprint (data[j]) ? data[j] : '.');
1947                     }
1948                   putchar ('\n');
1949                 }
1950               free (data);
1951             }
1952         }
1953     }
1954 }
1955
1956 /* Should perhaps share code and display with nm? */
1957 static void
1958 dump_symbols (abfd, dynamic)
1959      bfd *abfd;
1960      boolean dynamic;
1961 {
1962   asymbol **current;
1963   long max;
1964   long count;
1965
1966   if (dynamic)
1967     {
1968       current = dynsyms;
1969       max = dynsymcount;
1970       if (max == 0)
1971         return;
1972       printf ("DYNAMIC SYMBOL TABLE:\n");
1973     }
1974   else
1975     {
1976       current = syms;
1977       max = symcount;
1978       if (max == 0)
1979         return;
1980       printf ("SYMBOL TABLE:\n");
1981     }
1982
1983   for (count = 0; count < max; count++)
1984     {
1985       if (*current)
1986         {
1987           bfd *cur_bfd = bfd_asymbol_bfd(*current);
1988           if (cur_bfd)
1989             {
1990               bfd_print_symbol (cur_bfd,
1991                                 stdout,
1992                                 *current, bfd_print_symbol_all);
1993               printf ("\n");
1994             }
1995         }
1996       current++;
1997     }
1998   printf ("\n");
1999   printf ("\n");
2000 }
2001
2002 static void
2003 dump_relocs (abfd)
2004      bfd *abfd;
2005 {
2006   arelent **relpp;
2007   long relcount;
2008   asection *a;
2009
2010   for (a = abfd->sections; a != (asection *) NULL; a = a->next)
2011     {
2012       long relsize;
2013
2014       if (bfd_is_abs_section (a))
2015         continue;
2016       if (bfd_is_und_section (a))
2017         continue;
2018       if (bfd_is_com_section (a))
2019         continue;
2020
2021       if (only)
2022         {
2023           if (strcmp (only, a->name))
2024             continue;
2025         }
2026       else if ((a->flags & SEC_RELOC) == 0)
2027         continue;
2028
2029       relsize = bfd_get_reloc_upper_bound (abfd, a);
2030       if (relsize < 0)
2031         bfd_fatal (bfd_get_filename (abfd));
2032
2033       printf ("RELOCATION RECORDS FOR [%s]:", a->name);
2034
2035       if (relsize == 0)
2036         {
2037           printf (" (none)\n\n");
2038         }
2039       else
2040         {
2041           relpp = (arelent **) xmalloc (relsize);
2042           relcount = bfd_canonicalize_reloc (abfd, a, relpp, syms);
2043           if (relcount < 0)
2044             bfd_fatal (bfd_get_filename (abfd));
2045           else if (relcount == 0)
2046             {
2047               printf (" (none)\n\n");
2048             }
2049           else
2050             {
2051               printf ("\n");
2052               dump_reloc_set (abfd, a, relpp, relcount);
2053               printf ("\n\n");
2054             }
2055           free (relpp);
2056         }
2057     }
2058 }
2059
2060 static void
2061 dump_dynamic_relocs (abfd)
2062      bfd *abfd;
2063 {
2064   long relsize;
2065   arelent **relpp;
2066   long relcount;
2067
2068   relsize = bfd_get_dynamic_reloc_upper_bound (abfd);
2069   if (relsize < 0)
2070     bfd_fatal (bfd_get_filename (abfd));
2071
2072   printf ("DYNAMIC RELOCATION RECORDS");
2073
2074   if (relsize == 0)
2075     {
2076       printf (" (none)\n\n");
2077     }
2078   else
2079     {
2080       relpp = (arelent **) xmalloc (relsize);
2081       relcount = bfd_canonicalize_dynamic_reloc (abfd, relpp, dynsyms);
2082       if (relcount < 0)
2083         bfd_fatal (bfd_get_filename (abfd));
2084       else if (relcount == 0)
2085         {
2086           printf (" (none)\n\n");
2087         }
2088       else
2089         {
2090           printf ("\n");
2091           dump_reloc_set (abfd, (asection *) NULL, relpp, relcount);
2092           printf ("\n\n");
2093         }
2094       free (relpp);
2095     }
2096 }
2097
2098 static void
2099 dump_reloc_set (abfd, sec, relpp, relcount)
2100      bfd *abfd;
2101      asection *sec;
2102      arelent **relpp;
2103      long relcount;
2104 {
2105   arelent **p;
2106   char *last_filename, *last_functionname;
2107   unsigned int last_line;
2108
2109   /* Get column headers lined up reasonably.  */
2110   {
2111     static int width;
2112     if (width == 0)
2113       {
2114         char buf[30];
2115         sprintf_vma (buf, (bfd_vma) -1);
2116         width = strlen (buf) - 7;
2117       }
2118     printf ("OFFSET %*s TYPE %*s VALUE \n", width, "", 12, "");
2119   }
2120
2121   last_filename = NULL;
2122   last_functionname = NULL;
2123   last_line = 0;
2124
2125   for (p = relpp; relcount && *p != (arelent *) NULL; p++, relcount--)
2126     {
2127       arelent *q = *p;
2128       const char *filename, *functionname;
2129       unsigned int line;
2130       const char *sym_name;
2131       const char *section_name;
2132
2133       if (start_address != (bfd_vma) -1
2134           && q->address < start_address)
2135         continue;
2136       if (stop_address != (bfd_vma) -1
2137           && q->address > stop_address)
2138         continue;
2139
2140       if (with_line_numbers
2141           && sec != NULL
2142           && bfd_find_nearest_line (abfd, sec, syms, q->address,
2143                                     &filename, &functionname, &line))
2144         {
2145           if (functionname != NULL
2146               && (last_functionname == NULL
2147                   || strcmp (functionname, last_functionname) != 0))
2148             {
2149               printf ("%s():\n", functionname);
2150               if (last_functionname != NULL)
2151                 free (last_functionname);
2152               last_functionname = xstrdup (functionname);
2153             }
2154           if (line > 0
2155               && (line != last_line
2156                   || (filename != NULL
2157                       && last_filename != NULL
2158                       && strcmp (filename, last_filename) != 0)))
2159             {
2160               printf ("%s:%u\n", filename == NULL ? "???" : filename, line);
2161               last_line = line;
2162               if (last_filename != NULL)
2163                 free (last_filename);
2164               if (filename == NULL)
2165                 last_filename = NULL;
2166               else
2167                 last_filename = xstrdup (filename);
2168             }
2169         }
2170
2171       if (q->sym_ptr_ptr && *q->sym_ptr_ptr)
2172         {
2173           sym_name = (*(q->sym_ptr_ptr))->name;
2174           section_name = (*(q->sym_ptr_ptr))->section->name;
2175         }
2176       else
2177         {
2178           sym_name = NULL;
2179           section_name = NULL;
2180         }
2181       if (sym_name)
2182         {
2183           printf_vma (q->address);
2184           printf (" %-16s  %s",
2185                   q->howto->name,
2186                   sym_name);
2187         }
2188       else
2189         {
2190           if (section_name == (CONST char *) NULL)
2191             section_name = "*unknown*";
2192           printf_vma (q->address);
2193           printf (" %-16s  [%s]",
2194                   q->howto->name,
2195                   section_name);
2196         }
2197       if (q->addend)
2198         {
2199           printf ("+0x");
2200           printf_vma (q->addend);
2201         }
2202       printf ("\n");
2203     }
2204 }
2205 \f
2206 /* The length of the longest architecture name + 1.  */
2207 #define LONGEST_ARCH sizeof("rs6000:6000")
2208
2209 static const char *
2210 endian_string (endian)
2211      enum bfd_endian endian;
2212 {
2213   if (endian == BFD_ENDIAN_BIG)
2214     return "big endian";
2215   else if (endian == BFD_ENDIAN_LITTLE)
2216     return "little endian";
2217   else
2218     return "endianness unknown";
2219 }
2220
2221 /* List the targets that BFD is configured to support, each followed
2222    by its endianness and the architectures it supports.  */
2223
2224 static void
2225 display_target_list ()
2226 {
2227   extern bfd_target *bfd_target_vector[];
2228   char *dummy_name;
2229   int t;
2230
2231   dummy_name = choose_temp_base ();
2232   for (t = 0; bfd_target_vector[t]; t++)
2233     {
2234       bfd_target *p = bfd_target_vector[t];
2235       bfd *abfd = bfd_openw (dummy_name, p->name);
2236       int a;
2237
2238       printf ("%s\n (header %s, data %s)\n", p->name,
2239               endian_string (p->header_byteorder),
2240               endian_string (p->byteorder));
2241
2242       if (abfd == NULL)
2243         {
2244           bfd_nonfatal (dummy_name);
2245           continue;
2246         }
2247
2248       if (! bfd_set_format (abfd, bfd_object))
2249         {
2250           if (bfd_get_error () != bfd_error_invalid_operation)
2251             bfd_nonfatal (p->name);
2252           continue;
2253         }
2254
2255       for (a = (int) bfd_arch_obscure + 1; a < (int) bfd_arch_last; a++)
2256         if (bfd_set_arch_mach (abfd, (enum bfd_architecture) a, 0))
2257           printf ("  %s\n",
2258                   bfd_printable_arch_mach ((enum bfd_architecture) a, 0));
2259     }
2260   unlink (dummy_name);
2261   free (dummy_name);
2262 }
2263
2264 /* Print a table showing which architectures are supported for entries
2265    FIRST through LAST-1 of bfd_target_vector (targets across,
2266    architectures down).  */
2267
2268 static void
2269 display_info_table (first, last)
2270      int first;
2271      int last;
2272 {
2273   extern bfd_target *bfd_target_vector[];
2274   int t, a;
2275   char *dummy_name;
2276
2277   /* Print heading of target names.  */
2278   printf ("\n%*s", (int) LONGEST_ARCH, " ");
2279   for (t = first; t < last && bfd_target_vector[t]; t++)
2280     printf ("%s ", bfd_target_vector[t]->name);
2281   putchar ('\n');
2282
2283   dummy_name = choose_temp_base ();
2284   for (a = (int) bfd_arch_obscure + 1; a < (int) bfd_arch_last; a++)
2285     if (strcmp (bfd_printable_arch_mach (a, 0), "UNKNOWN!") != 0)
2286       {
2287         printf ("%*s ", (int) LONGEST_ARCH - 1,
2288                 bfd_printable_arch_mach (a, 0));
2289         for (t = first; t < last && bfd_target_vector[t]; t++)
2290           {
2291             bfd_target *p = bfd_target_vector[t];
2292             boolean ok = true;
2293             bfd *abfd = bfd_openw (dummy_name, p->name);
2294
2295             if (abfd == NULL)
2296               {
2297                 bfd_nonfatal (p->name);
2298                 ok = false;
2299               }
2300
2301             if (ok)
2302               {
2303                 if (! bfd_set_format (abfd, bfd_object))
2304                   {
2305                     if (bfd_get_error () != bfd_error_invalid_operation)
2306                       bfd_nonfatal (p->name);
2307                     ok = false;
2308                   }
2309               }
2310
2311             if (ok)
2312               {
2313                 if (! bfd_set_arch_mach (abfd, a, 0))
2314                   ok = false;
2315               }
2316
2317             if (ok)
2318               printf ("%s ", p->name);
2319             else
2320               {
2321                 int l = strlen (p->name);
2322                 while (l--)
2323                   putchar ('-');
2324                 putchar (' ');
2325               }
2326           }
2327         putchar ('\n');
2328       }
2329   unlink (dummy_name);
2330   free (dummy_name);
2331 }
2332
2333 /* Print tables of all the target-architecture combinations that
2334    BFD has been configured to support.  */
2335
2336 static void
2337 display_target_tables ()
2338 {
2339   int t, columns;
2340   extern bfd_target *bfd_target_vector[];
2341   char *colum;
2342   extern char *getenv ();
2343
2344   columns = 0;
2345   colum = getenv ("COLUMNS");
2346   if (colum != NULL)
2347     columns = atoi (colum);
2348   if (columns == 0)
2349     columns = 80;
2350
2351   t = 0;
2352   while (bfd_target_vector[t] != NULL)
2353     {
2354       int oldt = t, wid;
2355
2356       wid = LONGEST_ARCH + strlen (bfd_target_vector[t]->name) + 1;
2357       ++t;
2358       while (wid < columns && bfd_target_vector[t] != NULL)
2359         {
2360           int newwid;
2361
2362           newwid = wid + strlen (bfd_target_vector[t]->name) + 1;
2363           if (newwid >= columns)
2364             break;
2365           wid = newwid;
2366           ++t;
2367         }
2368       display_info_table (oldt, t);
2369     }
2370 }
2371
2372 static void
2373 display_info ()
2374 {
2375   printf ("BFD header file version %s\n", BFD_VERSION);
2376   display_target_list ();
2377   display_target_tables ();
2378 }
2379
2380 int
2381 main (argc, argv)
2382      int argc;
2383      char **argv;
2384 {
2385   int c;
2386   char *target = default_target;
2387   boolean seenflag = false;
2388
2389   program_name = *argv;
2390   xmalloc_set_program_name (program_name);
2391
2392   START_PROGRESS (program_name, 0);
2393
2394   bfd_init ();
2395
2396   while ((c = getopt_long (argc, argv, "pib:m:VdDlfahrRtTxsSj:wE:",
2397                            long_options, (int *) 0))
2398          != EOF)
2399     {
2400       if (c != 'l' && c != OPTION_START_ADDRESS && c != OPTION_STOP_ADDRESS)
2401         seenflag = true;
2402       switch (c)
2403         {
2404         case 0:
2405           break;                /* we've been given a long option */
2406         case 'm':
2407           machine = optarg;
2408           break;
2409         case 'j':
2410           only = optarg;
2411           break;
2412         case 'l':
2413           with_line_numbers = 1;
2414           break;
2415         case 'b':
2416           target = optarg;
2417           break;
2418         case 'f':
2419           dump_file_header = true;
2420           break;
2421         case 'i':
2422           formats_info = true;
2423           break;
2424         case 'p':
2425           dump_private_headers = 1;
2426           break;
2427         case 'x':
2428           dump_private_headers = 1;
2429           dump_symtab = 1;
2430           dump_reloc_info = 1;
2431           dump_file_header = true;
2432           dump_ar_hdrs = 1;
2433           dump_section_headers = 1;
2434           break;
2435         case 't':
2436           dump_symtab = 1;
2437           break;
2438         case 'T':
2439           dump_dynamic_symtab = 1;
2440           break;
2441         case 'd':
2442           disassemble = true;
2443           break;
2444         case 'D':
2445           disassemble = disassemble_all = true;
2446           break;
2447         case 'S':
2448           disassemble = true;
2449           with_source_code = true;
2450           break;
2451         case 's':
2452           dump_section_contents = 1;
2453           break;
2454         case 'r':
2455           dump_reloc_info = 1;
2456           break;
2457         case 'R':
2458           dump_dynamic_reloc_info = 1;
2459           break;
2460         case 'a':
2461           dump_ar_hdrs = 1;
2462           break;
2463         case 'h':
2464           dump_section_headers = 1;
2465           break;
2466         case 'H':
2467           usage (stdout, 0);
2468         case 'V':
2469           show_version = 1;
2470           break;
2471         case 'w':
2472           wide_output = 1;
2473           break;
2474         case OPTION_START_ADDRESS:
2475           start_address = parse_vma (optarg, "--start-address");
2476           break;
2477         case OPTION_STOP_ADDRESS:
2478           stop_address = parse_vma (optarg, "--stop-address");
2479           break;
2480         case 'E':
2481           if (strcmp (optarg, "B") == 0)
2482             endian = BFD_ENDIAN_BIG;
2483           else if (strcmp (optarg, "L") == 0)
2484             endian = BFD_ENDIAN_LITTLE;
2485           else
2486             {
2487               fprintf (stderr, "%s: unrecognized -E option\n", program_name);
2488               usage (stderr, 1);
2489             }
2490           break;
2491         case OPTION_ENDIAN:
2492           if (strncmp (optarg, "big", strlen (optarg)) == 0)
2493             endian = BFD_ENDIAN_BIG;
2494           else if (strncmp (optarg, "little", strlen (optarg)) == 0)
2495             endian = BFD_ENDIAN_LITTLE;
2496           else
2497             {
2498               fprintf (stderr, "%s: unrecognized --endian type `%s'\n",
2499                       program_name, optarg);
2500               usage (stderr, 1);
2501             }
2502           break;
2503         default:
2504           usage (stderr, 1);
2505         }
2506     }
2507
2508   if (show_version)
2509     print_version ("objdump");
2510
2511   if (seenflag == false)
2512     usage (stderr, 1);
2513
2514   if (formats_info)
2515     {
2516       display_info ();
2517     }
2518   else
2519     {
2520       if (optind == argc)
2521         display_file ("a.out", target);
2522       else
2523         for (; optind < argc;)
2524           display_file (argv[optind++], target);
2525     }
2526
2527   END_PROGRESS (program_name);
2528
2529   return 0;
2530 }