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