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