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_boolean have_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   have_separates = load_separate_debug_files (abfd, bfd_get_filename (abfd));
2950
2951   bfd_map_over_sections (abfd, dump_dwarf_section, NULL);
2952
2953   if (have_separates)
2954     {
2955       separate_info * i;
2956
2957       for (i = first_separate_info; i != NULL; i = i->next)
2958         bfd_map_over_sections (i->handle, dump_dwarf_section, NULL);
2959
2960       /* The file handles are closed by the call to free_debug_memory() below.  */
2961     }
2962
2963   free_debug_memory ();
2964 }
2965 \f
2966 /* Read ABFD's stabs section STABSECT_NAME, and return a pointer to
2967    it.  Return NULL on failure.   */
2968
2969 static bfd_byte *
2970 read_section_stabs (bfd *abfd, const char *sect_name, bfd_size_type *size_ptr)
2971 {
2972   asection *stabsect;
2973   bfd_byte *contents;
2974
2975   stabsect = bfd_get_section_by_name (abfd, sect_name);
2976   if (stabsect == NULL)
2977     {
2978       printf (_("No %s section present\n\n"),
2979               sanitize_string (sect_name));
2980       return FALSE;
2981     }
2982
2983   if (!bfd_malloc_and_get_section (abfd, stabsect, &contents))
2984     {
2985       non_fatal (_("reading %s section of %s failed: %s"),
2986                  sect_name, bfd_get_filename (abfd),
2987                  bfd_errmsg (bfd_get_error ()));
2988       exit_status = 1;
2989       free (contents);
2990       return NULL;
2991     }
2992
2993   *size_ptr = bfd_section_size (abfd, stabsect);
2994
2995   return contents;
2996 }
2997
2998 /* Stabs entries use a 12 byte format:
2999      4 byte string table index
3000      1 byte stab type
3001      1 byte stab other field
3002      2 byte stab desc field
3003      4 byte stab value
3004    FIXME: This will have to change for a 64 bit object format.  */
3005
3006 #define STRDXOFF  (0)
3007 #define TYPEOFF   (4)
3008 #define OTHEROFF  (5)
3009 #define DESCOFF   (6)
3010 #define VALOFF    (8)
3011 #define STABSIZE (12)
3012
3013 /* Print ABFD's stabs section STABSECT_NAME (in `stabs'),
3014    using string table section STRSECT_NAME (in `strtab').  */
3015
3016 static void
3017 print_section_stabs (bfd *abfd,
3018                      const char *stabsect_name,
3019                      unsigned *string_offset_ptr)
3020 {
3021   int i;
3022   unsigned file_string_table_offset = 0;
3023   unsigned next_file_string_table_offset = *string_offset_ptr;
3024   bfd_byte *stabp, *stabs_end;
3025
3026   stabp = stabs;
3027   stabs_end = stabp + stab_size;
3028
3029   printf (_("Contents of %s section:\n\n"), sanitize_string (stabsect_name));
3030   printf ("Symnum n_type n_othr n_desc n_value  n_strx String\n");
3031
3032   /* Loop through all symbols and print them.
3033
3034      We start the index at -1 because there is a dummy symbol on
3035      the front of stabs-in-{coff,elf} sections that supplies sizes.  */
3036   for (i = -1; stabp <= stabs_end - STABSIZE; stabp += STABSIZE, i++)
3037     {
3038       const char *name;
3039       unsigned long strx;
3040       unsigned char type, other;
3041       unsigned short desc;
3042       bfd_vma value;
3043
3044       strx = bfd_h_get_32 (abfd, stabp + STRDXOFF);
3045       type = bfd_h_get_8 (abfd, stabp + TYPEOFF);
3046       other = bfd_h_get_8 (abfd, stabp + OTHEROFF);
3047       desc = bfd_h_get_16 (abfd, stabp + DESCOFF);
3048       value = bfd_h_get_32 (abfd, stabp + VALOFF);
3049
3050       printf ("\n%-6d ", i);
3051       /* Either print the stab name, or, if unnamed, print its number
3052          again (makes consistent formatting for tools like awk).  */
3053       name = bfd_get_stab_name (type);
3054       if (name != NULL)
3055         printf ("%-6s", sanitize_string (name));
3056       else if (type == N_UNDF)
3057         printf ("HdrSym");
3058       else
3059         printf ("%-6d", type);
3060       printf (" %-6d %-6d ", other, desc);
3061       bfd_printf_vma (abfd, value);
3062       printf (" %-6lu", strx);
3063
3064       /* Symbols with type == 0 (N_UNDF) specify the length of the
3065          string table associated with this file.  We use that info
3066          to know how to relocate the *next* file's string table indices.  */
3067       if (type == N_UNDF)
3068         {
3069           file_string_table_offset = next_file_string_table_offset;
3070           next_file_string_table_offset += value;
3071         }
3072       else
3073         {
3074           bfd_size_type amt = strx + file_string_table_offset;
3075
3076           /* Using the (possibly updated) string table offset, print the
3077              string (if any) associated with this symbol.  */
3078           if (amt < stabstr_size)
3079             /* PR 17512: file: 079-79389-0.001:0.1.
3080                FIXME: May need to sanitize this string before displaying.  */
3081             printf (" %.*s", (int)(stabstr_size - amt), strtab + amt);
3082           else
3083             printf (" *");
3084         }
3085     }
3086   printf ("\n\n");
3087   *string_offset_ptr = next_file_string_table_offset;
3088 }
3089
3090 typedef struct
3091 {
3092   const char * section_name;
3093   const char * string_section_name;
3094   unsigned string_offset;
3095 }
3096 stab_section_names;
3097
3098 static void
3099 find_stabs_section (bfd *abfd, asection *section, void *names)
3100 {
3101   int len;
3102   stab_section_names * sought = (stab_section_names *) names;
3103
3104   /* Check for section names for which stabsect_name is a prefix, to
3105      handle .stab.N, etc.  */
3106   len = strlen (sought->section_name);
3107
3108   /* If the prefix matches, and the files section name ends with a
3109      nul or a digit, then we match.  I.e., we want either an exact
3110      match or a section followed by a number.  */
3111   if (strncmp (sought->section_name, section->name, len) == 0
3112       && (section->name[len] == 0
3113           || (section->name[len] == '.' && ISDIGIT (section->name[len + 1]))))
3114     {
3115       if (strtab == NULL)
3116         strtab = read_section_stabs (abfd, sought->string_section_name,
3117                                      &stabstr_size);
3118
3119       if (strtab)
3120         {
3121           stabs = read_section_stabs (abfd, section->name, &stab_size);
3122           if (stabs)
3123             print_section_stabs (abfd, section->name, &sought->string_offset);
3124         }
3125     }
3126 }
3127
3128 static void
3129 dump_stabs_section (bfd *abfd, char *stabsect_name, char *strsect_name)
3130 {
3131   stab_section_names s;
3132
3133   s.section_name = stabsect_name;
3134   s.string_section_name = strsect_name;
3135   s.string_offset = 0;
3136
3137   bfd_map_over_sections (abfd, find_stabs_section, & s);
3138
3139   free (strtab);
3140   strtab = NULL;
3141 }
3142
3143 /* Dump the any sections containing stabs debugging information.  */
3144
3145 static void
3146 dump_stabs (bfd *abfd)
3147 {
3148   dump_stabs_section (abfd, ".stab", ".stabstr");
3149   dump_stabs_section (abfd, ".stab.excl", ".stab.exclstr");
3150   dump_stabs_section (abfd, ".stab.index", ".stab.indexstr");
3151
3152   /* For Darwin.  */
3153   dump_stabs_section (abfd, "LC_SYMTAB.stabs", "LC_SYMTAB.stabstr");
3154
3155   dump_stabs_section (abfd, "$GDB_SYMBOLS$", "$GDB_STRINGS$");
3156 }
3157 \f
3158 static void
3159 dump_bfd_header (bfd *abfd)
3160 {
3161   char *comma = "";
3162
3163   printf (_("architecture: %s, "),
3164           bfd_printable_arch_mach (bfd_get_arch (abfd),
3165                                    bfd_get_mach (abfd)));
3166   printf (_("flags 0x%08x:\n"), abfd->flags & ~BFD_FLAGS_FOR_BFD_USE_MASK);
3167
3168 #define PF(x, y)    if (abfd->flags & x) {printf("%s%s", comma, y); comma=", ";}
3169   PF (HAS_RELOC, "HAS_RELOC");
3170   PF (EXEC_P, "EXEC_P");
3171   PF (HAS_LINENO, "HAS_LINENO");
3172   PF (HAS_DEBUG, "HAS_DEBUG");
3173   PF (HAS_SYMS, "HAS_SYMS");
3174   PF (HAS_LOCALS, "HAS_LOCALS");
3175   PF (DYNAMIC, "DYNAMIC");
3176   PF (WP_TEXT, "WP_TEXT");
3177   PF (D_PAGED, "D_PAGED");
3178   PF (BFD_IS_RELAXABLE, "BFD_IS_RELAXABLE");
3179   printf (_("\nstart address 0x"));
3180   bfd_printf_vma (abfd, abfd->start_address);
3181   printf ("\n");
3182 }
3183
3184 \f
3185 static void
3186 dump_bfd_private_header (bfd *abfd)
3187 {
3188   if (!bfd_print_private_bfd_data (abfd, stdout))
3189     non_fatal (_("warning: private headers incomplete: %s"),
3190                bfd_errmsg (bfd_get_error ()));
3191 }
3192
3193 static void
3194 dump_target_specific (bfd *abfd)
3195 {
3196   const struct objdump_private_desc * const *desc;
3197   struct objdump_private_option *opt;
3198   char *e, *b;
3199
3200   /* Find the desc.  */
3201   for (desc = objdump_private_vectors; *desc != NULL; desc++)
3202     if ((*desc)->filter (abfd))
3203       break;
3204
3205   if (*desc == NULL)
3206     {
3207       non_fatal (_("option -P/--private not supported by this file"));
3208       return;
3209     }
3210
3211   /* Clear all options.  */
3212   for (opt = (*desc)->options; opt->name; opt++)
3213     opt->selected = FALSE;
3214
3215   /* Decode options.  */
3216   b = dump_private_options;
3217   do
3218     {
3219       e = strchr (b, ',');
3220
3221       if (e)
3222         *e = 0;
3223
3224       for (opt = (*desc)->options; opt->name; opt++)
3225         if (strcmp (opt->name, b) == 0)
3226           {
3227             opt->selected = TRUE;
3228             break;
3229           }
3230       if (opt->name == NULL)
3231         non_fatal (_("target specific dump '%s' not supported"), b);
3232
3233       if (e)
3234         {
3235           *e = ',';
3236           b = e + 1;
3237         }
3238     }
3239   while (e != NULL);
3240
3241   /* Dump.  */
3242   (*desc)->dump (abfd);
3243 }
3244 \f
3245 /* Display a section in hexadecimal format with associated characters.
3246    Each line prefixed by the zero padded address.  */
3247
3248 static void
3249 dump_section (bfd *abfd, asection *section, void *dummy ATTRIBUTE_UNUSED)
3250 {
3251   bfd_byte *data = NULL;
3252   bfd_size_type datasize;
3253   bfd_vma addr_offset;
3254   bfd_vma start_offset;
3255   bfd_vma stop_offset;
3256   unsigned int opb = bfd_octets_per_byte (abfd);
3257   /* Bytes per line.  */
3258   const int onaline = 16;
3259   char buf[64];
3260   int count;
3261   int width;
3262
3263   if ((section->flags & SEC_HAS_CONTENTS) == 0)
3264     return;
3265
3266   if (! process_section_p (section))
3267     return;
3268
3269   if ((datasize = bfd_section_size (abfd, section)) == 0)
3270     return;
3271
3272   /* Compute the address range to display.  */
3273   if (start_address == (bfd_vma) -1
3274       || start_address < section->vma)
3275     start_offset = 0;
3276   else
3277     start_offset = start_address - section->vma;
3278
3279   if (stop_address == (bfd_vma) -1)
3280     stop_offset = datasize / opb;
3281   else
3282     {
3283       if (stop_address < section->vma)
3284         stop_offset = 0;
3285       else
3286         stop_offset = stop_address - section->vma;
3287
3288       if (stop_offset > datasize / opb)
3289         stop_offset = datasize / opb;
3290     }
3291
3292   if (start_offset >= stop_offset)
3293     return;
3294
3295   printf (_("Contents of section %s:"), sanitize_string (section->name));
3296   if (display_file_offsets)
3297     printf (_("  (Starting at file offset: 0x%lx)"),
3298             (unsigned long) (section->filepos + start_offset));
3299   printf ("\n");
3300
3301   if (!bfd_get_full_section_contents (abfd, section, &data))
3302     {
3303       non_fatal (_("Reading section %s failed because: %s"),
3304                  section->name, bfd_errmsg (bfd_get_error ()));
3305       return;
3306     }
3307
3308   width = 4;
3309
3310   bfd_sprintf_vma (abfd, buf, start_offset + section->vma);
3311   if (strlen (buf) >= sizeof (buf))
3312     abort ();
3313
3314   count = 0;
3315   while (buf[count] == '0' && buf[count+1] != '\0')
3316     count++;
3317   count = strlen (buf) - count;
3318   if (count > width)
3319     width = count;
3320
3321   bfd_sprintf_vma (abfd, buf, stop_offset + section->vma - 1);
3322   if (strlen (buf) >= sizeof (buf))
3323     abort ();
3324
3325   count = 0;
3326   while (buf[count] == '0' && buf[count+1] != '\0')
3327     count++;
3328   count = strlen (buf) - count;
3329   if (count > width)
3330     width = count;
3331
3332   for (addr_offset = start_offset;
3333        addr_offset < stop_offset; addr_offset += onaline / opb)
3334     {
3335       bfd_size_type j;
3336
3337       bfd_sprintf_vma (abfd, buf, (addr_offset + section->vma));
3338       count = strlen (buf);
3339       if ((size_t) count >= sizeof (buf))
3340         abort ();
3341
3342       putchar (' ');
3343       while (count < width)
3344         {
3345           putchar ('0');
3346           count++;
3347         }
3348       fputs (buf + count - width, stdout);
3349       putchar (' ');
3350
3351       for (j = addr_offset * opb;
3352            j < addr_offset * opb + onaline; j++)
3353         {
3354           if (j < stop_offset * opb)
3355             printf ("%02x", (unsigned) (data[j]));
3356           else
3357             printf ("  ");
3358           if ((j & 3) == 3)
3359             printf (" ");
3360         }
3361
3362       printf (" ");
3363       for (j = addr_offset * opb;
3364            j < addr_offset * opb + onaline; j++)
3365         {
3366           if (j >= stop_offset * opb)
3367             printf (" ");
3368           else
3369             printf ("%c", ISPRINT (data[j]) ? data[j] : '.');
3370         }
3371       putchar ('\n');
3372     }
3373   free (data);
3374 }
3375
3376 /* Actually display the various requested regions.  */
3377
3378 static void
3379 dump_data (bfd *abfd)
3380 {
3381   bfd_map_over_sections (abfd, dump_section, NULL);
3382 }
3383
3384 /* Should perhaps share code and display with nm?  */
3385
3386 static void
3387 dump_symbols (bfd *abfd ATTRIBUTE_UNUSED, bfd_boolean dynamic)
3388 {
3389   asymbol **current;
3390   long max_count;
3391   long count;
3392
3393   if (dynamic)
3394     {
3395       current = dynsyms;
3396       max_count = dynsymcount;
3397       printf ("DYNAMIC SYMBOL TABLE:\n");
3398     }
3399   else
3400     {
3401       current = syms;
3402       max_count = symcount;
3403       printf ("SYMBOL TABLE:\n");
3404     }
3405
3406   if (max_count == 0)
3407     printf (_("no symbols\n"));
3408
3409   for (count = 0; count < max_count; count++)
3410     {
3411       bfd *cur_bfd;
3412
3413       if (*current == NULL)
3414         printf (_("no information for symbol number %ld\n"), count);
3415
3416       else if ((cur_bfd = bfd_asymbol_bfd (*current)) == NULL)
3417         printf (_("could not determine the type of symbol number %ld\n"),
3418                 count);
3419
3420       else if (process_section_p ((* current)->section)
3421                && (dump_special_syms
3422                    || !bfd_is_target_special_symbol (cur_bfd, *current)))
3423         {
3424           const char *name = (*current)->name;
3425
3426           if (do_demangle && name != NULL && *name != '\0')
3427             {
3428               char *alloc;
3429
3430               /* If we want to demangle the name, we demangle it
3431                  here, and temporarily clobber it while calling
3432                  bfd_print_symbol.  FIXME: This is a gross hack.  */
3433               alloc = bfd_demangle (cur_bfd, name, demangle_flags);
3434               if (alloc != NULL)
3435                 (*current)->name = alloc;
3436               bfd_print_symbol (cur_bfd, stdout, *current,
3437                                 bfd_print_symbol_all);
3438               if (alloc != NULL)
3439                 {
3440                   (*current)->name = name;
3441                   free (alloc);
3442                 }
3443             }
3444           else
3445             bfd_print_symbol (cur_bfd, stdout, *current,
3446                               bfd_print_symbol_all);
3447           printf ("\n");
3448         }
3449
3450       current++;
3451     }
3452   printf ("\n\n");
3453 }
3454 \f
3455 static void
3456 dump_reloc_set (bfd *abfd, asection *sec, arelent **relpp, long relcount)
3457 {
3458   arelent **p;
3459   char *last_filename, *last_functionname;
3460   unsigned int last_line;
3461   unsigned int last_discriminator;
3462
3463   /* Get column headers lined up reasonably.  */
3464   {
3465     static int width;
3466
3467     if (width == 0)
3468       {
3469         char buf[30];
3470
3471         bfd_sprintf_vma (abfd, buf, (bfd_vma) -1);
3472         width = strlen (buf) - 7;
3473       }
3474     printf ("OFFSET %*s TYPE %*s VALUE \n", width, "", 12, "");
3475   }
3476
3477   last_filename = NULL;
3478   last_functionname = NULL;
3479   last_line = 0;
3480   last_discriminator = 0;
3481
3482   for (p = relpp; relcount && *p != NULL; p++, relcount--)
3483     {
3484       arelent *q = *p;
3485       const char *filename, *functionname;
3486       unsigned int linenumber;
3487       unsigned int discriminator;
3488       const char *sym_name;
3489       const char *section_name;
3490       bfd_vma addend2 = 0;
3491
3492       if (start_address != (bfd_vma) -1
3493           && q->address < start_address)
3494         continue;
3495       if (stop_address != (bfd_vma) -1
3496           && q->address > stop_address)
3497         continue;
3498
3499       if (with_line_numbers
3500           && sec != NULL
3501           && bfd_find_nearest_line_discriminator (abfd, sec, syms, q->address,
3502                                                   &filename, &functionname,
3503                                                   &linenumber, &discriminator))
3504         {
3505           if (functionname != NULL
3506               && (last_functionname == NULL
3507                   || strcmp (functionname, last_functionname) != 0))
3508             {
3509               printf ("%s():\n", sanitize_string (functionname));
3510               if (last_functionname != NULL)
3511                 free (last_functionname);
3512               last_functionname = xstrdup (functionname);
3513             }
3514
3515           if (linenumber > 0
3516               && (linenumber != last_line
3517                   || (filename != NULL
3518                       && last_filename != NULL
3519                       && filename_cmp (filename, last_filename) != 0)
3520                   || (discriminator != last_discriminator)))
3521             {
3522               if (discriminator > 0)
3523                 printf ("%s:%u\n", filename == NULL ? "???" :
3524                         sanitize_string (filename), linenumber);
3525               else
3526                 printf ("%s:%u (discriminator %u)\n",
3527                         filename == NULL ? "???" : sanitize_string (filename),
3528                         linenumber, discriminator);
3529               last_line = linenumber;
3530               last_discriminator = discriminator;
3531               if (last_filename != NULL)
3532                 free (last_filename);
3533               if (filename == NULL)
3534                 last_filename = NULL;
3535               else
3536                 last_filename = xstrdup (filename);
3537             }
3538         }
3539
3540       if (q->sym_ptr_ptr && *q->sym_ptr_ptr)
3541         {
3542           sym_name = (*(q->sym_ptr_ptr))->name;
3543           section_name = (*(q->sym_ptr_ptr))->section->name;
3544         }
3545       else
3546         {
3547           sym_name = NULL;
3548           section_name = NULL;
3549         }
3550
3551       bfd_printf_vma (abfd, q->address);
3552       if (q->howto == NULL)
3553         printf (" *unknown*         ");
3554       else if (q->howto->name)
3555         {
3556           const char *name = q->howto->name;
3557
3558           /* R_SPARC_OLO10 relocations contain two addends.
3559              But because 'arelent' lacks enough storage to
3560              store them both, the 64-bit ELF Sparc backend
3561              records this as two relocations.  One R_SPARC_LO10
3562              and one R_SPARC_13, both pointing to the same
3563              address.  This is merely so that we have some
3564              place to store both addend fields.
3565
3566              Undo this transformation, otherwise the output
3567              will be confusing.  */
3568           if (abfd->xvec->flavour == bfd_target_elf_flavour
3569               && elf_tdata(abfd)->elf_header->e_machine == EM_SPARCV9
3570               && relcount > 1
3571               && !strcmp (q->howto->name, "R_SPARC_LO10"))
3572             {
3573               arelent *q2 = *(p + 1);
3574               if (q2 != NULL
3575                   && q2->howto
3576                   && q->address == q2->address
3577                   && !strcmp (q2->howto->name, "R_SPARC_13"))
3578                 {
3579                   name = "R_SPARC_OLO10";
3580                   addend2 = q2->addend;
3581                   p++;
3582                 }
3583             }
3584           printf (" %-16s  ", name);
3585         }
3586       else
3587         printf (" %-16d  ", q->howto->type);
3588
3589       if (sym_name)
3590         {
3591           objdump_print_symname (abfd, NULL, *q->sym_ptr_ptr);
3592         }
3593       else
3594         {
3595           if (section_name == NULL)
3596             section_name = "*unknown*";
3597           printf ("[%s]", sanitize_string (section_name));
3598         }
3599
3600       if (q->addend)
3601         {
3602           bfd_signed_vma addend = q->addend;
3603           if (addend < 0)
3604             {
3605               printf ("-0x");
3606               addend = -addend;
3607             }
3608           else
3609             printf ("+0x");
3610           bfd_printf_vma (abfd, addend);
3611         }
3612       if (addend2)
3613         {
3614           printf ("+0x");
3615           bfd_printf_vma (abfd, addend2);
3616         }
3617
3618       printf ("\n");
3619     }
3620
3621   if (last_filename != NULL)
3622     free (last_filename);
3623   if (last_functionname != NULL)
3624     free (last_functionname);
3625 }
3626
3627 static void
3628 dump_relocs_in_section (bfd *abfd,
3629                         asection *section,
3630                         void *dummy ATTRIBUTE_UNUSED)
3631 {
3632   arelent **relpp;
3633   long relcount;
3634   long relsize;
3635
3636   if (   bfd_is_abs_section (section)
3637       || bfd_is_und_section (section)
3638       || bfd_is_com_section (section)
3639       || (! process_section_p (section))
3640       || ((section->flags & SEC_RELOC) == 0))
3641     return;
3642
3643   relsize = bfd_get_reloc_upper_bound (abfd, section);
3644   if (relsize < 0)
3645     bfd_fatal (bfd_get_filename (abfd));
3646
3647   printf ("RELOCATION RECORDS FOR [%s]:", sanitize_string (section->name));
3648
3649   if (relsize == 0)
3650     {
3651       printf (" (none)\n\n");
3652       return;
3653     }
3654
3655   if ((bfd_get_file_flags (abfd) & (BFD_IN_MEMORY | BFD_LINKER_CREATED)) == 0
3656       && (/* Check that the size of the relocs is reasonable.  Note that some
3657              file formats, eg aout, can have relocs whose internal size is
3658              larger than their external size, thus we check the size divided
3659              by four against the file size.  See PR 23931 for an example of
3660              this.  */
3661           ((ufile_ptr) (relsize / 4) > bfd_get_file_size (abfd))
3662           /* Also check the section's reloc count since if this is negative
3663              (or very large) the computation in bfd_get_reloc_upper_bound
3664              may have resulted in returning a small, positive integer.
3665              See PR 22508 for a reproducer.
3666
3667              Note - we check against file size rather than section size as
3668              it is possible for there to be more relocs that apply to a
3669              section than there are bytes in that section.  */
3670           || (section->reloc_count > bfd_get_file_size (abfd))))
3671     {
3672       printf (" (too many: %#x relocs)\n", section->reloc_count);
3673       bfd_set_error (bfd_error_file_truncated);
3674       bfd_fatal (bfd_get_filename (abfd));
3675     }
3676
3677   relpp = (arelent **) xmalloc (relsize);
3678   relcount = bfd_canonicalize_reloc (abfd, section, relpp, syms);
3679
3680   if (relcount < 0)
3681     {
3682       printf ("\n");
3683       non_fatal (_("failed to read relocs in: %s"), sanitize_string (bfd_get_filename (abfd)));
3684       bfd_fatal (_("error message was"));
3685     }
3686   else if (relcount == 0)
3687     printf (" (none)\n\n");
3688   else
3689     {
3690       printf ("\n");
3691       dump_reloc_set (abfd, section, relpp, relcount);
3692       printf ("\n\n");
3693     }
3694   free (relpp);
3695 }
3696
3697 static void
3698 dump_relocs (bfd *abfd)
3699 {
3700   bfd_map_over_sections (abfd, dump_relocs_in_section, NULL);
3701 }
3702
3703 static void
3704 dump_dynamic_relocs (bfd *abfd)
3705 {
3706   long relsize;
3707   arelent **relpp;
3708   long relcount;
3709
3710   relsize = bfd_get_dynamic_reloc_upper_bound (abfd);
3711   if (relsize < 0)
3712     bfd_fatal (bfd_get_filename (abfd));
3713
3714   printf ("DYNAMIC RELOCATION RECORDS");
3715
3716   if (relsize == 0)
3717     printf (" (none)\n\n");
3718   else
3719     {
3720       relpp = (arelent **) xmalloc (relsize);
3721       relcount = bfd_canonicalize_dynamic_reloc (abfd, relpp, dynsyms);
3722
3723       if (relcount < 0)
3724         bfd_fatal (bfd_get_filename (abfd));
3725       else if (relcount == 0)
3726         printf (" (none)\n\n");
3727       else
3728         {
3729           printf ("\n");
3730           dump_reloc_set (abfd, NULL, relpp, relcount);
3731           printf ("\n\n");
3732         }
3733       free (relpp);
3734     }
3735 }
3736
3737 /* Creates a table of paths, to search for source files.  */
3738
3739 static void
3740 add_include_path (const char *path)
3741 {
3742   if (path[0] == 0)
3743     return;
3744   include_path_count++;
3745   include_paths = (const char **)
3746       xrealloc (include_paths, include_path_count * sizeof (*include_paths));
3747 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
3748   if (path[1] == ':' && path[2] == 0)
3749     path = concat (path, ".", (const char *) 0);
3750 #endif
3751   include_paths[include_path_count - 1] = path;
3752 }
3753
3754 static void
3755 adjust_addresses (bfd *abfd ATTRIBUTE_UNUSED,
3756                   asection *section,
3757                   void *arg)
3758 {
3759   if ((section->flags & SEC_DEBUGGING) == 0)
3760     {
3761       bfd_boolean *has_reloc_p = (bfd_boolean *) arg;
3762       section->vma += adjust_section_vma;
3763       if (*has_reloc_p)
3764         section->lma += adjust_section_vma;
3765     }
3766 }
3767
3768 /* Dump selected contents of ABFD.  */
3769
3770 static void
3771 dump_bfd (bfd *abfd)
3772 {
3773   /* If we are adjusting section VMA's, change them all now.  Changing
3774      the BFD information is a hack.  However, we must do it, or
3775      bfd_find_nearest_line will not do the right thing.  */
3776   if (adjust_section_vma != 0)
3777     {
3778       bfd_boolean has_reloc = (abfd->flags & HAS_RELOC);
3779       bfd_map_over_sections (abfd, adjust_addresses, &has_reloc);
3780     }
3781
3782   if (! dump_debugging_tags && ! suppress_bfd_header)
3783     printf (_("\n%s:     file format %s\n"),
3784             sanitize_string (bfd_get_filename (abfd)),
3785             abfd->xvec->name);
3786   if (dump_ar_hdrs)
3787     print_arelt_descr (stdout, abfd, TRUE, FALSE);
3788   if (dump_file_header)
3789     dump_bfd_header (abfd);
3790   if (dump_private_headers)
3791     dump_bfd_private_header (abfd);
3792   if (dump_private_options != NULL)
3793     dump_target_specific (abfd);
3794   if (! dump_debugging_tags && ! suppress_bfd_header)
3795     putchar ('\n');
3796
3797   if (dump_symtab
3798       || dump_reloc_info
3799       || disassemble
3800       || dump_debugging
3801       || dump_dwarf_section_info)
3802     syms = slurp_symtab (abfd);
3803
3804   if (dump_section_headers)
3805     dump_headers (abfd);
3806
3807   if (dump_dynamic_symtab || dump_dynamic_reloc_info
3808       || (disassemble && bfd_get_dynamic_symtab_upper_bound (abfd) > 0))
3809     dynsyms = slurp_dynamic_symtab (abfd);
3810   if (disassemble)
3811     {
3812       synthcount = bfd_get_synthetic_symtab (abfd, symcount, syms,
3813                                              dynsymcount, dynsyms, &synthsyms);
3814       if (synthcount < 0)
3815         synthcount = 0;
3816     }
3817
3818   if (dump_symtab)
3819     dump_symbols (abfd, FALSE);
3820   if (dump_dynamic_symtab)
3821     dump_symbols (abfd, TRUE);
3822   if (dump_dwarf_section_info)
3823     dump_dwarf (abfd);
3824   if (dump_stab_section_info)
3825     dump_stabs (abfd);
3826   if (dump_reloc_info && ! disassemble)
3827     dump_relocs (abfd);
3828   if (dump_dynamic_reloc_info && ! disassemble)
3829     dump_dynamic_relocs (abfd);
3830   if (dump_section_contents)
3831     dump_data (abfd);
3832   if (disassemble)
3833     disassemble_data (abfd);
3834
3835   if (dump_debugging)
3836     {
3837       void *dhandle;
3838
3839       dhandle = read_debugging_info (abfd, syms, symcount, TRUE);
3840       if (dhandle != NULL)
3841         {
3842           if (!print_debugging_info (stdout, dhandle, abfd, syms,
3843                                      bfd_demangle,
3844                                      dump_debugging_tags ? TRUE : FALSE))
3845             {
3846               non_fatal (_("%s: printing debugging information failed"),
3847                          bfd_get_filename (abfd));
3848               exit_status = 1;
3849             }
3850
3851           free (dhandle);
3852         }
3853       /* PR 6483: If there was no STABS debug info in the file, try
3854          DWARF instead.  */
3855       else if (! dump_dwarf_section_info)
3856         {
3857           dwarf_select_sections_all ();
3858           dump_dwarf (abfd);
3859         }
3860     }
3861
3862   if (syms)
3863     {
3864       free (syms);
3865       syms = NULL;
3866     }
3867
3868   if (dynsyms)
3869     {
3870       free (dynsyms);
3871       dynsyms = NULL;
3872     }
3873
3874   if (synthsyms)
3875     {
3876       free (synthsyms);
3877       synthsyms = NULL;
3878     }
3879
3880   symcount = 0;
3881   dynsymcount = 0;
3882   synthcount = 0;
3883 }
3884
3885 static void
3886 display_object_bfd (bfd *abfd)
3887 {
3888   char **matching;
3889
3890   if (bfd_check_format_matches (abfd, bfd_object, &matching))
3891     {
3892       dump_bfd (abfd);
3893       return;
3894     }
3895
3896   if (bfd_get_error () == bfd_error_file_ambiguously_recognized)
3897     {
3898       nonfatal (bfd_get_filename (abfd));
3899       list_matching_formats (matching);
3900       free (matching);
3901       return;
3902     }
3903
3904   if (bfd_get_error () != bfd_error_file_not_recognized)
3905     {
3906       nonfatal (bfd_get_filename (abfd));
3907       return;
3908     }
3909
3910   if (bfd_check_format_matches (abfd, bfd_core, &matching))
3911     {
3912       dump_bfd (abfd);
3913       return;
3914     }
3915
3916   nonfatal (bfd_get_filename (abfd));
3917
3918   if (bfd_get_error () == bfd_error_file_ambiguously_recognized)
3919     {
3920       list_matching_formats (matching);
3921       free (matching);
3922     }
3923 }
3924
3925 static void
3926 display_any_bfd (bfd *file, int level)
3927 {
3928   /* Decompress sections unless dumping the section contents.  */
3929   if (!dump_section_contents)
3930     file->flags |= BFD_DECOMPRESS;
3931
3932   /* If the file is an archive, process all of its elements.  */
3933   if (bfd_check_format (file, bfd_archive))
3934     {
3935       bfd *arfile = NULL;
3936       bfd *last_arfile = NULL;
3937
3938       if (level == 0)
3939         printf (_("In archive %s:\n"), sanitize_string (bfd_get_filename (file)));
3940       else if (level > 100)
3941         {
3942           /* Prevent corrupted files from spinning us into an
3943              infinite loop.  100 is an arbitrary heuristic.  */
3944           fatal (_("Archive nesting is too deep"));
3945           return;
3946         }
3947       else
3948         printf (_("In nested archive %s:\n"),
3949                 sanitize_string (bfd_get_filename (file)));
3950
3951       for (;;)
3952         {
3953           bfd_set_error (bfd_error_no_error);
3954
3955           arfile = bfd_openr_next_archived_file (file, arfile);
3956           if (arfile == NULL)
3957             {
3958               if (bfd_get_error () != bfd_error_no_more_archived_files)
3959                 nonfatal (bfd_get_filename (file));
3960               break;
3961             }
3962
3963           display_any_bfd (arfile, level + 1);
3964
3965           if (last_arfile != NULL)
3966             {
3967               bfd_close (last_arfile);
3968               /* PR 17512: file: ac585d01.  */
3969               if (arfile == last_arfile)
3970                 {
3971                   last_arfile = NULL;
3972                   break;
3973                 }
3974             }
3975           last_arfile = arfile;
3976         }
3977
3978       if (last_arfile != NULL)
3979         bfd_close (last_arfile);
3980     }
3981   else
3982     display_object_bfd (file);
3983 }
3984
3985 static void
3986 display_file (char *filename, char *target, bfd_boolean last_file)
3987 {
3988   bfd *file;
3989
3990   if (get_file_size (filename) < 1)
3991     {
3992       exit_status = 1;
3993       return;
3994     }
3995
3996   file = bfd_openr (filename, target);
3997   if (file == NULL)
3998     {
3999       nonfatal (filename);
4000       return;
4001     }
4002
4003   display_any_bfd (file, 0);
4004
4005   /* This is an optimization to improve the speed of objdump, especially when
4006      dumping a file with lots of associated debug informatiom.  Calling
4007      bfd_close on such a file can take a non-trivial amount of time as there
4008      are lots of lists to walk and buffers to free.  This is only really
4009      necessary however if we are about to load another file and we need the
4010      memory back.  Otherwise, if we are about to exit, then we can save (a lot
4011      of) time by only doing a quick close, and allowing the OS to reclaim the
4012      memory for us.  */
4013   if (! last_file)
4014     bfd_close (file);
4015   else
4016     bfd_close_all_done (file);
4017 }
4018 \f
4019 int
4020 main (int argc, char **argv)
4021 {
4022   int c;
4023   char *target = default_target;
4024   bfd_boolean seenflag = FALSE;
4025
4026 #if defined (HAVE_SETLOCALE)
4027 #if defined (HAVE_LC_MESSAGES)
4028   setlocale (LC_MESSAGES, "");
4029 #endif
4030   setlocale (LC_CTYPE, "");
4031 #endif
4032
4033   bindtextdomain (PACKAGE, LOCALEDIR);
4034   textdomain (PACKAGE);
4035
4036   program_name = *argv;
4037   xmalloc_set_program_name (program_name);
4038   bfd_set_error_program_name (program_name);
4039
4040   START_PROGRESS (program_name, 0);
4041
4042   expandargv (&argc, &argv);
4043
4044   if (bfd_init () != BFD_INIT_MAGIC)
4045     fatal (_("fatal error: libbfd ABI mismatch"));
4046   set_default_bfd_target ();
4047
4048   while ((c = getopt_long (argc, argv,
4049                            "pP:ib:m:M:VvCdDlfFaHhrRtTxsSI:j:wE:zgeGW::",
4050                            long_options, (int *) 0))
4051          != EOF)
4052     {
4053       switch (c)
4054         {
4055         case 0:
4056           break;                /* We've been given a long option.  */
4057         case 'm':
4058           machine = optarg;
4059           break;
4060         case 'M':
4061           {
4062             char *options;
4063             if (disassembler_options)
4064               /* Ignore potential memory leak for now.  */
4065               options = concat (disassembler_options, ",",
4066                                 optarg, (const char *) NULL);
4067             else
4068               options = optarg;
4069             disassembler_options = remove_whitespace_and_extra_commas (options);
4070           }
4071           break;
4072         case 'j':
4073           add_only (optarg);
4074           break;
4075         case 'F':
4076           display_file_offsets = TRUE;
4077           break;
4078         case 'l':
4079           with_line_numbers = TRUE;
4080           break;
4081         case 'b':
4082           target = optarg;
4083           break;
4084         case 'C':
4085           do_demangle = TRUE;
4086           if (optarg != NULL)
4087             {
4088               enum demangling_styles style;
4089
4090               style = cplus_demangle_name_to_style (optarg);
4091               if (style == unknown_demangling)
4092                 fatal (_("unknown demangling style `%s'"),
4093                        optarg);
4094
4095               cplus_demangle_set_style (style);
4096             }
4097           break;
4098         case OPTION_RECURSE_LIMIT:
4099           demangle_flags &= ~ DMGL_NO_RECURSE_LIMIT;
4100           break;
4101         case OPTION_NO_RECURSE_LIMIT:
4102           demangle_flags |= DMGL_NO_RECURSE_LIMIT;
4103           break;
4104         case 'w':
4105           do_wide = wide_output = TRUE;
4106           break;
4107         case OPTION_ADJUST_VMA:
4108           adjust_section_vma = parse_vma (optarg, "--adjust-vma");
4109           break;
4110         case OPTION_START_ADDRESS:
4111           start_address = parse_vma (optarg, "--start-address");
4112           if ((stop_address != (bfd_vma) -1) && stop_address <= start_address)
4113             fatal (_("error: the start address should be before the end address"));
4114           break;
4115         case OPTION_STOP_ADDRESS:
4116           stop_address = parse_vma (optarg, "--stop-address");
4117           if ((start_address != (bfd_vma) -1) && stop_address <= start_address)
4118             fatal (_("error: the stop address should be after the start address"));
4119           break;
4120         case OPTION_PREFIX:
4121           prefix = optarg;
4122           prefix_length = strlen (prefix);
4123           /* Remove an unnecessary trailing '/' */
4124           while (IS_DIR_SEPARATOR (prefix[prefix_length - 1]))
4125             prefix_length--;
4126           break;
4127         case OPTION_PREFIX_STRIP:
4128           prefix_strip = atoi (optarg);
4129           if (prefix_strip < 0)
4130             fatal (_("error: prefix strip must be non-negative"));
4131           break;
4132         case OPTION_INSN_WIDTH:
4133           insn_width = strtoul (optarg, NULL, 0);
4134           if (insn_width <= 0)
4135             fatal (_("error: instruction width must be positive"));
4136           break;
4137         case OPTION_INLINES:
4138           unwind_inlines = TRUE;
4139           break;
4140         case 'E':
4141           if (strcmp (optarg, "B") == 0)
4142             endian = BFD_ENDIAN_BIG;
4143           else if (strcmp (optarg, "L") == 0)
4144             endian = BFD_ENDIAN_LITTLE;
4145           else
4146             {
4147               nonfatal (_("unrecognized -E option"));
4148               usage (stderr, 1);
4149             }
4150           break;
4151         case OPTION_ENDIAN:
4152           if (strncmp (optarg, "big", strlen (optarg)) == 0)
4153             endian = BFD_ENDIAN_BIG;
4154           else if (strncmp (optarg, "little", strlen (optarg)) == 0)
4155             endian = BFD_ENDIAN_LITTLE;
4156           else
4157             {
4158               non_fatal (_("unrecognized --endian type `%s'"), optarg);
4159               exit_status = 1;
4160               usage (stderr, 1);
4161             }
4162           break;
4163
4164         case 'f':
4165           dump_file_header = TRUE;
4166           seenflag = TRUE;
4167           break;
4168         case 'i':
4169           formats_info = TRUE;
4170           seenflag = TRUE;
4171           break;
4172         case 'I':
4173           add_include_path (optarg);
4174           break;
4175         case 'p':
4176           dump_private_headers = TRUE;
4177           seenflag = TRUE;
4178           break;
4179         case 'P':
4180           dump_private_options = optarg;
4181           seenflag = TRUE;
4182           break;
4183         case 'x':
4184           dump_private_headers = TRUE;
4185           dump_symtab = TRUE;
4186           dump_reloc_info = TRUE;
4187           dump_file_header = TRUE;
4188           dump_ar_hdrs = TRUE;
4189           dump_section_headers = TRUE;
4190           seenflag = TRUE;
4191           break;
4192         case 't':
4193           dump_symtab = TRUE;
4194           seenflag = TRUE;
4195           break;
4196         case 'T':
4197           dump_dynamic_symtab = TRUE;
4198           seenflag = TRUE;
4199           break;
4200         case 'd':
4201           disassemble = TRUE;
4202           seenflag = TRUE;
4203           disasm_sym = optarg;
4204           break;
4205         case 'z':
4206           disassemble_zeroes = TRUE;
4207           break;
4208         case 'D':
4209           disassemble = TRUE;
4210           disassemble_all = TRUE;
4211           seenflag = TRUE;
4212           break;
4213         case 'S':
4214           disassemble = TRUE;
4215           with_source_code = TRUE;
4216           seenflag = TRUE;
4217           break;
4218         case 'g':
4219           dump_debugging = 1;
4220           seenflag = TRUE;
4221           break;
4222         case 'e':
4223           dump_debugging = 1;
4224           dump_debugging_tags = 1;
4225           do_demangle = TRUE;
4226           seenflag = TRUE;
4227           break;
4228         case 'W':
4229           dump_dwarf_section_info = TRUE;
4230           seenflag = TRUE;
4231           if (optarg)
4232             dwarf_select_sections_by_letters (optarg);
4233           else
4234             dwarf_select_sections_all ();
4235           break;
4236         case OPTION_DWARF:
4237           dump_dwarf_section_info = TRUE;
4238           seenflag = TRUE;
4239           if (optarg)
4240             dwarf_select_sections_by_names (optarg);
4241           else
4242             dwarf_select_sections_all ();
4243           break;
4244         case OPTION_DWARF_DEPTH:
4245           {
4246             char *cp;
4247             dwarf_cutoff_level = strtoul (optarg, & cp, 0);
4248           }
4249           break;
4250         case OPTION_DWARF_START:
4251           {
4252             char *cp;
4253             dwarf_start_die = strtoul (optarg, & cp, 0);
4254             suppress_bfd_header = 1;
4255           }
4256           break;
4257         case OPTION_DWARF_CHECK:
4258           dwarf_check = TRUE;
4259           break;
4260         case 'G':
4261           dump_stab_section_info = TRUE;
4262           seenflag = TRUE;
4263           break;
4264         case 's':
4265           dump_section_contents = TRUE;
4266           seenflag = TRUE;
4267           break;
4268         case 'r':
4269           dump_reloc_info = TRUE;
4270           seenflag = TRUE;
4271           break;
4272         case 'R':
4273           dump_dynamic_reloc_info = TRUE;
4274           seenflag = TRUE;
4275           break;
4276         case 'a':
4277           dump_ar_hdrs = TRUE;
4278           seenflag = TRUE;
4279           break;
4280         case 'h':
4281           dump_section_headers = TRUE;
4282           seenflag = TRUE;
4283           break;
4284         case 'v':
4285         case 'V':
4286           show_version = TRUE;
4287           seenflag = TRUE;
4288           break;
4289
4290         case 'H':
4291           usage (stdout, 0);
4292           /* No need to set seenflag or to break - usage() does not return.  */
4293         default:
4294           usage (stderr, 1);
4295         }
4296     }
4297
4298   if (show_version)
4299     print_version ("objdump");
4300
4301   if (!seenflag)
4302     usage (stderr, 2);
4303
4304   if (formats_info)
4305     exit_status = display_info ();
4306   else
4307     {
4308       if (optind == argc)
4309         display_file ("a.out", target, TRUE);
4310       else
4311         for (; optind < argc;)
4312           {
4313             display_file (argv[optind], target, optind == argc - 1);
4314             optind++;
4315           }
4316     }
4317
4318   free_only_list ();
4319
4320   END_PROGRESS (program_name);
4321
4322   return exit_status;
4323 }