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