binutils/objdump.c

   1 /* objdump.c -- dump information about an object file.
   2    Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996 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 /* Internal headers for the ELF .stab-dump code - sorry.  */
  31 #define BYTES_IN_WORD   32
  32 #include "aout/aout64.h"
  33
  34 #ifdef NEED_DECLARATION_FPRINTF
  35 /* This is needed by INIT_DISASSEMBLE_INFO.  */
  36 extern int fprintf ();
  37 #endif
  38
  39 char *default_target = NULL;    /* default at runtime */
  40
  41 extern char *program_version;
  42
  43 int show_version = 0;           /* show the version number */
  44 int dump_section_contents;      /* -s */
  45 int dump_section_headers;       /* -h */
  46 boolean dump_file_header;       /* -f */
  47 int dump_symtab;                /* -t */
  48 int dump_dynamic_symtab;        /* -T */
  49 int dump_reloc_info;            /* -r */
  50 int dump_dynamic_reloc_info;    /* -R */
  51 int dump_ar_hdrs;               /* -a */
  52 int dump_private_headers;       /* -p */
  53 int with_line_numbers;          /* -l */
  54 boolean with_source_code;       /* -S */
  55 int show_raw_insn;              /* --show-raw-insn */
  56 int dump_stab_section_info;     /* --stabs */
  57 boolean disassemble;            /* -d */
  58 boolean disassemble_all;        /* -D */
  59 boolean formats_info;           /* -i */
  60 char *only;                     /* -j secname */
  61 int wide_output;                /* -w */
  62 bfd_vma start_address = (bfd_vma) -1; /* --start-address */
  63 bfd_vma stop_address = (bfd_vma) -1;  /* --stop-address */
  64 int dump_debugging;             /* --debugging */
  65
  66 /* Extra info to pass to the disassembler address printing function.  */
  67 struct objdump_disasm_info {
  68   bfd *abfd;
  69   asection *sec;
  70   boolean require_sec;
  71 };
  72
  73 /* Architecture to disassemble for, or default if NULL.  */
  74 char *machine = (char *) NULL;
  75
  76 /* The symbol table.  */
  77 asymbol **syms;
  78
  79 /* Number of symbols in `syms'.  */
  80 long symcount = 0;
  81
  82 /* The sorted symbol table.  */
  83 asymbol **sorted_syms;
  84
  85 /* Number of symbols in `sorted_syms'.  */
  86 long sorted_symcount = 0;
  87
  88 /* The dynamic symbol table.  */
  89 asymbol **dynsyms;
  90
  91 /* Number of symbols in `dynsyms'.  */
  92 long dynsymcount = 0;
  93
  94 /* Forward declarations.  */
  95
  96 static void
  97 display_file PARAMS ((char *filename, char *target));
  98
  99 static void
 100 dump_data PARAMS ((bfd *abfd));
 101
 102 static void
 103 dump_relocs PARAMS ((bfd *abfd));
 104
 105 static void
 106 dump_dynamic_relocs PARAMS ((bfd * abfd));
 107
 108 static void
 109 dump_reloc_set PARAMS ((bfd *, arelent **, long));
 110
 111 static void
 112 dump_symbols PARAMS ((bfd *abfd, boolean dynamic));
 113
 114 static void
 115 display_bfd PARAMS ((bfd *abfd));
 116
 117 static void
 118 objdump_print_value PARAMS ((bfd_vma, FILE *));
 119
 120 static void
 121 objdump_print_address PARAMS ((bfd_vma, struct disassemble_info *));
 122
 123 static void
 124 show_line PARAMS ((bfd *, asection *, bfd_vma));
 125
 126 static const char *
 127 endian_string PARAMS ((enum bfd_endian));
 128 \f
 129 void
 130 usage (stream, status)
 131      FILE *stream;
 132      int status;
 133 {
 134   fprintf (stream, "\
 135 Usage: %s [-ahifdDprRtTxsSlw] [-b bfdname] [-m machine] [-j section-name]\n\
 136        [--archive-headers] [--target=bfdname] [--debugging] [--disassemble]\n\
 137        [--disassemble-all] [--file-headers] [--section-headers] [--headers]\n\
 138        [--info] [--section=section-name] [--line-numbers] [--source]\n",
 139            program_name);
 140   fprintf (stream, "\
 141        [--architecture=machine] [--reloc] [--full-contents] [--stabs]\n\
 142        [--syms] [--all-headers] [--dynamic-syms] [--dynamic-reloc]\n\
 143        [--wide] [--version] [--help] [--private-headers]\n\
 144        [--start-address=addr] [--stop-address=addr]\n\
 145        [--show-raw-insn] objfile...\n\
 146 at least one option besides -l (--line-numbers) must be given\n");
 147   list_supported_targets (program_name, stream);
 148   exit (status);
 149 }
 150
 151 /* 150 isn't special; it's just an arbitrary non-ASCII char value.  */
 152
 153 #define OPTION_START_ADDRESS (150)
 154 #define OPTION_STOP_ADDRESS (OPTION_START_ADDRESS + 1)
 155
 156 static struct option long_options[]=
 157 {
 158   {"all-headers", no_argument, NULL, 'x'},
 159   {"private-headers", no_argument, NULL, 'p'},
 160   {"architecture", required_argument, NULL, 'm'},
 161   {"archive-headers", no_argument, NULL, 'a'},
 162   {"debugging", no_argument, &dump_debugging, 1},
 163   {"disassemble", no_argument, NULL, 'd'},
 164   {"disassemble-all", no_argument, NULL, 'D'},
 165   {"dynamic-reloc", no_argument, NULL, 'R'},
 166   {"dynamic-syms", no_argument, NULL, 'T'},
 167   {"file-headers", no_argument, NULL, 'f'},
 168   {"full-contents", no_argument, NULL, 's'},
 169   {"headers", no_argument, NULL, 'h'},
 170   {"help", no_argument, NULL, 'H'},
 171   {"info", no_argument, NULL, 'i'},
 172   {"line-numbers", no_argument, NULL, 'l'},
 173   {"reloc", no_argument, NULL, 'r'},
 174   {"section", required_argument, NULL, 'j'},
 175   {"section-headers", no_argument, NULL, 'h'},
 176   {"show-raw-insn", no_argument, &show_raw_insn, 1},
 177   {"source", no_argument, NULL, 'S'},
 178   {"stabs", no_argument, &dump_stab_section_info, 1},
 179   {"start-address", required_argument, NULL, OPTION_START_ADDRESS},
 180   {"stop-address", required_argument, NULL, OPTION_STOP_ADDRESS},
 181   {"syms", no_argument, NULL, 't'},
 182   {"target", required_argument, NULL, 'b'},
 183   {"version", no_argument, &show_version, 1},
 184   {"wide", no_argument, &wide_output, 'w'},
 185   {0, no_argument, 0, 0}
 186 };
 187 \f
 188 static void
 189 dump_section_header (abfd, section, ignored)
 190      bfd *abfd;
 191      asection *section;
 192      PTR ignored;
 193 {
 194   char *comma = "";
 195
 196 #define PF(x,y) \
 197   if (section->flags & x) {  printf("%s%s",comma,y); comma = ", "; }
 198
 199
 200   printf ("SECTION %d [%s]\t: size %08x",
 201           section->index,
 202           section->name,
 203           (unsigned) bfd_get_section_size_before_reloc (section));
 204   printf (" vma ");
 205   printf_vma (section->vma);
 206   printf (" lma ");
 207   printf_vma (section->lma);
 208   printf (" align 2**%u%s ",
 209           section->alignment_power, (wide_output) ? "" : "\n");
 210   PF (SEC_ALLOC, "ALLOC");
 211   PF (SEC_CONSTRUCTOR, "CONSTRUCTOR");
 212   PF (SEC_CONSTRUCTOR_TEXT, "CONSTRUCTOR TEXT");
 213   PF (SEC_CONSTRUCTOR_DATA, "CONSTRUCTOR DATA");
 214   PF (SEC_CONSTRUCTOR_BSS, "CONSTRUCTOR BSS");
 215   PF (SEC_LOAD, "LOAD");
 216   PF (SEC_RELOC, "RELOC");
 217 #ifdef SEC_BALIGN
 218   PF (SEC_BALIGN, "BALIGN");
 219 #endif
 220   PF (SEC_READONLY, "READONLY");
 221   PF (SEC_CODE, "CODE");
 222   PF (SEC_DATA, "DATA");
 223   PF (SEC_ROM, "ROM");
 224   PF (SEC_DEBUGGING, "DEBUGGING");
 225   PF (SEC_NEVER_LOAD, "NEVER_LOAD");
 226   PF (SEC_EXCLUDE, "EXCLUDE");
 227   PF (SEC_SORT_ENTRIES, "SORT ENTRIES");
 228   printf ("\n");
 229 #undef PF
 230 }
 231
 232 static void
 233 dump_headers (abfd)
 234      bfd *abfd;
 235 {
 236   bfd_map_over_sections (abfd, dump_section_header, (PTR) NULL);
 237 }
 238 \f
 239 static asymbol **
 240 slurp_symtab (abfd)
 241      bfd *abfd;
 242 {
 243   asymbol **sy = (asymbol **) NULL;
 244   long storage;
 245
 246   if (!(bfd_get_file_flags (abfd) & HAS_SYMS))
 247     {
 248       printf ("No symbols in \"%s\".\n", bfd_get_filename (abfd));
 249       symcount = 0;
 250       return NULL;
 251     }
 252
 253   storage = bfd_get_symtab_upper_bound (abfd);
 254   if (storage < 0)
 255     bfd_fatal (bfd_get_filename (abfd));
 256
 257   if (storage)
 258     {
 259       sy = (asymbol **) xmalloc (storage);
 260     }
 261   symcount = bfd_canonicalize_symtab (abfd, sy);
 262   if (symcount < 0)
 263     bfd_fatal (bfd_get_filename (abfd));
 264   if (symcount == 0)
 265     fprintf (stderr, "%s: %s: No symbols\n",
 266              program_name, bfd_get_filename (abfd));
 267   return sy;
 268 }
 269
 270 /* Read in the dynamic symbols.  */
 271
 272 static asymbol **
 273 slurp_dynamic_symtab (abfd)
 274      bfd *abfd;
 275 {
 276   asymbol **sy = (asymbol **) NULL;
 277   long storage;
 278
 279   storage = bfd_get_dynamic_symtab_upper_bound (abfd);
 280   if (storage < 0)
 281     {
 282       if (!(bfd_get_file_flags (abfd) & DYNAMIC))
 283         {
 284           fprintf (stderr, "%s: %s: not a dynamic object\n",
 285                    program_name, bfd_get_filename (abfd));
 286           dynsymcount = 0;
 287           return NULL;
 288         }
 289
 290       bfd_fatal (bfd_get_filename (abfd));
 291     }
 292
 293   if (storage)
 294     {
 295       sy = (asymbol **) xmalloc (storage);
 296     }
 297   dynsymcount = bfd_canonicalize_dynamic_symtab (abfd, sy);
 298   if (dynsymcount < 0)
 299     bfd_fatal (bfd_get_filename (abfd));
 300   if (dynsymcount == 0)
 301     fprintf (stderr, "%s: %s: No dynamic symbols\n",
 302              program_name, bfd_get_filename (abfd));
 303   return sy;
 304 }
 305
 306 /* Filter out (in place) symbols that are useless for disassembly.
 307    COUNT is the number of elements in SYMBOLS.
 308    Return the number of useful symbols. */
 309
 310 long
 311 remove_useless_symbols (symbols, count)
 312      asymbol **symbols;
 313      long count;
 314 {
 315   register asymbol **in_ptr = symbols, **out_ptr = symbols;
 316
 317   while (--count >= 0)
 318     {
 319       asymbol *sym = *in_ptr++;
 320
 321       if (sym->name == NULL || sym->name[0] == '\0')
 322         continue;
 323       if (sym->flags & (BSF_DEBUGGING))
 324         continue;
 325       if (bfd_is_und_section (sym->section)
 326           || bfd_is_com_section (sym->section))
 327         continue;
 328
 329       *out_ptr++ = sym;
 330     }
 331   return out_ptr - symbols;
 332 }
 333
 334 /* Sort symbols into value order.  */
 335
 336 static int
 337 compare_symbols (ap, bp)
 338      const PTR ap;
 339      const PTR bp;
 340 {
 341   const asymbol *a = *(const asymbol **)ap;
 342   const asymbol *b = *(const asymbol **)bp;
 343   const char *an, *bn;
 344   size_t anl, bnl;
 345   boolean af, bf;
 346   flagword aflags, bflags;
 347
 348   if (bfd_asymbol_value (a) > bfd_asymbol_value (b))
 349     return 1;
 350   else if (bfd_asymbol_value (a) < bfd_asymbol_value (b))
 351     return -1;
 352
 353   if (a->section > b->section)
 354     return 1;
 355   else if (a->section < b->section)
 356     return -1;
 357
 358   an = bfd_asymbol_name (a);
 359   bn = bfd_asymbol_name (b);
 360   anl = strlen (an);
 361   bnl = strlen (bn);
 362
 363   /* The symbols gnu_compiled and gcc2_compiled convey no real
 364      information, so put them after other symbols with the same value.  */
 365
 366   af = (strstr (an, "gnu_compiled") != NULL
 367         || strstr (an, "gcc2_compiled") != NULL);
 368   bf = (strstr (bn, "gnu_compiled") != NULL
 369         || strstr (bn, "gcc2_compiled") != NULL);
 370
 371   if (af && ! bf)
 372     return 1;
 373   if (! af && bf)
 374     return -1;
 375
 376   /* We use a heuristic for the file name, to try to sort it after
 377      more useful symbols.  It may not work on non Unix systems, but it
 378      doesn't really matter; the only difference is precisely which
 379      symbol names get printed.  */
 380
 381 #define file_symbol(s, sn, snl)                 \
 382   (((s)->flags & BSF_FILE) != 0                 \
 383    || ((sn)[(snl) - 2] == '.'                   \
 384        && ((sn)[(snl) - 1] == 'o'               \
 385            || (sn)[(snl) - 1] == 'a')))
 386
 387   af = file_symbol (a, an, anl);
 388   bf = file_symbol (b, bn, bnl);
 389
 390   if (af && ! bf)
 391     return 1;
 392   if (! af && bf)
 393     return -1;
 394
 395   /* Finally, try to sort global symbols before local symbols before
 396      debugging symbols.  */
 397
 398   aflags = a->flags;
 399   bflags = b->flags;
 400
 401   if ((aflags & BSF_DEBUGGING) != (bflags & BSF_DEBUGGING))
 402     {
 403       if ((aflags & BSF_DEBUGGING) != 0)
 404         return 1;
 405       else
 406         return -1;
 407     }
 408   if ((aflags & BSF_LOCAL) != (bflags & BSF_LOCAL))
 409     {
 410       if ((aflags & BSF_LOCAL) != 0)
 411         return 1;
 412       else
 413         return -1;
 414     }
 415
 416   return 0;
 417 }
 418
 419 /* Sort relocs into address order.  */
 420
 421 static int
 422 compare_relocs (ap, bp)
 423      const PTR ap;
 424      const PTR bp;
 425 {
 426   const arelent *a = *(const arelent **)ap;
 427   const arelent *b = *(const arelent **)bp;
 428
 429   if (a->address > b->address)
 430     return 1;
 431   else if (a->address < b->address)
 432     return -1;
 433
 434   /* So that associated relocations tied to the same address show up
 435      in the correct order, we don't do any further sorting.  */
 436   if (a > b)
 437     return 1;
 438   else if (a < b)
 439     return -1;
 440   else
 441     return 0;
 442 }
 443
 444 /* Print VMA to STREAM with no leading zeroes.  */
 445
 446 static void
 447 objdump_print_value (vma, stream)
 448      bfd_vma vma;
 449      FILE *stream;
 450 {
 451   char buf[30];
 452   char *p;
 453
 454   sprintf_vma (buf, vma);
 455   for (p = buf; *p == '0'; ++p)
 456     ;
 457   fprintf (stream, "%s", p);
 458 }
 459
 460 /* Print VMA symbolically to INFO if possible.  */
 461
 462 static void
 463 objdump_print_address (vma, info)
 464      bfd_vma vma;
 465      struct disassemble_info *info;
 466 {
 467   /* @@ Would it speed things up to cache the last two symbols returned,
 468      and maybe their address ranges?  For many processors, only one memory
 469      operand can be present at a time, so the 2-entry cache wouldn't be
 470      constantly churned by code doing heavy memory accesses.  */
 471
 472   /* Indices in `sorted_syms'.  */
 473   long min = 0;
 474   long max = sorted_symcount;
 475   long thisplace;
 476
 477   fprintf_vma (info->stream, vma);
 478
 479   if (sorted_symcount < 1)
 480     return;
 481
 482   /* Perform a binary search looking for the closest symbol to the
 483      required value.  We are searching the range (min, max].  */
 484   while (min + 1 < max)
 485     {
 486       asymbol *sym;
 487
 488       thisplace = (max + min) / 2;
 489       sym = sorted_syms[thisplace];
 490
 491       if (bfd_asymbol_value (sym) > vma)
 492         max = thisplace;
 493       else if (bfd_asymbol_value (sym) < vma)
 494         min = thisplace;
 495       else
 496         {
 497           min = thisplace;
 498           break;
 499         }
 500     }
 501
 502   /* The symbol we want is now in min, the low end of the range we
 503      were searching.  If there are several symbols with the same
 504      value, we want the first one.  */
 505   thisplace = min;
 506   while (thisplace > 0
 507          && (bfd_asymbol_value (sorted_syms[thisplace])
 508              == bfd_asymbol_value (sorted_syms[thisplace - 1])))
 509     --thisplace;
 510
 511   {
 512     /* If the file is relocateable, and the symbol could be from this
 513        section, prefer a symbol from this section over symbols from
 514        others, even if the other symbol's value might be closer.
 515
 516        Note that this may be wrong for some symbol references if the
 517        sections have overlapping memory ranges, but in that case there's
 518        no way to tell what's desired without looking at the relocation
 519        table.  */
 520     struct objdump_disasm_info *aux;
 521     long i;
 522
 523     aux = (struct objdump_disasm_info *) info->application_data;
 524     if (sorted_syms[thisplace]->section != aux->sec
 525         && (aux->require_sec
 526             || ((aux->abfd->flags & HAS_RELOC) != 0
 527                 && vma >= bfd_get_section_vma (aux->abfd, aux->sec)
 528                 && vma < (bfd_get_section_vma (aux->abfd, aux->sec)
 529                           + bfd_section_size (aux->abfd, aux->sec)))))
 530       {
 531         for (i = thisplace + 1; i < sorted_symcount; i++)
 532           {
 533             if (bfd_asymbol_value (sorted_syms[i])
 534                 != bfd_asymbol_value (sorted_syms[thisplace]))
 535               break;
 536           }
 537         --i;
 538         for (; i >= 0; i--)
 539           {
 540             if (sorted_syms[i]->section == aux->sec
 541                 && (i == 0
 542                     || sorted_syms[i - 1]->section != aux->sec
 543                     || (bfd_asymbol_value (sorted_syms[i])
 544                         != bfd_asymbol_value (sorted_syms[i - 1]))))
 545               {
 546                 thisplace = i;
 547                 break;
 548               }
 549           }
 550
 551         if (sorted_syms[thisplace]->section != aux->sec)
 552           {
 553             /* We didn't find a good symbol with a smaller value.
 554                Look for one with a larger value.  */
 555             for (i = thisplace + 1; i < sorted_symcount; i++)
 556               {
 557                 if (sorted_syms[i]->section == aux->sec)
 558                   {
 559                     thisplace = i;
 560                     break;
 561                   }
 562               }
 563           }
 564
 565         if (sorted_syms[thisplace]->section != aux->sec
 566             && (aux->require_sec
 567                 || ((aux->abfd->flags & HAS_RELOC) != 0
 568                     && vma >= bfd_get_section_vma (aux->abfd, aux->sec)
 569                     && vma < (bfd_get_section_vma (aux->abfd, aux->sec)
 570                               + bfd_section_size (aux->abfd, aux->sec)))))
 571           {
 572             bfd_vma secaddr;
 573
 574             fprintf (info->stream, " <%s",
 575                      bfd_get_section_name (aux->abfd, aux->sec));
 576             secaddr = bfd_get_section_vma (aux->abfd, aux->sec);
 577             if (vma < secaddr)
 578               {
 579                 fprintf (info->stream, "-");
 580                 objdump_print_value (secaddr - vma, info->stream);
 581               }
 582             else if (vma > secaddr)
 583               {
 584                 fprintf (info->stream, "+");
 585                 objdump_print_value (vma - secaddr, info->stream);
 586               }
 587             fprintf (info->stream, ">");
 588             return;
 589           }
 590       }
 591   }
 592
 593   fprintf (info->stream, " <%s", sorted_syms[thisplace]->name);
 594   if (bfd_asymbol_value (sorted_syms[thisplace]) > vma)
 595     {
 596       fprintf (info->stream, "-");
 597       objdump_print_value (bfd_asymbol_value (sorted_syms[thisplace]) - vma,
 598                            info->stream);
 599     }
 600   else if (vma > bfd_asymbol_value (sorted_syms[thisplace]))
 601     {
 602       fprintf (info->stream, "+");
 603       objdump_print_value (vma - bfd_asymbol_value (sorted_syms[thisplace]),
 604                            info->stream);
 605     }
 606   fprintf (info->stream, ">");
 607 }
 608
 609 /* Hold the last function name and the last line number we displayed
 610    in a disassembly.  */
 611
 612 static char *prev_functionname;
 613 static unsigned int prev_line;
 614
 615 /* We keep a list of all files that we have seen when doing a
 616    dissassembly with source, so that we know how much of the file to
 617    display.  This can be important for inlined functions.  */
 618
 619 struct print_file_list
 620 {
 621   struct print_file_list *next;
 622   char *filename;
 623   unsigned int line;
 624   FILE *f;
 625 };
 626
 627 static struct print_file_list *print_files;
 628
 629 /* The number of preceding context lines to show when we start
 630    displaying a file for the first time.  */
 631
 632 #define SHOW_PRECEDING_CONTEXT_LINES (5)
 633
 634 /* Skip ahead to a given line in a file, optionally printing each
 635    line.  */
 636
 637 static void
 638 skip_to_line PARAMS ((struct print_file_list *, unsigned int, boolean));
 639
 640 static void
 641 skip_to_line (p, line, show)
 642      struct print_file_list *p;
 643      unsigned int line;
 644      boolean show;
 645 {
 646   while (p->line < line)
 647     {
 648       char buf[100];
 649
 650       if (fgets (buf, sizeof buf, p->f) == NULL)
 651         {
 652           fclose (p->f);
 653           p->f = NULL;
 654           break;
 655         }
 656
 657       if (show)
 658         printf ("%s", buf);
 659
 660       if (strchr (buf, '\n') != NULL)
 661         ++p->line;
 662     }
 663 }
 664
 665 /* Show the line number, or the source line, in a dissassembly
 666    listing.  */
 667
 668 static void
 669 show_line (abfd, section, off)
 670      bfd *abfd;
 671      asection *section;
 672      bfd_vma off;
 673 {
 674   CONST char *filename;
 675   CONST char *functionname;
 676   unsigned int line;
 677
 678   if (! with_line_numbers && ! with_source_code)
 679     return;
 680
 681   if (! bfd_find_nearest_line (abfd, section, syms, off, &filename,
 682                                &functionname, &line))
 683     return;
 684
 685   if (filename != NULL && *filename == '\0')
 686     filename = NULL;
 687   if (functionname != NULL && *functionname == '\0')
 688     functionname = NULL;
 689
 690   if (with_line_numbers)
 691     {
 692       if (functionname != NULL
 693           && (prev_functionname == NULL
 694               || strcmp (functionname, prev_functionname) != 0))
 695         printf ("%s():\n", functionname);
 696       if (line > 0 && line != prev_line)
 697         printf ("%s:%u\n", filename == NULL ? "???" : filename, line);
 698     }
 699
 700   if (with_source_code
 701       && filename != NULL
 702       && line > 0)
 703     {
 704       struct print_file_list **pp, *p;
 705
 706       for (pp = &print_files; *pp != NULL; pp = &(*pp)->next)
 707         if (strcmp ((*pp)->filename, filename) == 0)
 708           break;
 709       p = *pp;
 710
 711       if (p != NULL)
 712         {
 713           if (p != print_files)
 714             {
 715               int l;
 716
 717               /* We have reencountered a file name which we saw
 718                  earlier.  This implies that either we are dumping out
 719                  code from an included file, or the same file was
 720                  linked in more than once.  There are two common cases
 721                  of an included file: inline functions in a header
 722                  file, and a bison or flex skeleton file.  In the
 723                  former case we want to just start printing (but we
 724                  back up a few lines to give context); in the latter
 725                  case we want to continue from where we left off.  I
 726                  can't think of a good way to distinguish the cases,
 727                  so I used a heuristic based on the file name.  */
 728               if (strcmp (p->filename + strlen (p->filename) - 2, ".h") != 0)
 729                 l = p->line;
 730               else
 731                 {
 732                   l = line - SHOW_PRECEDING_CONTEXT_LINES;
 733                   if (l <= 0)
 734                     l = 1;
 735                 }
 736
 737               if (p->f == NULL)
 738                 {
 739                   p->f = fopen (p->filename, "r");
 740                   p->line = 0;
 741                 }
 742               if (p->f != NULL)
 743                 skip_to_line (p, l, false);
 744
 745               if (print_files->f != NULL)
 746                 {
 747                   fclose (print_files->f);
 748                   print_files->f = NULL;
 749                 }
 750             }
 751
 752           if (p->f != NULL)
 753             {
 754               skip_to_line (p, line, true);
 755               *pp = p->next;
 756               p->next = print_files;
 757               print_files = p;
 758             }
 759         }
 760       else
 761         {
 762           FILE *f;
 763
 764           f = fopen (filename, "r");
 765           if (f != NULL)
 766             {
 767               int l;
 768
 769               p = ((struct print_file_list *)
 770                    xmalloc (sizeof (struct print_file_list)));
 771               p->filename = xmalloc (strlen (filename) + 1);
 772               strcpy (p->filename, filename);
 773               p->line = 0;
 774               p->f = f;
 775
 776               if (print_files != NULL && print_files->f != NULL)
 777                 {
 778                   fclose (print_files->f);
 779                   print_files->f = NULL;
 780                 }
 781               p->next = print_files;
 782               print_files = p;
 783
 784               l = line - SHOW_PRECEDING_CONTEXT_LINES;
 785               if (l <= 0)
 786                 l = 1;
 787               skip_to_line (p, l, false);
 788               if (p->f != NULL)
 789                 skip_to_line (p, line, true);
 790             }
 791         }
 792     }
 793
 794   if (functionname != NULL
 795       && (prev_functionname == NULL
 796           || strcmp (functionname, prev_functionname) != 0))
 797     {
 798       if (prev_functionname != NULL)
 799         free (prev_functionname);
 800       prev_functionname = xmalloc (strlen (functionname) + 1);
 801       strcpy (prev_functionname, functionname);
 802     }
 803
 804   if (line > 0 && line != prev_line)
 805     prev_line = line;
 806 }
 807
 808 void
 809 disassemble_data (abfd)
 810      bfd *abfd;
 811 {
 812   long i;
 813   disassembler_ftype disassemble_fn = 0; /* New style */
 814   struct disassemble_info disasm_info;
 815   struct objdump_disasm_info aux;
 816   asection *section;
 817   boolean done_dot = false;
 818
 819   print_files = NULL;
 820   prev_functionname = NULL;
 821   prev_line = -1;
 822
 823   /* We make a copy of syms to sort.  We don't want to sort syms
 824      because that will screw up the relocs.  */
 825   sorted_syms = (asymbol **) xmalloc (symcount * sizeof (asymbol *));
 826   memcpy (sorted_syms, syms, symcount * sizeof (asymbol *));
 827
 828   sorted_symcount = remove_useless_symbols (sorted_syms, symcount);
 829
 830   /* Sort the symbols into section and symbol order */
 831   qsort (sorted_syms, sorted_symcount, sizeof (asymbol *), compare_symbols);
 832
 833   INIT_DISASSEMBLE_INFO(disasm_info, stdout, fprintf);
 834   disasm_info.application_data = (PTR) &aux;
 835   aux.abfd = abfd;
 836   disasm_info.print_address_func = objdump_print_address;
 837   if (show_raw_insn)
 838     disasm_info.flags |= DISASM_RAW_INSN_FLAG;
 839
 840   if (machine != (char *) NULL)
 841     {
 842       const bfd_arch_info_type *info = bfd_scan_arch (machine);
 843       if (info == NULL)
 844         {
 845           fprintf (stderr, "%s: Can't use supplied machine %s\n",
 846                    program_name,
 847                    machine);
 848           exit (1);
 849         }
 850       abfd->arch_info = info;
 851     }
 852
 853   disassemble_fn = disassembler (abfd);
 854   if (!disassemble_fn)
 855     {
 856       fprintf (stderr, "%s: Can't disassemble for architecture %s\n",
 857                program_name,
 858                bfd_printable_arch_mach (bfd_get_arch (abfd), 0));
 859       exit (1);
 860     }
 861
 862   disasm_info.arch = bfd_get_arch (abfd);
 863   disasm_info.mach = bfd_get_mach (abfd);
 864   if (bfd_big_endian (abfd))
 865     disasm_info.endian = BFD_ENDIAN_BIG;
 866   else if (bfd_little_endian (abfd))
 867     disasm_info.endian = BFD_ENDIAN_LITTLE;
 868   else
 869     /* ??? Aborting here seems too drastic.  We could default to big or little
 870        instead.  */
 871     disasm_info.endian = BFD_ENDIAN_UNKNOWN;
 872
 873   for (section = abfd->sections;
 874        section != (asection *) NULL;
 875        section = section->next)
 876     {
 877       bfd_byte *data = NULL;
 878       bfd_size_type datasize = 0;
 879       arelent **relbuf = NULL;
 880       arelent **relpp = NULL;
 881       arelent **relppend = NULL;
 882       long stop;
 883
 884       if ((section->flags & SEC_LOAD) == 0
 885           || (! disassemble_all
 886               && only == NULL
 887               && (section->flags & SEC_CODE) == 0))
 888         continue;
 889       if (only != (char *) NULL && strcmp (only, section->name) != 0)
 890         continue;
 891
 892       if (dump_reloc_info
 893           && (section->flags & SEC_RELOC) != 0)
 894         {
 895           long relsize;
 896
 897           relsize = bfd_get_reloc_upper_bound (abfd, section);
 898           if (relsize < 0)
 899             bfd_fatal (bfd_get_filename (abfd));
 900
 901           if (relsize > 0)
 902             {
 903               long relcount;
 904
 905               relbuf = (arelent **) xmalloc (relsize);
 906               relcount = bfd_canonicalize_reloc (abfd, section, relbuf, syms);
 907               if (relcount < 0)
 908                 bfd_fatal (bfd_get_filename (abfd));
 909
 910               /* Sort the relocs by address.  */
 911               qsort (relbuf, relcount, sizeof (arelent *), compare_relocs);
 912
 913               relpp = relbuf;
 914               relppend = relpp + relcount;
 915             }
 916         }
 917
 918       printf ("Disassembly of section %s:\n", section->name);
 919
 920       datasize = bfd_get_section_size_before_reloc (section);
 921       if (datasize == 0)
 922         continue;
 923
 924       data = (bfd_byte *) xmalloc ((size_t) datasize);
 925
 926       bfd_get_section_contents (abfd, section, data, 0, datasize);
 927
 928       aux.sec = section;
 929       disasm_info.buffer = data;
 930       disasm_info.buffer_vma = section->vma;
 931       disasm_info.buffer_length = datasize;
 932       if (start_address == (bfd_vma) -1
 933           || start_address < disasm_info.buffer_vma)
 934         i = 0;
 935       else
 936         i = start_address - disasm_info.buffer_vma;
 937       if (stop_address == (bfd_vma) -1)
 938         stop = datasize;
 939       else
 940         {
 941           if (stop_address < disasm_info.buffer_vma)
 942             stop = 0;
 943           else
 944             stop = stop_address - disasm_info.buffer_vma;
 945           if (stop > disasm_info.buffer_length)
 946             stop = disasm_info.buffer_length;
 947         }
 948       while (i < stop)
 949         {
 950           int bytes;
 951           boolean need_nl = false;
 952
 953           if (data[i] == 0 && data[i + 1] == 0 && data[i + 2] == 0 &&
 954               data[i + 3] == 0)
 955             {
 956               if (done_dot == false)
 957                 {
 958                   printf ("...\n");
 959                   done_dot = true;
 960                 }
 961               bytes = 4;
 962             }
 963           else
 964             {
 965               done_dot = false;
 966               if (with_line_numbers || with_source_code)
 967                 show_line (abfd, section, i);
 968               aux.require_sec = true;
 969               objdump_print_address (section->vma + i, &disasm_info);
 970               aux.require_sec = false;
 971               putchar (' ');
 972
 973               bytes = (*disassemble_fn) (section->vma + i, &disasm_info);
 974               if (bytes < 0)
 975                 break;
 976
 977               if (!wide_output)
 978                 putchar ('\n');
 979               else
 980                 need_nl = true;
 981             }
 982
 983           if (dump_reloc_info
 984               && (section->flags & SEC_RELOC) != 0)
 985             {
 986               while (relpp < relppend
 987                      && ((*relpp)->address >= (bfd_vma) i
 988                          && (*relpp)->address < (bfd_vma) i + bytes))
 989                 {
 990                   arelent *q;
 991                   const char *sym_name;
 992
 993                   q = *relpp;
 994
 995                   printf ("\t\tRELOC: ");
 996
 997                   printf_vma (section->vma + q->address);
 998
 999                   printf (" %s ", q->howto->name);
1000
1001                   if (q->sym_ptr_ptr != NULL
1002                       && *q->sym_ptr_ptr != NULL)
1003                     {
1004                       sym_name = bfd_asymbol_name (*q->sym_ptr_ptr);
1005                       if (sym_name == NULL || *sym_name == '\0')
1006                         {
1007                           asection *sym_sec;
1008
1009                           sym_sec = bfd_get_section (*q->sym_ptr_ptr);
1010                           sym_name = bfd_get_section_name (abfd, sym_sec);
1011                           if (sym_name == NULL || *sym_name == '\0')
1012                             sym_name = "*unknown*";
1013                         }
1014                     }
1015
1016                   printf ("%s", sym_name);
1017
1018                   if (q->addend)
1019                     {
1020                       printf ("+0x");
1021                       printf_vma (q->addend);
1022                     }
1023
1024                   printf ("\n");
1025                   need_nl = false;
1026                   ++relpp;
1027                 }
1028             }
1029
1030           if (need_nl)
1031             printf ("\n");
1032
1033           i += bytes;
1034         }
1035
1036       free (data);
1037       if (relbuf != NULL)
1038         free (relbuf);
1039     }
1040   free (sorted_syms);
1041 }
1042 \f
1043
1044 /* Define a table of stab values and print-strings.  We wish the initializer
1045    could be a direct-mapped table, but instead we build one the first
1046    time we need it.  */
1047
1048 char **stab_name;
1049
1050 struct stab_print {
1051   int value;
1052   char *string;
1053 };
1054
1055 struct stab_print stab_print[] = {
1056 #define __define_stab(NAME, CODE, STRING) {CODE, STRING},
1057 #include "aout/stab.def"
1058 #undef __define_stab
1059   {0, ""}
1060 };
1061
1062 void dump_section_stabs PARAMS ((bfd *abfd, char *stabsect_name,
1063                                  char *strsect_name));
1064
1065 /* Dump the stabs sections from an object file that has a section that
1066    uses Sun stabs encoding.  It has to use some hooks into BFD because
1067    string table sections are not normally visible to BFD callers.  */
1068
1069 void
1070 dump_stabs (abfd)
1071      bfd *abfd;
1072 {
1073   /* Allocate and initialize stab name array if first time.  */
1074   if (stab_name == NULL)
1075     {
1076       int i;
1077
1078       stab_name = (char **) xmalloc (256 * sizeof(char *));
1079       /* Clear the array. */
1080       for (i = 0; i < 256; i++)
1081         stab_name[i] = NULL;
1082       /* Fill in the defined stabs. */
1083       for (i = 0; *stab_print[i].string; i++)
1084         stab_name[stab_print[i].value] = stab_print[i].string;
1085     }
1086
1087   dump_section_stabs (abfd, ".stab", ".stabstr");
1088   dump_section_stabs (abfd, ".stab.excl", ".stab.exclstr");
1089   dump_section_stabs (abfd, ".stab.index", ".stab.indexstr");
1090   dump_section_stabs (abfd, "$GDB_SYMBOLS$", "$GDB_STRINGS$");
1091 }
1092
1093 static struct internal_nlist *stabs;
1094 static bfd_size_type stab_size;
1095
1096 static char *strtab;
1097 static bfd_size_type stabstr_size;
1098
1099 /* Read ABFD's stabs section STABSECT_NAME into `stabs'
1100    and string table section STRSECT_NAME into `strtab'.
1101    If the section exists and was read, allocate the space and return true.
1102    Otherwise return false.  */
1103
1104 boolean
1105 read_section_stabs (abfd, stabsect_name, strsect_name)
1106      bfd *abfd;
1107      char *stabsect_name;
1108      char *strsect_name;
1109 {
1110   asection *stabsect, *stabstrsect;
1111
1112   stabsect = bfd_get_section_by_name (abfd, stabsect_name);
1113   if (0 == stabsect)
1114     {
1115       printf ("No %s section present\n\n", stabsect_name);
1116       return false;
1117     }
1118
1119   stabstrsect = bfd_get_section_by_name (abfd, strsect_name);
1120   if (0 == stabstrsect)
1121     {
1122       fprintf (stderr, "%s: %s has no %s section\n", program_name,
1123                bfd_get_filename (abfd), strsect_name);
1124       return false;
1125     }
1126
1127   stab_size    = bfd_section_size (abfd, stabsect);
1128   stabstr_size = bfd_section_size (abfd, stabstrsect);
1129
1130   stabs  = (struct internal_nlist *) xmalloc (stab_size);
1131   strtab = (char *) xmalloc (stabstr_size);
1132
1133   if (! bfd_get_section_contents (abfd, stabsect, (PTR) stabs, 0, stab_size))
1134     {
1135       fprintf (stderr, "%s: Reading %s section of %s failed: %s\n",
1136                program_name, stabsect_name, bfd_get_filename (abfd),
1137                bfd_errmsg (bfd_get_error ()));
1138       free (stabs);
1139       free (strtab);
1140       return false;
1141     }
1142
1143   if (! bfd_get_section_contents (abfd, stabstrsect, (PTR) strtab, 0,
1144                                   stabstr_size))
1145     {
1146       fprintf (stderr, "%s: Reading %s section of %s failed: %s\n",
1147                program_name, strsect_name, bfd_get_filename (abfd),
1148                bfd_errmsg (bfd_get_error ()));
1149       free (stabs);
1150       free (strtab);
1151       return false;
1152     }
1153
1154   return true;
1155 }
1156
1157 #define SWAP_SYMBOL(symp, abfd) \
1158 { \
1159     (symp)->n_strx = bfd_h_get_32(abfd,                 \
1160                                   (unsigned char *)&(symp)->n_strx);    \
1161     (symp)->n_desc = bfd_h_get_16 (abfd,                        \
1162                                    (unsigned char *)&(symp)->n_desc);   \
1163     (symp)->n_value = bfd_h_get_32 (abfd,                       \
1164                                     (unsigned char *)&(symp)->n_value); \
1165 }
1166
1167 /* Print ABFD's stabs section STABSECT_NAME (in `stabs'),
1168    using string table section STRSECT_NAME (in `strtab').  */
1169
1170 void
1171 print_section_stabs (abfd, stabsect_name, strsect_name)
1172      bfd *abfd;
1173      char *stabsect_name;
1174      char *strsect_name;
1175 {
1176   int i;
1177   unsigned file_string_table_offset = 0, next_file_string_table_offset = 0;
1178   struct internal_nlist *stabp = stabs,
1179   *stabs_end = (struct internal_nlist *) (stab_size + (char *) stabs);
1180
1181   printf ("Contents of %s section:\n\n", stabsect_name);
1182   printf ("Symnum n_type n_othr n_desc n_value  n_strx String\n");
1183
1184   /* Loop through all symbols and print them.
1185
1186      We start the index at -1 because there is a dummy symbol on
1187      the front of stabs-in-{coff,elf} sections that supplies sizes.  */
1188
1189   for (i = -1; stabp < stabs_end; stabp++, i++)
1190     {
1191       SWAP_SYMBOL (stabp, abfd);
1192       printf ("\n%-6d ", i);
1193       /* Either print the stab name, or, if unnamed, print its number
1194          again (makes consistent formatting for tools like awk). */
1195       if (stab_name[stabp->n_type])
1196         printf ("%-6s", stab_name[stabp->n_type]);
1197       else if (stabp->n_type == N_UNDF)
1198         printf ("HdrSym");
1199       else
1200         printf ("%-6d", stabp->n_type);
1201       printf (" %-6d %-6d ", stabp->n_other, stabp->n_desc);
1202       printf_vma (stabp->n_value);
1203       printf (" %-6lu", stabp->n_strx);
1204
1205       /* Symbols with type == 0 (N_UNDF) specify the length of the
1206          string table associated with this file.  We use that info
1207          to know how to relocate the *next* file's string table indices.  */
1208
1209       if (stabp->n_type == N_UNDF)
1210         {
1211           file_string_table_offset = next_file_string_table_offset;
1212           next_file_string_table_offset += stabp->n_value;
1213         }
1214       else
1215         {
1216           /* Using the (possibly updated) string table offset, print the
1217              string (if any) associated with this symbol.  */
1218
1219           if ((stabp->n_strx + file_string_table_offset) < stabstr_size)
1220             printf (" %s", &strtab[stabp->n_strx + file_string_table_offset]);
1221           else
1222             printf (" *");
1223         }
1224     }
1225   printf ("\n\n");
1226 }
1227
1228 void
1229 dump_section_stabs (abfd, stabsect_name, strsect_name)
1230      bfd *abfd;
1231      char *stabsect_name;
1232      char *strsect_name;
1233 {
1234   asection *s;
1235
1236   /* Check for section names for which stabsect_name is a prefix, to
1237      handle .stab0, etc.  */
1238   for (s = abfd->sections;
1239        s != NULL;
1240        s = s->next)
1241     {
1242       if (strncmp (stabsect_name, s->name, strlen (stabsect_name)) == 0
1243           && strncmp (strsect_name, s->name, strlen (strsect_name)) != 0)
1244         {
1245           if (read_section_stabs (abfd, s->name, strsect_name))
1246             {
1247               print_section_stabs (abfd, s->name, strsect_name);
1248               free (stabs);
1249               free (strtab);
1250             }
1251         }
1252     }
1253 }
1254 \f
1255 static void
1256 dump_bfd_header (abfd)
1257      bfd *abfd;
1258 {
1259   char *comma = "";
1260
1261   printf ("architecture: %s, ",
1262           bfd_printable_arch_mach (bfd_get_arch (abfd),
1263                                    bfd_get_mach (abfd)));
1264   printf ("flags 0x%08x:\n", abfd->flags);
1265
1266 #define PF(x, y)    if (abfd->flags & x) {printf("%s%s", comma, y); comma=", ";}
1267   PF (HAS_RELOC, "HAS_RELOC");
1268   PF (EXEC_P, "EXEC_P");
1269   PF (HAS_LINENO, "HAS_LINENO");
1270   PF (HAS_DEBUG, "HAS_DEBUG");
1271   PF (HAS_SYMS, "HAS_SYMS");
1272   PF (HAS_LOCALS, "HAS_LOCALS");
1273   PF (DYNAMIC, "DYNAMIC");
1274   PF (WP_TEXT, "WP_TEXT");
1275   PF (D_PAGED, "D_PAGED");
1276   PF (BFD_IS_RELAXABLE, "BFD_IS_RELAXABLE");
1277   printf ("\nstart address 0x");
1278   printf_vma (abfd->start_address);
1279 }
1280 \f
1281 static void
1282 dump_bfd_private_header (abfd)
1283 bfd *abfd;
1284 {
1285   bfd_print_private_bfd_data (abfd, stdout);
1286 }
1287 static void
1288 display_bfd (abfd)
1289      bfd *abfd;
1290 {
1291   char **matching;
1292
1293   if (!bfd_check_format_matches (abfd, bfd_object, &matching))
1294     {
1295       bfd_nonfatal (bfd_get_filename (abfd));
1296       if (bfd_get_error () == bfd_error_file_ambiguously_recognized)
1297         {
1298           list_matching_formats (matching);
1299           free (matching);
1300         }
1301       return;
1302     }
1303
1304   printf ("\n%s:     file format %s\n", bfd_get_filename (abfd),
1305           abfd->xvec->name);
1306   if (dump_ar_hdrs)
1307     print_arelt_descr (stdout, abfd, true);
1308   if (dump_file_header)
1309     dump_bfd_header (abfd);
1310   if (dump_private_headers)
1311     dump_bfd_private_header (abfd);
1312   putchar ('\n');
1313   if (dump_section_headers)
1314     dump_headers (abfd);
1315   if (dump_symtab || dump_reloc_info || disassemble || dump_debugging)
1316     {
1317       syms = slurp_symtab (abfd);
1318     }
1319   if (dump_dynamic_symtab || dump_dynamic_reloc_info)
1320     {
1321       dynsyms = slurp_dynamic_symtab (abfd);
1322     }
1323   if (dump_symtab)
1324     dump_symbols (abfd, false);
1325   if (dump_dynamic_symtab)
1326     dump_symbols (abfd, true);
1327   if (dump_stab_section_info)
1328     dump_stabs (abfd);
1329   if (dump_reloc_info && ! disassemble)
1330     dump_relocs (abfd);
1331   if (dump_dynamic_reloc_info)
1332     dump_dynamic_relocs (abfd);
1333   if (dump_section_contents)
1334     dump_data (abfd);
1335   if (disassemble)
1336     disassemble_data (abfd);
1337   if (dump_debugging)
1338     {
1339       PTR dhandle;
1340
1341       dhandle = read_debugging_info (abfd, syms, symcount);
1342       if (dhandle != NULL)
1343         {
1344           if (! print_debugging_info (stdout, dhandle))
1345             fprintf (stderr, "%s: printing debugging information failed\n",
1346                      bfd_get_filename (abfd));
1347         }
1348     }
1349   if (syms)
1350     {
1351       free (syms);
1352       syms = NULL;
1353     }
1354   if (dynsyms)
1355     {
1356       free (dynsyms);
1357       dynsyms = NULL;
1358     }
1359 }
1360
1361 static void
1362 display_file (filename, target)
1363      char *filename;
1364      char *target;
1365 {
1366   bfd *file, *arfile = (bfd *) NULL;
1367
1368   file = bfd_openr (filename, target);
1369   if (file == NULL)
1370     {
1371       bfd_nonfatal (filename);
1372       return;
1373     }
1374
1375   if (bfd_check_format (file, bfd_archive) == true)
1376     {
1377       bfd *last_arfile = NULL;
1378
1379       printf ("In archive %s:\n", bfd_get_filename (file));
1380       for (;;)
1381         {
1382           bfd_set_error (bfd_error_no_error);
1383
1384           arfile = bfd_openr_next_archived_file (file, arfile);
1385           if (arfile == NULL)
1386             {
1387               if (bfd_get_error () != bfd_error_no_more_archived_files)
1388                 {
1389                   bfd_nonfatal (bfd_get_filename (file));
1390                 }
1391               break;
1392             }
1393
1394           display_bfd (arfile);
1395
1396           if (last_arfile != NULL)
1397             bfd_close (last_arfile);
1398           last_arfile = arfile;
1399         }
1400
1401       if (last_arfile != NULL)
1402         bfd_close (last_arfile);
1403     }
1404   else
1405     display_bfd (file);
1406
1407   bfd_close (file);
1408 }
1409 \f
1410 /* Actually display the various requested regions */
1411
1412 static void
1413 dump_data (abfd)
1414      bfd *abfd;
1415 {
1416   asection *section;
1417   bfd_byte *data = 0;
1418   bfd_size_type datasize = 0;
1419   bfd_size_type i;
1420   bfd_size_type start, stop;
1421
1422   for (section = abfd->sections; section != NULL; section =
1423        section->next)
1424     {
1425       int onaline = 16;
1426
1427       if (only == (char *) NULL ||
1428           strcmp (only, section->name) == 0)
1429         {
1430           if (section->flags & SEC_HAS_CONTENTS)
1431             {
1432               printf ("Contents of section %s:\n", section->name);
1433
1434               if (bfd_section_size (abfd, section) == 0)
1435                 continue;
1436               data = (bfd_byte *) xmalloc ((size_t) bfd_section_size (abfd, section));
1437               datasize = bfd_section_size (abfd, section);
1438
1439
1440               bfd_get_section_contents (abfd, section, (PTR) data, 0, bfd_section_size (abfd, section));
1441
1442               if (start_address == (bfd_vma) -1
1443                   || start_address < section->vma)
1444                 start = 0;
1445               else
1446                 start = start_address - section->vma;
1447               if (stop_address == (bfd_vma) -1)
1448                 stop = bfd_section_size (abfd, section);
1449               else
1450                 {
1451                   if (stop_address < section->vma)
1452                     stop = 0;
1453                   else
1454                     stop = stop_address - section->vma;
1455                   if (stop > bfd_section_size (abfd, section))
1456                     stop = bfd_section_size (abfd, section);
1457                 }
1458               for (i = start; i < stop; i += onaline)
1459                 {
1460                   bfd_size_type j;
1461
1462                   printf (" %04lx ", (unsigned long int) (i + section->vma));
1463                   for (j = i; j < i + onaline; j++)
1464                     {
1465                       if (j < stop)
1466                         printf ("%02x", (unsigned) (data[j]));
1467                       else
1468                         printf ("  ");
1469                       if ((j & 3) == 3)
1470                         printf (" ");
1471                     }
1472
1473                   printf (" ");
1474                   for (j = i; j < i + onaline; j++)
1475                     {
1476                       if (j >= stop)
1477                         printf (" ");
1478                       else
1479                         printf ("%c", isprint (data[j]) ? data[j] : '.');
1480                     }
1481                   putchar ('\n');
1482                 }
1483               free (data);
1484             }
1485         }
1486     }
1487 }
1488
1489 /* Should perhaps share code and display with nm? */
1490 static void
1491 dump_symbols (abfd, dynamic)
1492      bfd *abfd;
1493      boolean dynamic;
1494 {
1495   asymbol **current;
1496   long max;
1497   long count;
1498
1499   if (dynamic)
1500     {
1501       current = dynsyms;
1502       max = dynsymcount;
1503       if (max == 0)
1504         return;
1505       printf ("DYNAMIC SYMBOL TABLE:\n");
1506     }
1507   else
1508     {
1509       current = syms;
1510       max = symcount;
1511       if (max == 0)
1512         return;
1513       printf ("SYMBOL TABLE:\n");
1514     }
1515
1516   for (count = 0; count < max; count++)
1517     {
1518       if (*current)
1519         {
1520           bfd *cur_bfd = bfd_asymbol_bfd(*current);
1521           if (cur_bfd)
1522             {
1523               bfd_print_symbol (cur_bfd,
1524                                 stdout,
1525                                 *current, bfd_print_symbol_all);
1526               printf ("\n");
1527             }
1528         }
1529       current++;
1530     }
1531   printf ("\n");
1532   printf ("\n");
1533 }
1534
1535 static void
1536 dump_relocs (abfd)
1537      bfd *abfd;
1538 {
1539   arelent **relpp;
1540   long relcount;
1541   asection *a;
1542
1543   for (a = abfd->sections; a != (asection *) NULL; a = a->next)
1544     {
1545       long relsize;
1546
1547       if (bfd_is_abs_section (a))
1548         continue;
1549       if (bfd_is_und_section (a))
1550         continue;
1551       if (bfd_is_com_section (a))
1552         continue;
1553
1554       if (only)
1555         {
1556           if (strcmp (only, a->name))
1557             continue;
1558         }
1559       else if ((a->flags & SEC_RELOC) == 0)
1560         continue;
1561
1562       relsize = bfd_get_reloc_upper_bound (abfd, a);
1563       if (relsize < 0)
1564         bfd_fatal (bfd_get_filename (abfd));
1565
1566       printf ("RELOCATION RECORDS FOR [%s]:", a->name);
1567
1568       if (relsize == 0)
1569         {
1570           printf (" (none)\n\n");
1571         }
1572       else
1573         {
1574           relpp = (arelent **) xmalloc (relsize);
1575           relcount = bfd_canonicalize_reloc (abfd, a, relpp, syms);
1576           if (relcount < 0)
1577             bfd_fatal (bfd_get_filename (abfd));
1578           else if (relcount == 0)
1579             {
1580               printf (" (none)\n\n");
1581             }
1582           else
1583             {
1584               printf ("\n");
1585               dump_reloc_set (abfd, relpp, relcount);
1586               printf ("\n\n");
1587             }
1588           free (relpp);
1589         }
1590     }
1591 }
1592
1593 static void
1594 dump_dynamic_relocs (abfd)
1595      bfd *abfd;
1596 {
1597   long relsize;
1598   arelent **relpp;
1599   long relcount;
1600
1601   relsize = bfd_get_dynamic_reloc_upper_bound (abfd);
1602   if (relsize < 0)
1603     bfd_fatal (bfd_get_filename (abfd));
1604
1605   printf ("DYNAMIC RELOCATION RECORDS");
1606
1607   if (relsize == 0)
1608     {
1609       printf (" (none)\n\n");
1610     }
1611   else
1612     {
1613       relpp = (arelent **) xmalloc (relsize);
1614       relcount = bfd_canonicalize_dynamic_reloc (abfd, relpp, dynsyms);
1615       if (relcount < 0)
1616         bfd_fatal (bfd_get_filename (abfd));
1617       else if (relcount == 0)
1618         {
1619           printf (" (none)\n\n");
1620         }
1621       else
1622         {
1623           printf ("\n");
1624           dump_reloc_set (abfd, relpp, relcount);
1625           printf ("\n\n");
1626         }
1627       free (relpp);
1628     }
1629 }
1630
1631 static void
1632 dump_reloc_set (abfd, relpp, relcount)
1633      bfd *abfd;
1634      arelent **relpp;
1635      long relcount;
1636 {
1637   arelent **p;
1638
1639   /* Get column headers lined up reasonably.  */
1640   {
1641     static int width;
1642     if (width == 0)
1643       {
1644         char buf[30];
1645         sprintf_vma (buf, (bfd_vma) -1);
1646         width = strlen (buf) - 7;
1647       }
1648     printf ("OFFSET %*s TYPE %*s VALUE \n", width, "", 12, "");
1649   }
1650
1651   for (p = relpp; relcount && *p != (arelent *) NULL; p++, relcount--)
1652     {
1653       arelent *q = *p;
1654       CONST char *sym_name;
1655       CONST char *section_name;
1656
1657       if (start_address != (bfd_vma) -1
1658           && q->address < start_address)
1659         continue;
1660       if (stop_address != (bfd_vma) -1
1661           && q->address > stop_address)
1662         continue;
1663
1664       if (q->sym_ptr_ptr && *q->sym_ptr_ptr)
1665         {
1666           sym_name = (*(q->sym_ptr_ptr))->name;
1667           section_name = (*(q->sym_ptr_ptr))->section->name;
1668         }
1669       else
1670         {
1671           sym_name = NULL;
1672           section_name = NULL;
1673         }
1674       if (sym_name)
1675         {
1676           printf_vma (q->address);
1677           printf (" %-16s  %s",
1678                   q->howto->name,
1679                   sym_name);
1680         }
1681       else
1682         {
1683           if (section_name == (CONST char *) NULL)
1684             section_name = "*unknown*";
1685           printf_vma (q->address);
1686           printf (" %-16s  [%s]",
1687                   q->howto->name,
1688                   section_name);
1689         }
1690       if (q->addend)
1691         {
1692           printf ("+0x");
1693           printf_vma (q->addend);
1694         }
1695       printf ("\n");
1696     }
1697 }
1698 \f
1699 /* The length of the longest architecture name + 1.  */
1700 #define LONGEST_ARCH sizeof("rs6000:6000")
1701
1702 #ifndef L_tmpnam
1703 #define L_tmpnam 25
1704 #endif
1705
1706 static const char *
1707 endian_string (endian)
1708      enum bfd_endian endian;
1709 {
1710   if (endian == BFD_ENDIAN_BIG)
1711     return "big endian";
1712   else if (endian == BFD_ENDIAN_LITTLE)
1713     return "little endian";
1714   else
1715     return "endianness unknown";
1716 }
1717
1718 /* List the targets that BFD is configured to support, each followed
1719    by its endianness and the architectures it supports.  */
1720
1721 static void
1722 display_target_list ()
1723 {
1724   extern char *tmpnam ();
1725   extern bfd_target *bfd_target_vector[];
1726   char tmparg[L_tmpnam];
1727   char *dummy_name;
1728   int t;
1729
1730   dummy_name = tmpnam (tmparg);
1731   for (t = 0; bfd_target_vector[t]; t++)
1732     {
1733       bfd_target *p = bfd_target_vector[t];
1734       bfd *abfd = bfd_openw (dummy_name, p->name);
1735       int a;
1736
1737       printf ("%s\n (header %s, data %s)\n", p->name,
1738               endian_string (p->header_byteorder),
1739               endian_string (p->byteorder));
1740
1741       if (abfd == NULL)
1742         {
1743           bfd_nonfatal (dummy_name);
1744           continue;
1745         }
1746
1747       if (! bfd_set_format (abfd, bfd_object))
1748         {
1749           if (bfd_get_error () != bfd_error_invalid_operation)
1750             bfd_nonfatal (p->name);
1751           continue;
1752         }
1753
1754       for (a = (int) bfd_arch_obscure + 1; a < (int) bfd_arch_last; a++)
1755         if (bfd_set_arch_mach (abfd, (enum bfd_architecture) a, 0))
1756           printf ("  %s\n",
1757                   bfd_printable_arch_mach ((enum bfd_architecture) a, 0));
1758     }
1759   unlink (dummy_name);
1760 }
1761
1762 /* Print a table showing which architectures are supported for entries
1763    FIRST through LAST-1 of bfd_target_vector (targets across,
1764    architectures down).  */
1765
1766 static void
1767 display_info_table (first, last)
1768      int first;
1769      int last;
1770 {
1771   extern bfd_target *bfd_target_vector[];
1772   extern char *tmpnam ();
1773   char tmparg[L_tmpnam];
1774   int t, a;
1775   char *dummy_name;
1776
1777   /* Print heading of target names.  */
1778   printf ("\n%*s", (int) LONGEST_ARCH, " ");
1779   for (t = first; t < last && bfd_target_vector[t]; t++)
1780     printf ("%s ", bfd_target_vector[t]->name);
1781   putchar ('\n');
1782
1783   dummy_name = tmpnam (tmparg);
1784   for (a = (int) bfd_arch_obscure + 1; a < (int) bfd_arch_last; a++)
1785     if (strcmp (bfd_printable_arch_mach (a, 0), "UNKNOWN!") != 0)
1786       {
1787         printf ("%*s ", (int) LONGEST_ARCH - 1,
1788                 bfd_printable_arch_mach (a, 0));
1789         for (t = first; t < last && bfd_target_vector[t]; t++)
1790           {
1791             bfd_target *p = bfd_target_vector[t];
1792             boolean ok = true;
1793             bfd *abfd = bfd_openw (dummy_name, p->name);
1794
1795             if (abfd == NULL)
1796               {
1797                 bfd_nonfatal (p->name);
1798                 ok = false;
1799               }
1800
1801             if (ok)
1802               {
1803                 if (! bfd_set_format (abfd, bfd_object))
1804                   {
1805                     if (bfd_get_error () != bfd_error_invalid_operation)
1806                       bfd_nonfatal (p->name);
1807                     ok = false;
1808                   }
1809               }
1810
1811             if (ok)
1812               {
1813                 if (! bfd_set_arch_mach (abfd, a, 0))
1814                   ok = false;
1815               }
1816
1817             if (ok)
1818               printf ("%s ", p->name);
1819             else
1820               {
1821                 int l = strlen (p->name);
1822                 while (l--)
1823                   putchar ('-');
1824                 putchar (' ');
1825               }
1826           }
1827         putchar ('\n');
1828       }
1829   unlink (dummy_name);
1830 }
1831
1832 /* Print tables of all the target-architecture combinations that
1833    BFD has been configured to support.  */
1834
1835 static void
1836 display_target_tables ()
1837 {
1838   int t, columns;
1839   extern bfd_target *bfd_target_vector[];
1840   char *colum;
1841   extern char *getenv ();
1842
1843   columns = 0;
1844   colum = getenv ("COLUMNS");
1845   if (colum != NULL)
1846     columns = atoi (colum);
1847   if (columns == 0)
1848     columns = 80;
1849
1850   t = 0;
1851   while (bfd_target_vector[t] != NULL)
1852     {
1853       int oldt = t, wid;
1854
1855       wid = LONGEST_ARCH + strlen (bfd_target_vector[t]->name) + 1;
1856       ++t;
1857       while (wid < columns && bfd_target_vector[t] != NULL)
1858         {
1859           int newwid;
1860
1861           newwid = wid + strlen (bfd_target_vector[t]->name) + 1;
1862           if (newwid >= columns)
1863             break;
1864           wid = newwid;
1865           ++t;
1866         }
1867       display_info_table (oldt, t);
1868     }
1869 }
1870
1871 static void
1872 display_info ()
1873 {
1874   printf ("BFD header file version %s\n", BFD_VERSION);
1875   display_target_list ();
1876   display_target_tables ();
1877 }
1878
1879 int
1880 main (argc, argv)
1881      int argc;
1882      char **argv;
1883 {
1884   int c;
1885   char *target = default_target;
1886   boolean seenflag = false;
1887
1888   program_name = *argv;
1889   xmalloc_set_program_name (program_name);
1890
1891   START_PROGRESS (program_name, 0);
1892
1893   bfd_init ();
1894
1895   while ((c = getopt_long (argc, argv, "pib:m:VdDlfahrRtTxsSj:w", long_options,
1896                            (int *) 0))
1897          != EOF)
1898     {
1899       if (c != 'l' && c != OPTION_START_ADDRESS && c != OPTION_STOP_ADDRESS)
1900         seenflag = true;
1901       switch (c)
1902         {
1903         case 0:
1904           break;                /* we've been given a long option */
1905         case 'm':
1906           machine = optarg;
1907           break;
1908         case 'j':
1909           only = optarg;
1910           break;
1911         case 'l':
1912           with_line_numbers = 1;
1913           break;
1914         case 'b':
1915           target = optarg;
1916           break;
1917         case 'f':
1918           dump_file_header = true;
1919           break;
1920         case 'i':
1921           formats_info = true;
1922           break;
1923         case 'p':
1924           dump_private_headers = 1;
1925           break;
1926         case 'x':
1927           dump_private_headers = 1;
1928           dump_symtab = 1;
1929           dump_reloc_info = 1;
1930           dump_file_header = true;
1931           dump_ar_hdrs = 1;
1932           dump_section_headers = 1;
1933           break;
1934         case 't':
1935           dump_symtab = 1;
1936           break;
1937         case 'T':
1938           dump_dynamic_symtab = 1;
1939           break;
1940         case 'd':
1941           disassemble = true;
1942           break;
1943         case 'D':
1944           disassemble = disassemble_all = true;
1945           break;
1946         case 'S':
1947           disassemble = true;
1948           with_source_code = true;
1949           break;
1950         case 's':
1951           dump_section_contents = 1;
1952           break;
1953         case 'r':
1954           dump_reloc_info = 1;
1955           break;
1956         case 'R':
1957           dump_dynamic_reloc_info = 1;
1958           break;
1959         case 'a':
1960           dump_ar_hdrs = 1;
1961           break;
1962         case 'h':
1963           dump_section_headers = 1;
1964           break;
1965         case 'H':
1966           usage (stdout, 0);
1967         case 'V':
1968           show_version = 1;
1969           break;
1970         case 'w':
1971           wide_output = 1;
1972           break;
1973         case OPTION_START_ADDRESS:
1974           start_address = parse_vma (optarg, "--start-address");
1975           break;
1976         case OPTION_STOP_ADDRESS:
1977           stop_address = parse_vma (optarg, "--stop-address");
1978           break;
1979         default:
1980           usage (stderr, 1);
1981         }
1982     }
1983
1984   if (show_version)
1985     {
1986       printf ("GNU %s version %s\n", program_name, program_version);
1987       exit (0);
1988     }
1989
1990   if (seenflag == false)
1991     usage (stderr, 1);
1992
1993   if (formats_info)
1994     {
1995       display_info ();
1996     }
1997   else
1998     {
1999       if (optind == argc)
2000         display_file ("a.out", target);
2001       else
2002         for (; optind < argc;)
2003           display_file (argv[optind++], target);
2004     }
2005
2006   END_PROGRESS (program_name);
2007
2008   return 0;
2009 }