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