binutils/objdump.c

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