binutils/objdump.c

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