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