binutils/objdump.c

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