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