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