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