binutils/objdump.c

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