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