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