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