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_entsize = 1;
3244   ctfsect.cts_size = size;
3245   ctfsect.cts_data = data;
3246
3247   return ctfsect;
3248 }
3249
3250 /* Dump one CTF archive member.  */
3251
3252 static int
3253 dump_ctf_archive_member (ctf_file_t *ctf, const char *name, void *arg)
3254 {
3255   ctf_file_t *parent = (ctf_file_t *) arg;
3256   const char *things[] = {"Labels", "Data objects", "Function objects",
3257                           "Variables", "Types", "Strings", ""};
3258   const char **thing;
3259   size_t i;
3260
3261   /* Only print out the name of non-default-named archive members.
3262      The name .ctf appears everywhere, even for things that aren't
3263      really archives, so printing it out is liable to be confusing.  */
3264   if (strcmp (name, ".ctf") != 0)
3265     printf (_("\nCTF archive member: %s:\n"), sanitize_string (name));
3266
3267   ctf_import (ctf, parent);
3268   for (i = 1, thing = things; *thing[0]; thing++, i++)
3269     {
3270       ctf_dump_state_t *s = NULL;
3271       char *item;
3272
3273       printf ("\n  %s:\n", *thing);
3274       while ((item = ctf_dump (ctf, &s, i, dump_ctf_indent_lines,
3275                                (void *) "    ")) != NULL)
3276         {
3277           printf ("%s\n", item);
3278           free (item);
3279         }
3280
3281       if (ctf_errno (ctf))
3282         {
3283           non_fatal (_("Iteration failed: %s, %s\n"), *thing,
3284                    ctf_errmsg (ctf_errno (ctf)));
3285           break;
3286         }
3287     }
3288   return 0;
3289 }
3290
3291 /* Dump the CTF debugging information.  */
3292
3293 static void
3294 dump_ctf (bfd *abfd, const char *sect_name, const char *parent_name)
3295 {
3296   ctf_archive_t *ctfa, *parenta = NULL;
3297   bfd_byte *ctfdata, *parentdata = NULL;
3298   bfd_size_type ctfsize, parentsize;
3299   ctf_sect_t ctfsect;
3300   ctf_file_t *parent = NULL;
3301   int err;
3302
3303   if ((ctfdata = read_section_stabs (abfd, sect_name, &ctfsize, NULL)) == NULL)
3304       bfd_fatal (bfd_get_filename (abfd));
3305
3306   if (parent_name
3307       && (parentdata = read_section_stabs (abfd, parent_name, &parentsize,
3308                                            NULL)) == NULL)
3309       bfd_fatal (bfd_get_filename (abfd));
3310
3311   /* Load the CTF file and dump it.  */
3312
3313   ctfsect = make_ctfsect (sect_name, ctfdata, ctfsize);
3314   if ((ctfa = ctf_bfdopen_ctfsect (abfd, &ctfsect, &err)) == NULL)
3315     {
3316       non_fatal (_("CTF open failure: %s\n"), ctf_errmsg (err));
3317       bfd_fatal (bfd_get_filename (abfd));
3318     }
3319
3320   if (parentdata)
3321     {
3322       ctfsect = make_ctfsect (parent_name, parentdata, parentsize);
3323       if ((parenta = ctf_bfdopen_ctfsect (abfd, &ctfsect, &err)) == NULL)
3324         {
3325           non_fatal (_("CTF open failure: %s\n"), ctf_errmsg (err));
3326           bfd_fatal (bfd_get_filename (abfd));
3327         }
3328
3329       /* Assume that the applicable parent archive member is the default one.
3330          (This is what all known implementations are expected to do, if they
3331          put CTFs and their parents in archives together.)  */
3332       if ((parent = ctf_arc_open_by_name (parenta, NULL, &err)) == NULL)
3333         {
3334           non_fatal (_("CTF open failure: %s\n"), ctf_errmsg (err));
3335           bfd_fatal (bfd_get_filename (abfd));
3336         }
3337     }
3338
3339   printf (_("Contents of CTF section %s:\n"), sanitize_string (sect_name));
3340
3341   ctf_archive_iter (ctfa, dump_ctf_archive_member, parent);
3342   ctf_file_close (parent);
3343   ctf_close (ctfa);
3344   ctf_close (parenta);
3345   free (parentdata);
3346   free (ctfdata);
3347 }
3348 #endif /* HAVE_LIBCTF */
3349
3350 static void
3351 dump_bfd_private_header (bfd *abfd)
3352 {
3353   if (!bfd_print_private_bfd_data (abfd, stdout))
3354     non_fatal (_("warning: private headers incomplete: %s"),
3355                bfd_errmsg (bfd_get_error ()));
3356 }
3357
3358 static void
3359 dump_target_specific (bfd *abfd)
3360 {
3361   const struct objdump_private_desc * const *desc;
3362   struct objdump_private_option *opt;
3363   char *e, *b;
3364
3365   /* Find the desc.  */
3366   for (desc = objdump_private_vectors; *desc != NULL; desc++)
3367     if ((*desc)->filter (abfd))
3368       break;
3369
3370   if (*desc == NULL)
3371     {
3372       non_fatal (_("option -P/--private not supported by this file"));
3373       return;
3374     }
3375
3376   /* Clear all options.  */
3377   for (opt = (*desc)->options; opt->name; opt++)
3378     opt->selected = FALSE;
3379
3380   /* Decode options.  */
3381   b = dump_private_options;
3382   do
3383     {
3384       e = strchr (b, ',');
3385
3386       if (e)
3387         *e = 0;
3388
3389       for (opt = (*desc)->options; opt->name; opt++)
3390         if (strcmp (opt->name, b) == 0)
3391           {
3392             opt->selected = TRUE;
3393             break;
3394           }
3395       if (opt->name == NULL)
3396         non_fatal (_("target specific dump '%s' not supported"), b);
3397
3398       if (e)
3399         {
3400           *e = ',';
3401           b = e + 1;
3402         }
3403     }
3404   while (e != NULL);
3405
3406   /* Dump.  */
3407   (*desc)->dump (abfd);
3408 }
3409 \f
3410 /* Display a section in hexadecimal format with associated characters.
3411    Each line prefixed by the zero padded address.  */
3412
3413 static void
3414 dump_section (bfd *abfd, asection *section, void *dummy ATTRIBUTE_UNUSED)
3415 {
3416   bfd_byte *data = NULL;
3417   bfd_size_type datasize;
3418   bfd_vma addr_offset;
3419   bfd_vma start_offset;
3420   bfd_vma stop_offset;
3421   unsigned int opb = bfd_octets_per_byte (abfd);
3422   /* Bytes per line.  */
3423   const int onaline = 16;
3424   char buf[64];
3425   int count;
3426   int width;
3427
3428   if ((section->flags & SEC_HAS_CONTENTS) == 0)
3429     return;
3430
3431   if (! process_section_p (section))
3432     return;
3433
3434   if ((datasize = bfd_section_size (abfd, section)) == 0)
3435     return;
3436
3437   /* Compute the address range to display.  */
3438   if (start_address == (bfd_vma) -1
3439       || start_address < section->vma)
3440     start_offset = 0;
3441   else
3442     start_offset = start_address - section->vma;
3443
3444   if (stop_address == (bfd_vma) -1)
3445     stop_offset = datasize / opb;
3446   else
3447     {
3448       if (stop_address < section->vma)
3449         stop_offset = 0;
3450       else
3451         stop_offset = stop_address - section->vma;
3452
3453       if (stop_offset > datasize / opb)
3454         stop_offset = datasize / opb;
3455     }
3456
3457   if (start_offset >= stop_offset)
3458     return;
3459
3460   printf (_("Contents of section %s:"), sanitize_string (section->name));
3461   if (display_file_offsets)
3462     printf (_("  (Starting at file offset: 0x%lx)"),
3463             (unsigned long) (section->filepos + start_offset));
3464   printf ("\n");
3465
3466   if (!bfd_get_full_section_contents (abfd, section, &data))
3467     {
3468       non_fatal (_("Reading section %s failed because: %s"),
3469                  section->name, bfd_errmsg (bfd_get_error ()));
3470       return;
3471     }
3472
3473   width = 4;
3474
3475   bfd_sprintf_vma (abfd, buf, start_offset + section->vma);
3476   if (strlen (buf) >= sizeof (buf))
3477     abort ();
3478
3479   count = 0;
3480   while (buf[count] == '0' && buf[count+1] != '\0')
3481     count++;
3482   count = strlen (buf) - count;
3483   if (count > width)
3484     width = count;
3485
3486   bfd_sprintf_vma (abfd, buf, stop_offset + section->vma - 1);
3487   if (strlen (buf) >= sizeof (buf))
3488     abort ();
3489
3490   count = 0;
3491   while (buf[count] == '0' && buf[count+1] != '\0')
3492     count++;
3493   count = strlen (buf) - count;
3494   if (count > width)
3495     width = count;
3496
3497   for (addr_offset = start_offset;
3498        addr_offset < stop_offset; addr_offset += onaline / opb)
3499     {
3500       bfd_size_type j;
3501
3502       bfd_sprintf_vma (abfd, buf, (addr_offset + section->vma));
3503       count = strlen (buf);
3504       if ((size_t) count >= sizeof (buf))
3505         abort ();
3506
3507       putchar (' ');
3508       while (count < width)
3509         {
3510           putchar ('0');
3511           count++;
3512         }
3513       fputs (buf + count - width, stdout);
3514       putchar (' ');
3515
3516       for (j = addr_offset * opb;
3517            j < addr_offset * opb + onaline; j++)
3518         {
3519           if (j < stop_offset * opb)
3520             printf ("%02x", (unsigned) (data[j]));
3521           else
3522             printf ("  ");
3523           if ((j & 3) == 3)
3524             printf (" ");
3525         }
3526
3527       printf (" ");
3528       for (j = addr_offset * opb;
3529            j < addr_offset * opb + onaline; j++)
3530         {
3531           if (j >= stop_offset * opb)
3532             printf (" ");
3533           else
3534             printf ("%c", ISPRINT (data[j]) ? data[j] : '.');
3535         }
3536       putchar ('\n');
3537     }
3538   free (data);
3539 }
3540
3541 /* Actually display the various requested regions.  */
3542
3543 static void
3544 dump_data (bfd *abfd)
3545 {
3546   bfd_map_over_sections (abfd, dump_section, NULL);
3547 }
3548
3549 /* Should perhaps share code and display with nm?  */
3550
3551 static void
3552 dump_symbols (bfd *abfd ATTRIBUTE_UNUSED, bfd_boolean dynamic)
3553 {
3554   asymbol **current;
3555   long max_count;
3556   long count;
3557
3558   if (dynamic)
3559     {
3560       current = dynsyms;
3561       max_count = dynsymcount;
3562       printf ("DYNAMIC SYMBOL TABLE:\n");
3563     }
3564   else
3565     {
3566       current = syms;
3567       max_count = symcount;
3568       printf ("SYMBOL TABLE:\n");
3569     }
3570
3571   if (max_count == 0)
3572     printf (_("no symbols\n"));
3573
3574   for (count = 0; count < max_count; count++)
3575     {
3576       bfd *cur_bfd;
3577
3578       if (*current == NULL)
3579         printf (_("no information for symbol number %ld\n"), count);
3580
3581       else if ((cur_bfd = bfd_asymbol_bfd (*current)) == NULL)
3582         printf (_("could not determine the type of symbol number %ld\n"),
3583                 count);
3584
3585       else if (process_section_p ((* current)->section)
3586                && (dump_special_syms
3587                    || !bfd_is_target_special_symbol (cur_bfd, *current)))
3588         {
3589           const char *name = (*current)->name;
3590
3591           if (do_demangle && name != NULL && *name != '\0')
3592             {
3593               char *alloc;
3594
3595               /* If we want to demangle the name, we demangle it
3596                  here, and temporarily clobber it while calling
3597                  bfd_print_symbol.  FIXME: This is a gross hack.  */
3598               alloc = bfd_demangle (cur_bfd, name, demangle_flags);
3599               if (alloc != NULL)
3600                 (*current)->name = alloc;
3601               bfd_print_symbol (cur_bfd, stdout, *current,
3602                                 bfd_print_symbol_all);
3603               if (alloc != NULL)
3604                 {
3605                   (*current)->name = name;
3606                   free (alloc);
3607                 }
3608             }
3609           else
3610             bfd_print_symbol (cur_bfd, stdout, *current,
3611                               bfd_print_symbol_all);
3612           printf ("\n");
3613         }
3614
3615       current++;
3616     }
3617   printf ("\n\n");
3618 }
3619 \f
3620 static void
3621 dump_reloc_set (bfd *abfd, asection *sec, arelent **relpp, long relcount)
3622 {
3623   arelent **p;
3624   char *last_filename, *last_functionname;
3625   unsigned int last_line;
3626   unsigned int last_discriminator;
3627
3628   /* Get column headers lined up reasonably.  */
3629   {
3630     static int width;
3631
3632     if (width == 0)
3633       {
3634         char buf[30];
3635
3636         bfd_sprintf_vma (abfd, buf, (bfd_vma) -1);
3637         width = strlen (buf) - 7;
3638       }
3639     printf ("OFFSET %*s TYPE %*s VALUE \n", width, "", 12, "");
3640   }
3641
3642   last_filename = NULL;
3643   last_functionname = NULL;
3644   last_line = 0;
3645   last_discriminator = 0;
3646
3647   for (p = relpp; relcount && *p != NULL; p++, relcount--)
3648     {
3649       arelent *q = *p;
3650       const char *filename, *functionname;
3651       unsigned int linenumber;
3652       unsigned int discriminator;
3653       const char *sym_name;
3654       const char *section_name;
3655       bfd_vma addend2 = 0;
3656
3657       if (start_address != (bfd_vma) -1
3658           && q->address < start_address)
3659         continue;
3660       if (stop_address != (bfd_vma) -1
3661           && q->address > stop_address)
3662         continue;
3663
3664       if (with_line_numbers
3665           && sec != NULL
3666           && bfd_find_nearest_line_discriminator (abfd, sec, syms, q->address,
3667                                                   &filename, &functionname,
3668                                                   &linenumber, &discriminator))
3669         {
3670           if (functionname != NULL
3671               && (last_functionname == NULL
3672                   || strcmp (functionname, last_functionname) != 0))
3673             {
3674               printf ("%s():\n", sanitize_string (functionname));
3675               if (last_functionname != NULL)
3676                 free (last_functionname);
3677               last_functionname = xstrdup (functionname);
3678             }
3679
3680           if (linenumber > 0
3681               && (linenumber != last_line
3682                   || (filename != NULL
3683                       && last_filename != NULL
3684                       && filename_cmp (filename, last_filename) != 0)
3685                   || (discriminator != last_discriminator)))
3686             {
3687               if (discriminator > 0)
3688                 printf ("%s:%u\n", filename == NULL ? "???" :
3689                         sanitize_string (filename), linenumber);
3690               else
3691                 printf ("%s:%u (discriminator %u)\n",
3692                         filename == NULL ? "???" : sanitize_string (filename),
3693                         linenumber, discriminator);
3694               last_line = linenumber;
3695               last_discriminator = discriminator;
3696               if (last_filename != NULL)
3697                 free (last_filename);
3698               if (filename == NULL)
3699                 last_filename = NULL;
3700               else
3701                 last_filename = xstrdup (filename);
3702             }
3703         }
3704
3705       if (q->sym_ptr_ptr && *q->sym_ptr_ptr)
3706         {
3707           sym_name = (*(q->sym_ptr_ptr))->name;
3708           section_name = (*(q->sym_ptr_ptr))->section->name;
3709         }
3710       else
3711         {
3712           sym_name = NULL;
3713           section_name = NULL;
3714         }
3715
3716       bfd_printf_vma (abfd, q->address);
3717       if (q->howto == NULL)
3718         printf (" *unknown*         ");
3719       else if (q->howto->name)
3720         {
3721           const char *name = q->howto->name;
3722
3723           /* R_SPARC_OLO10 relocations contain two addends.
3724              But because 'arelent' lacks enough storage to
3725              store them both, the 64-bit ELF Sparc backend
3726              records this as two relocations.  One R_SPARC_LO10
3727              and one R_SPARC_13, both pointing to the same
3728              address.  This is merely so that we have some
3729              place to store both addend fields.
3730
3731              Undo this transformation, otherwise the output
3732              will be confusing.  */
3733           if (abfd->xvec->flavour == bfd_target_elf_flavour
3734               && elf_tdata(abfd)->elf_header->e_machine == EM_SPARCV9
3735               && relcount > 1
3736               && !strcmp (q->howto->name, "R_SPARC_LO10"))
3737             {
3738               arelent *q2 = *(p + 1);
3739               if (q2 != NULL
3740                   && q2->howto
3741                   && q->address == q2->address
3742                   && !strcmp (q2->howto->name, "R_SPARC_13"))
3743                 {
3744                   name = "R_SPARC_OLO10";
3745                   addend2 = q2->addend;
3746                   p++;
3747                 }
3748             }
3749           printf (" %-16s  ", name);
3750         }
3751       else
3752         printf (" %-16d  ", q->howto->type);
3753
3754       if (sym_name)
3755         {
3756           objdump_print_symname (abfd, NULL, *q->sym_ptr_ptr);
3757         }
3758       else
3759         {
3760           if (section_name == NULL)
3761             section_name = "*unknown*";
3762           printf ("[%s]", sanitize_string (section_name));
3763         }
3764
3765       if (q->addend)
3766         {
3767           bfd_signed_vma addend = q->addend;
3768           if (addend < 0)
3769             {
3770               printf ("-0x");
3771               addend = -addend;
3772             }
3773           else
3774             printf ("+0x");
3775           bfd_printf_vma (abfd, addend);
3776         }
3777       if (addend2)
3778         {
3779           printf ("+0x");
3780           bfd_printf_vma (abfd, addend2);
3781         }
3782
3783       printf ("\n");
3784     }
3785
3786   if (last_filename != NULL)
3787     free (last_filename);
3788   if (last_functionname != NULL)
3789     free (last_functionname);
3790 }
3791
3792 static void
3793 dump_relocs_in_section (bfd *abfd,
3794                         asection *section,
3795                         void *dummy ATTRIBUTE_UNUSED)
3796 {
3797   arelent **relpp = NULL;
3798   long relcount;
3799   long relsize;
3800
3801   if (   bfd_is_abs_section (section)
3802       || bfd_is_und_section (section)
3803       || bfd_is_com_section (section)
3804       || (! process_section_p (section))
3805       || ((section->flags & SEC_RELOC) == 0))
3806     return;
3807
3808   printf ("RELOCATION RECORDS FOR [%s]:", sanitize_string (section->name));
3809
3810   relsize = bfd_get_reloc_upper_bound (abfd, section);
3811   if (relsize == 0)
3812     {
3813       printf (" (none)\n\n");
3814       return;
3815     }
3816
3817   if (relsize < 0)
3818     relcount = relsize;
3819   else
3820     {
3821       relpp = (arelent **) xmalloc (relsize);
3822       relcount = bfd_canonicalize_reloc (abfd, section, relpp, syms);
3823     }
3824
3825   if (relcount < 0)
3826     {
3827       printf ("\n");
3828       non_fatal (_("failed to read relocs in: %s"),
3829                  sanitize_string (bfd_get_filename (abfd)));
3830       bfd_fatal (_("error message was"));
3831     }
3832   else if (relcount == 0)
3833     printf (" (none)\n\n");
3834   else
3835     {
3836       printf ("\n");
3837       dump_reloc_set (abfd, section, relpp, relcount);
3838       printf ("\n\n");
3839     }
3840   free (relpp);
3841 }
3842
3843 static void
3844 dump_relocs (bfd *abfd)
3845 {
3846   bfd_map_over_sections (abfd, dump_relocs_in_section, NULL);
3847 }
3848
3849 static void
3850 dump_dynamic_relocs (bfd *abfd)
3851 {
3852   long relsize;
3853   arelent **relpp;
3854   long relcount;
3855
3856   relsize = bfd_get_dynamic_reloc_upper_bound (abfd);
3857   if (relsize < 0)
3858     bfd_fatal (bfd_get_filename (abfd));
3859
3860   printf ("DYNAMIC RELOCATION RECORDS");
3861
3862   if (relsize == 0)
3863     printf (" (none)\n\n");
3864   else
3865     {
3866       relpp = (arelent **) xmalloc (relsize);
3867       relcount = bfd_canonicalize_dynamic_reloc (abfd, relpp, dynsyms);
3868
3869       if (relcount < 0)
3870         bfd_fatal (bfd_get_filename (abfd));
3871       else if (relcount == 0)
3872         printf (" (none)\n\n");
3873       else
3874         {
3875           printf ("\n");
3876           dump_reloc_set (abfd, NULL, relpp, relcount);
3877           printf ("\n\n");
3878         }
3879       free (relpp);
3880     }
3881 }
3882
3883 /* Creates a table of paths, to search for source files.  */
3884
3885 static void
3886 add_include_path (const char *path)
3887 {
3888   if (path[0] == 0)
3889     return;
3890   include_path_count++;
3891   include_paths = (const char **)
3892       xrealloc (include_paths, include_path_count * sizeof (*include_paths));
3893 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
3894   if (path[1] == ':' && path[2] == 0)
3895     path = concat (path, ".", (const char *) 0);
3896 #endif
3897   include_paths[include_path_count - 1] = path;
3898 }
3899
3900 static void
3901 adjust_addresses (bfd *abfd ATTRIBUTE_UNUSED,
3902                   asection *section,
3903                   void *arg)
3904 {
3905   if ((section->flags & SEC_DEBUGGING) == 0)
3906     {
3907       bfd_boolean *has_reloc_p = (bfd_boolean *) arg;
3908       section->vma += adjust_section_vma;
3909       if (*has_reloc_p)
3910         section->lma += adjust_section_vma;
3911     }
3912 }
3913
3914 /* Return the sign-extended form of an ARCH_SIZE sized VMA.  */
3915
3916 static bfd_vma
3917 sign_extend_address (bfd *abfd ATTRIBUTE_UNUSED,
3918                      bfd_vma vma,
3919                      unsigned arch_size)
3920 {
3921   bfd_vma mask;
3922   mask = (bfd_vma) 1 << (arch_size - 1);
3923   return (((vma & ((mask << 1) - 1)) ^ mask) - mask);
3924 }
3925
3926 /* Dump selected contents of ABFD.  */
3927
3928 static void
3929 dump_bfd (bfd *abfd, bfd_boolean is_mainfile)
3930 {
3931   const struct elf_backend_data * bed;
3932
3933   if (bfd_big_endian (abfd))
3934     byte_get = byte_get_big_endian;
3935   else if (bfd_little_endian (abfd))
3936     byte_get = byte_get_little_endian;
3937   else
3938     byte_get = NULL;
3939
3940   /* Load any separate debug information files.
3941      We do this now and without checking do_follow_links because separate
3942      debug info files may contain symbol tables that we will need when
3943      displaying information about the main file.  Any memory allocated by
3944      load_separate_debug_files will be released when we call
3945      free_debug_memory below.
3946
3947      The test on is_mainfile is there because the chain of separate debug
3948      info files is a global variable shared by all invocations of dump_bfd.  */
3949   if (is_mainfile)
3950     {
3951       load_separate_debug_files (abfd, bfd_get_filename (abfd));
3952
3953       /* If asked to do so, recursively dump the separate files.  */
3954       if (do_follow_links)
3955         {
3956           separate_info * i;
3957
3958           for (i = first_separate_info; i != NULL; i = i->next)
3959             dump_bfd (i->handle, FALSE);
3960         }
3961     }
3962
3963   /* Adjust user-specified start and stop limits for targets that use
3964      signed addresses.  */
3965   if (bfd_get_flavour (abfd) == bfd_target_elf_flavour
3966       && (bed = get_elf_backend_data (abfd)) != NULL
3967       && bed->sign_extend_vma)
3968     {
3969       start_address = sign_extend_address (abfd, start_address,
3970                                            bed->s->arch_size);
3971       stop_address = sign_extend_address (abfd, stop_address,
3972                                           bed->s->arch_size);
3973     }
3974
3975   /* If we are adjusting section VMA's, change them all now.  Changing
3976      the BFD information is a hack.  However, we must do it, or
3977      bfd_find_nearest_line will not do the right thing.  */
3978   if (adjust_section_vma != 0)
3979     {
3980       bfd_boolean has_reloc = (abfd->flags & HAS_RELOC);
3981       bfd_map_over_sections (abfd, adjust_addresses, &has_reloc);
3982     }
3983
3984   if (! dump_debugging_tags && ! suppress_bfd_header)
3985     printf (_("\n%s:     file format %s\n"),
3986             sanitize_string (bfd_get_filename (abfd)),
3987             abfd->xvec->name);
3988   if (dump_ar_hdrs)
3989     print_arelt_descr (stdout, abfd, TRUE, FALSE);
3990   if (dump_file_header)
3991     dump_bfd_header (abfd);
3992   if (dump_private_headers)
3993     dump_bfd_private_header (abfd);
3994   if (dump_private_options != NULL)
3995     dump_target_specific (abfd);
3996   if (! dump_debugging_tags && ! suppress_bfd_header)
3997     putchar ('\n');
3998
3999   if (dump_symtab
4000       || dump_reloc_info
4001       || disassemble
4002       || dump_debugging
4003       || dump_dwarf_section_info)
4004     {
4005       syms = slurp_symtab (abfd);
4006
4007       /* If following links, load any symbol tables from the linked files as well.  */
4008       if (do_follow_links && is_mainfile)
4009         {
4010           separate_info * i;
4011
4012           for (i = first_separate_info; i != NULL; i = i->next)
4013             {
4014               asymbol **  extra_syms;
4015               long        old_symcount = symcount;
4016
4017               extra_syms = slurp_symtab (i->handle);
4018
4019               if (extra_syms)
4020                 {
4021                   if (old_symcount == 0)
4022                     {
4023                       syms = extra_syms;
4024                     }
4025                   else
4026                     {
4027                       syms = xrealloc (syms, (symcount + old_symcount) * sizeof (asymbol *));
4028                       memcpy (syms + old_symcount,
4029                               extra_syms,
4030                               symcount * sizeof (asymbol *));
4031                     }
4032                 }
4033
4034               symcount += old_symcount;
4035             }
4036         }
4037     }
4038
4039   if (dump_section_headers)
4040     dump_headers (abfd);
4041
4042   if (dump_dynamic_symtab || dump_dynamic_reloc_info
4043       || (disassemble && bfd_get_dynamic_symtab_upper_bound (abfd) > 0))
4044     dynsyms = slurp_dynamic_symtab (abfd);
4045
4046   if (disassemble)
4047     {
4048       synthcount = bfd_get_synthetic_symtab (abfd, symcount, syms,
4049                                              dynsymcount, dynsyms, &synthsyms);
4050       if (synthcount < 0)
4051         synthcount = 0;
4052     }
4053
4054   if (dump_symtab)
4055     dump_symbols (abfd, FALSE);
4056   if (dump_dynamic_symtab)
4057     dump_symbols (abfd, TRUE);
4058   if (dump_dwarf_section_info)
4059     dump_dwarf (abfd);
4060 #ifdef HAVE_LIBCTF
4061   if (dump_ctf_section_info)
4062     dump_ctf (abfd, dump_ctf_section_name, dump_ctf_parent_name);
4063 #endif
4064   if (dump_stab_section_info)
4065     dump_stabs (abfd);
4066   if (dump_reloc_info && ! disassemble)
4067     dump_relocs (abfd);
4068   if (dump_dynamic_reloc_info && ! disassemble)
4069     dump_dynamic_relocs (abfd);
4070   if (dump_section_contents)
4071     dump_data (abfd);
4072   if (disassemble)
4073     disassemble_data (abfd);
4074
4075   if (dump_debugging)
4076     {
4077       void *dhandle;
4078
4079       dhandle = read_debugging_info (abfd, syms, symcount, TRUE);
4080       if (dhandle != NULL)
4081         {
4082           if (!print_debugging_info (stdout, dhandle, abfd, syms,
4083                                      bfd_demangle,
4084                                      dump_debugging_tags ? TRUE : FALSE))
4085             {
4086               non_fatal (_("%s: printing debugging information failed"),
4087                          bfd_get_filename (abfd));
4088               exit_status = 1;
4089             }
4090
4091           free (dhandle);
4092         }
4093       /* PR 6483: If there was no STABS debug info in the file, try
4094          DWARF instead.  */
4095       else if (! dump_dwarf_section_info)
4096         {
4097           dwarf_select_sections_all ();
4098           dump_dwarf (abfd);
4099         }
4100     }
4101
4102   if (syms)
4103     {
4104       free (syms);
4105       syms = NULL;
4106     }
4107
4108   if (dynsyms)
4109     {
4110       free (dynsyms);
4111       dynsyms = NULL;
4112     }
4113
4114   if (synthsyms)
4115     {
4116       free (synthsyms);
4117       synthsyms = NULL;
4118     }
4119
4120   symcount = 0;
4121   dynsymcount = 0;
4122   synthcount = 0;
4123
4124   if (is_mainfile)
4125     free_debug_memory ();
4126 }
4127
4128 static void
4129 display_object_bfd (bfd *abfd)
4130 {
4131   char **matching;
4132
4133   if (bfd_check_format_matches (abfd, bfd_object, &matching))
4134     {
4135       dump_bfd (abfd, TRUE);
4136       return;
4137     }
4138
4139   if (bfd_get_error () == bfd_error_file_ambiguously_recognized)
4140     {
4141       nonfatal (bfd_get_filename (abfd));
4142       list_matching_formats (matching);
4143       free (matching);
4144       return;
4145     }
4146
4147   if (bfd_get_error () != bfd_error_file_not_recognized)
4148     {
4149       nonfatal (bfd_get_filename (abfd));
4150       return;
4151     }
4152
4153   if (bfd_check_format_matches (abfd, bfd_core, &matching))
4154     {
4155       dump_bfd (abfd, TRUE);
4156       return;
4157     }
4158
4159   nonfatal (bfd_get_filename (abfd));
4160
4161   if (bfd_get_error () == bfd_error_file_ambiguously_recognized)
4162     {
4163       list_matching_formats (matching);
4164       free (matching);
4165     }
4166 }
4167
4168 static void
4169 display_any_bfd (bfd *file, int level)
4170 {
4171   /* Decompress sections unless dumping the section contents.  */
4172   if (!dump_section_contents)
4173     file->flags |= BFD_DECOMPRESS;
4174
4175   /* If the file is an archive, process all of its elements.  */
4176   if (bfd_check_format (file, bfd_archive))
4177     {
4178       bfd *arfile = NULL;
4179       bfd *last_arfile = NULL;
4180
4181       if (level == 0)
4182         printf (_("In archive %s:\n"), sanitize_string (bfd_get_filename (file)));
4183       else if (level > 100)
4184         {
4185           /* Prevent corrupted files from spinning us into an
4186              infinite loop.  100 is an arbitrary heuristic.  */
4187           fatal (_("Archive nesting is too deep"));
4188           return;
4189         }
4190       else
4191         printf (_("In nested archive %s:\n"),
4192                 sanitize_string (bfd_get_filename (file)));
4193
4194       for (;;)
4195         {
4196           bfd_set_error (bfd_error_no_error);
4197
4198           arfile = bfd_openr_next_archived_file (file, arfile);
4199           if (arfile == NULL)
4200             {
4201               if (bfd_get_error () != bfd_error_no_more_archived_files)
4202                 nonfatal (bfd_get_filename (file));
4203               break;
4204             }
4205
4206           display_any_bfd (arfile, level + 1);
4207
4208           if (last_arfile != NULL)
4209             {
4210               bfd_close (last_arfile);
4211               /* PR 17512: file: ac585d01.  */
4212               if (arfile == last_arfile)
4213                 {
4214                   last_arfile = NULL;
4215                   break;
4216                 }
4217             }
4218           last_arfile = arfile;
4219         }
4220
4221       if (last_arfile != NULL)
4222         bfd_close (last_arfile);
4223     }
4224   else
4225     display_object_bfd (file);
4226 }
4227
4228 static void
4229 display_file (char *filename, char *target, bfd_boolean last_file)
4230 {
4231   bfd *file;
4232
4233   if (get_file_size (filename) < 1)
4234     {
4235       exit_status = 1;
4236       return;
4237     }
4238
4239   file = bfd_openr (filename, target);
4240   if (file == NULL)
4241     {
4242       nonfatal (filename);
4243       return;
4244     }
4245
4246   display_any_bfd (file, 0);
4247
4248   /* This is an optimization to improve the speed of objdump, especially when
4249      dumping a file with lots of associated debug informatiom.  Calling
4250      bfd_close on such a file can take a non-trivial amount of time as there
4251      are lots of lists to walk and buffers to free.  This is only really
4252      necessary however if we are about to load another file and we need the
4253      memory back.  Otherwise, if we are about to exit, then we can save (a lot
4254      of) time by only doing a quick close, and allowing the OS to reclaim the
4255      memory for us.  */
4256   if (! last_file)
4257     bfd_close (file);
4258   else
4259     bfd_close_all_done (file);
4260 }
4261 \f
4262 int
4263 main (int argc, char **argv)
4264 {
4265   int c;
4266   char *target = default_target;
4267   bfd_boolean seenflag = FALSE;
4268
4269 #if defined (HAVE_SETLOCALE)
4270 #if defined (HAVE_LC_MESSAGES)
4271   setlocale (LC_MESSAGES, "");
4272 #endif
4273   setlocale (LC_CTYPE, "");
4274 #endif
4275
4276   bindtextdomain (PACKAGE, LOCALEDIR);
4277   textdomain (PACKAGE);
4278
4279   program_name = *argv;
4280   xmalloc_set_program_name (program_name);
4281   bfd_set_error_program_name (program_name);
4282
4283   START_PROGRESS (program_name, 0);
4284
4285   expandargv (&argc, &argv);
4286
4287   if (bfd_init () != BFD_INIT_MAGIC)
4288     fatal (_("fatal error: libbfd ABI mismatch"));
4289   set_default_bfd_target ();
4290
4291   while ((c = getopt_long (argc, argv,
4292                            "pP:ib:m:M:VvCdDlfFaHhrRtTxsSI:j:wE:zgeGW::",
4293                            long_options, (int *) 0))
4294          != EOF)
4295     {
4296       switch (c)
4297         {
4298         case 0:
4299           break;                /* We've been given a long option.  */
4300         case 'm':
4301           machine = optarg;
4302           break;
4303         case 'M':
4304           {
4305             char *options;
4306             if (disassembler_options)
4307               /* Ignore potential memory leak for now.  */
4308               options = concat (disassembler_options, ",",
4309                                 optarg, (const char *) NULL);
4310             else
4311               options = optarg;
4312             disassembler_options = remove_whitespace_and_extra_commas (options);
4313           }
4314           break;
4315         case 'j':
4316           add_only (optarg);
4317           break;
4318         case 'F':
4319           display_file_offsets = TRUE;
4320           break;
4321         case 'l':
4322           with_line_numbers = TRUE;
4323           break;
4324         case 'b':
4325           target = optarg;
4326           break;
4327         case 'C':
4328           do_demangle = TRUE;
4329           if (optarg != NULL)
4330             {
4331               enum demangling_styles style;
4332
4333               style = cplus_demangle_name_to_style (optarg);
4334               if (style == unknown_demangling)
4335                 fatal (_("unknown demangling style `%s'"),
4336                        optarg);
4337
4338               cplus_demangle_set_style (style);
4339             }
4340           break;
4341         case OPTION_RECURSE_LIMIT:
4342           demangle_flags &= ~ DMGL_NO_RECURSE_LIMIT;
4343           break;
4344         case OPTION_NO_RECURSE_LIMIT:
4345           demangle_flags |= DMGL_NO_RECURSE_LIMIT;
4346           break;
4347         case 'w':
4348           do_wide = wide_output = TRUE;
4349           break;
4350         case OPTION_ADJUST_VMA:
4351           adjust_section_vma = parse_vma (optarg, "--adjust-vma");
4352           break;
4353         case OPTION_START_ADDRESS:
4354           start_address = parse_vma (optarg, "--start-address");
4355           if ((stop_address != (bfd_vma) -1) && stop_address <= start_address)
4356             fatal (_("error: the start address should be before the end address"));
4357           break;
4358         case OPTION_STOP_ADDRESS:
4359           stop_address = parse_vma (optarg, "--stop-address");
4360           if ((start_address != (bfd_vma) -1) && stop_address <= start_address)
4361             fatal (_("error: the stop address should be after the start address"));
4362           break;
4363         case OPTION_PREFIX:
4364           prefix = optarg;
4365           prefix_length = strlen (prefix);
4366           /* Remove an unnecessary trailing '/' */
4367           while (IS_DIR_SEPARATOR (prefix[prefix_length - 1]))
4368             prefix_length--;
4369           break;
4370         case OPTION_PREFIX_STRIP:
4371           prefix_strip = atoi (optarg);
4372           if (prefix_strip < 0)
4373             fatal (_("error: prefix strip must be non-negative"));
4374           break;
4375         case OPTION_INSN_WIDTH:
4376           insn_width = strtoul (optarg, NULL, 0);
4377           if (insn_width <= 0)
4378             fatal (_("error: instruction width must be positive"));
4379           break;
4380         case OPTION_INLINES:
4381           unwind_inlines = TRUE;
4382           break;
4383         case 'E':
4384           if (strcmp (optarg, "B") == 0)
4385             endian = BFD_ENDIAN_BIG;
4386           else if (strcmp (optarg, "L") == 0)
4387             endian = BFD_ENDIAN_LITTLE;
4388           else
4389             {
4390               nonfatal (_("unrecognized -E option"));
4391               usage (stderr, 1);
4392             }
4393           break;
4394         case OPTION_ENDIAN:
4395           if (strncmp (optarg, "big", strlen (optarg)) == 0)
4396             endian = BFD_ENDIAN_BIG;
4397           else if (strncmp (optarg, "little", strlen (optarg)) == 0)
4398             endian = BFD_ENDIAN_LITTLE;
4399           else
4400             {
4401               non_fatal (_("unrecognized --endian type `%s'"), optarg);
4402               exit_status = 1;
4403               usage (stderr, 1);
4404             }
4405           break;
4406
4407         case 'f':
4408           dump_file_header = TRUE;
4409           seenflag = TRUE;
4410           break;
4411         case 'i':
4412           formats_info = TRUE;
4413           seenflag = TRUE;
4414           break;
4415         case 'I':
4416           add_include_path (optarg);
4417           break;
4418         case 'p':
4419           dump_private_headers = TRUE;
4420           seenflag = TRUE;
4421           break;
4422         case 'P':
4423           dump_private_options = optarg;
4424           seenflag = TRUE;
4425           break;
4426         case 'x':
4427           dump_private_headers = TRUE;
4428           dump_symtab = TRUE;
4429           dump_reloc_info = TRUE;
4430           dump_file_header = TRUE;
4431           dump_ar_hdrs = TRUE;
4432           dump_section_headers = TRUE;
4433           seenflag = TRUE;
4434           break;
4435         case 't':
4436           dump_symtab = TRUE;
4437           seenflag = TRUE;
4438           break;
4439         case 'T':
4440           dump_dynamic_symtab = TRUE;
4441           seenflag = TRUE;
4442           break;
4443         case 'd':
4444           disassemble = TRUE;
4445           seenflag = TRUE;
4446           disasm_sym = optarg;
4447           break;
4448         case 'z':
4449           disassemble_zeroes = TRUE;
4450           break;
4451         case 'D':
4452           disassemble = TRUE;
4453           disassemble_all = TRUE;
4454           seenflag = TRUE;
4455           break;
4456         case 'S':
4457           disassemble = TRUE;
4458           with_source_code = TRUE;
4459           seenflag = TRUE;
4460           break;
4461         case 'g':
4462           dump_debugging = 1;
4463           seenflag = TRUE;
4464           break;
4465         case 'e':
4466           dump_debugging = 1;
4467           dump_debugging_tags = 1;
4468           do_demangle = TRUE;
4469           seenflag = TRUE;
4470           break;
4471         case 'W':
4472           dump_dwarf_section_info = TRUE;
4473           seenflag = TRUE;
4474           if (optarg)
4475             dwarf_select_sections_by_letters (optarg);
4476           else
4477             dwarf_select_sections_all ();
4478           break;
4479         case OPTION_DWARF:
4480           dump_dwarf_section_info = TRUE;
4481           seenflag = TRUE;
4482           if (optarg)
4483             dwarf_select_sections_by_names (optarg);
4484           else
4485             dwarf_select_sections_all ();
4486           break;
4487         case OPTION_DWARF_DEPTH:
4488           {
4489             char *cp;
4490             dwarf_cutoff_level = strtoul (optarg, & cp, 0);
4491           }
4492           break;
4493         case OPTION_DWARF_START:
4494           {
4495             char *cp;
4496             dwarf_start_die = strtoul (optarg, & cp, 0);
4497             suppress_bfd_header = 1;
4498           }
4499           break;
4500         case OPTION_DWARF_CHECK:
4501           dwarf_check = TRUE;
4502           break;
4503 #ifdef HAVE_LIBCTF
4504         case OPTION_CTF:
4505           dump_ctf_section_info = TRUE;
4506           dump_ctf_section_name = xstrdup (optarg);
4507           seenflag = TRUE;
4508           break;
4509         case OPTION_CTF_PARENT:
4510           dump_ctf_parent_name = xstrdup (optarg);
4511           break;
4512 #endif
4513         case 'G':
4514           dump_stab_section_info = TRUE;
4515           seenflag = TRUE;
4516           break;
4517         case 's':
4518           dump_section_contents = TRUE;
4519           seenflag = TRUE;
4520           break;
4521         case 'r':
4522           dump_reloc_info = TRUE;
4523           seenflag = TRUE;
4524           break;
4525         case 'R':
4526           dump_dynamic_reloc_info = TRUE;
4527           seenflag = TRUE;
4528           break;
4529         case 'a':
4530           dump_ar_hdrs = TRUE;
4531           seenflag = TRUE;
4532           break;
4533         case 'h':
4534           dump_section_headers = TRUE;
4535           seenflag = TRUE;
4536           break;
4537         case 'v':
4538         case 'V':
4539           show_version = TRUE;
4540           seenflag = TRUE;
4541           break;
4542
4543         case 'H':
4544           usage (stdout, 0);
4545           /* No need to set seenflag or to break - usage() does not return.  */
4546         default:
4547           usage (stderr, 1);
4548         }
4549     }
4550
4551   if (show_version)
4552     print_version ("objdump");
4553
4554   if (!seenflag)
4555     usage (stderr, 2);
4556
4557   if (formats_info)
4558     exit_status = display_info ();
4559   else
4560     {
4561       if (optind == argc)
4562         display_file ("a.out", target, TRUE);
4563       else
4564         for (; optind < argc;)
4565           {
4566             display_file (argv[optind], target, optind == argc - 1);
4567             optind++;
4568           }
4569     }
4570
4571   free_only_list ();
4572 #ifdef HAVE_LIBCTF
4573   free (dump_ctf_section_name);
4574   free (dump_ctf_parent_name);
4575 #endif
4576   END_PROGRESS (program_name);
4577
4578   return exit_status;
4579 }