binutils/objdump.c

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