binutils/objdump.c

   1 /* objdump.c -- dump information about an object file.
   2    Copyright (C) 1990-2017 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 3, 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, 51 Franklin Street - Fifth Floor, Boston,
  19    MA 02110-1301, USA.  */
  20
  21
  22 /* Objdump overview.
  23
  24    Objdump displays information about one or more object files, either on
  25    their own, or inside libraries.  It is commonly used as a disassembler,
  26    but it can also display information about file headers, symbol tables,
  27    relocations, debugging directives and more.
  28
  29    The flow of execution is as follows:
  30
  31    1. Command line arguments are checked for control switches and the
  32       information to be displayed is selected.
  33
  34    2. Any remaining arguments are assumed to be object files, and they are
  35       processed in order by display_bfd().  If the file is an archive each
  36       of its elements is processed in turn.
  37
  38    3. The file's target architecture and binary file format are determined
  39       by bfd_check_format().  If they are recognised, then dump_bfd() is
  40       called.
  41
  42    4. dump_bfd() in turn calls separate functions to display the requested
  43       item(s) of information(s).  For example disassemble_data() is called if
  44       a disassembly has been requested.
  45
  46    When disassembling the code loops through blocks of instructions bounded
  47    by symbols, calling disassemble_bytes() on each block.  The actual
  48    disassembling is done by the libopcodes library, via a function pointer
  49    supplied by the disassembler() function.  */
  50
  51 #include "sysdep.h"
  52 #include "bfd.h"
  53 #include "elf-bfd.h"
  54 #include "coff-bfd.h"
  55 #include "progress.h"
  56 #include "bucomm.h"
  57 #include "elfcomm.h"
  58 #include "dwarf.h"
  59 #include "getopt.h"
  60 #include "safe-ctype.h"
  61 #include "dis-asm.h"
  62 #include "libiberty.h"
  63 #include "demangle.h"
  64 #include "filenames.h"
  65 #include "debug.h"
  66 #include "budbg.h"
  67 #include "objdump.h"
  68
  69 #ifdef HAVE_MMAP
  70 #include <sys/mman.h>
  71 #endif
  72
  73 /* Internal headers for the ELF .stab-dump code - sorry.  */
  74 #define BYTES_IN_WORD   32
  75 #include "aout/aout64.h"
  76
  77 /* Exit status.  */
  78 static int exit_status = 0;
  79
  80 static char *default_target = NULL;     /* Default at runtime.  */
  81
  82 /* The following variables are set based on arguments passed on the
  83    command line.  */
  84 static int show_version = 0;            /* Show the version number.  */
  85 static int dump_section_contents;       /* -s */
  86 static int dump_section_headers;        /* -h */
  87 static bfd_boolean dump_file_header;    /* -f */
  88 static int dump_symtab;                 /* -t */
  89 static int dump_dynamic_symtab;         /* -T */
  90 static int dump_reloc_info;             /* -r */
  91 static int dump_dynamic_reloc_info;     /* -R */
  92 static int dump_ar_hdrs;                /* -a */
  93 static int dump_private_headers;        /* -p */
  94 static char *dump_private_options;      /* -P */
  95 static int prefix_addresses;            /* --prefix-addresses */
  96 static int with_line_numbers;           /* -l */
  97 static bfd_boolean with_source_code;    /* -S */
  98 static int show_raw_insn;               /* --show-raw-insn */
  99 static int dump_dwarf_section_info;     /* --dwarf */
 100 static int dump_stab_section_info;      /* --stabs */
 101 static int do_demangle;                 /* -C, --demangle */
 102 static bfd_boolean disassemble;         /* -d */
 103 static bfd_boolean disassemble_all;     /* -D */
 104 static int disassemble_zeroes;          /* --disassemble-zeroes */
 105 static bfd_boolean formats_info;        /* -i */
 106 static int wide_output;                 /* -w */
 107 static int insn_width;                  /* --insn-width */
 108 static bfd_vma start_address = (bfd_vma) -1; /* --start-address */
 109 static bfd_vma stop_address = (bfd_vma) -1;  /* --stop-address */
 110 static int dump_debugging;              /* --debugging */
 111 static int dump_debugging_tags;         /* --debugging-tags */
 112 static int suppress_bfd_header;
 113 static int dump_special_syms = 0;       /* --special-syms */
 114 static bfd_vma adjust_section_vma = 0;  /* --adjust-vma */
 115 static int file_start_context = 0;      /* --file-start-context */
 116 static bfd_boolean display_file_offsets;/* -F */
 117 static const char *prefix;              /* --prefix */
 118 static int prefix_strip;                /* --prefix-strip */
 119 static size_t prefix_length;
 120
 121 /* A structure to record the sections mentioned in -j switches.  */
 122 struct only
 123 {
 124   const char * name; /* The name of the section.  */
 125   bfd_boolean  seen; /* A flag to indicate that the section has been found in one or more input files.  */
 126   struct only * next; /* Pointer to the next structure in the list.  */
 127 };
 128 /* Pointer to an array of 'only' structures.
 129    This pointer is NULL if the -j switch has not been used.  */
 130 static struct only * only_list = NULL;
 131
 132 /* Variables for handling include file path table.  */
 133 static const char **include_paths;
 134 static int include_path_count;
 135
 136 /* Extra info to pass to the section disassembler and address printing
 137    function.  */
 138 struct objdump_disasm_info
 139 {
 140   bfd *              abfd;
 141   asection *         sec;
 142   bfd_boolean        require_sec;
 143   arelent **         dynrelbuf;
 144   long               dynrelcount;
 145   disassembler_ftype disassemble_fn;
 146   arelent *          reloc;
 147 };
 148
 149 /* Architecture to disassemble for, or default if NULL.  */
 150 static char *machine = NULL;
 151
 152 /* Target specific options to the disassembler.  */
 153 static char *disassembler_options = NULL;
 154
 155 /* Endianness to disassemble for, or default if BFD_ENDIAN_UNKNOWN.  */
 156 static enum bfd_endian endian = BFD_ENDIAN_UNKNOWN;
 157
 158 /* The symbol table.  */
 159 static asymbol **syms;
 160
 161 /* Number of symbols in `syms'.  */
 162 static long symcount = 0;
 163
 164 /* The sorted symbol table.  */
 165 static asymbol **sorted_syms;
 166
 167 /* Number of symbols in `sorted_syms'.  */
 168 static long sorted_symcount = 0;
 169
 170 /* The dynamic symbol table.  */
 171 static asymbol **dynsyms;
 172
 173 /* The synthetic symbol table.  */
 174 static asymbol *synthsyms;
 175 static long synthcount = 0;
 176
 177 /* Number of symbols in `dynsyms'.  */
 178 static long dynsymcount = 0;
 179
 180 static bfd_byte *stabs;
 181 static bfd_size_type stab_size;
 182
 183 static char *strtab;
 184 static bfd_size_type stabstr_size;
 185
 186 static bfd_boolean is_relocatable = FALSE;
 187
 188 /* Handlers for -P/--private.  */
 189 static const struct objdump_private_desc * const objdump_private_vectors[] =
 190   {
 191     OBJDUMP_PRIVATE_VECTORS
 192     NULL
 193   };
 194 \f
 195 static void usage (FILE *, int) ATTRIBUTE_NORETURN;
 196 static void
 197 usage (FILE *stream, int status)
 198 {
 199   fprintf (stream, _("Usage: %s <option(s)> <file(s)>\n"), program_name);
 200   fprintf (stream, _(" Display information from object <file(s)>.\n"));
 201   fprintf (stream, _(" At least one of the following switches must be given:\n"));
 202   fprintf (stream, _("\
 203   -a, --archive-headers    Display archive header information\n\
 204   -f, --file-headers       Display the contents of the overall file header\n\
 205   -p, --private-headers    Display object format specific file header contents\n\
 206   -P, --private=OPT,OPT... Display object format specific contents\n\
 207   -h, --[section-]headers  Display the contents of the section headers\n\
 208   -x, --all-headers        Display the contents of all headers\n\
 209   -d, --disassemble        Display assembler contents of executable sections\n\
 210   -D, --disassemble-all    Display assembler contents of all sections\n\
 211   -S, --source             Intermix source code with disassembly\n\
 212   -s, --full-contents      Display the full contents of all sections requested\n\
 213   -g, --debugging          Display debug information in object file\n\
 214   -e, --debugging-tags     Display debug information using ctags style\n\
 215   -G, --stabs              Display (in raw form) any STABS info in the file\n\
 216   -W[lLiaprmfFsoRt] or\n\
 217   --dwarf[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
 218           =frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
 219           =gdb_index,=trace_info,=trace_abbrev,=trace_aranges,\n\
 220           =addr,=cu_index]\n\
 221                            Display DWARF info in the file\n\
 222   -t, --syms               Display the contents of the symbol table(s)\n\
 223   -T, --dynamic-syms       Display the contents of the dynamic symbol table\n\
 224   -r, --reloc              Display the relocation entries in the file\n\
 225   -R, --dynamic-reloc      Display the dynamic relocation entries in the file\n\
 226   @<file>                  Read options from <file>\n\
 227   -v, --version            Display this program's version number\n\
 228   -i, --info               List object formats and architectures supported\n\
 229   -H, --help               Display this information\n\
 230 "));
 231   if (status != 2)
 232     {
 233       const struct objdump_private_desc * const *desc;
 234
 235       fprintf (stream, _("\n The following switches are optional:\n"));
 236       fprintf (stream, _("\
 237   -b, --target=BFDNAME           Specify the target object format as BFDNAME\n\
 238   -m, --architecture=MACHINE     Specify the target architecture as MACHINE\n\
 239   -j, --section=NAME             Only display information for section NAME\n\
 240   -M, --disassembler-options=OPT Pass text OPT on to the disassembler\n\
 241   -EB --endian=big               Assume big endian format when disassembling\n\
 242   -EL --endian=little            Assume little endian format when disassembling\n\
 243       --file-start-context       Include context from start of file (with -S)\n\
 244   -I, --include=DIR              Add DIR to search list for source files\n\
 245   -l, --line-numbers             Include line numbers and filenames in output\n\
 246   -F, --file-offsets             Include file offsets when displaying information\n\
 247   -C, --demangle[=STYLE]         Decode mangled/processed symbol names\n\
 248                                   The STYLE, if specified, can be `auto', `gnu',\n\
 249                                   `lucid', `arm', `hp', `edg', `gnu-v3', `java'\n\
 250                                   or `gnat'\n\
 251   -w, --wide                     Format output for more than 80 columns\n\
 252   -z, --disassemble-zeroes       Do not skip blocks of zeroes when disassembling\n\
 253       --start-address=ADDR       Only process data whose address is >= ADDR\n\
 254       --stop-address=ADDR        Only process data whose address is <= ADDR\n\
 255       --prefix-addresses         Print complete address alongside disassembly\n\
 256       --[no-]show-raw-insn       Display hex alongside symbolic disassembly\n\
 257       --insn-width=WIDTH         Display WIDTH bytes on a single line for -d\n\
 258       --adjust-vma=OFFSET        Add OFFSET to all displayed section addresses\n\
 259       --special-syms             Include special symbols in symbol dumps\n\
 260       --prefix=PREFIX            Add PREFIX to absolute paths for -S\n\
 261       --prefix-strip=LEVEL       Strip initial directory names for -S\n"));
 262       fprintf (stream, _("\
 263       --dwarf-depth=N        Do not display DIEs at depth N or greater\n\
 264       --dwarf-start=N        Display DIEs starting with N, at the same depth\n\
 265                              or deeper\n\
 266       --dwarf-check          Make additional dwarf internal consistency checks.\
 267       \n\n"));
 268       list_supported_targets (program_name, stream);
 269       list_supported_architectures (program_name, stream);
 270
 271       disassembler_usage (stream);
 272
 273       if (objdump_private_vectors[0] != NULL)
 274         {
 275           fprintf (stream,
 276                    _("\nOptions supported for -P/--private switch:\n"));
 277           for (desc = objdump_private_vectors; *desc != NULL; desc++)
 278             (*desc)->help (stream);
 279         }
 280     }
 281   if (REPORT_BUGS_TO[0] && status == 0)
 282     fprintf (stream, _("Report bugs to %s.\n"), REPORT_BUGS_TO);
 283   exit (status);
 284 }
 285
 286 /* 150 isn't special; it's just an arbitrary non-ASCII char value.  */
 287 enum option_values
 288   {
 289     OPTION_ENDIAN=150,
 290     OPTION_START_ADDRESS,
 291     OPTION_STOP_ADDRESS,
 292     OPTION_DWARF,
 293     OPTION_PREFIX,
 294     OPTION_PREFIX_STRIP,
 295     OPTION_INSN_WIDTH,
 296     OPTION_ADJUST_VMA,
 297     OPTION_DWARF_DEPTH,
 298     OPTION_DWARF_CHECK,
 299     OPTION_DWARF_START
 300   };
 301
 302 static struct option long_options[]=
 303 {
 304   {"adjust-vma", required_argument, NULL, OPTION_ADJUST_VMA},
 305   {"all-headers", no_argument, NULL, 'x'},
 306   {"private-headers", no_argument, NULL, 'p'},
 307   {"private", required_argument, NULL, 'P'},
 308   {"architecture", required_argument, NULL, 'm'},
 309   {"archive-headers", no_argument, NULL, 'a'},
 310   {"debugging", no_argument, NULL, 'g'},
 311   {"debugging-tags", no_argument, NULL, 'e'},
 312   {"demangle", optional_argument, NULL, 'C'},
 313   {"disassemble", no_argument, NULL, 'd'},
 314   {"disassemble-all", no_argument, NULL, 'D'},
 315   {"disassembler-options", required_argument, NULL, 'M'},
 316   {"disassemble-zeroes", no_argument, NULL, 'z'},
 317   {"dynamic-reloc", no_argument, NULL, 'R'},
 318   {"dynamic-syms", no_argument, NULL, 'T'},
 319   {"endian", required_argument, NULL, OPTION_ENDIAN},
 320   {"file-headers", no_argument, NULL, 'f'},
 321   {"file-offsets", no_argument, NULL, 'F'},
 322   {"file-start-context", no_argument, &file_start_context, 1},
 323   {"full-contents", no_argument, NULL, 's'},
 324   {"headers", no_argument, NULL, 'h'},
 325   {"help", no_argument, NULL, 'H'},
 326   {"info", no_argument, NULL, 'i'},
 327   {"line-numbers", no_argument, NULL, 'l'},
 328   {"no-show-raw-insn", no_argument, &show_raw_insn, -1},
 329   {"prefix-addresses", no_argument, &prefix_addresses, 1},
 330   {"reloc", no_argument, NULL, 'r'},
 331   {"section", required_argument, NULL, 'j'},
 332   {"section-headers", no_argument, NULL, 'h'},
 333   {"show-raw-insn", no_argument, &show_raw_insn, 1},
 334   {"source", no_argument, NULL, 'S'},
 335   {"special-syms", no_argument, &dump_special_syms, 1},
 336   {"include", required_argument, NULL, 'I'},
 337   {"dwarf", optional_argument, NULL, OPTION_DWARF},
 338   {"stabs", no_argument, NULL, 'G'},
 339   {"start-address", required_argument, NULL, OPTION_START_ADDRESS},
 340   {"stop-address", required_argument, NULL, OPTION_STOP_ADDRESS},
 341   {"syms", no_argument, NULL, 't'},
 342   {"target", required_argument, NULL, 'b'},
 343   {"version", no_argument, NULL, 'V'},
 344   {"wide", no_argument, NULL, 'w'},
 345   {"prefix", required_argument, NULL, OPTION_PREFIX},
 346   {"prefix-strip", required_argument, NULL, OPTION_PREFIX_STRIP},
 347   {"insn-width", required_argument, NULL, OPTION_INSN_WIDTH},
 348   {"dwarf-depth",      required_argument, 0, OPTION_DWARF_DEPTH},
 349   {"dwarf-start",      required_argument, 0, OPTION_DWARF_START},
 350   {"dwarf-check",      no_argument, 0, OPTION_DWARF_CHECK},
 351   {0, no_argument, 0, 0}
 352 };
 353 \f
 354 static void
 355 nonfatal (const char *msg)
 356 {
 357   bfd_nonfatal (msg);
 358   exit_status = 1;
 359 }
 360 \f
 361 /* Returns TRUE if the specified section should be dumped.  */
 362
 363 static bfd_boolean
 364 process_section_p (asection * section)
 365 {
 366   struct only * only;
 367
 368   if (only_list == NULL)
 369     return TRUE;
 370
 371   for (only = only_list; only; only = only->next)
 372     if (strcmp (only->name, section->name) == 0)
 373       {
 374         only->seen = TRUE;
 375         return TRUE;
 376       }
 377
 378   return FALSE;
 379 }
 380
 381 /* Add an entry to the 'only' list.  */
 382
 383 static void
 384 add_only (char * name)
 385 {
 386   struct only * only;
 387
 388   /* First check to make sure that we do not
 389      already have an entry for this name.  */
 390   for (only = only_list; only; only = only->next)
 391     if (strcmp (only->name, name) == 0)
 392       return;
 393
 394   only = xmalloc (sizeof * only);
 395   only->name = name;
 396   only->seen = FALSE;
 397   only->next = only_list;
 398   only_list = only;
 399 }
 400
 401 /* Release the memory used by the 'only' list.
 402    PR 11225: Issue a warning message for unseen sections.
 403    Only do this if none of the sections were seen.  This is mainly to support
 404    tools like the GAS testsuite where an object file is dumped with a list of
 405    generic section names known to be present in a range of different file
 406    formats.  */
 407
 408 static void
 409 free_only_list (void)
 410 {
 411   bfd_boolean at_least_one_seen = FALSE;
 412   struct only * only;
 413   struct only * next;
 414
 415   if (only_list == NULL)
 416     return;
 417
 418   for (only = only_list; only; only = only->next)
 419     if (only->seen)
 420       {
 421         at_least_one_seen = TRUE;
 422         break;
 423       }
 424
 425   for (only = only_list; only; only = next)
 426     {
 427       if (! at_least_one_seen)
 428         {
 429           non_fatal (_("section '%s' mentioned in a -j option, "
 430                        "but not found in any input file"),
 431                      only->name);
 432           exit_status = 1;
 433         }
 434       next = only->next;
 435       free (only);
 436     }
 437 }
 438
 439 \f
 440 static void
 441 dump_section_header (bfd *abfd, asection *section,
 442                      void *ignored ATTRIBUTE_UNUSED)
 443 {
 444   char *comma = "";
 445   unsigned int opb = bfd_octets_per_byte (abfd);
 446
 447   /* Ignore linker created section.  See elfNN_ia64_object_p in
 448      bfd/elfxx-ia64.c.  */
 449   if (section->flags & SEC_LINKER_CREATED)
 450     return;
 451
 452   /* PR 10413: Skip sections that we are ignoring.  */
 453   if (! process_section_p (section))
 454     return;
 455
 456   printf ("%3d %-13s %08lx  ", section->index,
 457           bfd_get_section_name (abfd, section),
 458           (unsigned long) bfd_section_size (abfd, section) / opb);
 459   bfd_printf_vma (abfd, bfd_get_section_vma (abfd, section));
 460   printf ("  ");
 461   bfd_printf_vma (abfd, section->lma);
 462   printf ("  %08lx  2**%u", (unsigned long) section->filepos,
 463           bfd_get_section_alignment (abfd, section));
 464   if (! wide_output)
 465     printf ("\n                ");
 466   printf ("  ");
 467
 468 #define PF(x, y) \
 469   if (section->flags & x) { printf ("%s%s", comma, y); comma = ", "; }
 470
 471   PF (SEC_HAS_CONTENTS, "CONTENTS");
 472   PF (SEC_ALLOC, "ALLOC");
 473   PF (SEC_CONSTRUCTOR, "CONSTRUCTOR");
 474   PF (SEC_LOAD, "LOAD");
 475   PF (SEC_RELOC, "RELOC");
 476   PF (SEC_READONLY, "READONLY");
 477   PF (SEC_CODE, "CODE");
 478   PF (SEC_DATA, "DATA");
 479   PF (SEC_ROM, "ROM");
 480   PF (SEC_DEBUGGING, "DEBUGGING");
 481   PF (SEC_NEVER_LOAD, "NEVER_LOAD");
 482   PF (SEC_EXCLUDE, "EXCLUDE");
 483   PF (SEC_SORT_ENTRIES, "SORT_ENTRIES");
 484   if (bfd_get_arch (abfd) == bfd_arch_tic54x)
 485     {
 486       PF (SEC_TIC54X_BLOCK, "BLOCK");
 487       PF (SEC_TIC54X_CLINK, "CLINK");
 488     }
 489   PF (SEC_SMALL_DATA, "SMALL_DATA");
 490   if (bfd_get_flavour (abfd) == bfd_target_coff_flavour)
 491     {
 492       PF (SEC_COFF_SHARED, "SHARED");
 493       PF (SEC_COFF_NOREAD, "NOREAD");
 494     }
 495   else if (bfd_get_flavour (abfd) == bfd_target_elf_flavour)
 496     PF (SEC_ELF_PURECODE, "PURECODE");
 497   PF (SEC_THREAD_LOCAL, "THREAD_LOCAL");
 498   PF (SEC_GROUP, "GROUP");
 499   if (bfd_get_arch (abfd) == bfd_arch_mep)
 500     {
 501       PF (SEC_MEP_VLIW, "VLIW");
 502     }
 503
 504   if ((section->flags & SEC_LINK_ONCE) != 0)
 505     {
 506       const char *ls;
 507       struct coff_comdat_info *comdat;
 508
 509       switch (section->flags & SEC_LINK_DUPLICATES)
 510         {
 511         default:
 512           abort ();
 513         case SEC_LINK_DUPLICATES_DISCARD:
 514           ls = "LINK_ONCE_DISCARD";
 515           break;
 516         case SEC_LINK_DUPLICATES_ONE_ONLY:
 517           ls = "LINK_ONCE_ONE_ONLY";
 518           break;
 519         case SEC_LINK_DUPLICATES_SAME_SIZE:
 520           ls = "LINK_ONCE_SAME_SIZE";
 521           break;
 522         case SEC_LINK_DUPLICATES_SAME_CONTENTS:
 523           ls = "LINK_ONCE_SAME_CONTENTS";
 524           break;
 525         }
 526       printf ("%s%s", comma, ls);
 527
 528       comdat = bfd_coff_get_comdat_section (abfd, section);
 529       if (comdat != NULL)
 530         printf (" (COMDAT %s %ld)", comdat->name, comdat->symbol);
 531
 532       comma = ", ";
 533     }
 534
 535   printf ("\n");
 536 #undef PF
 537 }
 538
 539 static void
 540 dump_headers (bfd *abfd)
 541 {
 542   printf (_("Sections:\n"));
 543
 544 #ifndef BFD64
 545   printf (_("Idx Name          Size      VMA       LMA       File off  Algn"));
 546 #else
 547   /* With BFD64, non-ELF returns -1 and wants always 64 bit addresses.  */
 548   if (bfd_get_arch_size (abfd) == 32)
 549     printf (_("Idx Name          Size      VMA       LMA       File off  Algn"));
 550   else
 551     printf (_("Idx Name          Size      VMA               LMA               File off  Algn"));
 552 #endif
 553
 554   if (wide_output)
 555     printf (_("  Flags"));
 556   printf ("\n");
 557
 558   bfd_map_over_sections (abfd, dump_section_header, NULL);
 559 }
 560 \f
 561 static asymbol **
 562 slurp_symtab (bfd *abfd)
 563 {
 564   asymbol **sy = NULL;
 565   long storage;
 566
 567   if (!(bfd_get_file_flags (abfd) & HAS_SYMS))
 568     {
 569       symcount = 0;
 570       return NULL;
 571     }
 572
 573   storage = bfd_get_symtab_upper_bound (abfd);
 574   if (storage < 0)
 575     {
 576       non_fatal (_("failed to read symbol table from: %s"), bfd_get_filename (abfd));
 577       bfd_fatal (_("error message was"));
 578     }
 579   if (storage)
 580     sy = (asymbol **) xmalloc (storage);
 581
 582   symcount = bfd_canonicalize_symtab (abfd, sy);
 583   if (symcount < 0)
 584     bfd_fatal (bfd_get_filename (abfd));
 585   return sy;
 586 }
 587
 588 /* Read in the dynamic symbols.  */
 589
 590 static asymbol **
 591 slurp_dynamic_symtab (bfd *abfd)
 592 {
 593   asymbol **sy = NULL;
 594   long storage;
 595
 596   storage = bfd_get_dynamic_symtab_upper_bound (abfd);
 597   if (storage < 0)
 598     {
 599       if (!(bfd_get_file_flags (abfd) & DYNAMIC))
 600         {
 601           non_fatal (_("%s: not a dynamic object"), bfd_get_filename (abfd));
 602           exit_status = 1;
 603           dynsymcount = 0;
 604           return NULL;
 605         }
 606
 607       bfd_fatal (bfd_get_filename (abfd));
 608     }
 609   if (storage)
 610     sy = (asymbol **) xmalloc (storage);
 611
 612   dynsymcount = bfd_canonicalize_dynamic_symtab (abfd, sy);
 613   if (dynsymcount < 0)
 614     bfd_fatal (bfd_get_filename (abfd));
 615   return sy;
 616 }
 617
 618 /* Some symbol names are significant and should be kept in the
 619    table of sorted symbol names, even if they are marked as
 620    debugging/section symbols.  */
 621
 622 static bfd_boolean
 623 is_significant_symbol_name (const char * name)
 624 {
 625   return strcmp (name, ".plt") == 0
 626     ||   strcmp (name, ".got") == 0
 627     ||   strcmp (name, ".plt.got") == 0;
 628 }
 629
 630 /* Filter out (in place) symbols that are useless for disassembly.
 631    COUNT is the number of elements in SYMBOLS.
 632    Return the number of useful symbols.  */
 633
 634 static long
 635 remove_useless_symbols (asymbol **symbols, long count)
 636 {
 637   asymbol **in_ptr = symbols, **out_ptr = symbols;
 638
 639   while (--count >= 0)
 640     {
 641       asymbol *sym = *in_ptr++;
 642
 643       if (sym->name == NULL || sym->name[0] == '\0')
 644         continue;
 645       if ((sym->flags & (BSF_DEBUGGING | BSF_SECTION_SYM))
 646           && ! is_significant_symbol_name (sym->name))
 647         continue;
 648       if (bfd_is_und_section (sym->section)
 649           || bfd_is_com_section (sym->section))
 650         continue;
 651
 652       *out_ptr++ = sym;
 653     }
 654   return out_ptr - symbols;
 655 }
 656
 657 /* Sort symbols into value order.  */
 658
 659 static int
 660 compare_symbols (const void *ap, const void *bp)
 661 {
 662   const asymbol *a = * (const asymbol **) ap;
 663   const asymbol *b = * (const asymbol **) bp;
 664   const char *an;
 665   const char *bn;
 666   size_t anl;
 667   size_t bnl;
 668   bfd_boolean af;
 669   bfd_boolean bf;
 670   flagword aflags;
 671   flagword bflags;
 672
 673   if (bfd_asymbol_value (a) > bfd_asymbol_value (b))
 674     return 1;
 675   else if (bfd_asymbol_value (a) < bfd_asymbol_value (b))
 676     return -1;
 677
 678   if (a->section > b->section)
 679     return 1;
 680   else if (a->section < b->section)
 681     return -1;
 682
 683   an = bfd_asymbol_name (a);
 684   bn = bfd_asymbol_name (b);
 685   anl = strlen (an);
 686   bnl = strlen (bn);
 687
 688   /* The symbols gnu_compiled and gcc2_compiled convey no real
 689      information, so put them after other symbols with the same value.  */
 690   af = (strstr (an, "gnu_compiled") != NULL
 691         || strstr (an, "gcc2_compiled") != NULL);
 692   bf = (strstr (bn, "gnu_compiled") != NULL
 693         || strstr (bn, "gcc2_compiled") != NULL);
 694
 695   if (af && ! bf)
 696     return 1;
 697   if (! af && bf)
 698     return -1;
 699
 700   /* We use a heuristic for the file name, to try to sort it after
 701      more useful symbols.  It may not work on non Unix systems, but it
 702      doesn't really matter; the only difference is precisely which
 703      symbol names get printed.  */
 704
 705 #define file_symbol(s, sn, snl)                 \
 706   (((s)->flags & BSF_FILE) != 0                 \
 707    || ((sn)[(snl) - 2] == '.'                   \
 708        && ((sn)[(snl) - 1] == 'o'               \
 709            || (sn)[(snl) - 1] == 'a')))
 710
 711   af = file_symbol (a, an, anl);
 712   bf = file_symbol (b, bn, bnl);
 713
 714   if (af && ! bf)
 715     return 1;
 716   if (! af && bf)
 717     return -1;
 718
 719   /* Try to sort global symbols before local symbols before function
 720      symbols before debugging symbols.  */
 721
 722   aflags = a->flags;
 723   bflags = b->flags;
 724
 725   if ((aflags & BSF_DEBUGGING) != (bflags & BSF_DEBUGGING))
 726     {
 727       if ((aflags & BSF_DEBUGGING) != 0)
 728         return 1;
 729       else
 730         return -1;
 731     }
 732   if ((aflags & BSF_FUNCTION) != (bflags & BSF_FUNCTION))
 733     {
 734       if ((aflags & BSF_FUNCTION) != 0)
 735         return -1;
 736       else
 737         return 1;
 738     }
 739   if ((aflags & BSF_LOCAL) != (bflags & BSF_LOCAL))
 740     {
 741       if ((aflags & BSF_LOCAL) != 0)
 742         return 1;
 743       else
 744         return -1;
 745     }
 746   if ((aflags & BSF_GLOBAL) != (bflags & BSF_GLOBAL))
 747     {
 748       if ((aflags & BSF_GLOBAL) != 0)
 749         return -1;
 750       else
 751         return 1;
 752     }
 753
 754   if (bfd_get_flavour (bfd_asymbol_bfd (a)) == bfd_target_elf_flavour
 755       && bfd_get_flavour (bfd_asymbol_bfd (b)) == bfd_target_elf_flavour)
 756     {
 757       bfd_vma asz, bsz;
 758
 759       asz = 0;
 760       if ((a->flags & BSF_SYNTHETIC) == 0)
 761         asz = ((elf_symbol_type *) a)->internal_elf_sym.st_size;
 762       bsz = 0;
 763       if ((b->flags & BSF_SYNTHETIC) == 0)
 764         bsz = ((elf_symbol_type *) b)->internal_elf_sym.st_size;
 765       if (asz != bsz)
 766         return asz > bsz ? -1 : 1;
 767     }
 768
 769   /* Symbols that start with '.' might be section names, so sort them
 770      after symbols that don't start with '.'.  */
 771   if (an[0] == '.' && bn[0] != '.')
 772     return 1;
 773   if (an[0] != '.' && bn[0] == '.')
 774     return -1;
 775
 776   /* Finally, if we can't distinguish them in any other way, try to
 777      get consistent results by sorting the symbols by name.  */
 778   return strcmp (an, bn);
 779 }
 780
 781 /* Sort relocs into address order.  */
 782
 783 static int
 784 compare_relocs (const void *ap, const void *bp)
 785 {
 786   const arelent *a = * (const arelent **) ap;
 787   const arelent *b = * (const arelent **) bp;
 788
 789   if (a->address > b->address)
 790     return 1;
 791   else if (a->address < b->address)
 792     return -1;
 793
 794   /* So that associated relocations tied to the same address show up
 795      in the correct order, we don't do any further sorting.  */
 796   if (a > b)
 797     return 1;
 798   else if (a < b)
 799     return -1;
 800   else
 801     return 0;
 802 }
 803
 804 /* Print an address (VMA) to the output stream in INFO.
 805    If SKIP_ZEROES is TRUE, omit leading zeroes.  */
 806
 807 static void
 808 objdump_print_value (bfd_vma vma, struct disassemble_info *inf,
 809                      bfd_boolean skip_zeroes)
 810 {
 811   char buf[30];
 812   char *p;
 813   struct objdump_disasm_info *aux;
 814
 815   aux = (struct objdump_disasm_info *) inf->application_data;
 816   bfd_sprintf_vma (aux->abfd, buf, vma);
 817   if (! skip_zeroes)
 818     p = buf;
 819   else
 820     {
 821       for (p = buf; *p == '0'; ++p)
 822         ;
 823       if (*p == '\0')
 824         --p;
 825     }
 826   (*inf->fprintf_func) (inf->stream, "%s", p);
 827 }
 828
 829 /* Print the name of a symbol.  */
 830
 831 static void
 832 objdump_print_symname (bfd *abfd, struct disassemble_info *inf,
 833                        asymbol *sym)
 834 {
 835   char *alloc;
 836   const char *name, *version_string = NULL;
 837   bfd_boolean hidden = FALSE;
 838
 839   alloc = NULL;
 840   name = bfd_asymbol_name (sym);
 841   if (do_demangle && name[0] != '\0')
 842     {
 843       /* Demangle the name.  */
 844       alloc = bfd_demangle (abfd, name, DMGL_ANSI | DMGL_PARAMS);
 845       if (alloc != NULL)
 846         name = alloc;
 847     }
 848
 849   if ((sym->flags & BSF_SYNTHETIC) == 0)
 850     version_string = bfd_get_symbol_version_string (abfd, sym, &hidden);
 851
 852   if (bfd_is_und_section (bfd_get_section (sym)))
 853     hidden = TRUE;
 854
 855   if (inf != NULL)
 856     {
 857       (*inf->fprintf_func) (inf->stream, "%s", name);
 858       if (version_string && *version_string != '\0')
 859         (*inf->fprintf_func) (inf->stream, hidden ? "@%s" : "@@%s",
 860                               version_string);
 861     }
 862   else
 863     {
 864       printf ("%s", name);
 865       if (version_string && *version_string != '\0')
 866         printf (hidden ? "@%s" : "@@%s", version_string);
 867     }
 868
 869   if (alloc != NULL)
 870     free (alloc);
 871 }
 872
 873 /* Locate a symbol given a bfd and a section (from INFO->application_data),
 874    and a VMA.  If INFO->application_data->require_sec is TRUE, then always
 875    require the symbol to be in the section.  Returns NULL if there is no
 876    suitable symbol.  If PLACE is not NULL, then *PLACE is set to the index
 877    of the symbol in sorted_syms.  */
 878
 879 static asymbol *
 880 find_symbol_for_address (bfd_vma vma,
 881                          struct disassemble_info *inf,
 882                          long *place)
 883 {
 884   /* @@ Would it speed things up to cache the last two symbols returned,
 885      and maybe their address ranges?  For many processors, only one memory
 886      operand can be present at a time, so the 2-entry cache wouldn't be
 887      constantly churned by code doing heavy memory accesses.  */
 888
 889   /* Indices in `sorted_syms'.  */
 890   long min = 0;
 891   long max_count = sorted_symcount;
 892   long thisplace;
 893   struct objdump_disasm_info *aux;
 894   bfd *abfd;
 895   asection *sec;
 896   unsigned int opb;
 897   bfd_boolean want_section;
 898
 899   if (sorted_symcount < 1)
 900     return NULL;
 901
 902   aux = (struct objdump_disasm_info *) inf->application_data;
 903   abfd = aux->abfd;
 904   sec = aux->sec;
 905   opb = inf->octets_per_byte;
 906
 907   /* Perform a binary search looking for the closest symbol to the
 908      required value.  We are searching the range (min, max_count].  */
 909   while (min + 1 < max_count)
 910     {
 911       asymbol *sym;
 912
 913       thisplace = (max_count + min) / 2;
 914       sym = sorted_syms[thisplace];
 915
 916       if (bfd_asymbol_value (sym) > vma)
 917         max_count = thisplace;
 918       else if (bfd_asymbol_value (sym) < vma)
 919         min = thisplace;
 920       else
 921         {
 922           min = thisplace;
 923           break;
 924         }
 925     }
 926
 927   /* The symbol we want is now in min, the low end of the range we
 928      were searching.  If there are several symbols with the same
 929      value, we want the first (non-section/non-debugging) one.  */
 930   thisplace = min;
 931   while (thisplace > 0
 932          && (bfd_asymbol_value (sorted_syms[thisplace])
 933              == bfd_asymbol_value (sorted_syms[thisplace - 1]))
 934          && ((sorted_syms[thisplace - 1]->flags
 935               & (BSF_SECTION_SYM | BSF_DEBUGGING)) == 0)
 936          )
 937     --thisplace;
 938
 939   /* Prefer a symbol in the current section if we have multple symbols
 940      with the same value, as can occur with overlays or zero size
 941      sections.  */
 942   min = thisplace;
 943   while (min < max_count
 944          && (bfd_asymbol_value (sorted_syms[min])
 945              == bfd_asymbol_value (sorted_syms[thisplace])))
 946     {
 947       if (sorted_syms[min]->section == sec
 948           && inf->symbol_is_valid (sorted_syms[min], inf))
 949         {
 950           thisplace = min;
 951
 952           if (place != NULL)
 953             *place = thisplace;
 954
 955           return sorted_syms[thisplace];
 956         }
 957       ++min;
 958     }
 959
 960   /* If the file is relocatable, and the symbol could be from this
 961      section, prefer a symbol from this section over symbols from
 962      others, even if the other symbol's value might be closer.
 963
 964      Note that this may be wrong for some symbol references if the
 965      sections have overlapping memory ranges, but in that case there's
 966      no way to tell what's desired without looking at the relocation
 967      table.
 968
 969      Also give the target a chance to reject symbols.  */
 970   want_section = (aux->require_sec
 971                   || ((abfd->flags & HAS_RELOC) != 0
 972                       && vma >= bfd_get_section_vma (abfd, sec)
 973                       && vma < (bfd_get_section_vma (abfd, sec)
 974                                 + bfd_section_size (abfd, sec) / opb)));
 975   if ((sorted_syms[thisplace]->section != sec && want_section)
 976       || ! inf->symbol_is_valid (sorted_syms[thisplace], inf))
 977     {
 978       long i;
 979       long newplace = sorted_symcount;
 980
 981       for (i = min - 1; i >= 0; i--)
 982         {
 983           if ((sorted_syms[i]->section == sec || !want_section)
 984               && inf->symbol_is_valid (sorted_syms[i], inf))
 985             {
 986               if (newplace == sorted_symcount)
 987                 newplace = i;
 988
 989               if (bfd_asymbol_value (sorted_syms[i])
 990                   != bfd_asymbol_value (sorted_syms[newplace]))
 991                 break;
 992
 993               /* Remember this symbol and keep searching until we reach
 994                  an earlier address.  */
 995               newplace = i;
 996             }
 997         }
 998
 999       if (newplace != sorted_symcount)
1000         thisplace = newplace;
1001       else
1002         {
1003           /* We didn't find a good symbol with a smaller value.
1004              Look for one with a larger value.  */
1005           for (i = thisplace + 1; i < sorted_symcount; i++)
1006             {
1007               if ((sorted_syms[i]->section == sec || !want_section)
1008                   && inf->symbol_is_valid (sorted_syms[i], inf))
1009                 {
1010                   thisplace = i;
1011                   break;
1012                 }
1013             }
1014         }
1015
1016       if ((sorted_syms[thisplace]->section != sec && want_section)
1017           || ! inf->symbol_is_valid (sorted_syms[thisplace], inf))
1018         /* There is no suitable symbol.  */
1019         return NULL;
1020     }
1021
1022   /* If we have not found an exact match for the specified address
1023      and we have dynamic relocations available, then we can produce
1024      a better result by matching a relocation to the address and
1025      using the symbol associated with that relocation.  */
1026   if (!want_section
1027       && aux->dynrelbuf != NULL
1028       && sorted_syms[thisplace]->value != vma
1029       /* If we have matched a synthetic symbol, then stick with that.  */
1030       && (sorted_syms[thisplace]->flags & BSF_SYNTHETIC) == 0)
1031     {
1032       long        rel_count;
1033       arelent **  rel_pp;
1034
1035       for (rel_count = aux->dynrelcount, rel_pp = aux->dynrelbuf;
1036            rel_count--;)
1037         {
1038           arelent * rel = rel_pp[rel_count];
1039
1040           if (rel->address == vma
1041               && rel->sym_ptr_ptr != NULL
1042               /* Absolute relocations do not provide a more helpful symbolic address.  */
1043               && ! bfd_is_abs_section ((* rel->sym_ptr_ptr)->section))
1044             {
1045               if (place != NULL)
1046                 * place = thisplace;
1047               return * rel->sym_ptr_ptr;
1048             }
1049
1050           /* We are scanning backwards, so if we go below the target address
1051              we have failed.  */
1052           if (rel_pp[rel_count]->address < vma)
1053             break;
1054         }
1055     }
1056
1057   if (place != NULL)
1058     *place = thisplace;
1059
1060   return sorted_syms[thisplace];
1061 }
1062
1063 /* Print an address and the offset to the nearest symbol.  */
1064
1065 static void
1066 objdump_print_addr_with_sym (bfd *abfd, asection *sec, asymbol *sym,
1067                              bfd_vma vma, struct disassemble_info *inf,
1068                              bfd_boolean skip_zeroes)
1069 {
1070   objdump_print_value (vma, inf, skip_zeroes);
1071
1072   if (sym == NULL)
1073     {
1074       bfd_vma secaddr;
1075
1076       (*inf->fprintf_func) (inf->stream, " <%s",
1077                             bfd_get_section_name (abfd, sec));
1078       secaddr = bfd_get_section_vma (abfd, sec);
1079       if (vma < secaddr)
1080         {
1081           (*inf->fprintf_func) (inf->stream, "-0x");
1082           objdump_print_value (secaddr - vma, inf, TRUE);
1083         }
1084       else if (vma > secaddr)
1085         {
1086           (*inf->fprintf_func) (inf->stream, "+0x");
1087           objdump_print_value (vma - secaddr, inf, TRUE);
1088         }
1089       (*inf->fprintf_func) (inf->stream, ">");
1090     }
1091   else
1092     {
1093       (*inf->fprintf_func) (inf->stream, " <");
1094
1095       objdump_print_symname (abfd, inf, sym);
1096
1097       if (bfd_asymbol_value (sym) == vma)
1098         ;
1099       /* Undefined symbols in an executables and dynamic objects do not have
1100          a value associated with them, so it does not make sense to display
1101          an offset relative to them.  Normally we would not be provided with
1102          this kind of symbol, but the target backend might choose to do so,
1103          and the code in find_symbol_for_address might return an as yet
1104          unresolved symbol associated with a dynamic reloc.  */
1105       else if ((bfd_get_file_flags (abfd) & (EXEC_P | DYNAMIC))
1106                && bfd_is_und_section (sym->section))
1107         ;
1108       else if (bfd_asymbol_value (sym) > vma)
1109         {
1110           (*inf->fprintf_func) (inf->stream, "-0x");
1111           objdump_print_value (bfd_asymbol_value (sym) - vma, inf, TRUE);
1112         }
1113       else if (vma > bfd_asymbol_value (sym))
1114         {
1115           (*inf->fprintf_func) (inf->stream, "+0x");
1116           objdump_print_value (vma - bfd_asymbol_value (sym), inf, TRUE);
1117         }
1118
1119       (*inf->fprintf_func) (inf->stream, ">");
1120     }
1121
1122   if (display_file_offsets)
1123     inf->fprintf_func (inf->stream, _(" (File Offset: 0x%lx)"),
1124                         (long int)(sec->filepos + (vma - sec->vma)));
1125 }
1126
1127 /* Print an address (VMA), symbolically if possible.
1128    If SKIP_ZEROES is TRUE, don't output leading zeroes.  */
1129
1130 static void
1131 objdump_print_addr (bfd_vma vma,
1132                     struct disassemble_info *inf,
1133                     bfd_boolean skip_zeroes)
1134 {
1135   struct objdump_disasm_info *aux;
1136   asymbol *sym = NULL;
1137   bfd_boolean skip_find = FALSE;
1138
1139   aux = (struct objdump_disasm_info *) inf->application_data;
1140
1141   if (sorted_symcount < 1)
1142     {
1143       (*inf->fprintf_func) (inf->stream, "0x");
1144       objdump_print_value (vma, inf, skip_zeroes);
1145
1146       if (display_file_offsets)
1147         inf->fprintf_func (inf->stream, _(" (File Offset: 0x%lx)"),
1148                            (long int)(aux->sec->filepos + (vma - aux->sec->vma)));
1149       return;
1150     }
1151
1152   if (aux->reloc != NULL
1153       && aux->reloc->sym_ptr_ptr != NULL
1154       && * aux->reloc->sym_ptr_ptr != NULL)
1155     {
1156       sym = * aux->reloc->sym_ptr_ptr;
1157
1158       /* Adjust the vma to the reloc.  */
1159       vma += bfd_asymbol_value (sym);
1160
1161       if (bfd_is_und_section (bfd_get_section (sym)))
1162         skip_find = TRUE;
1163     }
1164
1165   if (!skip_find)
1166     sym = find_symbol_for_address (vma, inf, NULL);
1167
1168   objdump_print_addr_with_sym (aux->abfd, aux->sec, sym, vma, inf,
1169                                skip_zeroes);
1170 }
1171
1172 /* Print VMA to INFO.  This function is passed to the disassembler
1173    routine.  */
1174
1175 static void
1176 objdump_print_address (bfd_vma vma, struct disassemble_info *inf)
1177 {
1178   objdump_print_addr (vma, inf, ! prefix_addresses);
1179 }
1180
1181 /* Determine if the given address has a symbol associated with it.  */
1182
1183 static int
1184 objdump_symbol_at_address (bfd_vma vma, struct disassemble_info * inf)
1185 {
1186   asymbol * sym;
1187
1188   sym = find_symbol_for_address (vma, inf, NULL);
1189
1190   return (sym != NULL && (bfd_asymbol_value (sym) == vma));
1191 }
1192
1193 /* Hold the last function name and the last line number we displayed
1194    in a disassembly.  */
1195
1196 static char *prev_functionname;
1197 static unsigned int prev_line;
1198 static unsigned int prev_discriminator;
1199
1200 /* We keep a list of all files that we have seen when doing a
1201    disassembly with source, so that we know how much of the file to
1202    display.  This can be important for inlined functions.  */
1203
1204 struct print_file_list
1205 {
1206   struct print_file_list *next;
1207   const char *filename;
1208   const char *modname;
1209   const char *map;
1210   size_t mapsize;
1211   const char **linemap;
1212   unsigned maxline;
1213   unsigned last_line;
1214   unsigned max_printed;
1215   int first;
1216 };
1217
1218 static struct print_file_list *print_files;
1219
1220 /* The number of preceding context lines to show when we start
1221    displaying a file for the first time.  */
1222
1223 #define SHOW_PRECEDING_CONTEXT_LINES (5)
1224
1225 /* Read a complete file into memory.  */
1226
1227 static const char *
1228 slurp_file (const char *fn, size_t *size)
1229 {
1230 #ifdef HAVE_MMAP
1231   int ps = getpagesize ();
1232   size_t msize;
1233 #endif
1234   const char *map;
1235   struct stat st;
1236   int fd = open (fn, O_RDONLY | O_BINARY);
1237
1238   if (fd < 0)
1239     return NULL;
1240   if (fstat (fd, &st) < 0)
1241     {
1242       close (fd);
1243       return NULL;
1244     }
1245   *size = st.st_size;
1246 #ifdef HAVE_MMAP
1247   msize = (*size + ps - 1) & ~(ps - 1);
1248   map = mmap (NULL, msize, PROT_READ, MAP_SHARED, fd, 0);
1249   if (map != (char *) -1L)
1250     {
1251       close (fd);
1252       return map;
1253     }
1254 #endif
1255   map = (const char *) malloc (*size);
1256   if (!map || (size_t) read (fd, (char *) map, *size) != *size)
1257     {
1258       free ((void *) map);
1259       map = NULL;
1260     }
1261   close (fd);
1262   return map;
1263 }
1264
1265 #define line_map_decrease 5
1266
1267 /* Precompute array of lines for a mapped file. */
1268
1269 static const char **
1270 index_file (const char *map, size_t size, unsigned int *maxline)
1271 {
1272   const char *p, *lstart, *end;
1273   int chars_per_line = 45; /* First iteration will use 40.  */
1274   unsigned int lineno;
1275   const char **linemap = NULL;
1276   unsigned long line_map_size = 0;
1277
1278   lineno = 0;
1279   lstart = map;
1280   end = map + size;
1281
1282   for (p = map; p < end; p++)
1283     {
1284       if (*p == '\n')
1285         {
1286           if (p + 1 < end && p[1] == '\r')
1287             p++;
1288         }
1289       else if (*p == '\r')
1290         {
1291           if (p + 1 < end && p[1] == '\n')
1292             p++;
1293         }
1294       else
1295         continue;
1296
1297       /* End of line found.  */
1298
1299       if (linemap == NULL || line_map_size < lineno + 1)
1300         {
1301           unsigned long newsize;
1302
1303           chars_per_line -= line_map_decrease;
1304           if (chars_per_line <= 1)
1305             chars_per_line = 1;
1306           line_map_size = size / chars_per_line + 1;
1307           if (line_map_size < lineno + 1)
1308             line_map_size = lineno + 1;
1309           newsize = line_map_size * sizeof (char *);
1310           linemap = (const char **) xrealloc (linemap, newsize);
1311         }
1312
1313       linemap[lineno++] = lstart;
1314       lstart = p + 1;
1315     }
1316
1317   *maxline = lineno;
1318   return linemap;
1319 }
1320
1321 /* Tries to open MODNAME, and if successful adds a node to print_files
1322    linked list and returns that node.  Returns NULL on failure.  */
1323
1324 static struct print_file_list *
1325 try_print_file_open (const char *origname, const char *modname)
1326 {
1327   struct print_file_list *p;
1328
1329   p = (struct print_file_list *) xmalloc (sizeof (struct print_file_list));
1330
1331   p->map = slurp_file (modname, &p->mapsize);
1332   if (p->map == NULL)
1333     {
1334       free (p);
1335       return NULL;
1336     }
1337
1338   p->linemap = index_file (p->map, p->mapsize, &p->maxline);
1339   p->last_line = 0;
1340   p->max_printed = 0;
1341   p->filename = origname;
1342   p->modname = modname;
1343   p->next = print_files;
1344   p->first = 1;
1345   print_files = p;
1346   return p;
1347 }
1348
1349 /* If the source file, as described in the symtab, is not found
1350    try to locate it in one of the paths specified with -I
1351    If found, add location to print_files linked list.  */
1352
1353 static struct print_file_list *
1354 update_source_path (const char *filename)
1355 {
1356   struct print_file_list *p;
1357   const char *fname;
1358   int i;
1359
1360   p = try_print_file_open (filename, filename);
1361   if (p != NULL)
1362     return p;
1363
1364   if (include_path_count == 0)
1365     return NULL;
1366
1367   /* Get the name of the file.  */
1368   fname = lbasename (filename);
1369
1370   /* If file exists under a new path, we need to add it to the list
1371      so that show_line knows about it.  */
1372   for (i = 0; i < include_path_count; i++)
1373     {
1374       char *modname = concat (include_paths[i], "/", fname, (const char *) 0);
1375
1376       p = try_print_file_open (filename, modname);
1377       if (p)
1378         return p;
1379
1380       free (modname);
1381     }
1382
1383   return NULL;
1384 }
1385
1386 /* Print a source file line.  */
1387
1388 static void
1389 print_line (struct print_file_list *p, unsigned int linenum)
1390 {
1391   const char *l;
1392   size_t len;
1393
1394   --linenum;
1395   if (linenum >= p->maxline)
1396     return;
1397   l = p->linemap [linenum];
1398   /* Test fwrite return value to quiet glibc warning.  */
1399   len = strcspn (l, "\n\r");
1400   if (len == 0 || fwrite (l, len, 1, stdout) == 1)
1401     putchar ('\n');
1402 }
1403
1404 /* Print a range of source code lines. */
1405
1406 static void
1407 dump_lines (struct print_file_list *p, unsigned int start, unsigned int end)
1408 {
1409   if (p->map == NULL)
1410     return;
1411   while (start <= end)
1412     {
1413       print_line (p, start);
1414       start++;
1415     }
1416 }
1417
1418 /* Show the line number, or the source line, in a disassembly
1419    listing.  */
1420
1421 static void
1422 show_line (bfd *abfd, asection *section, bfd_vma addr_offset)
1423 {
1424   const char *filename;
1425   const char *functionname;
1426   unsigned int linenumber;
1427   unsigned int discriminator;
1428   bfd_boolean reloc;
1429   char *path = NULL;
1430
1431   if (! with_line_numbers && ! with_source_code)
1432     return;
1433
1434   if (! bfd_find_nearest_line_discriminator (abfd, section, syms, addr_offset,
1435                                              &filename, &functionname,
1436                                              &linenumber, &discriminator))
1437     return;
1438
1439   if (filename != NULL && *filename == '\0')
1440     filename = NULL;
1441   if (functionname != NULL && *functionname == '\0')
1442     functionname = NULL;
1443
1444   if (filename
1445       && IS_ABSOLUTE_PATH (filename)
1446       && prefix)
1447     {
1448       char *path_up;
1449       const char *fname = filename;
1450
1451       path = xmalloc (prefix_length + PATH_MAX + 1);
1452
1453       if (prefix_length)
1454         memcpy (path, prefix, prefix_length);
1455       path_up = path + prefix_length;
1456
1457       /* Build relocated filename, stripping off leading directories
1458          from the initial filename if requested.  */
1459       if (prefix_strip > 0)
1460         {
1461           int level = 0;
1462           const char *s;
1463
1464           /* Skip selected directory levels.  */
1465           for (s = fname + 1; *s != '\0' && level < prefix_strip; s++)
1466             if (IS_DIR_SEPARATOR(*s))
1467               {
1468                 fname = s;
1469                 level++;
1470               }
1471         }
1472
1473       /* Update complete filename.  */
1474       strncpy (path_up, fname, PATH_MAX);
1475       path_up[PATH_MAX] = '\0';
1476
1477       filename = path;
1478       reloc = TRUE;
1479     }
1480   else
1481     reloc = FALSE;
1482
1483   if (with_line_numbers)
1484     {
1485       if (functionname != NULL
1486           && (prev_functionname == NULL
1487               || strcmp (functionname, prev_functionname) != 0))
1488         printf ("%s():\n", functionname);
1489       if (linenumber > 0 && (linenumber != prev_line ||
1490                              (discriminator != prev_discriminator)))
1491         {
1492           if (discriminator > 0)
1493             printf ("%s:%u (discriminator %u)\n", filename == NULL ? "???" : filename,
1494                     linenumber, discriminator);
1495           else
1496             printf ("%s:%u\n", filename == NULL ? "???" : filename, linenumber);
1497         }
1498     }
1499
1500   if (with_source_code
1501       && filename != NULL
1502       && linenumber > 0)
1503     {
1504       struct print_file_list **pp, *p;
1505       unsigned l;
1506
1507       for (pp = &print_files; *pp != NULL; pp = &(*pp)->next)
1508         if (filename_cmp ((*pp)->filename, filename) == 0)
1509           break;
1510       p = *pp;
1511
1512       if (p == NULL)
1513         {
1514           if (reloc)
1515             filename = xstrdup (filename);
1516           p = update_source_path (filename);
1517         }
1518
1519       if (p != NULL && linenumber != p->last_line)
1520         {
1521           if (file_start_context && p->first)
1522             l = 1;
1523           else
1524             {
1525               l = linenumber - SHOW_PRECEDING_CONTEXT_LINES;
1526               if (l >= linenumber)
1527                 l = 1;
1528               if (p->max_printed >= l)
1529                 {
1530                   if (p->max_printed < linenumber)
1531                     l = p->max_printed + 1;
1532                   else
1533                     l = linenumber;
1534                 }
1535             }
1536           dump_lines (p, l, linenumber);
1537           if (p->max_printed < linenumber)
1538             p->max_printed = linenumber;
1539           p->last_line = linenumber;
1540           p->first = 0;
1541         }
1542     }
1543
1544   if (functionname != NULL
1545       && (prev_functionname == NULL
1546           || strcmp (functionname, prev_functionname) != 0))
1547     {
1548       if (prev_functionname != NULL)
1549         free (prev_functionname);
1550       prev_functionname = (char *) xmalloc (strlen (functionname) + 1);
1551       strcpy (prev_functionname, functionname);
1552     }
1553
1554   if (linenumber > 0 && linenumber != prev_line)
1555     prev_line = linenumber;
1556
1557   if (discriminator != prev_discriminator)
1558     prev_discriminator = discriminator;
1559
1560   if (path)
1561     free (path);
1562 }
1563
1564 /* Pseudo FILE object for strings.  */
1565 typedef struct
1566 {
1567   char *buffer;
1568   size_t pos;
1569   size_t alloc;
1570 } SFILE;
1571
1572 /* sprintf to a "stream".  */
1573
1574 static int ATTRIBUTE_PRINTF_2
1575 objdump_sprintf (SFILE *f, const char *format, ...)
1576 {
1577   size_t n;
1578   va_list args;
1579
1580   while (1)
1581     {
1582       size_t space = f->alloc - f->pos;
1583
1584       va_start (args, format);
1585       n = vsnprintf (f->buffer + f->pos, space, format, args);
1586       va_end (args);
1587
1588       if (space > n)
1589         break;
1590
1591       f->alloc = (f->alloc + n) * 2;
1592       f->buffer = (char *) xrealloc (f->buffer, f->alloc);
1593     }
1594   f->pos += n;
1595
1596   return n;
1597 }
1598
1599 /* The number of zeroes we want to see before we start skipping them.
1600    The number is arbitrarily chosen.  */
1601
1602 #define DEFAULT_SKIP_ZEROES 8
1603
1604 /* The number of zeroes to skip at the end of a section.  If the
1605    number of zeroes at the end is between SKIP_ZEROES_AT_END and
1606    SKIP_ZEROES, they will be disassembled.  If there are fewer than
1607    SKIP_ZEROES_AT_END, they will be skipped.  This is a heuristic
1608    attempt to avoid disassembling zeroes inserted by section
1609    alignment.  */
1610
1611 #define DEFAULT_SKIP_ZEROES_AT_END 3
1612
1613 /* Disassemble some data in memory between given values.  */
1614
1615 static void
1616 disassemble_bytes (struct disassemble_info * inf,
1617                    disassembler_ftype        disassemble_fn,
1618                    bfd_boolean               insns,
1619                    bfd_byte *                data,
1620                    bfd_vma                   start_offset,
1621                    bfd_vma                   stop_offset,
1622                    bfd_vma                   rel_offset,
1623                    arelent ***               relppp,
1624                    arelent **                relppend)
1625 {
1626   struct objdump_disasm_info *aux;
1627   asection *section;
1628   int octets_per_line;
1629   int skip_addr_chars;
1630   bfd_vma addr_offset;
1631   unsigned int opb = inf->octets_per_byte;
1632   unsigned int skip_zeroes = inf->skip_zeroes;
1633   unsigned int skip_zeroes_at_end = inf->skip_zeroes_at_end;
1634   int octets = opb;
1635   SFILE sfile;
1636
1637   aux = (struct objdump_disasm_info *) inf->application_data;
1638   section = aux->sec;
1639
1640   sfile.alloc = 120;
1641   sfile.buffer = (char *) xmalloc (sfile.alloc);
1642   sfile.pos = 0;
1643
1644   if (insn_width)
1645     octets_per_line = insn_width;
1646   else if (insns)
1647     octets_per_line = 4;
1648   else
1649     octets_per_line = 16;
1650
1651   /* Figure out how many characters to skip at the start of an
1652      address, to make the disassembly look nicer.  We discard leading
1653      zeroes in chunks of 4, ensuring that there is always a leading
1654      zero remaining.  */
1655   skip_addr_chars = 0;
1656   if (! prefix_addresses)
1657     {
1658       char buf[30];
1659
1660       bfd_sprintf_vma (aux->abfd, buf, section->vma + section->size / opb);
1661
1662       while (buf[skip_addr_chars] == '0')
1663         ++skip_addr_chars;
1664
1665       /* Don't discard zeros on overflow.  */
1666       if (buf[skip_addr_chars] == '\0' && section->vma != 0)
1667         skip_addr_chars = 0;
1668
1669       if (skip_addr_chars != 0)
1670         skip_addr_chars = (skip_addr_chars - 1) & -4;
1671     }
1672
1673   inf->insn_info_valid = 0;
1674
1675   addr_offset = start_offset;
1676   while (addr_offset < stop_offset)
1677     {
1678       bfd_vma z;
1679       bfd_boolean need_nl = FALSE;
1680       int previous_octets;
1681
1682       /* Remember the length of the previous instruction.  */
1683       previous_octets = octets;
1684       octets = 0;
1685
1686       /* Make sure we don't use relocs from previous instructions.  */
1687       aux->reloc = NULL;
1688
1689       /* If we see more than SKIP_ZEROES octets of zeroes, we just
1690          print `...'.  */
1691       for (z = addr_offset * opb; z < stop_offset * opb; z++)
1692         if (data[z] != 0)
1693           break;
1694       if (! disassemble_zeroes
1695           && (inf->insn_info_valid == 0
1696               || inf->branch_delay_insns == 0)
1697           && (z - addr_offset * opb >= skip_zeroes
1698               || (z == stop_offset * opb &&
1699                   z - addr_offset * opb < skip_zeroes_at_end)))
1700         {
1701           /* If there are more nonzero octets to follow, we only skip
1702              zeroes in multiples of 4, to try to avoid running over
1703              the start of an instruction which happens to start with
1704              zero.  */
1705           if (z != stop_offset * opb)
1706             z = addr_offset * opb + ((z - addr_offset * opb) &~ 3);
1707
1708           octets = z - addr_offset * opb;
1709
1710           /* If we are going to display more data, and we are displaying
1711              file offsets, then tell the user how many zeroes we skip
1712              and the file offset from where we resume dumping.  */
1713           if (display_file_offsets && ((addr_offset + (octets / opb)) < stop_offset))
1714             printf ("\t... (skipping %d zeroes, resuming at file offset: 0x%lx)\n",
1715                     octets / opb,
1716                     (unsigned long) (section->filepos
1717                                      + (addr_offset + (octets / opb))));
1718           else
1719             printf ("\t...\n");
1720         }
1721       else
1722         {
1723           char buf[50];
1724           int bpc = 0;
1725           int pb = 0;
1726
1727           if (with_line_numbers || with_source_code)
1728             show_line (aux->abfd, section, addr_offset);
1729
1730           if (! prefix_addresses)
1731             {
1732               char *s;
1733
1734               bfd_sprintf_vma (aux->abfd, buf, section->vma + addr_offset);
1735               for (s = buf + skip_addr_chars; *s == '0'; s++)
1736                 *s = ' ';
1737               if (*s == '\0')
1738                 *--s = '0';
1739               printf ("%s:\t", buf + skip_addr_chars);
1740             }
1741           else
1742             {
1743               aux->require_sec = TRUE;
1744               objdump_print_address (section->vma + addr_offset, inf);
1745               aux->require_sec = FALSE;
1746               putchar (' ');
1747             }
1748
1749           if (insns)
1750             {
1751               sfile.pos = 0;
1752               inf->fprintf_func = (fprintf_ftype) objdump_sprintf;
1753               inf->stream = &sfile;
1754               inf->bytes_per_line = 0;
1755               inf->bytes_per_chunk = 0;
1756               inf->flags = disassemble_all ? DISASSEMBLE_DATA : 0;
1757               if (machine)
1758                 inf->flags |= USER_SPECIFIED_MACHINE_TYPE;
1759
1760               if (inf->disassembler_needs_relocs
1761                   && (bfd_get_file_flags (aux->abfd) & EXEC_P) == 0
1762                   && (bfd_get_file_flags (aux->abfd) & DYNAMIC) == 0
1763                   && *relppp < relppend)
1764                 {
1765                   bfd_signed_vma distance_to_rel;
1766
1767                   distance_to_rel = (**relppp)->address
1768                     - (rel_offset + addr_offset);
1769
1770                   /* Check to see if the current reloc is associated with
1771                      the instruction that we are about to disassemble.  */
1772                   if (distance_to_rel == 0
1773                       /* FIXME: This is wrong.  We are trying to catch
1774                          relocs that are addressed part way through the
1775                          current instruction, as might happen with a packed
1776                          VLIW instruction.  Unfortunately we do not know the
1777                          length of the current instruction since we have not
1778                          disassembled it yet.  Instead we take a guess based
1779                          upon the length of the previous instruction.  The
1780                          proper solution is to have a new target-specific
1781                          disassembler function which just returns the length
1782                          of an instruction at a given address without trying
1783                          to display its disassembly. */
1784                       || (distance_to_rel > 0
1785                           && distance_to_rel < (bfd_signed_vma) (previous_octets/ opb)))
1786                     {
1787                       inf->flags |= INSN_HAS_RELOC;
1788                       aux->reloc = **relppp;
1789                     }
1790                 }
1791
1792               if (! disassemble_all
1793                   && (section->flags & (SEC_CODE | SEC_HAS_CONTENTS))
1794                   == (SEC_CODE | SEC_HAS_CONTENTS))
1795                 /* Set a stop_vma so that the disassembler will not read
1796                    beyond the next symbol.  We assume that symbols appear on
1797                    the boundaries between instructions.  We only do this when
1798                    disassembling code of course, and when -D is in effect.  */
1799                 inf->stop_vma = section->vma + stop_offset;
1800
1801               octets = (*disassemble_fn) (section->vma + addr_offset, inf);
1802
1803               inf->stop_vma = 0;
1804               inf->fprintf_func = (fprintf_ftype) fprintf;
1805               inf->stream = stdout;
1806               if (insn_width == 0 && inf->bytes_per_line != 0)
1807                 octets_per_line = inf->bytes_per_line;
1808               if (octets < (int) opb)
1809                 {
1810                   if (sfile.pos)
1811                     printf ("%s\n", sfile.buffer);
1812                   if (octets >= 0)
1813                     {
1814                       non_fatal (_("disassemble_fn returned length %d"),
1815                                  octets);
1816                       exit_status = 1;
1817                     }
1818                   break;
1819                 }
1820             }
1821           else
1822             {
1823               bfd_vma j;
1824
1825               octets = octets_per_line;
1826               if (addr_offset + octets / opb > stop_offset)
1827                 octets = (stop_offset - addr_offset) * opb;
1828
1829               for (j = addr_offset * opb; j < addr_offset * opb + octets; ++j)
1830                 {
1831                   if (ISPRINT (data[j]))
1832                     buf[j - addr_offset * opb] = data[j];
1833                   else
1834                     buf[j - addr_offset * opb] = '.';
1835                 }
1836               buf[j - addr_offset * opb] = '\0';
1837             }
1838
1839           if (prefix_addresses
1840               ? show_raw_insn > 0
1841               : show_raw_insn >= 0)
1842             {
1843               bfd_vma j;
1844
1845               /* If ! prefix_addresses and ! wide_output, we print
1846                  octets_per_line octets per line.  */
1847               pb = octets;
1848               if (pb > octets_per_line && ! prefix_addresses && ! wide_output)
1849                 pb = octets_per_line;
1850
1851               if (inf->bytes_per_chunk)
1852                 bpc = inf->bytes_per_chunk;
1853               else
1854                 bpc = 1;
1855
1856               for (j = addr_offset * opb; j < addr_offset * opb + pb; j += bpc)
1857                 {
1858                   int k;
1859
1860                   if (bpc > 1 && inf->display_endian == BFD_ENDIAN_LITTLE)
1861                     {
1862                       for (k = bpc - 1; k >= 0; k--)
1863                         printf ("%02x", (unsigned) data[j + k]);
1864                       putchar (' ');
1865                     }
1866                   else
1867                     {
1868                       for (k = 0; k < bpc; k++)
1869                         printf ("%02x", (unsigned) data[j + k]);
1870                       putchar (' ');
1871                     }
1872                 }
1873
1874               for (; pb < octets_per_line; pb += bpc)
1875                 {
1876                   int k;
1877
1878                   for (k = 0; k < bpc; k++)
1879                     printf ("  ");
1880                   putchar (' ');
1881                 }
1882
1883               /* Separate raw data from instruction by extra space.  */
1884               if (insns)
1885                 putchar ('\t');
1886               else
1887                 printf ("    ");
1888             }
1889
1890           if (! insns)
1891             printf ("%s", buf);
1892           else if (sfile.pos)
1893             printf ("%s", sfile.buffer);
1894
1895           if (prefix_addresses
1896               ? show_raw_insn > 0
1897               : show_raw_insn >= 0)
1898             {
1899               while (pb < octets)
1900                 {
1901                   bfd_vma j;
1902                   char *s;
1903
1904                   putchar ('\n');
1905                   j = addr_offset * opb + pb;
1906
1907                   bfd_sprintf_vma (aux->abfd, buf, section->vma + j / opb);
1908                   for (s = buf + skip_addr_chars; *s == '0'; s++)
1909                     *s = ' ';
1910                   if (*s == '\0')
1911                     *--s = '0';
1912                   printf ("%s:\t", buf + skip_addr_chars);
1913
1914                   pb += octets_per_line;
1915                   if (pb > octets)
1916                     pb = octets;
1917                   for (; j < addr_offset * opb + pb; j += bpc)
1918                     {
1919                       int k;
1920
1921                       if (bpc > 1 && inf->display_endian == BFD_ENDIAN_LITTLE)
1922                         {
1923                           for (k = bpc - 1; k >= 0; k--)
1924                             printf ("%02x", (unsigned) data[j + k]);
1925                           putchar (' ');
1926                         }
1927                       else
1928                         {
1929                           for (k = 0; k < bpc; k++)
1930                             printf ("%02x", (unsigned) data[j + k]);
1931                           putchar (' ');
1932                         }
1933                     }
1934                 }
1935             }
1936
1937           if (!wide_output)
1938             putchar ('\n');
1939           else
1940             need_nl = TRUE;
1941         }
1942
1943       while ((*relppp) < relppend
1944              && (**relppp)->address < rel_offset + addr_offset + octets / opb)
1945         {
1946           if (dump_reloc_info || dump_dynamic_reloc_info)
1947             {
1948               arelent *q;
1949
1950               q = **relppp;
1951
1952               if (wide_output)
1953                 putchar ('\t');
1954               else
1955                 printf ("\t\t\t");
1956
1957               objdump_print_value (section->vma - rel_offset + q->address,
1958                                    inf, TRUE);
1959
1960               if (q->howto == NULL)
1961                 printf (": *unknown*\t");
1962               else if (q->howto->name)
1963                 printf (": %s\t", q->howto->name);
1964               else
1965                 printf (": %d\t", q->howto->type);
1966
1967               if (q->sym_ptr_ptr == NULL || *q->sym_ptr_ptr == NULL)
1968                 printf ("*unknown*");
1969               else
1970                 {
1971                   const char *sym_name;
1972
1973                   sym_name = bfd_asymbol_name (*q->sym_ptr_ptr);
1974                   if (sym_name != NULL && *sym_name != '\0')
1975                     objdump_print_symname (aux->abfd, inf, *q->sym_ptr_ptr);
1976                   else
1977                     {
1978                       asection *sym_sec;
1979
1980                       sym_sec = bfd_get_section (*q->sym_ptr_ptr);
1981                       sym_name = bfd_get_section_name (aux->abfd, sym_sec);
1982                       if (sym_name == NULL || *sym_name == '\0')
1983                         sym_name = "*unknown*";
1984                       printf ("%s", sym_name);
1985                     }
1986                 }
1987
1988               if (q->addend)
1989                 {
1990                   bfd_signed_vma addend = q->addend;
1991                   if (addend < 0)
1992                     {
1993                       printf ("-0x");
1994                       addend = -addend;
1995                     }
1996                   else
1997                     printf ("+0x");
1998                   objdump_print_value (addend, inf, TRUE);
1999                 }
2000
2001               printf ("\n");
2002               need_nl = FALSE;
2003             }
2004           ++(*relppp);
2005         }
2006
2007       if (need_nl)
2008         printf ("\n");
2009
2010       addr_offset += octets / opb;
2011     }
2012
2013   free (sfile.buffer);
2014 }
2015
2016 static void
2017 disassemble_section (bfd *abfd, asection *section, void *inf)
2018 {
2019   const struct elf_backend_data * bed;
2020   bfd_vma                      sign_adjust = 0;
2021   struct disassemble_info *    pinfo = (struct disassemble_info *) inf;
2022   struct objdump_disasm_info * paux;
2023   unsigned int                 opb = pinfo->octets_per_byte;
2024   bfd_byte *                   data = NULL;
2025   bfd_size_type                datasize = 0;
2026   arelent **                   rel_pp = NULL;
2027   arelent **                   rel_ppstart = NULL;
2028   arelent **                   rel_ppend;
2029   bfd_vma                      stop_offset;
2030   asymbol *                    sym = NULL;
2031   long                         place = 0;
2032   long                         rel_count;
2033   bfd_vma                      rel_offset;
2034   unsigned long                addr_offset;
2035
2036   /* Sections that do not contain machine
2037      code are not normally disassembled.  */
2038   if (! disassemble_all
2039       && only_list == NULL
2040       && ((section->flags & (SEC_CODE | SEC_HAS_CONTENTS))
2041           != (SEC_CODE | SEC_HAS_CONTENTS)))
2042     return;
2043
2044   if (! process_section_p (section))
2045     return;
2046
2047   datasize = bfd_get_section_size (section);
2048   if (datasize == 0)
2049     return;
2050
2051   if (start_address == (bfd_vma) -1
2052       || start_address < section->vma)
2053     addr_offset = 0;
2054   else
2055     addr_offset = start_address - section->vma;
2056
2057   if (stop_address == (bfd_vma) -1)
2058     stop_offset = datasize / opb;
2059   else
2060     {
2061       if (stop_address < section->vma)
2062         stop_offset = 0;
2063       else
2064         stop_offset = stop_address - section->vma;
2065       if (stop_offset > datasize / opb)
2066         stop_offset = datasize / opb;
2067     }
2068
2069   if (addr_offset >= stop_offset)
2070     return;
2071
2072   /* Decide which set of relocs to use.  Load them if necessary.  */
2073   paux = (struct objdump_disasm_info *) pinfo->application_data;
2074   if (paux->dynrelbuf && dump_dynamic_reloc_info)
2075     {
2076       rel_pp = paux->dynrelbuf;
2077       rel_count = paux->dynrelcount;
2078       /* Dynamic reloc addresses are absolute, non-dynamic are section
2079          relative.  REL_OFFSET specifies the reloc address corresponding
2080          to the start of this section.  */
2081       rel_offset = section->vma;
2082     }
2083   else
2084     {
2085       rel_count = 0;
2086       rel_pp = NULL;
2087       rel_offset = 0;
2088
2089       if ((section->flags & SEC_RELOC) != 0
2090           && (dump_reloc_info || pinfo->disassembler_needs_relocs))
2091         {
2092           long relsize;
2093
2094           relsize = bfd_get_reloc_upper_bound (abfd, section);
2095           if (relsize < 0)
2096             bfd_fatal (bfd_get_filename (abfd));
2097
2098           if (relsize > 0)
2099             {
2100               rel_ppstart = rel_pp = (arelent **) xmalloc (relsize);
2101               rel_count = bfd_canonicalize_reloc (abfd, section, rel_pp, syms);
2102               if (rel_count < 0)
2103                 bfd_fatal (bfd_get_filename (abfd));
2104
2105               /* Sort the relocs by address.  */
2106               qsort (rel_pp, rel_count, sizeof (arelent *), compare_relocs);
2107             }
2108         }
2109     }
2110   rel_ppend = rel_pp + rel_count;
2111
2112   data = (bfd_byte *) xmalloc (datasize);
2113
2114   bfd_get_section_contents (abfd, section, data, 0, datasize);
2115
2116   paux->sec = section;
2117   pinfo->buffer = data;
2118   pinfo->buffer_vma = section->vma;
2119   pinfo->buffer_length = datasize;
2120   pinfo->section = section;
2121
2122   /* Skip over the relocs belonging to addresses below the
2123      start address.  */
2124   while (rel_pp < rel_ppend
2125          && (*rel_pp)->address < rel_offset + addr_offset)
2126     ++rel_pp;
2127
2128   printf (_("\nDisassembly of section %s:\n"), section->name);
2129
2130   /* Find the nearest symbol forwards from our current position.  */
2131   paux->require_sec = TRUE;
2132   sym = (asymbol *) find_symbol_for_address (section->vma + addr_offset,
2133                                              (struct disassemble_info *) inf,
2134                                              &place);
2135   paux->require_sec = FALSE;
2136
2137   /* PR 9774: If the target used signed addresses then we must make
2138      sure that we sign extend the value that we calculate for 'addr'
2139      in the loop below.  */
2140   if (bfd_get_flavour (abfd) == bfd_target_elf_flavour
2141       && (bed = get_elf_backend_data (abfd)) != NULL
2142       && bed->sign_extend_vma)
2143     sign_adjust = (bfd_vma) 1 << (bed->s->arch_size - 1);
2144
2145   /* Disassemble a block of instructions up to the address associated with
2146      the symbol we have just found.  Then print the symbol and find the
2147      next symbol on.  Repeat until we have disassembled the entire section
2148      or we have reached the end of the address range we are interested in.  */
2149   while (addr_offset < stop_offset)
2150     {
2151       bfd_vma addr;
2152       asymbol *nextsym;
2153       bfd_vma nextstop_offset;
2154       bfd_boolean insns;
2155
2156       addr = section->vma + addr_offset;
2157       addr = ((addr & ((sign_adjust << 1) - 1)) ^ sign_adjust) - sign_adjust;
2158
2159       if (sym != NULL && bfd_asymbol_value (sym) <= addr)
2160         {
2161           int x;
2162
2163           for (x = place;
2164                (x < sorted_symcount
2165                 && (bfd_asymbol_value (sorted_syms[x]) <= addr));
2166                ++x)
2167             continue;
2168
2169           pinfo->symbols = sorted_syms + place;
2170           pinfo->num_symbols = x - place;
2171           pinfo->symtab_pos = place;
2172         }
2173       else
2174         {
2175           pinfo->symbols = NULL;
2176           pinfo->num_symbols = 0;
2177           pinfo->symtab_pos = -1;
2178         }
2179
2180       if (! prefix_addresses)
2181         {
2182           pinfo->fprintf_func (pinfo->stream, "\n");
2183           objdump_print_addr_with_sym (abfd, section, sym, addr,
2184                                        pinfo, FALSE);
2185           pinfo->fprintf_func (pinfo->stream, ":\n");
2186         }
2187
2188       if (sym != NULL && bfd_asymbol_value (sym) > addr)
2189         nextsym = sym;
2190       else if (sym == NULL)
2191         nextsym = NULL;
2192       else
2193         {
2194 #define is_valid_next_sym(SYM) \
2195   ((SYM)->section == section \
2196    && (bfd_asymbol_value (SYM) > bfd_asymbol_value (sym)) \
2197    && pinfo->symbol_is_valid (SYM, pinfo))
2198
2199           /* Search forward for the next appropriate symbol in
2200              SECTION.  Note that all the symbols are sorted
2201              together into one big array, and that some sections
2202              may have overlapping addresses.  */
2203           while (place < sorted_symcount
2204                  && ! is_valid_next_sym (sorted_syms [place]))
2205             ++place;
2206
2207           if (place >= sorted_symcount)
2208             nextsym = NULL;
2209           else
2210             nextsym = sorted_syms[place];
2211         }
2212
2213       if (sym != NULL && bfd_asymbol_value (sym) > addr)
2214         nextstop_offset = bfd_asymbol_value (sym) - section->vma;
2215       else if (nextsym == NULL)
2216         nextstop_offset = stop_offset;
2217       else
2218         nextstop_offset = bfd_asymbol_value (nextsym) - section->vma;
2219
2220       if (nextstop_offset > stop_offset
2221           || nextstop_offset <= addr_offset)
2222         nextstop_offset = stop_offset;
2223
2224       /* If a symbol is explicitly marked as being an object
2225          rather than a function, just dump the bytes without
2226          disassembling them.  */
2227       if (disassemble_all
2228           || sym == NULL
2229           || sym->section != section
2230           || bfd_asymbol_value (sym) > addr
2231           || ((sym->flags & BSF_OBJECT) == 0
2232               && (strstr (bfd_asymbol_name (sym), "gnu_compiled")
2233                   == NULL)
2234               && (strstr (bfd_asymbol_name (sym), "gcc2_compiled")
2235                   == NULL))
2236           || (sym->flags & BSF_FUNCTION) != 0)
2237         insns = TRUE;
2238       else
2239         insns = FALSE;
2240
2241       disassemble_bytes (pinfo, paux->disassemble_fn, insns, data,
2242                          addr_offset, nextstop_offset,
2243                          rel_offset, &rel_pp, rel_ppend);
2244
2245       addr_offset = nextstop_offset;
2246       sym = nextsym;
2247     }
2248
2249   free (data);
2250
2251   if (rel_ppstart != NULL)
2252     free (rel_ppstart);
2253 }
2254
2255 /* Disassemble the contents of an object file.  */
2256
2257 static void
2258 disassemble_data (bfd *abfd)
2259 {
2260   struct disassemble_info disasm_info;
2261   struct objdump_disasm_info aux;
2262   long i;
2263
2264   print_files = NULL;
2265   prev_functionname = NULL;
2266   prev_line = -1;
2267   prev_discriminator = 0;
2268
2269   /* We make a copy of syms to sort.  We don't want to sort syms
2270      because that will screw up the relocs.  */
2271   sorted_symcount = symcount ? symcount : dynsymcount;
2272   sorted_syms = (asymbol **) xmalloc ((sorted_symcount + synthcount)
2273                                       * sizeof (asymbol *));
2274   memcpy (sorted_syms, symcount ? syms : dynsyms,
2275           sorted_symcount * sizeof (asymbol *));
2276
2277   sorted_symcount = remove_useless_symbols (sorted_syms, sorted_symcount);
2278
2279   for (i = 0; i < synthcount; ++i)
2280     {
2281       sorted_syms[sorted_symcount] = synthsyms + i;
2282       ++sorted_symcount;
2283     }
2284
2285   /* Sort the symbols into section and symbol order.  */
2286   qsort (sorted_syms, sorted_symcount, sizeof (asymbol *), compare_symbols);
2287
2288   init_disassemble_info (&disasm_info, stdout, (fprintf_ftype) fprintf);
2289
2290   disasm_info.application_data = (void *) &aux;
2291   aux.abfd = abfd;
2292   aux.require_sec = FALSE;
2293   aux.dynrelbuf = NULL;
2294   aux.dynrelcount = 0;
2295   aux.reloc = NULL;
2296
2297   disasm_info.print_address_func = objdump_print_address;
2298   disasm_info.symbol_at_address_func = objdump_symbol_at_address;
2299
2300   if (machine != NULL)
2301     {
2302       const bfd_arch_info_type *inf = bfd_scan_arch (machine);
2303
2304       if (inf == NULL)
2305         fatal (_("can't use supplied machine %s"), machine);
2306
2307       abfd->arch_info = inf;
2308     }
2309
2310   if (endian != BFD_ENDIAN_UNKNOWN)
2311     {
2312       struct bfd_target *xvec;
2313
2314       xvec = (struct bfd_target *) xmalloc (sizeof (struct bfd_target));
2315       memcpy (xvec, abfd->xvec, sizeof (struct bfd_target));
2316       xvec->byteorder = endian;
2317       abfd->xvec = xvec;
2318     }
2319
2320   /* Use libopcodes to locate a suitable disassembler.  */
2321   aux.disassemble_fn = disassembler (abfd);
2322   if (!aux.disassemble_fn)
2323     {
2324       non_fatal (_("can't disassemble for architecture %s\n"),
2325                  bfd_printable_arch_mach (bfd_get_arch (abfd), 0));
2326       exit_status = 1;
2327       return;
2328     }
2329
2330   disasm_info.flavour = bfd_get_flavour (abfd);
2331   disasm_info.arch = bfd_get_arch (abfd);
2332   disasm_info.mach = bfd_get_mach (abfd);
2333   disasm_info.disassembler_options = disassembler_options;
2334   disasm_info.octets_per_byte = bfd_octets_per_byte (abfd);
2335   disasm_info.skip_zeroes = DEFAULT_SKIP_ZEROES;
2336   disasm_info.skip_zeroes_at_end = DEFAULT_SKIP_ZEROES_AT_END;
2337   disasm_info.disassembler_needs_relocs = FALSE;
2338
2339   if (bfd_big_endian (abfd))
2340     disasm_info.display_endian = disasm_info.endian = BFD_ENDIAN_BIG;
2341   else if (bfd_little_endian (abfd))
2342     disasm_info.display_endian = disasm_info.endian = BFD_ENDIAN_LITTLE;
2343   else
2344     /* ??? Aborting here seems too drastic.  We could default to big or little
2345        instead.  */
2346     disasm_info.endian = BFD_ENDIAN_UNKNOWN;
2347
2348   /* Allow the target to customize the info structure.  */
2349   disassemble_init_for_target (& disasm_info);
2350
2351   /* Pre-load the dynamic relocs as we may need them during the disassembly.  */
2352     {
2353       long relsize = bfd_get_dynamic_reloc_upper_bound (abfd);
2354
2355       if (relsize < 0 && dump_dynamic_reloc_info)
2356         bfd_fatal (bfd_get_filename (abfd));
2357
2358       if (relsize > 0)
2359         {
2360           aux.dynrelbuf = (arelent **) xmalloc (relsize);
2361           aux.dynrelcount = bfd_canonicalize_dynamic_reloc (abfd,
2362                                                             aux.dynrelbuf,
2363                                                             dynsyms);
2364           if (aux.dynrelcount < 0)
2365             bfd_fatal (bfd_get_filename (abfd));
2366
2367           /* Sort the relocs by address.  */
2368           qsort (aux.dynrelbuf, aux.dynrelcount, sizeof (arelent *),
2369                  compare_relocs);
2370         }
2371     }
2372   disasm_info.symtab = sorted_syms;
2373   disasm_info.symtab_size = sorted_symcount;
2374
2375   bfd_map_over_sections (abfd, disassemble_section, & disasm_info);
2376
2377   if (aux.dynrelbuf != NULL)
2378     free (aux.dynrelbuf);
2379   free (sorted_syms);
2380 }
2381 \f
2382 static int
2383 load_specific_debug_section (enum dwarf_section_display_enum debug,
2384                              asection *sec, void *file)
2385 {
2386   struct dwarf_section *section = &debug_displays [debug].section;
2387   bfd *abfd = (bfd *) file;
2388   bfd_boolean ret;
2389
2390   /* If it is already loaded, do nothing.  */
2391   if (section->start != NULL)
2392     return 1;
2393
2394   section->reloc_info = NULL;
2395   section->num_relocs = 0;
2396   section->address = bfd_get_section_vma (abfd, sec);
2397   section->size = bfd_get_section_size (sec);
2398   section->start = NULL;
2399   section->user_data = sec;
2400   ret = bfd_get_full_section_contents (abfd, sec, &section->start);
2401
2402   if (! ret)
2403     {
2404       free_debug_section (debug);
2405       printf (_("\nCan't get contents for section '%s'.\n"),
2406               section->name);
2407       return 0;
2408     }
2409
2410   if (is_relocatable && debug_displays [debug].relocate)
2411     {
2412       bfd_cache_section_contents (sec, section->start);
2413
2414       ret = bfd_simple_get_relocated_section_contents (abfd,
2415                                                        sec,
2416                                                        section->start,
2417                                                        syms) != NULL;
2418
2419       if (! ret)
2420         {
2421           free_debug_section (debug);
2422           printf (_("\nCan't get contents for section '%s'.\n"),
2423                   section->name);
2424           return 0;
2425         }
2426
2427       long reloc_size;
2428
2429       reloc_size = bfd_get_reloc_upper_bound (abfd, sec);
2430       if (reloc_size > 0)
2431         {
2432           unsigned long reloc_count;
2433           arelent **relocs;
2434
2435           relocs = (arelent **) xmalloc (reloc_size);
2436
2437           reloc_count = bfd_canonicalize_reloc (abfd, sec, relocs, NULL);
2438           if (reloc_count == 0)
2439             free (relocs);
2440           else
2441             {
2442               section->reloc_info = relocs;
2443               section->num_relocs = reloc_count;
2444             }
2445         }
2446     }
2447
2448   return 1;
2449 }
2450
2451 bfd_boolean
2452 reloc_at (struct dwarf_section * dsec, dwarf_vma offset)
2453 {
2454   arelent ** relocs;
2455   arelent * rp;
2456
2457   if (dsec == NULL || dsec->reloc_info == NULL)
2458     return FALSE;
2459
2460   relocs = (arelent **) dsec->reloc_info;
2461
2462   for (; (rp = * relocs) != NULL; ++ relocs)
2463     if (rp->address == offset)
2464       return TRUE;
2465
2466   return FALSE;
2467 }
2468
2469 int
2470 load_debug_section (enum dwarf_section_display_enum debug, void *file)
2471 {
2472   struct dwarf_section *section = &debug_displays [debug].section;
2473   bfd *abfd = (bfd *) file;
2474   asection *sec;
2475
2476   /* If it is already loaded, do nothing.  */
2477   if (section->start != NULL)
2478     return 1;
2479
2480   /* Locate the debug section.  */
2481   sec = bfd_get_section_by_name (abfd, section->uncompressed_name);
2482   if (sec != NULL)
2483     section->name = section->uncompressed_name;
2484   else
2485     {
2486       sec = bfd_get_section_by_name (abfd, section->compressed_name);
2487       if (sec != NULL)
2488         section->name = section->compressed_name;
2489     }
2490   if (sec == NULL)
2491     return 0;
2492
2493   return load_specific_debug_section (debug, sec, file);
2494 }
2495
2496 void
2497 free_debug_section (enum dwarf_section_display_enum debug)
2498 {
2499   struct dwarf_section *section = &debug_displays [debug].section;
2500
2501   if (section->start == NULL)
2502     return;
2503
2504   /* PR 17512: file: 0f67f69d.  */
2505   if (section->user_data != NULL)
2506     {
2507       asection * sec = (asection *) section->user_data;
2508
2509       /* If we are freeing contents that are also pointed to by the BFD
2510          library's section structure then make sure to update those pointers
2511          too.  Otherwise, the next time we try to load data for this section
2512          we can end up using a stale pointer.  */
2513       if (section->start == sec->contents)
2514         {
2515           sec->contents = NULL;
2516           sec->flags &= ~ SEC_IN_MEMORY;
2517           sec->compress_status = COMPRESS_SECTION_NONE;
2518         }
2519     }
2520
2521   free ((char *) section->start);
2522   section->start = NULL;
2523   section->address = 0;
2524   section->size = 0;
2525 }
2526
2527 static void
2528 dump_dwarf_section (bfd *abfd, asection *section,
2529                     void *arg ATTRIBUTE_UNUSED)
2530 {
2531   const char *name = bfd_get_section_name (abfd, section);
2532   const char *match;
2533   int i;
2534
2535   if (CONST_STRNEQ (name, ".gnu.linkonce.wi."))
2536     match = ".debug_info";
2537   else
2538     match = name;
2539
2540   for (i = 0; i < max; i++)
2541     if ((strcmp (debug_displays [i].section.uncompressed_name, match) == 0
2542          || strcmp (debug_displays [i].section.compressed_name, match) == 0)
2543         && debug_displays [i].enabled != NULL
2544         && *debug_displays [i].enabled)
2545       {
2546         struct dwarf_section *sec = &debug_displays [i].section;
2547
2548         if (strcmp (sec->uncompressed_name, match) == 0)
2549           sec->name = sec->uncompressed_name;
2550         else
2551           sec->name = sec->compressed_name;
2552         if (load_specific_debug_section ((enum dwarf_section_display_enum) i,
2553                                          section, abfd))
2554           {
2555             debug_displays [i].display (sec, abfd);
2556
2557             if (i != info && i != abbrev)
2558               free_debug_section ((enum dwarf_section_display_enum) i);
2559           }
2560         break;
2561       }
2562 }
2563
2564 /* Dump the dwarf debugging information.  */
2565
2566 static void
2567 dump_dwarf (bfd *abfd)
2568 {
2569   is_relocatable = (abfd->flags & (EXEC_P | DYNAMIC)) == 0;
2570
2571   eh_addr_size = bfd_arch_bits_per_address (abfd) / 8;
2572
2573   if (bfd_big_endian (abfd))
2574     byte_get = byte_get_big_endian;
2575   else if (bfd_little_endian (abfd))
2576     byte_get = byte_get_little_endian;
2577   else
2578     /* PR 17512: file: objdump-s-endless-loop.tekhex.  */
2579     {
2580       warn (_("File %s does not contain any dwarf debug information\n"),
2581             bfd_get_filename (abfd));
2582       return;
2583     }
2584
2585   switch (bfd_get_arch (abfd))
2586     {
2587     case bfd_arch_i386:
2588       switch (bfd_get_mach (abfd))
2589         {
2590         case bfd_mach_x86_64:
2591         case bfd_mach_x86_64_intel_syntax:
2592         case bfd_mach_x86_64_nacl:
2593         case bfd_mach_x64_32:
2594         case bfd_mach_x64_32_intel_syntax:
2595         case bfd_mach_x64_32_nacl:
2596           init_dwarf_regnames_x86_64 ();
2597           break;
2598
2599         default:
2600           init_dwarf_regnames_i386 ();
2601           break;
2602         }
2603       break;
2604
2605     case bfd_arch_iamcu:
2606       init_dwarf_regnames_iamcu ();
2607       break;
2608
2609     case bfd_arch_aarch64:
2610       init_dwarf_regnames_aarch64();
2611       break;
2612
2613     case bfd_arch_s390:
2614       init_dwarf_regnames_s390 ();
2615       break;
2616
2617     default:
2618       break;
2619     }
2620
2621   bfd_map_over_sections (abfd, dump_dwarf_section, NULL);
2622
2623   free_debug_memory ();
2624 }
2625 \f
2626 /* Read ABFD's stabs section STABSECT_NAME, and return a pointer to
2627    it.  Return NULL on failure.   */
2628
2629 static char *
2630 read_section_stabs (bfd *abfd, const char *sect_name, bfd_size_type *size_ptr)
2631 {
2632   asection *stabsect;
2633   bfd_size_type size;
2634   char *contents;
2635
2636   stabsect = bfd_get_section_by_name (abfd, sect_name);
2637   if (stabsect == NULL)
2638     {
2639       printf (_("No %s section present\n\n"), sect_name);
2640       return FALSE;
2641     }
2642
2643   size = bfd_section_size (abfd, stabsect);
2644   contents  = (char *) xmalloc (size);
2645
2646   if (! bfd_get_section_contents (abfd, stabsect, contents, 0, size))
2647     {
2648       non_fatal (_("reading %s section of %s failed: %s"),
2649                  sect_name, bfd_get_filename (abfd),
2650                  bfd_errmsg (bfd_get_error ()));
2651       exit_status = 1;
2652       free (contents);
2653       return NULL;
2654     }
2655
2656   *size_ptr = size;
2657
2658   return contents;
2659 }
2660
2661 /* Stabs entries use a 12 byte format:
2662      4 byte string table index
2663      1 byte stab type
2664      1 byte stab other field
2665      2 byte stab desc field
2666      4 byte stab value
2667    FIXME: This will have to change for a 64 bit object format.  */
2668
2669 #define STRDXOFF  (0)
2670 #define TYPEOFF   (4)
2671 #define OTHEROFF  (5)
2672 #define DESCOFF   (6)
2673 #define VALOFF    (8)
2674 #define STABSIZE (12)
2675
2676 /* Print ABFD's stabs section STABSECT_NAME (in `stabs'),
2677    using string table section STRSECT_NAME (in `strtab').  */
2678
2679 static void
2680 print_section_stabs (bfd *abfd,
2681                      const char *stabsect_name,
2682                      unsigned *string_offset_ptr)
2683 {
2684   int i;
2685   unsigned file_string_table_offset = 0;
2686   unsigned next_file_string_table_offset = *string_offset_ptr;
2687   bfd_byte *stabp, *stabs_end;
2688
2689   stabp = stabs;
2690   stabs_end = stabp + stab_size;
2691
2692   printf (_("Contents of %s section:\n\n"), stabsect_name);
2693   printf ("Symnum n_type n_othr n_desc n_value  n_strx String\n");
2694
2695   /* Loop through all symbols and print them.
2696
2697      We start the index at -1 because there is a dummy symbol on
2698      the front of stabs-in-{coff,elf} sections that supplies sizes.  */
2699   for (i = -1; stabp <= stabs_end - STABSIZE; stabp += STABSIZE, i++)
2700     {
2701       const char *name;
2702       unsigned long strx;
2703       unsigned char type, other;
2704       unsigned short desc;
2705       bfd_vma value;
2706
2707       strx = bfd_h_get_32 (abfd, stabp + STRDXOFF);
2708       type = bfd_h_get_8 (abfd, stabp + TYPEOFF);
2709       other = bfd_h_get_8 (abfd, stabp + OTHEROFF);
2710       desc = bfd_h_get_16 (abfd, stabp + DESCOFF);
2711       value = bfd_h_get_32 (abfd, stabp + VALOFF);
2712
2713       printf ("\n%-6d ", i);
2714       /* Either print the stab name, or, if unnamed, print its number
2715          again (makes consistent formatting for tools like awk).  */
2716       name = bfd_get_stab_name (type);
2717       if (name != NULL)
2718         printf ("%-6s", name);
2719       else if (type == N_UNDF)
2720         printf ("HdrSym");
2721       else
2722         printf ("%-6d", type);
2723       printf (" %-6d %-6d ", other, desc);
2724       bfd_printf_vma (abfd, value);
2725       printf (" %-6lu", strx);
2726
2727       /* Symbols with type == 0 (N_UNDF) specify the length of the
2728          string table associated with this file.  We use that info
2729          to know how to relocate the *next* file's string table indices.  */
2730       if (type == N_UNDF)
2731         {
2732           file_string_table_offset = next_file_string_table_offset;
2733           next_file_string_table_offset += value;
2734         }
2735       else
2736         {
2737           bfd_size_type amt = strx + file_string_table_offset;
2738
2739           /* Using the (possibly updated) string table offset, print the
2740              string (if any) associated with this symbol.  */
2741           if (amt < stabstr_size)
2742             /* PR 17512: file: 079-79389-0.001:0.1.  */
2743             printf (" %.*s", (int)(stabstr_size - amt), strtab + amt);
2744           else
2745             printf (" *");
2746         }
2747     }
2748   printf ("\n\n");
2749   *string_offset_ptr = next_file_string_table_offset;
2750 }
2751
2752 typedef struct
2753 {
2754   const char * section_name;
2755   const char * string_section_name;
2756   unsigned string_offset;
2757 }
2758 stab_section_names;
2759
2760 static void
2761 find_stabs_section (bfd *abfd, asection *section, void *names)
2762 {
2763   int len;
2764   stab_section_names * sought = (stab_section_names *) names;
2765
2766   /* Check for section names for which stabsect_name is a prefix, to
2767      handle .stab.N, etc.  */
2768   len = strlen (sought->section_name);
2769
2770   /* If the prefix matches, and the files section name ends with a
2771      nul or a digit, then we match.  I.e., we want either an exact
2772      match or a section followed by a number.  */
2773   if (strncmp (sought->section_name, section->name, len) == 0
2774       && (section->name[len] == 0
2775           || (section->name[len] == '.' && ISDIGIT (section->name[len + 1]))))
2776     {
2777       if (strtab == NULL)
2778         strtab = read_section_stabs (abfd, sought->string_section_name,
2779                                      &stabstr_size);
2780
2781       if (strtab)
2782         {
2783           stabs = (bfd_byte *) read_section_stabs (abfd, section->name,
2784                                                    &stab_size);
2785           if (stabs)
2786             print_section_stabs (abfd, section->name, &sought->string_offset);
2787         }
2788     }
2789 }
2790
2791 static void
2792 dump_stabs_section (bfd *abfd, char *stabsect_name, char *strsect_name)
2793 {
2794   stab_section_names s;
2795
2796   s.section_name = stabsect_name;
2797   s.string_section_name = strsect_name;
2798   s.string_offset = 0;
2799
2800   bfd_map_over_sections (abfd, find_stabs_section, & s);
2801
2802   free (strtab);
2803   strtab = NULL;
2804 }
2805
2806 /* Dump the any sections containing stabs debugging information.  */
2807
2808 static void
2809 dump_stabs (bfd *abfd)
2810 {
2811   dump_stabs_section (abfd, ".stab", ".stabstr");
2812   dump_stabs_section (abfd, ".stab.excl", ".stab.exclstr");
2813   dump_stabs_section (abfd, ".stab.index", ".stab.indexstr");
2814
2815   /* For Darwin.  */
2816   dump_stabs_section (abfd, "LC_SYMTAB.stabs", "LC_SYMTAB.stabstr");
2817
2818   dump_stabs_section (abfd, "$GDB_SYMBOLS$", "$GDB_STRINGS$");
2819 }
2820 \f
2821 static void
2822 dump_bfd_header (bfd *abfd)
2823 {
2824   char *comma = "";
2825
2826   printf (_("architecture: %s, "),
2827           bfd_printable_arch_mach (bfd_get_arch (abfd),
2828                                    bfd_get_mach (abfd)));
2829   printf (_("flags 0x%08x:\n"), abfd->flags & ~BFD_FLAGS_FOR_BFD_USE_MASK);
2830
2831 #define PF(x, y)    if (abfd->flags & x) {printf("%s%s", comma, y); comma=", ";}
2832   PF (HAS_RELOC, "HAS_RELOC");
2833   PF (EXEC_P, "EXEC_P");
2834   PF (HAS_LINENO, "HAS_LINENO");
2835   PF (HAS_DEBUG, "HAS_DEBUG");
2836   PF (HAS_SYMS, "HAS_SYMS");
2837   PF (HAS_LOCALS, "HAS_LOCALS");
2838   PF (DYNAMIC, "DYNAMIC");
2839   PF (WP_TEXT, "WP_TEXT");
2840   PF (D_PAGED, "D_PAGED");
2841   PF (BFD_IS_RELAXABLE, "BFD_IS_RELAXABLE");
2842   printf (_("\nstart address 0x"));
2843   bfd_printf_vma (abfd, abfd->start_address);
2844   printf ("\n");
2845 }
2846
2847 \f
2848 static void
2849 dump_bfd_private_header (bfd *abfd)
2850 {
2851   bfd_print_private_bfd_data (abfd, stdout);
2852 }
2853
2854 static void
2855 dump_target_specific (bfd *abfd)
2856 {
2857   const struct objdump_private_desc * const *desc;
2858   struct objdump_private_option *opt;
2859   char *e, *b;
2860
2861   /* Find the desc.  */
2862   for (desc = objdump_private_vectors; *desc != NULL; desc++)
2863     if ((*desc)->filter (abfd))
2864       break;
2865
2866   if (*desc == NULL)
2867     {
2868       non_fatal (_("option -P/--private not supported by this file"));
2869       return;
2870     }
2871
2872   /* Clear all options.  */
2873   for (opt = (*desc)->options; opt->name; opt++)
2874     opt->selected = FALSE;
2875
2876   /* Decode options.  */
2877   b = dump_private_options;
2878   do
2879     {
2880       e = strchr (b, ',');
2881
2882       if (e)
2883         *e = 0;
2884
2885       for (opt = (*desc)->options; opt->name; opt++)
2886         if (strcmp (opt->name, b) == 0)
2887           {
2888             opt->selected = TRUE;
2889             break;
2890           }
2891       if (opt->name == NULL)
2892         non_fatal (_("target specific dump '%s' not supported"), b);
2893
2894       if (e)
2895         {
2896           *e = ',';
2897           b = e + 1;
2898         }
2899     }
2900   while (e != NULL);
2901
2902   /* Dump.  */
2903   (*desc)->dump (abfd);
2904 }
2905 \f
2906 /* Display a section in hexadecimal format with associated characters.
2907    Each line prefixed by the zero padded address.  */
2908
2909 static void
2910 dump_section (bfd *abfd, asection *section, void *dummy ATTRIBUTE_UNUSED)
2911 {
2912   bfd_byte *data = 0;
2913   bfd_size_type datasize;
2914   bfd_vma addr_offset;
2915   bfd_vma start_offset;
2916   bfd_vma stop_offset;
2917   unsigned int opb = bfd_octets_per_byte (abfd);
2918   /* Bytes per line.  */
2919   const int onaline = 16;
2920   char buf[64];
2921   int count;
2922   int width;
2923
2924   if ((section->flags & SEC_HAS_CONTENTS) == 0)
2925     return;
2926
2927   if (! process_section_p (section))
2928     return;
2929
2930   if ((datasize = bfd_section_size (abfd, section)) == 0)
2931     return;
2932
2933   /* Compute the address range to display.  */
2934   if (start_address == (bfd_vma) -1
2935       || start_address < section->vma)
2936     start_offset = 0;
2937   else
2938     start_offset = start_address - section->vma;
2939
2940   if (stop_address == (bfd_vma) -1)
2941     stop_offset = datasize / opb;
2942   else
2943     {
2944       if (stop_address < section->vma)
2945         stop_offset = 0;
2946       else
2947         stop_offset = stop_address - section->vma;
2948
2949       if (stop_offset > datasize / opb)
2950         stop_offset = datasize / opb;
2951     }
2952
2953   if (start_offset >= stop_offset)
2954     return;
2955
2956   printf (_("Contents of section %s:"), section->name);
2957   if (display_file_offsets)
2958     printf (_("  (Starting at file offset: 0x%lx)"),
2959             (unsigned long) (section->filepos + start_offset));
2960   printf ("\n");
2961
2962   if (!bfd_get_full_section_contents (abfd, section, &data))
2963     {
2964       non_fatal (_("Reading section %s failed because: %s"),
2965                  section->name, bfd_errmsg (bfd_get_error ()));
2966       return;
2967     }
2968
2969   width = 4;
2970
2971   bfd_sprintf_vma (abfd, buf, start_offset + section->vma);
2972   if (strlen (buf) >= sizeof (buf))
2973     abort ();
2974
2975   count = 0;
2976   while (buf[count] == '0' && buf[count+1] != '\0')
2977     count++;
2978   count = strlen (buf) - count;
2979   if (count > width)
2980     width = count;
2981
2982   bfd_sprintf_vma (abfd, buf, stop_offset + section->vma - 1);
2983   if (strlen (buf) >= sizeof (buf))
2984     abort ();
2985
2986   count = 0;
2987   while (buf[count] == '0' && buf[count+1] != '\0')
2988     count++;
2989   count = strlen (buf) - count;
2990   if (count > width)
2991     width = count;
2992
2993   for (addr_offset = start_offset;
2994        addr_offset < stop_offset; addr_offset += onaline / opb)
2995     {
2996       bfd_size_type j;
2997
2998       bfd_sprintf_vma (abfd, buf, (addr_offset + section->vma));
2999       count = strlen (buf);
3000       if ((size_t) count >= sizeof (buf))
3001         abort ();
3002
3003       putchar (' ');
3004       while (count < width)
3005         {
3006           putchar ('0');
3007           count++;
3008         }
3009       fputs (buf + count - width, stdout);
3010       putchar (' ');
3011
3012       for (j = addr_offset * opb;
3013            j < addr_offset * opb + onaline; j++)
3014         {
3015           if (j < stop_offset * opb)
3016             printf ("%02x", (unsigned) (data[j]));
3017           else
3018             printf ("  ");
3019           if ((j & 3) == 3)
3020             printf (" ");
3021         }
3022
3023       printf (" ");
3024       for (j = addr_offset * opb;
3025            j < addr_offset * opb + onaline; j++)
3026         {
3027           if (j >= stop_offset * opb)
3028             printf (" ");
3029           else
3030             printf ("%c", ISPRINT (data[j]) ? data[j] : '.');
3031         }
3032       putchar ('\n');
3033     }
3034   free (data);
3035 }
3036
3037 /* Actually display the various requested regions.  */
3038
3039 static void
3040 dump_data (bfd *abfd)
3041 {
3042   bfd_map_over_sections (abfd, dump_section, NULL);
3043 }
3044
3045 /* Should perhaps share code and display with nm?  */
3046
3047 static void
3048 dump_symbols (bfd *abfd ATTRIBUTE_UNUSED, bfd_boolean dynamic)
3049 {
3050   asymbol **current;
3051   long max_count;
3052   long count;
3053
3054   if (dynamic)
3055     {
3056       current = dynsyms;
3057       max_count = dynsymcount;
3058       printf ("DYNAMIC SYMBOL TABLE:\n");
3059     }
3060   else
3061     {
3062       current = syms;
3063       max_count = symcount;
3064       printf ("SYMBOL TABLE:\n");
3065     }
3066
3067   if (max_count == 0)
3068     printf (_("no symbols\n"));
3069
3070   for (count = 0; count < max_count; count++)
3071     {
3072       bfd *cur_bfd;
3073
3074       if (*current == NULL)
3075         printf (_("no information for symbol number %ld\n"), count);
3076
3077       else if ((cur_bfd = bfd_asymbol_bfd (*current)) == NULL)
3078         printf (_("could not determine the type of symbol number %ld\n"),
3079                 count);
3080
3081       else if (process_section_p ((* current)->section)
3082                && (dump_special_syms
3083                    || !bfd_is_target_special_symbol (cur_bfd, *current)))
3084         {
3085           const char *name = (*current)->name;
3086
3087           if (do_demangle && name != NULL && *name != '\0')
3088             {
3089               char *alloc;
3090
3091               /* If we want to demangle the name, we demangle it
3092                  here, and temporarily clobber it while calling
3093                  bfd_print_symbol.  FIXME: This is a gross hack.  */
3094               alloc = bfd_demangle (cur_bfd, name, DMGL_ANSI | DMGL_PARAMS);
3095               if (alloc != NULL)
3096                 (*current)->name = alloc;
3097               bfd_print_symbol (cur_bfd, stdout, *current,
3098                                 bfd_print_symbol_all);
3099               if (alloc != NULL)
3100                 {
3101                   (*current)->name = name;
3102                   free (alloc);
3103                 }
3104             }
3105           else
3106             bfd_print_symbol (cur_bfd, stdout, *current,
3107                               bfd_print_symbol_all);
3108           printf ("\n");
3109         }
3110
3111       current++;
3112     }
3113   printf ("\n\n");
3114 }
3115 \f
3116 static void
3117 dump_reloc_set (bfd *abfd, asection *sec, arelent **relpp, long relcount)
3118 {
3119   arelent **p;
3120   char *last_filename, *last_functionname;
3121   unsigned int last_line;
3122   unsigned int last_discriminator;
3123
3124   /* Get column headers lined up reasonably.  */
3125   {
3126     static int width;
3127
3128     if (width == 0)
3129       {
3130         char buf[30];
3131
3132         bfd_sprintf_vma (abfd, buf, (bfd_vma) -1);
3133         width = strlen (buf) - 7;
3134       }
3135     printf ("OFFSET %*s TYPE %*s VALUE \n", width, "", 12, "");
3136   }
3137
3138   last_filename = NULL;
3139   last_functionname = NULL;
3140   last_line = 0;
3141   last_discriminator = 0;
3142
3143   for (p = relpp; relcount && *p != NULL; p++, relcount--)
3144     {
3145       arelent *q = *p;
3146       const char *filename, *functionname;
3147       unsigned int linenumber;
3148       unsigned int discriminator;
3149       const char *sym_name;
3150       const char *section_name;
3151       bfd_vma addend2 = 0;
3152
3153       if (start_address != (bfd_vma) -1
3154           && q->address < start_address)
3155         continue;
3156       if (stop_address != (bfd_vma) -1
3157           && q->address > stop_address)
3158         continue;
3159
3160       if (with_line_numbers
3161           && sec != NULL
3162           && bfd_find_nearest_line_discriminator (abfd, sec, syms, q->address,
3163                                                   &filename, &functionname,
3164                                                   &linenumber, &discriminator))
3165         {
3166           if (functionname != NULL
3167               && (last_functionname == NULL
3168                   || strcmp (functionname, last_functionname) != 0))
3169             {
3170               printf ("%s():\n", functionname);
3171               if (last_functionname != NULL)
3172                 free (last_functionname);
3173               last_functionname = xstrdup (functionname);
3174             }
3175
3176           if (linenumber > 0
3177               && (linenumber != last_line
3178                   || (filename != NULL
3179                       && last_filename != NULL
3180                       && filename_cmp (filename, last_filename) != 0)
3181                   || (discriminator != last_discriminator)))
3182             {
3183               if (discriminator > 0)
3184                 printf ("%s:%u\n", filename == NULL ? "???" : filename, linenumber);
3185               else
3186                 printf ("%s:%u (discriminator %u)\n", filename == NULL ? "???" : filename,
3187                         linenumber, discriminator);
3188               last_line = linenumber;
3189               last_discriminator = discriminator;
3190               if (last_filename != NULL)
3191                 free (last_filename);
3192               if (filename == NULL)
3193                 last_filename = NULL;
3194               else
3195                 last_filename = xstrdup (filename);
3196             }
3197         }
3198
3199       if (q->sym_ptr_ptr && *q->sym_ptr_ptr)
3200         {
3201           sym_name = (*(q->sym_ptr_ptr))->name;
3202           section_name = (*(q->sym_ptr_ptr))->section->name;
3203         }
3204       else
3205         {
3206           sym_name = NULL;
3207           section_name = NULL;
3208         }
3209
3210       bfd_printf_vma (abfd, q->address);
3211       if (q->howto == NULL)
3212         printf (" *unknown*         ");
3213       else if (q->howto->name)
3214         {
3215           const char *name = q->howto->name;
3216
3217           /* R_SPARC_OLO10 relocations contain two addends.
3218              But because 'arelent' lacks enough storage to
3219              store them both, the 64-bit ELF Sparc backend
3220              records this as two relocations.  One R_SPARC_LO10
3221              and one R_SPARC_13, both pointing to the same
3222              address.  This is merely so that we have some
3223              place to store both addend fields.
3224
3225              Undo this transformation, otherwise the output
3226              will be confusing.  */
3227           if (abfd->xvec->flavour == bfd_target_elf_flavour
3228               && elf_tdata(abfd)->elf_header->e_machine == EM_SPARCV9
3229               && relcount > 1
3230               && !strcmp (q->howto->name, "R_SPARC_LO10"))
3231             {
3232               arelent *q2 = *(p + 1);
3233               if (q2 != NULL
3234                   && q2->howto
3235                   && q->address == q2->address
3236                   && !strcmp (q2->howto->name, "R_SPARC_13"))
3237                 {
3238                   name = "R_SPARC_OLO10";
3239                   addend2 = q2->addend;
3240                   p++;
3241                 }
3242             }
3243           printf (" %-16s  ", name);
3244         }
3245       else
3246         printf (" %-16d  ", q->howto->type);
3247
3248       if (sym_name)
3249         {
3250           objdump_print_symname (abfd, NULL, *q->sym_ptr_ptr);
3251         }
3252       else
3253         {
3254           if (section_name == NULL)
3255             section_name = "*unknown*";
3256           printf ("[%s]", section_name);
3257         }
3258
3259       if (q->addend)
3260         {
3261           bfd_signed_vma addend = q->addend;
3262           if (addend < 0)
3263             {
3264               printf ("-0x");
3265               addend = -addend;
3266             }
3267           else
3268             printf ("+0x");
3269           bfd_printf_vma (abfd, addend);
3270         }
3271       if (addend2)
3272         {
3273           printf ("+0x");
3274           bfd_printf_vma (abfd, addend2);
3275         }
3276
3277       printf ("\n");
3278     }
3279
3280   if (last_filename != NULL)
3281     free (last_filename);
3282   if (last_functionname != NULL)
3283     free (last_functionname);
3284 }
3285
3286 static void
3287 dump_relocs_in_section (bfd *abfd,
3288                         asection *section,
3289                         void *dummy ATTRIBUTE_UNUSED)
3290 {
3291   arelent **relpp;
3292   long relcount;
3293   long relsize;
3294
3295   if (   bfd_is_abs_section (section)
3296       || bfd_is_und_section (section)
3297       || bfd_is_com_section (section)
3298       || (! process_section_p (section))
3299       || ((section->flags & SEC_RELOC) == 0))
3300     return;
3301
3302   relsize = bfd_get_reloc_upper_bound (abfd, section);
3303   if (relsize < 0)
3304     bfd_fatal (bfd_get_filename (abfd));
3305
3306   printf ("RELOCATION RECORDS FOR [%s]:", section->name);
3307
3308   if (relsize == 0)
3309     {
3310       printf (" (none)\n\n");
3311       return;
3312     }
3313
3314   relpp = (arelent **) xmalloc (relsize);
3315   relcount = bfd_canonicalize_reloc (abfd, section, relpp, syms);
3316
3317   if (relcount < 0)
3318     {
3319       printf ("\n");
3320       non_fatal (_("failed to read relocs in: %s"), bfd_get_filename (abfd));
3321       bfd_fatal (_("error message was"));
3322     }
3323   else if (relcount == 0)
3324     printf (" (none)\n\n");
3325   else
3326     {
3327       printf ("\n");
3328       dump_reloc_set (abfd, section, relpp, relcount);
3329       printf ("\n\n");
3330     }
3331   free (relpp);
3332 }
3333
3334 static void
3335 dump_relocs (bfd *abfd)
3336 {
3337   bfd_map_over_sections (abfd, dump_relocs_in_section, NULL);
3338 }
3339
3340 static void
3341 dump_dynamic_relocs (bfd *abfd)
3342 {
3343   long relsize;
3344   arelent **relpp;
3345   long relcount;
3346
3347   relsize = bfd_get_dynamic_reloc_upper_bound (abfd);
3348   if (relsize < 0)
3349     bfd_fatal (bfd_get_filename (abfd));
3350
3351   printf ("DYNAMIC RELOCATION RECORDS");
3352
3353   if (relsize == 0)
3354     printf (" (none)\n\n");
3355   else
3356     {
3357       relpp = (arelent **) xmalloc (relsize);
3358       relcount = bfd_canonicalize_dynamic_reloc (abfd, relpp, dynsyms);
3359
3360       if (relcount < 0)
3361         bfd_fatal (bfd_get_filename (abfd));
3362       else if (relcount == 0)
3363         printf (" (none)\n\n");
3364       else
3365         {
3366           printf ("\n");
3367           dump_reloc_set (abfd, NULL, relpp, relcount);
3368           printf ("\n\n");
3369         }
3370       free (relpp);
3371     }
3372 }
3373
3374 /* Creates a table of paths, to search for source files.  */
3375
3376 static void
3377 add_include_path (const char *path)
3378 {
3379   if (path[0] == 0)
3380     return;
3381   include_path_count++;
3382   include_paths = (const char **)
3383       xrealloc (include_paths, include_path_count * sizeof (*include_paths));
3384 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
3385   if (path[1] == ':' && path[2] == 0)
3386     path = concat (path, ".", (const char *) 0);
3387 #endif
3388   include_paths[include_path_count - 1] = path;
3389 }
3390
3391 static void
3392 adjust_addresses (bfd *abfd ATTRIBUTE_UNUSED,
3393                   asection *section,
3394                   void *arg)
3395 {
3396   if ((section->flags & SEC_DEBUGGING) == 0)
3397     {
3398       bfd_boolean *has_reloc_p = (bfd_boolean *) arg;
3399       section->vma += adjust_section_vma;
3400       if (*has_reloc_p)
3401         section->lma += adjust_section_vma;
3402     }
3403 }
3404
3405 /* Dump selected contents of ABFD.  */
3406
3407 static void
3408 dump_bfd (bfd *abfd)
3409 {
3410   /* If we are adjusting section VMA's, change them all now.  Changing
3411      the BFD information is a hack.  However, we must do it, or
3412      bfd_find_nearest_line will not do the right thing.  */
3413   if (adjust_section_vma != 0)
3414     {
3415       bfd_boolean has_reloc = (abfd->flags & HAS_RELOC);
3416       bfd_map_over_sections (abfd, adjust_addresses, &has_reloc);
3417     }
3418
3419   if (! dump_debugging_tags && ! suppress_bfd_header)
3420     printf (_("\n%s:     file format %s\n"), bfd_get_filename (abfd),
3421             abfd->xvec->name);
3422   if (dump_ar_hdrs)
3423     print_arelt_descr (stdout, abfd, TRUE);
3424   if (dump_file_header)
3425     dump_bfd_header (abfd);
3426   if (dump_private_headers)
3427     dump_bfd_private_header (abfd);
3428   if (dump_private_options != NULL)
3429     dump_target_specific (abfd);
3430   if (! dump_debugging_tags && ! suppress_bfd_header)
3431     putchar ('\n');
3432
3433   if (dump_symtab
3434       || dump_reloc_info
3435       || disassemble
3436       || dump_debugging
3437       || dump_dwarf_section_info)
3438     syms = slurp_symtab (abfd);
3439
3440   if (dump_section_headers)
3441     dump_headers (abfd);
3442
3443   if (dump_dynamic_symtab || dump_dynamic_reloc_info
3444       || (disassemble && bfd_get_dynamic_symtab_upper_bound (abfd) > 0))
3445     dynsyms = slurp_dynamic_symtab (abfd);
3446   if (disassemble)
3447     {
3448       synthcount = bfd_get_synthetic_symtab (abfd, symcount, syms,
3449                                              dynsymcount, dynsyms, &synthsyms);
3450       if (synthcount < 0)
3451         synthcount = 0;
3452     }
3453
3454   if (dump_symtab)
3455     dump_symbols (abfd, FALSE);
3456   if (dump_dynamic_symtab)
3457     dump_symbols (abfd, TRUE);
3458   if (dump_dwarf_section_info)
3459     dump_dwarf (abfd);
3460   if (dump_stab_section_info)
3461     dump_stabs (abfd);
3462   if (dump_reloc_info && ! disassemble)
3463     dump_relocs (abfd);
3464   if (dump_dynamic_reloc_info && ! disassemble)
3465     dump_dynamic_relocs (abfd);
3466   if (dump_section_contents)
3467     dump_data (abfd);
3468   if (disassemble)
3469     disassemble_data (abfd);
3470
3471   if (dump_debugging)
3472     {
3473       void *dhandle;
3474
3475       dhandle = read_debugging_info (abfd, syms, symcount, TRUE);
3476       if (dhandle != NULL)
3477         {
3478           if (!print_debugging_info (stdout, dhandle, abfd, syms,
3479                                      bfd_demangle,
3480                                      dump_debugging_tags ? TRUE : FALSE))
3481             {
3482               non_fatal (_("%s: printing debugging information failed"),
3483                          bfd_get_filename (abfd));
3484               exit_status = 1;
3485             }
3486         }
3487       /* PR 6483: If there was no STABS or IEEE debug
3488          info in the file, try DWARF instead.  */
3489       else if (! dump_dwarf_section_info)
3490         {
3491           dwarf_select_sections_all ();
3492           dump_dwarf (abfd);
3493         }
3494     }
3495
3496   if (syms)
3497     {
3498       free (syms);
3499       syms = NULL;
3500     }
3501
3502   if (dynsyms)
3503     {
3504       free (dynsyms);
3505       dynsyms = NULL;
3506     }
3507
3508   if (synthsyms)
3509     {
3510       free (synthsyms);
3511       synthsyms = NULL;
3512     }
3513
3514   symcount = 0;
3515   dynsymcount = 0;
3516   synthcount = 0;
3517 }
3518
3519 static void
3520 display_object_bfd (bfd *abfd)
3521 {
3522   char **matching;
3523
3524   if (bfd_check_format_matches (abfd, bfd_object, &matching))
3525     {
3526       dump_bfd (abfd);
3527       return;
3528     }
3529
3530   if (bfd_get_error () == bfd_error_file_ambiguously_recognized)
3531     {
3532       nonfatal (bfd_get_filename (abfd));
3533       list_matching_formats (matching);
3534       free (matching);
3535       return;
3536     }
3537
3538   if (bfd_get_error () != bfd_error_file_not_recognized)
3539     {
3540       nonfatal (bfd_get_filename (abfd));
3541       return;
3542     }
3543
3544   if (bfd_check_format_matches (abfd, bfd_core, &matching))
3545     {
3546       dump_bfd (abfd);
3547       return;
3548     }
3549
3550   nonfatal (bfd_get_filename (abfd));
3551
3552   if (bfd_get_error () == bfd_error_file_ambiguously_recognized)
3553     {
3554       list_matching_formats (matching);
3555       free (matching);
3556     }
3557 }
3558
3559 static void
3560 display_any_bfd (bfd *file, int level)
3561 {
3562   /* Decompress sections unless dumping the section contents.  */
3563   if (!dump_section_contents)
3564     file->flags |= BFD_DECOMPRESS;
3565
3566   /* If the file is an archive, process all of its elements.  */
3567   if (bfd_check_format (file, bfd_archive))
3568     {
3569       bfd *arfile = NULL;
3570       bfd *last_arfile = NULL;
3571
3572       if (level == 0)
3573         printf (_("In archive %s:\n"), bfd_get_filename (file));
3574       else if (level > 100)
3575         {
3576           /* Prevent corrupted files from spinning us into an
3577              infinite loop.  100 is an arbitrary heuristic.  */
3578           fatal (_("Archive nesting is too deep"));
3579           return;
3580         }
3581       else
3582         printf (_("In nested archive %s:\n"), bfd_get_filename (file));
3583
3584       for (;;)
3585         {
3586           bfd_set_error (bfd_error_no_error);
3587
3588           arfile = bfd_openr_next_archived_file (file, arfile);
3589           if (arfile == NULL)
3590             {
3591               if (bfd_get_error () != bfd_error_no_more_archived_files)
3592                 nonfatal (bfd_get_filename (file));
3593               break;
3594             }
3595
3596           display_any_bfd (arfile, level + 1);
3597
3598           if (last_arfile != NULL)
3599             {
3600               bfd_close (last_arfile);
3601               /* PR 17512: file: ac585d01.  */
3602               if (arfile == last_arfile)
3603                 {
3604                   last_arfile = NULL;
3605                   break;
3606                 }
3607             }
3608           last_arfile = arfile;
3609         }
3610
3611       if (last_arfile != NULL)
3612         bfd_close (last_arfile);
3613     }
3614   else
3615     display_object_bfd (file);
3616 }
3617
3618 static void
3619 display_file (char *filename, char *target)
3620 {
3621   bfd *file;
3622
3623   if (get_file_size (filename) < 1)
3624     {
3625       exit_status = 1;
3626       return;
3627     }
3628
3629   file = bfd_openr (filename, target);
3630   if (file == NULL)
3631     {
3632       nonfatal (filename);
3633       return;
3634     }
3635
3636   display_any_bfd (file, 0);
3637
3638   bfd_close (file);
3639 }
3640 \f
3641 int
3642 main (int argc, char **argv)
3643 {
3644   int c;
3645   char *target = default_target;
3646   bfd_boolean seenflag = FALSE;
3647
3648 #if defined (HAVE_SETLOCALE)
3649 #if defined (HAVE_LC_MESSAGES)
3650   setlocale (LC_MESSAGES, "");
3651 #endif
3652   setlocale (LC_CTYPE, "");
3653 #endif
3654
3655   bindtextdomain (PACKAGE, LOCALEDIR);
3656   textdomain (PACKAGE);
3657
3658   program_name = *argv;
3659   xmalloc_set_program_name (program_name);
3660   bfd_set_error_program_name (program_name);
3661
3662   START_PROGRESS (program_name, 0);
3663
3664   expandargv (&argc, &argv);
3665
3666   bfd_init ();
3667   set_default_bfd_target ();
3668
3669   while ((c = getopt_long (argc, argv,
3670                            "pP:ib:m:M:VvCdDlfFaHhrRtTxsSI:j:wE:zgeGW::",
3671                            long_options, (int *) 0))
3672          != EOF)
3673     {
3674       switch (c)
3675         {
3676         case 0:
3677           break;                /* We've been given a long option.  */
3678         case 'm':
3679           machine = optarg;
3680           break;
3681         case 'M':
3682           if (disassembler_options)
3683             /* Ignore potential memory leak for now.  */
3684             disassembler_options = concat (disassembler_options, ",",
3685                                            optarg, (const char *) NULL);
3686           else
3687             disassembler_options = optarg;
3688           break;
3689         case 'j':
3690           add_only (optarg);
3691           break;
3692         case 'F':
3693           display_file_offsets = TRUE;
3694           break;
3695         case 'l':
3696           with_line_numbers = TRUE;
3697           break;
3698         case 'b':
3699           target = optarg;
3700           break;
3701         case 'C':
3702           do_demangle = TRUE;
3703           if (optarg != NULL)
3704             {
3705               enum demangling_styles style;
3706
3707               style = cplus_demangle_name_to_style (optarg);
3708               if (style == unknown_demangling)
3709                 fatal (_("unknown demangling style `%s'"),
3710                        optarg);
3711
3712               cplus_demangle_set_style (style);
3713             }
3714           break;
3715         case 'w':
3716           wide_output = TRUE;
3717           break;
3718         case OPTION_ADJUST_VMA:
3719           adjust_section_vma = parse_vma (optarg, "--adjust-vma");
3720           break;
3721         case OPTION_START_ADDRESS:
3722           start_address = parse_vma (optarg, "--start-address");
3723           if ((stop_address != (bfd_vma) -1) && stop_address <= start_address)
3724             fatal (_("error: the start address should be before the end address"));
3725           break;
3726         case OPTION_STOP_ADDRESS:
3727           stop_address = parse_vma (optarg, "--stop-address");
3728           if ((start_address != (bfd_vma) -1) && stop_address <= start_address)
3729             fatal (_("error: the stop address should be after the start address"));
3730           break;
3731         case OPTION_PREFIX:
3732           prefix = optarg;
3733           prefix_length = strlen (prefix);
3734           /* Remove an unnecessary trailing '/' */
3735           while (IS_DIR_SEPARATOR (prefix[prefix_length - 1]))
3736             prefix_length--;
3737           break;
3738         case OPTION_PREFIX_STRIP:
3739           prefix_strip = atoi (optarg);
3740           if (prefix_strip < 0)
3741             fatal (_("error: prefix strip must be non-negative"));
3742           break;
3743         case OPTION_INSN_WIDTH:
3744           insn_width = strtoul (optarg, NULL, 0);
3745           if (insn_width <= 0)
3746             fatal (_("error: instruction width must be positive"));
3747           break;
3748         case 'E':
3749           if (strcmp (optarg, "B") == 0)
3750             endian = BFD_ENDIAN_BIG;
3751           else if (strcmp (optarg, "L") == 0)
3752             endian = BFD_ENDIAN_LITTLE;
3753           else
3754             {
3755               nonfatal (_("unrecognized -E option"));
3756               usage (stderr, 1);
3757             }
3758           break;
3759         case OPTION_ENDIAN:
3760           if (strncmp (optarg, "big", strlen (optarg)) == 0)
3761             endian = BFD_ENDIAN_BIG;
3762           else if (strncmp (optarg, "little", strlen (optarg)) == 0)
3763             endian = BFD_ENDIAN_LITTLE;
3764           else
3765             {
3766               non_fatal (_("unrecognized --endian type `%s'"), optarg);
3767               exit_status = 1;
3768               usage (stderr, 1);
3769             }
3770           break;
3771
3772         case 'f':
3773           dump_file_header = TRUE;
3774           seenflag = TRUE;
3775           break;
3776         case 'i':
3777           formats_info = TRUE;
3778           seenflag = TRUE;
3779           break;
3780         case 'I':
3781           add_include_path (optarg);
3782           break;
3783         case 'p':
3784           dump_private_headers = TRUE;
3785           seenflag = TRUE;
3786           break;
3787         case 'P':
3788           dump_private_options = optarg;
3789           seenflag = TRUE;
3790           break;
3791         case 'x':
3792           dump_private_headers = TRUE;
3793           dump_symtab = TRUE;
3794           dump_reloc_info = TRUE;
3795           dump_file_header = TRUE;
3796           dump_ar_hdrs = TRUE;
3797           dump_section_headers = TRUE;
3798           seenflag = TRUE;
3799           break;
3800         case 't':
3801           dump_symtab = TRUE;
3802           seenflag = TRUE;
3803           break;
3804         case 'T':
3805           dump_dynamic_symtab = TRUE;
3806           seenflag = TRUE;
3807           break;
3808         case 'd':
3809           disassemble = TRUE;
3810           seenflag = TRUE;
3811           break;
3812         case 'z':
3813           disassemble_zeroes = TRUE;
3814           break;
3815         case 'D':
3816           disassemble = TRUE;
3817           disassemble_all = TRUE;
3818           seenflag = TRUE;
3819           break;
3820         case 'S':
3821           disassemble = TRUE;
3822           with_source_code = TRUE;
3823           seenflag = TRUE;
3824           break;
3825         case 'g':
3826           dump_debugging = 1;
3827           seenflag = TRUE;
3828           break;
3829         case 'e':
3830           dump_debugging = 1;
3831           dump_debugging_tags = 1;
3832           do_demangle = TRUE;
3833           seenflag = TRUE;
3834           break;
3835         case 'W':
3836           dump_dwarf_section_info = TRUE;
3837           seenflag = TRUE;
3838           if (optarg)
3839             dwarf_select_sections_by_letters (optarg);
3840           else
3841             dwarf_select_sections_all ();
3842           break;
3843         case OPTION_DWARF:
3844           dump_dwarf_section_info = TRUE;
3845           seenflag = TRUE;
3846           if (optarg)
3847             dwarf_select_sections_by_names (optarg);
3848           else
3849             dwarf_select_sections_all ();
3850           break;
3851         case OPTION_DWARF_DEPTH:
3852           {
3853             char *cp;
3854             dwarf_cutoff_level = strtoul (optarg, & cp, 0);
3855           }
3856           break;
3857         case OPTION_DWARF_START:
3858           {
3859             char *cp;
3860             dwarf_start_die = strtoul (optarg, & cp, 0);
3861             suppress_bfd_header = 1;
3862           }
3863           break;
3864         case OPTION_DWARF_CHECK:
3865           dwarf_check = TRUE;
3866           break;
3867         case 'G':
3868           dump_stab_section_info = TRUE;
3869           seenflag = TRUE;
3870           break;
3871         case 's':
3872           dump_section_contents = TRUE;
3873           seenflag = TRUE;
3874           break;
3875         case 'r':
3876           dump_reloc_info = TRUE;
3877           seenflag = TRUE;
3878           break;
3879         case 'R':
3880           dump_dynamic_reloc_info = TRUE;
3881           seenflag = TRUE;
3882           break;
3883         case 'a':
3884           dump_ar_hdrs = TRUE;
3885           seenflag = TRUE;
3886           break;
3887         case 'h':
3888           dump_section_headers = TRUE;
3889           seenflag = TRUE;
3890           break;
3891         case 'v':
3892         case 'V':
3893           show_version = TRUE;
3894           seenflag = TRUE;
3895           break;
3896
3897         case 'H':
3898           usage (stdout, 0);
3899           /* No need to set seenflag or to break - usage() does not return.  */
3900         default:
3901           usage (stderr, 1);
3902         }
3903     }
3904
3905   if (show_version)
3906     print_version ("objdump");
3907
3908   if (!seenflag)
3909     usage (stderr, 2);
3910
3911   if (formats_info)
3912     exit_status = display_info ();
3913   else
3914     {
3915       if (optind == argc)
3916         display_file ("a.out", target);
3917       else
3918         for (; optind < argc;)
3919           display_file (argv[optind++], target);
3920     }
3921
3922   free_only_list ();
3923
3924   END_PROGRESS (program_name);
3925
3926   return exit_status;
3927 }