binutils/objdump.c

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