binutils/objdump.c

   1 /* objdump.c -- dump information about an object file.
   2    Copyright (C) 1990-2019 Free Software Foundation, Inc.
   3
   4    This file is part of GNU Binutils.
   5
   6    This program is free software; you can redistribute it and/or modify
   7    it under the terms of the GNU General Public License as published by
   8    the Free Software Foundation; either version 3, or (at your option)
   9    any later version.
  10
  11    This program is distributed in the hope that it will be useful,
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14    GNU General Public License for more details.
  15
  16    You should have received a copy of the GNU General Public License
  17    along with this program; if not, write to the Free Software
  18    Foundation, 51 Franklin Street - Fifth Floor, Boston,
  19    MA 02110-1301, USA.  */
  20
  21
  22 /* Objdump overview.
  23
  24    Objdump displays information about one or more object files, either on
  25    their own, or inside libraries.  It is commonly used as a disassembler,
  26    but it can also display information about file headers, symbol tables,
  27    relocations, debugging directives and more.
  28
  29    The flow of execution is as follows:
  30
  31    1. Command line arguments are checked for control switches and the
  32       information to be displayed is selected.
  33
  34    2. Any remaining arguments are assumed to be object files, and they are
  35       processed in order by display_bfd().  If the file is an archive each
  36       of its elements is processed in turn.
  37
  38    3. The file's target architecture and binary file format are determined
  39       by bfd_check_format().  If they are recognised, then dump_bfd() is
  40       called.
  41
  42    4. dump_bfd() in turn calls separate functions to display the requested
  43       item(s) of information(s).  For example disassemble_data() is called if
  44       a disassembly has been requested.
  45
  46    When disassembling the code loops through blocks of instructions bounded
  47    by symbols, calling disassemble_bytes() on each block.  The actual
  48    disassembling is done by the libopcodes library, via a function pointer
  49    supplied by the disassembler() function.  */
  50
  51 #include "sysdep.h"
  52 #include "bfd.h"
  53 #include "elf-bfd.h"
  54 #include "coff-bfd.h"
  55 #include "progress.h"
  56 #include "bucomm.h"
  57 #include "elfcomm.h"
  58 #include "dwarf.h"
  59 #include "getopt.h"
  60 #include "safe-ctype.h"
  61 #include "dis-asm.h"
  62 #include "libiberty.h"
  63 #include "demangle.h"
  64 #include "filenames.h"
  65 #include "debug.h"
  66 #include "budbg.h"
  67 #include "objdump.h"
  68
  69 #ifdef HAVE_MMAP
  70 #include <sys/mman.h>
  71 #endif
  72
  73 /* Internal headers for the ELF .stab-dump code - sorry.  */
  74 #define BYTES_IN_WORD   32
  75 #include "aout/aout64.h"
  76
  77 /* Exit status.  */
  78 static int exit_status = 0;
  79
  80 static char *default_target = NULL;     /* Default at runtime.  */
  81
  82 /* The following variables are set based on arguments passed on the
  83    command line.  */
  84 static int show_version = 0;            /* Show the version number.  */
  85 static int dump_section_contents;       /* -s */
  86 static int dump_section_headers;        /* -h */
  87 static bfd_boolean dump_file_header;    /* -f */
  88 static int dump_symtab;                 /* -t */
  89 static int dump_dynamic_symtab;         /* -T */
  90 static int dump_reloc_info;             /* -r */
  91 static int dump_dynamic_reloc_info;     /* -R */
  92 static int dump_ar_hdrs;                /* -a */
  93 static int dump_private_headers;        /* -p */
  94 static char *dump_private_options;      /* -P */
  95 static int prefix_addresses;            /* --prefix-addresses */
  96 static int with_line_numbers;           /* -l */
  97 static bfd_boolean with_source_code;    /* -S */
  98 static int show_raw_insn;               /* --show-raw-insn */
  99 static int dump_dwarf_section_info;     /* --dwarf */
 100 static int dump_stab_section_info;      /* --stabs */
 101 static int do_demangle;                 /* -C, --demangle */
 102 static bfd_boolean disassemble;         /* -d */
 103 static bfd_boolean disassemble_all;     /* -D */
 104 static int disassemble_zeroes;          /* --disassemble-zeroes */
 105 static bfd_boolean formats_info;        /* -i */
 106 static int wide_output;                 /* -w */
 107 static int insn_width;                  /* --insn-width */
 108 static bfd_vma start_address = (bfd_vma) -1; /* --start-address */
 109 static bfd_vma stop_address = (bfd_vma) -1;  /* --stop-address */
 110 static int dump_debugging;              /* --debugging */
 111 static int dump_debugging_tags;         /* --debugging-tags */
 112 static int suppress_bfd_header;
 113 static int dump_special_syms = 0;       /* --special-syms */
 114 static bfd_vma adjust_section_vma = 0;  /* --adjust-vma */
 115 static int file_start_context = 0;      /* --file-start-context */
 116 static bfd_boolean display_file_offsets;/* -F */
 117 static const char *prefix;              /* --prefix */
 118 static int prefix_strip;                /* --prefix-strip */
 119 static size_t prefix_length;
 120 static bfd_boolean unwind_inlines;      /* --inlines.  */
 121 static const char * disasm_sym;         /* Disassembly start symbol.  */
 122
 123 static int demangle_flags = DMGL_ANSI | DMGL_PARAMS;
 124
 125 /* A structure to record the sections mentioned in -j switches.  */
 126 struct only
 127 {
 128   const char * name; /* The name of the section.  */
 129   bfd_boolean  seen; /* A flag to indicate that the section has been found in one or more input files.  */
 130   struct only * next; /* Pointer to the next structure in the list.  */
 131 };
 132 /* Pointer to an array of 'only' structures.
 133    This pointer is NULL if the -j switch has not been used.  */
 134 static struct only * only_list = NULL;
 135
 136 /* Variables for handling include file path table.  */
 137 static const char **include_paths;
 138 static int include_path_count;
 139
 140 /* Extra info to pass to the section disassembler and address printing
 141    function.  */
 142 struct objdump_disasm_info
 143 {
 144   bfd *              abfd;
 145   asection *         sec;
 146   bfd_boolean        require_sec;
 147   arelent **         dynrelbuf;
 148   long               dynrelcount;
 149   disassembler_ftype disassemble_fn;
 150   arelent *          reloc;
 151   const char *       symbol;
 152 };
 153
 154 /* Architecture to disassemble for, or default if NULL.  */
 155 static char *machine = NULL;
 156
 157 /* Target specific options to the disassembler.  */
 158 static char *disassembler_options = NULL;
 159
 160 /* Endianness to disassemble for, or default if BFD_ENDIAN_UNKNOWN.  */
 161 static enum bfd_endian endian = BFD_ENDIAN_UNKNOWN;
 162
 163 /* The symbol table.  */
 164 static asymbol **syms;
 165
 166 /* Number of symbols in `syms'.  */
 167 static long symcount = 0;
 168
 169 /* The sorted symbol table.  */
 170 static asymbol **sorted_syms;
 171
 172 /* Number of symbols in `sorted_syms'.  */
 173 static long sorted_symcount = 0;
 174
 175 /* The dynamic symbol table.  */
 176 static asymbol **dynsyms;
 177
 178 /* The synthetic symbol table.  */
 179 static asymbol *synthsyms;
 180 static long synthcount = 0;
 181
 182 /* Number of symbols in `dynsyms'.  */
 183 static long dynsymcount = 0;
 184
 185 static bfd_byte *stabs;
 186 static bfd_size_type stab_size;
 187
 188 static bfd_byte *strtab;
 189 static bfd_size_type stabstr_size;
 190
 191 static bfd_boolean is_relocatable = FALSE;
 192
 193 /* Handlers for -P/--private.  */
 194 static const struct objdump_private_desc * const objdump_private_vectors[] =
 195   {
 196     OBJDUMP_PRIVATE_VECTORS
 197     NULL
 198   };
 199 \f
 200 static void usage (FILE *, int) ATTRIBUTE_NORETURN;
 201 static void
 202 usage (FILE *stream, int status)
 203 {
 204   fprintf (stream, _("Usage: %s <option(s)> <file(s)>\n"), program_name);
 205   fprintf (stream, _(" Display information from object <file(s)>.\n"));
 206   fprintf (stream, _(" At least one of the following switches must be given:\n"));
 207   fprintf (stream, _("\
 208   -a, --archive-headers    Display archive header information\n\
 209   -f, --file-headers       Display the contents of the overall file header\n\
 210   -p, --private-headers    Display object format specific file header contents\n\
 211   -P, --private=OPT,OPT... Display object format specific contents\n\
 212   -h, --[section-]headers  Display the contents of the section headers\n\
 213   -x, --all-headers        Display the contents of all headers\n\
 214   -d, --disassemble        Display assembler contents of executable sections\n\
 215   -D, --disassemble-all    Display assembler contents of all sections\n\
 216       --disassemble=<sym>  Display assembler contents from <sym>\n\
 217   -S, --source             Intermix source code with disassembly\n\
 218   -s, --full-contents      Display the full contents of all sections requested\n\
 219   -g, --debugging          Display debug information in object file\n\
 220   -e, --debugging-tags     Display debug information using ctags style\n\
 221   -G, --stabs              Display (in raw form) any STABS info in the file\n\
 222   -W[lLiaprmfFsoRtUuTgAckK] or\n\
 223   --dwarf[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
 224           =frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
 225           =gdb_index,=trace_info,=trace_abbrev,=trace_aranges,\n\
 226           =addr,=cu_index,=links,=follow-links]\n\
 227                            Display DWARF info in the file\n\
 228   -t, --syms               Display the contents of the symbol table(s)\n\
 229   -T, --dynamic-syms       Display the contents of the dynamic symbol table\n\
 230   -r, --reloc              Display the relocation entries in the file\n\
 231   -R, --dynamic-reloc      Display the dynamic relocation entries in the file\n\
 232   @<file>                  Read options from <file>\n\
 233   -v, --version            Display this program's version number\n\
 234   -i, --info               List object formats and architectures supported\n\
 235   -H, --help               Display this information\n\
 236 "));
 237   if (status != 2)
 238     {
 239       const struct objdump_private_desc * const *desc;
 240
 241       fprintf (stream, _("\n The following switches are optional:\n"));
 242       fprintf (stream, _("\
 243   -b, --target=BFDNAME           Specify the target object format as BFDNAME\n\
 244   -m, --architecture=MACHINE     Specify the target architecture as MACHINE\n\
 245   -j, --section=NAME             Only display information for section NAME\n\
 246   -M, --disassembler-options=OPT Pass text OPT on to the disassembler\n\
 247   -EB --endian=big               Assume big endian format when disassembling\n\
 248   -EL --endian=little            Assume little endian format when disassembling\n\
 249       --file-start-context       Include context from start of file (with -S)\n\
 250   -I, --include=DIR              Add DIR to search list for source files\n\
 251   -l, --line-numbers             Include line numbers and filenames in output\n\
 252   -F, --file-offsets             Include file offsets when displaying information\n\
 253   -C, --demangle[=STYLE]         Decode mangled/processed symbol names\n\
 254                                   The STYLE, if specified, can be `auto', `gnu',\n\
 255                                   `lucid', `arm', `hp', `edg', `gnu-v3', `java'\n\
 256                                   or `gnat'\n\
 257       --recurse-limit            Enable a limit on recursion whilst demangling.  [Default]\n\
 258       --no-recurse-limit         Disable a limit on recursion whilst demangling\n\
 259   -w, --wide                     Format output for more than 80 columns\n\
 260   -z, --disassemble-zeroes       Do not skip blocks of zeroes when disassembling\n\
 261       --start-address=ADDR       Only process data whose address is >= ADDR\n\
 262       --stop-address=ADDR        Only process data whose address is <= ADDR\n\
 263       --prefix-addresses         Print complete address alongside disassembly\n\
 264       --[no-]show-raw-insn       Display hex alongside symbolic disassembly\n\
 265       --insn-width=WIDTH         Display WIDTH bytes on a single line for -d\n\
 266       --adjust-vma=OFFSET        Add OFFSET to all displayed section addresses\n\
 267       --special-syms             Include special symbols in symbol dumps\n\
 268       --inlines                  Print all inlines for source line (with -l)\n\
 269       --prefix=PREFIX            Add PREFIX to absolute paths for -S\n\
 270       --prefix-strip=LEVEL       Strip initial directory names for -S\n"));
 271       fprintf (stream, _("\
 272       --dwarf-depth=N        Do not display DIEs at depth N or greater\n\
 273       --dwarf-start=N        Display DIEs starting with N, at the same depth\n\
 274                              or deeper\n\
 275       --dwarf-check          Make additional dwarf internal consistency checks.\
 276       \n\n"));
 277       list_supported_targets (program_name, stream);
 278       list_supported_architectures (program_name, stream);
 279
 280       disassembler_usage (stream);
 281
 282       if (objdump_private_vectors[0] != NULL)
 283         {
 284           fprintf (stream,
 285                    _("\nOptions supported for -P/--private switch:\n"));
 286           for (desc = objdump_private_vectors; *desc != NULL; desc++)
 287             (*desc)->help (stream);
 288         }
 289     }
 290   if (REPORT_BUGS_TO[0] && status == 0)
 291     fprintf (stream, _("Report bugs to %s.\n"), REPORT_BUGS_TO);
 292   exit (status);
 293 }
 294
 295 /* 150 isn't special; it's just an arbitrary non-ASCII char value.  */
 296 enum option_values
 297   {
 298     OPTION_ENDIAN=150,
 299     OPTION_START_ADDRESS,
 300     OPTION_STOP_ADDRESS,
 301     OPTION_DWARF,
 302     OPTION_PREFIX,
 303     OPTION_PREFIX_STRIP,
 304     OPTION_INSN_WIDTH,
 305     OPTION_ADJUST_VMA,
 306     OPTION_DWARF_DEPTH,
 307     OPTION_DWARF_CHECK,
 308     OPTION_DWARF_START,
 309     OPTION_RECURSE_LIMIT,
 310     OPTION_NO_RECURSE_LIMIT,
 311     OPTION_INLINES
 312   };
 313
 314 static struct option long_options[]=
 315 {
 316   {"adjust-vma", required_argument, NULL, OPTION_ADJUST_VMA},
 317   {"all-headers", no_argument, NULL, 'x'},
 318   {"private-headers", no_argument, NULL, 'p'},
 319   {"private", required_argument, NULL, 'P'},
 320   {"architecture", required_argument, NULL, 'm'},
 321   {"archive-headers", no_argument, NULL, 'a'},
 322   {"debugging", no_argument, NULL, 'g'},
 323   {"debugging-tags", no_argument, NULL, 'e'},
 324   {"demangle", optional_argument, NULL, 'C'},
 325   {"disassemble", optional_argument, NULL, 'd'},
 326   {"disassemble-all", no_argument, NULL, 'D'},
 327   {"disassembler-options", required_argument, NULL, 'M'},
 328   {"disassemble-zeroes", no_argument, NULL, 'z'},
 329   {"dynamic-reloc", no_argument, NULL, 'R'},
 330   {"dynamic-syms", no_argument, NULL, 'T'},
 331   {"endian", required_argument, NULL, OPTION_ENDIAN},
 332   {"file-headers", no_argument, NULL, 'f'},
 333   {"file-offsets", no_argument, NULL, 'F'},
 334   {"file-start-context", no_argument, &file_start_context, 1},
 335   {"full-contents", no_argument, NULL, 's'},
 336   {"headers", no_argument, NULL, 'h'},
 337   {"help", no_argument, NULL, 'H'},
 338   {"info", no_argument, NULL, 'i'},
 339   {"line-numbers", no_argument, NULL, 'l'},
 340   {"no-show-raw-insn", no_argument, &show_raw_insn, -1},
 341   {"prefix-addresses", no_argument, &prefix_addresses, 1},
 342   {"recurse-limit", no_argument, NULL, OPTION_RECURSE_LIMIT},
 343   {"recursion-limit", no_argument, NULL, OPTION_RECURSE_LIMIT},
 344   {"no-recurse-limit", no_argument, NULL, OPTION_NO_RECURSE_LIMIT},
 345   {"no-recursion-limit", no_argument, NULL, OPTION_NO_RECURSE_LIMIT},
 346   {"reloc", no_argument, NULL, 'r'},
 347   {"section", required_argument, NULL, 'j'},
 348   {"section-headers", no_argument, NULL, 'h'},
 349   {"show-raw-insn", no_argument, &show_raw_insn, 1},
 350   {"source", no_argument, NULL, 'S'},
 351   {"special-syms", no_argument, &dump_special_syms, 1},
 352   {"include", required_argument, NULL, 'I'},
 353   {"dwarf", optional_argument, NULL, OPTION_DWARF},
 354   {"stabs", no_argument, NULL, 'G'},
 355   {"start-address", required_argument, NULL, OPTION_START_ADDRESS},
 356   {"stop-address", required_argument, NULL, OPTION_STOP_ADDRESS},
 357   {"syms", no_argument, NULL, 't'},
 358   {"target", required_argument, NULL, 'b'},
 359   {"version", no_argument, NULL, 'V'},
 360   {"wide", no_argument, NULL, 'w'},
 361   {"prefix", required_argument, NULL, OPTION_PREFIX},
 362   {"prefix-strip", required_argument, NULL, OPTION_PREFIX_STRIP},
 363   {"insn-width", required_argument, NULL, OPTION_INSN_WIDTH},
 364   {"dwarf-depth", required_argument, 0, OPTION_DWARF_DEPTH},
 365   {"dwarf-start", required_argument, 0, OPTION_DWARF_START},
 366   {"dwarf-check", no_argument, 0, OPTION_DWARF_CHECK},
 367   {"inlines", no_argument, 0, OPTION_INLINES},
 368   {0, no_argument, 0, 0}
 369 };
 370 \f
 371 static void
 372 nonfatal (const char *msg)
 373 {
 374   bfd_nonfatal (msg);
 375   exit_status = 1;
 376 }
 377
 378 /* Returns a version of IN with any control characters
 379    replaced by escape sequences.  Uses a static buffer
 380    if necessary.  */
 381
 382 static const char *
 383 sanitize_string (const char * in)
 384 {
 385   static char *        buffer = NULL;
 386   static unsigned int  buffer_len = 0;
 387   const char *         original = in;
 388   char *               out;
 389
 390   /* Paranoia.  */
 391   if (in == NULL)
 392     return "";
 393
 394   /* See if any conversion is necessary.  In the majority
 395      of cases it will not be needed.  */
 396   do
 397     {
 398       char c = *in++;
 399
 400       if (c == 0)
 401         return original;
 402
 403       if (ISCNTRL (c))
 404         break;
 405     }
 406   while (1);
 407
 408   /* Copy the input, translating as needed.  */
 409   in = original;
 410   if (buffer_len < (strlen (in) * 2))
 411     {
 412       free ((void *) buffer);
 413       buffer_len = strlen (in) * 2;
 414       buffer = xmalloc (buffer_len + 1);
 415     }
 416
 417   out = buffer;
 418   do
 419     {
 420       char c = *in++;
 421
 422       if (c == 0)
 423         break;
 424
 425       if (!ISCNTRL (c))
 426         *out++ = c;
 427       else
 428         {
 429           *out++ = '^';
 430           *out++ = c + 0x40;
 431         }
 432     }
 433   while (1);
 434
 435   *out = 0;
 436   return buffer;
 437 }
 438
 439 \f
 440 /* Returns TRUE if the specified section should be dumped.  */
 441
 442 static bfd_boolean
 443 process_section_p (asection * section)
 444 {
 445   struct only * only;
 446
 447   if (only_list == NULL)
 448     return TRUE;
 449
 450   for (only = only_list; only; only = only->next)
 451     if (strcmp (only->name, section->name) == 0)
 452       {
 453         only->seen = TRUE;
 454         return TRUE;
 455       }
 456
 457   return FALSE;
 458 }
 459
 460 /* Add an entry to the 'only' list.  */
 461
 462 static void
 463 add_only (char * name)
 464 {
 465   struct only * only;
 466
 467   /* First check to make sure that we do not
 468      already have an entry for this name.  */
 469   for (only = only_list; only; only = only->next)
 470     if (strcmp (only->name, name) == 0)
 471       return;
 472
 473   only = xmalloc (sizeof * only);
 474   only->name = name;
 475   only->seen = FALSE;
 476   only->next = only_list;
 477   only_list = only;
 478 }
 479
 480 /* Release the memory used by the 'only' list.
 481    PR 11225: Issue a warning message for unseen sections.
 482    Only do this if none of the sections were seen.  This is mainly to support
 483    tools like the GAS testsuite where an object file is dumped with a list of
 484    generic section names known to be present in a range of different file
 485    formats.  */
 486
 487 static void
 488 free_only_list (void)
 489 {
 490   bfd_boolean at_least_one_seen = FALSE;
 491   struct only * only;
 492   struct only * next;
 493
 494   if (only_list == NULL)
 495     return;
 496
 497   for (only = only_list; only; only = only->next)
 498     if (only->seen)
 499       {
 500         at_least_one_seen = TRUE;
 501         break;
 502       }
 503
 504   for (only = only_list; only; only = next)
 505     {
 506       if (! at_least_one_seen)
 507         {
 508           non_fatal (_("section '%s' mentioned in a -j option, "
 509                        "but not found in any input file"),
 510                      only->name);
 511           exit_status = 1;
 512         }
 513       next = only->next;
 514       free (only);
 515     }
 516 }
 517
 518 \f
 519 static void
 520 dump_section_header (bfd *abfd, asection *section, void *data)
 521 {
 522   char *comma = "";
 523   unsigned int opb = bfd_octets_per_byte (abfd);
 524   int longest_section_name = *((int *) data);
 525
 526   /* Ignore linker created section.  See elfNN_ia64_object_p in
 527      bfd/elfxx-ia64.c.  */
 528   if (section->flags & SEC_LINKER_CREATED)
 529     return;
 530
 531   /* PR 10413: Skip sections that we are ignoring.  */
 532   if (! process_section_p (section))
 533     return;
 534
 535   printf ("%3d %-*s %08lx  ", section->index, longest_section_name,
 536           sanitize_string (bfd_get_section_name (abfd, section)),
 537           (unsigned long) bfd_section_size (abfd, section) / opb);
 538   bfd_printf_vma (abfd, bfd_get_section_vma (abfd, section));
 539   printf ("  ");
 540   bfd_printf_vma (abfd, section->lma);
 541   printf ("  %08lx  2**%u", (unsigned long) section->filepos,
 542           bfd_get_section_alignment (abfd, section));
 543   if (! wide_output)
 544     printf ("\n                ");
 545   printf ("  ");
 546
 547 #define PF(x, y) \
 548   if (section->flags & x) { printf ("%s%s", comma, y); comma = ", "; }
 549
 550   PF (SEC_HAS_CONTENTS, "CONTENTS");
 551   PF (SEC_ALLOC, "ALLOC");
 552   PF (SEC_CONSTRUCTOR, "CONSTRUCTOR");
 553   PF (SEC_LOAD, "LOAD");
 554   PF (SEC_RELOC, "RELOC");
 555   PF (SEC_READONLY, "READONLY");
 556   PF (SEC_CODE, "CODE");
 557   PF (SEC_DATA, "DATA");
 558   PF (SEC_ROM, "ROM");
 559   PF (SEC_DEBUGGING, "DEBUGGING");
 560   PF (SEC_NEVER_LOAD, "NEVER_LOAD");
 561   PF (SEC_EXCLUDE, "EXCLUDE");
 562   PF (SEC_SORT_ENTRIES, "SORT_ENTRIES");
 563   if (bfd_get_arch (abfd) == bfd_arch_tic54x)
 564     {
 565       PF (SEC_TIC54X_BLOCK, "BLOCK");
 566       PF (SEC_TIC54X_CLINK, "CLINK");
 567     }
 568   PF (SEC_SMALL_DATA, "SMALL_DATA");
 569   if (bfd_get_flavour (abfd) == bfd_target_coff_flavour)
 570     {
 571       PF (SEC_COFF_SHARED, "SHARED");
 572       PF (SEC_COFF_NOREAD, "NOREAD");
 573     }
 574   else if (bfd_get_flavour (abfd) == bfd_target_elf_flavour)
 575     PF (SEC_ELF_PURECODE, "PURECODE");
 576   PF (SEC_THREAD_LOCAL, "THREAD_LOCAL");
 577   PF (SEC_GROUP, "GROUP");
 578   if (bfd_get_arch (abfd) == bfd_arch_mep)
 579     {
 580       PF (SEC_MEP_VLIW, "VLIW");
 581     }
 582
 583   if ((section->flags & SEC_LINK_ONCE) != 0)
 584     {
 585       const char *ls;
 586       struct coff_comdat_info *comdat;
 587
 588       switch (section->flags & SEC_LINK_DUPLICATES)
 589         {
 590         default:
 591           abort ();
 592         case SEC_LINK_DUPLICATES_DISCARD:
 593           ls = "LINK_ONCE_DISCARD";
 594           break;
 595         case SEC_LINK_DUPLICATES_ONE_ONLY:
 596           ls = "LINK_ONCE_ONE_ONLY";
 597           break;
 598         case SEC_LINK_DUPLICATES_SAME_SIZE:
 599           ls = "LINK_ONCE_SAME_SIZE";
 600           break;
 601         case SEC_LINK_DUPLICATES_SAME_CONTENTS:
 602           ls = "LINK_ONCE_SAME_CONTENTS";
 603           break;
 604         }
 605       printf ("%s%s", comma, ls);
 606
 607       comdat = bfd_coff_get_comdat_section (abfd, section);
 608       if (comdat != NULL)
 609         printf (" (COMDAT %s %ld)", comdat->name, comdat->symbol);
 610
 611       comma = ", ";
 612     }
 613
 614   printf ("\n");
 615 #undef PF
 616 }
 617
 618 /* Called on each SECTION in ABFD, update the int variable pointed to by
 619    DATA which contains the string length of the longest section name.  */
 620
 621 static void
 622 find_longest_section_name (bfd *abfd, asection *section, void *data)
 623 {
 624   int *longest_so_far = (int *) data;
 625   const char *name;
 626   int len;
 627
 628   /* Ignore linker created section.  */
 629   if (section->flags & SEC_LINKER_CREATED)
 630     return;
 631
 632   /* Skip sections that we are ignoring.  */
 633   if (! process_section_p (section))
 634     return;
 635
 636   name = bfd_get_section_name (abfd, section);
 637   len = (int) strlen (name);
 638   if (len > *longest_so_far)
 639     *longest_so_far = len;
 640 }
 641
 642 static void
 643 dump_headers (bfd *abfd)
 644 {
 645   /* The default width of 13 is just an arbitrary choice.  */
 646   int max_section_name_length = 13;
 647   int bfd_vma_width;
 648
 649 #ifndef BFD64
 650   bfd_vma_width = 10;
 651 #else
 652   /* With BFD64, non-ELF returns -1 and wants always 64 bit addresses.  */
 653   if (bfd_get_arch_size (abfd) == 32)
 654     bfd_vma_width = 10;
 655   else
 656     bfd_vma_width = 18;
 657 #endif
 658
 659   printf (_("Sections:\n"));
 660
 661   if (wide_output)
 662     bfd_map_over_sections (abfd, find_longest_section_name,
 663                            &max_section_name_length);
 664
 665   printf (_("Idx %-*s Size      %-*s%-*sFile off  Algn"),
 666           max_section_name_length, "Name",
 667           bfd_vma_width, "VMA",
 668           bfd_vma_width, "LMA");
 669
 670   if (wide_output)
 671     printf (_("  Flags"));
 672   printf ("\n");
 673
 674   bfd_map_over_sections (abfd, dump_section_header,
 675                          &max_section_name_length);
 676 }
 677 \f
 678 static asymbol **
 679 slurp_symtab (bfd *abfd)
 680 {
 681   asymbol **sy = NULL;
 682   long storage;
 683
 684   if (!(bfd_get_file_flags (abfd) & HAS_SYMS))
 685     {
 686       symcount = 0;
 687       return NULL;
 688     }
 689
 690   storage = bfd_get_symtab_upper_bound (abfd);
 691   if (storage < 0)
 692     {
 693       non_fatal (_("failed to read symbol table from: %s"), bfd_get_filename (abfd));
 694       bfd_fatal (_("error message was"));
 695     }
 696   if (storage)
 697     sy = (asymbol **) xmalloc (storage);
 698
 699   symcount = bfd_canonicalize_symtab (abfd, sy);
 700   if (symcount < 0)
 701     bfd_fatal (bfd_get_filename (abfd));
 702   return sy;
 703 }
 704
 705 /* Read in the dynamic symbols.  */
 706
 707 static asymbol **
 708 slurp_dynamic_symtab (bfd *abfd)
 709 {
 710   asymbol **sy = NULL;
 711   long storage;
 712
 713   storage = bfd_get_dynamic_symtab_upper_bound (abfd);
 714   if (storage < 0)
 715     {
 716       if (!(bfd_get_file_flags (abfd) & DYNAMIC))
 717         {
 718           non_fatal (_("%s: not a dynamic object"), bfd_get_filename (abfd));
 719           exit_status = 1;
 720           dynsymcount = 0;
 721           return NULL;
 722         }
 723
 724       bfd_fatal (bfd_get_filename (abfd));
 725     }
 726   if (storage)
 727     sy = (asymbol **) xmalloc (storage);
 728
 729   dynsymcount = bfd_canonicalize_dynamic_symtab (abfd, sy);
 730   if (dynsymcount < 0)
 731     bfd_fatal (bfd_get_filename (abfd));
 732   return sy;
 733 }
 734
 735 /* Some symbol names are significant and should be kept in the
 736    table of sorted symbol names, even if they are marked as
 737    debugging/section symbols.  */
 738
 739 static bfd_boolean
 740 is_significant_symbol_name (const char * name)
 741 {
 742   return strncmp (name, ".plt", 4) == 0 || strcmp (name, ".got") == 0;
 743 }
 744
 745 /* Filter out (in place) symbols that are useless for disassembly.
 746    COUNT is the number of elements in SYMBOLS.
 747    Return the number of useful symbols.  */
 748
 749 static long
 750 remove_useless_symbols (asymbol **symbols, long count)
 751 {
 752   asymbol **in_ptr = symbols, **out_ptr = symbols;
 753
 754   while (--count >= 0)
 755     {
 756       asymbol *sym = *in_ptr++;
 757
 758       if (sym->name == NULL || sym->name[0] == '\0')
 759         continue;
 760       if ((sym->flags & (BSF_DEBUGGING | BSF_SECTION_SYM))
 761           && ! is_significant_symbol_name (sym->name))
 762         continue;
 763       if (bfd_is_und_section (sym->section)
 764           || bfd_is_com_section (sym->section))
 765         continue;
 766
 767       *out_ptr++ = sym;
 768     }
 769   return out_ptr - symbols;
 770 }
 771
 772 /* Sort symbols into value order.  */
 773
 774 static int
 775 compare_symbols (const void *ap, const void *bp)
 776 {
 777   const asymbol *a = * (const asymbol **) ap;
 778   const asymbol *b = * (const asymbol **) bp;
 779   const char *an;
 780   const char *bn;
 781   size_t anl;
 782   size_t bnl;
 783   bfd_boolean af;
 784   bfd_boolean bf;
 785   flagword aflags;
 786   flagword bflags;
 787
 788   if (bfd_asymbol_value (a) > bfd_asymbol_value (b))
 789     return 1;
 790   else if (bfd_asymbol_value (a) < bfd_asymbol_value (b))
 791     return -1;
 792
 793   if (a->section > b->section)
 794     return 1;
 795   else if (a->section < b->section)
 796     return -1;
 797
 798   an = bfd_asymbol_name (a);
 799   bn = bfd_asymbol_name (b);
 800   anl = strlen (an);
 801   bnl = strlen (bn);
 802
 803   /* The symbols gnu_compiled and gcc2_compiled convey no real
 804      information, so put them after other symbols with the same value.  */
 805   af = (strstr (an, "gnu_compiled") != NULL
 806         || strstr (an, "gcc2_compiled") != NULL);
 807   bf = (strstr (bn, "gnu_compiled") != NULL
 808         || strstr (bn, "gcc2_compiled") != NULL);
 809
 810   if (af && ! bf)
 811     return 1;
 812   if (! af && bf)
 813     return -1;
 814
 815   /* We use a heuristic for the file name, to try to sort it after
 816      more useful symbols.  It may not work on non Unix systems, but it
 817      doesn't really matter; the only difference is precisely which
 818      symbol names get printed.  */
 819
 820 #define file_symbol(s, sn, snl)                 \
 821   (((s)->flags & BSF_FILE) != 0                 \
 822    || ((sn)[(snl) - 2] == '.'                   \
 823        && ((sn)[(snl) - 1] == 'o'               \
 824            || (sn)[(snl) - 1] == 'a')))
 825
 826   af = file_symbol (a, an, anl);
 827   bf = file_symbol (b, bn, bnl);
 828
 829   if (af && ! bf)
 830     return 1;
 831   if (! af && bf)
 832     return -1;
 833
 834   /* Try to sort global symbols before local symbols before function
 835      symbols before debugging symbols.  */
 836
 837   aflags = a->flags;
 838   bflags = b->flags;
 839
 840   if ((aflags & BSF_DEBUGGING) != (bflags & BSF_DEBUGGING))
 841     {
 842       if ((aflags & BSF_DEBUGGING) != 0)
 843         return 1;
 844       else
 845         return -1;
 846     }
 847   if ((aflags & BSF_FUNCTION) != (bflags & BSF_FUNCTION))
 848     {
 849       if ((aflags & BSF_FUNCTION) != 0)
 850         return -1;
 851       else
 852         return 1;
 853     }
 854   if ((aflags & BSF_LOCAL) != (bflags & BSF_LOCAL))
 855     {
 856       if ((aflags & BSF_LOCAL) != 0)
 857         return 1;
 858       else
 859         return -1;
 860     }
 861   if ((aflags & BSF_GLOBAL) != (bflags & BSF_GLOBAL))
 862     {
 863       if ((aflags & BSF_GLOBAL) != 0)
 864         return -1;
 865       else
 866         return 1;
 867     }
 868
 869   if (bfd_get_flavour (bfd_asymbol_bfd (a)) == bfd_target_elf_flavour
 870       && bfd_get_flavour (bfd_asymbol_bfd (b)) == bfd_target_elf_flavour)
 871     {
 872       bfd_vma asz, bsz;
 873
 874       asz = 0;
 875       if ((a->flags & (BSF_SECTION_SYM | BSF_SYNTHETIC)) == 0)
 876         asz = ((elf_symbol_type *) a)->internal_elf_sym.st_size;
 877       bsz = 0;
 878       if ((b->flags & (BSF_SECTION_SYM | BSF_SYNTHETIC)) == 0)
 879         bsz = ((elf_symbol_type *) b)->internal_elf_sym.st_size;
 880       if (asz != bsz)
 881         return asz > bsz ? -1 : 1;
 882     }
 883
 884   /* Symbols that start with '.' might be section names, so sort them
 885      after symbols that don't start with '.'.  */
 886   if (an[0] == '.' && bn[0] != '.')
 887     return 1;
 888   if (an[0] != '.' && bn[0] == '.')
 889     return -1;
 890
 891   /* Finally, if we can't distinguish them in any other way, try to
 892      get consistent results by sorting the symbols by name.  */
 893   return strcmp (an, bn);
 894 }
 895
 896 /* Sort relocs into address order.  */
 897
 898 static int
 899 compare_relocs (const void *ap, const void *bp)
 900 {
 901   const arelent *a = * (const arelent **) ap;
 902   const arelent *b = * (const arelent **) bp;
 903
 904   if (a->address > b->address)
 905     return 1;
 906   else if (a->address < b->address)
 907     return -1;
 908
 909   /* So that associated relocations tied to the same address show up
 910      in the correct order, we don't do any further sorting.  */
 911   if (a > b)
 912     return 1;
 913   else if (a < b)
 914     return -1;
 915   else
 916     return 0;
 917 }
 918
 919 /* Print an address (VMA) to the output stream in INFO.
 920    If SKIP_ZEROES is TRUE, omit leading zeroes.  */
 921
 922 static void
 923 objdump_print_value (bfd_vma vma, struct disassemble_info *inf,
 924                      bfd_boolean skip_zeroes)
 925 {
 926   char buf[30];
 927   char *p;
 928   struct objdump_disasm_info *aux;
 929
 930   aux = (struct objdump_disasm_info *) inf->application_data;
 931   bfd_sprintf_vma (aux->abfd, buf, vma);
 932   if (! skip_zeroes)
 933     p = buf;
 934   else
 935     {
 936       for (p = buf; *p == '0'; ++p)
 937         ;
 938       if (*p == '\0')
 939         --p;
 940     }
 941   (*inf->fprintf_func) (inf->stream, "%s", p);
 942 }
 943
 944 /* Print the name of a symbol.  */
 945
 946 static void
 947 objdump_print_symname (bfd *abfd, struct disassemble_info *inf,
 948                        asymbol *sym)
 949 {
 950   char *alloc;
 951   const char *name, *version_string = NULL;
 952   bfd_boolean hidden = FALSE;
 953
 954   alloc = NULL;
 955   name = bfd_asymbol_name (sym);
 956   if (do_demangle && name[0] != '\0')
 957     {
 958       /* Demangle the name.  */
 959       alloc = bfd_demangle (abfd, name, demangle_flags);
 960       if (alloc != NULL)
 961         name = alloc;
 962     }
 963
 964   if ((sym->flags & (BSF_SECTION_SYM | BSF_SYNTHETIC)) == 0)
 965     version_string = bfd_get_symbol_version_string (abfd, sym, &hidden);
 966
 967   if (bfd_is_und_section (bfd_get_section (sym)))
 968     hidden = TRUE;
 969
 970   name = sanitize_string (name);
 971
 972   if (inf != NULL)
 973     {
 974       (*inf->fprintf_func) (inf->stream, "%s", name);
 975       if (version_string && *version_string != '\0')
 976         (*inf->fprintf_func) (inf->stream, hidden ? "@%s" : "@@%s",
 977                               version_string);
 978     }
 979   else
 980     {
 981       printf ("%s", name);
 982       if (version_string && *version_string != '\0')
 983         printf (hidden ? "@%s" : "@@%s", version_string);
 984     }
 985
 986   if (alloc != NULL)
 987     free (alloc);
 988 }
 989
 990 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               octets = (*disassemble_fn) (section->vma + addr_offset, inf);
1995
1996               inf->stop_vma = 0;
1997               inf->fprintf_func = (fprintf_ftype) fprintf;
1998               inf->stream = stdout;
1999               if (insn_width == 0 && inf->bytes_per_line != 0)
2000                 octets_per_line = inf->bytes_per_line;
2001               if (octets < (int) opb)
2002                 {
2003                   if (sfile.pos)
2004                     printf ("%s\n", sfile.buffer);
2005                   if (octets >= 0)
2006                     {
2007                       non_fatal (_("disassemble_fn returned length %d"),
2008                                  octets);
2009                       exit_status = 1;
2010                     }
2011                   break;
2012                 }
2013             }
2014           else
2015             {
2016               bfd_vma j;
2017
2018               octets = octets_per_line;
2019               if (addr_offset + octets / opb > stop_offset)
2020                 octets = (stop_offset - addr_offset) * opb;
2021
2022               for (j = addr_offset * opb; j < addr_offset * opb + octets; ++j)
2023                 {
2024                   if (ISPRINT (data[j]))
2025                     buf[j - addr_offset * opb] = data[j];
2026                   else
2027                     buf[j - addr_offset * opb] = '.';
2028                 }
2029               buf[j - addr_offset * opb] = '\0';
2030             }
2031
2032           if (prefix_addresses
2033               ? show_raw_insn > 0
2034               : show_raw_insn >= 0)
2035             {
2036               bfd_vma j;
2037
2038               /* If ! prefix_addresses and ! wide_output, we print
2039                  octets_per_line octets per line.  */
2040               pb = octets;
2041               if (pb > octets_per_line && ! prefix_addresses && ! wide_output)
2042                 pb = octets_per_line;
2043
2044               if (inf->bytes_per_chunk)
2045                 bpc = inf->bytes_per_chunk;
2046               else
2047                 bpc = 1;
2048
2049               for (j = addr_offset * opb; j < addr_offset * opb + pb; j += bpc)
2050                 {
2051                   /* PR 21580: Check for a buffer ending early.  */
2052                   if (j + bpc <= stop_offset * opb)
2053                     {
2054                       int k;
2055
2056                       if (inf->display_endian == BFD_ENDIAN_LITTLE)
2057                         {
2058                           for (k = bpc - 1; k >= 0; k--)
2059                             printf ("%02x", (unsigned) data[j + k]);
2060                         }
2061                       else
2062                         {
2063                           for (k = 0; k < bpc; k++)
2064                             printf ("%02x", (unsigned) data[j + k]);
2065                         }
2066                     }
2067                   putchar (' ');
2068                 }
2069
2070               for (; pb < octets_per_line; pb += bpc)
2071                 {
2072                   int k;
2073
2074                   for (k = 0; k < bpc; k++)
2075                     printf ("  ");
2076                   putchar (' ');
2077                 }
2078
2079               /* Separate raw data from instruction by extra space.  */
2080               if (insns)
2081                 putchar ('\t');
2082               else
2083                 printf ("    ");
2084             }
2085
2086           if (! insns)
2087             printf ("%s", buf);
2088           else if (sfile.pos)
2089             printf ("%s", sfile.buffer);
2090
2091           if (prefix_addresses
2092               ? show_raw_insn > 0
2093               : show_raw_insn >= 0)
2094             {
2095               while (pb < octets)
2096                 {
2097                   bfd_vma j;
2098                   char *s;
2099
2100                   putchar ('\n');
2101                   j = addr_offset * opb + pb;
2102
2103                   bfd_sprintf_vma (aux->abfd, buf, section->vma + j / opb);
2104                   for (s = buf + skip_addr_chars; *s == '0'; s++)
2105                     *s = ' ';
2106                   if (*s == '\0')
2107                     *--s = '0';
2108                   printf ("%s:\t", buf + skip_addr_chars);
2109
2110                   pb += octets_per_line;
2111                   if (pb > octets)
2112                     pb = octets;
2113                   for (; j < addr_offset * opb + pb; j += bpc)
2114                     {
2115                       /* PR 21619: Check for a buffer ending early.  */
2116                       if (j + bpc <= stop_offset * opb)
2117                         {
2118                           int k;
2119
2120                           if (inf->display_endian == BFD_ENDIAN_LITTLE)
2121                             {
2122                               for (k = bpc - 1; k >= 0; k--)
2123                                 printf ("%02x", (unsigned) data[j + k]);
2124                             }
2125                           else
2126                             {
2127                               for (k = 0; k < bpc; k++)
2128                                 printf ("%02x", (unsigned) data[j + k]);
2129                             }
2130                         }
2131                       putchar (' ');
2132                     }
2133                 }
2134             }
2135
2136           if (!wide_output)
2137             putchar ('\n');
2138           else
2139             need_nl = TRUE;
2140         }
2141
2142       while ((*relppp) < relppend
2143              && (**relppp)->address < rel_offset + addr_offset + octets / opb)
2144         {
2145           if (dump_reloc_info || dump_dynamic_reloc_info)
2146             {
2147               arelent *q;
2148
2149               q = **relppp;
2150
2151               if (wide_output)
2152                 putchar ('\t');
2153               else
2154                 printf ("\t\t\t");
2155
2156               objdump_print_value (section->vma - rel_offset + q->address,
2157                                    inf, TRUE);
2158
2159               if (q->howto == NULL)
2160                 printf (": *unknown*\t");
2161               else if (q->howto->name)
2162                 printf (": %s\t", q->howto->name);
2163               else
2164                 printf (": %d\t", q->howto->type);
2165
2166               if (q->sym_ptr_ptr == NULL || *q->sym_ptr_ptr == NULL)
2167                 printf ("*unknown*");
2168               else
2169                 {
2170                   const char *sym_name;
2171
2172                   sym_name = bfd_asymbol_name (*q->sym_ptr_ptr);
2173                   if (sym_name != NULL && *sym_name != '\0')
2174                     objdump_print_symname (aux->abfd, inf, *q->sym_ptr_ptr);
2175                   else
2176                     {
2177                       asection *sym_sec;
2178
2179                       sym_sec = bfd_get_section (*q->sym_ptr_ptr);
2180                       sym_name = bfd_get_section_name (aux->abfd, sym_sec);
2181                       if (sym_name == NULL || *sym_name == '\0')
2182                         sym_name = "*unknown*";
2183                       printf ("%s", sanitize_string (sym_name));
2184                     }
2185                 }
2186
2187               if (q->addend)
2188                 {
2189                   bfd_signed_vma addend = q->addend;
2190                   if (addend < 0)
2191                     {
2192                       printf ("-0x");
2193                       addend = -addend;
2194                     }
2195                   else
2196                     printf ("+0x");
2197                   objdump_print_value (addend, inf, TRUE);
2198                 }
2199
2200               printf ("\n");
2201               need_nl = FALSE;
2202             }
2203           ++(*relppp);
2204         }
2205
2206       if (need_nl)
2207         printf ("\n");
2208
2209       addr_offset += octets / opb;
2210     }
2211
2212   free (sfile.buffer);
2213 }
2214
2215 static void
2216 disassemble_section (bfd *abfd, asection *section, void *inf)
2217 {
2218   const struct elf_backend_data * bed;
2219   bfd_vma                      sign_adjust = 0;
2220   struct disassemble_info *    pinfo = (struct disassemble_info *) inf;
2221   struct objdump_disasm_info * paux;
2222   unsigned int                 opb = pinfo->octets_per_byte;
2223   bfd_byte *                   data = NULL;
2224   bfd_size_type                datasize = 0;
2225   arelent **                   rel_pp = NULL;
2226   arelent **                   rel_ppstart = NULL;
2227   arelent **                   rel_ppend;
2228   bfd_vma                      stop_offset;
2229   asymbol *                    sym = NULL;
2230   long                         place = 0;
2231   long                         rel_count;
2232   bfd_vma                      rel_offset;
2233   unsigned long                addr_offset;
2234   bfd_boolean                  do_print;
2235   enum loop_control
2236   {
2237    stop_offset_reached,
2238    function_sym,
2239    next_sym
2240   } loop_until;
2241
2242   /* Sections that do not contain machine
2243      code are not normally disassembled.  */
2244   if (! disassemble_all
2245       && only_list == NULL
2246       && ((section->flags & (SEC_CODE | SEC_HAS_CONTENTS))
2247           != (SEC_CODE | SEC_HAS_CONTENTS)))
2248     return;
2249
2250   if (! process_section_p (section))
2251     return;
2252
2253   datasize = bfd_get_section_size (section);
2254   if (datasize == 0)
2255     return;
2256
2257   if (start_address == (bfd_vma) -1
2258       || start_address < section->vma)
2259     addr_offset = 0;
2260   else
2261     addr_offset = start_address - section->vma;
2262
2263   if (stop_address == (bfd_vma) -1)
2264     stop_offset = datasize / opb;
2265   else
2266     {
2267       if (stop_address < section->vma)
2268         stop_offset = 0;
2269       else
2270         stop_offset = stop_address - section->vma;
2271       if (stop_offset > datasize / opb)
2272         stop_offset = datasize / opb;
2273     }
2274
2275   if (addr_offset >= stop_offset)
2276     return;
2277
2278   /* Decide which set of relocs to use.  Load them if necessary.  */
2279   paux = (struct objdump_disasm_info *) pinfo->application_data;
2280   if (paux->dynrelbuf && dump_dynamic_reloc_info)
2281     {
2282       rel_pp = paux->dynrelbuf;
2283       rel_count = paux->dynrelcount;
2284       /* Dynamic reloc addresses are absolute, non-dynamic are section
2285          relative.  REL_OFFSET specifies the reloc address corresponding
2286          to the start of this section.  */
2287       rel_offset = section->vma;
2288     }
2289   else
2290     {
2291       rel_count = 0;
2292       rel_pp = NULL;
2293       rel_offset = 0;
2294
2295       if ((section->flags & SEC_RELOC) != 0
2296           && (dump_reloc_info || pinfo->disassembler_needs_relocs))
2297         {
2298           long relsize;
2299
2300           relsize = bfd_get_reloc_upper_bound (abfd, section);
2301           if (relsize < 0)
2302             bfd_fatal (bfd_get_filename (abfd));
2303
2304           if (relsize > 0)
2305             {
2306               rel_ppstart = rel_pp = (arelent **) xmalloc (relsize);
2307               rel_count = bfd_canonicalize_reloc (abfd, section, rel_pp, syms);
2308               if (rel_count < 0)
2309                 bfd_fatal (bfd_get_filename (abfd));
2310
2311               /* Sort the relocs by address.  */
2312               qsort (rel_pp, rel_count, sizeof (arelent *), compare_relocs);
2313             }
2314         }
2315     }
2316   rel_ppend = rel_pp + rel_count;
2317
2318   if (!bfd_malloc_and_get_section (abfd, section, &data))
2319     {
2320       non_fatal (_("Reading section %s failed because: %s"),
2321                  section->name, bfd_errmsg (bfd_get_error ()));
2322       return;
2323     }
2324
2325   paux->sec = section;
2326   pinfo->buffer = data;
2327   pinfo->buffer_vma = section->vma;
2328   pinfo->buffer_length = datasize;
2329   pinfo->section = section;
2330
2331   /* Skip over the relocs belonging to addresses below the
2332      start address.  */
2333   while (rel_pp < rel_ppend
2334          && (*rel_pp)->address < rel_offset + addr_offset)
2335     ++rel_pp;
2336
2337   printf (_("\nDisassembly of section %s:\n"), sanitize_string (section->name));
2338
2339   /* Find the nearest symbol forwards from our current position.  */
2340   paux->require_sec = TRUE;
2341   sym = (asymbol *) find_symbol_for_address (section->vma + addr_offset,
2342                                              (struct disassemble_info *) inf,
2343                                              &place);
2344   paux->require_sec = FALSE;
2345
2346   /* PR 9774: If the target used signed addresses then we must make
2347      sure that we sign extend the value that we calculate for 'addr'
2348      in the loop below.  */
2349   if (bfd_get_flavour (abfd) == bfd_target_elf_flavour
2350       && (bed = get_elf_backend_data (abfd)) != NULL
2351       && bed->sign_extend_vma)
2352     sign_adjust = (bfd_vma) 1 << (bed->s->arch_size - 1);
2353
2354   /* Disassemble a block of instructions up to the address associated with
2355      the symbol we have just found.  Then print the symbol and find the
2356      next symbol on.  Repeat until we have disassembled the entire section
2357      or we have reached the end of the address range we are interested in.  */
2358   do_print = paux->symbol == NULL;
2359   loop_until = stop_offset_reached;
2360
2361   while (addr_offset < stop_offset)
2362     {
2363       bfd_vma addr;
2364       asymbol *nextsym;
2365       bfd_vma nextstop_offset;
2366       bfd_boolean insns;
2367
2368       addr = section->vma + addr_offset;
2369       addr = ((addr & ((sign_adjust << 1) - 1)) ^ sign_adjust) - sign_adjust;
2370
2371       if (sym != NULL && bfd_asymbol_value (sym) <= addr)
2372         {
2373           int x;
2374
2375           for (x = place;
2376                (x < sorted_symcount
2377                 && (bfd_asymbol_value (sorted_syms[x]) <= addr));
2378                ++x)
2379             continue;
2380
2381           pinfo->symbols = sorted_syms + place;
2382           pinfo->num_symbols = x - place;
2383           pinfo->symtab_pos = place;
2384         }
2385       else
2386         {
2387           pinfo->symbols = NULL;
2388           pinfo->num_symbols = 0;
2389           pinfo->symtab_pos = -1;
2390         }
2391
2392       /* If we are only disassembling from a specific symbol,
2393          check to see if we should start or stop displaying.  */
2394       if (sym && paux->symbol)
2395         {
2396           if (do_print)
2397             {
2398               /* See if we should stop printing.  */
2399               switch (loop_until)
2400                 {
2401                 case function_sym:
2402                   if (sym->flags & BSF_FUNCTION)
2403                     do_print = FALSE;
2404                   break;
2405
2406                 case stop_offset_reached:
2407                   /* Handled by the while loop.  */
2408                   break;
2409
2410                 case next_sym:
2411                   /* FIXME: There is an implicit assumption here
2412                      that the name of sym is different from
2413                      paux->symbol.  */
2414                   if (! bfd_is_local_label (abfd, sym))
2415                     do_print = FALSE;
2416                   break;
2417                 }
2418             }
2419           else
2420             {
2421               const char * name = bfd_asymbol_name (sym);
2422               char * alloc = NULL;
2423
2424               if (do_demangle && name[0] != '\0')
2425                 {
2426                   /* Demangle the name.  */
2427                   alloc = bfd_demangle (abfd, name, demangle_flags);
2428                   if (alloc != NULL)
2429                     name = alloc;
2430                 }
2431
2432               /* We are not currently printing.  Check to see
2433                  if the current symbol matches the requested symbol.  */
2434               if (streq (name, paux->symbol))
2435                 {
2436                   do_print = TRUE;
2437
2438                   if (sym->flags & BSF_FUNCTION)
2439                     {
2440                       if (bfd_get_flavour (abfd) == bfd_target_elf_flavour
2441                           && ((elf_symbol_type *) sym)->internal_elf_sym.st_size > 0)
2442                         {
2443                           /* Sym is a function symbol with a size associated
2444                              with it.  Turn on automatic disassembly for the
2445                              next VALUE bytes.  */
2446                           stop_offset = addr_offset
2447                             + ((elf_symbol_type *) sym)->internal_elf_sym.st_size;
2448                           loop_until = stop_offset_reached;
2449                         }
2450                       else
2451                         {
2452                           /* Otherwise we need to tell the loop heuristic to
2453                              loop until the next function symbol is encountered.  */
2454                           loop_until = function_sym;
2455                         }
2456                     }
2457                   else
2458                     {
2459                       /* Otherwise loop until the next symbol is encountered.  */
2460                       loop_until = next_sym;
2461                     }
2462                 }
2463
2464               free (alloc);
2465             }
2466         }
2467
2468       if (! prefix_addresses && do_print)
2469         {
2470           pinfo->fprintf_func (pinfo->stream, "\n");
2471           objdump_print_addr_with_sym (abfd, section, sym, addr,
2472                                        pinfo, FALSE);
2473           pinfo->fprintf_func (pinfo->stream, ":\n");
2474         }
2475
2476       if (sym != NULL && bfd_asymbol_value (sym) > addr)
2477         nextsym = sym;
2478       else if (sym == NULL)
2479         nextsym = NULL;
2480       else
2481         {
2482 #define is_valid_next_sym(SYM) \
2483   (strcmp (bfd_section_name (abfd, (SYM)->section), bfd_section_name (abfd, section)) == 0 \
2484    && (bfd_asymbol_value (SYM) > bfd_asymbol_value (sym)) \
2485    && pinfo->symbol_is_valid (SYM, pinfo))
2486
2487           /* Search forward for the next appropriate symbol in
2488              SECTION.  Note that all the symbols are sorted
2489              together into one big array, and that some sections
2490              may have overlapping addresses.  */
2491           while (place < sorted_symcount
2492                  && ! is_valid_next_sym (sorted_syms [place]))
2493             ++place;
2494
2495           if (place >= sorted_symcount)
2496             nextsym = NULL;
2497           else
2498             nextsym = sorted_syms[place];
2499         }
2500
2501       if (sym != NULL && bfd_asymbol_value (sym) > addr)
2502         nextstop_offset = bfd_asymbol_value (sym) - section->vma;
2503       else if (nextsym == NULL)
2504         nextstop_offset = stop_offset;
2505       else
2506         nextstop_offset = bfd_asymbol_value (nextsym) - section->vma;
2507
2508       if (nextstop_offset > stop_offset
2509           || nextstop_offset <= addr_offset)
2510         nextstop_offset = stop_offset;
2511
2512       /* If a symbol is explicitly marked as being an object
2513          rather than a function, just dump the bytes without
2514          disassembling them.  */
2515       if (disassemble_all
2516           || sym == NULL
2517           || sym->section != section
2518           || bfd_asymbol_value (sym) > addr
2519           || ((sym->flags & BSF_OBJECT) == 0
2520               && (strstr (bfd_asymbol_name (sym), "gnu_compiled")
2521                   == NULL)
2522               && (strstr (bfd_asymbol_name (sym), "gcc2_compiled")
2523                   == NULL))
2524           || (sym->flags & BSF_FUNCTION) != 0)
2525         insns = TRUE;
2526       else
2527         insns = FALSE;
2528
2529       if (do_print)
2530         disassemble_bytes (pinfo, paux->disassemble_fn, insns, data,
2531                            addr_offset, nextstop_offset,
2532                            rel_offset, &rel_pp, rel_ppend);
2533
2534       addr_offset = nextstop_offset;
2535       sym = nextsym;
2536     }
2537
2538   free (data);
2539
2540   if (rel_ppstart != NULL)
2541     free (rel_ppstart);
2542 }
2543
2544 /* Disassemble the contents of an object file.  */
2545
2546 static void
2547 disassemble_data (bfd *abfd)
2548 {
2549   struct disassemble_info disasm_info;
2550   struct objdump_disasm_info aux;
2551   long i;
2552
2553   print_files = NULL;
2554   prev_functionname = NULL;
2555   prev_line = -1;
2556   prev_discriminator = 0;
2557
2558   /* We make a copy of syms to sort.  We don't want to sort syms
2559      because that will screw up the relocs.  */
2560   sorted_symcount = symcount ? symcount : dynsymcount;
2561   sorted_syms = (asymbol **) xmalloc ((sorted_symcount + synthcount)
2562                                       * sizeof (asymbol *));
2563   memcpy (sorted_syms, symcount ? syms : dynsyms,
2564           sorted_symcount * sizeof (asymbol *));
2565
2566   sorted_symcount = remove_useless_symbols (sorted_syms, sorted_symcount);
2567
2568   for (i = 0; i < synthcount; ++i)
2569     {
2570       sorted_syms[sorted_symcount] = synthsyms + i;
2571       ++sorted_symcount;
2572     }
2573
2574   /* Sort the symbols into section and symbol order.  */
2575   qsort (sorted_syms, sorted_symcount, sizeof (asymbol *), compare_symbols);
2576
2577   init_disassemble_info (&disasm_info, stdout, (fprintf_ftype) fprintf);
2578
2579   disasm_info.application_data = (void *) &aux;
2580   aux.abfd = abfd;
2581   aux.require_sec = FALSE;
2582   aux.dynrelbuf = NULL;
2583   aux.dynrelcount = 0;
2584   aux.reloc = NULL;
2585   aux.symbol = disasm_sym;
2586
2587   disasm_info.print_address_func = objdump_print_address;
2588   disasm_info.symbol_at_address_func = objdump_symbol_at_address;
2589
2590   if (machine != NULL)
2591     {
2592       const bfd_arch_info_type *inf = bfd_scan_arch (machine);
2593
2594       if (inf == NULL)
2595         fatal (_("can't use supplied machine %s"), machine);
2596
2597       abfd->arch_info = inf;
2598     }
2599
2600   if (endian != BFD_ENDIAN_UNKNOWN)
2601     {
2602       struct bfd_target *xvec;
2603
2604       xvec = (struct bfd_target *) xmalloc (sizeof (struct bfd_target));
2605       memcpy (xvec, abfd->xvec, sizeof (struct bfd_target));
2606       xvec->byteorder = endian;
2607       abfd->xvec = xvec;
2608     }
2609
2610   /* Use libopcodes to locate a suitable disassembler.  */
2611   aux.disassemble_fn = disassembler (bfd_get_arch (abfd),
2612                                      bfd_big_endian (abfd),
2613                                      bfd_get_mach (abfd), abfd);
2614   if (!aux.disassemble_fn)
2615     {
2616       non_fatal (_("can't disassemble for architecture %s\n"),
2617                  bfd_printable_arch_mach (bfd_get_arch (abfd), 0));
2618       exit_status = 1;
2619       return;
2620     }
2621
2622   disasm_info.flavour = bfd_get_flavour (abfd);
2623   disasm_info.arch = bfd_get_arch (abfd);
2624   disasm_info.mach = bfd_get_mach (abfd);
2625   disasm_info.disassembler_options = disassembler_options;
2626   disasm_info.octets_per_byte = bfd_octets_per_byte (abfd);
2627   disasm_info.skip_zeroes = DEFAULT_SKIP_ZEROES;
2628   disasm_info.skip_zeroes_at_end = DEFAULT_SKIP_ZEROES_AT_END;
2629   disasm_info.disassembler_needs_relocs = FALSE;
2630
2631   if (bfd_big_endian (abfd))
2632     disasm_info.display_endian = disasm_info.endian = BFD_ENDIAN_BIG;
2633   else if (bfd_little_endian (abfd))
2634     disasm_info.display_endian = disasm_info.endian = BFD_ENDIAN_LITTLE;
2635   else
2636     /* ??? Aborting here seems too drastic.  We could default to big or little
2637        instead.  */
2638     disasm_info.endian = BFD_ENDIAN_UNKNOWN;
2639
2640   /* Allow the target to customize the info structure.  */
2641   disassemble_init_for_target (& disasm_info);
2642
2643   /* Pre-load the dynamic relocs as we may need them during the disassembly.  */
2644     {
2645       long relsize = bfd_get_dynamic_reloc_upper_bound (abfd);
2646
2647       if (relsize < 0 && dump_dynamic_reloc_info)
2648         bfd_fatal (bfd_get_filename (abfd));
2649
2650       if (relsize > 0)
2651         {
2652           aux.dynrelbuf = (arelent **) xmalloc (relsize);
2653           aux.dynrelcount = bfd_canonicalize_dynamic_reloc (abfd,
2654                                                             aux.dynrelbuf,
2655                                                             dynsyms);
2656           if (aux.dynrelcount < 0)
2657             bfd_fatal (bfd_get_filename (abfd));
2658
2659           /* Sort the relocs by address.  */
2660           qsort (aux.dynrelbuf, aux.dynrelcount, sizeof (arelent *),
2661                  compare_relocs);
2662         }
2663     }
2664   disasm_info.symtab = sorted_syms;
2665   disasm_info.symtab_size = sorted_symcount;
2666
2667   bfd_map_over_sections (abfd, disassemble_section, & disasm_info);
2668
2669   if (aux.dynrelbuf != NULL)
2670     free (aux.dynrelbuf);
2671   free (sorted_syms);
2672 }
2673 \f
2674 static bfd_boolean
2675 load_specific_debug_section (enum dwarf_section_display_enum debug,
2676                              asection *sec, void *file)
2677 {
2678   struct dwarf_section *section = &debug_displays [debug].section;
2679   bfd *abfd = (bfd *) file;
2680   bfd_byte *contents;
2681   bfd_size_type amt;
2682
2683   if (section->start != NULL)
2684     {
2685       /* If it is already loaded, do nothing.  */
2686       if (streq (section->filename, bfd_get_filename (abfd)))
2687         return TRUE;
2688       free (section->start);
2689     }
2690
2691   section->filename = bfd_get_filename (abfd);
2692   section->reloc_info = NULL;
2693   section->num_relocs = 0;
2694   section->address = bfd_get_section_vma (abfd, sec);
2695   section->user_data = sec;
2696   section->size = bfd_get_section_size (sec);
2697   amt = section->size + 1;
2698   if (amt == 0 || amt > bfd_get_file_size (abfd))
2699     {
2700       section->start = NULL;
2701       free_debug_section (debug);
2702       printf (_("\nSection '%s' has an invalid size: %#llx.\n"),
2703               sanitize_string (section->name),
2704               (unsigned long long) section->size);
2705       return FALSE;
2706     }
2707   section->start = contents = malloc (amt);
2708   if (section->start == NULL
2709       || !bfd_get_full_section_contents (abfd, sec, &contents))
2710     {
2711       free_debug_section (debug);
2712       printf (_("\nCan't get contents for section '%s'.\n"),
2713               sanitize_string (section->name));
2714       return FALSE;
2715     }
2716   /* Ensure any string section has a terminating NUL.  */
2717   section->start[section->size] = 0;
2718
2719   if (is_relocatable && debug_displays [debug].relocate)
2720     {
2721       long         reloc_size;
2722       bfd_boolean  ret;
2723
2724       bfd_cache_section_contents (sec, section->start);
2725
2726       ret = bfd_simple_get_relocated_section_contents (abfd,
2727                                                        sec,
2728                                                        section->start,
2729                                                        syms) != NULL;
2730
2731       if (! ret)
2732         {
2733           free_debug_section (debug);
2734           printf (_("\nCan't get contents for section '%s'.\n"),
2735                   sanitize_string (section->name));
2736           return FALSE;
2737         }
2738
2739       reloc_size = bfd_get_reloc_upper_bound (abfd, sec);
2740       if (reloc_size > 0)
2741         {
2742           unsigned long reloc_count;
2743           arelent **relocs;
2744
2745           relocs = (arelent **) xmalloc (reloc_size);
2746
2747           reloc_count = bfd_canonicalize_reloc (abfd, sec, relocs, NULL);
2748           if (reloc_count == 0)
2749             free (relocs);
2750           else
2751             {
2752               section->reloc_info = relocs;
2753               section->num_relocs = reloc_count;
2754             }
2755         }
2756     }
2757
2758   return TRUE;
2759 }
2760
2761 bfd_boolean
2762 reloc_at (struct dwarf_section * dsec, dwarf_vma offset)
2763 {
2764   arelent ** relocs;
2765   arelent * rp;
2766
2767   if (dsec == NULL || dsec->reloc_info == NULL)
2768     return FALSE;
2769
2770   relocs = (arelent **) dsec->reloc_info;
2771
2772   for (; (rp = * relocs) != NULL; ++ relocs)
2773     if (rp->address == offset)
2774       return TRUE;
2775
2776   return FALSE;
2777 }
2778
2779 bfd_boolean
2780 load_debug_section (enum dwarf_section_display_enum debug, void *file)
2781 {
2782   struct dwarf_section *section = &debug_displays [debug].section;
2783   bfd *abfd = (bfd *) file;
2784   asection *sec;
2785
2786   /* If it is already loaded, do nothing.  */
2787   if (section->start != NULL)
2788     {
2789       if (streq (section->filename, bfd_get_filename (abfd)))
2790         return TRUE;
2791     }
2792
2793   /* Locate the debug section.  */
2794   sec = bfd_get_section_by_name (abfd, section->uncompressed_name);
2795   if (sec != NULL)
2796     section->name = section->uncompressed_name;
2797   else
2798     {
2799       sec = bfd_get_section_by_name (abfd, section->compressed_name);
2800       if (sec != NULL)
2801         section->name = section->compressed_name;
2802     }
2803   if (sec == NULL)
2804     return FALSE;
2805
2806   return load_specific_debug_section (debug, sec, file);
2807 }
2808
2809 void
2810 free_debug_section (enum dwarf_section_display_enum debug)
2811 {
2812   struct dwarf_section *section = &debug_displays [debug].section;
2813
2814   if (section->start == NULL)
2815     return;
2816
2817   /* PR 17512: file: 0f67f69d.  */
2818   if (section->user_data != NULL)
2819     {
2820       asection * sec = (asection *) section->user_data;
2821
2822       /* If we are freeing contents that are also pointed to by the BFD
2823          library's section structure then make sure to update those pointers
2824          too.  Otherwise, the next time we try to load data for this section
2825          we can end up using a stale pointer.  */
2826       if (section->start == sec->contents)
2827         {
2828           sec->contents = NULL;
2829           sec->flags &= ~ SEC_IN_MEMORY;
2830           sec->compress_status = COMPRESS_SECTION_NONE;
2831         }
2832     }
2833
2834   free ((char *) section->start);
2835   section->start = NULL;
2836   section->address = 0;
2837   section->size = 0;
2838 }
2839
2840 void
2841 close_debug_file (void * file)
2842 {
2843   bfd * abfd = (bfd *) file;
2844
2845   bfd_close (abfd);
2846 }
2847
2848 void *
2849 open_debug_file (const char * pathname)
2850 {
2851   bfd * data;
2852
2853   data = bfd_openr (pathname, NULL);
2854   if (data == NULL)
2855     return NULL;
2856
2857   if (! bfd_check_format (data, bfd_object))
2858     return NULL;
2859
2860   return data;
2861 }
2862
2863 static void
2864 dump_dwarf_section (bfd *abfd, asection *section,
2865                     void *arg ATTRIBUTE_UNUSED)
2866 {
2867   const char *name = bfd_get_section_name (abfd, section);
2868   const char *match;
2869   int i;
2870
2871   if (CONST_STRNEQ (name, ".gnu.linkonce.wi."))
2872     match = ".debug_info";
2873   else
2874     match = name;
2875
2876   for (i = 0; i < max; i++)
2877     if ((strcmp (debug_displays [i].section.uncompressed_name, match) == 0
2878          || strcmp (debug_displays [i].section.compressed_name, match) == 0)
2879         && debug_displays [i].enabled != NULL
2880         && *debug_displays [i].enabled)
2881       {
2882         struct dwarf_section *sec = &debug_displays [i].section;
2883
2884         if (strcmp (sec->uncompressed_name, match) == 0)
2885           sec->name = sec->uncompressed_name;
2886         else
2887           sec->name = sec->compressed_name;
2888         if (load_specific_debug_section ((enum dwarf_section_display_enum) i,
2889                                          section, abfd))
2890           {
2891             debug_displays [i].display (sec, abfd);
2892
2893             if (i != info && i != abbrev)
2894               free_debug_section ((enum dwarf_section_display_enum) i);
2895           }
2896         break;
2897       }
2898 }
2899
2900 /* Dump the dwarf debugging information.  */
2901
2902 static void
2903 dump_dwarf (bfd *abfd)
2904 {
2905   /* The byte_get pointer should have been set at the start of dump_bfd().  */
2906   if (byte_get == NULL)
2907     {
2908       warn (_("File %s does not contain any dwarf debug information\n"),
2909             bfd_get_filename (abfd));
2910       return;
2911     }
2912
2913   is_relocatable = (abfd->flags & (EXEC_P | DYNAMIC)) == 0;
2914
2915   eh_addr_size = bfd_arch_bits_per_address (abfd) / 8;
2916
2917   switch (bfd_get_arch (abfd))
2918     {
2919     case bfd_arch_i386:
2920       switch (bfd_get_mach (abfd))
2921         {
2922         case bfd_mach_x86_64:
2923         case bfd_mach_x86_64_intel_syntax:
2924         case bfd_mach_x86_64_nacl:
2925         case bfd_mach_x64_32:
2926         case bfd_mach_x64_32_intel_syntax:
2927         case bfd_mach_x64_32_nacl:
2928           init_dwarf_regnames_x86_64 ();
2929           break;
2930
2931         default:
2932           init_dwarf_regnames_i386 ();
2933           break;
2934         }
2935       break;
2936
2937     case bfd_arch_iamcu:
2938       init_dwarf_regnames_iamcu ();
2939       break;
2940
2941     case bfd_arch_aarch64:
2942       init_dwarf_regnames_aarch64();
2943       break;
2944
2945     case bfd_arch_s390:
2946       init_dwarf_regnames_s390 ();
2947       break;
2948
2949     case bfd_arch_riscv:
2950       init_dwarf_regnames_riscv ();
2951       break;
2952
2953     case bfd_arch_s12z:
2954       /* S12Z has a 24 bit address space.  But the only known
2955          producer of dwarf_info encodes addresses into 32 bits.  */
2956       eh_addr_size = 4;
2957       break;
2958
2959     default:
2960       break;
2961     }
2962
2963   bfd_map_over_sections (abfd, dump_dwarf_section, NULL);
2964 }
2965 \f
2966 /* Read ABFD's stabs section STABSECT_NAME, and return a pointer to
2967    it.  Return NULL on failure.   */
2968
2969 static bfd_byte *
2970 read_section_stabs (bfd *abfd, const char *sect_name, bfd_size_type *size_ptr)
2971 {
2972   asection *stabsect;
2973   bfd_byte *contents;
2974
2975   stabsect = bfd_get_section_by_name (abfd, sect_name);
2976   if (stabsect == NULL)
2977     {
2978       printf (_("No %s section present\n\n"),
2979               sanitize_string (sect_name));
2980       return FALSE;
2981     }
2982
2983   if (!bfd_malloc_and_get_section (abfd, stabsect, &contents))
2984     {
2985       non_fatal (_("reading %s section of %s failed: %s"),
2986                  sect_name, bfd_get_filename (abfd),
2987                  bfd_errmsg (bfd_get_error ()));
2988       exit_status = 1;
2989       free (contents);
2990       return NULL;
2991     }
2992
2993   *size_ptr = bfd_section_size (abfd, stabsect);
2994
2995   return contents;
2996 }
2997
2998 /* Stabs entries use a 12 byte format:
2999      4 byte string table index
3000      1 byte stab type
3001      1 byte stab other field
3002      2 byte stab desc field
3003      4 byte stab value
3004    FIXME: This will have to change for a 64 bit object format.  */
3005
3006 #define STRDXOFF  (0)
3007 #define TYPEOFF   (4)
3008 #define OTHEROFF  (5)
3009 #define DESCOFF   (6)
3010 #define VALOFF    (8)
3011 #define STABSIZE (12)
3012
3013 /* Print ABFD's stabs section STABSECT_NAME (in `stabs'),
3014    using string table section STRSECT_NAME (in `strtab').  */
3015
3016 static void
3017 print_section_stabs (bfd *abfd,
3018                      const char *stabsect_name,
3019                      unsigned *string_offset_ptr)
3020 {
3021   int i;
3022   unsigned file_string_table_offset = 0;
3023   unsigned next_file_string_table_offset = *string_offset_ptr;
3024   bfd_byte *stabp, *stabs_end;
3025
3026   stabp = stabs;
3027   stabs_end = stabp + stab_size;
3028
3029   printf (_("Contents of %s section:\n\n"), sanitize_string (stabsect_name));
3030   printf ("Symnum n_type n_othr n_desc n_value  n_strx String\n");
3031
3032   /* Loop through all symbols and print them.
3033
3034      We start the index at -1 because there is a dummy symbol on
3035      the front of stabs-in-{coff,elf} sections that supplies sizes.  */
3036   for (i = -1; stabp <= stabs_end - STABSIZE; stabp += STABSIZE, i++)
3037     {
3038       const char *name;
3039       unsigned long strx;
3040       unsigned char type, other;
3041       unsigned short desc;
3042       bfd_vma value;
3043
3044       strx = bfd_h_get_32 (abfd, stabp + STRDXOFF);
3045       type = bfd_h_get_8 (abfd, stabp + TYPEOFF);
3046       other = bfd_h_get_8 (abfd, stabp + OTHEROFF);
3047       desc = bfd_h_get_16 (abfd, stabp + DESCOFF);
3048       value = bfd_h_get_32 (abfd, stabp + VALOFF);
3049
3050       printf ("\n%-6d ", i);
3051       /* Either print the stab name, or, if unnamed, print its number
3052          again (makes consistent formatting for tools like awk).  */
3053       name = bfd_get_stab_name (type);
3054       if (name != NULL)
3055         printf ("%-6s", sanitize_string (name));
3056       else if (type == N_UNDF)
3057         printf ("HdrSym");
3058       else
3059         printf ("%-6d", type);
3060       printf (" %-6d %-6d ", other, desc);
3061       bfd_printf_vma (abfd, value);
3062       printf (" %-6lu", strx);
3063
3064       /* Symbols with type == 0 (N_UNDF) specify the length of the
3065          string table associated with this file.  We use that info
3066          to know how to relocate the *next* file's string table indices.  */
3067       if (type == N_UNDF)
3068         {
3069           file_string_table_offset = next_file_string_table_offset;
3070           next_file_string_table_offset += value;
3071         }
3072       else
3073         {
3074           bfd_size_type amt = strx + file_string_table_offset;
3075
3076           /* Using the (possibly updated) string table offset, print the
3077              string (if any) associated with this symbol.  */
3078           if (amt < stabstr_size)
3079             /* PR 17512: file: 079-79389-0.001:0.1.
3080                FIXME: May need to sanitize this string before displaying.  */
3081             printf (" %.*s", (int)(stabstr_size - amt), strtab + amt);
3082           else
3083             printf (" *");
3084         }
3085     }
3086   printf ("\n\n");
3087   *string_offset_ptr = next_file_string_table_offset;
3088 }
3089
3090 typedef struct
3091 {
3092   const char * section_name;
3093   const char * string_section_name;
3094   unsigned string_offset;
3095 }
3096 stab_section_names;
3097
3098 static void
3099 find_stabs_section (bfd *abfd, asection *section, void *names)
3100 {
3101   int len;
3102   stab_section_names * sought = (stab_section_names *) names;
3103
3104   /* Check for section names for which stabsect_name is a prefix, to
3105      handle .stab.N, etc.  */
3106   len = strlen (sought->section_name);
3107
3108   /* If the prefix matches, and the files section name ends with a
3109      nul or a digit, then we match.  I.e., we want either an exact
3110      match or a section followed by a number.  */
3111   if (strncmp (sought->section_name, section->name, len) == 0
3112       && (section->name[len] == 0
3113           || (section->name[len] == '.' && ISDIGIT (section->name[len + 1]))))
3114     {
3115       if (strtab == NULL)
3116         strtab = read_section_stabs (abfd, sought->string_section_name,
3117                                      &stabstr_size);
3118
3119       if (strtab)
3120         {
3121           stabs = read_section_stabs (abfd, section->name, &stab_size);
3122           if (stabs)
3123             print_section_stabs (abfd, section->name, &sought->string_offset);
3124         }
3125     }
3126 }
3127
3128 static void
3129 dump_stabs_section (bfd *abfd, char *stabsect_name, char *strsect_name)
3130 {
3131   stab_section_names s;
3132
3133   s.section_name = stabsect_name;
3134   s.string_section_name = strsect_name;
3135   s.string_offset = 0;
3136
3137   bfd_map_over_sections (abfd, find_stabs_section, & s);
3138
3139   free (strtab);
3140   strtab = NULL;
3141 }
3142
3143 /* Dump the any sections containing stabs debugging information.  */
3144
3145 static void
3146 dump_stabs (bfd *abfd)
3147 {
3148   dump_stabs_section (abfd, ".stab", ".stabstr");
3149   dump_stabs_section (abfd, ".stab.excl", ".stab.exclstr");
3150   dump_stabs_section (abfd, ".stab.index", ".stab.indexstr");
3151
3152   /* For Darwin.  */
3153   dump_stabs_section (abfd, "LC_SYMTAB.stabs", "LC_SYMTAB.stabstr");
3154
3155   dump_stabs_section (abfd, "$GDB_SYMBOLS$", "$GDB_STRINGS$");
3156 }
3157 \f
3158 static void
3159 dump_bfd_header (bfd *abfd)
3160 {
3161   char *comma = "";
3162
3163   printf (_("architecture: %s, "),
3164           bfd_printable_arch_mach (bfd_get_arch (abfd),
3165                                    bfd_get_mach (abfd)));
3166   printf (_("flags 0x%08x:\n"), abfd->flags & ~BFD_FLAGS_FOR_BFD_USE_MASK);
3167
3168 #define PF(x, y)    if (abfd->flags & x) {printf("%s%s", comma, y); comma=", ";}
3169   PF (HAS_RELOC, "HAS_RELOC");
3170   PF (EXEC_P, "EXEC_P");
3171   PF (HAS_LINENO, "HAS_LINENO");
3172   PF (HAS_DEBUG, "HAS_DEBUG");
3173   PF (HAS_SYMS, "HAS_SYMS");
3174   PF (HAS_LOCALS, "HAS_LOCALS");
3175   PF (DYNAMIC, "DYNAMIC");
3176   PF (WP_TEXT, "WP_TEXT");
3177   PF (D_PAGED, "D_PAGED");
3178   PF (BFD_IS_RELAXABLE, "BFD_IS_RELAXABLE");
3179   printf (_("\nstart address 0x"));
3180   bfd_printf_vma (abfd, abfd->start_address);
3181   printf ("\n");
3182 }
3183
3184 \f
3185 static void
3186 dump_bfd_private_header (bfd *abfd)
3187 {
3188   if (!bfd_print_private_bfd_data (abfd, stdout))
3189     non_fatal (_("warning: private headers incomplete: %s"),
3190                bfd_errmsg (bfd_get_error ()));
3191 }
3192
3193 static void
3194 dump_target_specific (bfd *abfd)
3195 {
3196   const struct objdump_private_desc * const *desc;
3197   struct objdump_private_option *opt;
3198   char *e, *b;
3199
3200   /* Find the desc.  */
3201   for (desc = objdump_private_vectors; *desc != NULL; desc++)
3202     if ((*desc)->filter (abfd))
3203       break;
3204
3205   if (*desc == NULL)
3206     {
3207       non_fatal (_("option -P/--private not supported by this file"));
3208       return;
3209     }
3210
3211   /* Clear all options.  */
3212   for (opt = (*desc)->options; opt->name; opt++)
3213     opt->selected = FALSE;
3214
3215   /* Decode options.  */
3216   b = dump_private_options;
3217   do
3218     {
3219       e = strchr (b, ',');
3220
3221       if (e)
3222         *e = 0;
3223
3224       for (opt = (*desc)->options; opt->name; opt++)
3225         if (strcmp (opt->name, b) == 0)
3226           {
3227             opt->selected = TRUE;
3228             break;
3229           }
3230       if (opt->name == NULL)
3231         non_fatal (_("target specific dump '%s' not supported"), b);
3232
3233       if (e)
3234         {
3235           *e = ',';
3236           b = e + 1;
3237         }
3238     }
3239   while (e != NULL);
3240
3241   /* Dump.  */
3242   (*desc)->dump (abfd);
3243 }
3244 \f
3245 /* Display a section in hexadecimal format with associated characters.
3246    Each line prefixed by the zero padded address.  */
3247
3248 static void
3249 dump_section (bfd *abfd, asection *section, void *dummy ATTRIBUTE_UNUSED)
3250 {
3251   bfd_byte *data = NULL;
3252   bfd_size_type datasize;
3253   bfd_vma addr_offset;
3254   bfd_vma start_offset;
3255   bfd_vma stop_offset;
3256   unsigned int opb = bfd_octets_per_byte (abfd);
3257   /* Bytes per line.  */
3258   const int onaline = 16;
3259   char buf[64];
3260   int count;
3261   int width;
3262
3263   if ((section->flags & SEC_HAS_CONTENTS) == 0)
3264     return;
3265
3266   if (! process_section_p (section))
3267     return;
3268
3269   if ((datasize = bfd_section_size (abfd, section)) == 0)
3270     return;
3271
3272   /* Compute the address range to display.  */
3273   if (start_address == (bfd_vma) -1
3274       || start_address < section->vma)
3275     start_offset = 0;
3276   else
3277     start_offset = start_address - section->vma;
3278
3279   if (stop_address == (bfd_vma) -1)
3280     stop_offset = datasize / opb;
3281   else
3282     {
3283       if (stop_address < section->vma)
3284         stop_offset = 0;
3285       else
3286         stop_offset = stop_address - section->vma;
3287
3288       if (stop_offset > datasize / opb)
3289         stop_offset = datasize / opb;
3290     }
3291
3292   if (start_offset >= stop_offset)
3293     return;
3294
3295   printf (_("Contents of section %s:"), sanitize_string (section->name));
3296   if (display_file_offsets)
3297     printf (_("  (Starting at file offset: 0x%lx)"),
3298             (unsigned long) (section->filepos + start_offset));
3299   printf ("\n");
3300
3301   if (!bfd_get_full_section_contents (abfd, section, &data))
3302     {
3303       non_fatal (_("Reading section %s failed because: %s"),
3304                  section->name, bfd_errmsg (bfd_get_error ()));
3305       return;
3306     }
3307
3308   width = 4;
3309
3310   bfd_sprintf_vma (abfd, buf, start_offset + section->vma);
3311   if (strlen (buf) >= sizeof (buf))
3312     abort ();
3313
3314   count = 0;
3315   while (buf[count] == '0' && buf[count+1] != '\0')
3316     count++;
3317   count = strlen (buf) - count;
3318   if (count > width)
3319     width = count;
3320
3321   bfd_sprintf_vma (abfd, buf, stop_offset + section->vma - 1);
3322   if (strlen (buf) >= sizeof (buf))
3323     abort ();
3324
3325   count = 0;
3326   while (buf[count] == '0' && buf[count+1] != '\0')
3327     count++;
3328   count = strlen (buf) - count;
3329   if (count > width)
3330     width = count;
3331
3332   for (addr_offset = start_offset;
3333        addr_offset < stop_offset; addr_offset += onaline / opb)
3334     {
3335       bfd_size_type j;
3336
3337       bfd_sprintf_vma (abfd, buf, (addr_offset + section->vma));
3338       count = strlen (buf);
3339       if ((size_t) count >= sizeof (buf))
3340         abort ();
3341
3342       putchar (' ');
3343       while (count < width)
3344         {
3345           putchar ('0');
3346           count++;
3347         }
3348       fputs (buf + count - width, stdout);
3349       putchar (' ');
3350
3351       for (j = addr_offset * opb;
3352            j < addr_offset * opb + onaline; j++)
3353         {
3354           if (j < stop_offset * opb)
3355             printf ("%02x", (unsigned) (data[j]));
3356           else
3357             printf ("  ");
3358           if ((j & 3) == 3)
3359             printf (" ");
3360         }
3361
3362       printf (" ");
3363       for (j = addr_offset * opb;
3364            j < addr_offset * opb + onaline; j++)
3365         {
3366           if (j >= stop_offset * opb)
3367             printf (" ");
3368           else
3369             printf ("%c", ISPRINT (data[j]) ? data[j] : '.');
3370         }
3371       putchar ('\n');
3372     }
3373   free (data);
3374 }
3375
3376 /* Actually display the various requested regions.  */
3377
3378 static void
3379 dump_data (bfd *abfd)
3380 {
3381   bfd_map_over_sections (abfd, dump_section, NULL);
3382 }
3383
3384 /* Should perhaps share code and display with nm?  */
3385
3386 static void
3387 dump_symbols (bfd *abfd ATTRIBUTE_UNUSED, bfd_boolean dynamic)
3388 {
3389   asymbol **current;
3390   long max_count;
3391   long count;
3392
3393   if (dynamic)
3394     {
3395       current = dynsyms;
3396       max_count = dynsymcount;
3397       printf ("DYNAMIC SYMBOL TABLE:\n");
3398     }
3399   else
3400     {
3401       current = syms;
3402       max_count = symcount;
3403       printf ("SYMBOL TABLE:\n");
3404     }
3405
3406   if (max_count == 0)
3407     printf (_("no symbols\n"));
3408
3409   for (count = 0; count < max_count; count++)
3410     {
3411       bfd *cur_bfd;
3412
3413       if (*current == NULL)
3414         printf (_("no information for symbol number %ld\n"), count);
3415
3416       else if ((cur_bfd = bfd_asymbol_bfd (*current)) == NULL)
3417         printf (_("could not determine the type of symbol number %ld\n"),
3418                 count);
3419
3420       else if (process_section_p ((* current)->section)
3421                && (dump_special_syms
3422                    || !bfd_is_target_special_symbol (cur_bfd, *current)))
3423         {
3424           const char *name = (*current)->name;
3425
3426           if (do_demangle && name != NULL && *name != '\0')
3427             {
3428               char *alloc;
3429
3430               /* If we want to demangle the name, we demangle it
3431                  here, and temporarily clobber it while calling
3432                  bfd_print_symbol.  FIXME: This is a gross hack.  */
3433               alloc = bfd_demangle (cur_bfd, name, demangle_flags);
3434               if (alloc != NULL)
3435                 (*current)->name = alloc;
3436               bfd_print_symbol (cur_bfd, stdout, *current,
3437                                 bfd_print_symbol_all);
3438               if (alloc != NULL)
3439                 {
3440                   (*current)->name = name;
3441                   free (alloc);
3442                 }
3443             }
3444           else
3445             bfd_print_symbol (cur_bfd, stdout, *current,
3446                               bfd_print_symbol_all);
3447           printf ("\n");
3448         }
3449
3450       current++;
3451     }
3452   printf ("\n\n");
3453 }
3454 \f
3455 static void
3456 dump_reloc_set (bfd *abfd, asection *sec, arelent **relpp, long relcount)
3457 {
3458   arelent **p;
3459   char *last_filename, *last_functionname;
3460   unsigned int last_line;
3461   unsigned int last_discriminator;
3462
3463   /* Get column headers lined up reasonably.  */
3464   {
3465     static int width;
3466
3467     if (width == 0)
3468       {
3469         char buf[30];
3470
3471         bfd_sprintf_vma (abfd, buf, (bfd_vma) -1);
3472         width = strlen (buf) - 7;
3473       }
3474     printf ("OFFSET %*s TYPE %*s VALUE \n", width, "", 12, "");
3475   }
3476
3477   last_filename = NULL;
3478   last_functionname = NULL;
3479   last_line = 0;
3480   last_discriminator = 0;
3481
3482   for (p = relpp; relcount && *p != NULL; p++, relcount--)
3483     {
3484       arelent *q = *p;
3485       const char *filename, *functionname;
3486       unsigned int linenumber;
3487       unsigned int discriminator;
3488       const char *sym_name;
3489       const char *section_name;
3490       bfd_vma addend2 = 0;
3491
3492       if (start_address != (bfd_vma) -1
3493           && q->address < start_address)
3494         continue;
3495       if (stop_address != (bfd_vma) -1
3496           && q->address > stop_address)
3497         continue;
3498
3499       if (with_line_numbers
3500           && sec != NULL
3501           && bfd_find_nearest_line_discriminator (abfd, sec, syms, q->address,
3502                                                   &filename, &functionname,
3503                                                   &linenumber, &discriminator))
3504         {
3505           if (functionname != NULL
3506               && (last_functionname == NULL
3507                   || strcmp (functionname, last_functionname) != 0))
3508             {
3509               printf ("%s():\n", sanitize_string (functionname));
3510               if (last_functionname != NULL)
3511                 free (last_functionname);
3512               last_functionname = xstrdup (functionname);
3513             }
3514
3515           if (linenumber > 0
3516               && (linenumber != last_line
3517                   || (filename != NULL
3518                       && last_filename != NULL
3519                       && filename_cmp (filename, last_filename) != 0)
3520                   || (discriminator != last_discriminator)))
3521             {
3522               if (discriminator > 0)
3523                 printf ("%s:%u\n", filename == NULL ? "???" :
3524                         sanitize_string (filename), linenumber);
3525               else
3526                 printf ("%s:%u (discriminator %u)\n",
3527                         filename == NULL ? "???" : sanitize_string (filename),
3528                         linenumber, discriminator);
3529               last_line = linenumber;
3530               last_discriminator = discriminator;
3531               if (last_filename != NULL)
3532                 free (last_filename);
3533               if (filename == NULL)
3534                 last_filename = NULL;
3535               else
3536                 last_filename = xstrdup (filename);
3537             }
3538         }
3539
3540       if (q->sym_ptr_ptr && *q->sym_ptr_ptr)
3541         {
3542           sym_name = (*(q->sym_ptr_ptr))->name;
3543           section_name = (*(q->sym_ptr_ptr))->section->name;
3544         }
3545       else
3546         {
3547           sym_name = NULL;
3548           section_name = NULL;
3549         }
3550
3551       bfd_printf_vma (abfd, q->address);
3552       if (q->howto == NULL)
3553         printf (" *unknown*         ");
3554       else if (q->howto->name)
3555         {
3556           const char *name = q->howto->name;
3557
3558           /* R_SPARC_OLO10 relocations contain two addends.
3559              But because 'arelent' lacks enough storage to
3560              store them both, the 64-bit ELF Sparc backend
3561              records this as two relocations.  One R_SPARC_LO10
3562              and one R_SPARC_13, both pointing to the same
3563              address.  This is merely so that we have some
3564              place to store both addend fields.
3565
3566              Undo this transformation, otherwise the output
3567              will be confusing.  */
3568           if (abfd->xvec->flavour == bfd_target_elf_flavour
3569               && elf_tdata(abfd)->elf_header->e_machine == EM_SPARCV9
3570               && relcount > 1
3571               && !strcmp (q->howto->name, "R_SPARC_LO10"))
3572             {
3573               arelent *q2 = *(p + 1);
3574               if (q2 != NULL
3575                   && q2->howto
3576                   && q->address == q2->address
3577                   && !strcmp (q2->howto->name, "R_SPARC_13"))
3578                 {
3579                   name = "R_SPARC_OLO10";
3580                   addend2 = q2->addend;
3581                   p++;
3582                 }
3583             }
3584           printf (" %-16s  ", name);
3585         }
3586       else
3587         printf (" %-16d  ", q->howto->type);
3588
3589       if (sym_name)
3590         {
3591           objdump_print_symname (abfd, NULL, *q->sym_ptr_ptr);
3592         }
3593       else
3594         {
3595           if (section_name == NULL)
3596             section_name = "*unknown*";
3597           printf ("[%s]", sanitize_string (section_name));
3598         }
3599
3600       if (q->addend)
3601         {
3602           bfd_signed_vma addend = q->addend;
3603           if (addend < 0)
3604             {
3605               printf ("-0x");
3606               addend = -addend;
3607             }
3608           else
3609             printf ("+0x");
3610           bfd_printf_vma (abfd, addend);
3611         }
3612       if (addend2)
3613         {
3614           printf ("+0x");
3615           bfd_printf_vma (abfd, addend2);
3616         }
3617
3618       printf ("\n");
3619     }
3620
3621   if (last_filename != NULL)
3622     free (last_filename);
3623   if (last_functionname != NULL)
3624     free (last_functionname);
3625 }
3626
3627 static void
3628 dump_relocs_in_section (bfd *abfd,
3629                         asection *section,
3630                         void *dummy ATTRIBUTE_UNUSED)
3631 {
3632   arelent **relpp;
3633   long relcount;
3634   long relsize;
3635
3636   if (   bfd_is_abs_section (section)
3637       || bfd_is_und_section (section)
3638       || bfd_is_com_section (section)
3639       || (! process_section_p (section))
3640       || ((section->flags & SEC_RELOC) == 0))
3641     return;
3642
3643   relsize = bfd_get_reloc_upper_bound (abfd, section);
3644   if (relsize < 0)
3645     bfd_fatal (bfd_get_filename (abfd));
3646
3647   printf ("RELOCATION RECORDS FOR [%s]:", sanitize_string (section->name));
3648
3649   if (relsize == 0)
3650     {
3651       printf (" (none)\n\n");
3652       return;
3653     }
3654
3655   if ((bfd_get_file_flags (abfd) & (BFD_IN_MEMORY | BFD_LINKER_CREATED)) == 0
3656       && (/* Check that the size of the relocs is reasonable.  Note that some
3657              file formats, eg aout, can have relocs whose internal size is
3658              larger than their external size, thus we check the size divided
3659              by four against the file size.  See PR 23931 for an example of
3660              this.  */
3661           ((ufile_ptr) (relsize / 4) > bfd_get_file_size (abfd))
3662           /* Also check the section's reloc count since if this is negative
3663              (or very large) the computation in bfd_get_reloc_upper_bound
3664              may have resulted in returning a small, positive integer.
3665              See PR 22508 for a reproducer.
3666
3667              Note - we check against file size rather than section size as
3668              it is possible for there to be more relocs that apply to a
3669              section than there are bytes in that section.  */
3670           || (section->reloc_count > bfd_get_file_size (abfd))))
3671     {
3672       printf (" (too many: %#x relocs)\n", section->reloc_count);
3673       bfd_set_error (bfd_error_file_truncated);
3674       bfd_fatal (bfd_get_filename (abfd));
3675     }
3676
3677   relpp = (arelent **) xmalloc (relsize);
3678   relcount = bfd_canonicalize_reloc (abfd, section, relpp, syms);
3679
3680   if (relcount < 0)
3681     {
3682       printf ("\n");
3683       non_fatal (_("failed to read relocs in: %s"), sanitize_string (bfd_get_filename (abfd)));
3684       bfd_fatal (_("error message was"));
3685     }
3686   else if (relcount == 0)
3687     printf (" (none)\n\n");
3688   else
3689     {
3690       printf ("\n");
3691       dump_reloc_set (abfd, section, relpp, relcount);
3692       printf ("\n\n");
3693     }
3694   free (relpp);
3695 }
3696
3697 static void
3698 dump_relocs (bfd *abfd)
3699 {
3700   bfd_map_over_sections (abfd, dump_relocs_in_section, NULL);
3701 }
3702
3703 static void
3704 dump_dynamic_relocs (bfd *abfd)
3705 {
3706   long relsize;
3707   arelent **relpp;
3708   long relcount;
3709
3710   relsize = bfd_get_dynamic_reloc_upper_bound (abfd);
3711   if (relsize < 0)
3712     bfd_fatal (bfd_get_filename (abfd));
3713
3714   printf ("DYNAMIC RELOCATION RECORDS");
3715
3716   if (relsize == 0)
3717     printf (" (none)\n\n");
3718   else
3719     {
3720       relpp = (arelent **) xmalloc (relsize);
3721       relcount = bfd_canonicalize_dynamic_reloc (abfd, relpp, dynsyms);
3722
3723       if (relcount < 0)
3724         bfd_fatal (bfd_get_filename (abfd));
3725       else if (relcount == 0)
3726         printf (" (none)\n\n");
3727       else
3728         {
3729           printf ("\n");
3730           dump_reloc_set (abfd, NULL, relpp, relcount);
3731           printf ("\n\n");
3732         }
3733       free (relpp);
3734     }
3735 }
3736
3737 /* Creates a table of paths, to search for source files.  */
3738
3739 static void
3740 add_include_path (const char *path)
3741 {
3742   if (path[0] == 0)
3743     return;
3744   include_path_count++;
3745   include_paths = (const char **)
3746       xrealloc (include_paths, include_path_count * sizeof (*include_paths));
3747 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
3748   if (path[1] == ':' && path[2] == 0)
3749     path = concat (path, ".", (const char *) 0);
3750 #endif
3751   include_paths[include_path_count - 1] = path;
3752 }
3753
3754 static void
3755 adjust_addresses (bfd *abfd ATTRIBUTE_UNUSED,
3756                   asection *section,
3757                   void *arg)
3758 {
3759   if ((section->flags & SEC_DEBUGGING) == 0)
3760     {
3761       bfd_boolean *has_reloc_p = (bfd_boolean *) arg;
3762       section->vma += adjust_section_vma;
3763       if (*has_reloc_p)
3764         section->lma += adjust_section_vma;
3765     }
3766 }
3767
3768 /* Dump selected contents of ABFD.  */
3769
3770 static void
3771 dump_bfd (bfd *abfd, bfd_boolean is_mainfile)
3772 {
3773   if (bfd_big_endian (abfd))
3774     byte_get = byte_get_big_endian;
3775   else if (bfd_little_endian (abfd))
3776     byte_get = byte_get_little_endian;
3777   else
3778     byte_get = NULL;
3779
3780   /* Load any separate debug information files.
3781      We do this now and without checking do_follow_links because separate
3782      debug info files may contain symbol tables that we will need when
3783      displaying information about the main file.  Any memory allocated by
3784      load_separate_debug_files will be released when we call
3785      free_debug_memory below.
3786
3787      The test on is_mainfile is there because the chain of separate debug
3788      info files is a global variable shared by all invocations of dump_bfd.  */
3789   if (is_mainfile)
3790     {
3791       load_separate_debug_files (abfd, bfd_get_filename (abfd));
3792
3793       /* If asked to do so, recursively dump the separate files.  */
3794       if (do_follow_links)
3795         {
3796           separate_info * i;
3797
3798           for (i = first_separate_info; i != NULL; i = i->next)
3799             dump_bfd (i->handle, FALSE);
3800         }
3801     }
3802
3803   /* If we are adjusting section VMA's, change them all now.  Changing
3804      the BFD information is a hack.  However, we must do it, or
3805      bfd_find_nearest_line will not do the right thing.  */
3806   if (adjust_section_vma != 0)
3807     {
3808       bfd_boolean has_reloc = (abfd->flags & HAS_RELOC);
3809       bfd_map_over_sections (abfd, adjust_addresses, &has_reloc);
3810     }
3811
3812   if (! dump_debugging_tags && ! suppress_bfd_header)
3813     printf (_("\n%s:     file format %s\n"),
3814             sanitize_string (bfd_get_filename (abfd)),
3815             abfd->xvec->name);
3816   if (dump_ar_hdrs)
3817     print_arelt_descr (stdout, abfd, TRUE, FALSE);
3818   if (dump_file_header)
3819     dump_bfd_header (abfd);
3820   if (dump_private_headers)
3821     dump_bfd_private_header (abfd);
3822   if (dump_private_options != NULL)
3823     dump_target_specific (abfd);
3824   if (! dump_debugging_tags && ! suppress_bfd_header)
3825     putchar ('\n');
3826
3827   if (dump_symtab
3828       || dump_reloc_info
3829       || disassemble
3830       || dump_debugging
3831       || dump_dwarf_section_info)
3832     {
3833       syms = slurp_symtab (abfd);
3834
3835       /* If following links, load any symbol tables from the linked files as well.  */
3836       if (do_follow_links && is_mainfile)
3837         {
3838           separate_info * i;
3839
3840           for (i = first_separate_info; i != NULL; i = i->next)
3841             {
3842               asymbol **  extra_syms;
3843               long        old_symcount = symcount;
3844
3845               extra_syms = slurp_symtab (i->handle);
3846
3847               if (extra_syms)
3848                 {
3849                   if (old_symcount == 0)
3850                     {
3851                       syms = extra_syms;
3852                     }
3853                   else
3854                     {
3855                       syms = xrealloc (syms, (symcount + old_symcount) * sizeof (asymbol *));
3856                       memcpy (syms + old_symcount,
3857                               extra_syms,
3858                               symcount * sizeof (asymbol *));
3859                     }
3860                 }
3861
3862               symcount += old_symcount;
3863             }
3864         }
3865     }
3866
3867   if (dump_section_headers)
3868     dump_headers (abfd);
3869
3870   if (dump_dynamic_symtab || dump_dynamic_reloc_info
3871       || (disassemble && bfd_get_dynamic_symtab_upper_bound (abfd) > 0))
3872     dynsyms = slurp_dynamic_symtab (abfd);
3873
3874   if (disassemble)
3875     {
3876       synthcount = bfd_get_synthetic_symtab (abfd, symcount, syms,
3877                                              dynsymcount, dynsyms, &synthsyms);
3878       if (synthcount < 0)
3879         synthcount = 0;
3880     }
3881
3882   if (dump_symtab)
3883     dump_symbols (abfd, FALSE);
3884   if (dump_dynamic_symtab)
3885     dump_symbols (abfd, TRUE);
3886   if (dump_dwarf_section_info)
3887     dump_dwarf (abfd);
3888   if (dump_stab_section_info)
3889     dump_stabs (abfd);
3890   if (dump_reloc_info && ! disassemble)
3891     dump_relocs (abfd);
3892   if (dump_dynamic_reloc_info && ! disassemble)
3893     dump_dynamic_relocs (abfd);
3894   if (dump_section_contents)
3895     dump_data (abfd);
3896   if (disassemble)
3897     disassemble_data (abfd);
3898
3899   if (dump_debugging)
3900     {
3901       void *dhandle;
3902
3903       dhandle = read_debugging_info (abfd, syms, symcount, TRUE);
3904       if (dhandle != NULL)
3905         {
3906           if (!print_debugging_info (stdout, dhandle, abfd, syms,
3907                                      bfd_demangle,
3908                                      dump_debugging_tags ? TRUE : FALSE))
3909             {
3910               non_fatal (_("%s: printing debugging information failed"),
3911                          bfd_get_filename (abfd));
3912               exit_status = 1;
3913             }
3914
3915           free (dhandle);
3916         }
3917       /* PR 6483: If there was no STABS debug info in the file, try
3918          DWARF instead.  */
3919       else if (! dump_dwarf_section_info)
3920         {
3921           dwarf_select_sections_all ();
3922           dump_dwarf (abfd);
3923         }
3924     }
3925
3926   if (syms)
3927     {
3928       free (syms);
3929       syms = NULL;
3930     }
3931
3932   if (dynsyms)
3933     {
3934       free (dynsyms);
3935       dynsyms = NULL;
3936     }
3937
3938   if (synthsyms)
3939     {
3940       free (synthsyms);
3941       synthsyms = NULL;
3942     }
3943
3944   symcount = 0;
3945   dynsymcount = 0;
3946   synthcount = 0;
3947
3948   if (is_mainfile)
3949     free_debug_memory ();
3950 }
3951
3952 static void
3953 display_object_bfd (bfd *abfd)
3954 {
3955   char **matching;
3956
3957   if (bfd_check_format_matches (abfd, bfd_object, &matching))
3958     {
3959       dump_bfd (abfd, TRUE);
3960       return;
3961     }
3962
3963   if (bfd_get_error () == bfd_error_file_ambiguously_recognized)
3964     {
3965       nonfatal (bfd_get_filename (abfd));
3966       list_matching_formats (matching);
3967       free (matching);
3968       return;
3969     }
3970
3971   if (bfd_get_error () != bfd_error_file_not_recognized)
3972     {
3973       nonfatal (bfd_get_filename (abfd));
3974       return;
3975     }
3976
3977   if (bfd_check_format_matches (abfd, bfd_core, &matching))
3978     {
3979       dump_bfd (abfd, TRUE);
3980       return;
3981     }
3982
3983   nonfatal (bfd_get_filename (abfd));
3984
3985   if (bfd_get_error () == bfd_error_file_ambiguously_recognized)
3986     {
3987       list_matching_formats (matching);
3988       free (matching);
3989     }
3990 }
3991
3992 static void
3993 display_any_bfd (bfd *file, int level)
3994 {
3995   /* Decompress sections unless dumping the section contents.  */
3996   if (!dump_section_contents)
3997     file->flags |= BFD_DECOMPRESS;
3998
3999   /* If the file is an archive, process all of its elements.  */
4000   if (bfd_check_format (file, bfd_archive))
4001     {
4002       bfd *arfile = NULL;
4003       bfd *last_arfile = NULL;
4004
4005       if (level == 0)
4006         printf (_("In archive %s:\n"), sanitize_string (bfd_get_filename (file)));
4007       else if (level > 100)
4008         {
4009           /* Prevent corrupted files from spinning us into an
4010              infinite loop.  100 is an arbitrary heuristic.  */
4011           fatal (_("Archive nesting is too deep"));
4012           return;
4013         }
4014       else
4015         printf (_("In nested archive %s:\n"),
4016                 sanitize_string (bfd_get_filename (file)));
4017
4018       for (;;)
4019         {
4020           bfd_set_error (bfd_error_no_error);
4021
4022           arfile = bfd_openr_next_archived_file (file, arfile);
4023           if (arfile == NULL)
4024             {
4025               if (bfd_get_error () != bfd_error_no_more_archived_files)
4026                 nonfatal (bfd_get_filename (file));
4027               break;
4028             }
4029
4030           display_any_bfd (arfile, level + 1);
4031
4032           if (last_arfile != NULL)
4033             {
4034               bfd_close (last_arfile);
4035               /* PR 17512: file: ac585d01.  */
4036               if (arfile == last_arfile)
4037                 {
4038                   last_arfile = NULL;
4039                   break;
4040                 }
4041             }
4042           last_arfile = arfile;
4043         }
4044
4045       if (last_arfile != NULL)
4046         bfd_close (last_arfile);
4047     }
4048   else
4049     display_object_bfd (file);
4050 }
4051
4052 static void
4053 display_file (char *filename, char *target, bfd_boolean last_file)
4054 {
4055   bfd *file;
4056
4057   if (get_file_size (filename) < 1)
4058     {
4059       exit_status = 1;
4060       return;
4061     }
4062
4063   file = bfd_openr (filename, target);
4064   if (file == NULL)
4065     {
4066       nonfatal (filename);
4067       return;
4068     }
4069
4070   display_any_bfd (file, 0);
4071
4072   /* This is an optimization to improve the speed of objdump, especially when
4073      dumping a file with lots of associated debug informatiom.  Calling
4074      bfd_close on such a file can take a non-trivial amount of time as there
4075      are lots of lists to walk and buffers to free.  This is only really
4076      necessary however if we are about to load another file and we need the
4077      memory back.  Otherwise, if we are about to exit, then we can save (a lot
4078      of) time by only doing a quick close, and allowing the OS to reclaim the
4079      memory for us.  */
4080   if (! last_file)
4081     bfd_close (file);
4082   else
4083     bfd_close_all_done (file);
4084 }
4085 \f
4086 int
4087 main (int argc, char **argv)
4088 {
4089   int c;
4090   char *target = default_target;
4091   bfd_boolean seenflag = FALSE;
4092
4093 #if defined (HAVE_SETLOCALE)
4094 #if defined (HAVE_LC_MESSAGES)
4095   setlocale (LC_MESSAGES, "");
4096 #endif
4097   setlocale (LC_CTYPE, "");
4098 #endif
4099
4100   bindtextdomain (PACKAGE, LOCALEDIR);
4101   textdomain (PACKAGE);
4102
4103   program_name = *argv;
4104   xmalloc_set_program_name (program_name);
4105   bfd_set_error_program_name (program_name);
4106
4107   START_PROGRESS (program_name, 0);
4108
4109   expandargv (&argc, &argv);
4110
4111   if (bfd_init () != BFD_INIT_MAGIC)
4112     fatal (_("fatal error: libbfd ABI mismatch"));
4113   set_default_bfd_target ();
4114
4115   while ((c = getopt_long (argc, argv,
4116                            "pP:ib:m:M:VvCdDlfFaHhrRtTxsSI:j:wE:zgeGW::",
4117                            long_options, (int *) 0))
4118          != EOF)
4119     {
4120       switch (c)
4121         {
4122         case 0:
4123           break;                /* We've been given a long option.  */
4124         case 'm':
4125           machine = optarg;
4126           break;
4127         case 'M':
4128           {
4129             char *options;
4130             if (disassembler_options)
4131               /* Ignore potential memory leak for now.  */
4132               options = concat (disassembler_options, ",",
4133                                 optarg, (const char *) NULL);
4134             else
4135               options = optarg;
4136             disassembler_options = remove_whitespace_and_extra_commas (options);
4137           }
4138           break;
4139         case 'j':
4140           add_only (optarg);
4141           break;
4142         case 'F':
4143           display_file_offsets = TRUE;
4144           break;
4145         case 'l':
4146           with_line_numbers = TRUE;
4147           break;
4148         case 'b':
4149           target = optarg;
4150           break;
4151         case 'C':
4152           do_demangle = TRUE;
4153           if (optarg != NULL)
4154             {
4155               enum demangling_styles style;
4156
4157               style = cplus_demangle_name_to_style (optarg);
4158               if (style == unknown_demangling)
4159                 fatal (_("unknown demangling style `%s'"),
4160                        optarg);
4161
4162               cplus_demangle_set_style (style);
4163             }
4164           break;
4165         case OPTION_RECURSE_LIMIT:
4166           demangle_flags &= ~ DMGL_NO_RECURSE_LIMIT;
4167           break;
4168         case OPTION_NO_RECURSE_LIMIT:
4169           demangle_flags |= DMGL_NO_RECURSE_LIMIT;
4170           break;
4171         case 'w':
4172           do_wide = wide_output = TRUE;
4173           break;
4174         case OPTION_ADJUST_VMA:
4175           adjust_section_vma = parse_vma (optarg, "--adjust-vma");
4176           break;
4177         case OPTION_START_ADDRESS:
4178           start_address = parse_vma (optarg, "--start-address");
4179           if ((stop_address != (bfd_vma) -1) && stop_address <= start_address)
4180             fatal (_("error: the start address should be before the end address"));
4181           break;
4182         case OPTION_STOP_ADDRESS:
4183           stop_address = parse_vma (optarg, "--stop-address");
4184           if ((start_address != (bfd_vma) -1) && stop_address <= start_address)
4185             fatal (_("error: the stop address should be after the start address"));
4186           break;
4187         case OPTION_PREFIX:
4188           prefix = optarg;
4189           prefix_length = strlen (prefix);
4190           /* Remove an unnecessary trailing '/' */
4191           while (IS_DIR_SEPARATOR (prefix[prefix_length - 1]))
4192             prefix_length--;
4193           break;
4194         case OPTION_PREFIX_STRIP:
4195           prefix_strip = atoi (optarg);
4196           if (prefix_strip < 0)
4197             fatal (_("error: prefix strip must be non-negative"));
4198           break;
4199         case OPTION_INSN_WIDTH:
4200           insn_width = strtoul (optarg, NULL, 0);
4201           if (insn_width <= 0)
4202             fatal (_("error: instruction width must be positive"));
4203           break;
4204         case OPTION_INLINES:
4205           unwind_inlines = TRUE;
4206           break;
4207         case 'E':
4208           if (strcmp (optarg, "B") == 0)
4209             endian = BFD_ENDIAN_BIG;
4210           else if (strcmp (optarg, "L") == 0)
4211             endian = BFD_ENDIAN_LITTLE;
4212           else
4213             {
4214               nonfatal (_("unrecognized -E option"));
4215               usage (stderr, 1);
4216             }
4217           break;
4218         case OPTION_ENDIAN:
4219           if (strncmp (optarg, "big", strlen (optarg)) == 0)
4220             endian = BFD_ENDIAN_BIG;
4221           else if (strncmp (optarg, "little", strlen (optarg)) == 0)
4222             endian = BFD_ENDIAN_LITTLE;
4223           else
4224             {
4225               non_fatal (_("unrecognized --endian type `%s'"), optarg);
4226               exit_status = 1;
4227               usage (stderr, 1);
4228             }
4229           break;
4230
4231         case 'f':
4232           dump_file_header = TRUE;
4233           seenflag = TRUE;
4234           break;
4235         case 'i':
4236           formats_info = TRUE;
4237           seenflag = TRUE;
4238           break;
4239         case 'I':
4240           add_include_path (optarg);
4241           break;
4242         case 'p':
4243           dump_private_headers = TRUE;
4244           seenflag = TRUE;
4245           break;
4246         case 'P':
4247           dump_private_options = optarg;
4248           seenflag = TRUE;
4249           break;
4250         case 'x':
4251           dump_private_headers = TRUE;
4252           dump_symtab = TRUE;
4253           dump_reloc_info = TRUE;
4254           dump_file_header = TRUE;
4255           dump_ar_hdrs = TRUE;
4256           dump_section_headers = TRUE;
4257           seenflag = TRUE;
4258           break;
4259         case 't':
4260           dump_symtab = TRUE;
4261           seenflag = TRUE;
4262           break;
4263         case 'T':
4264           dump_dynamic_symtab = TRUE;
4265           seenflag = TRUE;
4266           break;
4267         case 'd':
4268           disassemble = TRUE;
4269           seenflag = TRUE;
4270           disasm_sym = optarg;
4271           break;
4272         case 'z':
4273           disassemble_zeroes = TRUE;
4274           break;
4275         case 'D':
4276           disassemble = TRUE;
4277           disassemble_all = TRUE;
4278           seenflag = TRUE;
4279           break;
4280         case 'S':
4281           disassemble = TRUE;
4282           with_source_code = TRUE;
4283           seenflag = TRUE;
4284           break;
4285         case 'g':
4286           dump_debugging = 1;
4287           seenflag = TRUE;
4288           break;
4289         case 'e':
4290           dump_debugging = 1;
4291           dump_debugging_tags = 1;
4292           do_demangle = TRUE;
4293           seenflag = TRUE;
4294           break;
4295         case 'W':
4296           dump_dwarf_section_info = TRUE;
4297           seenflag = TRUE;
4298           if (optarg)
4299             dwarf_select_sections_by_letters (optarg);
4300           else
4301             dwarf_select_sections_all ();
4302           break;
4303         case OPTION_DWARF:
4304           dump_dwarf_section_info = TRUE;
4305           seenflag = TRUE;
4306           if (optarg)
4307             dwarf_select_sections_by_names (optarg);
4308           else
4309             dwarf_select_sections_all ();
4310           break;
4311         case OPTION_DWARF_DEPTH:
4312           {
4313             char *cp;
4314             dwarf_cutoff_level = strtoul (optarg, & cp, 0);
4315           }
4316           break;
4317         case OPTION_DWARF_START:
4318           {
4319             char *cp;
4320             dwarf_start_die = strtoul (optarg, & cp, 0);
4321             suppress_bfd_header = 1;
4322           }
4323           break;
4324         case OPTION_DWARF_CHECK:
4325           dwarf_check = TRUE;
4326           break;
4327         case 'G':
4328           dump_stab_section_info = TRUE;
4329           seenflag = TRUE;
4330           break;
4331         case 's':
4332           dump_section_contents = TRUE;
4333           seenflag = TRUE;
4334           break;
4335         case 'r':
4336           dump_reloc_info = TRUE;
4337           seenflag = TRUE;
4338           break;
4339         case 'R':
4340           dump_dynamic_reloc_info = TRUE;
4341           seenflag = TRUE;
4342           break;
4343         case 'a':
4344           dump_ar_hdrs = TRUE;
4345           seenflag = TRUE;
4346           break;
4347         case 'h':
4348           dump_section_headers = TRUE;
4349           seenflag = TRUE;
4350           break;
4351         case 'v':
4352         case 'V':
4353           show_version = TRUE;
4354           seenflag = TRUE;
4355           break;
4356
4357         case 'H':
4358           usage (stdout, 0);
4359           /* No need to set seenflag or to break - usage() does not return.  */
4360         default:
4361           usage (stderr, 1);
4362         }
4363     }
4364
4365   if (show_version)
4366     print_version ("objdump");
4367
4368   if (!seenflag)
4369     usage (stderr, 2);
4370
4371   if (formats_info)
4372     exit_status = display_info ();
4373   else
4374     {
4375       if (optind == argc)
4376         display_file ("a.out", target, TRUE);
4377       else
4378         for (; optind < argc;)
4379           {
4380             display_file (argv[optind], target, optind == argc - 1);
4381             optind++;
4382           }
4383     }
4384
4385   free_only_list ();
4386
4387   END_PROGRESS (program_name);
4388
4389   return exit_status;
4390 }