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