binutils/objdump.c

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